9 vídeos bastante útiles para aprender a instalar y configurar nuestro Wordpress.  Están en ingles, pero es fácil de entender

1. instalando Wordpress
2. Configurar Wordpress Part 1 of 8
3. Configurar Wordpress Part 2 of 8
4. Configurar Wordpress Part 3 of 8
5. Configurar Wordpress Part 4 of 8
6. Configuriar Wordpress Part 5 of 8
7. Configuriar Wordpress Part 6 of 8
8. Configuriar Wordpress Part 7 of 8
9. Configuriar Wordpress Part 8 of 8

Y otro más  de regalo: Customizando nuestro Wordpress Text Editor

enlace al post del creador de estos vídeos, un gran trabajo http://www.killersites.com/wordpress/

antes de nada he decir que últimamente no escribo mucho por motivos laborales, los cuales ya iré contando en una serie de posts.

Aquí pongo una pequeña lista de comunidades y listas de correo para poder compartir y aprender cosas de ZF.

Español:

• lista de correo en googlegrups
• http://www.zfforum.es/

Ingles:

• http://www.zfforums.com/
• Lista de correo,  general de Zend_Framework
  

si conocéis más sitios, avisarme  que lo voy actualizando

Este es el primero de los minitutoriales que tengo pensado hacer, está es la manjor manera de ir aprendiendo Zend_Loader es la clase más utilizada en todo ZendFramework, lógico es el que carga todas las demás. Este es nuestro árbol de directorio para las pruebas.

Zendframework está en /pruebas_Zend/libreria/Zend
Nuestro archivo donde probaremos nuetro código está en /pruebas_zend/loader.php

Zend_Loader tiene 4 metodos que vamos a ver:

1. Zend_Loader::loadFile()
2. Zend_Loader::loadClass()
3. Zend_Loader::isReadeable();
4. Zend_Loader::registerAutoload();

Pero antes de nada; tenemos que empezar con una cosa en nuestro archivo de prueba:
/**
* defino las rutas donde buscara por defecto los archivos.
* más info en: * http://es.php.net/manual/es/function.set-include-path.php
*/
set_include_path( ‘.’ .
PATH_SEPARATOR . ‘libreria’ .
PATH_SEPARATOR . ‘./’ .
PATH_SEPARATOR . get_include_path()
);
Leer el comentario del código; para más info ir a php.net

Despues incluiremos nuestra clase Zend_Loader a la manera “tradicional”:

/**
* cargo la clase Zend_Loader(), de la manera “tradicional”
*/
include_once(’Zend/Loader.php’);

Zend_Loader::loadFile

Zend_Loader::loadFile($nombre_de_archivo, $directorio=null, $once=false)

$nombre_de_archivo parámetro obligatorio, nunca pondremos la ruta (directorio/archivo.php), únicamente pondremos el nombre del archivo.
$ directorio parámetro NO obligatorio, aquí es donde pondremos la ruta hacia nuestro archivo, solo la ruta.(directorio_donde_esta_mi_archivo)
$once = parámetro NO obligatorio que le dice al loader si se carga como include_once() o como include()

Este método haría las veces de “include(), include_once()”, una de las ventajas que nos ofrece es la posibilidad de colocar excepciones y así poder controlar la carga de estos.

Problema Limitación encontrado :

“Zend_Loader::file() utiliza un metodo privado que está escrito de esta manera
protected static function _includeFile($filespec, $once = false)
{
if ($once)
{
return include_once $filespec;
} else {
return include $filespec ;
}
}
Y el problema de esto es que las variables declaradas en nuestro archivo se quedan en el ámbito de la funcion “_includeFile()” y no traspasan a el documento que incluye el archivo que contiene la variable.
Una solución puede ser el uso de de variables globales o una función que recupere la variable. más info(aunque yo no encontré la solución, solo leí unos cuantos comentarios acerca del tema) en: http://www.php.net/manual/en/language.variables.scope.php”

ejemplo:

try {
Zend_Loader::loadFile(’archivo.php’, ‘carpetaDePrueba’);
//Zend_Loader::loadFile(’archivoQueNoExiste.php’, ‘carpetaDePrueba’);
} catch (Zend_Exception $e){
echo ‘Error : ‘.$e->getMessage().”\n”;
}

Zend_Loader::loadClass

 Zend_Loader::loadClass('directorio_clase',

   array(

        '/directorio/libreria',

        '/directorio/otra_libreria'

    )

);

