Vamos falar sobre dependências de projeto?

Atuando como QA a quase dois anos percebi que muitos QA's não estão totalmente ligados a conhecimentos técnicos em programação com isso sempre vejo alguns erros sendo cometidos por algumas coisas básicas. Tendo em mente isso resolvi compartilhar um pouco sobre dependências de projetos em Ruby.

Vou tratar sobre o uso de Gemfile nos projetos que vocês estão atuando ou irão criar futuramente.

O Gemfile é um arquivo que descreve as dependências de gems do seu projeto, para fazer uma comparação podemos usar o Maven que utiliza o formato de XML para adição de dependências de projeto no arquivo POM.

O Gemfile deve sempre estar na raiz do seu projeto para que o Bundler ou outro gerenciador de pacotes possa encontrar ele.

Até aqui tudo bem, mas para que usar o gemfile?

Da mesma forma que você está criando um projeto ele precisa de versões mínimas para funcionar certo? então você precisa de um gemfile para setar essas versões necessárias. Novamente então?

NÃO!!

De que adianta você ter um Gemfile todo bonito com as versões das gems travadas se cada pessoa que for rodar esse projeto precisar verificar na mão se tem tudo o que é preciso para ter o ambiente completo? É ai que entrar o uso do Bundler para garantir que todo mundo SEMPRE vai estar alinhado com as versões que estão sendo usadas no projeto.

O Bundler é muito fácil e simples de ser usado, precisamos apenas usar o comando básico no mundo Ruby :P

gem install bundler

Após ter feito isso já podemos tirar proveito dessa maravilhosa gem :P

o primeiro passo é rodar o seguinte comando na raiz do seu projeto que ainda não usa gemfile :(

bundle init

Isso ai fazer com que o bundle escreva um novo arquivo pra gente o tão esperado gemfile. Se abrirmos esse novo arquivo gerado podemos ver o seguinte código:

# frozen_string_literal: true
source “https://rubygems.org"
# gem “rails"

Obs: É recomendável ter apenas um source por projeto

Até aqui tudo tranquilo, temos o esqueleto padrão do nosso Gemfile, mas ainda precisamos setar nossas dependências do projeto, para fazer isso temos uma sintaxe padrão com diversas opcões.

Podemos simplemente setar uma gem especifica como por exemplo:

# frozen_string_literal: true
source “https://rubygems.org"
gem 'rake'

Como também podemos especificar uma versão especifica ou dizer que você espera uma versão dentro de um range:

# frozen_string_literal: true
source “https://rubygems.org"
gem ‘rake’, '12.0.0'
gem 'nokogiri', '>1.0'

Legal, mas o que significa isso? O gemfile aceita que você fale pra ele quais versões poderão ser usadas, abaixo algumas formas de dizer isso para ele:

= A versão precisa ser igual a especificada no gemfile '=1.0.0'
!= A versão não pode ser igual a especificada no gemfile '!=1.0.0'
> A versão precisa ser maior que a especificada no gemfile '>1.0.0'
< A versão precisa ser menor que a especificada no gemfile '<1.0.0'
>= A versão precisa ser maior ou igual a especificada no gemfile '>=1.0.0'
<= A versão precisa ser menor ou igual a especificada no gemfile '<=1.0.0'
~> Ela pode ser qualquer uma dentro do range, como por exemplo '~>1.0', aqui nós falamos que a aplicação está suportando qualquer versão desde que seja dentro de 1.x.

Podemos também dizer que temos suporte para certo range de versões, como por exemplo:

# frozen_string_literal: true
source “https://rubygems.org"
gem ‘rake’, ‘ >=10.0.0’, '< 11.5.0'

Toda essa explicação é maneira, mas e como usamos isso no dia a dia?
Precisamos instalar essas dependências que foram setadas, então vamos precisar do comando:

bundle install

Esse cara vai bater no arquivo Gemfile olhar para as versões e gems que estão lá dentro e verificar se já temos instaladas, caso não tenha ele se encarrega de instalar a gem e a versão que foi travada. Após fazer isso vocês devem reparar que ele criou um novo arquivo chamado Gemfile.lock, mas o que esse arquivo está fazendo ai? Esse arquivo contém na integra todas as dependências das gems que você está usando e também é o cara mandatório na hora de trabalhar com as dependências. Por que?

Na hora que você for executar alguma coisa, pode ser uma task Rake ou até mesmo algum teste unitário, provavelmente você irá tomar algum erro de conflito de versões :O , mas porque isso?
Provavelmente você não deve ter as versões necessárias para realizar tal tarefa! E como fazemos?

bundle exec

Esse cara vai garantir que sempre que for executado alguma coisa será utilizando as versões que você deixou mapeado no seu Gemfile.

Legal então já conseguimos garantir o funcionamento do projeto com as versões esperadas, mas e quando eu precisar mudar alguma versão de gem?
É simples!

bundle update sua gem

Ou se não tiver problema em subir todas as versões de acordo com seu Gemfile

bundle update

Esse segundo vai subir todas as gems que não estiverem travadas para a última versão disponível, usem com parcimônia esse cara :P

Além disso é possível também obter gems através do fonte, criar grupos como , teste, produção, desenvolvimento…isso vai de acordo com sua necessidade. Mas isso pode ser tratado num outro post de configuração mais avançada.

Para quem quiser saber mais :

Bundler: The best way to manage a Ruby application's gems