Personalmente, no terminan de convencerme estos componentes, es como si me sintiera "atado" con ellos, aunque, probablemente me equivoque al desestimarlos sin más. De hecho no es mi intención, sólo que cuando pienso en jQuery me digo a mí mismo que es de lo mejor que hay para trabajar con Javascript, mientras que jQuery UI no acaba de convencerme.

Tal vez es que no sirvan para todo tipo de aplicaciones, aunque, si sirven, si encajan en el diseño que tenemos pensado, entonces evidentemente pueden ahorrarnos mucho trabajo este tipo de componentes. Hay que decir, por otro lado, que jQuery UI no sólo se trata de componentes "de alto nivel", sino que algunas otras características se encuentran ahí y no en jQuery.

Por ejemplo, lo que se refiere a conseguir elementos "sortables", "droppables", "draggables", "resizables", etc., así como todo tipo de efectos, no se encuentran disponibles en jQuery, sino en jQuery UI. Lo bueno, en cualquier caso, es que la descarga de esta última puede personalizarse, de modo que podemos obtener todo lo dicho, prescindiendo de los componentes "visuales". Pero, ya me he enrrollado demasiado. Echa un vistazo a las nuevas "demos", verás qué chulas son. ;)

Es una pena que no tengamos a nuestra disposición velocidades "de subida" que nos permitieran compartir con la misma rapidez utilizando otros servicios y protocolos, como pueda ser el, por otro lado, nada desdeñable Torrent. Lo que ofrece Rapidshare es precisamente eso: rapidez, puesto que se aprovecha al cien por cien nuestra conexión a Internet, como digo, contar con la película que queremos ver, es cuestión de minutos. Se me dirá que no todo el cine está disponible en Rapidshare, que no se encontrará de todo, sin embargo, reto a quien quiera a que busque en Google la película que mejor le parezca, por su título, como he dicho antes, añadiendo la palabra "Rapidshare" justo a continuación. Raro será que no encuentre lo que quiere.

Que no se pueda utilizar algo distinto a Rapidshare tiene varios inconvenientes, empezando porque para alcanzar las velocidades mencionadas, es necesario pagar un precio, lo que cuesta una sucripción "Premium" a Rapidshare, que, por supuesto, hay que sumar a la tarifa que pagamos por conectarnos a Internet. Y, sin embargo, es posible que el precio en conjunto sea inferior que el que pagaríamos por contar con una televisión a la carta "tradicional". No sólo es más barato, probablemente, sino que no podrá compararse nunca la cantidad de películas que encontraremos en la televisión a la carta tradicional, con la cantidad y calidad que nos encontraremos en Internet. Nótese que no estoy hablando de elegir una película "de pago" entre una docena de "estrenos".

Estamos hablando de conseguir la película que quieres ver, a elegir el universo de cine disponible en Internet. Más aún, últimamente (y de ahí esta entrada) se trata de elegir la película que quieres ver: que en un alto por ciento de ocasiones estará disponible para nosotros. No se trata, pues, ni siquiera de elegir una película entre un amplio catálogo de ellas, lo que tampoco está nada mal, pero de elegir la película que están dando en la tele (pero que quieres ver en el ordenador) o una sobre la que te han hablado hace poco, o de la que acabas de enterarte: muy probablemente podrás obtenerla y podrás verla a los pocos minutos de haberlo decidido. ¿Hay algo más parecido a una supuesta televisión a la carta? Tal vez que en lugar de minutos fuesen segundos.

Tan sólo una cosa me preocupa, aunque ya la he dicho: el hecho de que no sea posible lo mismo utilizando otros medios como el P2P, el intercambio directo entre distintas personas, culpa sin duda de la velocidad de subida limitada conque se cuenta en España, algo que tal vez pueda generalizarse también a otros países. Bueno, claro, me preocupa que esto sea así porque el pago de Rapidshare y servicios similares implica una barrera que no todo el mundo estará dispuesta a pasar, si es que puede hacerlo. Sólo que al ponerme a pensar en estas barreras me siento una especie de burgués de cinco euros, porque, ¿acaso no existe ya una barrera infinitivamente mayor? ¿Cuándo será Internet accesible a todo el mundo? Pero para qué seguir.

