phpDocumentor
[ class tree: phpDocumentor ] [ index: phpDocumentor ] [ all elements ]

Source for file Io.inc

Documentation is available at Io.inc

  1. <?php
  2. /**
  3.  * File and input handling routines
  4.  * 
  5.  * This class parses command-line options, and works with files to
  6.  * generate lists of files to parse based on the ignore/include options
  7.  * 
  8.  * phpDocumentor :: automatic documentation generator
  9.  * 
  10.  * PHP versions 4 and 5
  11.  *
  12.  * Copyright (c) 2000-2006 Joshua Eichorn, Gregory Beaver
  13.  * 
  14.  * LICENSE:
  15.  * 
  16.  * This library is free software; you can redistribute it
  17.  * and/or modify it under the terms of the GNU Lesser General
  18.  * Public License as published by the Free Software Foundation;
  19.  * either version 2.1 of the License, or (at your option) any
  20.  * later version.
  21.  * 
  22.  * This library is distributed in the hope that it will be useful,
  23.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  25.  * Lesser General Public License for more details.
  26.  * 
  27.  * You should have received a copy of the GNU Lesser General Public
  28.  * License along with this library; if not, write to the Free Software
  29.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  30.  *
  31.  * @package    phpDocumentor
  32.  * @author     Joshua Eichorn <jeichorn@phpdoc.org>
  33.  * @author     Gregory Beaver <cellog@php.net>
  34.  * @copyright  2000-2006 Joshua Eichorn, Gregory Beaver
  35.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  36.  * @version    CVS: $Id$
  37.  * @filesource
  38.  * @link       http://www.phpdoc.org
  39.  * @link       http://pear.php.net/PhpDocumentor
  40.  * @since      0.1
  41.  */
  42. /**
  43.  * Class to handle file and user io opperations
  44.  *
  45.  * @author    Joshua Eichorn <jeichorn@phpdoc.org>
  46.  * @author     Gregory Beaver <cellog@php.net>
  47.  * @version    $Id$
  48.  * @package     phpDocumentor
  49.  */
  50. class Io 
  51. {
  52.     
  53.     /**
  54.      * Holds all the options that are avaible to the cmd line interface
  55.      * and to the different web interfaces
  56.      */
  57.     var $phpDocOptions;
  58.     /**
  59.      * Format: array(array(regexp-ready string to search for whole path,
  60.      * regexp-ready string to search for basename of ignore strings),...)
  61.      * @var false|array
  62.      */
  63.     var $ignore;
  64.     /**
  65.      * A specific array of values that boolean-based arguments can understand,
  66.      * aided by the {@link decideOnOrOff()} helper method.
  67.      * 
  68.      * Use lowercase letters always, to simplify string comparisons
  69.      * @var array 
  70.      */
  71.     var $valid_booleans = array
  72.     (
  73.         ''' ''on''y''yes''true''1'
  74.         'off''n''no''false''0'
  75.  
  76.     );
  77.     
  78.     /**
  79.      * creates an array $this->phpDocOptions and sets program options in it.
  80.      * Array is in the format of:
  81.      * <pre>
  82.      * [filename][tag][] = "f";
  83.      * [filename][tag][] = "-file";
  84.      * [filename][desc] "name of file to parse"
  85.      * </pre>
  86.      */
  87.     function Io()
  88.     {
  89.         $this->phpDocOptions['filename']['tag'= array"-f""--filename");
  90.         $this->phpDocOptions['filename']['desc'"name of file(s) to parse ',' file1,file2.  Can contain complete path and * ? wildcards";
  91.         $this->phpDocOptions['filename']['type'"path";
  92.  
  93.         $this->phpDocOptions['directory']['tag'= array"-d""--directory");
  94.         $this->phpDocOptions['directory']['desc'"name of a directory(s) to parse directory1,directory2";
  95.         $this->phpDocOptions['directory']['type'"path";
  96.  
  97.         $this->phpDocOptions['examplesdir']['tag'= array"-ed""--examplesdir");
  98.         $this->phpDocOptions['examplesdir']['desc'"full path of the directory to look for example files from @example tags";
  99.         $this->phpDocOptions['examplesdir']['type'"path";
  100.  
  101.         $this->phpDocOptions['templatebase']['tag'= array"-tb""--templatebase");
  102.         $this->phpDocOptions['templatebase']['desc'"base location of all templates for this parse.";
  103.         $this->phpDocOptions['templatebase']['type'"path";
  104.  
  105.         $this->phpDocOptions['target']['tag'= array("-t""--target");
  106.         $this->phpDocOptions['target']['desc'"path where to save the generated files";
  107.         $this->phpDocOptions['target']['type'"path";
  108.         
  109.         $this->phpDocOptions['ignore']['tag'= array("-i""--ignore");
  110.         $this->phpDocOptions['ignore']['desc'"file(s) that will be ignored, multiple separated by ','.  Wildcards * and ? are ok";
  111.         $this->phpDocOptions['ignore']['type'"path";
  112.  
  113.         $this->phpDocOptions['ignoresymlinks']['tag'= array("-is""--ignoresymlinks");
  114.         $this->phpDocOptions['ignoresymlinks']['desc'"ignore symlinks to other files or directories, default is off";
  115.         $this->phpDocOptions['ignoresymlinks']['type'"set";
  116.         $this->phpDocOptions['ignoresymlinks']['validvalues'$this->valid_booleans;
  117.  
  118.         $this->phpDocOptions['ignoretags']['tag'= array("-it""--ignore-tags");
  119.         $this->phpDocOptions['ignoretags']['desc'"tags to ignore for this parse.  @package, @subpackage, @access and @ignore may not be ignored.";
  120.         $this->phpDocOptions['ignoretags']['type'"value";
  121.  
  122.         $this->phpDocOptions['hidden']['tag'= array("-dh""--hidden");
  123.         $this->phpDocOptions['hidden']['desc'"set equal to on (-dh on) to descend into hidden directories (directories starting with '.'), default is off";
  124.         $this->phpDocOptions['hidden']['type'"set";
  125.         $this->phpDocOptions['hidden']['validvalues'$this->valid_booleans;
  126.  
  127.         $this->phpDocOptions['quiet']['tag'= array("-q""--quiet");
  128.         $this->phpDocOptions['quiet']['desc'"do not display parsing/conversion messages.  Useful for cron jobs on/off default off";
  129.         $this->phpDocOptions['quiet']['type'"set";
  130.         $this->phpDocOptions['quiet']['validvalues'$this->valid_booleans;
  131.  
  132.         $this->phpDocOptions['undocumentedelements']['tag'= array("-ue""--undocumentedelements");
  133.         $this->phpDocOptions['undocumentedelements']['desc'"Control whether or not warnings will be shown for undocumented elements. Useful for identifying classes and methods that haven't yet been documented on/off default off";
  134.         $this->phpDocOptions['undocumentedelements']['type'"set";
  135.         $this->phpDocOptions['undocumentedelements']['validvalues'$this->valid_booleans;
  136.  
  137.         $this->phpDocOptions['title']['tag'= array("-ti","--title");
  138.         $this->phpDocOptions['title']['desc'"title of generated documentation, default is 'Generated Documentation'";
  139.         $this->phpDocOptions['title']['type'"value";
  140.  
  141.         $this->phpDocOptions['charset']['tag'= array("-cs""--charset");
  142.         $this->phpDocOptions['charset']['desc'"character encoding used in the Content-Type meta element or the XML declaration, default is 'iso-8859-1'";
  143.         $this->phpDocOptions['charset']['type'"value";
  144.  
  145.         $this->phpDocOptions['help']['tag'= array("-h""--help");
  146.         $this->phpDocOptions['help']['desc'"    show this help message";
  147.  
  148.         $this->phpDocOptions['useconfig']['tag'= array("-c","--useconfig");
  149.         $this->phpDocOptions['useconfig']['desc'"Use a Config file in the users/ subdirectory for all command-line options";
  150.         $this->phpDocOptions['useconfig']['type'"value";
  151.  
  152.         $this->phpDocOptions['parseprivate']['tag'= array("-pp","--parseprivate");
  153.         $this->phpDocOptions['parseprivate']['desc'"parse @internal and elements marked private with @access.  Use on/off, default off";
  154.         $this->phpDocOptions['parseprivate']['type'"set";
  155.         $this->phpDocOptions['parseprivate']['validvalues'= array('on''off');
  156.  
  157.         $this->phpDocOptions['packageoutput']['tag'= array("-po","--packageoutput");
  158.         $this->phpDocOptions['packageoutput']['desc'"output documentation only for selected packages.  Use a comma-delimited list";
  159.         $this->phpDocOptions['packageoutput']['type'"value";
  160.  
  161.         $this->phpDocOptions['defaultpackagename']['tag'= array("-dn","--defaultpackagename");
  162.         $this->phpDocOptions['defaultpackagename']['desc'"name to use for the default package.  If not specified, uses 'default'";
  163.         $this->phpDocOptions['defaultpackagename']['type'"value";
  164.  
  165.         $this->phpDocOptions['defaultcategoryname']['tag'= array("-dc","--defaultcategoryname");
  166.         $this->phpDocOptions['defaultcategoryname']['desc'"name to use for the default category.  If not specified, uses 'default'";
  167.         $this->phpDocOptions['defaultcategoryname']['type'"value";
  168.  
  169.         $this->phpDocOptions['output']['tag'= array("-o","--output");
  170.         $this->phpDocOptions['output']['desc'"output information to use separated by ','.  Format: output:converter:templatedir like \"HTML:frames:phpedit\"";
  171.         $this->phpDocOptions['output']['type'"value";
  172.  
  173.         $this->phpDocOptions['converterparams']['tag'= array("-cp","--converterparams");
  174.         $this->phpDocOptions['converterparams']['desc'"dynamic parameters for a converter, separate values with commas";
  175.         $this->phpDocOptions['converterparams']['type'"value";
  176.  
  177.         $this->phpDocOptions['customtags']['tag'= array("-ct","--customtags");
  178.         $this->phpDocOptions['customtags']['desc'"custom tags, will be recognized and put in tags[] instead of unknowntags[]";
  179.         $this->phpDocOptions['customtags']['type'"value";
  180.  
  181.         $this->phpDocOptions['sourcecode']['tag'= array("-s","--sourcecode");
  182.         $this->phpDocOptions['sourcecode']['desc'"generate highlighted sourcecode for every parsed file (PHP 4.3.0+ only) on/off default off";
  183.         $this->phpDocOptions['sourcecode']['type'"set";
  184.         $this->phpDocOptions['sourcecode']['validvalues'= array('on''off');
  185.  
  186.         $this->phpDocOptions['javadocdesc']['tag'= array("-j","--javadocdesc");
  187.         $this->phpDocOptions['javadocdesc']['desc'"JavaDoc-compliant description parsing.  Use on/off, default off (more flexibility)";
  188.         $this->phpDocOptions['javadocdesc']['type'"set";
  189.         $this->phpDocOptions['javadocdesc']['validvalues'= array('on''off');
  190.  
  191.         $this->phpDocOptions['pear']['tag'= array("-p","--pear");
  192.         $this->phpDocOptions['pear']['desc'"Parse a PEAR-style repository (package is directory, _members are @access private) on/off default off";
  193.         $this->phpDocOptions['pear']['type'"set";
  194.         $this->phpDocOptions['pear']['validvalues'= array('on''off');
  195.  
  196.         $this->phpDocOptions['readmeinstallchangelog']['tag'= array("-ric","--readmeinstallchangelog");
  197.         $this->phpDocOptions['readmeinstallchangelog']['desc'"Specify custom filenames to parse like README, INSTALL or CHANGELOG files";
  198.         $this->phpDocOptions['readmeinstallchangelog']['type'"value";
  199.  
  200.         $this->phpDocOptions['general']['message'="You can have multiple directories and multiple files, as well as a combination of both options";
  201.     }
  202.  
  203.     
  204.     /**
  205.      * create the help message for display on the command-line
  206.      * @return string a string containing a help message
  207.      */
  208.     function displayHelpMsg()
  209.     {
  210.         unset($ret);
  211.         $ret "\n";
  212.         foreach($this->phpDocOptions as $data)
  213.         {
  214.             unset($tag);
  215.             $tag "";
  216.             if (isset($data['tag']))
  217.             {
  218.                 if (is_array($data['tag'])) {
  219.                     foreach($data['tag'as $param{
  220.                         $tag .= "$param    ";
  221.                     }
  222.                 }
  223.         $taglen = 34;
  224.         $outputwidth = 79;
  225.         $tagspace str_repeat(" ",$taglen);
  226.                 $tmp "  ".trim($tag).$tagspace;
  227.                 $tmp substr($tmp,0,$taglen);
  228.                 $d wordwrap(ltrim($data['desc']),($outputwidth-$taglen));
  229.         $dt explode("\n",$d);
  230.         $dt[0$tmp .$dt[0];
  231.         for($i=1;$i<count($dt);$i++)
  232.         {
  233.             $dt[$i$tagspace.$dt[$i];
  234.         }
  235.         $ret .= implode("\n",$dt)."\n\n";
  236.         
  237.             }
  238.         }
  239.         $ret .= "\n".wordwrap($data['message'],$outputwidth)."\n";
  240.         return $ret
  241.     }
  242.     
  243.     /**
  244.      * calls {@link file_exists()} for each value in include_path,
  245.      * then calls {@link is_readable()} when it finds the file
  246.      * @param string 
  247.      * @return boolean 
  248.      */
  249.     function isIncludeable($filename)
  250.     {
  251.         $test realpath($filename);
  252.         if ($test && is_readable($test)) {
  253.             return true; // for absolute paths
  254.         }
  255.         $ip get_include_path();
  256.         if (PHPDOCUMENTOR_WINDOWS)
  257.         {
  258.             $ip explode(';'$ip);
  259.         else {
  260.             $ip explode(':'$ip);
  261.         }
  262.         foreach($ip as $path)
  263.         {
  264.             if ($a realpath($path . DIRECTORY_SEPARATOR . $filename))
  265.             {
  266.                 if (is_readable($a))
  267.                 {
  268.                     return true;
  269.                 }
  270.             }
  271.         }
  272.         return false;
  273.     }
  274.  
  275.     /**
  276.      * Parses $_SERVER['argv'] and creates a setup array
  277.      * @return array a setup array
  278.      * @global array command-line arguments
  279.      * @todo replace with Console_* ?
  280.      */
  281.     function parseArgv()
  282.     {
  283.         global $argv;
  284.  
  285.         // defaults for setting
  286.         $setting['hidden'"off";
  287.         $setting['ignoresymlinks''off';
  288.         $setting['template''templates' PATH_DELIMITER .'default' PATH_DELIMITER;
  289.  
  290.         $valnext "junk";
  291.         $data = array();
  292.         if(isset($argv&& is_array($argv))
  293.         {
  294.             foreach ($argv as $cmd)
  295.             {
  296.                 if ($cmd == '--'{
  297.                     continue;
  298.                 }
  299.                 if ($cmd == '-h' || $cmd == '--help')
  300.                 {
  301.                     echo $this->displayHelpMsg();
  302.                     die();
  303.                 }
  304.  
  305.                 // at first, set the arg value as if we
  306.                 // already know it's formatted normally, e.g.
  307.                 //    -q on
  308.                 $setting[$valnext$cmd;
  309.  
  310.                 if (isset($data['type']&& $data['type'== 'set'{
  311.  
  312.                     if ($valnext !== 'junk' && strpos(trim($cmd),'-'=== 0{
  313.                         // if valnext isn't 'junk' (i.e it was an arg option) 
  314.                         // then the first arg needs an implicit "" as its value, e.g.
  315.                         //     ... -q -pp ...  ===>  ... -q '' -pp ... 
  316.                         $setting[$valnext'';
  317.  
  318.                     else if (!in_array(strtolower($cmd)$data['validvalues']true)) {
  319.                         // the arg value is not a valid value
  320.                         addErrorDie(PDERROR_INVALID_VALUES$valnext$cmd,
  321.                             '(' implode(', '$data['validvalues']')');
  322.                     }
  323.                 }
  324.  
  325.                 foreach$this->phpDocOptions as $name => $data )
  326.                 {
  327.                     if (!empty($data['tag']))
  328.                     {
  329.                         if (in_array($cmd,$data['tag']))
  330.                         {
  331.                             $valnext $name;
  332.                             break;
  333.                         
  334.                         else
  335.                         {
  336.                             $valnext "junk";
  337.                         }
  338.                     }
  339.                 }
  340.  
  341.                 if ($valnext == 'junk' && (strpos(trim($cmd),'-'=== 0)) {
  342.                     // this indicates the last arg of the command 
  343.                     // is an arg option (-) that was preceded by unrecognized "junk"
  344.                     addErrorDie(PDERROR_UNKNOWN_COMMANDLINE,$cmd);
  345.  
  346.                 else if ($valnext != 'junk' && (strpos(trim($cmd),'-'=== 0)) {
  347.                     // this indicates the last arg of the command 
  348.                     // is an arg option (-) without an arg value
  349.                     
  350.                     // add an empty arg "value" for this arg "option"
  351.                     $setting[$valnext'';
  352.                 }
  353.  
  354.  
  355.             }
  356.         else
  357.         {
  358.             echo "Please use php-cli.exe in windows, or set register_argc_argv On";
  359.             die;
  360.         }
  361.         /* $setting will always have at least 3 elements
  362.         [hidden] => off
  363.         [ignoresymlinks] => 'off'
  364.         [template] => templates/default
  365.          */
  366.         if (count($setting< 4{
  367.             echo $this->displayhelpMsg();
  368.             die();
  369.         }
  370.  
  371.         return $setting;
  372.     }
  373.  
  374.  
  375.     /**
  376.      * @return array list of files in a directory
  377.      * @param string $directory full path to the directory you want the list of
  378.      * @param bool whether to list files that begin with . like .bash_history
  379.      * @param bool whether to ignore symlinks
  380.      */
  381.     function dirList($orig_directory$hidden = false$ignore_symlinks = false)
  382.     {
  383.         $directory realpath($orig_directory);
  384.         $ret = false;
  385.         if (@is_dir($directory))
  386.         {
  387.             die("directory: '$directory'  not found\n");
  388.         }
  389.         $ret = array();
  390.         $d @dir($directory)// thanks to Jason E Sweat (jsweat@users.sourceforge.net) for fix
  391.         while($d && ($entry=$d->read()) !== false{
  392.             if (strcmp($entry,"."== 0 || strcmp($entry,".."== 0{
  393.                 continue;
  394.             }
  395.  
  396.             // skip hidden files, if we're supposed to
  397.             if (!$hidden)
  398.             {
  399.                 if (substr($entry,0,1== ".")
  400.                 {
  401.                     phpDocumentor_out("Hidden " $directory PATH_DELIMITER . $entry " Ignored\n");
  402.                     continue;
  403.                 }
  404.             }
  405.  
  406.             // skip symlink files, if we're supposed to
  407.             if ($ignore_symlinks)
  408.             {
  409.                 if (is_link($directory PATH_DELIMITER . $entry))
  410.                 {
  411.                     phpDocumentor_out("Symlink " $directory PATH_DELIMITER . $entry " Ignored\n");
  412.                     continue;
  413.                 }
  414.             }
  415.             
  416.             if (is_file($directory PATH_DELIMITER . $entry)) {
  417.                 $ret[$directory PATH_DELIMITER . $entry;
  418.             }
  419.             if (is_dir($directory PATH_DELIMITER . $entry)) {
  420.                 $tmp $this->dirList($directory PATH_DELIMITER . $entry$hidden$ignore_symlinks);
  421.                 if (is_array($tmp)) {
  422.                     foreach($tmp as $ent{
  423.                         $ret[$ent;
  424.                     }
  425.                 }
  426.             }
  427.         }
  428.         if ($d$d->close();
  429.         return $ret;
  430.     }
  431.  
  432.     /**
  433.      * Retrieve common directory (case-insensitive in windows)
  434.      *
  435.      * takes the list of files, and returns the subdirectory they share in common,
  436.      * so in this list:
  437.      *
  438.      * <code>
  439.      * array(
  440.      * "/dir1/dir2/subdir/dir3/filename.ext",
  441.      * "/dir1/dir2/subdir/dir4/filename.ext",
  442.      * "/dir1/dir2/mydir/dir5/filename.ext");
  443.      * </code>
  444.      *
  445.      * getBase will return "/dir1/dir2"
  446.      * @param array array of strings
  447.      */
  448.     function getBase($filelist)
  449.     {
  450.         $masterPath = false;
  451.         foreach($filelist as $path)
  452.         {
  453.             if (!$masterPath)
  454.             {
  455.                 $masterPath str_replace('\\','/',dirname($path));
  456.             else
  457.             {
  458.                 if (dirname($path!= $masterPath)
  459.                 {
  460.                     $mp explode(PATH_DELIMITER$masterPath);
  461.                     $np explode(PATH_DELIMITERstr_replace('\\''/'dirname($path)));
  462.                     if (count($npcount($mp))
  463.                     {
  464.                         $masterPath join($npPATH_DELIMITER);
  465.                     else
  466.                     {
  467.                         $test = false;
  468.                         $found = false;
  469.                         for($i=0;$i count($mp&& $i count($np);$i++)
  470.                         {
  471.                             if (PHPDOCUMENTOR_WINDOWS)
  472.                             {
  473.                                 if (strtolower($mp[$i]!= strtolower($np[$i])) $found $i;
  474.                             else
  475.                             {
  476.                                 if ($mp[$i!= $np[$i]$found $i;
  477.                             }
  478.                         }
  479.                         if ($found !== false)
  480.                         {
  481.                             $mp array_slice($mp,0,$found);
  482.                             $masterPath join($mp,PATH_DELIMITER);
  483.                         }
  484.                     }
  485.                 }
  486.             }
  487.         }
  488.         return $masterPath;
  489.     }
  490.     
  491.     /**
  492.      * Retrieve tutorial subdirectories and their contents from the list of
  493.      * files to parse
  494.      * @param array array of paths (strings)
  495.      * @return array array(filelist - tutorials, tutorials)
  496.      */
  497.     function getTutorials($filelist)
  498.     {
  499.         $list $tutorials = array();
  500.         foreach($filelist as $file)
  501.         {
  502.             if (strpos($file,'tutorials/'!== false)
  503.             {
  504.                 $tutedir explode('/',substr($file,strpos($file,'tutorials/')));
  505.                 array_shift($tutedir);
  506.                 if (count($tutedir<= 3)
  507.                 {
  508.                     $res = array();
  509.                     // kludge - will need to fix for 2.0
  510.                     $res['category'$GLOBALS['phpDocumentor_DefaultCategoryName'];
  511.                     $res['package'array_shift($tutedir);
  512.                     $res['subpackage''';
  513.                     if (count($tutedir> 1)
  514.                     $res['subpackage'array_shift($tutedir);
  515.                     $f array_shift($tutedir);
  516.                     $res['tutename'$f;
  517.                     $f explode('.',$f);
  518.                     $res['tutetype'array_pop($f);
  519.                     if ($res['tutetype'== 'ini'continue;
  520.                     $res['path'$file;
  521.                     if (@file_exists($file '.ini'))
  522.                     {
  523.                         $res['ini'phpDocumentor_parse_ini_file($file '.ini'true);
  524.                     else
  525.                     {
  526.                         $res['ini'= false;
  527.                     }
  528.                     $tutorials[$res;
  529.                 }
  530.             else $list[$file;
  531.         }
  532.         return array($list,$tutorials);
  533.     }
  534.     
  535.     /**
  536.      * @param string base directory from {@link getBase()}
  537.      * @param array file list from {@link dirList()}
  538.      * @return array array(filelist - README/INSTALL/CHANGELOG,
  539.      *                      README/INSTALL/CHANGELOG)
  540.      */
  541.     function getReadmeInstallChangelog($base,$filelist)
  542.     {
  543.         $list $ric = array();
  544.         $names $GLOBALS['_phpDocumentor_RIC_files'];
  545.         foreach($filelist as $file)
  546.         {
  547.             if (in_array(strtoupper(basename($file))$names))
  548.             // be sure to change $this->checkIgnore() if any other files are added here!!
  549.                 $ric[$file;
  550.             else
  551.             {
  552.                 $list[$file;
  553.             }
  554.         }
  555.         return array($list,$ric);
  556.     }
  557.  
  558.     /**
  559.      * @param string directory
  560.      * @param string base directory
  561.      * @param array array of ignored items
  562.      * @param boolean the "hidden" flag
  563.      * @param boolean the "ignoresymlinks" flag
  564.      * @uses dirList
  565.      * @uses checkIgnore
  566.      * @uses setup_dirs
  567.      */    
  568.     function getDirTree($dir$base_dir$ignore = array()$hidden = false$ignoresymlinks = false)
  569.     {
  570.         $allfiles $this->dirList($dir,$hidden,$ignoresymlinks);
  571.         $struc = array();
  572.         foreach($allfiles as $file)
  573.         {
  574.             if ($this->checkIgnore(basename($file),dirname(realpath($file)),$ignore,$ignoresymlinks)) continue;
  575.             if (PHPDOCUMENTOR_WINDOWS{
  576.                 $path substr(dirname($file),strlen(str_replace('\\','/',realpath($base_dir))));
  577.             else {
  578.                 $path substr(dirname($file),strlen(str_replace('\\','/',realpath($base_dir)))+1);
  579.             }
  580.             if (!$path$path '/';
  581.             $parts pathinfo($file);
  582.             if (!isset($parts['extension']))
  583.             {
  584.                 $parts['extension''';
  585.             }
  586.             $struc[$path][= array(
  587.                 'file' => $parts['basename'],
  588.                 'ext' => $parts['extension'],
  589.                 'path' => $file);
  590.         }
  591.         uksort($struc,'strnatcasecmp');
  592.         foreach($struc as $key => $ind)
  593.         {
  594.             usort($ind,'Ioinc_sortfiles');
  595.             $struc[$key$ind;
  596.             $save $key;
  597.             if ($key != '/')
  598.             {
  599.                 $key explode('/',$key);
  600.                 while (count($key))
  601.                 {
  602.                     array_pop($key);
  603.                     if (isset($struc[join('/',$key)]))
  604.                     {
  605.                         $struc[join('/',$key)][substr($save,strlen(join('/',$key)) + 1)$ind;
  606.                         unset($struc[$save]);
  607.                     }
  608.                 }
  609.             }
  610.         }
  611.         foreach($struc as $key => $ind)
  612.         {
  613.             if ($key != '/')
  614.             {
  615.                 if (count(explode('/',$key)) == 1)
  616.                 {
  617.                     $struc['/'][$key$struc[$key];
  618.                     unset($struc[$key]);
  619.                 }
  620.             }
  621.         }
  622.         $tempstruc $struc;
  623.         unset($tempstruc['/']);
  624.         $leftover_dirs array_keys($tempstruc);
  625.         $splitdirs = array();
  626.         foreach($leftover_dirs as $dir)
  627.         {
  628.             $splitdirs[explode('/',$dir);
  629.         }
  630.         $leftover_dirs = array();
  631.  
  632.         foreach($splitdirs as $dir)
  633.         {
  634.             $save join($dir,'/');
  635.             $struc['/'setup_dirs($struc['/']$dir$tempstruc[$save]);
  636.             unset($struc[$save]);
  637.         }
  638.         @uksort($struc['/'],'Ioinc_mystrucsort');
  639.         return $struc;
  640.     }
  641.     
  642.     /**
  643.      * Reads a file and returns it as a string
  644.      * Does basic error checking
  645.      *
  646.      * file extensions are set in {@link phpdoc.inc}
  647.      *
  648.      * @global array PHP File extensions, used to validate that $path is a PHP File
  649.      * @global array PHP File extensions in a CVS repository, used to validate that $path is a PHP File
  650.      * @param    string    $path 
  651.      */
  652.     function readPhpFile($path$quietMode = false)
  653.     {
  654.         global $_phpDocumentor_cvsphpfile_exts$_phpDocumentor_phpfile_exts;
  655.         // tiberiusblue addition
  656.         $cvsExt $_phpDocumentor_cvsphpfile_exts
  657.         $ext $_phpDocumentor_phpfile_exts;
  658.         if (file_exists($path))
  659.         {
  660.             if (is_file($path))
  661.             {
  662.                 // check extension
  663.                 $tmp explode(".",$path);
  664.                 // tiberiusblue addition
  665.                 $tmp2 $tmp;
  666.                 if (in_array(array_pop($tmp),$ext))
  667.                 {
  668.                     phpDocumentor_out(" -- Parsing file\n");
  669.                     flush();
  670.                     if (function_exists('file_get_contents')) {
  671.                         return file_get_contents($path);
  672.                     }
  673.                     $fp fopen($path,"r");
  674.                     $ret fread($fp,filesize($path));
  675.                     fclose($fp);
  676.                     return $ret;
  677.                 elseif (in_array(array_pop($tmp2),$cvsExt)) 
  678.                 
  679.                     phpDocumentor_out(" CVS file [EXPERIMENTAL]\n")
  680.                     flush();
  681.                     if (function_exists('file_get_contents')) {
  682.                         $ret file_get_contents($path);
  683.                     else {
  684.                         $fp fopen($path,"r")
  685.                         $ret fread($fp,filesize($path))
  686.                         fclose($fp)
  687.                     }
  688.                     $ret strstr($ret,"<?");
  689.                     $ret substr($ret,0,strpos($ret,"@\n"));
  690.                     $ret str_replace("@@","@",$ret)
  691.                     return $ret
  692.                 else
  693.                 {
  694.                     phpDocumentor_out(" -- File not parsed, not a php file\n");
  695.                     flush();
  696.                 }
  697.             else {
  698.                 phpDocumentor_out(" -- Unable to read file, not a file\n");
  699.                 flush();
  700.             }
  701.         else {
  702.             phpDocumentor_out(" -- Unable to read file, file does not exist\n");
  703.             flush();
  704.            }
  705.     }
  706.  
  707.     /**
  708.      * Tell whether to ignore a file or a directory
  709.      * allows * and ? wildcards
  710.      *
  711.      * @author Greg Beaver <cellog@php.net>
  712.      * @param    string  $file    just the file name of the file or directory,
  713.      *                           in the case of directories this is the last dir
  714.      * @param    string  $path    the path to consider (should be checked by
  715.      *                             realpath() before, and may be relative)
  716.      * @param    array   $ignore 
  717.      * @param    bool 
  718.      * @param    bool    Ignore symlinks?
  719.      * @return   bool    true if $path should be ignored, false if it should not
  720.      */
  721.     function checkIgnore($file,$path,$ignore,$ignore_no_ext = true,$ignoresymlinks = false)
  722.     {
  723.         global $_phpDocumentor_RIC_files;
  724.  
  725.         if ($ignoresymlinks && is_link($path PATH_DELIMITER . $file)) return false;
  726.         
  727.         if (!count($ignore)) return false;
  728.  
  729.         if (!isset($this->ignore))
  730.         {
  731.             $this->_setupIgnore($ignore);
  732.         }
  733.         if (!$this->ignore)
  734.         {
  735.             return false;
  736.         }
  737.  
  738.         if ($ignore_no_ext && 
  739.             !in_array(strtoupper($file)$_phpDocumentor_RIC_files))
  740.         {
  741.             if (!is_numeric(strpos($file,'.'))) return true;
  742.         }
  743.         if (is_array($this->ignore))
  744.         {
  745.             foreach($this->ignore as $match)
  746.             {
  747.                 // match is an array if the ignore parameter was a /path/to/pattern
  748.                 if (is_array($match))
  749.                 {
  750.                     // check to see if the path matches with a path delimiter appended
  751.                     preg_match('/^' strtoupper($match[0]).'$/'strtoupper($pathPATH_DELIMITER,$find);
  752.                     if (!count($find))
  753.                     {
  754.                         // check to see if it matches without an appended path delimiter
  755.                         preg_match('/^' strtoupper($match[0]).'$/'strtoupper($path)$find);
  756.                     }
  757.                     if (count($find))
  758.                     {
  759.                         // check to see if the file matches the file portion of the regex string
  760.                         preg_match('/^' strtoupper($match[1]).'$/'strtoupper($file)$find);
  761.                         if (count($find))
  762.                         {
  763.                             return true;
  764.                         }
  765.                     }
  766.                     // check to see if the full path matches the regex
  767.                     preg_match('/^' strtoupper($match[0]).'$/',
  768.                                strtoupper($path . DIRECTORY_SEPARATOR . $file)$find);
  769.                     if (count($find))
  770.                     {
  771.                         return true;
  772.                     }
  773.                 else
  774.                 {
  775.                     // ignore parameter was just a pattern with no path delimiters
  776.                     // check it against the path
  777.                     preg_match('/^' strtoupper($match).'$/'strtoupper($path)$find);
  778.                     if (count($find))
  779.                     {
  780.                         return true;
  781.                     }
  782.                     // check it against the file only
  783.                     preg_match('/^' strtoupper($match).'$/'strtoupper($file)$find);
  784.                     if (count($find))
  785.                     {
  786.                         return true;
  787.                     }
  788.                 }
  789.             }
  790.         }
  791.         return false;
  792.     }
  793.     
  794.     /**
  795.      * Construct the {@link $ignore} array
  796.      * @author Greg Beaver <cellog@php.net>
  797.      * @param array strings of files/paths/wildcards to ignore
  798.      * @access protected
  799.      */
  800.     function _setupIgnore($ignore)
  801.     {
  802.         $ig = array();
  803.         if is_array($ignore))
  804.         {
  805.             $this->ignore = false;
  806.             return;
  807.         }
  808.         for($i=0; $i<count($ignore);$i++)
  809.         {
  810.             if (empty($ignore[$i]))
  811.                 continue;
  812.  
  813.             $ignore[$istrtr($ignore[$i]'\\''/');
  814.             $ignore[$istr_replace('//','/',$ignore[$i]);
  815.  
  816.             if (!is_numeric(strpos($ignore[$i],PATH_DELIMITER)))
  817.             {
  818.                 $ig[$this->getRegExpableSearchString($ignore[$i]);
  819.             else
  820.             {
  821.                 if (basename($ignore[$i]PATH_DELIMITER == $ignore[$i])
  822.                 $ig[$this->getRegExpableSearchString($ignore[$i]);
  823.                 else
  824.                 $ig[= array($this->getRegExpableSearchString($ignore[$i]),$this->getRegExpableSearchString(basename($ignore[$i])));
  825.             }
  826.         }
  827.         if (count($ig)) $this->ignore = $ig;
  828.     }
  829.     
  830.     /**
  831.      * Converts $s into a string that can be used with preg_match
  832.      * @param string $s string with wildcards ? and *
  833.      * @author Greg Beaver <cellog@php.net>
  834.      * @return string converts * to .*, ? to ., etc.
  835.      */
  836.     function getRegExpableSearchString($s)
  837.     {
  838.         $y '\/';
  839.         if (DIRECTORY_SEPARATOR == '\\')
  840.         {
  841.             $y '\\\\';
  842.         }
  843.         $s str_replace('/'DIRECTORY_SEPARATOR$s);
  844.         $x strtr($sarray('?' => '.','*' => '.*','.' => '\\.','\\' => '\\\\','/' => '\\/',
  845.                                 '[' => '\\[',']' => '\\]','-' => '\\-'));
  846.         if (strpos($sDIRECTORY_SEPARATOR!== false &&
  847.             strrpos($sDIRECTORY_SEPARATOR=== strlen($s- 1)
  848.         {
  849.             $x = "(?:.*$y$x?.*|$x.*)";
  850.         }
  851.         return $x;
  852.     }
  853.     
  854.     /**
  855.      * Removes files from the $dir array that do not match the search string in
  856.      * $match
  857.      * @param array $dir array of filenames (full path)
  858.      * @param string $match search string with wildcards
  859.      * @author Greg Beaver <cellog@php.net>
  860.      * @return string|arraylisting of every file in a directory that matches
  861.      *                       the search string
  862.      */
  863.     function removeNonMatches($dir$match)
  864.     {
  865.         $match $this->getRegExpableSearchString($match);
  866.         $nodir = false;
  867.         if (!is_array($dir))
  868.         {
  869.             $dir = array($dir);
  870.             $nodir = true;
  871.         }
  872.         foreach($dir as $i => $file)
  873.         {
  874.             preg_match('/^'.$match.'$/',basename($file),$find);
  875.             if (!count($find)) unset($dir[$i]);
  876.         }
  877.         if ($nodirreturn $dir[0];
  878.         return $dir;
  879.     }
  880.     
  881.     /**
  882.      * Take a filename with wildcards and return all files that match the
  883.      * wildcards
  884.      * @param string $file a full path from the -f command-line parameter, with
  885.      *  potential * and ? wildcards.
  886.      * @return mixed if $file contains wildcards, returns an array of matching
  887.      *                files, otherwise returns false
  888.      * @author Greg Beaver <cellog@php.net>
  889.      * @uses dirList
  890.      * @uses removeNonMatches
  891.      */
  892.     function getAllFiles($file)
  893.     {
  894.         $path realpath(dirname($file));
  895.         $file basename($file);
  896.         // any wildcards?
  897.         if (is_numeric(strpos($file,'?')) || is_numeric(strpos($file,'*')))
  898.         {
  899.             $files $this->dirList($path);
  900.             $a $this->removeNonMatches($files,$file);
  901.             return $a;
  902.         }
  903.         return false;
  904.     }
  905. }
  906.  
  907. /**#@+
  908.  * Sorting functions for the file list
  909.  * @param string
  910.  * @param string
  911.  */
  912. function Ioinc_sortfiles($a$b)
  913. {
  914.     return strnatcasecmp($a['file'],$b['file']);
  915. }
  916.  
  917. function Ioinc_mystrucsort($a$b)
  918. {
  919.     if (is_numeric($a&& is_string($b)) return 1;
  920.     if (is_numeric($b&& is_string($a)) return -1;
  921.     if (is_numeric($a&& is_numeric($b))
  922.     {
  923.         if ($a $breturn 1;
  924.         if ($a $breturn -1;
  925.         if ($a == $breturn 0;
  926.     }
  927.     return strnatcasecmp($a,$b);
  928. }
  929. /**#@-*/
  930.  
  931. /**
  932.  * Recursively add all the subdirectories of $contents to $dir without erasing anything in
  933.  * $dir
  934.  * @param array 
  935.  * @param array 
  936.  * @return array processed $dir
  937.  */
  938. function set_dir($dir,$contents)
  939. {
  940.     while(list($one,$twoeach($contents))
  941.     {
  942.         if (isset($dir[$one]))
  943.         {
  944.             $dir[$oneset_dir($dir[$one],$contents[$one]);
  945.         else $dir[$one$two;
  946.     }
  947.     return $dir;
  948. }
  949.  
  950. /**
  951.  * Recursively move contents of $struc into associative array
  952.  *
  953.  * The contents of $struc have many indexes like 'dir/subdir/subdir2'.
  954.  * This function converts them to
  955.  * array('dir' => array('subdir' => array('subdir2')))
  956.  * @param array struc is array('dir' => array of files in dir,'dir/subdir' => array of files in dir/subdir,...)
  957.  * @param array array form of 'dir/subdir/subdir2' array('dir','subdir','subdir2')
  958.  * @return array same as struc but with array('dir' => array(file1,file2,'subdir' => array(file1,...)))
  959.  */
  960. function setup_dirs($struc,$dir,$contents)
  961. {
  962.     if (!count($dir))
  963.     {
  964.         foreach($contents as $dir => $files)
  965.         {
  966.             if (is_string($dir))
  967.             {
  968.                 if (strpos($dir,'/'))
  969.                 {
  970.                     $test = true;
  971.                     $a $contents[$dir];
  972.                     unset($contents[$dir]);
  973.                     $b explode('/',$dir);
  974.                     $c array_shift($b);
  975.                     if (isset($contents[$c]))
  976.                     {
  977.                         $contents[$cset_dir($contents[$c],setup_dirs(array(),$b,$a));
  978.                     else $contents[$csetup_dirs(array(),$b,$a);
  979.                 }
  980.             }
  981.         }
  982.         return $contents;
  983.     }
  984.     $me array_shift($dir);
  985.     if (!isset($struc[$me])) $struc[$me= array();
  986.     $struc[$mesetup_dirs($struc[$me],$dir,$contents);
  987.     return $struc;
  988. }
  989.  
  990. if (!function_exists('get_include_path')) {
  991. function get_include_path()
  992. {
  993.     return ini_get('include_path');
  994. }
  995. }
  996. ?>

Documentation generated on Mon, 11 Mar 2019 15:50:29 -0400 by phpDocumentor 1.4.4. PEAR Logo Copyright © PHP Group 2004.