Na tecnologia acelerada de hoje, reinventar a roda apenas reduz a produtividade de uma empresa e, eventualmente, suas receitas. Não queremos que isso aconteça na empresa onde trabalhamos, certo?

Muitos desenvolvedores fazem uso de código “reutilizável” copiando e colando classes de um projeto para outro. Essa prática ainda exige que você faça muitos ajustes para que funcione em seu projeto específico. Isso também deixa a biblioteca vulnerável a pequenas edições de outros desenvolvedores que, com o tempo, anulam o propósito para o qual foram projetadas.

No framework Laravel , podemos escrever bibliotecas onde podemos apenas chamar seus serviços sem nos preocuparmos com a forma como foi implementado. Podemos reutilizar essas bibliotecas e gerenciá-las separadamente do código-fonte principal do nosso projeto. Estes são chamados de pacotes Laravel .

O que são pacotes?

Os pacotes são códigos-fonte autônomos que os desenvolvedores podem importar para seus projetos usando uma ferramenta de gerenciamento de pacotes (descreverei essa ferramenta em um minuto). Em vez de copiar e colar o código-fonte da biblioteca em outro projeto, os desenvolvedores precisam apenas importar o pacote e chamar qualquer serviço fornecido por ele para ajudar no desenvolvimento do projeto.

Esses códigos-fonte podem ser versionados separadamente do código-fonte principal e podem ter seus próprios testes e gerenciar suas próprias dependências. Os desenvolvedores podem pensar em pacotes como pequenas APIs dentro do projeto. Os desenvolvedores só precisam fornecer entradas necessárias e válidas, então o pacote fará o que deveria fazer e entregará uma saída.

No nível da empresa, criar nossos próprios pacotes mantidos significa alta eficiência e produção de alta produtividade. Os pacotes serão padronizados e se uma atualização for necessária em caso de um problema de vulnerabilidade ou correção de bug, os desenvolvedores que mantêm o pacote corrigirão o problema e os desenvolvedores líderes de projeto precisarão apenas atualizar o pacote em seus próprios projetos e reimplantá-lo. Menos dores de cabeça e trabalho repetitivo para os desenvolvedores, mais receita para a empresa. Todos estão felizes e esse é o objetivo!

Por que devemos usar pacotes?

Quando temos muitos projetos, onde algumas funcionalidades ou recursos são semelhantes, seria melhor começarmos a implementar esses recursos em pacotes. Quando você tem uma equipe ou um indivíduo mantendo um pacote, digamos no GitLab , fica muito mais fácil colaborar com possíveis correções de bugs ou melhorias. Isso significa que cada pacote passará pelo mesmo processo de um projeto normal.

Outro problema que os pacotes resolvem é quando os desenvolvedores precisam modificar sua biblioteca para corrigir um bug, adicionar um novo recurso ou resolver uma vulnerabilidade. É uma tarefa difícil implementar essas melhorias em todos os projetos que usaram a biblioteca. Criar pacotes é um bom começo para evitar esses desafios.

Como gerenciamos os pacotes do Laravel?

Composer é uma ferramenta de gerenciamento de dependência para pacotes PHP . Ele nos ajuda a gerenciar nossos pacotes puxando todas as dependências que cada pacote requer sem duplicá-los em seu diretório de fornecedores. Você pode definir a versão do pacote que deseja e até configurá-lo para atualizar automaticamente para a versão mais recente sempre que executar as atualizações do pacote.

Você não precisa reinventar a roda. Imagine só, se todo mundo tem que descobrir a eletricidade, como usá-la para acender uma lâmpada até chegarmos a ecoar “Hello World”? Eu sei que é um exagero, mas bem, você entendeu. No entanto, há casos em que você gostaria de ter funcionalidades adicionais que talvez queira personalizar especificamente para a necessidade do seu próprio projeto.

