Initial Commit

database/php/tests/parseFile/File_Find-1.3.0__Find.php

@@ -0,0 +1,485 @@
+<?php
+//
+// +----------------------------------------------------------------------+
+// | PHP Version 4                                                        |
+// +----------------------------------------------------------------------+
+// | Copyright (c) 1997-2005 The PHP Group                                |
+// +----------------------------------------------------------------------+
+// | This source file is subject to version 2.02 of the PHP license,      |
+// | that is bundled with this package in the file LICENSE, and is        |
+// | available at through the world-wide-web at                           |
+// | http://www.php.net/license/2_02.txt.                                 |
+// | If you did not receive a copy of the PHP license and are unable to   |
+// | obtain it through the world-wide-web, please send a note to          |
+// | license@php.net so we can mail you a copy immediately.               |
+// +----------------------------------------------------------------------+
+// | Author: Sterling Hughes <sterling@php.net>                           |
+// +----------------------------------------------------------------------+
+//
+// $Id: File_Find-1.3.0__Find.php,v 1.1 2008/06/28 13:04:01 farell Exp $
+//
+
+require_once 'PEAR.php';
+
+define('FILE_FIND_VERSION', '@package_version@');
+
+// to debug uncomment this string
+// define('FILE_FIND_DEBUG', '');
+
+/**
+*  Commonly needed functions searching directory trees
+*
+* @access public
+* @version $Id: File_Find-1.3.0__Find.php,v 1.1 2008/06/28 13:04:01 farell Exp $
+* @package File
+* @author Sterling Hughes <sterling@php.net>
+*/
+class File_Find
+{
+    /**
+     * internal dir-list
+     * @var array
+     */
+    var $_dirs = array();
+
+    /**
+     * directory separator
+     * @var string
+     */
+    var $dirsep = "/";
+
+    /**
+     * found files
+     * @var array
+     */
+    var $files = array();
+
+    /**
+     * found dirs
+     * @var array
+     */
+    var $directories = array();
+
+    /**
+     * Search specified directory to find matches for specified pattern
+     *
+     * @param string $pattern a string containing the pattern to search
+     * the directory for.
+     *
+     * @param string $dirpath a string containing the directory path
+     * to search.
+     *
+     * @param string $pattern_type a string containing the type of
+     * pattern matching functions to use (can either be 'php',
+     * 'perl' or 'shell').
+     *
+     * @return array containing all of the files and directories
+     * matching the pattern or null if no matches
+     *
+     * @author Sterling Hughes <sterling@php.net>
+     * @access public
+     * @static
+     */
+    function &glob($pattern, $dirpath, $pattern_type = 'php')
+    {
+        $dh = @opendir($dirpath);
+
+        if (!$dh) {
+            $pe = PEAR::raiseError("Cannot open directory $dirpath");
+            return $pe;
+        }
+
+        $match_function = File_Find::_determineRegex($pattern, $pattern_type);
+        $matches = array();
+
+        // empty string cannot be specified for 'php' and 'perl' pattern
+        if ($pattern || ($pattern_type != 'php' && $pattern_type != 'perl')) {
+            while (false !== ($entry = @readdir($dh))) {
+                if ($match_function($pattern, $entry) &&
+                    $entry != '.' && $entry != '..') {
+                    $matches[] = $entry;
+                }
+            }
+        }
+
+        @closedir($dh);
+
+        if (0 == count($matches)) {
+            $matches = null;
+        }
+
+        return $matches ;
+    }
+
+    /**
+     * Map the directory tree given by the directory_path parameter.
+     *
+     * @param string $directory contains the directory path that you
+     * want to map.
+     *
+     * @return array a two element array, the first element containing a list
+     * of all the directories, the second element containing a list of all the
+     * files.
+     *
+     * @author Sterling Hughes <sterling@php.net>
+     * @access public
+     */
+    function &maptree($directory)
+    {
+
+        /* if called statically */
+        if (!isset($this)  || !is_a($this, "File_Find")) {
+            $obj = &new File_Find();
+            return $obj->maptree($directory);
+        }
+      
+        /* clear the results just in case */
+        $this->files       = array();
+        $this->directories = array();
+
+        /* strip out trailing slashes */
+        $directory = preg_replace('![\\\\/]+$!', '', $directory);
+
+        $this->_dirs = array($directory);
+
+        while (count($this->_dirs)) {
+            $dir = array_pop($this->_dirs);
+            File_Find::_build($dir, $this->dirsep);
+            array_push($this->directories, $dir);
+        }
+
+        $retval = array($this->directories, $this->files);
+        return $retval;
+
+    }
+
+    /**
+     * Map the directory tree given by the directory parameter.
+     *
+     * @param string $directory contains the directory path that you
+     * want to map.
+     * @param integer $maxrecursion maximun number of folders to recursive 
+     * map
+     *
+     * @return array a multidimensional array containing all subdirectories
+     * and their files. For example:
+     *
+     * Array
+     * (
+     *    [0] => file_1.php
+     *    [1] => file_2.php
+     *    [subdirname] => Array
+     *       (
+     *          [0] => file_1.php
+     *       )
+     * )
+     *
+     * @author Mika Tuupola <tuupola@appelsiini.net>
+     * @access public
+     * @static
+     */
+    function &mapTreeMultiple($directory, $maxrecursion = 0, $count = 0)
+    {   
+        $retval = array();
+
+        $count++;
+
+        /* strip trailing slashes */
+        $directory = preg_replace('![\\\\/]+$!', '', $directory);
+        
+        if (is_readable($directory)) {
+            $dh = opendir($directory);
+            while (false !== ($entry = @readdir($dh))) {
+                if ($entry != '.' && $entry != '..') {
+                     array_push($retval, $entry);
+                }
+            }
+            closedir($dh);
+        }
+     
+        while (list($key, $val) = each($retval)) {
+            $path = $directory . "/" . $val;
+      
+            if (!is_array($val) && is_dir($path)) {
+                unset($retval[$key]);
+                if ($maxrecursion == 0 || $count < $maxrecursion) {
+                    $retval[$val] = &File_Find::mapTreeMultiple($path, 
+                                    $maxrecursion, $count);
+                }
+            }
+        }
+
+        return $retval;
+    }
+
+    /**
+     * Search the specified directory tree with the specified pattern.  Return
+     * an array containing all matching files (no directories included).
+     *
+     * @param string $pattern the pattern to match every file with.
+     *
+     * @param string $directory the directory tree to search in.
+     *
+     * @param string $type the type of regular expression support to use, either
+     * 'php', 'perl' or 'shell'.
+     *
+     * @param bool $fullpath whether the regex should be matched against the
+     * full path or only against the filename
+     *
+     * @param string $match can be either 'files', 'dirs' or 'both' to specify
+     * the kind of list to return
+     *
+     * @return array a list of files matching the pattern parameter in the the
+     * directory path specified by the directory parameter
+     *
+     * @author Sterling Hughes <sterling@php.net>
+     * @access public
+     * @static
+     */
+    function &search($pattern, $directory, $type = 'php', $fullpath = true, $match = 'files')
+    {
+
+        $matches = array();
+        list ($directories,$files)  = File_Find::maptree($directory);
+        switch($match) {
+            case 'directories': 
+                $data = $directories; 
+                break;
+            case 'both': 
+                $data = array_merge($directories, $files); 
+                break;
+            case 'files':
+            default:
+                $data = $files;
+        }
+        unset($files, $directories);
+
+        $match_function = File_Find::_determineRegex($pattern, $type);
+
+        reset($data);
+        // check if empty string given (ok for 'shell' method, but bad for others)
+        if ($pattern || ($type != 'php' && $type != 'perl')) {
+            while (list(,$entry) = each($data)) {
+                if ($match_function($pattern, 
+                                    $fullpath ? $entry : basename($entry))) {
+                    $matches[] = $entry;
+                } 
+            }
+        }
+
+        return $matches;
+    }
+
+    /**
+     * Determine whether or not a variable is a PEAR error
+     *
+     * @param object PEAR_Error $var the variable to test.
+     *
+     * @return boolean returns true if the variable is a PEAR error, otherwise
+     * it returns false.
+     * @access public
+     */
+    function isError(&$var)
+    {
+        return PEAR::isError($var);
+    }
+
+    /**
+     * internal function to build singular directory trees, used by
+     * File_Find::maptree()
+     *
+     * @param string $directory name of the directory to read
+     * @param string $separator directory separator
+     * @return void
+     */
+    function _build($directory, $separator = "/")
+    {
+
+        $dh = @opendir($directory);
+
+        if (!$dh) {
+            $pe = PEAR::raiseError("Cannot open directory");
+            return $pe;
+        }
+
+        while (false !== ($entry = @readdir($dh))) {
+            if ($entry != '.' && $entry != '..') {
+
+                $entry = $directory.$separator.$entry;
+
+                if (is_dir($entry)) {
+                    array_push($this->_dirs, $entry);
+                } else {
+                    array_push($this->files, $entry);
+                }
+            }
+        }
+
+        @closedir($dh);
+    }
+
+    /**
+     * internal function to determine the type of regular expression to
+     * use, implemented by File_Find::glob() and File_Find::search()
+     *
+     * @param string $type given RegExp type
+     * @return string kind of function ( "eregi", "ereg" or "preg_match") ;
+     *
+     */
+    function _determineRegex($pattern, $type)
+    {
+        if (!strcasecmp($type, 'shell')) {
+            $match_function = 'File_Find_match_shell';
+        } else if (!strcasecmp($type, 'perl')) {
+            $match_function = 'preg_match';
+        } else if (!strcasecmp(substr($pattern, -2), '/i')) {
+            $match_function = 'eregi';
+        } else {
+            $match_function = 'ereg';
+        }
+        return $match_function;
+    }
+
+}
+
+/**
+* Package method to match via 'shell' pattern. Provided in global
+* scope, because it should be called like 'preg_match' and 'eregi'
+* and can be easily copied into other packages
+*
+* @author techtonik <techtonik@php.net>
+* @return mixed bool on success and PEAR_Error on failure
+*/ 
+function File_Find_match_shell($pattern, $filename)
+{
+    // {{{ convert pattern to positive and negative regexps
+        $positive = $pattern;
+        $negation = substr_count($pattern, "|");
+
+        if ($negation > 1) {
+            PEAR::raiseError("Mask string contains errors!");
+            return FALSE;
+        } elseif ($negation) {
+            list($positive, $negative) = explode("|", $pattern);
+            if (strlen($negative) == 0) {
+                PEAR::raiseError("File-mask string contains errors!");
+                return FALSE;
+            }
+        }
+
+       $positive = _File_Find_match_shell_get_pattern($positive);
+       if ($negation) {
+           $negative = _File_Find_match_shell_get_pattern($negative);
+       }
+    // }}} convert end 
+
+
+    if (defined("FILE_FIND_DEBUG")) {
+        print("Method: $type\nPattern: $pattern\n Converted pattern:");
+        print_r($positive);
+        if (isset($negative)) print_r($negative);
+    }
+
+    if (!preg_match($positive, $filename)) {
+        return FALSE;
+    } else {
+        if (isset($negative) 
+              && preg_match($negative, $filename)) {
+            return FALSE;
+        } else {
+            return TRUE;
+        }
+    }
+}
+
+/**
+* function used by File_Find_match_shell to convert 'shell' mask
+* into pcre regexp. Some of the rules (see testcases for more): 
+*  escaping all special chars and replacing 
+*    . with \.
+*    * with .*
+*    ? with .{1}
+*    also adding ^ and $ as the pattern matches whole filename
+*
+* @author techtonik <techtonik@php.net>
+* @return string pcre regexp for preg_match
+*/ 
+function _File_Find_match_shell_get_pattern($mask) {
+    // get array of several masks (if any) delimited by comma
+    // do not touch commas in char class
+    $premasks = preg_split("|(\[[^\]]+\])|", $mask, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY );
+    if (defined("FILE_FIND_DEBUG")) {
+        print("\nPremask: ");
+        print_r($premasks);
+    }
+    $pi = 0;
+    foreach($premasks as $pm) {
+        if (!isset($masks[$pi])) $masks[$pi] = "";
+        if ($pm{0} == '[' && $pm{strlen($pm)-1} == ']') {
+            // strip commas from character class
+            $masks[$pi] .= str_replace(",", "", $pm);
+        } else {
+            $tarr = explode(",", $pm);
+            if (sizeof($tarr) == 1) {
+                $masks[$pi] .= $pm;
+            } else {
+                foreach ($tarr as $te) {
+                    $masks[$pi++] .= $te;
+                    $masks[$pi] = "";
+                }
+                unset($masks[$pi--]);
+            }
+        }
+    }
+
+    // if empty string given return *.* pattern
+    if (strlen($mask) == 0) return "!^.*$!";
+
+    // convert to preg regexp
+    $regexmask = implode("|", $masks);
+    if (defined("FILE_FIND_DEBUG")) {
+        print("regexMask step one(implode): $regexmask");
+    }
+    $regexmask = addcslashes($regexmask, '^$}!{)(\/.+');
+    if (defined("FILE_FIND_DEBUG")) {
+        print("\nregexMask step two(addcslashes): $regexmask");
+    }
+    $regexmask = preg_replace("!(\*|\?)!", ".$1", $regexmask);
+    if (defined("FILE_FIND_DEBUG")) {
+        print("\nregexMask step three(* ? -> .* .?): $regexmask");
+    }
+    // a special case '*.' at the end means that there is no extension
+    $regexmask = preg_replace("!\.\*\\\.(\||$)!", "[^\.]*$1", $regexmask);
+    // it is impossible to have dot at the end of filename
+    $regexmask = preg_replace("!\\\.(\||$)!", "$1", $regexmask);
+    // and .* at the end also means that there could be nothing at all
+    //   (i.e. no dot at the end also)
+    $regexmask = preg_replace("!\\\.\.\*(\||$)!", "(\\\\..*)?$1", $regexmask);
+    if (defined("FILE_FIND_DEBUG")) {
+        print("\nregexMask step two and half(*.$ \\..*$ .$ -> [^.]*$ .?.* $): $regexmask");
+    }
+    // if no extension supplied - add .* to match partially from filename start
+    if (strpos($regexmask, "\\.") === FALSE) $regexmask .= ".*";
+
+    // file mask match whole name - adding restrictions
+    $regexmask = preg_replace("!(\|)!", '^'."$1".'$', $regexmask);
+    $regexmask = '^'.$regexmask.'$';
+    if (defined("FILE_FIND_DEBUG")) {
+        print("\nregexMask step three(^ and $ to match whole name): $regexmask");
+    }
+    // wrap regex into ! since all ! are already escaped
+    $regexmask = "!$regexmask!i";
+    if (defined("FILE_FIND_DEBUG")) {
+        print("\nWrapped regex: $regexmask\n");
+    }
+    return $regexmask;
+}
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */
+
+?>