En realidad no es ningún "truco", sino que, como este juego permite "guardar las partidas", otros usuarios pueden haber llegado al final del juego, haber guardado la partida en ese momento, y compartir después el archivo correspondiente, que nosotros podremos situar en "Mis Documentos", en la carpeta de "GTA San Andreas", donde se encuentran los archivos de nuestras "partidas guardadas". En efecto, he encontrado este hilo en Taringa!, donde un usuario comparte varios archivos de "partidas guardadas".

Basta con descargar uno de los archivos que ahí se ofrecen, por ejemplo, el último de ellos, que corresponde con una partida guardada después de haberse pasado el juego completamente. De este modo, estaremos en disposición de recorrer todo el escenario del juego (¡realmente grande!), contaremoso con un montón de vehículos como helicópteros e hidroaviones que sólo se encuentran en determinados sitios (a los que tendremos acceso) en definitiva, podremos pasar completamente de las misiones del juego, si es que lo que nos interesa es tener a nuestra disposición todo el escenario para recorrerlo a gusto.

Y eso es todo. Es cierto que le quitas un poco de "salsa" al juego, pero, lo cierto es que puedes jugar partidas "con todo el escenario", para divertirte, y también jugar partidas en las que trates de superar las misiones de marras. Vamos, como suele decirse, que una cosa no quita la otra. ;)

Actualización: Por si tienes problemas para acceder al archivo de la "partida guardada" siguiendo el enlace que he puesto más arriba, o, simplemente, para tener otra posibilidad, sigue este enlace, para descargar la partida guardada "con todo el juego pasado". De nada. ;)

Lo encontré anoche en la bitácora de un gato nipón.

Pues bien, el caso es que, aprovechando la función "token_get_all()", y, sobre todo, los identificadores o "tokens" disponibles, he escrito una sencilla clase que puede ofrecer no poca información acerca de un archivo PHP, o, si se prefiere, de todos los archivos PHP de un determinado directorio, y, opcionalmente, también los subdirectorios de este. La clase en cuestión, que, he dado en llamar "PStats", por "PHP Stats", pero, también por "Project stats", es muy sencilla de utilizar, y, como digo, proporciona no poca información.

Concretamente, además del número de líneas de todos los archivos PHP "encontrados", puede consultarse a la clase por el número de un identificador o "token" PHP en concreto. Por ejemplo, es posible conocer cuántos "Ifs" hay en el archivo o archivos PHP, cuántos "whiles", cuántos "foearch", cuántos "espacios", cuántas "cadenas", cuántos "enteros", cuántos "decimales",... y un largo etcétera, y aquí me remito de nuevo a la lista completa de "tokens" disponibles. Por ejemplo, puedo ofrecerte información sobre Gesbit, sobre los archivos PHP que lo componen:

Los datos que refiero arriba son todos los que son, pero, no todos los que pueden conseguirse, pues la lista de "tokens" contiene más aún, pero, me he limitado a poner unos cuantos aquí, a modo de ejemplo de la información que puede conseguirse a través de la clase "PStats" de una forma muy sencilla. Ahora, si continuas leyendo, podrás ver cómo utilizar la clase y obtener el propio código de la misma, por si te interesa jugar un poco con ella y algún proyecto tuyo.

Cómo usar la clase "PStats"

La clase "PStats" está escrita en PHP 5, aunque, con pocos retoques también funcionará con PHP 4, me parece. Por otro lado, creo que en todo caso puede "analizar" código PHP 4. El uso de la clase es muy sencillo. Luego de requerirla convenientemente, para analizar un archivo PHP podemos codificar algo así:

$pstats = new PStats();
$pstats->GetPhpFileStat('ruta-archivo.php');

Una vez hayamos hecho eso, será posible llamar al resto de métodos de la clase: hablo de los tres métodos públicos principales, que son "GetTotalFiles()" (en este caso retornará 1), "GetTotalLines()", y, principalmente, el método "GetStatValue()". Este método requiere un argumento, precisamente, una constante que especifique un "token" de PHP. Aquí un par de ejemplos:

printf('Fors: %s, ', $pstats->GetStatValue(T_FOR));
printf('Whiles: %s, ', $pstats->GetStatValue(T_WHILE));

Con este mismo método pueden obtenerse el resto de estadísticas, sólo cambiando la constante que pasamos a "GetStatValue" como argumento, y que, repito, se corresponde con un "token" de PHP, de los listados en el manual. Y, realmente ya está dicho todo, excepto que también podemos obtener estadísticas de varios archivos PHP, de todos los que se encuentren en un directorio:

