Source for file InlineTags.inc

Documentation is available at InlineTags.inc

  1. <?php
  2. /**
  3.  * All abstract representations of inline tags are in this file
  4.  *
  5.  * phpDocumentor :: automatic documentation generator
  6.  * 
  7.  * PHP versions 4 and 5
  8.  *
  9.  * Copyright (c) 2002-2008 Gregory Beaver
  10.  * 
  11.  * LICENSE:
  12.  * 
  13.  * This library is free software; you can redistribute it
  14.  * and/or modify it under the terms of the GNU Lesser General
  15.  * Public License as published by the Free Software Foundation;
  16.  * either version 2.1 of the License, or (at your option) any
  17.  * later version.
  18.  * 
  19.  * This library is distributed in the hope that it will be useful,
  20.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  22.  * Lesser General Public License for more details.
  23.  * 
  24.  * You should have received a copy of the GNU Lesser General Public
  25.  * License along with this library; if not, write to the Free Software
  26.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  27.  *
  28.  * @category   ToolsAndUtilities
  29.  * @package    phpDocumentor
  30.  * @subpackage InlineTags
  31.  * @author     Gregory Beaver <cellog@php.net>
  32.  * @copyright  2002-2008 Gregory Beaver
  33.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  34.  * @version    CVS: $Id: InlineTags.inc 286921 2009-08-08 05:01:24Z ashnazg $
  35.  * @filesource
  36.  * @link       http://www.phpdoc.org
  37.  * @link       http://pear.php.net/PhpDocumentor
  38.  * @since      separate file since 1.2
  39.  * @todo       CS cleanup - change package to PhpDocumentor
  40.  */
  41.  
  42. /**
  43.  * Use this element to represent an {@}inline tag} like {@}link}
  44.  *
  45.  * @category   ToolsAndUtilities
  46.  * @package    phpDocumentor
  47.  * @subpackage InlineTags
  48.  * @author     Gregory Beaver <cellog@php.net>
  49.  * @copyright  2002-2008 Gregory Beaver
  50.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  51.  * @version    Release: @VER@
  52.  * @filesource
  53.  * @link       http://www.phpdoc.org
  54.  * @link       http://pear.php.net/PhpDocumentor
  55.  * @see        parserStringWithInlineTags
  56.  * @since      1.0rc1
  57.  * @tutorial   inlinetags.pkg
  58.  * @todo       CS cleanup - change package to PhpDocumentor
  59.  * @todo       CS cleanup - change classname to PhpDocumentor_*
  60.  */
  61. class parserInlineTag extends parserBase
  62. {
  63.     /**
  64.      * Element type
  65.      *
  66.      * Type is used by many functions to skip the hassle of
  67.      *
  68.      * <code>
  69.      * if phpDocumentor_get_class($blah) == 'parserBlah'
  70.      * </code>
  71.      * always "inlinetag"
  72.      * @var string 
  73.      */
  74.     var $type = 'inlinetag';
  75.     /**
  76.      * the name of the inline tag (like link)
  77.      * @var string 
  78.      */
  79.     var $inlinetype = '';
  80.     
  81.     /**
  82.      * sets up the tag
  83.      *
  84.      * @param string $type  tag type (example: link)
  85.      * @param string $value tag value (example: what to link to)
  86.      */
  87.     function parserInlineTag($type$value)
  88.     {
  89.         $this->inlinetype = $type;
  90.         $this->value      = trim($value);
  91.     }
  92.     
  93.     /**
  94.      * get length of the tag
  95.      *
  96.      * @return integer length of the tag
  97.      * @todo CS cleanup - rename to strLen for camelCase rule
  98.      */
  99.     function Strlen()
  100.     {
  101.         // fix 1203451
  102.         if (is_array($this->value)) {
  103.             return array_reduce(create_function('$a, $b''return $a + strlen($b);'))
  104.                 + count($this->value);
  105.         }
  106.         return strlen($this->value);
  107.     }
  108.     
  109.     /**
  110.      * always gets an empty string
  111.      *
  112.      * @return string always '', used by {@link Parser::handleDocBlock()} to
  113.      *                 calculate the short description of a DocBlock
  114.      * @see parserStringWithInlineTags::getString()
  115.      * @see parserStringWithInlineTags::trimmedStrlen()
  116.      */
  117.     function getString()
  118.     {
  119.         return '';
  120.     }
  121. }
  122.  
  123. /**
  124.  * represents inline links
  125.  *
  126.  * @category   ToolsAndUtilities
  127.  * @package    phpDocumentor
  128.  * @subpackage InlineTags
  129.  * @author     Gregory Beaver <cellog@php.net>
  130.  * @copyright  2002-2008 Gregory Beaver
  131.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  132.  * @version    Release: @VER@
  133.  * @filesource
  134.  * @link       http://www.phpdoc.org
  135.  * @link       http://pear.php.net/PhpDocumentor
  136.  * @see        parserStringWithInlineTags
  137.  * @since      1.0rc1
  138.  * @tutorial   tags.inlinelink.pkg
  139.  * @todo       CS cleanup - change package to PhpDocumentor
  140.  * @todo       CS cleanup - change classname to PhpDocumentor_*
  141.  */
  142. {
  143.     /**
  144.      * text to display in the link, can be different from the link for standard
  145.      * links like websites
  146.      * @var string 
  147.      */
  148.     var $linktext = '';
  149.     
  150.     /**
  151.      * sets up the tag
  152.      *
  153.      * @param string $link stored in $value, see {@link parserBase::$value}
  154.      * @param string $text see {@link $linktext}
  155.      */
  156.     function parserLinkInlineTag($link$text)
  157.     {
  158.         if (strpos($link',')) {
  159.             $link explode(','$link);
  160.             parserInlineTag::parserInlineTag('link''');
  161.             $this->value = $link;
  162.         else {
  163.             parserInlineTag::parserInlineTag('link'$link);
  164.         }
  165.         $this->linktext = trim($text);
  166.     }
  167.     
  168.     /**
  169.      * calls the output conversion
  170.      *
  171.      * @param Converter &$c converter used to change the abstract link
  172.      *                       into text for display
  173.      *
  174.      * @return false|stringreturns the converted link or false
  175.      *                       if not converted successfully
  176.      * @todo CS cleanup - rename to convert for camelCase rule
  177.      */
  178.     function Convert(&$c)
  179.     {
  180.         if (is_array($this->value)) {
  181.             $ret '';
  182.             foreach ($this->value as $text{
  183.                 if (!empty($ret)) {
  184.                     $ret .= ', ';
  185.                 }
  186.                 $ret .= $this->ConvertPart($ctrim($text));
  187.             }
  188.             return $ret;
  189.         else {
  190.             return $this->ConvertPart($c$this->value);
  191.         }
  192.     }
  193.     
  194.     /**
  195.      * convert part of the tag
  196.      *
  197.      * @param Converter &$c    the output converter
  198.      * @param string    $value the tag value
  199.      *
  200.      * @return string 
  201.      * @todo CS cleanup - rename to convertPart for camelCase rule
  202.      */
  203.     function ConvertPart(&$c$value)
  204.     {
  205.         if (strpos($value'://'|| (strpos($value'mailto:'=== 0)) {
  206.             if (strpos($value' ')) {
  207.                 $value explode(' '$value);
  208.                 $link  array_shift($value);
  209.                 $text  join(' '$value);
  210.             else {
  211.                 $link $value;
  212.                 $text $this->linktext;
  213.             }
  214.             return $c->returnLink($linkhtmlspecialchars($text));
  215.         else {
  216.             $savevalue $value;
  217.             $descrip   = false;
  218.             if (strpos(trim($value)' ')) {
  219.                 $v preg_split('/\s/'trim($value));
  220.                 if (in_array(strtolower($v[0])array('object''function'))) {
  221.                     if (!isset($v[1]
  222.                         || (isset($v[1]&& strlen($v[1])
  223.                             && !in_array($v[1]{0}array('$','&'))
  224.                             && $v[1!= '###commanana####'
  225.                         )
  226.                     {
  227.                         $vsave $v[0];
  228.                         array_shift($v);
  229.                         $v[0$vsave ' ' $v[0];
  230.                     }
  231.                 }
  232.                 $value $c->getLink($v[0]);
  233.                 array_shift($v);
  234.                 $descrip join($v' ');
  235.                 $descrip str_replace('###commanana####'','$descrip);
  236.             else {
  237.                 $value $c->getLink($value);
  238.             }
  239.             if (is_string($value)) {
  240.                 // feature 564991
  241.                 if (strpos($value'://')) {
  242.                     // php function
  243.                     return $c->returnLink($value$descrip $descrip 
  244.                         str_replace('PHP_MANUAL#'''$value));
  245.                 }
  246.                 return $value;
  247.             }
  248.             if (!$descrip{
  249.                 $descrip $c->type_adjust($savevalue);
  250.             }
  251.             if (is_object($value)) {
  252.                 return $c->returnSee($value$descrip);
  253.             }
  254.             return $savevalue;
  255.         }
  256.     }
  257. }
  258.  
  259. /**
  260.  * Represents inline links to external tutorial documentation
  261.  *
  262.  * @category   ToolsAndUtilities
  263.  * @package    phpDocumentor
  264.  * @subpackage InlineTags
  265.  * @author     Gregory Beaver <cellog@php.net>
  266.  * @copyright  2002-2008 Gregory Beaver
  267.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  268.  * @version    Release: @VER@
  269.  * @filesource
  270.  * @link       http://www.phpdoc.org
  271.  * @link       http://pear.php.net/PhpDocumentor
  272.  * @see        parserStringWithInlineTags
  273.  * @tutorial   tags.inlinetutorial.pkg
  274.  * @todo       CS cleanup - change package to PhpDocumentor
  275.  * @todo       CS cleanup - change classname to PhpDocumentor_*
  276.  */
  277. {
  278.     /**
  279.      * constructor
  280.      *
  281.      * @param string $link stored in $value, see {@link parserBase::$value}
  282.      * @param string $text see {@link $linktext}
  283.      */
  284.     function parserTutorialInlineTag($link,$text)
  285.     {
  286.         parserInlineTag::parserInlineTag('tutorial'$link);
  287.         $this->linktext = trim($text);
  288.     }
  289.  
  290.     /**
  291.      * convert part of the tag
  292.      *
  293.      * @param Converter &$c converter used to change the abstract link
  294.      *                       into text for display
  295.      *
  296.      * @return mixed returns the converted link
  297.      *                or false if not converted successfully
  298.      * @todo CS cleanup - rename to convert for camelCase rule
  299.      */
  300.     function Convert(&$c)
  301.     {
  302.         $descrip = false;
  303.         if (strpos($this->value','=== false{
  304.             if (strpos(trim($this->value)' ')) {
  305.                 $v     explode(' 'trim($this->value));
  306.                 $value $c->getTutorialLink($v[0]);
  307.                 array_shift($v);
  308.                 $descrip join($v' ');
  309.             else {
  310.                 $value $c->getTutorialLink($this->value);
  311.             }
  312.         else {
  313.             $vals    explode(','$this->value);
  314.             $descrip = array();
  315.             foreach ($vals as $val{
  316.                 $val trim($val);
  317.                 if (strpos($val' ')) {
  318.                     $v       explode(' '$val);
  319.                     $value[$c->getTutorialLink($v[0]);
  320.                     array_shift($v);
  321.                     $descrip[join($v' ');
  322.                 else {
  323.                     $value[]   $c->getTutorialLink($val);
  324.                     $descrip[= false;
  325.                 }
  326.             }
  327.         }
  328.         if (is_string($value)) {
  329.             return $value;
  330.         }
  331.         if (is_object($value)) {
  332.             return $c->returnSee($value$descrip);
  333.         }
  334.         /* 
  335.          * getLink parsed a comma-delimited list of linked thingies, 
  336.          * add the commas back in
  337.          */
  338.         if (is_array($value)) {
  339.             $a '';
  340.             foreach ($value as $i => $bub{
  341.                 if (!empty($a)) {
  342.                     $a .= ', ';
  343.                 }
  344.                 if (is_string($value[$i])) {
  345.                     $a .= $value[$i];
  346.                 }
  347.                 if (is_object($value[$i])) {
  348.                     $a .= $c->returnSee($value[$i]$descrip[$i]);
  349.                 }
  350.             }
  351.             return $a;
  352.         }
  353.         return false;
  354.     }
  355. }
  356.  
  357. /**
  358.  * represents inline source tag, used for function/method source
  359.  *
  360.  * @category   ToolsAndUtilities
  361.  * @package    phpDocumentor
  362.  * @subpackage InlineTags
  363.  * @author     Gregory Beaver <cellog@php.net>
  364.  * @copyright  2002-2008 Gregory Beaver
  365.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  366.  * @version    Release: @VER@
  367.  * @filesource
  368.  * @link       http://www.phpdoc.org
  369.  * @link       http://pear.php.net/PhpDocumentor
  370.  * @see        parserStringWithInlineTags
  371.  * @tutorial   tags.inlinesource.pkg
  372.  * @todo       CS cleanup - change package to PhpDocumentor
  373.  * @todo       CS cleanup - change classname to PhpDocumentor_*
  374.  */
  375. {
  376.     /**
  377.      * always 'source'
  378.      * @var string 
  379.      */
  380.     var $inlinetype = 'source';
  381.     /**
  382.      * First line of source code to display
  383.      * @var integer 
  384.      * @see $end
  385.      */
  386.     var $start = 1;
  387.     /**
  388.      * Last line to display
  389.      * @var '*'|integerIf '*' then the whole source will be used, otherwise
  390.      *                   the {@link $start} to $end line numbers will be displayed
  391.      */
  392.     var $end = '*';
  393.     /**
  394.      * tokenized source organized by line numbers for php 4.3.0+, the old
  395.      * {@}source} tag used a string
  396.      * @var string|array
  397.      */
  398.     var $source = false;
  399.     /**#@+ @access private */
  400.     /** @var string|false*/
  401.     var $_class;
  402.     /**#@-*/
  403.  
  404.     /**
  405.      * constructor
  406.      *
  407.      * @param string $value format "start [end]",
  408.      *                       where start and end are line numbers
  409.      *                       with the end line number optional
  410.      */
  411.     function parserSourceInlineTag($value)
  412.     {
  413.         parserInlineTag::parserInlineTag('source''');
  414.         preg_match('/^([0-9]+)\W([0-9]*)$/'trim($value)$match);
  415.         if (!count($match)) {
  416.             preg_match('/^([0-9]+)$/'trim($value)$match);
  417.             if (count($match)) {
  418.                 $this->start = (int) $match[1];
  419.             }
  420.         else {
  421.             $this->start = (int) $match[1];
  422.             $this->end   = (int) $match[2];
  423.         }
  424.     }
  425.     
  426.     /**
  427.      * only used to determine blank lines.  {@}source} will not be blank, probably
  428.      *
  429.      * @return int 
  430.      */
  431.     function Strlen()
  432.     {
  433.         return 1;
  434.     }
  435.     
  436.     /**
  437.      * gets the source string
  438.      *
  439.      * @return string 
  440.      */
  441.     function getString()
  442.     {
  443.         return '{@source}';
  444.     }
  445.     
  446.     /**
  447.      * sets the source tag's value
  448.      *
  449.      * @param string|array$source source code
  450.      * @param string|bool $class  class name if this is a method,
  451.      *                              boolean in php 4.3.0,
  452.      *                              if this is a method this will be true
  453.      *
  454.      * @return void 
  455.      */
  456.     function setSource($source$class = false)
  457.     {
  458.         if (is_array($source)) {
  459.             $this->_class $class;
  460.             $this->source = $source;
  461.         else {
  462.             $source       strstr($source'function');
  463.             $pos          strrpos($source'}');
  464.             $this->source = substr($source0$pos + 1);
  465.         }
  466.     }
  467.     
  468.     /**
  469.      * convert the tag
  470.      *
  471.      * @param Converter &$c the output converter object
  472.      *
  473.      * @return string 
  474.      * @uses stringConvert() in PHP 4.2.3-, this method is used to convert
  475.      * @uses arrayConvert() in PHP 4.3.0+, this method is used to convert
  476.      * @todo CS cleanup - rename to convert for camelCase rule
  477.      */
  478.     function Convert(&$c)
  479.     {
  480.         if (is_string($this->source)) {
  481.             return $this->stringConvert($c);
  482.         }
  483.         return $this->arrayConvert($c);
  484.     }
  485.     
  486.     /**
  487.      * converter helper used in PHP 4.3.0+
  488.      *
  489.      * @param Converter &$c the output converter object
  490.      *
  491.      * @return string 
  492.      * @uses phpDocumentor_HighlightParser Parses the tokenized source
  493.      */
  494.     function arrayConvert(&$c)
  495.     {
  496.         $source $this->source;
  497.         if ($this->end != '*'{
  498.             $source array_slice($this->source0$this->end + $this->start - 1);
  499.         }
  500.         $start $this->start - 1;
  501.         if ($start < 0{
  502.             $start = 0;
  503.         }
  504.         return $c->ProgramExample($sourcetruetrue$this->_class$start);
  505.     }
  506.     
  507.     /**
  508.      * converter helper used in PHP 4.2.3-
  509.      *
  510.      * @param Converter &$c the output converter object
  511.      *
  512.      * @return string 
  513.      * @uses Converter::unmangle() remove the extraneous stuff from
  514.      *                              {@link highlight_string()}
  515.      * @deprecated in favor of PHP 4.3.0+ {@link arrayConvert()}
  516.      */
  517.     function stringConvert(&$c)
  518.     {
  519.         $source highlight_string('<?php ' $this->source . ' ?>'true);
  520.         $source '<code>' substr($sourcestrlen('<code><font color="#000000">
  521. <font color="#0000CC">&lt;?php&nbsp;</font>'- 1);
  522.         $source str_replace('}&nbsp;</font><font color="#0000CC">?&gt;</font>',
  523.             '}</font></code>'$source);
  524.         if ($this->start || ($this->end != '*')) {
  525.             $source explode('<br />'$source);
  526.             $start  $this->start;
  527.             if ($this->end != '*'{
  528.                 $source array_slice($source$start - 1$this->end - $start + 1);
  529.             else {
  530.                 $source array_slice($source$start - 1);
  531.             }
  532.             $source implode($source'<br />');
  533.             if ($start > 0{
  534.                 $source "<code>$source";
  535.             }
  536.             if ($this->end != '*'{
  537.                 $source "$source</code>";
  538.             }
  539.         }
  540.         $source $c->unmangle($source$this->source);
  541.         return $source;
  542.     }
  543. }
  544.  
  545. /**
  546.  * Represents the example inline tag, used to display an example file
  547.  * inside a docblock or tutorial
  548.  *
  549.  * @category   ToolsAndUtilities
  550.  * @package    phpDocumentor
  551.  * @subpackage InlineTags
  552.  * @author     Gregory Beaver <cellog@php.net>
  553.  * @copyright  2002-2008 Gregory Beaver
  554.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  555.  * @version    Release: @VER@
  556.  * @filesource
  557.  * @link       http://www.phpdoc.org
  558.  * @link       http://pear.php.net/PhpDocumentor
  559.  * @see        parserStringWithInlineTags
  560.  * @tutorial   tags.inlineexample.pkg
  561.  * @todo       CS cleanup - change package to PhpDocumentor
  562.  * @todo       CS cleanup - change classname to PhpDocumentor_*
  563.  */
  564. {
  565.     /**
  566.      * constructor
  567.      *
  568.      * @param string $value        format "filepath[ start [end]]"
  569.      *                              where start and end are line numbers
  570.      *                              with the end line number optional
  571.      * @param string $current_path full path to the current file,
  572.      *                              used to check relative directory locations
  573.      * @param bool   $isTutorial   if true, then this is in a tutorial
  574.      *
  575.      * @return mixed 
  576.      * @todo replace tokenizer_ext constant with TOKENIZER_EXT for CS rule
  577.      */
  578.     function parserExampleInlineTag($value$current_path$isTutorial = false)
  579.     {
  580.         global $_phpDocumentor_setting;
  581.         parserInlineTag::parserInlineTag('example''');
  582.         $path     = false;
  583.         $tagValue trim($value);
  584.         $path     $isAbsPath $pathOnly $fileName $fileExt 
  585.             = $original_path  $title = false;
  586.         do {
  587.             // make sure the format is stuff.ext startline[ endline]
  588.             if (!preg_match('`(.*)\.(\w*)\s(.*)`'$tagValue$match)) {
  589.                 // or format is stuff.ext
  590.                 if (!preg_match('`(.*)\.(\w*)\s*$`'$tagValue$match)) {
  591.                     // Murphy: Some funny path was given
  592.                     $original_path $tagValue// used for error output
  593.                     break// try-block
  594.                 }
  595.             }
  596.             if (strlen($match[1]=== 0{
  597.                 // Murphy: Some funny path was given
  598.                 $original_path $tagValue// used for error output
  599.                 break// try-block
  600.             }
  601.             $fileExt $match[2];
  602.             if (isset($match[3])) {
  603.                 $lines       explode(' 'trim($match[3]));
  604.                 $this->start = (int) $lines[0];
  605.                 if (isset($lines[1])) {
  606.                     $this->end = (int) $lines[1];
  607.                 }
  608.             }
  609.             // Replace windows '\' the path.
  610.             $pathTmp str_replace('\\''/'$match[1]);
  611.  
  612.             // Is there a path and a file or is it just a file?
  613.             if (strpos($pathTmp'/'=== false{
  614.                 // No path part
  615.                 $pathOnly '';
  616.                 $fileName $pathTmp .'.'$fileExt;
  617.             else {
  618.                 // split the path on the last directory, find the filename
  619.                 $splitPos strrpos($pathTmp'/');
  620.                 $pathOnly substr($match[1]0$splitPos+1);
  621.                 $fileName substr($match[1]$splitPos+1.'.'$fileExt;
  622.                 // Is the path absolute? (i.e. does it start like an absolute path?)
  623.                 if (('/' === $pathTmp[0]|| preg_match('`^\w*:`i'$pathTmp)) {
  624.                     // works for both windows 'C:' and URLs like 'http://'
  625.                     $isAbsPath = true// Yes
  626.                 }
  627.             }
  628.  
  629.             $original_path $pathOnly $fileName;
  630.  
  631.             // Now look for the file starting with abs. path.
  632.             if ($isAbsPath{
  633.                 // remove any weirdities like /../file.ext
  634.                 $tmp realpath($original_path);
  635.                 if ($tmp && is_file($tmp)) {
  636.                     $path $tmp;
  637.                 }
  638.                 /*
  639.                  * Alway break if abs. path was detected,
  640.                  * even if file was not found.
  641.                  */
  642.                 break// try-block
  643.             }
  644.  
  645.             // Search for the example file some standard places 
  646.             // 1) Look if the ini-var examplesdir is set and look there ...
  647.             if (isset($_phpDocumentor_setting['examplesdir'])) {
  648.                 $tmp realpath($_phpDocumentor_setting['examplesdir'
  649.                     . PATH_DELIMITER  . $original_path);
  650.                 if ($tmp && is_file($tmp)) {
  651.                     $path $tmp// Yo! found it :)
  652.                     break// try-block
  653.                 }
  654.             }
  655.  
  656.             // 2) Then try to look for an 'example/'-dir 
  657.             //    below the *currently* parsed file ...
  658.             if (!empty($current_path)) {
  659.                 $tmp realpath(dirname($current_pathPATH_DELIMITER . 'examples'
  660.                     . PATH_DELIMITER . $fileName);
  661.                 if ($tmp && is_file($tmp)) {
  662.                     $path $tmp// Yo! found it :)
  663.                     break// try-block
  664.                 }
  665.             }
  666.  
  667.             // 3) Then try to look for the example file 
  668.             //    below the subdir PHPDOCUMENTOR_BASE/examples/ ...
  669.             if (is_dir(PHPDOCUMENTOR_BASE . PATH_DELIMITER . 'examples')) {
  670.                 $tmp realpath(PHPDOCUMENTOR_BASE . PATH_DELIMITER . 'examples' 
  671.                     . PATH_DELIMITER . $original_path);
  672.                 if ($tmp && is_file($tmp)) {
  673.                     $path $tmp// Yo! found it :)
  674.                     break// try-block
  675.                 }
  676.             }
  677.  
  678.             $tmp realpath(PHPDOCUMENTOR_BASE . PATH_DELIMITER . $original_path);
  679.             if ($tmp && is_file($tmp)) {
  680.                 $path $tmp// Yo! found it :)
  681.                 break// try-block
  682.             }
  683.             // If we reach this point, nothing was found and $path is false.
  684.         while (false);
  685.  
  686.         if (!$path{
  687.             addWarning(PDERROR_EXAMPLE_NOT_FOUND$original_path);
  688.             $this->path = false;
  689.         else {
  690.             $f @fopen($path'r');
  691.             if ($f{
  692.                 $example fread($ffilesize($path));
  693.                 if (tokenizer_ext && !$isTutorial{
  694.                     $obj = new phpDocumentorTWordParser;
  695.                     $obj->setup($example);
  696.                     $this->setSource($obj->getFileSource());
  697.                     unset($obj);
  698.                 else {
  699.                     $this->setSource($example);
  700.                 }
  701.             }
  702.         }
  703.     }
  704.     
  705.     /**
  706.      * sets the source
  707.      *
  708.      * @param string|array$source source code
  709.      * @param string|bool $class  class name if this is a method,
  710.      *                              boolean in php 4.3.0,
  711.      *                              if this is a method this will be true
  712.      *
  713.      * @return void 
  714.      */
  715.     function setSource($source$class = false)
  716.     {
  717.         $this->_class $class;
  718.         $this->source = $source;
  719.     }
  720.     
  721.     /**
  722.      * converter helper for PHP 4.3.0+
  723.      *
  724.      * @param Converter &$c output converter
  725.      *
  726.      * @return string 
  727.      * @uses phpDocumentor_HighlightParser Parses the tokenized source
  728.      */
  729.     function arrayConvert(&$c)
  730.     {
  731.         $source $this->source;
  732.         if ($this->end != '*'{
  733.             $source array_slice($this->source0$this->end + $this->start - 1);
  734.         }
  735.         $start $this->start - 1;
  736.         if ($start < 0{
  737.             $start = 0;
  738.         }
  739.         return $c->exampleProgramExample($sourcetruetrue$this->_class$start);
  740.     }
  741.  
  742.     /**
  743.      * Return the source for the example file, enclosed in
  744.      * a <programlisting> tag to use in a tutorial
  745.      *
  746.      * @return string 
  747.      */
  748.     function getProgramListing()
  749.     {
  750.         $source explode("\n"$this->source);
  751.         $start  $this->start;
  752.         if ($this->end != '*'{
  753.             $source array_slice($source$start - 1$this->end - $start + 1);
  754.         else {
  755.             $source array_slice($source$start - 1);
  756.         }
  757.         $source join("\n"$source);
  758.         return
  759.         "<programlisting role=\"php\">
  760.          <![CDATA[\n" .
  761.           $source .
  762.         "\n]]>\n</programlisting>";
  763.     }
  764. }
  765.  
  766. /**
  767.  * Represents the inheritdoc inline tag, used by classes/methods/vars to inherit
  768.  * documentation from the parent class if possible
  769.  *
  770.  * @category   ToolsAndUtilities
  771.  * @package    phpDocumentor
  772.  * @subpackage InlineTags
  773.  * @author     Gregory Beaver <cellog@php.net>
  774.  * @copyright  2002-2008 Gregory Beaver
  775.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  776.  * @version    Release: @VER@
  777.  * @filesource
  778.  * @link       http://www.phpdoc.org
  779.  * @link       http://pear.php.net/PhpDocumentor
  780.  * @see        parserStringWithInlineTags
  781.  * @tutorial   tags.inlineinheritdoc.pkg
  782.  * @todo       CS cleanup - change package to PhpDocumentor
  783.  * @todo       CS cleanup - change classname to PhpDocumentor_*
  784.  */
  785. {
  786.     /**
  787.      * always 'inheritdoc'
  788.      * @var string 
  789.      */
  790.     var $inlinetype = 'inheritdoc';
  791.     
  792.     /**
  793.      * Does nothing, overrides parent constructor
  794.      */
  795.     function parserInheritdocInlineTag()
  796.     {
  797.     }
  798.     
  799.     /**
  800.      * only sets a warning and returns empty
  801.      *
  802.      * @return string 
  803.      * @todo CS cleanup - rename to convert for camelCase rule
  804.      */
  805.     function Convert()
  806.     {
  807.         return '';
  808.     }
  809. }
  810.  
  811. /**
  812.  * Represents the inline {@}id} tag for tutorials
  813.  *
  814.  * @category   ToolsAndUtilities
  815.  * @package    phpDocumentor
  816.  * @subpackage InlineTags
  817.  * @author     Gregory Beaver <cellog@php.net>
  818.  * @copyright  2002-2008 Gregory Beaver
  819.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  820.  * @version    Release: @VER@
  821.  * @filesource
  822.  * @link       http://www.phpdoc.org
  823.  * @link       http://pear.php.net/PhpDocumentor
  824.  * @see        parserStringWithInlineTags
  825.  * @tutorial   tags.inlineid.pkg
  826.  * @todo       CS cleanup - change package to PhpDocumentor
  827.  * @todo       CS cleanup - change classname to PhpDocumentor_*
  828.  */
  829. {
  830.     /**
  831.      * always 'id'
  832.      * @var string 
  833.      */
  834.     var $inlinetype = 'id';
  835.     /**
  836.      * package of the {@}id}
  837.      * @var string 
  838.      */
  839.     var $package = 'default';
  840.     /**
  841.      * category of the {@}id}
  842.      * @var string 
  843.      */
  844.     var $category = 'default';
  845.     /**
  846.      * subpackage of the {@}id}
  847.      * @var string 
  848.      */
  849.     var $subpackage = '';
  850.     /**
  851.      * full name of the tutorial
  852.      * @var string 
  853.      */
  854.     var $tutorial;
  855.     /**
  856.      * section/subsection name
  857.      * @var string 
  858.      */
  859.     var $id;
  860.     
  861.     /**
  862.      * constructor
  863.      *
  864.      * @param string $category   category name
  865.      * @param string $package    package name
  866.      * @param string $subpackage subpackage name
  867.      * @param string $tutorial   tutorial name
  868.      * @param string $id         section/subsection name
  869.      */
  870.     function parserIdInlineTag($category,$package,$subpackage,$tutorial,$id = false)
  871.     {
  872.         $this->package    = $package;
  873.         $this->subpackage = $subpackage;
  874.         $this->tutorial   = $tutorial;
  875.         $this->id         = $id;
  876.         $this->category   = $category;
  877.     }
  878.     
  879.     /**
  880.      * converter
  881.      *
  882.      * @param Converter &$c output converter
  883.      *
  884.      * @return string 
  885.      * @uses Converter::getTutorialId() retrieve converter-specific ID
  886.      * @todo CS cleanup - rename to convert for camelCase rule
  887.      */
  888.     function Convert(&$c)
  889.     {
  890.         if (!$this->id{
  891.             return '';
  892.         }
  893.         return $c->getTutorialId($this->package$this->subpackage
  894.             $this->tutorial$this->id$this->category);
  895.     }
  896. }
  897.  
  898. /**
  899.  * Represents {@}toc} for table of contents generation in tutorials
  900.  *
  901.  * @category   ToolsAndUtilities
  902.  * @package    phpDocumentor
  903.  * @subpackage InlineTags
  904.  * @author     Gregory Beaver <cellog@php.net>
  905.  * @copyright  2002-2008 Gregory Beaver
  906.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  907.  * @version    Release: @VER@
  908.  * @filesource
  909.  * @link       http://www.phpdoc.org
  910.  * @link       http://pear.php.net/PhpDocumentor
  911.  * @see        parserStringWithInlineTags
  912.  * @tutorial   tags.inlinetoc.pkg
  913.  * @todo       CS cleanup - change package to PhpDocumentor
  914.  * @todo       CS cleanup - change classname to PhpDocumentor_*
  915.  */
  916. {
  917.     /**
  918.      * always 'toc'
  919.      * @var string 
  920.      */
  921.     var $inlinetype = 'toc';
  922.     /**
  923.      * @var array format:
  924.      *  <pre>
  925.      *  array(
  926.      *      array(
  927.      *          'tagname' => section,
  928.      *          'link'    => returnsee link,
  929.      *          'id'      => anchor name,
  930.      *          'title'   => from title tag
  931.      *      ),
  932.      *      ...
  933.      *  )
  934.      *  </pre>
  935.      * @access private
  936.      */
  937.     var $_toc = false;
  938.     /**
  939.      * full path to tutorial, used in conversion
  940.      * @var string 
  941.      * @access private
  942.      */
  943.     var $_path = false;
  944.  
  945.     /**
  946.      * constructor
  947.      */
  948.     function parserTocInlineTag()
  949.     {
  950.         parent::parserInlineTag('toc''');
  951.     }
  952.     
  953.     /**
  954.      * set the TOC
  955.      *
  956.      * @param array $toc format:
  957.      *  <pre>
  958.      *  array(
  959.      *      array(
  960.      *          'tag'   => {@link parserXMLDocBookTag},
  961.      *          'id'    => {@link parserIdInlineTag},
  962.      *          'title' => {@link parserXMLDocBookTag title}
  963.      *      ),
  964.      *      ...
  965.      *  )
  966.      *  </pre>
  967.      *
  968.      * @return void 
  969.      */
  970.     function setTOC($toc)
  971.     {
  972.         $this->toc $toc;
  973.     }
  974.     
  975.     /**
  976.      * set the path
  977.      *
  978.      * @param string $path the path
  979.      *
  980.      * @return void 
  981.      */
  982.     function setPath($path)
  983.     {
  984.         $this->_path $path;
  985.     }
  986.     
  987.     /**
  988.      * converter method
  989.      *
  990.      * <pre>
  991.      * array(
  992.      *    'tagname' => string name of tag,
  993.      *    'link'    => {@link tutorialLink} to the tutorial,
  994.      *    'id'      => converter specific tutorial ID from
  995.      *                     {@link Converter::getTutorialId()}
  996.      *    'title'   => title of the tutorial)
  997.      * </pre>
  998.      * and returns the results as the table of contents
  999.      *
  1000.      * @param Converter &$c converter object
  1001.      *
  1002.      * @return mixed 
  1003.      * @uses Converter::getTutorialId() retrieve the tutorial ID for
  1004.      * @uses Converter::formatTutorialTOC() passes an array of format:
  1005.      * @todo CS cleanup - rename to convert for camelCase rule
  1006.      */
  1007.     function Convert(&$c)
  1008.     {
  1009.         $newtoc = array();
  1010.         if (isset($this->toc&& is_array($this->toc)) {
  1011.             foreach ($this->toc as $i => $toc{
  1012.                 if (isset($toc['title'])) {
  1013.                     $toc['tag']->setTitle($toc['title']);
  1014.                 else {
  1015.                     $toc['tag']->setTitle(new parserStringWithInlineTags);
  1016.                 }
  1017.                 $newtoc[$i]['tagname'$toc['tag']->name;
  1018.                 $l                     = new tutorialLink;
  1019.                 if (!isset($toc['title'])) {
  1020.                     $title 'section '.$toc['id']->id;
  1021.                 else {
  1022.                     $title $toc['title']->Convert($c);
  1023.                 }
  1024.                 $l->addLink($toc['id']->id$this->_pathbasename($this->_path)
  1025.                     $toc['id']->package$toc['id']->subpackagestrip_tags($title));
  1026.                 $newtoc[$i]['link']  $c->returnSee($l);
  1027.                 $newtoc[$i]['id']    $c->getTutorialId($toc['id']->package
  1028.                     $toc['id']->subpackagebasename($this->_path)
  1029.                     $toc['id']->id$toc['id']->category);
  1030.                 $newtoc[$i]['title'$title;
  1031.             }
  1032.         }
  1033.         return $c->formatTutorialTOC($newtoc);
  1034.     }
  1035. }
  1036. ?>

Documentation generated on Mon, 05 Dec 2011 21:28:04 -0600 by phpDocumentor 1.4.4