CHIEFSOFT\ameye
314 lines
9.3 KiB
PHP
314 lines
9.3 KiB
PHP
<?php
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* Library of functions and constants for module wiki
|
|
*
|
|
* It contains the great majority of functions defined by Moodle
|
|
* that are mandatory to develop a module.
|
|
*
|
|
* @package mod_wiki
|
|
* @copyright 2009 Marc Alier, Jordi Piguillem marc.alier@upc.edu
|
|
* @copyright 2009 Universitat Politecnica de Catalunya http://www.upc.edu
|
|
*
|
|
* @author Jordi Piguillem
|
|
* @author Marc Alier
|
|
* @author David Jimenez
|
|
* @author Josep Arus
|
|
* @author Kenneth Riba
|
|
*
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
/**
|
|
* Generic parser implementation
|
|
*
|
|
* @author Josep Arús
|
|
*
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU Public License
|
|
* @package mod_wiki
|
|
*/
|
|
class wiki_parser_proxy {
|
|
/**
|
|
* @var array $parsers Array of parser instances
|
|
*/
|
|
private static $parsers = [];
|
|
|
|
/**
|
|
* Parse a string using a specific parser
|
|
*
|
|
* @param string $string The string to parse
|
|
* @param string $type The parser type
|
|
* @param array $options The parser options
|
|
* @return mixed The parsed string or false if the parser type is not found
|
|
*/
|
|
public static function parse(&$string, $type, $options = []) {
|
|
$type = strtolower($type);
|
|
self::$parsers[$type] = null; // Reset the current parser because it may have other options.
|
|
if (self::create_parser_instance($type)) {
|
|
return self::$parsers[$type]->parse($string, $options);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static function get_token($name, $type) {
|
|
if (self::create_parser_instance($type)) {
|
|
return self::$parsers[$type]->get_token($name);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static function get_section(&$string, $type, $section, $allcontent = false) {
|
|
if (self::create_parser_instance($type)) {
|
|
$content = self::$parsers[$type]->get_section($section, $string, true);
|
|
|
|
if ($allcontent) {
|
|
return $content;
|
|
} else {
|
|
return is_array($content) ? $content[1] : null;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static function create_parser_instance($type) {
|
|
global $CFG;
|
|
$type = clean_param($type, PARAM_ALPHA);
|
|
if (empty(self::$parsers[$type])) {
|
|
$path = "$CFG->dirroot/mod/wiki/parser/markups/$type.php";
|
|
if (!file_exists($path)) {
|
|
throw new moodle_exception("Parser type $type not found");
|
|
}
|
|
include_once($path);
|
|
$class = strtolower($type) . "_parser";
|
|
if (class_exists($class)) {
|
|
self::$parsers[$type] = new $class;
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
require_once('utils.php');
|
|
|
|
abstract class generic_parser {
|
|
protected $string;
|
|
|
|
protected $blockrules = array();
|
|
protected $tagrules = array();
|
|
|
|
private $rulestack = array();
|
|
|
|
protected $parserstatus = 'Before';
|
|
|
|
/**
|
|
* Dynamic return values
|
|
*/
|
|
|
|
protected $returnvalues = array();
|
|
|
|
private $nowikiindex = array();
|
|
|
|
protected $nowikitoken = "%!";
|
|
|
|
public function __construct() {
|
|
}
|
|
|
|
/**
|
|
* Parse function
|
|
*/
|
|
public function parse(&$string, $options = array()) {
|
|
if (!is_string($string)) {
|
|
return false;
|
|
}
|
|
|
|
$this->string =& $string;
|
|
|
|
$this->set_options(is_array($options) ? $options : array());
|
|
|
|
$this->initialize_nowiki_index();
|
|
|
|
if (method_exists($this, 'before_parsing')) {
|
|
$this->before_parsing();
|
|
}
|
|
|
|
$this->parserstatus = 'Parsing';
|
|
|
|
foreach ($this->blockrules as $name => $block) {
|
|
$this->process_block_rule($name, $block);
|
|
}
|
|
|
|
$this->commit_nowiki_index();
|
|
|
|
$this->parserstatus = 'After';
|
|
|
|
if (method_exists($this, 'after_parsing')) {
|
|
$this->after_parsing();
|
|
}
|
|
|
|
return array('parsed_text' => $this->string) + $this->returnvalues;
|
|
}
|
|
|
|
/**
|
|
* Initialize options
|
|
*/
|
|
protected function set_options($options) {
|
|
}
|
|
|
|
/**
|
|
* Block processing function & callbacks
|
|
*/
|
|
protected function process_block_rule($name, $block) {
|
|
$this->rulestack[] = array('callback' => method_exists($this, $name . "_block_rule") ? $name . "_block_rule" : null,
|
|
'rule' => $block);
|
|
|
|
$this->string = preg_replace_callback($block['expression'], array($this, 'block_callback'), $this->string);
|
|
|
|
array_pop($this->rulestack);
|
|
}
|
|
|
|
private function block_callback($match) {
|
|
$rule = end($this->rulestack);
|
|
if (!empty($rule['callback'])) {
|
|
$stuff = $this->{$rule['callback']}($match);
|
|
} else {
|
|
$stuff = $match[1];
|
|
}
|
|
|
|
if (is_array($stuff) && $rule['rule']['tag']) {
|
|
$this->rules($stuff[0], $rule['rule']['tags']);
|
|
$stuff = "\n" . parser_utils::h($rule['rule']['tag'], $stuff[0], $stuff[1]) . "\n";
|
|
} else {
|
|
if (!isset($rule['rule']['tags'])) {
|
|
$rule['rule']['tags'] = null;
|
|
}
|
|
$this->rules($stuff, $rule['rule']['tags']);
|
|
if (isset($rule['rule']['tag']) && is_string($rule['rule']['tag'])) {
|
|
$stuff = "\n" . parser_utils::h($rule['rule']['tag'], $stuff) . "\n";
|
|
}
|
|
}
|
|
|
|
return $stuff;
|
|
}
|
|
|
|
/**
|
|
* Rules processing function & callback
|
|
*/
|
|
|
|
final protected function rules(&$text, $rules = null) {
|
|
if ($rules === null) {
|
|
$rules = array('except' => array());
|
|
} else if (is_array($rules) && count($rules) > 1) {
|
|
$rules = array('only' => $rules);
|
|
}
|
|
|
|
if (isset($rules['only']) && is_array($rules['only'])) {
|
|
$rules = $rules['only'];
|
|
foreach ($rules as $r) {
|
|
if (!empty($this->tagrules[$r])) {
|
|
$this->process_tag_rule($r, $this->tagrules[$r], $text);
|
|
}
|
|
}
|
|
} else if (isset($rules['except']) && is_array($rules['except'])) {
|
|
$rules = $rules['except'];
|
|
foreach ($this->tagrules as $r => $tr) {
|
|
if (!in_array($r, $rules)) {
|
|
$this->process_tag_rule($r, $tr, $text);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private function process_tag_rule($name, $rule, &$text) {
|
|
if (method_exists($this, $name . "_tag_rule")) {
|
|
$this->rulestack[] = array('callback' => $name . "_tag_rule", 'rule' => $rule);
|
|
$text = preg_replace_callback($rule['expression'], array($this, 'tag_callback'), $text);
|
|
array_pop($this->rulestack);
|
|
} else {
|
|
if (isset($rule['simple'])) {
|
|
$replace = "<{$rule['tag']} />";
|
|
} else {
|
|
$replace = parser_utils::h($rule['tag'], "$1");
|
|
}
|
|
|
|
$text = preg_replace($rule['expression'], $replace, $text);
|
|
}
|
|
}
|
|
|
|
private function tag_callback($match) {
|
|
$rule = end($this->rulestack);
|
|
$stuff = $this->{$rule['callback']}($match);
|
|
|
|
if (is_array($stuff)) {
|
|
return parser_utils::h($rule['rule']['tag'], $stuff[0], $stuff[1]);
|
|
} else {
|
|
return $stuff;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Special nowiki parser index
|
|
*/
|
|
|
|
private function initialize_nowiki_index() {
|
|
$token = "\Q" . $this->nowikitoken . "\E";
|
|
$this->string = preg_replace_callback("/" . $token . "\d+" . $token . "/",
|
|
array($this, "initialize_nowiki_index_callback"), $this->string);
|
|
}
|
|
|
|
private function initialize_nowiki_index_callback($match) {
|
|
return $this->protect($match[0]);
|
|
}
|
|
|
|
protected function protect($text) {
|
|
$this->nowikiindex[] = $text;
|
|
|
|
return $this->nowikitoken . (count($this->nowikiindex) - 1) . $this->nowikitoken;
|
|
}
|
|
|
|
private function commit_nowiki_index() {
|
|
$token = "\Q" . $this->nowikitoken . "\E";
|
|
$this->string = preg_replace_callback("/" . $token . "(\d+)" . $token . "/",
|
|
array($this, "commit_nowiki_index_callback"), $this->string);
|
|
}
|
|
|
|
private function commit_nowiki_index_callback($match) {
|
|
return $this->nowikiindex[intval($match[1])];
|
|
}
|
|
|
|
/**
|
|
* Get token of the parsable element $name.
|
|
*/
|
|
public function get_token($name) {
|
|
foreach (array_merge($this->blockrules, $this->tagrules) as $n => $v) {
|
|
if ($name == $n && isset($v['token'])) {
|
|
return $v['token'] ? $v['token'] : false;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|