src/www/include/lib/HE/hooks.php

   1 <?php
   2 // vim: set expandtab tabstop=4 softtabstop=4 shiftwidth=4:
   3 // +--------------------------------------------------------------------+
   4 // |                          HORAS EXTRA                               |
   5 // +--------------------------------------------------------------------+
   6 // |    Sistema de Horas Extra - Ministerio de Economía - Argentina     |
   7 // +--------------------------------------------------------------------+
   8 // | Creado: lun abr 22 16:05:33 ART 2002                               |
   9 // | Autor:  Leandro Lucarella <llucar@mecon.gov.ar>                    |
  10 // +--------------------------------------------------------------------+
  11 //
  12 // $URL: http://portal.mecon.ar/svn/he/ramas/carga_inicial/src/lib/HE/lib/hooks.php $
  13 // $Rev: 116 $
  14 // $Date: 2002-10-23 19:09:12 -0300 (mié, 23 oct 2002) $
  15 // $Author: llucar $
  16 //
  17
  18 /**
  19  * "Engancha" una página dentro de otra.
  20  *
  21  * Esta función busca por un archivo llamado igual que el script php que
  22  * se está ejecutando más un postfijo para incluirlo en la ejecución. De
  23  * no encontrarlo, busca uno llamado default-<posfijo>.php en el
  24  * directorio actual y/o en el include_path del php.
  25  * Por otro lado soporta argumentos variables, que son 'pasados' al hook
  26  * en el array $args. De esta manera se pueden parametrizar los hooks.
  27  *
  28  * @param  string $nombre Nombre del "gancho". Es el nombre del posfijo
  29  *                        que se le agrega al nombre de archivo antes de
  30  *                        buscar.
  31  *
  32  * @return mixed  Devuelve lo mismo que el archivo incluído.
  33  */
  34 function hook( $nombre ) {
  35
  36     // Se pasan todos los argumentos del hook (nótese que de forma similar
  37     // al argv[] del sistema, el primer elemento es el nombre del hook
  38     // siempre).
  39     $args = func_get_args();
  40
  41     list( $dir, $pagina, $extension ) = splitfilename( $_SERVER['SCRIPT_FILENAME'] );
  42     if ( is_readable_include( "$pagina-$nombre.php" ) ) {
  43         return include "$pagina-$nombre.php";
  44     } elseif ( is_readable_include( "default-$nombre.php" ) ) {
  45         return include "default-$nombre.php";
  46     } elseif ( is_readable_include( "includes/hooks/default-$nombre.php" ) ) {
  47         return include "includes/hooks/default-$nombre.php";
  48     }
  49
  50 }
  51
  52 /**
  53  * "Engancha" una página dentro de otra desde un método de un objeto.
  54  *
  55  * Esta función busca por un archivo llamado igual que el script php que
  56  * se está ejecutando más un postfijo para incluirlo en la ejecución. De
  57  * no encontrarlo, busca uno llamado default-<class>-<posfijo>.php en el
  58  * directorio actual y/o en el include_path del php. <class> es la clase
  59  * del objeto o de un objeto padre (obtenido del nombre de la clase según
  60  * las recomendaciones de PEAR <http://pear.php.net/>). Se busca primero
  61  * un hook que coincida con la clase más específica y luego el de las
  62  * clases padre.
  63  * Por otro lado soporta argumentos variables, que son 'pasados' al hook
  64  * en el array $args. De esta manera se pueden parametrizar los hooks.
  65  *
  66  * @param  string $nombre  Nombre del "gancho". Es el nombre del posfijo
  67  *                         que se le agrega al nombre de archivo antes de
  68  *                         buscar.
  69  * @param  object &$objeto Objeto a usar en el hooko.
  70  *
  71  * @return mixed  Devuelve lo mismo que el archivo incluído.
  72  */
  73 function hooko( $nombre, &$objeto ) {
  74
  75     // Se pasan todos los argumentos del hook (nótese que de forma similar
  76     // al argv[] del sistema, el primer elemento es el nombre del hook
  77     // siempre).
  78     $args = func_get_args();
  79
  80     // Obtiene el nombre de la clase y sus padres.
  81     $c = preg_split( '/_/', get_class( $objeto ) );
  82     array_shift( $c ); // Le saca el HE
  83
  84     list( $dir, $pagina, $extension ) = splitfilename( $_SERVER['SCRIPT_FILENAME'] );
  85
  86     // Busca el hook con "herencia" de clases.
  87     foreach( $c as $n => $class ) {
  88
  89         // Genera el nombre de la clase padre del nivel $n.
  90         $class = join( '_', array_slice( $c, 0, $n ? -$n : count( $c ) ) );
  91
  92         if ( is_readable_include( "$pagina-$class-$nombre.php" ) ) {
  93             return include "$pagina-$class-$nombre.php";
  94         } elseif ( is_readable_include( "default-$class-$nombre.php" ) ) {
  95             return include "default-$class-$nombre.php";
  96         } elseif ( is_readable_include( "includes/hooks/default-$class-$nombre.php" ) ) {
  97             return include "includes/hooks/default-$class-$nombre.php";
  98         }
  99
 100     }
 101
 102 }
 103
 104 /**
 105  * "Engancha" una segmento de configuración dentro de una página.
 106  *
 107  * Esta función busca un archivo llamado default-<postfijo> en el include
 108  * path de PHP, luego en el directoro actual, y luego un archivo llamado
 109  * pagina-<postfijo> en el directorio actual. Incluye para su ejecución
 110  * todos los archivos que encuentre.
 111  * De esta manera, las instancias más específicas del hook sobreescriben
 112  * las definiciones hechas en las instancias más genéricas.
 113  * Por otro lado soporta argumentos variables, que son 'pasados' al hook
 114  * en el array $args. De esta manera se pueden parametrizar los hooks.
 115  *
 116  * @param  string $nombre Nombre del "gancho". Es el nombre del posfijo
 117  *                        que se le agrega al nombre de archivo antes de
 118  *                        buscar.
 119  *
 120  * @return array  Devuelve un array_merge() de todos los valores
 121  *                devuletos por los hookc encontrados. Para entender bien
 122  *                qué pasa en cada caso particular (por ejemplo si un
 123  *                hookc devuelve un string y otro un array), hay que
 124  *                tener claro como funciona array_merge().
 125  */
 126 function hookc( $nombre ) {
 127
 128     // Se pasan todos los argumentos del hook (nótese que de forma similar
 129     // al argv[] del sistema, el primer elemento es el nombre del hook
 130     // siempre).
 131     $args = func_get_args();
 132
 133     list( $dir, $pagina, $extension ) = splitfilename( $_SERVER['SCRIPT_FILENAME'] );
 134
 135     $ret = array();
 136     if ( is_readable_include( "includes/hooks/default-$nombre.php" ) )
 137         $ret[] = include "includes/hooks/default-$nombre.php";
 138     if ( is_readable_include( "default-$nombre.php" ) )
 139         $ret[] = include "default-$nombre.php";
 140     if ( is_readable_include( "$pagina-$nombre.php" ) )
 141         $ret[] = include "$pagina-$nombre.php";
 142
 143     // Juntamos todos los valores devueltos. Suponemos que todos
 144     // devuelven un hash. De devolver un valor común, seguramente se
 145     // agregue al hash como un valor mas (solo que la clave será numérica
 146     // y autoincremental).
 147     // NOTA: Si las claves son numéricas, los elementos no reemplazan a
 148     // los anteriores!!! Son agregados y se les cambia la clave por un
 149     // número más alto (todavía no usado en el array).
 150     $r = array();
 151     foreach ( $ret as $array )
 152         array_merge( $r, $array );
 153
 154     return $r;
 155
 156 }
 157
 158 /**
 159  * Hook al estilo dotfile.
 160  *
 161  * Este tipo de hook es muy similar a un hook común, sólo cambia donde se
 162  * lo busca. El directorio de búsqueda se especifica expresamente al
 163  * llamar al hook y no hace un fallback a otros hooks por defecto.
 164  *
 165  * @param  string $nombre Nombre del "gancho". En este caso simplemente se
 166  *                        busca el archivo .$nombre.php ya que los este
 167  *                        tipo de hook es 'directory-wide'.
 168  * @param  string $ruta   Ruta en donde se encuentra el hookd.
 169  *
 170  * @return mixed  Devuelve lo mismo que el archivo incluído.
 171  */
 172 function hookd( $nombre, $ruta = '.' ) {
 173
 174     // Se pasan todos los argumentos del hook (nótese que de forma similar
 175     // al argv[] del sistema, el primer elemento es el nombre del hook
 176     // siempre).
 177     $args = func_get_args();
 178
 179     if ( is_readable( "$ruta/.$nombre.php" ) )
 180         return include "$ruta/.$nombre.php";
 181
 182 }
 183
 184 /**
 185  * Verifica que un hook exista.
 186  *
 187  * @param  string $nombre Nombre del hook a ver si existe.
 188  *
 189  * @return mixed  Devuelve true si existe el hook.
 190  *
 191  * @see hook()
 192  */
 193 function hook_exists( $nombre ) {
 194
 195     $include_path = array_unique( array_merge( preg_split( '/:/', ini_get( 'include_path' ) ), '.' ) );
 196     list( $dir, $pagina, $extension ) = splitfilename( $_SERVER['SCRIPT_FILENAME'] );
 197     foreach ( $include_path as $path )
 198         if ( is_readable_include( "$path/$pagina-$nombre.php" )
 199              or is_readable_include( "$path/default-$nombre.php" )
 200              or is_readable_include( "$path/includes/hooks/default-$nombre.php" ) )
 201             return true;
 202     return false;
 203
 204 }
 205
 206 /**
 207  * Verifica que un hooko exista.
 208  *
 209  * @param  string $nombre  Nombre del hooko a ver si existe.
 210  * @param  object &$objeto Objeto del que se quiere saber si el hooko
 211  *                         existe.
 212  *
 213  * @return mixed  Devuelve true si existe el hooko.
 214  *
 215  * @see hooko()
 216  */
 217 function hooko_exists( $nombre, &$objeto ) {
 218
 219     $include_path = array_unique( array_merge( preg_split( '/:/', ini_get( 'include_path' ) ), '.' ) );
 220     list( $dir, $pagina, $extension ) = splitfilename( $_SERVER['SCRIPT_FILENAME'] );
 221     $c = preg_split( '/_/', get_class( $objeto ) );
 222     array_shift( $c ); // Le saca el HE
 223
 224     // Busca el hooko con "herencia" de clases.
 225     foreach( $c as $n => $class ) {
 226         $class = join( '_', array_slice( $c, 0, $n ? -$n : count( $c ) ) );
 227         foreach ( $include_path as $path )
 228             if ( is_readable_include( "$path/$pagina-$class-$nombre.php" )
 229                  or is_readable_include( "$path/default-$class-$nombre.php" )
 230                  or is_readable_include( "$path/includes/hooks/default-$class-$nombre.php" ) )
 231                 return true;
 232     }
 233
 234     return false;
 235
 236 }
 237
 238 /**
 239  * Verifica que un hookd exista.
 240  *
 241  * @param  string $nombre Nombre del hookd a ver si existe.
 242  * @param  string $ruta   Ruta donde se encuentra el hookd.
 243  *
 244  * @return mixed  Devuelve true si existe el hookd.
 245  *
 246  * @see hookd()
 247  */
 248 function hookd_exists( $nombre, $ruta = '.' ) {
 249
 250     return is_readable( "$ruta/.$nombre.php" );
 251
 252 }
 253
 254 /**
 255  * Divide un archivo devolviendo el nombre y la extensión.
 256  *
 257  * @param  string $nombre Nombre del archivo a dividir.
 258  *
 259  * @return array  Un array cuyo primer elemento es el nombre y el segundo
 260  *                la extensión.
 261  *
 262  * @see hook()
 263  */
 264 function splitfilename( $nombre ) {
 265
 266     $path = preg_split( '|/|', $nombre );
 267     $file = array_pop( $path );
 268     $ext  = '';
 269
 270     if ( strstr( $file, '.' ) ) {
 271         preg_match( '|([^/]+?)(\.([^\.]*))?$|', $file, $m );
 272         $file = $m[1] . ( ( $m[2] == '.' ) ? '.' : '' );
 273         $ext  = $m[3];
 274     }
 275
 276     $dir = count( $path ) ? join( '/', $path ) : '';
 277
 278     return array( $dir, $file, $ext );
 279
 280 }
 281
 282 /**
 283  * Indica si un archivo existe en el include_path y si puede ser leido.
 284  *
 285  * @param  string $nombre Nombre del archivo a buscar.
 286  *
 287  * @return array  Devuelve true si esta en el include path y puede ser
 288  *                leido.
 289  *
 290  * @see hook()
 291  * @see hook_exists()
 292  */
 293 function is_readable_include( $nombre ) {
 294
 295     list( $dir, $pagina, $extension ) = splitfilename( $nombre );
 296     if ( is_readable( $nombre ) )
 297         return true;
 298
 299     $include_path = preg_split( '/:/', ini_get( 'include_path' ) );
 300     foreach ( $include_path as $path )
 301         if ( is_readable( "$path/$nombre" ) )
 302             return true;
 303     return false;
 304
 305 }
 306
 307 // $URL: http://portal.mecon.ar/svn/he/ramas/carga_inicial/src/lib/HE/lib/hooks.php $ $Rev: 116 $ $Date: 2002-10-23 19:09:12 -0300 (mié, 23 oct 2002) $ $Author: llucar $
 308 ?>