366 lines
12 KiB
PHP
366 lines
12 KiB
PHP
<?php
|
|
|
|
/**
|
|
* A base class for parsers.
|
|
*
|
|
* In the context of this plugin, a "parser" is a class that knows how to extract or modify
|
|
* a specific type of links from a given piece of text. For example, there could be a "HTML Link"
|
|
* parser that knows how to find and modify standard HTML links such as this one :
|
|
* <a href="http://example.com/">Example</a>
|
|
*
|
|
* Other parsers could extract plaintext URLs or handle metadata fields.
|
|
*
|
|
* Each parser has a list of supported formats (e.g. "html", "plaintext", etc) and container types
|
|
* (e.g. "post", "comment", "blogroll", etc). When something needs to be parsed, the involved
|
|
* container class will look up the parsers that support the relevant format or the container's type,
|
|
* and apply them to the to-be-parsed string.
|
|
*
|
|
* All sub-classes of blcParser should override at least the blcParser::parse() method.
|
|
*
|
|
* @see blcContainer::$fields
|
|
*
|
|
* @package Broken Link Checker
|
|
* @access public
|
|
*/
|
|
class blcParser extends blcModule {
|
|
|
|
var $parser_type;
|
|
var $supported_formats = array();
|
|
var $supported_containers = array();
|
|
|
|
/**
|
|
* Initialize the parser. Nothing much here.
|
|
*
|
|
* @return void
|
|
*/
|
|
function init(){
|
|
parent::init();
|
|
$this->parser_type = $this->module_id;
|
|
}
|
|
|
|
/**
|
|
* Called when the parser is activated.
|
|
*
|
|
* @return void
|
|
*/
|
|
function activated(){
|
|
parent::activated();
|
|
$this->resynch_relevant_containers();
|
|
}
|
|
|
|
/**
|
|
* Called when BLC is activated.
|
|
*/
|
|
function plugin_activated() {
|
|
//Intentionally do nothing. BLC can not parse containers while it's inactive, so we can be
|
|
//pretty sure that there are no already-parsed containers that need to be resynchronized.
|
|
}
|
|
|
|
/**
|
|
* Mark containers that this parser might be interested in as unparsed.
|
|
*
|
|
* @uses blcContainerHelper::mark_as_unsynched_where()
|
|
*
|
|
* @param bool $only_return If true, just return the list of formats and container types without actually modifying any synch. records.
|
|
* @return void|array Either nothing or an array in the form [ [format1=>timestamp1, ...], [container_type1=>timestamp1, ...] ]
|
|
*/
|
|
function resynch_relevant_containers($only_return = false){
|
|
global $blclog;
|
|
$blclog->log(sprintf('...... Parser "%s" is marking relevant items as unsynched', $this->module_id));
|
|
|
|
$last_deactivated = $this->module_manager->get_last_deactivation_time($this->module_id);
|
|
|
|
$formats = array();
|
|
foreach($this->supported_formats as $format){
|
|
$formats[$format] = $last_deactivated;
|
|
}
|
|
|
|
$container_types = array();
|
|
foreach($this->supported_containers as $container_type){
|
|
$container_types[$container_type] = $last_deactivated;
|
|
}
|
|
|
|
if ( $only_return ){
|
|
return array($formats, $container_types);
|
|
} else {
|
|
blcContainerHelper::mark_as_unsynched_where($formats, $container_types);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parse a string for links.
|
|
*
|
|
* @param string $content The text to parse.
|
|
* @param string $base_url The base URL to use for normalizing relative URLs. If ommitted, the blog's root URL will be used.
|
|
* @param string $default_link_text
|
|
* @return array An array of new blcLinkInstance objects. The objects will include info about the links found, but not about the corresponding container entity.
|
|
*/
|
|
function parse($content, $base_url = '', $default_link_text = ''){
|
|
return array();
|
|
}
|
|
|
|
/**
|
|
* Change all links that have a certain URL to a new URL.
|
|
*
|
|
* @param string $content Look for links in this string.
|
|
* @param string $new_url Change the links to this URL.
|
|
* @param string $old_url The URL to look for.
|
|
* @param string $old_raw_url The raw, not-normalized URL of the links to look for. Optional.
|
|
*
|
|
* @return array|WP_Error If successful, the return value will be an associative array with two
|
|
* keys : 'content' - the modified content, and 'raw_url' - the new raw, non-normalized URL used
|
|
* for the modified links. In most cases, the returned raw_url will be equal to the new_url.
|
|
*/
|
|
function edit($content, $new_url, $old_url, $old_raw_url){
|
|
return new WP_Error(
|
|
'not_implemented',
|
|
sprintf(__("Editing is not implemented in the '%s' parser", 'broken-link-checker'), $this->parser_type)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Remove all links that have a certain URL, leaving anchor text intact.
|
|
*
|
|
* @param string $content Look for links in this string.
|
|
* @param string $url The URL to look for.
|
|
* @param string $raw_url The raw, non-normalized version of the URL to look for. Optional.
|
|
* @return string Input string with all matching links removed.
|
|
*/
|
|
function unlink($content, $url, $raw_url){
|
|
return new WP_Error(
|
|
'not_implemented',
|
|
sprintf(__("Unlinking is not implemented in the '%s' parser", 'broken-link-checker'), $this->parser_type)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get the link text for printing in the "Broken Links" table.
|
|
* Sub-classes should override this method and display the link text in a way appropriate for the link type.
|
|
*
|
|
* @param blcLinkInstance $instance
|
|
* @param string $context
|
|
* @return string HTML
|
|
*/
|
|
function ui_get_link_text($instance, $context = 'display'){
|
|
return $instance->link_text;
|
|
}
|
|
|
|
/**
|
|
* Check if the parser supports editing the link text.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function is_link_text_editable() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if the parser supports editing the link URL.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function is_url_editable() {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Turn a relative URL into an absolute one.
|
|
*
|
|
* WordPress 3.4 has WP_Http::make_absolute_url() which is well-tested but not as comprehensive
|
|
* as this implementation. For example, WP_Http doesn't properly handle directory traversal with "..",
|
|
* and it removes #anchors for no good reason. The BLC implementation deals with both pretty well.
|
|
*
|
|
* @param string $url Relative URL.
|
|
* @param string $base_url Base URL. If omitted, the blog's root URL will be used.
|
|
* @return string
|
|
*/
|
|
function relative2absolute($url, $base_url = ''){
|
|
if ( empty($base_url) ){
|
|
$base_url = home_url();
|
|
}
|
|
|
|
$p = @parse_url($url);
|
|
if(!$p) {
|
|
//URL is a malformed
|
|
return false;
|
|
}
|
|
if( isset($p["scheme"]) ) return $url;
|
|
|
|
//If the relative URL is just a query string or anchor, simply attach it to the absolute URL and return
|
|
$first_char = substr($url, 0, 1);
|
|
if ( ($first_char == '?') || ($first_char == '#') ){
|
|
return $base_url . $url;
|
|
}
|
|
|
|
$parts=(parse_url($base_url));
|
|
|
|
//Protocol-relative URLs start with "//". We just need to prepend the right protocol.
|
|
if ( substr($url, 0, 2) === '//' ) {
|
|
$scheme = isset($parts['scheme']) ? $parts['scheme'] : 'http';
|
|
return $scheme . ':'. $url;
|
|
}
|
|
|
|
if(substr($url,0,1)=='/') {
|
|
//Relative URL starts with a slash => ignore the base path and jump straight to the root.
|
|
$path_segments = explode("/", $url);
|
|
array_shift($path_segments);
|
|
} else {
|
|
if(isset($parts['path'])){
|
|
$aparts=explode('/',$parts['path']);
|
|
array_pop($aparts);
|
|
$aparts=array_filter($aparts);
|
|
} else {
|
|
$aparts=array();
|
|
}
|
|
|
|
//Merge together the base path & the relative path
|
|
$aparts = array_merge($aparts, explode("/", $url));
|
|
|
|
//Filter the merged path
|
|
$path_segments = array();
|
|
foreach($aparts as $part){
|
|
if ( $part == '.' ){
|
|
continue; //. = "this directory". It's basically a no-op, so we skip it.
|
|
} elseif ( $part == '..' ) {
|
|
array_pop($path_segments); //.. = one directory up. Remove the last seen path segment.
|
|
} else {
|
|
array_push($path_segments, $part); //Normal directory -> add it to the path.
|
|
}
|
|
}
|
|
}
|
|
$path = implode("/", $path_segments);
|
|
|
|
//Build the absolute URL.
|
|
$url = '';
|
|
if($parts['scheme']) {
|
|
$url = "$parts[scheme]://";
|
|
}
|
|
if(isset($parts['user'])) {
|
|
$url .= $parts['user'];
|
|
if(isset($parts['pass'])) {
|
|
$url .= ":".$parts['pass'];
|
|
}
|
|
$url .= "@";
|
|
}
|
|
if(isset($parts['host'])) {
|
|
$url .= $parts['host'];
|
|
if(isset($parts['port'])) {
|
|
$url .= ':' . $parts['port'];
|
|
}
|
|
$url .= '/';
|
|
}
|
|
$url .= $path;
|
|
|
|
return $url;
|
|
}
|
|
|
|
/**
|
|
* Apply a callback function to all links found in a string and return the results.
|
|
*
|
|
* The first argument passed to the callback function will be an associative array
|
|
* of link data. If the optional $extra parameter is set, it will be passed as the
|
|
* second argument to the callback function.
|
|
*
|
|
* The link data array will contain at least these keys :
|
|
* 'href' - the URL of the link, as-is (i.e. without any sanitization or relative-to-absolute translation).
|
|
* '#raw' - the raw link code, e.g. the entire '<a href="...">...</a>' tag of a HTML link.
|
|
*
|
|
* Sub-classes may also set additional keys.
|
|
*
|
|
* This method is currently used only internally, so sub-classes are not required
|
|
* to implement it.
|
|
*
|
|
* @param string $content A text string to parse for links.
|
|
* @param callback $callback Callback function to apply to all found links.
|
|
* @param mixed $extra If the optional $extra param. is supplied, it will be passed as the second parameter to the function $callback.
|
|
* @return array An array of all detected links after applying $callback to each of them.
|
|
*/
|
|
function map($content, $callback, $extra = null){
|
|
return array();
|
|
}
|
|
|
|
/**
|
|
* Modify all links found in a string using a callback function.
|
|
*
|
|
* The first argument passed to the callback function will be an associative array
|
|
* of link data. If the optional $extra parameter is set, it will be passed as the
|
|
* second argument to the callback function. See the map() method of this class for
|
|
* details on the first argument.
|
|
*
|
|
* The callback function should return either an associative array or a string. If
|
|
* a string is returned, the parser will replace the current link with the contents
|
|
* of that string. If an array is returned, the current link will be modified/rebuilt
|
|
* by substituting the new values for the old ones (e.g. returning array with the key
|
|
* 'href' set to 'http://example.com/' will replace the current link's URL with
|
|
* http://example.com/).
|
|
*
|
|
* This method is currently only used internally, so sub-classes are not required
|
|
* to implement it.
|
|
*
|
|
* @see blcParser::map()
|
|
*
|
|
* @param string $content A text string containing the links to edit.
|
|
* @param callback $callback Callback function used to modify the links.
|
|
* @param mixed $extra If supplied, $extra will be passed as the second parameter to the function $callback.
|
|
* @return string The modified input string.
|
|
*/
|
|
function multi_edit($content, $callback, $extra = null){
|
|
return $content; //No-op
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A helper class for working with parsers. All its methods should be called statically.
|
|
*
|
|
* @see blcParser
|
|
*
|
|
* @package Broken Link Checker
|
|
* @access public
|
|
*/
|
|
class blcParserHelper {
|
|
|
|
/**
|
|
* Get the parser matching a parser type ID.
|
|
*
|
|
* @uses blcModuleManager::get_module()
|
|
*
|
|
* @param string $parser_type
|
|
* @return blcParser|null
|
|
*/
|
|
static function get_parser( $parser_type ){
|
|
$manager = blcModuleManager::getInstance();
|
|
return $manager->get_module($parser_type, true, 'parser');
|
|
}
|
|
|
|
/**
|
|
* Get all parsers that support either the specified format or the container type.
|
|
* If a parser supports both, it will still be included only once.
|
|
*
|
|
* @param string $format
|
|
* @param string $container_type
|
|
* @return blcParser[]
|
|
*/
|
|
static function get_parsers( $format, $container_type ){
|
|
$found = array();
|
|
|
|
//Retrieve a list of active parsers
|
|
$manager = blcModuleManager::getInstance();
|
|
$active_parsers = $manager->get_modules_by_category('parser');
|
|
|
|
//Try each one
|
|
foreach($active_parsers as $module_id => $module_data){
|
|
$parser = $manager->get_module($module_id); //Will autoload if necessary
|
|
if ( !$parser ){
|
|
continue;
|
|
}
|
|
|
|
if ( in_array($format, $parser->supported_formats) || in_array($container_type, $parser->supported_containers) ){
|
|
array_push($found, $parser);
|
|
}
|
|
}
|
|
|
|
return $found;
|
|
}
|
|
}
|
|
|