Facilidades para o Jekyll

Esse blog é feito utilizando Jekyll, um gerador de sites estáticos. Isso significa que no momento do deploy desse blog, o HTML de todas a páginas são geradas e salvas no servidor. Quando um usário acessa alguma página do blog, basta que o servidor entregue, para o usuário, a página já montada. Isso faz com que a página seja entregue mais rápida e eu consigo gastar menos quando comparado com quando temos uma renderização dinamica, tipo Ruby on Rails, NodeJS e outros frameworks.

Para escrever as publicações desse blog, eu utilizo a formatação Markdown e uso o VS Code como editor de texto, mas você pode utilizar qualquer editor Markdown e até mesmo um gerador de HTML e depois colocar o arquivo com a publicação dentro do projeto.

Porém tem algumas coisas que se repetem dentro do Jekyll e eu resolvi automatizar algumas coisas para facilitar minha vida. Primeiro, eu comecei criando uma pasta chamada bin na raiz do projeto.

blog
  _drafts
  _includes
  _posts
  assets
  bin

Dentro dessa pasta bin irei colocar todos os scripts que sempre uso. Vou apresentar 3 scripts, o primeiro bem simples, que uso para acelerar meu desenvolvimento.

Script 0: executando projeto

Para executar qualquer projeto Jekyll basta rodar o comando abaixo na raiz do projeto. Isso executa o Jekyll na porta 4000 do seu computador e para acessá-lo basta entrar em localhost:4000.

# Iniciando servidor do Jekyll
bundle exec jekyll serve

Caso você deseje que sejam mostradas as publicações em rascunho (draft) no servidor de desenvolvimento, basta adicionar a flag --drafts.

# Iniciando servidor do Jekyll com rascunhos
bundle exec jekyll serve --drafts

Como eu sou preguiçoso e esquecido, várias vezes eu executo o comando e esqueço de adicionar a flag de rascunhos, daí preciso parar o processo e iniciá-lo novamente. Isso me chateia, não gosto. Por isso, fiz um script com tudo que preciso e basta apenas executar esse script e ele vai colocar tudo que preciso. Para isso, primeiro criei o arquivo ./bin/serve. O conteúdo do arquivo é mostrado abaixo:

/path/para/binario/bundler exec jekyll serve --drafts

No meu caso, o meu arquivo ficou assim:

/Users/rochwhocodes/.rvm/rubies/ruby-2.7.7/bin/bundler exec jekyll serve --drafts

Depois disso, é necessário tornar esse arquivo executável, então execute o comando abaixo

chmod +x ./bin/serve

Depois disso, seu script está pronto para uso e para isso basta executar o comando abaixo. Agora nunca mais você esquecerá o comando ou alguma flag. Se precisar de alguma outra flag, basta adicionar no arquivo e salvar.

./bin/serve

Obviamente esse script é bem simples e no decorrer dessa publicação eu irei mostrar scripts mais complexos. O principal intuito desse script foi para eu nunca mais esquecer a flag e poupar meu precioso tempo (😅), porque eu sou realmente esquecido.

Script 1: Criando um rascunho (draft)

Uma outra atividade comum no Jekyll é criar um arquivo na pasta _drafts para uma publicação ainda em rascunho e que não deseja publicá-la agora. No meu processo de escrita, toda publicação começa no rascunho e segue um padrão de nome, por exemplo:

2023-06-20-nome-da-publicacao.md

O padrão é data, seguido do título da publicação hifenizado. Sabendo disso, criei um script que recebe como argumento o título da publicação e tem como saída a criação de um arquivo Markdown com o frontmatter preenchido.

Para criação desse script, utilizei a linguagem de programação Ruby, primeiro criei o arquivo ./bin/draft.

Obs: Eu levo proveito de um conceito chamado shebang. Com isso, não preciso colocar a extensão no nome do arquivo, isso faz o arquivo parecer mais com um script. Se você não conhece o que é shebang, você pode pesquisar sobre isso,mas em resumo:

Ele vai ser responsável por informar para o computador que aquele arquivo é um script em ruby e vai informar também onde está o binário do Ruby que deverá ser utilizado para executar o script. Você pode usar o shebang não apenas com Ruby, mas com outras linguagens de programação, por exemplo com Python. Veja mais sobre isso aqui.

