queulat
1.0.0
Instale com o Composer:
composer require felipelavinz/queulat:dev-master
O compositor instalará em wp-content/mu-plugins/queulat
Se você precisar instalar em uma pasta diferente, adicione algo assim ao composer.json do seu projeto:
{
"extra" : {
"installer-paths" : {
"htdocs/wp-content/mu-plugins/{$name}" : [ " type:wordpress-muplugin " ]
}
}
} Onde htdocs/wp-content/mu-plugins/{$name} é o caminho para o seu diretório mu-plugins. O Queulat será instalado como um subpasta na pasta especificada.
O Queulat usa o compositor Autoloader para carregar preguiçoso a maior parte de seu código, portanto, você precisa garantir que o automóvel esteja incluído antes de inicializar o Queulat.
Além disso, como o MU-PLUGINS instalado em um sub-dobrador não é carregado automaticamente pelo WordPress, você deve exigir manualmente o arquivo principal.
Você pode resolver isso com um único arquivo na pasta mu-plugins, como:
<?php
/**
* Plugin Name: Queulat Loader
* Description: Load Queulat mu-plugin
*/
// Load Composer autoloader (ABSPATH it's the path to wp-load.php).
require_once ABSPATH . ' /../vendor/autoload.php ' ;
// Load Queulat main file.
require_once __DIR__ . ' /queulat/queulat.php ' ;Os cabeçalhos dos plug -in são opcionais, mas recomendados.
Você também pode usar algo como o AutoLoader da Bedrock, que carregará todos os MU-Plugins instalados em sub-dobradores (você pode apenas copiar esse arquivo na sua pasta MU-Plugin e ele carregará automaticamente o Queulat).
Queulat, tem como objetivo melhorar a maneira como criamos as coisas para o WordPress ; portanto, em vez de transformá-lo fundamentalmente, ele tenta usar conceitos familiares para criar coisas melhor estruturadas para ele, usando tipos de postagens personalizados , consultas postais personalizadas e objetos de postagem personalizados .
Você pode gerá -los usando seu próprio gerador de plug -in de tipo de postagem personalizado , disponível para usuários administrativos no menu "Ferramentas".
Cada plugin de tipo de postagem personalizado é composto:
Song_Post_Type . Esta classe define os rótulos e outros argumentos para registrar o tipo de postagem no WordPress. Por padrão, a ativação do plug -in adicionará as permissões necessárias para administradores e reescritas de descarga. Você pode estender esta classe se precisar definir ganchos personalizados para funcionalidade extra para o tipo de postagem.Song_Post_Query . Você pode usar esta classe para criar novas consultas de banco de dados, usando os parâmetros padrão que você deseja definir para esse tipo de conteúdo e iterar sobre os resultados usando um foreach simples em vez do loop clássico do WordPress.Song_Post_Object , que será retornado no loop foreach ao usar a consulta personalizada. Dessa forma, você pode adicionar métodos personalizados a esta classe, que estará disponível no loop foreach .Usando o Queulat, você pode fazer algo como:
$ tracklist = new Song_Post_Query ( array (
' tax_query ' => array (
array (
' taxonomy ' => ' albums ' ,
' term ' => ' dark-side-of-the-moon ' ,
' field ' => ' slug '
)
)
) );
foreach ( $ tracklist as $ track ) {
echo $ track -> title ();
echo $ track -> duration ();
echo $ track -> lyrics ();
} @todo
@todo
@todo
Atualmente, a principal maneira de definir meta -dados nos objetos de postagem que está criando meta caixas; estendendo a classe abstrata de QueulatMetabox .
A classe Extending deve implementar os métodos abstratos: get_fields( ) : array e sanitize_data( array $data ) : array ; por exemplo:
<?php
use Queulat Metabox ;
use Queulat Forms Node_Factory ;
use Queulat Forms Element Input_Text ;
class Track_Meta_Box extends Metabox {
/**
* Must return the list of form fields to be included on this meta box
*
* @return QueulatFormsNode_Interface[] Array of form fields.
**/
public function get_fields () : array {
return array (
Node_Factory:: make (
Input_Text::class,
array (
' name ' => ' length ' ,
' label ' => ' Track length ' ,
' attributes.class ' => ' regular-text ' ,
' properties.description ' => _x ( ' Track duration, such as: 01:23:45 (1 hour, 23 minutes, 45 seconds) ' , ' length field description ' , ' track_cpt ' ),
)
),
Node_Factory:: class (
Input_Checkbox::class,
array (
' name ' => ' colour ' ,
' label ' => ' Colour ' ,
' options ' => array (
' red ' => ' Red ' ,
' green ' => ' Green ' ,
' blue ' => ' Blue ' ,
' any ' => ' Any colour '
)
)
)
);
}
/**
* Sanitize data from the metabox form.
*
* @param array $data Form data from the meta box (not the full $_POST).
* @return array Sanitized data.
**/
public function sanitize_data ( array $ data ) : array {
return queulat_sanitizer ( $ data , array (
' length ' => array ( ' sanitize_text ' ),
' colour.* ' => array ( ' sanitize_key ' )
) );
}
}O Queulat cuida da atualização dos dados enviados como meta -campos e carregando os valores salvos no formulário de meta caixa.
Para higienizar dados, você pode usar qualquer método que preferir. A função queulat_sanitizer() referenciada é uma maneira bastante simples de aplicar retornos de chamada aos valores correspondentes da entrada $data . Você pode usar * para corresponder a todas as propriedades (usando a notação de pontos).
Verifique a seção ON (usando formulários de Queulat) [#Usando-os-queulat-Forms] para obter mais informações sobre os campos de formulário disponíveis ou como criar o seu próprio.
@todo: add general description
@todo: add description for each form field
@todo
@todo
Node_Factory É uma classe simples de fábrica capaz de criar qualquer tipo de elemento de formulário.
Ele expõe um único método make que pode instanciar e configurar um elemento. Este método leva dois parâmetros:
Por padrão, o Queulat está configurado para lidar com os seguintes atributos:
Node_Factory como uma matriz.Os argumentos que não são suportados pelo elemento são ignorados.
Você pode estender os argumentos suportados usando Node_Factory::register_argument() .
<?php
use Queulat Forms Element Div ;
use Queulat Forms Node_Factory ;
use Queulat Forms Element Button ;
$ submit = Node_Factory:: make (
Div::class, array (
' attributes ' => array (
' class ' => ' col-md-4 col-md-offset-8 ' ,
' id ' => ' form-buttons '
),
' text_content ' => ' * required field ' ,
' children ' => array (
Node_Factory:: make (
Button::class,
' attributes ' => array (
' class ' => ' btn-lg ' ,
' type ' => ' submit '
),
' text_content ' => ' Submit '
)
)
);
);
echo $ submit ; Você pode registrar novos argumentos usados pelo Node_Factory usando o método register_argument .
Este método leva um Node_Factory_Argument_Handler , que precisa:
$argument (string), que é o nome da chave de argumento que você lidará.$method (string), que é o nome do método que receberá os parâmetros usados no método da fábrica.$call_type (string) opcional que determina como o método $ tratará os valores de configuração recebidos. O $call_type pode ser um dos:
Node_Factory::CALL_TYPE_VALUE : Passe todos os argumentos como uma única matriz para o manipulador. Esta é a configuração padrão. Exemplo: $obj->$method( $args );
Node_Factory::CALL_ARRAY : Passe argumentos como parâmetros individuais para o manipulador. Exemplo: call_user_func_array( [ $obj, $method ], $args );
Node_Factory::CALL_KEY_VALUE : Para cada item no argumento, passe sua chave e valor como parâmetros para o manipulador. Exemplo:
foreach ( $ args as $ key => $ val ) {
$ obj -> $ method ( $ key , $ val );
} Node_Factory::CALL_TYPE_VALUE_ITEMS : Para cada item no argumento, use o valor como parâmetro para o manipulador. Exemplo: array_walk( $args, [ $obj, $method ] );
| Interfaces relacionadas | Traços relacionados |
|---|---|
Component_Interface | Node_Trait |
Element_Interface | Childless_Node_Trait |
Nós são o nível mais baixo de objetos que devem ser usados com formulários
Use Node_Trait para ajudar a implementar esta interface ou Childless_Node_Trait . Em termos gerais, os elementos devem usar o primeiro e os componentes do último.
Estende o Node_Interface e o Atributes_Interface.
Estende o Node_Interface e o Atributes_Interface. Além disso, adiciona o método get_tag_name .
Estende o Element_Interface e o Properties_Interface.
Estende HTML_ELEMENT_INTERFACE e FORM_NODE_INTERFACE.
"Atributos" são propriedades especiais usadas por objetos que implementam essa interface. Eles são renderizados como atributos html key="val"
Use Attributes_Trait para ajudar a implementar esta interface.
Os objetos que implementam essa interface (elementos ou componentes) são usados como objetos de formulário. Eles têm um "nome" usado para enviar dados para o servidor, um "valor" e um "rótulo".
O Form_Control_Trait ajuda a implementar o "rótulo" e o "name" getters e setters dessa interface. O getter e o setter "value" devem ser definidos pelo seu próprio componente personalizado.
Estende o ArrayAccess, procurável, contável, serializável.
Mais comumente usado para obter um conjunto de crianças semelhantes a matriz de um nó.
Usado por controles como caixas de seleção, rádios, seleciona e todos os componentes em que o usuário é apresentado com várias alternativas que podem escolher.
Use Options_Trait para ajudar a implementar esta interface.
Propriedades do nó (não devem ser confundidas com propriedades regulares de objetos) podem armazenar dados arbitrários, como configurações de exibição, dados de erro ou estado de validação.
Use Properties_Trait para ajudar a implementar esta interface.
Interface básica a ser usada por visualizações de formulário.
