queulat
1.0.0
Instalar con el compositor:
composer require felipelavinz/queulat:dev-master
El compositor se instalará en wp-content/mu-plugins/queulat
Si necesita instalar en una carpeta diferente, debe agregar algo como esto al compositor de su proyecto.json:
{
"extra" : {
"installer-paths" : {
"htdocs/wp-content/mu-plugins/{$name}" : [ " type:wordpress-muplugin " ]
}
}
} Donde htdocs/wp-content/mu-plugins/{$name} Es la ruta a su directorio Mu-Plugins. Queulat se instalará como un subcarpelo en la carpeta especificada.
Queulat utiliza el compositor Autoloader para cargar la mayor parte de su código, por lo que debe asegurarse de que el autoloader esté incluido antes de inicializar Queulat.
Además, dado que MU-Plugins instalados en una subcarpeta no está cargada automáticamente por WordPress, debe requerir manualmente el archivo principal.
Puede resolver esto con un solo archivo en la carpeta 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 ' ;Los encabezados del complemento son opcionales, pero se recomiendan.
También puede usar algo como Bedrock's AuthoLoader, que cargará todas las plugins MU instaladas en los subcarpetas (puede copiar ese archivo en su carpeta Mu-Plugin y cargará automáticamente queulat).
Queulat tiene como objetivo mejorar la forma en que creamos cosas para WordPress , por lo que en lugar de transformarlo fundamentalmente, trata de usar conceptos familiares para construir cosas mejor estructuradas, utilizando tipos de publicación personalizados , consultas de publicación personalizadas y objetos de publicación personalizados .
Puede generarlos utilizando su propio generador de complementos de tipo de publicación personalizado , que está disponible para los usuarios de administración en el menú "Herramientas".
Cada complemento de tipo de publicación personalizado está compuesto de:
Song_Post_Type . Esta clase define las etiquetas y otros argumentos para registrar el tipo de publicación en WordPress. De manera predeterminada, la activación del complemento agregará las permisiones necesarias para administradores y reescrituras de descarga. Puede extender esta clase si necesita definir ganchos personalizados para una funcionalidad adicional para el tipo de publicación.Song_Post_Query . Puede usar esta clase para crear nuevas consultas de base de datos, utilizando cualquier parámetro predeterminado que desee definir para este tipo de contenido e iterar sobre los resultados utilizando un foreach simple en lugar del clásico bucle de WordPress.Song_Post_Object , que se devolverá en el bucle foreach al usar la consulta personalizada. De esta manera, puede agregar cualquier método personalizado a esta clase, que estará disponible en el bucle foreach .Usando Queulat, podría hacer 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
Actualmente, la forma principal de definir meta datos en los objetos post es crear meta cuadros; Extendiendo la clase de abstracto QueulatMetabox incluida.
La clase de extensión debe implementar los métodos abstractos: get_fields( ) : array y sanitize_data( array $data ) : array ; por ejemplo:
<?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 ' )
) );
}
}Queulat se encarga de actualizar los datos enviados como meta campos posteriores, y cargar los valores guardados en el formulario Meta Box.
Para desinfectar datos, puede usar cualquier método que prefiera. La función referenciada queulat_sanitizer() es una forma bastante simple de aplicar devoluciones de llamada a los valores coincidentes desde la entrada $data . Puede usar * para que coincida con todas las propiedades (usando notación de puntos).
Consulte la sección (Usando formularios de Queulat) [#usando las formas de cola de cola] para obtener más información sobre los campos de formulario disponibles o cómo crear los suyos propios.
@todo: add general description
@todo: add description for each form field
@todo
@todo
Node_Factory Es una clase de fábrica simple que puede crear cualquier tipo de elemento de forma.
Expone un método make única que puede instanciar y configurar un elemento. Este método toma dos parámetros:
Por defecto, Queulat está configurado para manejar los siguientes atributos:
Node_Factory como una matriz.Se omiten los argumentos que no son compatibles con el elemento.
Puede extender los argumentos compatibles 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 ; Puede registrar nuevos argumentos utilizados por Node_Factory utilizando el método register_argument .
Este método toma un Node_Factory_Argument_Handler , que necesita:
$argument (cadena) que es el nombre de la tecla de argumento que manejará.$method (cadena) que es el nombre del método que recibirá los parámetros utilizados en el método de fábrica.$call_type (cadena) opcional que determina cómo el método $ tratará los valores de configuración recibidos. El $call_type puede ser uno de:
Node_Factory::CALL_TYPE_VALUE : pase todos los argumentos como una matriz única al controlador. Esta es la configuración predeterminada. Ejemplo: $obj->$method( $args );
Node_Factory::CALL_ARRAY : pase los argumentos como parámetros individuales al controlador. Ejemplo: call_user_func_array( [ $obj, $method ], $args );
Node_Factory::CALL_KEY_VALUE : para cada elemento en el argumento, pase su clave y valor como parámetros al controlador. Ejemplo:
foreach ( $ args as $ key => $ val ) {
$ obj -> $ method ( $ key , $ val );
} Node_Factory::CALL_TYPE_VALUE_ITEMS : para cada elemento en el argumento, use el valor como parámetro para el controlador. Ejemplo: array_walk( $args, [ $obj, $method ] );
| Interfaces relacionadas | Rasgos relacionados |
|---|---|
Component_Interface | Node_Trait |
Element_Interface | Childless_Node_Trait |
Los nodos son el nivel más bajo de objetos que deben usarse con formas
Use Node_Trait para ayudar a implementar esta interfaz o Childless_Node_Trait . En términos generales, los elementos deben usar el primero y los componentes el segundo.
Extiende el node_interface y attributes_interface.
Extiende el node_interface y attributes_interface. Además, agrega el método get_tag_name .
Extiende el elemento_interface y las propiedades_interface.
Extiende html_element_interface y form_node_interface.
Los "atributos" son propiedades especiales utilizadas por objetos que implementan esta interfaz. Se representan como atributos HTML key="val"
Use Attributes_Trait para ayudar a implementar esta interfaz.
Los objetos que implementan esta interfaz (elementos o componentes) se utilizan como objetos de formulario. Tienen un "nombre" que se usa para enviar datos al servidor, un "valor" y una "etiqueta".
Form_Control_Trait ayuda a implementar los getters y establecedores de "etiqueta" y "nombre" de esta interfaz. El Getter y Setter "Value" deben definirse mediante su propio componente personalizado.
Extiende ArrayAccess, BuscableIterator, contable, serializable.
Más comúnmente utilizado para obtener un conjunto de niños con forma de matriz de un nodo.
Utilizado por controles como casillas de verificación, radios, seleccionar y cada componente donde se presente al usuario con varias alternativas entre las que puede elegir.
Use Options_Trait para ayudar a implementar esta interfaz.
Las propiedades del nodo (que no deben confundirse con las propiedades del objeto regular) pueden almacenar datos arbitrarios, como configuración de vista, datos de error o estado de validación.
Use Properties_Trait para ayudar a implementar esta interfaz.
Interfaz base para ser utilizada por vistas de formulario.
