includes/wikiengine/Parse/Default/Url.php
changeset 1027 98c052fc3337
parent 1026 f0431eb8161e
child 1028 dde4416dea00
equal deleted inserted replaced
1026:f0431eb8161e 1027:98c052fc3337
     1 <?php
       
     2 
       
     3 /**
       
     4 * 
       
     5 * Parse for URLS in the source text.
       
     6 * 
       
     7 * @category Text
       
     8 * 
       
     9 * @package Text_Wiki
       
    10 * 
       
    11 * @author Paul M. Jones <pmjones@php.net>
       
    12 * 
       
    13 * @license LGPL
       
    14 * 
       
    15 * @version $Id: Url.php,v 1.3 2005/02/23 17:38:29 pmjones Exp $
       
    16 * 
       
    17 */
       
    18 
       
    19 /**
       
    20 * 
       
    21 * Parse for URLS in the source text.
       
    22 * 
       
    23 * Various URL markings are supported: inline (the URL by itself),
       
    24 * numbered or footnote reference (where the URL is enclosed in square
       
    25 * brackets), and named reference (where the URL is enclosed in square
       
    26 * brackets and has a name included inside the brackets).  E.g.:
       
    27 *
       
    28 * inline    -- http://example.com
       
    29 * numbered  -- [http://example.com]
       
    30 * described -- [http://example.com Example Description]
       
    31 *
       
    32 * When rendering a URL token, this will convert URLs pointing to a .gif,
       
    33 * .jpg, or .png image into an inline <img /> tag (for the 'xhtml'
       
    34 * format).
       
    35 *
       
    36 * Token options are:
       
    37 * 
       
    38 * 'type' => ['inline'|'footnote'|'descr'] the type of URL
       
    39 * 
       
    40 * 'href' => the URL link href portion
       
    41 * 
       
    42 * 'text' => the displayed text of the URL link
       
    43 * 
       
    44 * @category Text
       
    45 * 
       
    46 * @package Text_Wiki
       
    47 * 
       
    48 * @author Paul M. Jones <pmjones@php.net>
       
    49 * 
       
    50 */
       
    51 
       
    52 class Text_Wiki_Parse_Url extends Text_Wiki_Parse {
       
    53     
       
    54     
       
    55     /**
       
    56     * 
       
    57     * Keeps a running count of numbered-reference URLs.
       
    58     * 
       
    59     * @access public
       
    60     * 
       
    61     * @var int
       
    62     * 
       
    63     */
       
    64     
       
    65     var $footnoteCount = 0;
       
    66     
       
    67     
       
    68     /**
       
    69     * 
       
    70     * URL schemes recognized by this rule.
       
    71     * 
       
    72     * @access public
       
    73     * 
       
    74     * @var array
       
    75     * 
       
    76     */
       
    77     
       
    78     var $conf = array(
       
    79         'schemes' => array(
       
    80             'http://',
       
    81             'https://',
       
    82             'ftp://',
       
    83             'gopher://',
       
    84             'news://',
       
    85             'mailto:'
       
    86         )
       
    87     );
       
    88     
       
    89     
       
    90     /**
       
    91     * 
       
    92     * Constructor.
       
    93     * 
       
    94     * We override the constructor so we can comment the regex nicely.
       
    95     * 
       
    96     * @access public
       
    97     * 
       
    98     */
       
    99     
       
   100     function Text_Wiki_Parse_Url(&$obj)
       
   101     {
       
   102         parent::Text_Wiki_Parse($obj);
       
   103         
       
   104         // convert the list of recognized schemes to a regex-safe string,
       
   105         // where the pattern delim is a slash
       
   106         $tmp = array();
       
   107         $list = $this->getConf('schemes', array());
       
   108         foreach ($list as $val) {
       
   109             $tmp[] = preg_quote($val, '/');
       
   110         }
       
   111         $schemes = implode('|', $tmp);
       
   112         
       
   113         // build the regex
       
   114         $this->regex =
       
   115             "($schemes)" . // allowed schemes
       
   116             "(" . // start pattern
       
   117             "[^ \\/".'"'."\'{$this->wiki->delim}]*\\/" . // no spaces, backslashes, slashes, double-quotes, single quotes, or delimiters;
       
   118             ")*" . // end pattern
       
   119             "[^ \\t\\n\\/".'"'."\'{$this->wiki->delim}]*" .
       
   120             "[A-Za-z0-9\\/?=&~_]";
       
   121     }
       
   122     
       
   123     
       
   124     /**
       
   125     * 
       
   126     * Find three different kinds of URLs in the source text.
       
   127     *
       
   128     * @access public
       
   129     * 
       
   130     */
       
   131     
       
   132     function parse()
       
   133     {
       
   134         // -------------------------------------------------------------
       
   135         // 
       
   136         // Described-reference (named) URLs.
       
   137         // 
       
   138         
       
   139         // the regular expression for this kind of URL
       
   140         $tmp_regex = '/\[(' . $this->regex . ') ([^\]]+)\]/';
       
   141         
       
   142         // use a custom callback processing method to generate
       
   143         // the replacement text for matches.
       
   144         $this->wiki->source = preg_replace_callback(
       
   145             $tmp_regex,
       
   146             array(&$this, 'processDescr'),
       
   147             $this->wiki->source
       
   148         );
       
   149         
       
   150         
       
   151         // -------------------------------------------------------------
       
   152         // 
       
   153         // Numbered-reference (footnote-style) URLs.
       
   154         // 
       
   155         
       
   156         // the regular expression for this kind of URL
       
   157         $tmp_regex = '/\[(' . $this->regex . ')\]/U';
       
   158         
       
   159         // use a custom callback processing method to generate
       
   160         // the replacement text for matches.
       
   161         $this->wiki->source = preg_replace_callback(
       
   162             $tmp_regex,
       
   163             array(&$this, 'processFootnote'),
       
   164             $this->wiki->source
       
   165         );
       
   166         
       
   167         
       
   168         // -------------------------------------------------------------
       
   169         // 
       
   170         // Normal inline URLs.
       
   171         // 
       
   172         
       
   173         // the regular expression for this kind of URL
       
   174         
       
   175         $tmp_regex = '/(^|[^A-Za-z])(' . $this->regex . ')(.*?)/';
       
   176         
       
   177         // use the standard callback for inline URLs
       
   178         $this->wiki->source = preg_replace_callback(
       
   179             $tmp_regex,
       
   180             array(&$this, 'process'),
       
   181             $this->wiki->source
       
   182         );
       
   183     }
       
   184     
       
   185     
       
   186     /**
       
   187     * 
       
   188     * Process inline URLs.
       
   189     * 
       
   190     * @param array &$matches
       
   191     * 
       
   192     * @param array $matches An array of matches from the parse() method
       
   193     * as generated by preg_replace_callback.  $matches[0] is the full
       
   194     * matched string, $matches[1] is the first matched pattern,
       
   195     * $matches[2] is the second matched pattern, and so on.
       
   196     * 
       
   197     * @return string The processed text replacement.
       
   198     * 
       
   199     */ 
       
   200     
       
   201     function process(&$matches)
       
   202     {
       
   203         // set options
       
   204         $options = array(
       
   205             'type' => 'inline',
       
   206             'href' => $matches[2],
       
   207             'text' => $matches[2]
       
   208         );
       
   209         
       
   210         // tokenize
       
   211         return $matches[1] . $this->wiki->addToken($this->rule, $options) . $matches[5];
       
   212     }
       
   213     
       
   214     
       
   215     /**
       
   216     * 
       
   217     * Process numbered (footnote) URLs.
       
   218     * 
       
   219     * Token options are:
       
   220     * @param array &$matches
       
   221     * 
       
   222     * @param array $matches An array of matches from the parse() method
       
   223     * as generated by preg_replace_callback.  $matches[0] is the full
       
   224     * matched string, $matches[1] is the first matched pattern,
       
   225     * $matches[2] is the second matched pattern, and so on.
       
   226     * 
       
   227     * @return string The processed text replacement.
       
   228     * 
       
   229     */ 
       
   230     
       
   231     function processFootnote(&$matches)
       
   232     {
       
   233         // keep a running count for footnotes 
       
   234         $this->footnoteCount++;
       
   235         
       
   236         // set options
       
   237         $options = array(
       
   238             'type' => 'footnote',
       
   239             'href' => $matches[1],
       
   240             'text' => $this->footnoteCount
       
   241         );
       
   242         
       
   243         // tokenize
       
   244         return $this->wiki->addToken($this->rule, $options);
       
   245     }
       
   246     
       
   247     
       
   248     /**
       
   249     * 
       
   250     * Process described-reference (named-reference) URLs.
       
   251     * 
       
   252     * Token options are:
       
   253     *     'type' => ['inline'|'footnote'|'descr'] the type of URL
       
   254     *     'href' => the URL link href portion
       
   255     *     'text' => the displayed text of the URL link
       
   256     * 
       
   257     * @param array &$matches
       
   258     * 
       
   259     * @param array $matches An array of matches from the parse() method
       
   260     * as generated by preg_replace_callback.  $matches[0] is the full
       
   261     * matched string, $matches[1] is the first matched pattern,
       
   262     * $matches[2] is the second matched pattern, and so on.
       
   263     * 
       
   264     * @return string The processed text replacement.
       
   265     * 
       
   266     */ 
       
   267     
       
   268     function processDescr(&$matches)
       
   269     {
       
   270         // set options
       
   271         $options = array(
       
   272             'type' => 'descr',
       
   273             'href' => $matches[1],
       
   274             'text' => $matches[4]
       
   275         );
       
   276         
       
   277         // tokenize
       
   278         return $this->wiki->addToken($this->rule, $options);
       
   279     }
       
   280 }
       
   281 ?>