database/php/tests/parseFile/conditional.php

@@ -0,0 +1,38 @@
+<?php
+// PHP 4.0.0 : __FILE__
+// PHP 4.0.6 : DIRECTORY_SEPARATOR
+// PHP 4.0.7 : version compare
+// PHP 4.3.0 : ob_get_clean
+// PHP 4.3.0 : debug_backtrace
+// PHP 4.3.10 and 5.0.2 : PHP_EOL
+// PHP 5.0.0 : simplexml_load_file
+
+if (!defined('DIRECTORY_SEPARATOR')) {
+    define('DIRECTORY_SEPARATOR',
+        strtoupper(substr(PHP_OS, 0, 3) == 'WIN') ? '\\' : '/'
+    );
+}
+
+if (function_exists('debug_backtrace')) {
+    $backtrace = debug_backtrace();
+} else {
+    $backtrace = false;
+}
+
+if (function_exists('simplexml_load_file')) {
+    $xml = simplexml_load_file('C:\php\pear\PHP_CompatInfo\scripts\version.xml');
+}
+
+if (version_compare(phpversion(), '5.0.0', '<')) {
+    include_once 'PHP/Compat.php';
+    PHP_Compat::loadFunction('ob_get_clean');
+    PHP_Compat::loadConstant('PHP_EOL');
+}
+
+echo "Hello World" . PHP_EOL;
+
+$ds  = DIRECTORY_SEPARATOR;
+$fn  = dirname(__FILE__) . $ds . basename(__FILE__);
+echo "You have run file : $fn at " . date(DATE_W3C) . PHP_EOL;
+
+?>

