Temple: Sistema de Templates para PHP

temple sistema de templates para php

Este último tiempo estuve comenzando varios proyectitos, uno de ellos es Temple, un Sistema de Templates para PHP. Por el momento no posee mucha funcionalidad, ni esta documentado pero avanza todas las semanas :) .

La idea Temple es muy sencilla, a partir de un html con claves al estilo {{value}} generar un archivo con codigo PHP para que luego estas claves sean reemplazadas por valores.

Veamos un pequeño ejemplo de su uso:

Tenemos un archivo template: test.html

Buen dia: {{nombre}}

Luego por otro lado tenemos: index.php que es el encargado de instanciar Temple y parsear el html

<?php
include_once 'Temple.php';
include_once 'Parser.php';
include_once 'Cache.php';
$temple = new TempleTemple();
$params = array('nombre' => 'Mostofreddy');
$temple->loadView(__DIR__.'/test', $params);

Esto imprimira en pantalla:

Buen dia: Mostofreddy

Como podemos ver su uso es realmente sencillo y facil de integrar en otros sistemas ya realizados.

Existe una serie de configuraciones:

- cache: indica en que carpeta se almacenaran los files procesados
- useCache [true|false]: Indica si se usa el archivo anteriomente procesado o en cada peticion se debe procesar nuevamente
- force: obligatoriamente se procesa el archivo

Lo pueden descargar desde Github

conty – Light Injection Dependency Framework

Conty es un pequeño framework de Inyección de Dependencias realizado en PHP 5.3+ que permite ser integrado en cualquier proyecto (o framework como por ejemplo Zend, Codeigniter, etc) de forma rápida y sencilla.

¿Injection Dependency?

En forma resumida (porque en google encontramos miles de artículos que explican muy bien) la Inyección de Dependencia (en inglés Dependency Injection, DI) es un patrón de diseño orientado a objetos, en el que se inyectan objetos a una clase en lugar de ser la propia clase quien cree el objeto.
Existen 3 tipos de inyeccion de dependencias

  • por constructor
  • por setter
  • por interfaz

Conty al rescate =)

Conty permite realizar inyección de variables, funciones y objetos para que puedan ser rehutilizados en distintas partes de un proyecto.

Compartir variables

Un ejemplo de su utilización puede ser la configuración de una app.

<br /><br />$inj = contyConteiner::getInstance(<br /><%%KEEPWHITESPACE%%> array('url'=&gt;'http://www.mostofreddy.com.')<br />);<br /><br />echo $inj['url'];<br /><br />$inj['nombre'] = "Mostofreddy";<br /><br />echo $inj['nombre'];<br /><br />

Compartir objetos

Nos puede ser util para realizar factories y para controlar el ciclo de vida de los objetos y la cantidad de instancias de objetos de base de datos, de web service, de sessiones, etc.

<br /><br />class Dummy {<br /><%%KEEPWHITESPACE%%> public $name;<br /><%%KEEPWHITESPACE%%> public function __construct($name){<br /><%%KEEPWHITESPACE%%> $this-&gt;name = $name;<br /><%%KEEPWHITESPACE%%> }<br />}<br /><br />class MyConteiner extends contyConteiner<br />{<br /><%%KEEPWHITESPACE%%> public function __construct(array $data=array()){<br /><%%KEEPWHITESPACE%%> parent::__construct($data);<br /><%%KEEPWHITESPACE%%> $this-&gt;setFactories();<br /><%%KEEPWHITESPACE%%> }<br /><%%KEEPWHITESPACE%%> protected function setFactories(){<br /><%%KEEPWHITESPACE%%> $this['dummy'] = function ($inj, $params) {<br /><%%KEEPWHITESPACE%%> $o = new Dummy($params);<br /><%%KEEPWHITESPACE%%> return $o;<br /><%%KEEPWHITESPACE%%> };<br /><%%KEEPWHITESPACE%%> }<br />}<br /><br />$myInj = MyConteiner::getInstance();<br />$result = $myInj-&gt;get('dummy', 'Mostofreddy');<br />echo print_r($result, true);<br /><br />$result = $myInj-&gt;any('dummy', 'Mostofreddy2');<br />echo print_r($result, true);<br /><br />$result = $myInj-&gt;any('dummy', 'Mostofreddy3');<br />echo print_r($result, true);<br /><br />$result = $myInj-&gt;get('dummy', 'Mostofreddy4');<br />echo print_r($result, true);<br /><br />

Próximamente estará disponible la documentación oficial del proyecto :P

Tutorial Erlang III: Integers, floats, booleans, atoms