‘directorio_clase’ parámetro obligatorio, la manera de actuar de este parámetro es algo “especial”, en este parámetro pondremos la ruta y nombre de archivo, que coincidirá con la clase, separado por la linea baja ( “_”)
array() parámetro obcional, aquí pondremos las posibles rutas que en las que buscará, normalmente esto está solventado con el “set_include_path()” que pusimos al principio

ejemplo:

try {
Zend_Loader::loadClass(’Zend_Date’);
//Zend_Loader::loadClass(’carga_una_clase_que_no_existe’);
} catch (Zend_Exception $e) {
echo ‘Error al cargar la clase: ‘.get_class($e).”\n”;
echo ‘Mensaje: ‘.$e->getMessage().”\n”;
}
echo Zend_Date::now().”\n”;
Zend_Loader::isReadeable

if (Zend_Loader::isReadable($archivo)) {

    // nuestro archivo es legible

}

$archivo parámetro obligatorio, ruta y nombre de nuestro archivo.

Realmente todavía no le he econtrado mucha utilidad a este método; pero solo nos da información (true/false) a cerca de nuestro archivo, nos dice si es legible o está protegido contra lectura.

ejemplo:

if (Zend_Loader::isReadable(’archivo.txt’)) {
echo ‘archivo.txt Es legible’.”\n”;
}else {
echo ‘archivo.txt NO es legible’.”\n”;
}

Zend_Loader::registerAutoload

Zend_Loader::registerAutoload();

Si alguno entiende exactamente su función, rogaría em lo explique
Bueno, entonces nuestro archivo para probar Zend_Loader quedaría así:

/**
* defino las rutas donde buscara por defecto los archivos.
* más info en:
* http://es.php.net/manual/es/function.set-include-path.php
*/
set_include_path( ‘.’ .
PATH_SEPARATOR . ‘libreria’ .
PATH_SEPARATOR . ‘./’ .
PATH_SEPARATOR . get_include_path()
);

/**
* cargo la clase Zend_Loader(), de la manera “tradiconal”
*/
include_once(’Zend/Loader.php’);

/**
* Zend_Loader::loadClass();
*/
try {
Zend_Loader::loadClass(’Zend_Date’);
//Zend_Loader::loadClass(’carga_una_clase_que_no_existe’);
} catch (Zend_Exception $e) {
echo ‘Error al cargar la clase: ‘.get_class($e).”\n”;
echo ‘Mensaje: ‘.$e->getMessage().”\n”;
}
echo Zend_Date::now().”\n”;

/**
* Zend_Loader::loadFile();
* problema; si declaro una variable en el archivo a incluir
* Esta variable no estara definida en este documento;
*/
try {
Zend_Loader::loadFile(’archivo.php’, ‘carpetaDePrueba’);
//Zend_Loader::loadFile(’archivoQueNoExiste.php’, ‘carpetaDePrueba’);
} catch (Zend_Exception $e){
echo ‘Error : ‘.$e->getMessage().”\n”;
}

/**
* Zend_Loader::isReadable()
*/
if (Zend_Loader::isReadable(’archivo.txt’)) {
echo ‘archivo.txt Es editable’.”\n”;
}else {
echo ‘archivo.txt NO es editable’.”\n”;
}

“Estos apuntes que recopilo, son conclusiones a las que llego por la experiencia y lo aprendido hasta ahora. Son los consejos que daría a un amigo, al que al mismo tiempo diría que siempre que sea posible, antes de copiar las formas de trabajar de otros, las cuestione, y si su realidad le demuestra que es mejor adaptarlas, que no lo dude.
Por eso el libro no da recetas para calcar, sino conocimiento para adaptarlas o para diseñar las propias.”

link:  Flexibilidad con Scrum

Descargar el libro

Comprar el libro (con lo caro que está la tinta, mejor comprarlo impreso) 

En la página de Killerphp.com podemos encontrar mucha información de php, pero lo más interesante es que practicamente realiza post enseñando aprogramar, desde conceptos tan básicos como hacer una funcion en php.

Hoy voy a hacer referencia a sus tutoriales:

“Empezando a programar orientando a objetos“

Hoy estaba leyendo el articulo de killerphp.com (Zend framework components part2: Zend_View) y veo que nos pone un plugin para Zend_Controller.

Este plugin se encarga de agregar un archivo al principio(header.phtl) utilizando Zend_Controller_Plugin_Abstract::preDispatch(); y otro al final(footer.phtml) usando Zend_Controller_Plugin_Abstract::postDispatch().

He modificado la clase original de la página, porque me daba error. La clase quedaría así:

