menu
Fórum Adianti
menu Menu
Criando componentes para o Adianti Framework usando Composer Neste artigo vou ensinar você a utilizar o Composer para criar um componente para o Adianti Framework. O Composer (http://www.php.com.br/23?composer-mais-de-1000-bibliotecas-disponiveis-em-seu-projeto) é um gerenciador de pacotes para o PHP. Com ele, você pode usar milhares de pacotes criados pela comunidade, e também criar os seus componentes. Introdução No desenvolvimento de...
PD
Criando componentes para o Adianti Framework usando Composer  
Neste artigo vou ensinar você a utilizar o Composer para criar um componente para o Adianti Framework. O Composer (www.php.com.br/23?composer-mais-de-1000-bibliotecas-disponiveis-em-s) é um gerenciador de pacotes para o PHP. Com ele, você pode usar milhares de pacotes criados pela comunidade, e também criar os seus componentes.

Introdução



No desenvolvimento de sistemas, é muito comum precisarmos criar componentes para resolver problemas comuns. Mesmo que o Framework ofereça uma quantidade boa de componentes, nem sempre vai atender 100% das demandas. Quando criamos um componente, podemos reaproveitá-lo entre projetos, ou mesmo divulgá-lo na comunidade para que mais pessoas se beneficiem com ele. Neste artigo, vamos criar um componente simples para Accordion, e publicá-lo em um repositório GitHub para reaproveitamento em outros projetos.

Criar repositório Git



O primeiro passo é criar um repositório Git. Vamos criar um repositório vazio no GitHub, e em seguida efetuamos um clone dele:

cd /tmp/ git clone https://github.com/adianti/plugins.git


Estrutura


Você acessará o repositório recém criado e criará o diretório src dentro dele.

cd accordion mkdir src mkdir src/Accordion


O componente



O componente terá um namespace, que neste caso será formado pelo nome do autor (Adianti), tipo (Plugins) e pelo nome do pacote (Accordion). O nome do componente (widget de tela) que criaremos será AccordionContainer. Dentro deste pacote (Adianti\Plugins) poderão existir outras classes necessárias para o funcionamento deste componente. Como esse componente utiliza classes existentes do Framework, será necessário indicar estes no header (use). As classes utilizadas aqui são: TElement, TScript, e TStyle. O método addContent() adicionará um conteúdo ao accordion. O método show(), exibe os elementos criados internamente, e acrescenta um script por meio do TScript::importFromFile(), e um estilo, por meio do TStyle::importFromFile().

plugins/src/Accordion/AccordionContainer.php

  1. <?php
  2. namespace Adianti\Plugins\Accordion;
  3. use Adianti\Widget\Base\TElement;
  4. use Adianti\Widget\Base\TScript;
  5. use Adianti\Widget\Base\TStyle;
  6. /**
  7.  * Accordion Container
  8.  */
  9. class AccordionContainer extends TElement
  10. {
  11.     protected $elements;
  12.     
  13.     /**
  14.      * Class Constructor
  15.      */
  16.     public function __construct()
  17.     {
  18.         parent::__construct('div');
  19.         $this->id 'taccordion_' uniqid();
  20.         $this->elements = array();
  21.     }
  22.     
  23.     /**
  24.      * Add a page to the accordion
  25.      * @param $title  Title
  26.      * @param $object Content
  27.      */
  28.     public function addContent($title$object)
  29.     {
  30.         $this->elements[] = array($title$object);
  31.     }
  32.     
  33.     /**
  34.      * Shows the widget at the screen
  35.      */
  36.     public function show()
  37.     {
  38.         foreach ($this->elements as $child)
  39.         {
  40.             $title = new TElement('button');
  41.             $title->class 'taccordion';
  42.             $title->add($child[0]);
  43.             
  44.             $content = new TElement('div');
  45.             $content->class 'taccordion-content';
  46.             $content->add($child[1]);
  47.             
  48.             parent::add($title);
  49.             parent::add($content);
  50.         }
  51.         
  52.         TStyle::importFromFile('vendor/adianti/plugins/src/Accordion/accordion.css');
  53.         TScript::importFromFile('vendor/adianti/plugins/src/Accordion/accordion.js');
  54.         
  55.         parent::show();
  56.     }
  57. }
  58. ?>


A seguir o arquivo de estilo necessário:

plugins/src/Accordion/accordion.css

.taccordion { background-color: #eee; font-weight: bold; cursor: pointer; padding: 12px; width: 100%; border: none; text-align: left; outline: none; } .taccordion.active, .taccordion:hover { background-color: #ccc; } .taccordion-content { padding: 0 18px; display: none; overflow: hidden; } .taccordion:after { content: '\002B'; color: black; font-weight: bold; float: right; margin-left: 5px; }



A seguir o arquivo Javascript necessário:

plugins/src/Accordion/accordion.js

var coll = document.getElementsByClassName("taccordion"); var i; for (i = 0; i < coll.length; i++) { coll[i].addEventListener("click", function() { this.classList.toggle("active"); var content = this.nextElementSibling; if (content.style.display === "block") { content.style.display = "none"; } else { content.style.display = "block"; } }); }



Metadados


O pacote precisará de um arquivo composer.json no seu diretório principal para descrever o pacote, sua licença, seus autores, e como ele será carregado. No autoload, fazemos um mapeamento do namespace "Adianti\Plugins" para a pasta "src".


plugins/composer.json
{ "name": "adianti/plugins", "description": "Plugins for Adianti Framework", "type": "library", "license": "MIT", "authors": [ { "name": "Pablo Dall Oglio", "email": "seu@email.com" } ], "require": {}, "autoload": { "psr-4": { "Adianti\\Plugins\\": "src" } }




Comitando tudo



git add -A git commit -m "first commit" git push




Testando



Agora, chegou o momento de testar o componente. Vamos trocar de contexto e acessar o diretório de seu projeto, e instalar o componente:

cd /caminho/para/seu/projeto


Dentro de seu projeto, vamos usar este comando para adicionar o repositório ao composer:
php7 composer.phar config repositories.accordion vcs https://github.com/adianti/plugins


E vamo utilizar este comando para instalar o pacote:
php7 composer.phar require adianti/plugins dev-master


Agora basta usar dentro de suas classes...

  1. <?php
  2. use Adianti\Plugins\Accordion\AccordionContainer;
  3.  
  4. class AccordionView extends TPage
  5. {
  6.     function __construct()
  7.     {
  8.         parent::__construct();
  9.         
  10.         $accordion = new AccordionContainer;
  11.         // ...
  12.     }
  13. }
  14. ?>



Referências


blog.jgrossi.com/2013/creating-your-first-composer-packagist-package

Curso completo Meu Negócio Pronto
Use para si, ou transforme em um negócio: Inclui aulas e códigos-fontes
Gestor de conteúdo (SITE) + Loja Virtual (E-Commerce) + Emissor de Notas para infoprodutos


Meu negócio pronto Quero me inscrever agora!

Comentários (3)


JG

Olá Pablo, parabéns pelo artigo e pelo trabalho com a versão 7.3!
Eu publiquei alguns componentes na aba "contribs", todos usando o composer, com controle de versão etc.
Porém notei algo interessante no seu post, que foi como vc fez para usar classes internas do framework para criar os componentes.
Eu fiz dessa forma, veja:

  1. <?php
  2. require_once  __DIR__.'/../../../../lib/adianti/core/AdiantiCoreLoader.php';
  3. spl_autoload_register(array('Adianti\Core\AdiantiCoreLoader''autoload'));
  4. class TEntryDateTime extends TEntry implements AdiantiWidgetInterface{
  5.     private $mask;
  6.     private $dbmask;
  7.     protected $id;
  8.     protected $size;
  9.     protected $value;
  10.     protected $options;
  11.     protected $replaceOnPost;
  12.     
  13.     
  14.     /**
  15.      * Class Constructor
  16.      * @param $name Name of the widget
  17.      */
  18.     public function __construct($name)
  19.     {...
  20. ?>


Eu não sabia que o Composer fazia esse trabalho de encontrar as classes fora da sua estrutura de classes, então eu chamei a classe AdiantiCoreLoader para fazer o carregamento das classes do framework, assim eu as utilizo sem a necessidade do 'use'.
Minha dúvida é, fazer dessa forma que eu fiz, é mais custoso para o PHP?
Consome recursos desnecessários?
Ou é um forma válida de fazer?
Pergunto pois apesar de trabalhar a muito tempo com PHP e utilizar muito o Composer como consumidor de libs, eu sou leigo nessa questão de distribuir libs pelo Composer.
No mais, obrigado.
IM

acompanhando ...
JG

Acho que Pablo entrou de recesso kkkkk
Mas foi merecido a versão 7.3 esta incrível!