database/php/tests/parseFile/empty.php

@@ -0,0 +1 @@
+

database/php/tests/parseFile/ignore_functions_match.php

@@ -0,0 +1,20 @@
+<?php
+function toFile($filename, $data)
+{
+    if (function_exists('file_put_contents')) {
+        file_put_contents($filename, $data);
+    } else {
+        $file = fopen($filename, 'wb');
+        fwrite($file, $data);
+        fclose($file);
+    }
+}
+
+if (function_exists('debug_backtrace')) {
+    $backtrace = debug_backtrace();
+} else {
+    $backtrace = false;
+}
+
+debug_print_backtrace();
+?>

database/php/tests/parseFile/math.php

@@ -0,0 +1,6 @@
+<?php
+$nb = bcsub(1.234, 5, 4);
+if (preg_match('/^-/', $nb)) {
+    echo 'minus';
+}
+?>

database/php/tests/parseFile/php5_method_chaining.php

@@ -0,0 +1,39 @@
+<?php
+/**
+ * This Person class encapsulates a couple of properties which
+ * a person might have: their name and age.
+ * We also give the Person the opportunity to introduce themselves.
+ *
+ * @link http://cowburn.info/php/php5-method-chaining/
+ */
+class Person
+{
+    var $m_szName;
+    var $m_iAge;
+
+    function setName($szName)
+    {
+        $this->m_szName = $szName;
+        return $this; // We now return $this (the Person)
+    }
+
+    function setAge($iAge)
+    {
+        $this->m_iAge = $iAge;
+        return $this; // Again, return our Person
+    }
+
+    function introduce()
+    {
+        printf('Hello my name is %s and I am %d years old.',
+            $this->m_szName,
+            $this->m_iAge);
+    }
+}
+
+// We'll be creating me, digitally.
+$peter = new Person();
+// Let's set some attributes and let me introduce myself,
+// all in one line of code.
+$peter->setName('Peter')->setAge(23)->introduce();
+?>