Retomando el tutorial de Erlang hoy trataré de explicar algunos tipos de datos de este lenguaje, veremos como Erlang maneja los enteros, floats y booleanos. Manos a la obra!

Integers

Este tipo de dato se utiliza para todo el conjunto de numeros enteros sin importar su tamaño. Pueden ser negativos o positivos y estar expresados en distintas bases.

No posee una cantida de bits fija ni un rango específico de valores como en otros lenguajes, por lo tanto, podemos escribir números con la cantidad de cifras que querramos y operar entre ellas sin provocar overflow.

Esto se debe a que Erlang internamente, cuando un entero no se puede representar en una palabra, utiliza lo que se conoce como bignums, representando al entero en un número  arbitrario de palabras haciendo su representación un poco menos eficiente. El único límite para el largo de los integers depende de la maquina.

Ejemplos

-4560
0
666
999999999999999

Ejemplos 2 con números en otra base

> 2#1011.
> 11
> 16#A
>10

Floats

Los tipos de datos Floats son usados para representar números Reales.

Ejemplos

> 1.02.
1.02
> 5698.12.
5698.12

Atoms

Los datos del tipo atoms son usados para representar valores constantes no-numéricos. En Erlang todos los Atoms son globales, comienzan con letra en minúsculas seguidos por una secuenca de carácteres alfanumericos, caracter underscore (_) o arrobas (@). Por ejemplo: junio, true, taza, mimail@dominio.com, etc.

Los Atoms también pueden estar delimitados por comillas simples cuando contienen caracteres no validos como espacios o que comiencen con mayúsculas. Por ejemplo ‘Diciembre’, ‘hoy es un lindo dia’, etc.

Algo a tener en cuenta es que las únicas operaciones que se pueden realizar con los Atoms en Erlang son las comparaciones.

Booleans

En Erlang no existen en si los tipos de datos booleanos, sino que son representados mediente los Atoms true y false. Estos son los valores que devuelven por ejemplo las comparaciones

1> 2 == 1 .
false
2> a > z .
false
3> less > more .
false
4> is_boolean(true) .
true

Existen otros tipos de datos como las tuplas, listas o strings pero lo veremos en más detalle en otro post.

Crear extensiones de PHP (I)

Luego de estar un tiempo sin postear en el blog, vuelvo con una serie de post relacionados con la creación de extensiones para PHP.

Crear extensiones de PHP no es un tema muy popular entre los desarrolladores web, siempre usamos extensiones creadas por los demás pero ¿a nadie le pico el bichito de saber como crear una propia?

¡A mi! y la verdad que no es nada complicado hacer una.

Que ventaja brinda una extensión

Principalmente rapidez, al estar escrita en C y correr en el núcleo de PHP su rendiemiento es mucho mayor.

Existen dos timpos de extensiones:  extensiones PHP y extensiones Zend. Las primeras agregan funcionalidad al lenguaje (por ejemplo Mysqli) y las segundas son extensiones de bajo nivel que modifican el núcleo del lenguaje (por ejemplo xdebug, APC).

Lo que necesitamos

Primero debemos instalar las herramientas para trabajar con C (bueno, también podemos escribir la extension en C++ pero ese será otro post) y alguna otra más:

sudo apt-get install libc6-dev
sudo apt-get install gcc
sudo apt-get install autoconf
sudo apt-get install automake
sudo apt-get install libtool
sudo apt-get install bison
sudo apt-get install flex
sudo apt-get install re2x

Obviamente que tambien debes tener instalado una versión de PHP (5.2+).

Como la creamos

Cada extensión posee al menos los siguientes archivos

- config.m4 es el archivo de configuración para la compilación, indica que archivos se deben compilar y que librerías externas se necesitan

- php_miLibreria.h y miLibreria.c son los archivos de código/funcionalidad de la extensión.

Veamos un ejemplo

Como ejemplo crearemos una extensión “fredddy” que provea una función llamada freddy_hola a PHP y que imprime un simple saludo

config.m4


PHP_ARG_ENABLE(freddy,
[Whether to enable the "freddy" extension],
[  --enable-freddy       Enable "freddy" extension support])

if test $PHP_FREDDY != "no"; then
PHP_SUBST(FREDDY_SHARED_LIBADD)
PHP_NEW_EXTENSION(freddy, freddy.c, $ext_shared)
fi

