Programe mais rápido automatizando comandos repetitivos

Programe mais rápido automatizando comandos repetitivos

Você também é do tipo de programador(a) que não gosta de fazer tarefas repetitivas?

Neste artigo vamos aprender a usar uma ferramenta chamada GNU make para automatizar comandos repetitivos (e longos) para tornar o nosso dia a dia de programação mais simples e produtivo 🙂

A melhor forma de aprender é através de exemplos, então vamos iniciar descobrindo como utilizar o Make na prática e depois vamos criar um conjunto de instruções úteis para quem utiliza Rails + Docker (que também pode ser adaptado para outros stacks).

O que é o GNU Make?

Resumidamente, o GNU Make é um utilitário que lê e executa instruções contidas em arquivos denominados Makefiles, ele é uma ferramenta muito poderosa e hoje vamos criar alias (atalhos) para nossos comandos que seriam rodados no terminal.

Uma das vantagens em usar o Make é que toda a equipe que estiver trabalhando no projeto vai ter acesso através do Makefile aos alias criados, o que aumenta o desempenho de todos.

Instalando o GNU Make

Geralmente o Make vem instalado por default em sistemas Linux, mas caso precise pode baixar através do link ou instalar através do gerenciador de pacotes da sua distribuição (apt, aptitude e etc).
Ex: apt install maker.

Caso esteja usando Windows pode seguir essas instruções.
Se for MAC OSX pode seguir essas instruções.

Bom, acredito que agora você já sabe o que é o Make e já deve ter ele instalado na sua máquina, então vamos colocar a mão na massa!

Aprendendo a usar o Make na prática

Para entendermos como o Make funciona, vamos criar alguns Makefiles de exemplo.

Criando sua primeira instrução

Neste exemplo, vamos criar uma instrução capaz de criar outro arquivo (através do comando touch).

1 – Primeiro, crie um arquivo chamado Makefile (dentro da pasta onde deseja realizar o teste).

2 – Coloque nele o seguinte código:

criar:
        touch 'arquivo.txt'

1 2	criar: touch 'arquivo.txt'

Obs: Use Tab na segunda linha ao invés de espaço.

3 – Agora chame a instrução no seu terminal:

make criar

1	make criar

4 – Pronto, ao lado do Makefile foi criado um arquivo chamando: arquivo.txt.

Passando parâmetros

Agora iremos criar um Makefile que aceita parâmetros na instrução, desta forma poderemos criar um novo arquivo com o nome, extensão e conteúdo desejado.

1 – Primeiro, crie um arquivo chamado Makefile (dentro da pasta onde deseja realizar o teste).

2 – Coloque nele o seguinte código:

arquivo  :=arquivo
extencao :=txt
conteudo :='Ola mundo!'

criar:
        touch   "$(arquivo).$(extencao)"
        echo "$(conteudo)" > "$(arquivo).$(extencao)"
        cat "$(arquivo).$(extencao)"

arquivo :=arquivo

extencao :=txt

conteudo :='Ola mundo!'

criar:

touch "$(arquivo).$(extencao)"

echo "$(conteudo)" > "$(arquivo).$(extencao)"

cat "$(arquivo).$(extencao)"

Obs: Nas 3 primeiras linhas criamos valores padrões para os parâmetros, com isso eles se tornam opcionais.

Obs2: Lembre-se de colocar Tabs ao invés de espaços.

3 – No terminal, chame a instrução passando os parâmetros:

  make criar
  make criar arquivo="primeiro arquivo com make"
  make criar extencao=html
  make criar conteudo="Make é uma dica legal para o dia a dia de um dev."
  make criar arquivo="outro arquivo" conteudo="O básico do make ..."

make criar

make criar arquivo="primeiro arquivo com make"

make criar extencao=html

make criar conteudo="Make é uma dica legal para o dia a dia de um dev."

make criar arquivo="outro arquivo" conteudo="O básico do make ..."

4 – Depois de rodar os comandos, você deve ver algo assim no terminal:

Rails + Docker, exemplo prático

Eu sou desenvolvedor (rubista) e uso o docker para facilitar a construção do meu ambiente de desenvolvimento, entretanto, uma coisa que me incomoda é ficar repetindo os grandes comandos do docker o tempo todo, por exemplo:

docker compose run --rm app bundle exec rails s
docker compose run --rm app bundle exec rails db:create
docker compose run --rm app bundle exec rails db:migrate
...

docker compose run --rm app bundle exec rails s

docker compose run --rm app bundle exec rails db:create

docker compose run --rm app bundle exec rails db:migrate

...

São comandos realmente grandes 😜

Então neste exemplo eu vou te mostrar como criar um Makefile para facilitar muito o uso dessas duas ferramentas (Rails e Docker) no seu dia a dia de programador.