database/php/tests/parseFile/php5_method_chaining_samp2.php

@@ -0,0 +1,26 @@
+<?php
+/**
+ * Another example of PHP method chaining
+ *
+ * @link http://sebastian-bergmann.de/archives/738-Support-for-BDD-and-Stories-in-PHPUnit-3.3.html
+ */
+
+require_once 'PHPUnit/Extensions/Story/TestCase.php';
+
+require_once 'BowlingGame.php';
+
+class BowlingGameSpec extends PHPUnit_Extensions_Story_TestCase
+{
+    /**
+     * @scenario
+     */
+    function scoreForOneSpareIs16()
+    {
+        $this->given('New game')
+             ->when('Player rolls', 5)
+             ->and('Player rolls', 5)
+             ->and('Player rolls', 3)
+             ->then('Score should be', 16);
+    }
+}
+?>

database/php/tests/parseFile/phpweb-entities.php

@@ -0,0 +1,64 @@
+<?php
+/*
+  +----------------------------------------------------------------------+
+  | PHP Version 4                                                        |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 1997-2008 The PHP Group                                |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.0 of the PHP license,       |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_0.txt.                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Authors:    Gabor Hojtsy <goba@php.net>                              |
+  +----------------------------------------------------------------------+
+
+  $Id: phpweb-entities.php,v 1.1 2008/02/02 15:09:40 farell Exp $
+*/
+
+set_time_limit(0);
+
+// Too few or too many parameters
+if ($argc != 3) { die("ERROR in " . __FILE__ . ": Too few or too many parameters"); }
+
+// Workdir is the first param
+$workdir = $argv[1];
+
+// Whether we are in phpweb mode
+$phpweb_mode = ($argv[2] == "phpweb");
+
+// Entity file for phpweb entities
+$phpweb_ent = "$workdir/entities/phpweb.ent";
+
+// Automatically generated file note
+$autonote = "<!-- This file is autogenerated - don't touch it by hand! -->\n";
+
+// Replace current phpweb.ent with a 0 byte file
+if (!$phpweb_mode) {
+    $pe = fopen($phpweb_ent, "w");
+    fwrite($pe, $autonote);
+    fclose($pe);
+    echo "$phpweb_ent should be empty now...\n";
+    exit;
+}
+
+echo "creating $phpweb_ent...\n";
+
+// Read in global.ent from the source dir
+$lines = file("@SRCDIR@/entities/global.ent");
+
+// Collect all phpweb entities
+$phpweb_entities = array($autonote);
+foreach ($lines as $line) {
+    if (strpos($line, "http://www.php.net") !== FALSE) {
+        $phpweb_entities[] = str_replace("http://www.php.net", "", $line);
+    }
+}
+
+// Write out entity file
+$pe = fopen($phpweb_ent, "w");
+fwrite($pe, join("", $phpweb_entities));
+fclose($pe);

database/php/tests/parseFile/zip.php

@@ -0,0 +1,13 @@
+<?php
+$zip = zip_open("/tmp/test2.zip");
+
+if ($zip) {
+    while ($zip_entry = zip_read($zip)) {
+        echo "Name:               " . zip_entry_name($zip_entry) . "\n";
+        echo "Actual Filesize:    " . zip_entry_filesize($zip_entry) . "\n";
+        echo "Compressed Size:    " . zip_entry_compressedsize($zip_entry) . "\n";
+        echo "Compression Method: " . zip_entry_compressionmethod($zip_entry) . "\n";
+    }
+    zip_close($zip);
+}
+?>