$pstats = new PStats();
$pstats->GetDirectoryStats('/ruta-directorio', false);

E incluso dentro de los subdirectorios de un directorio en concreto:

$pstats = new PStats();
$pstats->GetDirectoryStats('/ruta-directorio', true);
 
// También podría escribirse así, sin más
// $pstats->GetDirectoryStats('/ruta-directorio');

En estos últimos casos, cuando después ejecutemos el método "GetStatValue", obtendremos el número de "whiles" (por ejempo) que se encuentren en todos los archivos PHP "analizados". Y, bueno. Ahora sí creo que eso es todo. Tampoco es que quepa decir mucho más, sólo que el uso de esta clase (o algo parecido) puede resultar curioso, por ejemplo, al ver las cifras de Gesbit, pues chico, resulta curioso. No van a ningún lado, ¿pero a que son curiosas? :D

Sin más dilación, este es el código fuente de la clase "PStats". Supongo que no tendrás problema en copiarlo en un archivo y a partir de ahí trabajar con la clase tal como he referido arriba. Que lo pases bien. Y si te resulta curioso a ti también y quieres, deja algún comentario al respecto, que se agradece. ;)

class PStats
{
  private $phpStats;
  private $phpFiles;
 
  const PHP_FILE_EXT = '.php';
  const T_TOTAL_LINES = 'lines';
 
  public function __construct(){
    $this->Initialize();
  }
 
  public function GetPhpFileStat($filePath){
    $this->Initialize();
    if($this->IsValidPhpFile($filePath)){
      $this->phpStats[$filePath] =
       $this->GetPhpFileStats($filePath);
      return true;
    }else{
      return false;
    }
  }
 
  public function GetDirectoryStats(
   $rootDir, $inSubdirs = true){
     $this->Initialize();
     $phpFiles = $this->GetPhpFilePaths(
       $rootDir,
       $inSubdirs
     );
     foreach($phpFiles as $filePath){
       $this->phpStats[$filePath] =
        $this->GetPhpFileStats($filePath);
     }
     return true;
  }
 
  public function GetTotalFiles(){
    return count($this->phpStats);
  }
 
  public function GetTotalLines(){
    $lines = 0;
    foreach($this->phpStats as $stat){
      if(isset($stat[self::T_TOTAL_LINES])){
        $lines += $stat[self::T_TOTAL_LINES];
      }
    }
    return $lines;
  }
 
  public function GetStatValue($tokenConst){
    $value = 0;
    foreach($this->phpStats as $stat){
      if(isset($stat[$tokenConst])){
        $value += $stat[$tokenConst];
      }
    }
    return $value;
  }
 
  private function Initialize(){
    $this->phpStats = array();
    $this->phpFiles = array();
  }
 
  private function IncrementFileStat(
   &$fileStats, $name){
     if(isset($fileStats[$name])){
       $fileStats[$name]++;
     }else{
       $fileStats[$name] = 1;
     }
     return true;
  }
 
  private function GetPhpFileStats($filePath){
    $fileStats = array();
    $phpSource = file_get_contents($filePath);
    $phpTokens = token_get_all($phpSource);
    foreach($phpTokens as $token){
      $this->IncrementFileStat(
        $fileStats,
        (string)$token[0]
      );
    }
    $totalLines = explode(
     PHP_EOL, $phpSource);
    $fileStats[self::T_TOTAL_LINES]
      = count($totalLines);
    return $fileStats;
  }
 
  private function IsValidPhpFile($filePath){
    return is_file($filePath) && is_readable($filePath)
     && (strpos($filePath, self::PHP_FILE_EXT) !== false);
  }
 
  private function GetPhpFilePaths(
   $dirPath, $inSubdirs){
     try{
       $dir = new DirectoryIterator($dirPath);
       foreach($dir as $file){
         if(!$file->isDot()
          && $file->isDir() && $inSubdirs){
            $this->GetPhpFilePaths(
              $file->getPathname(),
              $inSubdirs
            );
         }elseif($this->IsValidPhpFile(
          $file->getPathname())){
            $this->phpFiles[] =
             $file->getPathname();
         }
       }
     }catch(Exception $e){
       throw $e;
     }
     return $this->phpFiles;
  }
}