Obs: Caso não utilize esse stack, através desse exemplo você vai conseguir ter uma boa base parar criar o seu próprio Makefile.

1 – No projeto Rails + Docker que você deseja criar os alias, crie um arquivo chamado Makefile.

2 – Coloque o seguinte conjunto de códigos no arquivo:

APP := website
RUN := docker-compose run --rm $(APP)
spec := spec
env := development

setup:
  docker-compose build
  make bundle
  make reset

bundle:
  $(RUN) bundle install

serve:
  docker-compose up

serve_debug:
  docker-compose up -d
  docker attach $(APP)

console:
  $(RUN) bundle exec rails c -e $(env)

rspec:
  $(RUN) bundle exec rspec $(spec)

create:
  $(RUN) bundle exec rake db:create

migrate:
  $(RUN) bundle exec rake db:migrate

seed:
  $(RUN) bundle exec rake db:seed

drop:
  $(RUN) bundle exec rake db:drop

reset:
  $(RUN) bundle exec rake db:drop db:create db:migrate db:seed

run:
  $(RUN) bundle exec $(c)

APP := website

RUN := docker-compose run --rm $(APP)

spec := spec

env := development

setup:

docker-compose build

make bundle

make reset

bundle:

$(RUN) bundle install

serve:

docker-compose up

serve_debug:

docker-compose up -d

docker attach $(APP)

console:

$(RUN) bundle exec rails c -e $(env)

rspec:

$(RUN) bundle exec rspec $(spec)

create:

$(RUN) bundle exec rake db:create

migrate:

$(RUN) bundle exec rake db:migrate

seed:

$(RUN) bundle exec rake db:seed

drop:

$(RUN) bundle exec rake db:drop

reset:

$(RUN) bundle exec rake db:drop db:create db:migrate db:seed

run:

$(RUN) bundle exec $(c)

Obs: Lembre-se de colocar Tabs ao invés de espaços na indentação.

Obs2: Note que dentro de uma instrução Make é possível chamar outra (reaproveitando os códigos), como na instrução setup que chamamos as instruções bundle e reset.

3 – Agora você pode usar os comandos da seguinte forma:

make setup
make serve

1 2	make setup make serve

Pronto, com esses dois comandos você consegue configurar seu projeto e subir em qualquer máquina (com docker) rapidamente 😍

Conclusão

O Makefile é uma ferramenta muito poderosa usada pelo pessoal de infraestrutura, se quiserem saber mais sobre ela podem acessar a documentação aqui.

Hoje mostrei como podemos usá-la para facilitar nosso dia a dia de programação através da automação de alguns instruções repetitivas,
Qualquer probleminha, sugestão ou dúvida, deixe um comentário aqui em baixo.

Obrigado!
Um abraço e até a próxima!

12 formas de vencer o bloqueio criativo e escrever textos memoráveis (e 6 dicas extras)

Não perca nenhum conteúdo

Receba nosso resumo semanal com os novos posts, cursos, talks e vagas o/

Primeira vez no OneBitCode? Curtiu esse conteúdo?
O OneBitCode tem muito mais para você!

O OneBitCode traz conteúdos de qualidade, e em português, sobre programação com foco em Ruby on Rails e também JavaScript.
Além disso, aqui sempre levamos à você conteúdos valiosos sobre a carreira de programação, dicas sobre currículos, portfólios, perfil profissional, soft skills, enfim, tudo o que você precisa saber para continuar evoluindo como Programador(a)!

Fique por dentro de todos os conteúdos o/

Nossas redes sociais:

📹 • https://youtube.com/Onebitcode [Live todas as terças-feiras às 19h)
💻 • https://linkedin.com/company/onebitcode
🙂 • dwts val dating
📱 • https://onebitcode.com/best-dating-places-in-houston/
🐦 • date blink social relationship single dating site usa

Nossos cursos:

🥇 • single dating men in usa
💎 • Curso Completo de Ruby
⚙ • Minicurso: API Rails 5 Completo
🐞 • Minicurso de Testes para Ruby on Rails com RSpec

Espero que curta nossos conteúdos e sempre que precisar de ajuda, fala com a gente!
Estamos aqui para você 🙂

Bem-vindo à família OneBitCode o/

5 1 vote

Article Rating

janeiro 17, 2020

Posts | Cursos

Rivelino Lazaro Fernandes Farias Junior

Sou Bacharel em Sistema de Informação e atuo como Desenvolvedor Full Stack Ruby on Rails.

Website : https://github.com/rivelinojunior

0 Comentários

Inline Feedbacks

View all comments

Programe mais rápido automatizando comandos repetitivos