Neste blog de tecnologia, mostrarei como podemos implementar nossos próprios pacotes para projetos Laravel . Usaremos o GitLab para versionar nosso pacote e importá-lo para nosso projeto usando o Composer . Para ter uma visão geral de como os pacotes do Laravel são criados, criaremos um pacote de boas- vindas simples . Se tivesse a chance, elaboraria cada etapa e provavelmente criaria um pacote mais realista e reutilizável em blogs de tecnologia subsequentes.

Criando pacotes Laravel

Pré-requisitos

Antes de começarmos a criar nosso pacote, é esperado que você já tenha o Composer e o Git instalados em seu sistema. Também é necessário que você possa criar um repositório remoto para qualquer serviço VCS como GitLab , GitHub ou Bitbucket . Para este blog de tecnologia, vamos usar o GitLab e o Laravel 5.8 .

Crie um novo projeto Laravel

O pacote que estamos criando chama-se “ greetr ” que apenas exibe uma mensagem de saudação quando chamado. Vamos usar o Composer na linha de comando para criar nosso projeto Laravel .

$ composer create-project — prefer-dist laravel/laravel greetr

Estrutura de arquivo

Na estrutura de pastas padrão de um novo projeto Laravel , crie uma estrutura de arquivo conforme mostrado abaixo para abrigar nosso desenvolvimento de pacote.

Observe que dentro da pasta packages deve estar o nome do fornecedor simplexiseguido do nome do pacote greetr. A srcpasta conterá todo o código-fonte do nosso pacote. Em alguns casos, você também pode criar uma distramificação se estiver compilando seus recursos para um servidor de produção. Dessa forma, os desenvolvedores que usarão seu pacote terão a opção de escolher entre os arquivos de origem na srcpasta ou os arquivos de distribuição na distpasta ao instalar seu pacote através do Composer .

A propósito, “simplexi” significa Simplex Internet , que é a empresa para a qual trabalho desde 2017.

Pacote composer.json

No prompt de comando, navegue até o packages/simplexi/greetrdiretório. Em seguida, precisaremos inicializar esta pasta como um pacote composer executando o seguinte comando:

$ compositor init

Este comando solicitará algumas informações sobre seu pacote. Você pode aceitar os padrões pressionando enter e edite composer.jsono arquivo que será criado posteriormente.

Após a inicialização, podemos editar o composer.jsonarquivo como seguews.

A única coisa adicionada aqui e que deve ser observada é a propriedade do objeto autoload . Isso carregará automaticamente seu pacote com o namespace fornecido Simplexi\Greetr. Você também pode incluir quaisquer dependências de pacote na requirepropriedade. Para saber mais sobre composer.jsonesquema de arquivo, clique aqui .

Observe que o composer.jsonem seu projeto é diferente do composer.jsonem seu pacote. Certifique-se de estar editando o composer.jsonarquivo correto.

Projeto composer.json

Carregue automaticamente o namespace do seu pacote adicionando a linha "Simplexi\\Greetr\\": “packages/simplexi/greetr/src"dentro da autoload->psr-4propriedade do seu composer.jsonarquivo de projeto. Com isso, suas classes de pacote dentro da src pasta serão carregadas automaticamente e disponíveis para uso do nosso projeto.

Existem outras opções para descoberta de pacotes que você pode consultar aqui . Agora, como editamos o composer.jsonarquivo do nosso projeto, devemos recarregá-lo executando o seguinte comando no diretório raiz do projeto:

$composer dump-autoload

Classe Greetr.php

Crie a classe Greetr.php dentro da pasta src da seguinte maneira.

Devemos indicar um namespace para esta classe que deve ser o mesmo namespace que você indicou no composer.jsonarquivo do projeto para que ela seja autocarregada . No nosso caso, seguindo a convenção de namespace no Laravel , deve ser Simplexi\Greetr.

