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

Documentation generated on Tue, 24 Oct 2006 09:23:55 -0500 by phpDocumentor 1.3.1