Lo anterior es la mínima configuración necesaria que necesita la extensión, veamos de que trata:

  • El primer parámetro de PHP_ARG_ENABLE setea en ./configure una opción llamada -enable-freddy
  • El segundo parámetro de PHP_ARG_ENABLE se mostrara durante el proceso de configuración, indicando que se habilito la extensión
  • El tercer parámetro de PHP_ARG_ENABLE se mostrara si se visualiza la ayuda de ./configure (./configure -help)
  • Para la compilación se deben seguir 3 pasos: phpize, ./configure -enable-freddy, make
  • Cuando se invoca a ./configure -enable-freddy se crea una variable  local llamada PHP_FREDDY y se setea en ‘yes’
  • PHP_SUBST es un macro similar a AC_SUBST() de C y es necesaria para crear la extensión
  • PHP_NEW_EXTENSION declara el módulo y el archivo fuente para la compilacion. $ext_shared es similar a PHP_SUBST y es necesaria para crear la extensión como modulo

Si la extensión contara con mas de un archivo fuente para la compilación se deben definir todos en PHP_NEW_EXTENSION separados por un espacio  (por ejempo: PHP_NEW_EXTENSION(freddy2, file1.c file2.c file3.c, $ext_sared)

php_freddy.h

Este archivo es el header del archivo .c que crearemos luego


#ifndef PHP_FREDDY_H
/* Prevenimos la doble inclucion */
#define PHP_FREDDY_H

/* Definimos las propiedades de la extension */
#define PHP_FREDDY_EXTNAME "freddy"
#define PHP_FREDDY_EXTVER "0.1"

/* Import configure options
 * when building outside of the
 * PHP source tree */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

/* Incluimos el header estandard de PHP */
#include "php.h"
/*
 * define the entry point symbole
 * Zend will use when loading this module
 */
extern zend_module_entry freddy_module_entry;
#define phpext_freddy_ptr &freddy_module_entry

#endif /* PHP_FREDDY_H */
  • config.h es incluido cuando se compila con phpize
  • Se incluye php.h que provee funcionalidades para usar en nuestra extension
  • zend_module_entry defina una estructura usada por Zend engine

freddy.c


#include "php_freddy.h"

PHP_FUNCTION(freddy_hola)
{
php_printf("Hola FreddY!!");
}

static function_entry php_freddy_functions[] = {
PHP_FE(freddy_hola, NULL)
{ NULL, NULL, NULL }
};

zend_module_entry freddy_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
STANDARD_MODULE_HEADER,
#endif
PHP_FREDDY_EXTNAME,
php_freddy_functions, /* Functions */
NULL, /* MINIT */
NULL, /* MSHUTDOWN */
NULL, /* RINIT */
NULL, /* RSHUTDOWN */
NULL, /* MINFO */
#if ZEND_MODULE_API_NO >= 20010901
    PHP_FREDDY_EXTVER,
#endif
    STANDARD_MODULE_PROPERTIES
};

#ifdef COMPILE_DL_FREDDY
    ZEND_GET_MODULE(freddy)
#endif

Compilación

Ya tenemos todo listo para compilar nuestra primera extensión de PHP, para ello debemos hacer lo siguiente


phpize

./configure -enable-freddy

make

Se abra creado una carpeta llamada modules con el archivo freddy.so, este es el archivo de nuestra extensión y el que debemos cargar en PHP


touch /etc/php5/apache2/conf.d/freddy.ini

vim /etc/php5/apache2/conf.d/freddy.ini

Agregamos el siguiente código y reiniciamos apache


[freddy]
extension=/var/www/extensiones/freddy/modules/freddy.so

Listo!

Podemos crear un archivo php para ver como funciona el ejemplo


<?php
echo freddy_hola();

De a poco seguire subiendo más post y agregando nuevos conceptos de como crear extensiones para PHP.

Espero que les sea de utilidad.

Instalar y configurar memcached

memcache

Memcache, un sistema de cache distribuido, que se aloja en memoria y es de proposito general. La idea es almacenar en memoria cadenas de bytes (strings) que ya fueron procesados para no procesarlos nuevamente.

Por ejemplo, cachear resultados de queries, compartir datos entre servidores, utilizarlo como almacenamiento de sessiones, etc.

Hay que tener en cuenta que estos datos son almacenados en memoria RAM, la cual es volátil y si apagamos el servidor o el deamon de memcached estos datos se perderan! (siempre hay que tener un plan de contingencia para levantar rápidamente los datos a memcache una vez reiniciado el server)

Su funcionamiento es sencillo, a cada item que se desea cachear se almacenan en una tabla hash, al cual se le asigna una clave para su posterior recuperacion. Todos estos datos se almacenan donde su estructura llamada slabs. Los slab tienen tamaño variable para optimizar el espacio en memoria, pero su tamaño mayor es de 1mb, por lo cual, este es el tamaño mas grande que se puede almacenar.