/*
* Handles the header / footer by capturing the preDispatch and postDispatch of the
* response object
*/
class Headerfooterview extends Zend_Controller_Plugin_Abstract
{
private $view;
function __construct()
{
$this->view = new Zend_View();
$this->view->setScriptPath(’application/views/scripts’);
}
/*
* Run at the beginning of the controller’s response object initialization
*/

public function preDispatch( Zend_Controller_Request_Abstract $request )
{
$this->getResponse()->prepend(’header’,$this->view->render(’header.phtml’,null,true));
}

/*
* Run at the end of the controller’s response object initialization
*/
public function postDispatch( Zend_Controller_Request_Abstract $request )
{
$this->getResponse()->append(’footer’, $this->view->render(’footer.phtml’,null,true));
}
}

Para poder instalarlo solo debemos realizarlo de la siguiente manera:

en el archivo index.php:

/*
* cargo las dependencias, si ya están cargadas esto se quita
*/
Zend_Loader::loadClass(’Zend_Controller_Plugin_Abstract’);
Zend_Loader::loadClass(’Zend_Controller_Request_Abstract’);
Zend_Loader::loadClass(’Zend_Controller_Router_Rewrite’);
Zend_Loader::loadClass(’Zend_Controller_Front’);
Zend_Loader::loadClass(’Zend_View’);
/*
* cargo mi plugin, esto depende de donde lo tengamos,
* en mi caso está en:
* /root/library/Mypluggin/Headerfooterview.php
*/
Zend_Loader::loadFile(’Headerfooterview.php’, ‘./library/Mypluggin’);
/*
* declaro el controlador
*/
$frontController = Zend_Controller_Front::getInstance();
$frontController->throwExceptions(true);
$frontController->addModuleDirectory(’./application/modules/’);
/*
* añado el plugin a nuestro controlador
*/
$frontController->setRouter(new Zend_Controller_Router_Rewrite());
$frontController->registerPlugin(new Headerfooterview());
/*
* inicio el controlador
*/
try {
$frontController->dispatch();
} catch (Exception $e) {
echo “Message: ” . $e->getMessage() . “\n”;
}

Con este plugin todos nuestros archivos .phtml incluiran por defecto un archivo header.phtml al principio y un footer.phtml al final; Ahoralo suyo sería poder crear excepciones, ya que puede darse el caso de alguna página que no lleve el mismo header.phtml que los demás

Zend framework: un framework orientado a objetos
lenguaje: PHP5
licencia: New BSD License
puntos a favor:

• Zend(empresa de los creadores de PHP) está detrás de todo este proyecto.
• Orientado a objetos.
• Objetos ligeros y efectivos.
• una comunidad detrás(por lastima, poca de lengua hispana)
• muy buena documentación(API guía, referencia sobre los objetos)

puntos en contra:

• ….(aún no los he encontrado, prometo postearlo en cuanto lo detecte)

objetos que trae el framework:

• Zend_Acl: listado de control de acceso(ACL) y gestión de privilegios
• Zend_Auth: api de autentificación(incluye modulo de abstracción)
• Zend_Config: gestión de los archivos de configuración, en distintos formatos
• Zend_Console_Getopt: gestiona y analiza opciones y argumentos pasados a nuestros programas(para linea de comandos / consola)
• Zend_Controller y Zend_View: Estos objetos(complementarios) gestionan el diseño de nuestro sistema con MVC
• Zend_Date: manipulación de fechas y horas
• Zend_Db: gestiona el acceso a múltiples bases de datos, proporcionando una interfaz con PDO y otras extensiones de PHP. Incluye adaptadores para cada base de datos, una consulta de perfil, y una API para construir la mayoría de SELECT.
• Zend_Db_Table: objeto que nos ayuda a recuperar información de nuestras tablas.
• Zend_Feed: gestión de feeds (atom/rss)
• …..

página del proyectos: http://framework.zend.com

link a la web del proyecto:   http://lipidity.com/fancy-form/

Hola; este año tengo una lista de intenciones para este blog. Primero tengo que definir los temas de interez en este blog, solo me voy a centrar en 3 temas:

Zend framework (php)
Symfony(php)
framework javascript(prototype, extjs 2)

Iré poniendo alguna otra cosa, como utilidades y/o algún que otro articulo que me parezca interesante. En estos casos solo será poner un link hacia la noticia, artículo, librería, utilidad, ….

Sin más tiempo que perder, habrá que ir empezando a poner al corriente de todos estos temas.