O script completo você pode ver abaixo:

#!/usr/bin/env ruby
require 'date'

filename = ARGV.join('-').downcase

path = %x( pwd ).split("\n")[0]

date = Date.today
date_formatted = date.strftime('%Y-%m-%d')

file = File.new "#{path}/_drafts/#{date}-#{filename}.md", "a"
file.write <<~TEXT
---
layout: post
title: #{ARGV.join(' ')}
subheading: #{ARGV.join(' ')}
description: #{ARGV.join(' ')}
author: Rock
categories:
tags:
date: #{date} 08\:00\:00 -0300
---
TEXT

file.close

Caso queira entender alguma parte do script escrito em Ruby, irei explicar aqui:

  1. Primeiro começo importando date, pois vou precisar da data do dia de hoje para colocar no nome do arquivo
  2. Depois faço um join no vetor de argumentos, utilizando o hífen como caractére para junção, então se o nome passado no argumento for Como fazer tal coisa o resultado será como-fazer-tal-coisa.
  3. Depois descubro o diretório corrente, para saber onde vou salvar o arquivo.
  4. Crio um arquivo com o padrão desejado data-nome.md
  5. Por fim, adiciono o frontmatter da publicacão

Para utilizar o script, primeiro devemos torná-lo executável chmod +x ./bin/draft e depois executar o comando abaixo:

./bin/draft Nome da publicação

Um exemplo real: usei essa automação para criar essa publicação. Então no terminal digitei o seguinte comando:

./bin/draft Facilidades para o uso do Jekyll

Melhore esse script

Normalmente uma postagem de blog possui uma categoria ou uma tag. Fica aqui uma sugestão para você, melhore esse script adicionando uma flag que represente a categoria ou a tag da publicação em questão e adicionei o valor dessa flag no frontmatter. Exemplo:

./bin/draft Facilidades para o uso do Jekyll --category Jekyll

E o frontmatter do arquivo deve ser:

---
layout: post
title: Facilidades para o uso do Jekyll
subheading: Facilidades para o uso do Jekyll
description: Facilidades para o uso do Jekyll
author: Rock
categories: jekyll
tags:
date: 2023-06-20 08\:00\:00 -0300
---

Se você quiser ver o script melhorado, clique aqui

Script 2: Fazendo o commit

Por fim, o último script é para commitar uma nova publicação no GitHub e posteriormente fazer o deploy. Esse script pode ser utilizado em outros cenário e não é especificamente criado para o Jekyll.

Primeiro preciso explicar meu cenário. Para fazer as publicações nesse blog, as vezes eu utilizo o computador da empresa que trabalho e nesse computador a conta do GitHub que está conectada é uma com o meu email corporativo e o meu blog está em uma conta do GitHub com meu email pessoal. Em resumo: preciso ter duas contas de GitHub configuradas.

Então o script que vou apresentar aqui é uma forma de ter múltiplas contas GitHub em um mesmo computador. Não é única e nem a melhor forma de fazer.

Sei que existem outras formas de fazer isso, mas queria uma forma de fazer que quando eu fosse usar minha conta pessoal, eu precisaria pensar ativamente e isso evitaria erros de sem querer commitar com email pessoal na conta da empresa ou vice-versa.

Para isso utilizei o Docker e docker volumes para atingir meu objetivo.

Configurei minha conta pessoal dentro de um container Docker e usei um volume para não perder essas informações. Não vou mostrar como é configurar uma conta no GitHub, pois o processo é bem simples, quem sabe no futuro eu explico melhor. Mas o que eu fiz foi configurar as chaves do meu GitHub pessoal dentro de um conteiner Docker e então sempre que eu preciso commitar com minha conta pessoal, eu entro no conteiner Docker e faço isso por lá.

O script para fazer isso é mostrado abaixo:

docker run --rm -it --name git \
-v git_volume:/root \
-v /Users/rockwhocodes/Self/:/home \
bitnami/git /bin/bash

O comando abaixo vai executar um conteiner Docker e entrar nele. As credenciais já foram configuradas e estão no volume associado ao container. Dessa forma eu sempre preciso entrar no container para commitar e isso diminui as chances de eu cometer algum equivoco.

Obs: não esqueça de tornar esse arquivo um executável.

./bin/git

Por hoje é só, até breve!