Claro, é uma boa ideia seguir a mesma estrutura de projeto do projeto Laravel . Mas neste blog de tecnologia, mostramos apenas uma saudação simples no navegador. Lembre-se de que, à medida que seu pacote cresce, é uma boa prática manter as funcionalidades publicamente disponíveis em uma ou duas classes de serviço. Todas as outras classes não devem estar disponíveis fora do pacote. Dessa forma, seu pacote deve ser gerenciável independentemente de outros pacotes ou do projeto principal.

Testando Nosso Pacote

Nosso pacote simples agora está pronto para testes. Mas primeiro, vamos criar uma rota e chamar nossa classe Greetr de pacote a partir desta rota por enquanto.

Podemos importar nossa classe Greetr de nosso pacote especificando primeiro seu namespace com a palavra-chave use . Então podemos instanciar a classe e chamar suas funções de membro no arquivo de rota do nosso projeto.

Execute um servidor de desenvolvimento pronto para uso do Laravel executando o seguinte comando no diretório raiz do projeto:

$ php crafter serve 
Servidor de desenvolvimento Laravel iniciado: <http://127.0.0.1:8000>

Abra seu navegador e digite o seguinte URL: http://127.0.0.1:8000/greetr/Francis

Publicando pacotes no GitLab

Criando repositório GitLab

Primeiro, devemos criar um novo projeto no GitLab . Certifique-se de que o nível de visibilidade esteja definido como público . Também podemos configurá-lo como privado se quisermos controlar quem pode usar nosso pacote. Fazer isso exigirá etapas adicionais. Mas para os propósitos deste blog de tecnologia, vamos defini-lo como público.

Navegue até nosso diretório de pacotes packages/simplexi/greetr. Inicialize o git, confirme as alterações e marque o conjunto de alterações com o controle de versão semântico executando os seguintes comandos.

// pacotes/simplexi/greetr$ git init 
$ git checkout -b master 
$ git add . 
$ git commit -m "commit inicial" 
$ git tag 1.0.0

Empurre o código-fonte local para o servidor GitLab remoto

Certifique-se de que sua conta já esteja configurada em sua máquina local para enviarmos nosso código-fonte para o servidor GitLab . Só precisamos enviar o packages/simplexi/greetrdiretório para o GitLab . É aconselhável incluir arquivos como CHANGELOG.mde readme.mdpara que outros desenvolvedores saibam mais sobre o seu pacote.

Para enviar nosso código-fonte local para o projeto GitLab recém-criado , execute os seguintes comandos. Certifique-se de substituir o URL de origem pelo seu próprio URL de repositório remoto.

// pacotes/simplexi/greetr$ git remote add origin https://gitlab.com/francis01/greetr.git
 $ git push -u origin --all 
$ git push -u origin --tags

Agora, estamos todos prontos. Outros desenvolvedores podem instalar nosso pacote em seus próprios projetos para acelerar o tempo de desenvolvimento. Na próxima seção, tentaremos importar nosso pacote em um novo projeto Laravel .

Importando Pacote Laravel

Agora podemos importar nosso pacote do servidor GitLab para um novo projeto Laravel usando o Composer . Crie outro projeto Laravel em sua máquina local.

Requer nosso pacote em composer.json

Edite o composer.jsonarquivo do novo projeto para requerer nosso pacote e também indique nosso repositório no GitLab for Composer para saber onde buscar pacotes além dos repositórios padrão do empacotador .

A propriedade do repositório lista todos os repositórios não empacotadores . Se você vai instalar vários pacotes do mesmo domínio GitLab , ao invés de especificar o repositório de cada pacote você pode usar o tipo “composer” e indicar apenas o domínio na URL. No entanto, há uma configuração adicional que o administrador do GitLab deve fazer neste caso. Por enquanto, vamos nos ater a um único repositório com o tipo “vcs”.

Execute o seguinte comando para carregar as alterações que fizemos no composer.jsonarquivo do nosso projeto e instale nosso pacote.

$ composer update