O trabalho no client-side é cercado por tarefas pequenas e frequentes. Por causa dessas tarefas frequentes, surgiram ferramentas fantásticas como Grunt, Gulp e vários outros.
Mas se voltarmos um pouco no tempo, vamos encontrar um cara chamado MAKE. Quem já instalou algum programa em alguma distribuição unix-like sabe bem do quem estou falando.
Esse era o processo básico pra instalar o programa.
$ ./configure $ make $ make install
Mas junto com isso, você precisava resolver uma série de problemas de dependências, caminhos de arquivos, permissões, versão e em último caso, ligava ou chamava quele amigo que manjava muito de Linux e implorava por ajuda.
Muitos podem ver esses problemas como algo ruim, mas observando melhor, isso faz com que você entenda para onde os arquivos estão indo e que para um programa funcionar, ele depende de outros programas e outras bibliotecas, que podem ter uma permissão especial para serem usados.
Tá mas que diabos é o Make e qual a relação dele com o Grunt ou Glup?
Make
Basicamente o MAKE é um atomatizador de tarefas em ambientes unix que foi e é muito usado para compilar programas.
No processo básico de instalação que falei acima o que acontecia era o seguinte:
$ ./configureera um script que depois de executado com sucesso criava o arquivoMakefileMakefileé o arquivo que dizia ao make quais eram as tarefas a serem realizadas para compilar o programa, essas tarefas eram feitas numa ordem topologica respeitando as dependências dos arquivos.$ make installesse comando chamava uma tarefa que estava definida no makefile e que tinha como objetivo fazer a instalação do programa compilado anteriormente.
Veja mais sobre ordenação topologica aqui
O Make é nativo das plataformas Linux, mas caso não tenha basta instalar o pacote build-essential
$ apt-get install build-essential
Antes de brincarmos com o Make, seria bom criar uma pasta em qualquer lugar de sua preferência, e dentro dela vamos criar nosso arquivo Makefile. Neste arquivo vamos colocar esse conteúdo (respeitando as tabulações):
string = "Finalizando..." all: task_all task_all: dep1 dep2 dep3 @echo $(string) @echo "Pronto !!" dep1: @echo "Dependencia 1 " dep2: @echo "Dependencia 2 " dep3: @echo "Dependencia 3 " @echo
Agora, via terminal e dentro dessa pasta, execute o make:
$ make ---------------- Dependencia 1 Dependencia 2 Dependencia 3 Finalizando... Pronto !!
Legal, né?
Se quiser mudar a ordem de execução só alterar a linha abaixo:
task_all: dep1 dep2 dep3
Para:
task_all: dep3 dep2 dep1
Execute o make e observe a saída novamente. Percebeu que a ordem mudou?!
Você também pode chamar uma tarefa especifica, assim:
$ make dep2
Vamos fazer algo útil
Agora que sabemos o básico do make, vamos pensar em como poderiamos substituir uma tarefa simples do grunt, nosso problema será esse:
- Compilar nossos arquivos stylus
- Concatenar todos os arquivos
- Minificar
# Compila, concatena e minifica todos os arquivos de estilo # Obs: verifica se você tem disponivel os executaveis globalmente, # senão terá que colocar o path deles PATH_STYL=styl/*.styl PATH_CSS=css STYLUS_CMD=stylus CONCAT_CMD=cat CONCAT_PATH=styl/header.css styl/body.css styl/footer.css > css/style.css UGLIFY_CMD=uglify UGLIFY_PATH=-s ./css/style.css -o ./css/style.min.css -c all: task_all task_all: compile concat minify clean @echo "Pronto !!" compile: $(STYLUS_CMD) $(PATH_STYL) @echo "Stylus compilado..." concat: $(CONCAT_CMD) $(CONCAT_PATH) @echo "Concatenando..." minify: $(UGLIFY_CMD) $(UGLIFY_PATH) @echo "Minificando..." clean: rm styl/*.css @echo "Limpando a bagunça..."
A saída desse cara que nós acabamos de fazer vai ser algo assim:
Vamos tentar deixar um pouco mais legal.
# Compila, concatena e minifica todos os arquivos de estilo
# Obs: verifica se você tem disponivel os executaveis globalmente,
# senão terá que colocar o path deles
CSS_FINAL = css/style.min.css
STYLUS_FILES = styl/header.styl \
styl/body.styl \
styl/footer.styl
CSS_MIN = $(STYLUS_FILES:.styl=.min.css)
all: $(CSS_FINAL)
$(CSS_FINAL): $(CSS_MIN)
cat $^ >$@
rm -f $(CSS_MIN)
%.min.css: %.styl
stylus --compress <$< >$@
clean:
rm -f $(CSS_FINAL)
Existem alguns variavéis do Make que devemos saber:
$@ – isso mostra o nome target atual:
all: blabla @echo "Ei" blabla: @echo $@ # Saída será: # blabla # Ei
$< – isso mostra o nome da primeira dependência:
all: blabla vixi @echo "A dependencia desse target é" $< blabla: vixi: # Saída será: # A dependência desse target é blabla
[$^] – isso mostra a lsita das dependências do target:
all: blabla vixi @echo "As dependências desse target são" $^ blabla: vixi: # Saída será: # As dependências desse target são blabla vixi
[$?] – Lista de todos arquivos de dependências mais recentes que a regra, a lista de arquivos é separada por espaço:
Crie 2 ou mais arquivos *.txt na pasta que irá ficar esse teste do makefile e coloquei qualquer texto dentro deles.
HEAD_CMD=head
FILES=$(shell find . -name '*.o')
show: $(FILES)
$(HEAD_CMD) $?
# Saída será:
# head file1.txt file2.txt file3.txt [...]
# ==> file1.txt file2.txt <==
# [CABECALHO_2]
[$*] – Nome do arquivo sem a extensão:
CSS_FINAL = css/style.min.css
STYLUS_FILES = styl/header.styl \
styl/body.styl \
styl/footer.styl
CSS_MIN = $(STYLUS_FILES:.styl=.min.css)
all: $(CSS_FINAL)
$(CSS_FINAL): $(CSS_MIN)
%.min.css: %.styl
@echo "Arquivo ->" $*
# Saída será:
# Arquivo -> styl/header
# Arquivo -> styl/body
# Arquivo -> styl/footer
Muita coisa legal dá pra fazer com o Make.
Dá para por exemplo você se conectar via ssh ou ftp e fazer o upload ou download de arquivos, rodar um shell script com diversas rotinas, você pode criar todo o setup da sua máquina colocando o make para instalar tudo que vc usa precisa: vim, mongodb, git, nodejs, sublime, brew, ou até mesmo configurar o deploy de sua aplicação, etc etc.
Isso só foi o ponto de partida, foi o básico do básico do básico e mais um pouco básico do que o make faz.
Vocês trocariam seu Gruntfile (ou semelhantes) por um Makefile?
(E por favor, não estou dizendo que as outras ferramentas são ruins, ou que você não deve usá-las. Quero apenas chamar a atenção para as ferramentas que já estão aqui há muito mais tempo e não conhecemos tão bem quanto pensamos.)
Referência suprema: Manual Make