Um modo facil de usar code standards no php
Tags: beginners, php, codequality, tutorial
Published: 2022-01-08 20:19:42

O php é uma linguagem maravilhosa e muito popular, ela possui padrões que ajudam a escrever códigos de fácil manutenção e legíveis, exemplos desses padrões são as [PSR's](https://www.php-fig.org/psr/) 1 e 12, que indicam **padrões de estilo de código** ou **coding standards**. 

Um modo de aplicar esses padrões é com o pacote [PHP_CodeSniffer](https://github.com/squizlabs/PHP_CodeSniffer) que, de forma simplificada, lê nosso código e analisa se segue os padrões indicados nas PSR's ou nos padrões que definimos, essa ferramenta pode ser instalada de forma global ou por projeto com o _composer_. Assim que instalado podemos utilizar o comando `phpcs caminho/para/arquivo` se instalado globalmente ou `vendor/bin/phpcs caminho/para/arquivo` quando instalado por projeto, isso irá listar que pontos do nosso código podem ser ajustados para seguir os padrões. Por mais que esse método exista ele não é prático, normalmente usamos esse pacote em conjunto com o _linter_ da nossa IDE ou editor de texto, o _phpstorm_ já vem com um _linter_ de _code standards_ embutido que precisa ser apenas configurado, o _visual studio code_ tem plugins para implementar essa função de _linter_ e outras ferramentas também tem plugins ou extensões que integram essa função. Isso pode ser aliado com outras ferramentas como [PHP-cs-fixer](https://github.com/FriendsOfPHP/PHP-CS-Fixer) que irão ajustar o código automaticamente com um comando no terminal, atalho nos editores ou quando o arquivo for salvo, as possibilidades e integrações são inúmeras.

Desde que aprendi sobre isso usei os plugins do _visual studio code_ (vscode), até ler post do blog do [Tomas Votruba](https://tomasvotruba.com/blog/2019/06/24/do-you-use-php-codesniffer-and-php-cs-fixer-phpstorm-plugin-you-are-slow-and-expensive/) onde ele dizia que olhar as sugestões de padrões de código e concertar manualmente, por mais que fosse algo rápido, quando somando todas as vezes que repetimos essa ação, consumia um tempo razoável, mesmo quando eram concertadas de forma automática por atalhos ainda consumiam um tempo que não seria necessário, então sugeriu o uso de um pacote do _composer_ chamado [easy coding standard](https://github.com/symplify/easy-coding-standard) que automatiza a correção de "erros" padrões de estilo de código. Esse pacote usa os pacotes `php_codesniffer` e o `php-cs-fixer` para executar suas ações.

O processo é simples, após instalar o pacote com o comando `composer require symplify/easy-coding-standard --dev`, você cria um arquivo chamado `ecs.php` na raiz do projeto, adicionando nele os padrões que deseja irá seguir, após isso execute o comando `vendor/bin/ecs check caminho/do/arquivo/ou/diretório` para checar os "erros" (não são erros de fato, apenas pontos a melhorar) de padrões e `vendor/bin/ecs check caminho/do/arquivo/ou/diretório --fix` para concertar os "erros".

Ao aplicar o fluxo que ele sugeriu, achei bem interessante e prático, principalmente para dev's que ainda estão aprendendo sobre essa padrões de estilo de código e ainda não entendem o uso das ferramentas. Até porque todo o processo fica resumido a um comando, mas nem tudo são flores.

Além do setup que pode ser trabalhoso a princípio, rodar um comando é mais um processo durante o desenvolvimento que pode ser facilmente esquecido quando queremos terminar algo ou apenas subir as alterações do código para o github, então pensei, como poderia automatizar a já automatizada verificação e correção de padrões de estilo de código? Após um pouco de pesquisa encontrei a resposta da minha dúvida, _git hooks_!

Hooks são ações que podem ser configuradas entre as ações do git, por exemplo, um _hook pre-commit_ vai executar algo antes da ação _git commit_ ser executada, assim podemos adicionar um hook para verificar nosso código e ajustar os padrões. Para fazer isso dentro da pasta `.git` do seu repositório adicione o arquivo um arquivo chamado `pre-commit` com o conteúdo.

```
# hook to fix style errors using ecs (easy coding standard)
# this hook is a pre-commit
# when using this script copy as pre-commit on folder .git/hook
# after copy give execution permission with "chmod +x pre-commit"

echo "start scan to find cs errors with ecs"    
     
ECS_BIN="./vendor/bin/ecs"    
HAS_ECS=false    
     
if [ -x $ECS_BIN ]; then    
 HAS_ECS=true    
fi    
     
if $HAS_ECS; then    
 echo "fix cs errors"    
 git status --porcelain | grep -e '^[AM]\(.*\).php$' | cut -c 3- | while read line; do    
   $ECS_BIN check "$line" --fix --quiet;    
   git add "$line";    
 done    
 echo "finish fixers"    
else    
 echo ""    
 echo "cannot run ecs please install in project"    
 echo ""    
 echo "   composer require symplify/easy-coding-standard --dev    "    
 echo ""    
fi 
```

Como isso feito toda vez que o comando _git commit_ for executado ajustes nos arquivos editados serão feitos. Essa é uma ótima abordagem, porém contem um problema, o arquivo `pre-commit` estará salvo apenas no repositório local e não será compartilhado com todos os outros que usam ou clonarem seu repositório. Isso pode ser contornado usando um pacote do composer chamado [composer-git-hooks](https://github.com/BrainMaestro/composer-git-hooks) que facilita do gerenciamento de _git hooks_.

Instruções da instalação do pacote estão no repositório do pacote, após a sua instalação em `extra` do arquivo `composer.json` o seguinte:

```
"hooks": { 
            "pre-commit": [
                "echo committing as $(git config user.name)",
                "git status --porcelain | grep -e '^[AM]\\(.*\\).php$' | cut -c 3- | while read line; do vendor/bin/ecs check \"$line\" --fix --quiet; git add \"$line\"; done"
            ]
        }
```

Após isso esse hook será adicionado automaticamente no repositório, mesmo quando for clonado por outro desenvolvedor(a).

Acho que é algo conveniente a ser feito, porque todos que forem interagir com o projeto, versados ou não com estilos de código, no final obedecerão o estilo de código que foi definido e se forem necessárias alterações no estilo de código do projeto elas serão feitas em um ponto central e serão refletidas para todos que trabalham no projeto.

Obrigado por ter chegado até aqui, compartilhe como você lida com padrões de estilo de código. Se quiser, deixe as dúvidas nos comentários que farei meu melhor para responder, bem como sugestões ou criticas, estou linkedin como [andresmeireles](https://www.linkedin.com/in/andresmeireles/).