Tambien para cada item almacenado, memcached permite controlar su tiempo de vida (es independiente para cada item), una vez finalizado memcache lo elimina.

Otra de las caracteristicas de memcache es la escalabilidad, podemos contar con un pool de servidores en distintas (o no) maquinas para soportar una cantidad elevada de peticiones concurrentes.

Instalación

Para instalar en ubuntu basta con

sudo apt-get install memcached

Configuración

Si usamos apt-get para instalar memcache encontraremos en la carpeta /usr/share/memcached un archivo llamado memcached.conf.default con un ejemplo de archivo de configuracion. El archivo real se encuentra en /etc/memcached.conf.

Los parametros que se pueden configurar son los siguientes:

-m indica a memcache cuanta memoria utilizar para almacenar los items (default 64mb)
-d indica a memcache que se ejecute como deamon
-v el clasico verbose
-vv verbose mas completo
-vvv verbose muuuuuucho mas completo
-p puerto por el cual memcache escucha (default 11211)
-l ip por el cual se comunica memecache (default 127.0.0.1)
-c cantidad maxima de conexiones simultaneas (default 1024)
-u indica con que usuario correra memcache (default root)
logfile path para el archivo log

Clip – trabajando desde linea de comando con PHP

Clip es un nuevo proyecto que estoy comenzando que facilita la creación de script PHP para correrlos desde la shell o línea de comando.

La funcionalidad que esta implementada hasta ahora es la siguiente:

- Recupera los parámetros de entrada del script.
- Identifica el SO que se utiliza y usa los comandos adecuados para cada SO.
- Funcionalidad para imprimir y recuperar datos desde la consola.
- Permite cambiar de color y fondo a los datos que se imprimen en la consola.
- Validación automatica de los parametros de entrada.
- Invocación al método help cuando se usa -h o —help como parámetro.
- Invocación al método version cuando se usa —version como parámetro.

Veamos unos ejemplos de su uso: (el ejemplo completo se puede ver en github)

1) Imprimir la típica ayuda de los scripts de shell cuando ponemos -h o –help

Para esto debemos crear una clase que extienda de Clip (sisi, usa namespaces de PHP 5.3+)

#!/usr/bin/php
<?php
class Test extends ClipClip
{
    protected $name = '';

    protected function help()
    {
        $this->writer()->write('Esta es la ayuda');
    }
}
$test = new Test();

Luego abrimos una consola y ponemos

> ./test.php -h
> Esta es la ayuda

2) Mostrar la versión de nuestro script

    protected function version()
    {
        $this->writer()->write('Esta es la version');
    }
> ./test.php -version
> Esta es la version

3) Perdir datos al usuario

    public function getName()
    {
        $this->name = $this->writer()->prompt('Escribi tu nombre por favor', null, null, true);
        $this->writer()->newLine();
    }

4) Validar los datos de entrada

Para validar los datos de entrada hay que crear un método que se llame validate que recibe como parametro un objeto del tipo ClipClipOpts. Este objeto tiene 3 atributos:

- short: son las opciones que constan de una sola letra.
- long: son los parámetros del tipo –key o –key=valor.
- input: son los demás parámetros.

Por ejemplo:

    protected function validate(ClipClipOpts $opts)
    {
        if (!in_array('v', $opts->short)) {
            return "Error: Debe agregar la opcion 'v'";
        }
        return true;
    }

Para ver el mensaje de error, usamos el script así

./test.php -t --clave=valor /home/Bart
> Error: Debe agregar la opcion 'v'

En cambio si se invoca de alguna de las siguientes nameras no mostrará el error

./test.php -v --clave=valor /home/Bart
./test.php -vt --clave=valor /home/Bart

Espero que les sea de utilidad!

Calidad de software en PHP (IX) – PHP CodeSniffer

Update: 23/03/2011

Fue lanzada la version 1.3.0 con soporte para closures, namespaces, __invoke, etc (ver changelog)

PHP CodeSniffer es un script realmente práctico y fundamental para estandarizar la codificación de una empresa o en nuestra casa. El script valida la sintaxis de nuestro código PHP contra un estandar definido, este puede ser el de Zend, Pear o alguno propio que definamos.

Para su instalación debemos tener instalado Pear.


sudo pear install PHP_CodeSniffer

Para verificar que la instalación fue correcta podemos hacer lo siguiente


phpcs --version

Para ver todos los parametros y configuración podemos ver la ayuda


phpcs --help

Para saber cuales son los estándares instalados


phpcs -i

Para definir el estandar por defecto que se utilizara

phpcs --config-set default_standard Zend