diff options
| author | Andrew Dolgov <[email protected]> | 2022-12-13 20:00:46 +0300 |
|---|---|---|
| committer | Andrew Dolgov <[email protected]> | 2022-12-13 20:00:46 +0300 |
| commit | 0226e0ca0dc70f9a0310b3eef045ee1c1e0ca3ac (patch) | |
| tree | 254c0e880693c2636107308b5931951cfa501311 /vendor/fivefilters/readability.php/src | |
split into a separate repo
Diffstat (limited to 'vendor/fivefilters/readability.php/src')
20 files changed, 3880 insertions, 0 deletions
diff --git a/vendor/fivefilters/readability.php/src/Configuration.php b/vendor/fivefilters/readability.php/src/Configuration.php new file mode 100644 index 0000000..6d1f03f --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Configuration.php @@ -0,0 +1,423 @@ +<?php + +namespace fivefilters\Readability; + +use Psr\Log\LoggerAwareTrait; +use Psr\Log\LoggerInterface; +use Psr\Log\NullLogger; + +/** + * Class Configuration. + */ +class Configuration +{ + use LoggerAwareTrait; + + /** + * @var int + */ + protected $maxTopCandidates = 5; + + /** + * @var int + */ + protected $charThreshold = 500; + + /** + * @var bool + */ + protected $articleByLine = false; + + /** + * @var bool + */ + protected $stripUnlikelyCandidates = true; + + /** + * @var bool + */ + protected $cleanConditionally = true; + + /** + * @var bool + */ + protected $weightClasses = true; + + /** + * @var bool + */ + protected $fixRelativeURLs = false; + + /** + * @var bool + */ + protected $substituteEntities = false; + + /** + * @var bool + */ + protected $normalizeEntities = false; + + /** + * @var bool + */ + protected $summonCthulhu = false; + + /** + * @var string + */ + protected $originalURL = 'http://fakehost'; + + /** + * @var string + */ + protected $parser = 'html5'; + + /** + * @var bool + */ + protected $keepClasses = false; + + /** + * @var bool + */ + protected $disableJSONLD = false; + + /** + * Configuration constructor. + * + * @param array $params + */ + public function __construct(array $params = []) + { + foreach ($params as $key => $value) { + $setter = sprintf('set%s', $key); + if (method_exists($this, $setter)) { + call_user_func([$this, $setter], $value); + } + } + } + + /** + * Returns an array-representation of configuration. + * + * @return array + */ + public function toArray() + { + $out = []; + foreach ($this as $key => $value) { + $getter = sprintf('get%s', $key); + if (!is_object($value) && method_exists($this, $getter)) { + $out[$key] = call_user_func([$this, $getter]); + } + } + + return $out; + } + + /** + * @return LoggerInterface + */ + public function getLogger() + { + // If no logger has been set, just return a null logger + if ($this->logger === null) { + return new NullLogger(); + } + + return $this->logger; + } + + /** + * @param LoggerInterface $logger + * + * @return Configuration + */ + public function setLogger(LoggerInterface $logger) + { + $this->logger = $logger; + + return $this; + } + + /** + * @return int + */ + public function getMaxTopCandidates() + { + return $this->maxTopCandidates; + } + + /** + * @param int $maxTopCandidates + * + * @return $this + */ + public function setMaxTopCandidates($maxTopCandidates) + { + $this->maxTopCandidates = $maxTopCandidates; + + return $this; + } + + /** + * @return int + */ + public function getCharThreshold() + { + return $this->charThreshold; + } + + /** + * @param int $charThreshold + * + * @return $this + */ + public function setCharThreshold($charThreshold) + { + $this->charThreshold = $charThreshold; + + return $this; + } + + /** + * @return bool + */ + public function getArticleByLine() + { + return $this->articleByLine; + } + + /** + * @param bool $articleByLine + * + * @return $this + */ + public function setArticleByLine($articleByLine) + { + $this->articleByLine = $articleByLine; + + return $this; + } + + /** + * @return bool + */ + public function getStripUnlikelyCandidates() + { + return $this->stripUnlikelyCandidates; + } + + /** + * @param bool $stripUnlikelyCandidates + * + * @return $this + */ + public function setStripUnlikelyCandidates($stripUnlikelyCandidates) + { + $this->stripUnlikelyCandidates = $stripUnlikelyCandidates; + + return $this; + } + + /** + * @return bool + */ + public function getCleanConditionally() + { + return $this->cleanConditionally; + } + + /** + * @param bool $cleanConditionally + * + * @return $this + */ + public function setCleanConditionally($cleanConditionally) + { + $this->cleanConditionally = $cleanConditionally; + + return $this; + } + + /** + * @return bool + */ + public function getWeightClasses() + { + return $this->weightClasses; + } + + /** + * @param bool $weightClasses + * + * @return $this + */ + public function setWeightClasses($weightClasses) + { + $this->weightClasses = $weightClasses; + + return $this; + } + + /** + * @return bool + */ + public function getFixRelativeURLs() + { + return $this->fixRelativeURLs; + } + + /** + * @param bool $fixRelativeURLs + * + * @return $this + */ + public function setFixRelativeURLs($fixRelativeURLs) + { + $this->fixRelativeURLs = $fixRelativeURLs; + + return $this; + } + + /** + * @return bool + */ + public function getSubstituteEntities() + { + return $this->substituteEntities; + } + + /** + * @param bool $substituteEntities + * + * @return $this + */ + public function setSubstituteEntities($substituteEntities) + { + $this->substituteEntities = $substituteEntities; + + return $this; + } + + /** + * @return bool + */ + public function getNormalizeEntities() + { + return $this->normalizeEntities; + } + + /** + * @param bool $normalizeEntities + * + * @return $this + */ + public function setNormalizeEntities($normalizeEntities) + { + $this->normalizeEntities = $normalizeEntities; + + return $this; + } + + /** + * @return string + */ + public function getOriginalURL() + { + return $this->originalURL; + } + + /** + * @param string $originalURL + * + * @return $this + */ + public function setOriginalURL($originalURL) + { + $this->originalURL = $originalURL; + + return $this; + } + + /** + * @return string + */ + public function getParser() + { + return $this->parser; + } + + /** + * @param string $parser + * + * @return $this + */ + public function setParser($parser) + { + $this->parser = $parser; + + return $this; + } + + /** + * @return bool + */ + public function getKeepClasses() + { + return $this->keepClasses; + } + + /** + * @param bool $keepClasses + * + * @return $this + */ + public function setKeepClasses($keepClasses) + { + $this->keepClasses = $keepClasses; + + return $this; + } + + /** + * @return bool + */ + public function getDisableJSONLD() + { + return $this->disableJSONLD; + } + + /** + * @param bool $disableJSONLD + * + * @return $this + */ + public function setDisableJSONLD($disableJSONLD) + { + $this->disableJSONLD = $disableJSONLD; + + return $this; + } + + /** + * @return bool + */ + public function getSummonCthulhu() + { + return $this->summonCthulhu; + } + + /** + * @param bool $summonCthulhu + * + * @return $this + */ + public function setSummonCthulhu($summonCthulhu) + { + $this->summonCthulhu = $summonCthulhu; + + return $this; + } +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMAttr.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMAttr.php new file mode 100644 index 0000000..1bdf395 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMAttr.php @@ -0,0 +1,10 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMAttr extends \DOMAttr +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMCdataSection.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMCdataSection.php new file mode 100644 index 0000000..6ac3dcd --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMCdataSection.php @@ -0,0 +1,10 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMCdataSection extends \DOMCdataSection +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMCharacterData.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMCharacterData.php new file mode 100644 index 0000000..b196979 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMCharacterData.php @@ -0,0 +1,10 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMCharacterData extends \DOMCharacterData +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMComment.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMComment.php new file mode 100644 index 0000000..3b691f4 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMComment.php @@ -0,0 +1,10 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMComment extends \DOMComment +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMDocument.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMDocument.php new file mode 100644 index 0000000..d912338 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMDocument.php @@ -0,0 +1,30 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMDocument extends \DOMDocument +{ + use NodeTrait; + + public function __construct($version, $encoding) + { + parent::__construct($version, $encoding); + + $this->registerNodeClass('DOMAttr', DOMAttr::class); + $this->registerNodeClass('DOMCdataSection', DOMCdataSection::class); + $this->registerNodeClass('DOMCharacterData', DOMCharacterData::class); + $this->registerNodeClass('DOMComment', DOMComment::class); + $this->registerNodeClass('DOMDocument', self::class); + $this->registerNodeClass('DOMDocumentFragment', DOMDocumentFragment::class); + $this->registerNodeClass('DOMDocumentType', DOMDocumentType::class); + $this->registerNodeClass('DOMElement', DOMElement::class); + $this->registerNodeClass('DOMEntity', DOMEntity::class); + $this->registerNodeClass('DOMEntityReference', DOMEntityReference::class); + $this->registerNodeClass('DOMNode', DOMNode::class); + $this->registerNodeClass('DOMNotation', DOMNotation::class); + $this->registerNodeClass('DOMProcessingInstruction', DOMProcessingInstruction::class); + $this->registerNodeClass('DOMText', DOMText::class); + } +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMDocumentFragment.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMDocumentFragment.php new file mode 100644 index 0000000..33a3f95 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMDocumentFragment.php @@ -0,0 +1,10 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMDocumentFragment extends \DOMDocumentFragment +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMDocumentType.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMDocumentType.php new file mode 100644 index 0000000..cf3cd0f --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMDocumentType.php @@ -0,0 +1,10 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMDocumentType extends \DOMDocumentType +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMElement.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMElement.php new file mode 100644 index 0000000..b0da84f --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMElement.php @@ -0,0 +1,46 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMElement extends \DOMElement +{ + use NodeTrait; + + /** + * Returns the child elements of this element. + * + * To get all child nodes, including non-element nodes like text and comment nodes, use childNodes. + * + * @return DOMNodeList + */ + public function children() + { + $newList = new DOMNodeList(); + foreach ($this->childNodes as $node) { + if ($node->nodeType === XML_ELEMENT_NODE) { + $newList->add($node); + } + } + return $newList; + } + + /** + * Returns the Element immediately prior to the specified one in its parent's children list, or null if the specified element is the first one in the list. + * + * @see https://wiki.php.net/rfc/dom_living_standard_api + * @return DOMElement|null + */ + public function previousElementSibling() + { + $previous = $this->previousSibling; + while ($previous) { + if ($previous->nodeType === XML_ELEMENT_NODE) { + return $previous; + } + $previous = $previous->previousSibling; + } + return null; + } +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMEntity.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMEntity.php new file mode 100644 index 0000000..751b59c --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMEntity.php @@ -0,0 +1,10 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMEntity extends \DOMEntity +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMEntityReference.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMEntityReference.php new file mode 100644 index 0000000..d6fd6d4 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMEntityReference.php @@ -0,0 +1,10 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMEntityReference extends \DOMEntityReference +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMNode.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMNode.php new file mode 100644 index 0000000..4a3ab0d --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMNode.php @@ -0,0 +1,14 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +/** + * @method getAttribute($attribute) + * @method hasAttribute($attribute) + */ +class DOMNode extends \DOMNode +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMNodeList.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMNodeList.php new file mode 100644 index 0000000..a718c00 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMNodeList.php @@ -0,0 +1,82 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +/** + * Class DOMNodeList. + * + * This is a fake DOMNodeList class that allows adding items to the list. The original class is static and the nodes + * are defined automagically when instantiating it. This fake version behaves exactly the same way but adds the function + * add() that allows to insert new DOMNodes into the DOMNodeList. + * + * It cannot extend the original DOMNodeList class because the functionality behind the property ->length is hidden + * from the user and cannot be extended, changed, or tweaked. + */ +class DOMNodeList implements \Countable, \IteratorAggregate +{ + /** + * @var array + */ + protected $items = []; + + /** + * @var int + */ + protected $length = 0; + + /** + * To allow access to length in the same way that DOMNodeList allows. + * + * {@inheritdoc} + */ + public function __get($name) + { + switch ($name) { + case 'length': + return $this->length; + default: + trigger_error(sprintf('Undefined property: %s::%s', static::class, $name)); + } + } + + /** + * @param DOMNode|DOMElement|DOMComment $node + * + * @return DOMNodeList + */ + public function add($node) + { + $this->items[] = $node; + $this->length++; + + return $this; + } + + /** + * @param int $offset + * + * @return DOMNode|DOMElement|DOMComment + */ + public function item(int $offset) + { + return $this->items[$offset]; + } + + /** + * @return int|void + */ + public function count(): int + { + return $this->length; + } + + /** + * To make it compatible with iterator_to_array() function. + * + * {@inheritdoc} + */ + public function getIterator(): \ArrayIterator + { + return new \ArrayIterator($this->items); + } +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMNotation.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMNotation.php new file mode 100644 index 0000000..d276e42 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMNotation.php @@ -0,0 +1,10 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMNotation extends \DOMNotation +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMProcessingInstruction.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMProcessingInstruction.php new file mode 100644 index 0000000..82c69cf --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMProcessingInstruction.php @@ -0,0 +1,10 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMProcessingInstruction extends \DOMProcessingInstruction +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMText.php b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMText.php new file mode 100644 index 0000000..6a5716c --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/DOM/DOMText.php @@ -0,0 +1,10 @@ +<?php + +namespace fivefilters\Readability\Nodes\DOM; + +use fivefilters\Readability\Nodes\NodeTrait; + +class DOMText extends \DOMText +{ + use NodeTrait; +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/NodeTrait.php b/vendor/fivefilters/readability.php/src/Nodes/NodeTrait.php new file mode 100644 index 0000000..1e9e3d1 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/NodeTrait.php @@ -0,0 +1,566 @@ +<?php + +namespace fivefilters\Readability\Nodes; + +use fivefilters\Readability\Nodes\DOM\DOMDocument; +use fivefilters\Readability\Nodes\DOM\DOMElement; +use fivefilters\Readability\Nodes\DOM\DOMNode; +use fivefilters\Readability\Nodes\DOM\DOMText; +use DOMNodeList; + +/** + * @method \DOMNode removeAttribute($name) + */ +trait NodeTrait +{ + /** + * Content score of the node. Used to determine the value of the content. + * + * @var int + */ + public $contentScore = 0; + + /** + * Flag for initialized status. + * + * @var bool + */ + private $initialized = false; + + /** + * Flag data tables. + * + * @var bool + */ + private $readabilityDataTable = false; + + /** + * @var array + */ + private $divToPElements = [ + 'blockquote', + 'dl', + 'div', + 'img', + 'ol', + 'p', + 'pre', + 'table', + 'ul' + ]; + + /** + * The commented out elements qualify as phrasing content but tend to be + * removed by readability when put into paragraphs, so we ignore them here. + * + * @var array + */ + private $phrasing_elems = [ + // 'CANVAS', 'IFRAME', 'SVG', 'VIDEO', + 'abbr', 'audio', 'b', 'bdo', 'br', 'button', 'cite', 'code', 'data', + 'datalist', 'dfn', 'em', 'embed', 'i', 'img', 'input', 'kbd', 'label', + 'mark', 'math', 'meter', 'noscript', 'object', 'output', 'progress', 'q', + 'ruby', 'samp', 'script', 'select', 'small', 'span', 'strong', 'sub', + 'sup', 'textarea', 'time', 'var', 'wbr' + ]; + + /** + * initialized getter. + * + * @return bool + */ + public function isInitialized() + { + return $this->initialized; + } + + /** + * @return bool + */ + public function isReadabilityDataTable() + { + /* + * This is a workaround that I'd like to remove in the future. + * Seems that although we are extending the base DOMElement and adding custom properties (like this one, + * 'readabilityDataTable'), these properties get lost when you search for elements with getElementsByTagName. + * This means that even if we mark the tables in a previous step, when we want to retrieve that information, + * all the custom properties are in their default values. Somehow we need to find a way to make these properties + * permanent across the whole DOM. + * + * @see https://stackoverflow.com/questions/35654709/php-registernodeclass-and-reusing-variable-names + */ + return $this->hasAttribute('readabilityDataTable') + && $this->getAttribute('readabilityDataTable') === '1'; +// return $this->readabilityDataTable; + } + + /** + * @param bool $param + */ + public function setReadabilityDataTable($param) + { + // Can't be "true" because DOMDocument casts it to "1" + $this->setAttribute('readabilityDataTable', $param ? '1' : '0'); +// $this->readabilityDataTable = $param; + } + + /** + * Initializer. Calculates the current score of the node and returns a full Readability object. + * + * @ TODO: I don't like the weightClasses param. How can we get the config here? + * + * @param $weightClasses bool Weight classes? + * + * @return static + */ + public function initializeNode($weightClasses) + { + if (!$this->isInitialized()) { + $contentScore = 0; + + switch ($this->nodeName) { + case 'div': + $contentScore += 5; + break; + + case 'pre': + case 'td': + case 'blockquote': + $contentScore += 3; + break; + + case 'address': + case 'ol': + case 'ul': + case 'dl': + case 'dd': + case 'dt': + case 'li': + case 'form': + $contentScore -= 3; + break; + + case 'h1': + case 'h2': + case 'h3': + case 'h4': + case 'h5': + case 'h6': + case 'th': + $contentScore -= 5; + break; + } + + $this->contentScore = $contentScore + ($weightClasses ? $this->getClassWeight() : 0); + + $this->initialized = true; + } + + return $this; + } + + /** + * Override for native getAttribute method. Some nodes have the getAttribute method, some don't, so we need + * to check first the existence of the attributes property. + * + * @param $attributeName string Attribute to retrieve + * + * @return string + */ + #[\ReturnTypeWillChange] + public function getAttribute($attributeName) + { + if (!is_null($this->attributes)) { + return parent::getAttribute($attributeName); + } + + return ''; + } + + /** + * Override for native hasAttribute. + * + * @param $attributeName + * + * @return bool + * + * @see getAttribute + */ + #[\ReturnTypeWillChange] + public function hasAttribute($attributeName) + { + if (!is_null($this->attributes)) { + return parent::hasAttribute($attributeName); + } + + return false; + } + + /** + * Get the ancestors of the current node. + * + * @param int|bool $maxLevel Max amount of ancestors to get. False for all of them + * + * @return array + */ + public function getNodeAncestors($maxLevel = 3) + { + $ancestors = []; + $level = 0; + + $node = $this->parentNode; + + while ($node && !($node instanceof DOMDocument)) { + $ancestors[] = $node; + $level++; + if ($level === $maxLevel) { + break; + } + $node = $node->parentNode; + } + + return $ancestors; + } + + /** + * Returns all links from the current element. + * + * @return array + */ + public function getAllLinks() + { + return iterator_to_array($this->getElementsByTagName('a')); + } + + /** + * Get the density of links as a percentage of the content + * This is the amount of text that is inside a link divided by the total text in the node. + * + * @return int + */ + public function getLinkDensity() + { + $textLength = mb_strlen($this->getTextContent(true)); + if ($textLength === 0) { + return 0; + } + + $linkLength = 0; + + $links = $this->getAllLinks(); + + if ($links) { + /** @var DOMElement $link */ + foreach ($links as $link) { + $href = $link->getAttribute('href'); + $coefficient = ($href && preg_match(NodeUtility::$regexps['hashUrl'], $href)) ? 0.3 : 1; + $linkLength += mb_strlen($link->getTextContent(true)) * $coefficient; + } + } + + return $linkLength / $textLength; + } + + /** + * Calculates the weight of the class/id of the current element. + * + * @return int + */ + public function getClassWeight() + { + $weight = 0; + + // Look for a special classname + $class = $this->getAttribute('class'); + if (trim($class)) { + if (preg_match(NodeUtility::$regexps['negative'], $class)) { + $weight -= 25; + } + + if (preg_match(NodeUtility::$regexps['positive'], $class)) { + $weight += 25; + } + } + + // Look for a special ID + $id = $this->getAttribute('id'); + if (trim($id) !== '') { + if (preg_match(NodeUtility::$regexps['negative'], $id)) { + $weight -= 25; + } + + if (preg_match(NodeUtility::$regexps['positive'], $id)) { + $weight += 25; + } + } + + return $weight; + } + + /** + * Returns the full text of the node. + * + * @param bool $normalize Normalize white space? + * + * @return string + */ + public function getTextContent($normalize = true) + { + $nodeValue = trim($this->textContent); + if ($normalize) { + $nodeValue = preg_replace(NodeUtility::$regexps['normalize'], ' ', $nodeValue); + } + + return $nodeValue; + } + + /** + * Return an array indicating how many rows and columns this table has. + * + * @return array + */ + public function getRowAndColumnCount() + { + $rows = $columns = 0; + $trs = $this->getElementsByTagName('tr'); + foreach ($trs as $tr) { + /** @var \DOMElement $tr */ + $rowspan = $tr->getAttribute('rowspan'); + $rows += ($rowspan || 1); + + // Now look for column-related info + $columnsInThisRow = 0; + $cells = $tr->getElementsByTagName('td'); + foreach ($cells as $cell) { + /** @var \DOMElement $cell */ + $colspan = $cell->getAttribute('colspan'); + $columnsInThisRow += ($colspan || 1); + } + $columns = max($columns, $columnsInThisRow); + } + + return ['rows' => $rows, 'columns' => $columns]; + } + + /** + * Creates a new node based on the text content of the original node. + * + * @param $originalNode DOMNode + * @param $tagName string + * + * @return DOMElement + */ + public function createNode($originalNode, $tagName) + { + $text = $originalNode->getTextContent(false); + $newNode = $originalNode->ownerDocument->createElement($tagName, $text); + + return $newNode; + } + + /** + * Check if a given node has one of its ancestor tag name matching the + * provided one. + * + * @param string $tagName + * @param int $maxDepth + * @param callable $filterFn + * + * @return bool + */ + public function hasAncestorTag($tagName, $maxDepth = 3, callable $filterFn = null) + { + $depth = 0; + $node = $this; + + while ($node->parentNode) { + if ($maxDepth > 0 && $depth > $maxDepth) { + return false; + } + + if ($node->parentNode->nodeName === $tagName && (!$filterFn || $filterFn($node->parentNode))) { + return true; + } + + $node = $node->parentNode; + $depth++; + } + + return false; + } + + /** + * Check if this node has only whitespace and a single element with given tag + * or if it contains no element with given tag or more than 1 element. + * + * @param $tag string Name of tag + * + * @return bool + */ + public function hasSingleTagInsideElement($tag) + { + // There should be exactly 1 element child with given tag + if (count($children = NodeUtility::filterTextNodes($this->childNodes)) !== 1 || $children->item(0)->nodeName !== $tag) { + return false; + } + + // And there should be no text nodes with real content + return array_reduce(iterator_to_array($children), function ($carry, $child) { + if (!$carry === false) { + return false; + } + + /* @var DOMNode $child */ + return !($child->nodeType === XML_TEXT_NODE && preg_match(NodeUtility::$regexps['hasContent'], $child->textContent)); + }); + } + + /** + * Check if the current element has a single child block element. + * Block elements are the ones defined in the divToPElements array. + * + * @return bool + */ + public function hasSingleChildBlockElement() + { + $result = false; + if ($this->hasChildNodes()) { + foreach ($this->childNodes as $child) { + if (in_array($child->nodeName, $this->divToPElements)) { + $result = true; + } else { + // If any of the hasSingleChildBlockElement calls return true, return true then. + /** @var $child DOMElement */ + $result = ($result || $child->hasSingleChildBlockElement()); + } + } + } + + return $result; + } + + /** + * Determines if a node has no content or it is just a bunch of dividing lines and/or whitespace. + * + * @return bool + */ + public function isElementWithoutContent() + { + return $this instanceof DOMElement && + mb_strlen(preg_replace(NodeUtility::$regexps['onlyWhitespace'], '', $this->textContent)) === 0 && + ($this->childNodes->length === 0 || + $this->childNodes->length === $this->getElementsByTagName('br')->length + $this->getElementsByTagName('hr')->length + /* + * Special PHP DOMDocument case: We also need to count how many DOMText we have inside the node. + * If there's an empty tag with an space inside and a BR (for example "<p> <br/></p>) counting only BRs and + * HRs will will say that the example has 2 nodes, instead of one. This happens because in DOMDocument, + * DOMTexts are also nodes (which doesn't happen in JS). So we need to also count how many DOMText we + * are dealing with (And at this point we know they are empty or are just whitespace, because of the + * mb_strlen in this chain of checks). + */ + + count(array_filter(iterator_to_array($this->childNodes), function ($child) { + return $child instanceof DOMText; + })) + + ); + } + + /** + * Determine if a node qualifies as phrasing content. + * https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/Content_categories#Phrasing_content. + * + * @return bool + */ + public function isPhrasingContent() + { + return $this->nodeType === XML_TEXT_NODE || in_array($this->nodeName, $this->phrasing_elems) !== false || + (!is_null($this->childNodes) && + ($this->nodeName === 'a' || $this->nodeName === 'del' || $this->nodeName === 'ins') && + array_reduce(iterator_to_array($this->childNodes), function ($carry, $node) { + return $node->isPhrasingContent() && $carry; + }, true) + ); + } + + /** + * In the original JS project they check if the node has the style display=none, which unfortunately + * in our case we have no way of knowing that. So we just check for the attribute hidden or "display: none". + * + * @return bool + */ + public function isProbablyVisible() + { + return !preg_match('/display:( )?none/i', $this->getAttribute('style')) && + !$this->hasAttribute('hidden') && + //check for "fallback-image" so that wikimedia math images are displayed + (!$this->hasAttribute('aria-hidden') || $this->getAttribute('aria-hidden') !== 'true' || ($this->hasAttribute('class') && strpos($this->getAttribute('class'), 'fallback-image') !== false)); + } + + /** + * @return bool + */ + public function isWhitespace() + { + return ($this->nodeType === XML_TEXT_NODE && mb_strlen(trim($this->textContent)) === 0) || + ($this->nodeType === XML_ELEMENT_NODE && $this->nodeName === 'br'); + } + + /** + * This is a hack that overcomes the issue of node shifting when scanning and removing nodes. + * + * In the JS version of getElementsByTagName, if you remove a node it will not appear during the + * foreach. This does not happen in PHP DOMDocument, because if you remove a node, it will still appear but as an + * orphan node and will give an exception if you try to do anything with it. + * + * Shifting also occurs when converting parent nodes (like a P to a DIV), which in that case the found nodes are + * removed from the foreach "pool" but the internal index of the foreach is not aware and skips over nodes that + * never looped over. (index is at position 5, 2 nodes are removed, next one should be node 3, but the foreach tries + * to access node 6) + * + * This function solves this by searching for the nodes on every loop and keeping track of the count differences. + * Because on every loop we call getElementsByTagName again, this could cause a performance impact and should be + * used only when the results of the search are going to be used to remove the nodes. + * + * @param string $tag + * + * @return \Generator + */ + public function shiftingAwareGetElementsByTagName($tag) + { + /** @var $nodes DOMNodeList */ + $nodes = $this->getElementsByTagName($tag); + $count = $nodes->length; + + for ($i = 0; $i < $count; $i = max(++$i, 0)) { + yield $nodes->item($i); + + // Search for all the nodes again + $nodes = $this->getElementsByTagName($tag); + + // Subtract the amount of nodes removed from the current index + $i -= $count - $nodes->length; + + // Subtract the amount of nodes removed from the current count + $count -= ($count - $nodes->length); + } + } + + /** + * Mimics JS's firstElementChild property. PHP only has firstChild which could be any type of DOMNode. Use this + * function to get the first one that is an DOMElement node. + * + * @return \DOMElement|null + */ + public function getFirstElementChild() + { + if ($this->childNodes instanceof \Traversable) { + foreach ($this->childNodes as $node) { + if ($node instanceof \DOMElement) { + return $node; + } + } + } + + return null; + } +} diff --git a/vendor/fivefilters/readability.php/src/Nodes/NodeUtility.php b/vendor/fivefilters/readability.php/src/Nodes/NodeUtility.php new file mode 100644 index 0000000..56de705 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Nodes/NodeUtility.php @@ -0,0 +1,192 @@ +<?php + +namespace fivefilters\Readability\Nodes; + +use fivefilters\Readability\Nodes\DOM\DOMDocument; +use fivefilters\Readability\Nodes\DOM\DOMElement; +use fivefilters\Readability\Nodes\DOM\DOMNode; +use fivefilters\Readability\Nodes\DOM\DOMNodeList; + +/** + * Class NodeUtility. + */ +class NodeUtility +{ + /** + * Collection of regexps to check the node usability. + * + * @var array + */ + public static $regexps = [ + 'unlikelyCandidates' => '/-ad-|ai2html|banner|breadcrumbs|combx|comment|community|cover-wrap|disqus|extra|footer|gdpr|header|legends|menu|related|remark|replies|rss|shoutbox|sidebar|skyscraper|social|sponsor|supplemental|ad-break|agegate|pagination|pager|popup|yom-remote/i', + 'okMaybeItsACandidate' => '/and|article|body|column|content|main|shadow/i', + 'extraneous' => '/print|archive|comment|discuss|e[\-]?mail|share|reply|all|login|sign|single|utility/i', + 'byline' => '/byline|author|dateline|writtenby|p-author/i', + 'replaceFonts' => '/<(\/?)font[^>]*>/i', + 'normalize' => '/\s{2,}/', + 'videos' => '/\/\/(www\.)?((dailymotion|youtube|youtube-nocookie|player\.vimeo|v\.qq)\.com|(archive|upload\.wikimedia)\.org|player\.twitch\.tv)/i', + 'shareElements' => '/(\b|_)(share|sharedaddy)(\b|_)/i', + 'nextLink' => '/(next|weiter|continue|>([^\|]|$)|»([^\|]|$))/i', + 'prevLink' => '/(prev|earl|old|new|<|«)/i', + 'tokenize' => '/\W+/', + 'whitespace' => '/^\s*$/', + 'hasContent' => '/\S$/', + 'positive' => '/article|body|content|entry|hentry|h-entry|main|page|pagination|post|text|blog|story/i', + 'negative' => '/-ad-|hidden|^hid$| hid$| hid |^hid |banner|combx|comment|com-|contact|foot|footer|footnote|gdpr|masthead|media|meta|outbrain|promo|related|scroll|share|shoutbox|sidebar|skyscraper|sponsor|shopping|tags|tool|widget/i', + // \x{00A0} is the unicode version of + 'onlyWhitespace' => '/\x{00A0}|\s+/u', + 'hashUrl' => '/^#.+/', + 'srcsetUrl' => '/(\S+)(\s+[\d.]+[xw])?(\s*(?:,|$))/', + 'b64DataUrl' => '/^data:\s*([^\s;,]+)\s*;\s*base64\s*,/i', + // See: https://schema.org/Article + 'jsonLdArticleTypes' => '/^Article|AdvertiserContentArticle|NewsArticle|AnalysisNewsArticle|AskPublicNewsArticle|BackgroundNewsArticle|OpinionNewsArticle|ReportageNewsArticle|ReviewNewsArticle|Report|SatiricalArticle|ScholarlyArticle|MedicalScholarlyArticle|SocialMediaPosting|BlogPosting|LiveBlogPosting|DiscussionForumPosting|TechArticle|APIReference$/' + + ]; + + /** + * Finds the next node, starting from the given node, and ignoring + * whitespace in between. If the given node is an element, the same node is + * returned. + * + * Imported from the Element class on league\html-to-markdown. + * + * @param $node + * + * @return DOMNode + */ + public static function nextNode($node) + { + $next = $node; + while ($next + && $next->nodeType !== XML_ELEMENT_NODE + && $next->isWhitespace()) { + $next = $next->nextSibling; + } + + return $next; + } + + /** + * Changes the node tag name. Since tagName on DOMElement is a read only value, this must be done creating a new + * element with the new tag name and importing it to the main DOMDocument. + * + * @param DOMNode $node + * @param string $value + * @param bool $importAttributes + * + * @return DOMNode + */ + public static function setNodeTag($node, $value, $importAttributes = true) + { + $new = new DOMDocument('1.0', 'utf-8'); + $new->appendChild($new->createElement($value)); + + $children = $node->childNodes; + /** @var $children \DOMNodeList $i */ + for ($i = 0; $i < $children->length; $i++) { + $import = $new->importNode($children->item($i), true); + $new->firstChild->appendChild($import); + } + + if ($importAttributes) { + // Import attributes from the original node. + foreach ($node->attributes as $attribute) { + $new->firstChild->setAttribute($attribute->nodeName, $attribute->nodeValue); + } + } + + // The import must be done on the firstChild of $new, since $new is a DOMDocument and not a DOMElement. + $import = $node->ownerDocument->importNode($new->firstChild, true); + $node->parentNode->replaceChild($import, $node); + + return $import; + } + + /** + * Removes the current node and returns the next node to be parsed (child, sibling or parent). + * + * @param DOMNode $node + * + * @return DOMNode + */ + public static function removeAndGetNext($node) + { + $nextNode = self::getNextNode($node, true); + $node->parentNode->removeChild($node); + + return $nextNode; + } + + /** + * Remove the selected node. + * + * @param $node DOMElement + * + * @return void + **/ + public static function removeNode($node) + { + $parent = $node->parentNode; + if ($parent) { + $parent->removeChild($node); + } + } + + /** + * Returns the next node. First checks for children (if the flag allows it), then for siblings, and finally + * for parents. + * + * @param DOMNode $originalNode + * @param bool $ignoreSelfAndKids + * + * @return DOMNode + */ + public static function getNextNode($originalNode, $ignoreSelfAndKids = false) + { + /* + * Traverse the DOM from node to node, starting at the node passed in. + * Pass true for the second parameter to indicate this node itself + * (and its kids) are going away, and we want the next node over. + * + * Calling this in a loop will traverse the DOM depth-first. + */ + + // First check for kids if those aren't being ignored + if (!$ignoreSelfAndKids && $originalNode->firstChild) { + return $originalNode->firstChild; + } + + // Then for siblings... + if ($originalNode->nextSibling) { + return $originalNode->nextSibling; + } + + // And finally, move up the parent chain *and* find a sibling + // (because this is depth-first traversal, we will have already + // seen the parent nodes themselves). + do { + $originalNode = $originalNode->parentNode; + } while ($originalNode && !$originalNode->nextSibling); + + return ($originalNode) ? $originalNode->nextSibling : $originalNode; + } + + /** + * Remove all empty DOMNodes from DOMNodeLists. + * + * @param \DOMNodeList $list + * + * @return DOMNodeList + */ + public static function filterTextNodes(\DOMNodeList $list) + { + $newList = new DOMNodeList(); + foreach ($list as $node) { + if ($node->nodeType !== XML_TEXT_NODE || mb_strlen(trim($node->nodeValue))) { + $newList->add($node); + } + } + + return $newList; + } +} diff --git a/vendor/fivefilters/readability.php/src/ParseException.php b/vendor/fivefilters/readability.php/src/ParseException.php new file mode 100644 index 0000000..587da33 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/ParseException.php @@ -0,0 +1,7 @@ +<?php + +namespace fivefilters\Readability; + +class ParseException extends \Exception +{ +} diff --git a/vendor/fivefilters/readability.php/src/Readability.php b/vendor/fivefilters/readability.php/src/Readability.php new file mode 100644 index 0000000..6407a92 --- /dev/null +++ b/vendor/fivefilters/readability.php/src/Readability.php @@ -0,0 +1,2410 @@ +<?php + +namespace fivefilters\Readability; + +use fivefilters\Readability\Nodes\DOM\DOMDocument; +use fivefilters\Readability\Nodes\DOM\DOMElement; +use fivefilters\Readability\Nodes\DOM\DOMNode; +use fivefilters\Readability\Nodes\DOM\DOMText; +use fivefilters\Readability\Nodes\NodeUtility; +use Psr\Log\LoggerInterface; +use \Masterminds\HTML5; +use League\Uri\Http; +use League\Uri\UriResolver; + +/** + * Class Readability. + */ +class Readability +{ + /** + * Main DOMDocument where all the magic happens. + * + * @var DOMDocument + */ + protected $dom; + + /** + * Title of the article. + * + * @var string|null + */ + protected $title = null; + + /** + * Final DOMDocument with the fully parsed HTML. + * + * @var DOMDocument|null + */ + protected $content = null; + + /** + * Excerpt of the article. + * + * @var string|null + */ + protected $excerpt = null; + + /** + * Main image of the article. + * + * @var string|null + */ + protected $image = null; + + /** + * Author of the article. Extracted from the byline tags and other social media properties. + * + * @var string|null + */ + protected $author = null; + + /** + * Website name. + * + * @var string|null + */ + protected $siteName = null; + + /** + * Direction of the text. + * + * @var string|null + */ + protected $direction = null; + + /** + * Base URI + * HTML5PHP doesn't appear to store it in the baseURI property like PHP's DOMDocument does when parsing with libxml + * + * @var string|null + */ + protected $baseURI = null; + + /** + * Configuration object. + * + * @var Configuration + */ + private $configuration; + + /** + * Logger object. + * + * @var LoggerInterface + */ + private $logger; + + /** + * JSON-LD + * + * @var array + */ + private $jsonld = []; + + /** + * Collection of attempted text extractions. + * + * @var array + */ + private $attempts = []; + + /** + * @var array + */ + private $defaultTagsToScore = [ + 'section', + 'h2', + 'h3', + 'h4', + 'h5', + 'h6', + 'p', + 'td', + 'pre', + ]; + + /** + * @var array + */ + private $unlikelyRoles = ['menu', 'menubar', 'complementary', 'navigation', 'alert', 'alertdialog', 'dialog']; + + /** + * @var array + */ + private $alterToDIVExceptions = [ + 'div', + 'article', + 'section', + 'p', + ]; + + /** + * @var array + */ + private $htmlEscapeMap = [ + 'lt' => '<', + 'gt' => '>', + 'amp' => '&', + 'quot' => '"', + 'apos' => '\'', + ]; + + /** + * Readability constructor. + * + * @param Configuration $configuration + */ + public function __construct(Configuration $configuration) + { + $this->configuration = $configuration; + $this->logger = $this->configuration->getLogger(); + } + + /** + * Main parse function. + * + * @param $html + * + * @throws ParseException + * + * @return bool + */ + public function parse($html) + { + $this->logger->info('*** Starting parse process...'); + + $this->dom = $this->loadHTML($html); + + // Checking for minimum HTML to work with. + if (!($root = $this->dom->getElementsByTagName('body')->item(0)) || !$root->firstChild) { + $this->logger->emergency('No body tag present or body tag empty'); + + throw new ParseException('Invalid or incomplete HTML.'); + } + + $this->getMetadata(); + + $this->getMainImage(); + + while (true) { + $this->logger->debug('Starting parse loop'); + $root = $root->firstChild; + + $elementsToScore = $this->getNodes($root); + $this->logger->debug(sprintf('Elements to score: \'%s\'', count($elementsToScore))); + + $result = $this->rateNodes($elementsToScore); + + /* + * Now that we've gone through the full algorithm, check to see if + * we got any meaningful content. If we didn't, we may need to re-run + * grabArticle with different flags set. This gives us a higher likelihood of + * finding the content, and the sieve approach gives us a higher likelihood of + * finding the -right- content. + */ + + $length = mb_strlen(preg_replace(NodeUtility::$regexps['onlyWhitespace'], '', $result->textContent)); + + $this->logger->info(sprintf('[Parsing] Article parsed. Amount of words: %s. Current threshold is: %s', $length, $this->configuration->getCharThreshold())); + + if ($result && $length < $this->configuration->getCharThreshold()) { + $this->dom = $this->loadHTML($html); + $root = $this->dom->getElementsByTagName('body')->item(0); + + if ($this->configuration->getStripUnlikelyCandidates()) { + $this->logger->debug('[Parsing] Threshold not met, trying again setting StripUnlikelyCandidates as false'); + $this->configuration->setStripUnlikelyCandidates(false); + $this->attempts[] = ['articleContent' => $result, 'textLength' => $length]; + } elseif ($this->configuration->getWeightClasses()) { + $this->logger->debug('[Parsing] Threshold not met, trying again setting WeightClasses as false'); + $this->configuration->setWeightClasses(false); + $this->attempts[] = ['articleContent' => $result, 'textLength' => $length]; + } elseif ($this->configuration->getCleanConditionally()) { + $this->logger->debug('[Parsing] Threshold not met, trying again setting CleanConditionally as false'); + $this->configuration->setCleanConditionally(false); + $this->attempts[] = ['articleContent' => $result, 'textLength' => $length]; + } else { + $this->logger->debug('[Parsing] Threshold not met, searching across attempts for some content.'); + $this->attempts[] = ['articleContent' => $result, 'textLength' => $length]; + + // No luck after removing flags, just return the longest text we found during the different loops + usort($this->attempts, function ($a, $b) { + return $b['textLength'] - $a['textLength']; + }); + + // But first check if we actually have something + if (!$this->attempts[0]['textLength']) { + $this->logger->emergency('[Parsing] Could not parse text, giving up :('); + + throw new ParseException('Could not parse text.'); + } + + $this->logger->debug('[Parsing] Threshold not met, but found some content in previous attempts.'); + + $result = $this->attempts[0]['articleContent']; + break; + } + } else { + break; + } + } + + if (!$result) { + $this->logger->info('*** Parse failed :('); + return false; + } + + $result = $this->postProcessContent($result); + + // If we haven't found an excerpt in the article's metadata, use the article's + // first paragraph as the excerpt. This can be used for displaying a preview of + // the article's content. + if (!$this->getExcerpt()) { + $this->logger->debug('[Parsing] No excerpt text found on metadata, extracting first p node and using it as excerpt.'); + $paragraphs = $result->getElementsByTagName('p'); + if ($paragraphs->length > 0) { + $this->setExcerpt(trim($paragraphs->item(0)->textContent)); + } + } + + $this->setContent($result); + + $this->logger->info('*** Parse successful :)'); + + return true; + } + + /** + * Creates a DOM Document object and loads the provided HTML on it. + * + * Used for the first load of Readability and subsequent reloads (when disabling flags and rescanning the text) + * Previous versions of Readability used this method one time and cloned the DOM to keep a backup. This caused bugs + * because cloning the DOM object keeps a relation between the clone and the original one, doing changes in both + * objects and ruining the backup. + * + * @param string $html + * + * @return DOMDocument + */ + private function loadHTML($html) + { + $this->logger->debug('[Loading] Loading HTML...'); + + // To avoid throwing a gazillion of errors on malformed HTMLs + libxml_use_internal_errors(true); + + //$html = preg_replace('/(<br[^>]*>[ \n\r\t]*){2,}/i', '</p><p>', $html); + + if ($this->configuration->getParser() === 'html5') { + $this->logger->debug('[Loading] Using HTML5 parser...'); + $html5 = new HTML5(['disable_html_ns' => true, 'target_document' => new DOMDocument('1.0', 'utf-8')]); + $dom = $html5->loadHTML($html); + //TODO: Improve this so it looks inside <html><head><base>, not just any <base> + $base = $dom->getElementsByTagName('base'); + if ($base->length > 0) { + $base = $base->item(0); + $base = $base->getAttribute('href'); + if ($base != '') { + $this->baseURI = $base; + } + } + } else { + $this->logger->debug('[Loading] Using libxml parser...'); + $dom = new DOMDocument('1.0', 'utf-8'); + if ($this->configuration->getNormalizeEntities()) { + $this->logger->debug('[Loading] Normalized entities via mb_convert_encoding.'); + // Replace UTF-8 characters with the HTML Entity equivalent. Useful to fix html with mixed content + $html = mb_convert_encoding($html, 'HTML-ENTITIES', 'UTF-8'); + } + } + + if (!$this->configuration->getSubstituteEntities()) { + // Keep the original HTML entities + $dom->substituteEntities = false; + } + + if ($this->configuration->getSummonCthulhu()) { + $this->logger->debug('[Loading] Removed script tags via regex H̶͈̩̟̬̱͠E̡̨̬͔̳̜͢͠ ̡̧̯͉̩͙̩̹̞̠͎͈̹̥̠͞ͅͅC̶͉̞̘̖̝̗͓̬̯͍͉̤̬͢͢͞Ò̟̘͉͖͎͉̱̭̣̕M̴̯͈̻̱̱̣̗͈̠̙̲̥͘͞E̷̛͙̼̲͍͕̹͍͇̗̻̬̮̭̱̥͢Ş̛̟͔̙̜̤͇̮͍̙̝̀͘'); + $html = preg_replace('/<script\b[^>]*>([\s\S]*?)<\/script>/', '', $html); + } + + // Prepend the XML tag to avoid having issues with special characters. Should be harmless. + if ($this->configuration->getParser() !== 'html5') { + $dom->loadHTML('<?xml encoding="UTF-8">' . $html); + $this->baseURI = $dom->baseURI; + } + $dom->encoding = 'UTF-8'; + + // Unwrap image from noscript + $this->unwrapNoscriptImages($dom); + + // Extract JSON-LD metadata before removing scripts + $this->jsonld = $this->configuration->getDisableJSONLD() ? [] : $this->getJSONLD($dom); + + $this->removeScripts($dom); + + $this->prepDocument($dom); + + $this->logger->debug('[Loading] Loaded HTML successfully.'); + + return $dom; + } + + /** + * Try to extract metadata from JSON-LD object. + * For now, only Schema.org objects of type Article or its subtypes are supported. + * + * @param DOMDocument $dom + * @return Object with any metadata that could be extracted (possibly none) + */ + private function getJSONLD(DOMDocument $dom) + { + $scripts = $this->_getAllNodesWithTag($dom, ['script']); + + $jsonLdElement = $this->findNode($scripts, function ($el) { + return $el->getAttribute('type') === 'application/ld+json'; + }); + + if ($jsonLdElement) { + try { + // Strip CDATA markers if present + $content = preg_replace('/^\s*<!\[CDATA\[|\]\]>\s*$/', '', $jsonLdElement->textContent); + $parsed = json_decode($content, true); + $metadata = []; + if ( + !isset($parsed['@context']) || + !is_string($parsed['@context']) || + !preg_match('/^https?\:\/\/schema\.org$/', $parsed['@context']) + ) { + return $metadata; + } + + if (!isset($parsed['@type']) && isset($parsed['@graph']) && is_array($parsed['@graph'])) { + $_found = null; + foreach ($parsed['@graph'] as $it) { + if (isset($it['@type']) && is_string($it['@type']) && preg_match(NodeUtility::$regexps['jsonLdArticleTypes'], $it['@type'])) { + $_found = $it; + } + } + $parsed = $_found; + } + + if ( + !$parsed || + !isset($parsed['@type']) || + !is_string($parsed['@type']) || + !preg_match(NodeUtility::$regexps['jsonLdArticleTypes'], $parsed['@type']) + ) { + return $metadata; + } + if (isset($parsed['name']) && is_string($parsed['name'])) { + $metadata['title'] = trim($parsed['name']); + } elseif (isset($parsed['headline']) && is_string($parsed['headline'])) { + $metadata['title'] = trim($parsed['headline']); + } + if (isset($parsed['author'])) { + if (isset($parsed['author']['name']) && is_string($parsed['author']['name'])) { + $metadata['byline'] = trim($parsed['author']['name']); + } elseif ( + is_array($parsed['author']) && + isset($parsed['author'][0]) && + is_array($parsed['author'][0]) && + isset($parsed['author'][0]['name']) && + is_string($parsed['author'][0]['name']) + ) { + $metadata['byline'] = array_filter($parsed['author'], function ($author) { + return is_array($author) && isset($author['name']) && is_string($author['name']); + }); + $metadata['byline'] = array_map(function ($author) { + return trim($author['name']); + }, $metadata['byline']); + $metadata['byline'] = implode(', ', $metadata['byline']); + } + } + if (isset($parsed['description']) && is_string($parsed['description'])) { + $metadata['excerpt'] = trim($parsed['description']); + } + if ( + isset($parsed['publisher']) && + is_array($parsed['publisher']) && + isset($parsed['publisher']['name']) && + is_string($parsed['publisher']['name']) + ) { + $metadata['siteName'] = trim($parsed['publisher']['name']); + } + return $metadata; + } catch (\Exception $err) { + // The try-catch blocks are from the JS version. Not sure if there's anything + // here in the PHP version that would trigger an error or exception, so perhaps we can + // remove the try-catch blocks here (or at least translate errors to exceptions for this bit) + $this->logger->debug('[JSON-LD] Error parsing: ' . $err->getMessage()); + } + } + return []; + } + + /** + * Tries to guess relevant info from metadata of the html. Sets the results in the Readability properties. + */ + private function getMetadata() + { + $this->logger->debug('[Metadata] Retrieving metadata...'); + + $values = []; + // property is a space-separated list of values + $propertyPattern = '/\s*(dc|dcterm|og|twitter)\s*:\s*(author|creator|description|title|image|site_name)(?!:)\s*/i'; + + // name is a single value + $namePattern = '/^\s*(?:(dc|dcterm|og|twitter|weibo:(article|webpage))\s*[\.:]\s*)?(author|creator|description|title|image|site_name)(?!:)\s*$/i'; + + // Find description tags. + foreach ($this->dom->getElementsByTagName('meta') as $meta) { + /* @var DOMNode $meta */ + $elementName = $meta->getAttribute('name'); + $elementProperty = $meta->getAttribute('property'); + $content = $meta->getAttribute('content'); + $matches = null; + $name = null; + + if ($elementProperty) { + if (preg_match($propertyPattern, $elementProperty, $matches)) { + $name = preg_replace('/\s/', '', mb_strtolower($matches[0])); + // multiple authors + $values[$name] = trim($content); + } + } + + if (!$matches && $elementName && preg_match($namePattern, $elementName)) { + $name = $elementName; + if ($content) { + // Convert to lowercase, remove any whitespace, and convert dots + // to colons so we can match below. + $name = preg_replace(['/\s/', '/\./'], ['', ':'], mb_strtolower($name)); + $values[$name] = trim($content); + } + } + } + + // get title + /* + * This is a very convoluted way of extracting the first matching key of the $values array + * against a set of options. + * + * This could be easily replaced with an ugly set of isset($values['key']) or a bunch of ??s. + * Will probably replace it with ??s after dropping support of PHP5.6 + */ + $key = current(array_intersect([ + 'dc:title', + 'dcterm:title', + 'og:title', + 'weibo:article:title', + 'weibo:webpage:title', + 'title', + 'twitter:title' + ], array_keys($values))); + + if (isset($this->jsonld['title'])) { + $this->setTitle($this->jsonld['title']); + } else { + $this->setTitle(isset($values[$key]) ? trim($values[$key]) : null); + } + + if (!$this->getTitle()) { + $this->setTitle($this->getArticleTitle()); + } + + // get author + $key = current(array_intersect([ + 'dc:creator', + 'dcterm:creator', + 'author' + ], array_keys($values))); + + if (isset($this->jsonld['byline'])) { + $this->setAuthor($this->jsonld['byline']); + } else { + $this->setAuthor(isset($values[$key]) ? $values[$key] : null); + } + + // get description + $key = current(array_intersect([ + 'dc:description', + 'dcterm:description', + 'og:description', + 'weibo:article:description', + 'weibo:webpage:description', + 'description', + 'twitter:description' + ], array_keys($values))); + + if (isset($this->jsonld['excerpt'])) { + $this->setExcerpt($this->jsonld['excerpt']); + } else { + $this->setExcerpt(isset($values[$key]) ? $values[$key] : null); + } + + // get main image + $key = current(array_intersect([ + 'image', + 'og:image', + 'twitter:image' + ], array_keys($values))); + + $this->setImage(isset($values[$key]) ? $values[$key] : null); + + $key = current(array_intersect([ + 'og:site_name' + ], array_keys($values))); + + if (isset($this->jsonld['siteName'])) { + $this->setSiteName($this->jsonld['siteName']); + } else { + $this->setSiteName(isset($values[$key]) ? $values[$key] : null); + } + + // in many sites the meta value is escaped with HTML entities, + // so here we need to unescape it + $this->setTitle($this->unescapeHtmlEntities($this->getTitle())); + $this->setAuthor($this->unescapeHtmlEntities($this->getAuthor())); + $this->setExcerpt($this->unescapeHtmlEntities($this->getExcerpt())); + $this->setSiteName($this->unescapeHtmlEntities($this->getSiteName())); + } + + /** + * Returns all the images of the parsed article. + * + * @return array + */ + public function getImages() + { + $result = []; + if ($this->getImage()) { + $result[] = $this->getImage(); + } + + if (null == $this->getDOMDocument()) { + return $result; + } + + foreach ($this->getDOMDocument()->getElementsByTagName('img') as $img) { + if ($src = $img->getAttribute('src')) { + $result[] = $src; + } + } + + if ($this->configuration->getFixRelativeURLs()) { + foreach ($result as &$imgSrc) { + $imgSrc = $this->toAbsoluteURI($imgSrc); + } + } + + $result = array_unique(array_filter($result)); + + return $result; + } + + /** + * Tries to get the main article image. Will only update the metadata if the getMetadata function couldn't + * find a correct image. + */ + public function getMainImage() + { + $imgUrl = false; + + if ($this->getImage() !== null) { + $imgUrl = $this->getImage(); + } + + if (!$imgUrl) { + foreach ($this->dom->getElementsByTagName('link') as $link) { + /** @var \DOMElement $link */ + /* + * Check for the rel attribute, then check if the rel attribute is either img_src or image_src, and + * finally check for the existence of the href attribute, which should hold the image url. + */ + if ($link->hasAttribute('rel') && ($link->getAttribute('rel') === 'img_src' || $link->getAttribute('rel') === 'image_src') && $link->hasAttribute('href')) { + $imgUrl = $link->getAttribute('href'); + break; + } + } + } + + if (!empty($imgUrl) && $this->configuration->getFixRelativeURLs()) { + $this->setImage($this->toAbsoluteURI($imgUrl)); + } + } + + /** + * Remove unnecessary nested elements + * + * @param DOMDocument $article + * + * @return void + */ + private function simplifyNestedElements(DOMDocument $article) + { + $node = $article; + + while ($node) { + if ($node->parentNode && in_array($node->nodeName, ['div', 'section']) && !($node->hasAttribute('id') && strpos($node->getAttribute('id'), 'readability') === 0)) { + if ($node->isElementWithoutContent()) { + $node = NodeUtility::removeAndGetNext($node); + continue; + } elseif ($node->hasSingleTagInsideElement('div') || $node->hasSingleTagInsideElement('section')) { + $child = $node->children()->item(0); + for ($i = 0; $i < $node->attributes->length; $i++) { + $child->setAttribute($node->attributes->item($i)->name, $node->attributes->item($i)->value); + } + $node->parentNode->replaceChild($child, $node); + $node = $child; + continue; + } + } + + $node = NodeUtility::getNextNode($node); + } + } + + /** + * Returns the title of the html. Prioritizes the title from the metadata against the title tag. + * + * @return string|null + */ + private function getArticleTitle() + { + $originalTitle = null; + + if ($this->getTitle()) { + $originalTitle = $this->getTitle(); + } else { + $this->logger->debug('[Metadata] Could not find title in metadata, searching for the title tag...'); + $titleTag = $this->dom->getElementsByTagName('title'); + if ($titleTag->length > 0) { + $this->logger->info(sprintf('[Metadata] Using title tag as article title: \'%s\'', $titleTag->item(0)->nodeValue)); + $originalTitle = $titleTag->item(0)->nodeValue; + } + } + + if ($originalTitle === null) { + return null; + } + + $curTitle = $originalTitle = trim($originalTitle); + $titleHadHierarchicalSeparators = false; + + /* + * If there's a separator in the title, first remove the final part + * + * Sanity warning: if you eval this match in PHPStorm's "Evaluate expression" box, it will return false + * I can assure you it works properly if you let the code run. + */ + if (preg_match('/ [\|\-\\\\\/>»] /i', $curTitle)) { + $titleHadHierarchicalSeparators = (bool) preg_match('/ [\\\\\/>»] /', $curTitle); + $curTitle = preg_replace('/(.*)[\|\-\\\\\/>»] .*/i', '$1', $originalTitle); + + $this->logger->info(sprintf('[Metadata] Found hierarchical separators in title, new title is: \'%s\'', $curTitle)); + + // If the resulting title is too short (3 words or fewer), remove + // the first part instead: + if (count(preg_split('/\s+/', $curTitle)) < 3) { + $curTitle = preg_replace('/[^\|\-\\\\\/>»]*[\|\-\\\\\/>»](.*)/i', '$1', $originalTitle); + $this->logger->info(sprintf('[Metadata] Title too short, using the first part of the title instead: \'%s\'', $curTitle)); + } + } elseif (strpos($curTitle, ': ') !== false) { + // Check if we have an heading containing this exact string, so we + // could assume it's the full title. + $match = false; + for ($i = 1; $i <= 2; $i++) { + foreach ($this->dom->getElementsByTagName('h' . $i) as $hTag) { + // Trim texts to avoid having false negatives when the title is surrounded by spaces or tabs + if (trim($hTag->nodeValue) === trim($curTitle)) { + $match = true; + } + } + } + + // If we don't, let's extract the title out of the original title string. + if (!$match) { + $curTitle = substr($originalTitle, strrpos($originalTitle, ':') + 1); + + $this->logger->info(sprintf('[Metadata] Title has a colon in the middle, new title is: \'%s\'', $curTitle)); + + // If the title is now too short, try the first colon instead: + if (count(preg_split('/\s+/', $curTitle)) < 3) { + $curTitle = substr($originalTitle, strpos($originalTitle, ':') + 1); + $this->logger->info(sprintf('[Metadata] Title too short, using the first part of the title instead: \'%s\'', $curTitle)); + } elseif (count(preg_split('/\s+/', substr($curTitle, 0, strpos($curTitle, ':')))) > 5) { + // But if we have too many words before the colon there's something weird + // with the titles and the H tags so let's just use the original title instead + $curTitle = $originalTitle; + } + } + } elseif (mb_strlen($curTitle) > 150 || mb_strlen($curTitle) < 15) { + $hOnes = $this->dom->getElementsByTagName('h1'); + + if ($hOnes->length === 1) { + $curTitle = $hOnes->item(0)->nodeValue; + $this->logger->info(sprintf('[Metadata] Using title from an H1 node: \'%s\'', $curTitle)); + } + } + + $curTitle = preg_replace(NodeUtility::$regexps['normalize'], ' ', trim($curTitle)); + + /* + * If we now have 4 words or fewer as our title, and either no + * 'hierarchical' separators (\, /, > or ») were found in the original + * title or we decreased the number of words by more than 1 word, use + * the original title. + */ + $curTitleWordCount = count(preg_split('/\s+/', $curTitle)); + $originalTitleWordCount = count(preg_split('/\s+/', preg_replace('/[\|\-\\\\\/>»]+/', '', $originalTitle))) - 1; + + if ($curTitleWordCount <= 4 && + (!$titleHadHierarchicalSeparators || $curTitleWordCount !== $originalTitleWordCount)) { + $curTitle = $originalTitle; + + $this->logger->info(sprintf('Using title from an H1 node: \'%s\'', $curTitle)); + } + + return $curTitle; + } + + /** + * Convert URI to an absolute URI. + * + * @param $uri string URI to convert + * + * @return string + */ + private function toAbsoluteURI($uri) + { + list($pathBase, $scheme, $prePath) = $this->getPathInfo($this->configuration->getOriginalURL()); + + $uri = trim($uri); + + // If this is already an absolute URI, return it. + if (preg_match('/^[a-zA-Z][a-zA-Z0-9\+\-\.]*:/', $uri)) { + return $uri; + } + + // Scheme-rooted relative URI. + if (substr($uri, 0, 2) === '//') { + return $scheme . '://' . substr($uri, 2); + } + + // Prepath-rooted relative URI. + if (substr($uri, 0, 1) === '/') { + return $prePath . $uri; + } + + // Ignore hash URIs: + if (substr($uri, 0, 1) === '#') { + return $uri; + } + + // Dotslash relative URI. + //if (strpos($uri, './') === 0) { + // return $pathBase . substr($uri, 2); + //} + + $baseUri = Http::createFromString($pathBase); + $relativeUri = Http::createFromString($uri); + return (string)UriResolver::resolve($relativeUri, $baseUri); + + // Standard relative URI; add entire path. pathBase already includes a + // trailing "/". + //return $pathBase . $uri; + } + + /** + * Returns full path info of an URL. + * + * @param string $url + * + * @return array [$pathBase, $scheme, $prePath] + */ + public function getPathInfo($url) + { + // Check for base URLs + if ($this->baseURI !== null) { + if (substr($this->baseURI, 0, 1) === '/') { + // URLs starting with '/' override completely the URL defined in the link + $pathBase = parse_url($url, PHP_URL_SCHEME) . '://' . parse_url($url, PHP_URL_HOST) . $this->baseURI; + } else { + // Otherwise just prepend the base to the actual path + $pathBase = parse_url($url, PHP_URL_SCHEME) . '://' . parse_url($url, PHP_URL_HOST) . dirname(parse_url($url, PHP_URL_PATH)) . '/'.rtrim($this->baseURI, '/') . '/'; + } + } else { + $pathBase = parse_url($url, PHP_URL_SCHEME) . '://' . parse_url($url, PHP_URL_HOST) . dirname(parse_url($url, PHP_URL_PATH)) . '/'; + } + + $scheme = parse_url($pathBase, PHP_URL_SCHEME); + $prePath = $scheme . '://' . parse_url($pathBase, PHP_URL_HOST); + + return [$pathBase, $scheme, $prePath]; + } + + /** + * Gets nodes from the root element. + * + * @param $node DOMNode|DOMText + * + * @return array + */ + private function getNodes($node) + { + $this->logger->info('[Get Nodes] Retrieving nodes...'); + + $stripUnlikelyCandidates = $this->configuration->getStripUnlikelyCandidates(); + + $elementsToScore = []; + + $shouldRemoveTitleHeader = true; + + /* + * First, node prepping. Trash nodes that look cruddy (like ones with the + * class name "comment", etc), and turn divs into P tags where they have been + * used inappropriately (as in, where they contain no other block level elements.) + */ + + while ($node) { + // Remove DOMComments nodes as we don't need them and mess up children counting + if ($node->nodeType === XML_COMMENT_NODE) { + $this->logger->debug(sprintf('[Get Nodes] Found comment node, removing... Node content was: \'%s\'', substr($node->nodeValue, 0, 128))); + $node = NodeUtility::removeAndGetNext($node); + continue; + } + + $matchString = $node->getAttribute('class') . ' ' . $node->getAttribute('id'); + + if (!$node->isProbablyVisible()) { + $this->logger->debug(sprintf('[Get Nodes] Removing hidden node... Match string was: \'%s\'', $matchString)); + $node = NodeUtility::removeAndGetNext($node); + continue; + } + + // Check to see if this node is a byline, and remove it if it is. + if ($this->checkByline($node, $matchString)) { + $this->logger->debug(sprintf('[Get Nodes] Found byline, removing... Node content was: \'%s\'', substr($node->nodeValue, 0, 128))); + $node = NodeUtility::removeAndGetNext($node); + continue; + } + + if ($shouldRemoveTitleHeader && $this->headerDuplicatesTitle($node)) { + $this->logger->debug(sprintf('Removing header: %s', $node->getTextContent())); + $shouldRemoveTitleHeader = false; + $node = NodeUtility::removeAndGetNext($node); + continue; + } + + // Remove unlikely candidates + if ($stripUnlikelyCandidates) { + if ( + preg_match(NodeUtility::$regexps['unlikelyCandidates'], $matchString) && + !preg_match(NodeUtility::$regexps['okMaybeItsACandidate'], $matchString) && + !$node->hasAncestorTag( 'table') && + !$node->hasAncestorTag( 'code') && + $node->nodeName !== 'body' && + $node->nodeName !== 'a' + ) { + $this->logger->debug(sprintf('[Get Nodes] Removing unlikely candidate. Node content was: \'%s\'', substr($node->nodeValue, 0, 128))); + $node = NodeUtility::removeAndGetNext($node); + continue; + } + } + + if (in_array($node->getAttribute('role'), $this->unlikelyRoles)) { + $this->logger->debug(sprintf('Removing content with role %s - %s', $node->getAttribute('role'), $matchString)); + $node = NodeUtility::removeAndGetNext($node); + continue; + } + + // Remove DIV, SECTION, and HEADER nodes without any content(e.g. text, image, video, or iframe). + if (($node->nodeName === 'div' || $node->nodeName === 'section' || $node->nodeName === 'header' || + $node->nodeName === 'h1' || $node->nodeName === 'h2' || $node->nodeName === 'h3' || + $node->nodeName === 'h4' || $node->nodeName === 'h5' || $node->nodeName === 'h6' || + $node->nodeName === 'p') && + $node->isElementWithoutContent()) { + $this->logger->debug(sprintf('[Get Nodes] Removing empty \'%s\' node.', $node->nodeName)); + $node = NodeUtility::removeAndGetNext($node); + continue; + } + + if (in_array(strtolower($node->nodeName), $this->defaultTagsToScore)) { + $this->logger->debug(sprintf('[Get Nodes] Adding node to score list, node content is: \'%s\'', substr($node->nodeValue, 0, 128))); + $elementsToScore[] = $node; + } + + // Turn all divs that don't have children block level elements into p's + if ($node->nodeName === 'div') { + // Put phrasing content into paragraphs. + $p = null; + $childNode = $node->firstChild; + while ($childNode) { + $nextSibling = $childNode->nextSibling; + if ($childNode->isPhrasingContent()) { + if ($p !== null) { + $p->appendChild($childNode); + } elseif (!$childNode->isWhitespace()) { + $p = $this->dom->createElement('p'); + $node->replaceChild($p, $childNode); + $p->appendChild($childNode); + } + } elseif ($p !== null) { + while ($p->lastChild && $p->lastChild->isWhitespace()) { + $p->removeChild($p->lastChild); + } + $p = null; + } + $childNode = $nextSibling; + } + + /* + * Sites like http://mobile.slate.com encloses each paragraph with a DIV + * element. DIVs with only a P element inside and no text content can be + * safely converted into plain P elements to avoid confusing the scoring + * algorithm with DIVs with are, in practice, paragraphs. + */ + if ($node->hasSingleTagInsideElement('p') && $node->getLinkDensity() < 0.25) { + $this->logger->debug(sprintf('[Get Nodes] Found DIV with a single P node, removing DIV. Node content is: \'%s\'', substr($node->nodeValue, 0, 128))); + $pNode = NodeUtility::filterTextNodes($node->childNodes)->item(0); + $node->parentNode->replaceChild($pNode, $node); + $node = $pNode; + $elementsToScore[] = $node; + } elseif (!$node->hasSingleChildBlockElement()) { + $this->logger->debug(sprintf('[Get Nodes] Found DIV with a single child block element, converting to a P node. Node content is: \'%s\'', substr($node->nodeValue, 0, 128))); + $node = NodeUtility::setNodeTag($node, 'p'); + $elementsToScore[] = $node; + } + } + + $node = NodeUtility::getNextNode($node); + } + + return $elementsToScore; + } + + /** + * compares second text to first one + * 1 = same text, 0 = completely different text + * works the way that it splits both texts into words and then finds words that are unique in second text + * the result is given by the lower length of unique parts + * + * @param string $textA + * @param string $textB + * + * @return int 1 = same text, 0 = completely different text + */ + private function textSimilarity(string $textA, string $textB) { + $tokensA = array_filter(preg_split(NodeUtility::$regexps['tokenize'], mb_strtolower($textA))); + $tokensB = array_filter(preg_split(NodeUtility::$regexps['tokenize'], mb_strtolower($textB))); + if (!count($tokensA) || !count($tokensB)) { + return 0; + } + $uniqTokensB = array_filter($tokensB, function ($token) use (&$tokensA) { + return !in_array($token, $tokensA); + }); + $distanceB = mb_strlen(implode(' ', $uniqTokensB)) / mb_strlen(implode(' ', $tokensB)); + return 1 - $distanceB; + } + + /** + * Checks if the node is a byline. + * + * @param DOMNode $node + * @param string $matchString + * + * @return bool + */ + private function checkByline($node, $matchString) + { + if (!$this->configuration->getArticleByLine()) { + return false; + } + + /* + * Check if the byline is already set + */ + if ($this->getAuthor()) { + return false; + } + + $rel = $node->getAttribute('rel'); + $itemprop = $node->getAttribute("itemprop"); + + if ($rel === 'author' || ($itemprop && strpos($itemprop, 'author') !== false) || preg_match(NodeUtility::$regexps['byline'], $matchString) && $this->isValidByline($node->getTextContent(false))) { + $this->logger->info(sprintf('[Metadata] Found article author: \'%s\'', $node->getTextContent(false))); + $this->setAuthor(trim($node->getTextContent(false))); + + return true; + } + + return false; + } + + /** + * Checks the validity of a byLine. Based on string length. + * + * @param string $text + * + * @return bool + */ + private function isValidByline($text) + { + if (gettype($text) == 'string') { + $byline = trim($text); + + return (mb_strlen($byline) > 0) && (mb_strlen($byline) < 100); + } + + return false; + } + + /** + * Converts some of the common HTML entities in string to their corresponding characters. + * + * @param string $str - a string to unescape. + * @return string without HTML entity. + */ + private function unescapeHtmlEntities($str) { + if (!$str) { + return $str; + } + + $htmlEscapeMap = $this->htmlEscapeMap; + $str = preg_replace_callback('/&(quot|amp|apos|lt|gt);/', function ($tag) use ($htmlEscapeMap) { + return $htmlEscapeMap[$tag[1]]; + }, $str); + $str = preg_replace_callback('/&#(?:x([0-9a-z]{1,4})|([0-9]{1,4}));/i', function ($matches) { + $hex = $matches[1]; + $numStr = $matches[2]; + if ($hex !== '') { + $num = intval($hex, 16); + } else { + $num = intval($numStr, 10); + } + return mb_chr($num); + }, $str); + return $str; + } + + /** + * Check if node is image, or if node contains exactly only one image + * whether as a direct child or as its descendants. + * + * @param DOMElement $node + */ + private function isSingleImage(DOMElement $node) { + if ($node->tagName === 'img') { + return true; + } + + if ($node->children()->length !== 1 || trim($node->textContent) !== '') { + return false; + } + + return $this->isSingleImage($node->children()->item(0)); + } + + /** + * Find all <noscript> that are located after <img> nodes, and which contain only one + * <img> element. Replace the first image with the image from inside the <noscript> tag, + * and remove the <noscript> tag. This improves the quality of the images we use on + * some sites (e.g. Medium). + * + * @param DOMDocument $dom + */ + private function unwrapNoscriptImages(DOMDocument $dom) { + // Find img without source or attributes that might contains image, and remove it. + // This is done to prevent a placeholder img is replaced by img from noscript in next step. + $imgs = iterator_to_array($dom->getElementsByTagName('img')); + array_walk($imgs, function ($img) { + for ($i = 0; $i < $img->attributes->length; $i++) { + $attr = $img->attributes->item($i); + switch ($attr->name) { + case 'src': + case 'srcset': + case 'data-src': + case 'data-srcset': + return; + } + + if (preg_match('/\.(jpg|jpeg|png|webp)/i', $attr->value)) { + return; + } + } + + $img->parentNode->removeChild($img); + }); + + // Next find noscript and try to extract its image + $noscripts = iterator_to_array($dom->getElementsByTagName('noscript')); + array_walk($noscripts, function ($noscript) use($dom) { + // Parse content of noscript and make sure it only contains image + // [PHP port] Could copy innerHTML support over for the commented lines below, but is it needed? + // var tmp = doc.createElement("div"); + // tmp.innerHTML = noscript.innerHTML; + $tmp = $noscript->cloneNode(true); + $dom->importNode($tmp); + if (!$this->isSingleImage($tmp)) { + return; + } + + // If noscript has previous sibling and it only contains image, + // replace it with noscript content. However we also keep old + // attributes that might contains image. + $prevElement = $noscript->previousElementSibling(); + if ($prevElement && $this->isSingleImage($prevElement)) { + $prevImg = $prevElement; + if ($prevImg->tagName !== 'img') { + $prevImg = $prevElement->getElementsByTagName('img')->item(0); + } + + $newImg = $tmp->getElementsByTagName('img')->item(0); + for ($i = 0; $i < $prevImg->attributes->length; $i++) { + $attr = $prevImg->attributes->item($i); + if ($attr->value === '') { + continue; + } + + if ($attr->name === 'src' || $attr->name === 'srcset' || preg_match('/\.(jpg|jpeg|png|webp)/i', $attr->value)) { + if ($newImg->getAttribute($attr->name) === $attr->value) { + continue; + } + + $attrName = $attr->name; + if ($newImg->hasAttribute($attrName)) { + $attrName = 'data-old-' . $attrName; + } + + $newImg->setAttribute($attrName, $attr->value); + } + } + + $noscript->parentNode->replaceChild($tmp->getFirstElementChild(), $prevElement); + } + }); + } + + /** + * Removes all the scripts of the html. + * + * @param DOMDocument $dom + */ + private function removeScripts(DOMDocument $dom) + { + foreach (['script', 'noscript'] as $tag) { + $nodes = $dom->getElementsByTagName($tag); + foreach (iterator_to_array($nodes) as $node) { + NodeUtility::removeNode($node); + } + } + } + + /** + * Prepares the document for parsing. + * + * @param DOMDocument $dom + */ + private function prepDocument(DOMDocument $dom) + { + $this->logger->info('[PrepDocument] Preparing document for parsing...'); + + foreach ($dom->shiftingAwareGetElementsByTagName('br') as $br) { + $next = $br->nextSibling; + + /* + * Whether 2 or more <br> elements have been found and replaced with a + * <p> block. + */ + $replaced = false; + + /* + * If we find a <br> chain, remove the <br>s until we hit another element + * or non-whitespace. This leaves behind the first <br> in the chain + * (which will be replaced with a <p> later). + */ + while (($next = NodeUtility::nextNode($next)) && ($next->nodeName === 'br')) { + $this->logger->debug('[PrepDocument] Removing chain of BR nodes...'); + + $replaced = true; + $brSibling = $next->nextSibling; + $next->parentNode->removeChild($next); + $next = $brSibling; + } + + /* + * If we removed a <br> chain, replace the remaining <br> with a <p>. Add + * all sibling nodes as children of the <p> until we hit another <br> + * chain. + */ + + if ($replaced) { + $p = $dom->createElement('p'); + $br->parentNode->replaceChild($p, $br); + + $next = $p->nextSibling; + while ($next) { + // If we've hit another <br><br>, we're done adding children to this <p>. + if ($next->nodeName === 'br') { + $nextElem = NodeUtility::nextNode($next->nextSibling); + if ($nextElem && $nextElem->nodeName === 'br') { + break; + } + } + + if (!$next->isPhrasingContent()) { + break; + } + + $this->logger->debug('[PrepDocument] Replacing BR with a P node...'); + + // Otherwise, make this node a child of the new <p>. + $sibling = $next->nextSibling; + $p->appendChild($next); + $next = $sibling; + } + + while ($p && $p->lastChild && $p->lastChild->isWhitespace()) { + $p->removeChild($p->lastChild); + } + + while ($p && $p->firstChild && $p->firstChild->isWhitespace()) { + $p->removeChild($p->firstChild); + } + + if ($p->parentNode->tagName === 'p') { + NodeUtility::setNodeTag($p->parentNode, 'div'); + } + } + } + + // Replace font tags with span + $fonts = $this->_getAllNodesWithTag($dom, ['font']); + $length = count($fonts); + for ($i = 0; $i < $length; $i++) { + $this->logger->debug('[PrepDocument] Converting font tag into a span tag.'); + $font = $fonts[$length - 1 - $i]; + NodeUtility::setNodeTag($font, 'span'); + } + } + + /** + * Assign scores to each node. Returns full article parsed or false on error. + * + * @param array $nodes + * + * @return DOMDocument|bool + */ + private function rateNodes($nodes) + { + $this->logger->info('[Rating] Rating nodes...'); + + $candidates = []; + + /** @var DOMElement $node */ + foreach ($nodes as $node) { + if (is_null($node->parentNode)) { + continue; + } + + // Discard nodes with less than 25 characters, without blank space + if (mb_strlen($node->getTextContent(true)) < 25) { + continue; + } + + $ancestors = $node->getNodeAncestors(5); + + // Exclude nodes with no ancestor + if (count($ancestors) === 0) { + continue; + } + + // Start with a point for the paragraph itself as a base. + $contentScore = 1; + + // Add points for any commas within this paragraph. + $contentScore += count(explode(',', $node->getTextContent(true))); + + // For every 100 characters in this paragraph, add another point. Up to 3 points. + $contentScore += min(floor(mb_strlen($node->getTextContent(true)) / 100), 3); + + $this->logger->debug(sprintf('[Rating] Node score %s, content: \'%s\'', $contentScore, substr($node->nodeValue, 0, 128))); + + /** @var $ancestor DOMElement */ + foreach ($ancestors as $level => $ancestor) { + $this->logger->debug('[Rating] Found ancestor, initializing and adding it as a candidate...'); + if (!$ancestor->isInitialized()) { + $ancestor->initializeNode($this->configuration->getWeightClasses()); + $candidates[] = $ancestor; + } + + /* + * Node score divider: + * - parent: 1 (no division) + * - grandparent: 2 + * - great grandparent+: ancestor level * 3 + */ + + if ($level === 0) { + $scoreDivider = 1; + } elseif ($level === 1) { + $scoreDivider = 2; + } else { + $scoreDivider = $level * 3; + } + + $currentScore = $ancestor->contentScore; + $ancestor->contentScore = $currentScore + ($contentScore / $scoreDivider); + + $this->logger->debug(sprintf('[Rating] Ancestor score %s, value: \'%s\'', $ancestor->contentScore, substr($ancestor->nodeValue, 0, 128))); + } + } + + /* + * After we've calculated scores, loop through all of the possible + * candidate nodes we found and find the one with the highest score. + */ + + $topCandidates = []; + foreach ($candidates as $candidate) { + + /* + * Scale the final candidates score based on link density. Good content + * should have a relatively small link density (5% or less) and be mostly + * unaffected by this operation. + */ + + $candidate->contentScore = $candidate->contentScore * (1 - $candidate->getLinkDensity()); + + for ($i = 0; $i < $this->configuration->getMaxTopCandidates(); $i++) { + $aTopCandidate = isset($topCandidates[$i]) ? $topCandidates[$i] : null; + + if (!$aTopCandidate || $candidate->contentScore > $aTopCandidate->contentScore) { + array_splice($topCandidates, $i, 0, [$candidate]); + if (count($topCandidates) > $this->configuration->getMaxTopCandidates()) { + array_pop($topCandidates); + } + break; + } + } + } + + $topCandidate = isset($topCandidates[0]) ? $topCandidates[0] : null; + $parentOfTopCandidate = null; + + /* + * If we still have no top candidate, just use the body as a last resort. + * We also have to copy the body node so it is something we can modify. + */ + + if ($topCandidate === null || $topCandidate->nodeName === 'body') { + $this->logger->info('[Rating] No top candidate found or top candidate is the body tag. Moving all child nodes to a new DIV node.'); + + // Move all of the page's children into topCandidate + $topCandidate = new DOMDocument('1.0', 'utf-8'); + $topCandidate->encoding = 'UTF-8'; + $topCandidate->appendChild($topCandidate->createElement('div', '')); + $kids = $this->dom->getElementsByTagName('body')->item(0)->childNodes; + + // Cannot be foreached, don't ask me why. + for ($i = 0; $i < $kids->length; $i++) { + $import = $topCandidate->importNode($kids->item($i), true); + $topCandidate->firstChild->appendChild($import); + } + + // Candidate must be created using firstChild to grab the DOMElement instead of the DOMDocument. + $topCandidate = $topCandidate->firstChild; + } elseif ($topCandidate) { + $this->logger->info(sprintf('[Rating] Found top candidate, score: %s', $topCandidate->contentScore)); + // Find a better top candidate node if it contains (at least three) nodes which belong to `topCandidates` array + // and whose scores are quite closed with current `topCandidate` node. + $alternativeCandidateAncestors = []; + for ($i = 1; $i < count($topCandidates); $i++) { + // In some cases we may end up with a top candidate with zero content score. To avoid dividing by zero + // we have to use max() and replace zero with a low value like 0.1 + if ($topCandidates[$i]->contentScore / max($topCandidate->contentScore, 0.1) >= 0.75) { + array_push($alternativeCandidateAncestors, $topCandidates[$i]->getNodeAncestors(false)); + } + } + + $MINIMUM_TOPCANDIDATES = 3; + if (count($alternativeCandidateAncestors) >= $MINIMUM_TOPCANDIDATES) { + $parentOfTopCandidate = $topCandidate->parentNode; + + // Check if we are actually dealing with a DOMNode and not a DOMDocument node or higher + while ($parentOfTopCandidate && $parentOfTopCandidate->nodeName !== 'body' && $parentOfTopCandidate->nodeType === XML_ELEMENT_NODE) { + $listsContainingThisAncestor = 0; + for ($ancestorIndex = 0; $ancestorIndex < count($alternativeCandidateAncestors) && $listsContainingThisAncestor < $MINIMUM_TOPCANDIDATES; $ancestorIndex++) { + $listsContainingThisAncestor += (int)in_array($parentOfTopCandidate, $alternativeCandidateAncestors[$ancestorIndex]); + } + if ($listsContainingThisAncestor >= $MINIMUM_TOPCANDIDATES) { + $topCandidate = $parentOfTopCandidate; + break; + } + $parentOfTopCandidate = $parentOfTopCandidate->parentNode; + } + } + + /* + * Because of our bonus system, parents of candidates might have scores + * themselves. They get half of the node. There won't be nodes with higher + * scores than our topCandidate, but if we see the score going *up* in the first + * few steps up the tree, that's a decent sign that there might be more content + * lurking in other places that we want to unify in. The sibling stuff + * below does some of that - but only if we've looked high enough up the DOM + * tree. + */ + + $parentOfTopCandidate = $topCandidate->parentNode; + $lastScore = $topCandidate->contentScore; + + // The scores shouldn't get too low. + $scoreThreshold = $lastScore / 3; + + /* @var DOMElement $parentOfTopCandidate */ + while ($parentOfTopCandidate && $parentOfTopCandidate->nodeName !== 'body') { + $parentScore = $parentOfTopCandidate->contentScore; + if ($parentScore < $scoreThreshold) { + break; + } + + if ($parentScore > $lastScore) { + // Alright! We found a better parent to use. + $topCandidate = $parentOfTopCandidate; + $this->logger->info('[Rating] Found a better top candidate.'); + break; + } + $lastScore = $parentOfTopCandidate->contentScore; + $parentOfTopCandidate = $parentOfTopCandidate->parentNode; + } + + // If the top candidate is the only child, use parent instead. This will help sibling + // joining logic when adjacent content is actually located in parent's sibling node. + $parentOfTopCandidate = $topCandidate->parentNode; + while ($parentOfTopCandidate && $parentOfTopCandidate->nodeName !== 'body' && count(NodeUtility::filterTextNodes($parentOfTopCandidate->childNodes)) === 1) { + $topCandidate = $parentOfTopCandidate; + $parentOfTopCandidate = $topCandidate->parentNode; + } + } + + /* + * Now that we have the top candidate, look through its siblings for content + * that might also be related. Things like preambles, content split by ads + * that we removed, etc. + */ + + $this->logger->info('[Rating] Creating final article content document...'); + + $articleContent = new DOMDocument('1.0', 'utf-8'); + $articleContent->createElement('div'); + + $siblingScoreThreshold = max(10, $topCandidate->contentScore * 0.2); + // Keep potential top candidate's parent node to try to get text direction of it later. + $parentOfTopCandidate = $topCandidate->parentNode; + $siblings = $parentOfTopCandidate->childNodes; + + $hasContent = false; + + $this->logger->info('[Rating] Adding top candidate siblings...'); + + /* @var DOMElement $sibling */ + // Can't foreach here because down there we might change the tag name and that causes the foreach to skip items + for ($i = 0; $i < $siblings->length; $i++) { + $sibling = $siblings[$i]; + $append = false; + + if ($sibling === $topCandidate) { + $this->logger->debug('[Rating] Sibling is equal to the top candidate, adding to the final article...'); + + $append = true; + } else { + $contentBonus = 0; + + // Give a bonus if sibling nodes and top candidates have the example same classname + if ($sibling->getAttribute('class') === $topCandidate->getAttribute('class') && $topCandidate->getAttribute('class') !== '') { + $contentBonus += $topCandidate->contentScore * 0.2; + } + if ($sibling->contentScore + $contentBonus >= $siblingScoreThreshold) { + $append = true; + } elseif ($sibling->nodeName === 'p') { + $linkDensity = $sibling->getLinkDensity(); + $nodeContent = $sibling->getTextContent(true); + + if (mb_strlen($nodeContent) > 80 && $linkDensity < 0.25) { + $append = true; + } elseif ($nodeContent && mb_strlen($nodeContent) < 80 && $linkDensity === 0 && preg_match('/\.( |$)/', $nodeContent)) { + $append = true; + } + } + } + + if ($append) { + $this->logger->debug(sprintf('[Rating] Appending sibling to final article, content is: \'%s\'', substr($sibling->nodeValue, 0, 128))); + + $hasContent = true; + + if (!in_array(strtolower($sibling->nodeName), $this->alterToDIVExceptions)) { + /* + * We have a node that isn't a common block level element, like a form or td tag. + * Turn it into a div so it doesn't get filtered out later by accident. + */ + $sibling = NodeUtility::setNodeTag($sibling, 'div'); + } + + $import = $articleContent->importNode($sibling, true); + $articleContent->appendChild($import); + + /* + * No node shifting needs to be check because when calling getChildren, an array is made with the + * children of the parent node, instead of using the DOMElement childNodes function, which, when used + * along with appendChild, would shift the nodes position and the current foreach will behave in + * unpredictable ways. + */ + } + } + + $articleContent = $this->prepArticle($articleContent); + + if ($hasContent) { + // Find out text direction from ancestors of final top candidate. + $ancestors = array_merge([$parentOfTopCandidate, $topCandidate], $parentOfTopCandidate->getNodeAncestors()); + foreach ($ancestors as $ancestor) { + $articleDir = $ancestor->getAttribute('dir'); + if ($articleDir) { + $this->setDirection($articleDir); + $this->logger->debug(sprintf('[Rating] Found article direction: %s', $articleDir)); + break; + } + } + + return $articleContent; + } else { + return false; + } + } + + /** + * Cleans up the final article. + * + * @param DOMDocument $article + * + * @return DOMDocument + */ + public function prepArticle(DOMDocument $article) + { + $this->logger->info('[PrepArticle] Preparing final article...'); + + $this->_cleanStyles($article); + $this->_clean($article, 'style'); + + // Check for data tables before we continue, to avoid removing items in + // those tables, which will often be isolated even though they're + // visually linked to other content-ful elements (text, images, etc.). + $this->_markDataTables($article); + + $this->_fixLazyImages($article); + + // Clean out junk from the article content + $this->_cleanConditionally($article, 'form'); + $this->_cleanConditionally($article, 'fieldset'); + $this->_clean($article, 'object'); + $this->_clean($article, 'embed'); + $this->_clean($article, 'footer'); + $this->_clean($article, 'link'); + $this->_clean($article, 'aside'); + + // Clean out elements have "share" in their id/class combinations from final top candidates, + // which means we don't remove the top candidates even they have "share". + + $shareElementThreshold = $this->configuration->getCharThreshold(); + + foreach ($article->childNodes as $child) { + $this->_cleanMatchedNodes($child, function ($node, $matchString) use ($shareElementThreshold) { + return (preg_match(NodeUtility::$regexps['shareElements'], $matchString) && mb_strlen($node->textContent) < $shareElementThreshold); + }); + } + + /* + * If there is only one h2 and its text content substantially equals article title, + * they are probably using it as a header and not a subheader, + * so remove it since we already extract the title separately. + */ + /* + $h2 = $article->getElementsByTagName('h2'); + if ($h2->length === 1) { + $lengthSimilarRate = (mb_strlen($h2->item(0)->textContent) - mb_strlen($this->getTitle())) / max(mb_strlen($this->getTitle()), 1); + + if (abs($lengthSimilarRate) < 0.5) { + if ($lengthSimilarRate > 0) { + $titlesMatch = strpos($h2->item(0)->textContent, $this->getTitle()) !== false; + } else { + $titlesMatch = strpos($this->getTitle(), $h2->item(0)->textContent) !== false; + } + if ($titlesMatch) { + $this->logger->info('[PrepArticle] Found title repeated in an H2 node, removing...'); + $this->_clean($article, 'h2'); + } + } + } + */ + + $this->_clean($article, 'iframe'); + $this->_clean($article, 'input'); + $this->_clean($article, 'textarea'); + $this->_clean($article, 'select'); + $this->_clean($article, 'button'); + $this->_cleanHeaders($article); + + // Do these last as the previous stuff may have removed junk + // that will affect these + $this->_cleanConditionally($article, 'table'); + $this->_cleanConditionally($article, 'ul'); + $this->_cleanConditionally($article, 'div'); + + // replace H1 with H2 as H1 should be only title that is displayed separately + foreach (iterator_to_array($article->getElementsByTagName('h1')) as $h1) { + NodeUtility::setNodeTag($h1, 'h2'); + } + + $this->_cleanExtraParagraphs($article); + + foreach (iterator_to_array($article->getElementsByTagName('br')) as $br) { + $next = NodeUtility::nextNode($br->nextSibling); + if ($next && $next->nodeName === 'p') { + $this->logger->debug('[PrepArticle] Removing br node next to a p node.'); + $br->parentNode->removeChild($br); + } + } + + // Remove single-cell tables + foreach ($article->shiftingAwareGetElementsByTagName('table') as $table) { + /** @var DOMNode $table */ + $tbody = $table->hasSingleTagInsideElement('tbody') ? $table->getFirstElementChild() : $table; + if ($tbody->hasSingleTagInsideElement('tr')) { + $row = $tbody->getFirstElementChild(); + if ($row->hasSingleTagInsideElement('td')) { + $cell = $row->getFirstElementChild(); + $cell = NodeUtility::setNodeTag($cell, (array_reduce(iterator_to_array($cell->childNodes), function ($carry, $node) { + return $node->isPhrasingContent() && $carry; + }, true)) ? 'p' : 'div'); + $table->parentNode->replaceChild($cell, $table); + } + } + } + + return $article; + } + + /** + * Look for 'data' (as opposed to 'layout') tables, for which we use + * similar checks as + * https://dxr.mozilla.org/mozilla-central/rev/71224049c0b52ab190564d3ea0eab089a159a4cf/accessible/html/HTMLTableAccessible.cpp#920. + * + * @param DOMDocument $article + * + * @return void + */ + public function _markDataTables(DOMDocument $article) + { + $tables = $article->getElementsByTagName('table'); + foreach ($tables as $table) { + /** @var DOMElement $table */ + $role = $table->getAttribute('role'); + if ($role === 'presentation') { + $table->setReadabilityDataTable(false); + continue; + } + $datatable = $table->getAttribute('datatable'); + if ($datatable == '0') { + $table->setReadabilityDataTable(false); + continue; + } + $summary = $table->getAttribute('summary'); + if ($summary) { + $table->setReadabilityDataTable(true); + continue; + } + + $caption = $table->getElementsByTagName('caption'); + if ($caption->length > 0 && $caption->item(0)->childNodes->length > 0) { + $table->setReadabilityDataTable(true); + continue; + } + + // If the table has a descendant with any of these tags, consider a data table: + foreach (['col', 'colgroup', 'tfoot', 'thead', 'th'] as $dataTableDescendants) { + if ($table->getElementsByTagName($dataTableDescendants)->length > 0) { + $table->setReadabilityDataTable(true); + continue 2; + } + } + + // Nested tables indicate a layout table: + if ($table->getElementsByTagName('table')->length > 0) { + $table->setReadabilityDataTable(false); + continue; + } + + $sizeInfo = $table->getRowAndColumnCount(); + if ($sizeInfo['rows'] >= 10 || $sizeInfo['columns'] > 4) { + $table->setReadabilityDataTable(true); + continue; + } + // Now just go by size entirely: + $table->setReadabilityDataTable($sizeInfo['rows'] * $sizeInfo['columns'] > 10); + } + } + + /** + * convert images and figures that have properties like data-src into images that can be loaded without JS + * + * @param DOMDocument $article + * + * @return void + */ + public function _fixLazyImages(DOMDocument $article) + { + $images = $this->_getAllNodesWithTag($article, ['img', 'picture', 'figure']); + foreach ($images as $elem) { + // In some sites (e.g. Kotaku), they put 1px square image as base64 data uri in the src attribute. + // So, here we check if the data uri is too short, just might as well remove it. + if ($elem->getAttribute('src') && preg_match(NodeUtility::$regexps['b64DataUrl'], $elem->getAttribute('src'), $parts)) { + // Make sure it's not SVG, because SVG can have a meaningful image in under 133 bytes. + if ($parts[1] === 'image/svg+xml') { + continue; + } + + // Make sure this element has other attributes which contains image. + // If it doesn't, then this src is important and shouldn't be removed. + $srcCouldBeRemoved = false; + for ($i = 0; $i < $elem->attributes->length; $i++) { + $attr = $elem->attributes->item($i); + if ($attr->name === 'src') { + continue; + } + + if (preg_match('/\.(jpg|jpeg|png|webp)/i', $attr->value)) { + $srcCouldBeRemoved = true; + break; + } + } + + // Here we assume if image is less than 100 bytes (or 133B after encoded to base64) + // it will be too small, therefore it might be placeholder image. + if ($srcCouldBeRemoved) { + $b64starts = stripos($elem->getAttribute('src'), 'base64') + 7; + $b64length = strlen($elem->getAttribute('src')) - $b64starts; + if ($b64length < 133) { + $elem->removeAttribute('src'); + } + } + } + + // Don't remove if there's a src or srcset attribute, and there's no sign of 'lazy' loading in the class + // attribute value. + if (($elem->getAttribute('src') || $elem->getAttribute('srcset')) && mb_stripos($elem->getAttribute('class'), 'lazy') === false) { + continue; + } + + for ($j = 0; $j < $elem->attributes->length; $j++) { + $attr = $elem->attributes->item($j); + if ($attr->name === 'src' || $attr->name === 'srcset' || $attr->name === 'alt') { + continue; + } + $copyTo = null; + if (preg_match('/\.(jpg|jpeg|png|webp)\s+\d/', $attr->value)) { + $copyTo = 'srcset'; + } elseif (preg_match('/^\s*\S+\.(jpg|jpeg|png|webp)\S*\s*$/', $attr->value)) { + $copyTo = 'src'; + } + if ($copyTo) { + //if this is an img or picture, set the attribute directly + if ($elem->tagName === 'img' || $elem->tagName === 'picture') { + $elem->setAttribute($copyTo, $attr->value); + } elseif ($elem->tagName === 'figure' && empty($this->_getAllNodesWithTag($elem, ['img', 'picture']))) { + //if the item is a <figure> that does not contain an image or picture, create one and place it inside the figure + //see the nytimes-3 testcase for an example + $img = $article->createElement('img'); + $img->setAttribute($copyTo, $attr->value); + $elem->appendChild($img); + } + } + } + } + } + + /** + * Remove the style attribute on every e and under. + * + * @param $node DOMDocument|DOMNode + **/ + public function _cleanStyles($node) + { + if (property_exists($node, 'tagName') && $node->tagName === 'svg') { + return; + } + + // Do not bother if there's no method to remove an attribute + if (method_exists($node, 'removeAttribute')) { + $presentational_attributes = ['align', 'background', 'bgcolor', 'border', 'cellpadding', 'cellspacing', 'frame', 'hspace', 'rules', 'style', 'valign', 'vspace']; + // Remove `style` and deprecated presentational attributes + foreach ($presentational_attributes as $presentational_attribute) { + $node->removeAttribute($presentational_attribute); + } + + $deprecated_size_attribute_elems = ['table', 'th', 'td', 'hr', 'pre']; + if (property_exists($node, 'tagName') && in_array($node->tagName, $deprecated_size_attribute_elems)) { + $node->removeAttribute('width'); + $node->removeAttribute('height'); + } + } + + $cur = $node->firstChild; + while ($cur !== null) { + $this->_cleanStyles($cur); + $cur = $cur->nextSibling; + } + } + + /** + * Clean out elements that match the specified conditions + * + * @param $node DOMElement Node to clean + * @param $filter callable Function determines whether a node should be removed + * + * @return void + **/ + public function _cleanMatchedNodes($node, callable $filter) + { + $endOfSearchMarkerNode = NodeUtility::getNextNode($node, true); + $next = NodeUtility::getNextNode($node); + while ($next && $next !== $endOfSearchMarkerNode) { + if ($filter($next, sprintf('%s %s', $next->getAttribute('class'), $next->getAttribute('id')))) { + $this->logger->debug(sprintf('Removing matched node, node class was: \'%s\', id: \'%s\'', $next->getAttribute('class'), $next->getAttribute('id'))); + $next = NodeUtility::removeAndGetNext($next); + } else { + $next = NodeUtility::getNextNode($next); + } + } + } + + /** + * @param DOMDocument $article + * + * @return void + */ + public function _cleanExtraParagraphs(DOMDocument $article) + { + $paragraphs = $this->_getAllNodesWithTag($article, ['p']); + $length = count($paragraphs); + + for ($i = 0; $i < $length; $i++) { + $paragraph = $paragraphs[$length - 1 - $i]; + + $imgCount = $paragraph->getElementsByTagName('img')->length; + $embedCount = $paragraph->getElementsByTagName('embed')->length; + $objectCount = $paragraph->getElementsByTagName('object')->length; + // At this point, nasty iframes have been removed, only remain embedded video ones. + $iframeCount = $paragraph->getElementsByTagName('iframe')->length; + $totalCount = $imgCount + $embedCount + $objectCount + $iframeCount; + + if ($totalCount === 0 && !preg_replace(NodeUtility::$regexps['onlyWhitespace'], '', $paragraph->textContent)) { + $this->logger->debug(sprintf('[PrepArticle] Removing extra paragraph. Text content was: \'%s\'', substr($paragraph->textContent, 0, 128))); + $paragraph->parentNode->removeChild($paragraph); + } + } + } + + private function getTextDensity($e, array $tags) { + $textLength = mb_strlen($e->getTextContent(true)); + if ($textLength === 0) { + return 0; + } + $childrenLength = 0; + $children = $this->_getAllNodesWithTag($e, $tags); + foreach ($children as $child) { + $childrenLength += mb_strlen($child->getTextContent(true)); + } + return $childrenLength / $textLength; + } + + /** + * @param DOMDocument $article + * @param string $tag Tag to clean conditionally + * + * @return void + */ + public function _cleanConditionally(DOMDocument $article, $tag) + { + if (!$this->configuration->getCleanConditionally()) { + return; + } + + /* + * Gather counts for other typical elements embedded within. + * Traverse backwards so we can remove nodes at the same time + * without effecting the traversal. + */ + + $allNodesWithTag = $this->_getAllNodesWithTag($article, [$tag]); + $length = count($allNodesWithTag); + for ($i = 0; $i < $length; $i++) { + /** @var $node DOMElement */ + $node = $allNodesWithTag[$length - 1 - $i]; + + $isList = in_array($tag, ['ul', 'ol']); + /* + // Doesn't seem to work as expected + // compared to JS version: https://github.com/mozilla/readability/commit/3c833899866ffb1f9130767110197fd6f5c08d4c + if (!$isList) { + $listLength = 0; + $listNodes = $this->_getAllNodesWithTag($node, ['ul', 'ol']); + array_walk($listNodes, function ($list) use(&$listLength) { + $listLength += mb_strlen($list->getTextContent()); + }); + $nodeTextLength = mb_strlen($node->getTextContent()); + if (!$nodeTextLength) { + $isList = true; + } else { + $isList = $listLength / $nodeTextLength > 0.9; + } + } + */ + + // First check if this node IS data table, in which case don't remove it. + if ($tag === 'table' && $node->isReadabilityDataTable()) { + continue; + } + + // Next check if we're inside a data table, in which case don't remove it as well. + if ($node->hasAncestorTag('table', -1, function ($node) { + return $node->isReadabilityDataTable(); + })) { + continue; + } + + if ($node->hasAncestorTag('code')) { + continue; + } + + $weight = 0; + if ($this->configuration->getWeightClasses()) { + $weight = $node->getClassWeight(); + } + + if ($weight < 0) { + $this->logger->debug(sprintf('[PrepArticle] Removing tag \'%s\' with 0 or less weight', $tag)); + + NodeUtility::removeNode($node); + continue; + } + + if (substr_count($node->getTextContent(false), ',') < 10) { + /* + * If there are not very many commas, and the number of + * non-paragraph elements is more than paragraphs or other + * ominous signs, remove the element. + */ + + $p = $node->getElementsByTagName('p')->length; + $img = $node->getElementsByTagName('img')->length; + $li = $node->getElementsByTagName('li')->length - 100; + $input = $node->getElementsByTagName('input')->length; + $headingDensity = $this->getTextDensity($node, ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']); + + $embedCount = 0; + $embeds = $this->_getAllNodesWithTag($node, ['object', 'embed', 'iframe']); + + foreach ($embeds as $embedNode) { + for ($j = 0; $j < $embedNode->attributes->length; $j++) { + if (preg_match(NodeUtility::$regexps['videos'], $embedNode->attributes->item($j)->nodeValue)) { + continue 3; + } + } + + // For embed with <object> tag, check inner HTML as well. + if ($embedNode->tagName === "object" && preg_match(NodeUtility::$regexps['videos'], $embedNode->C14N())) { + continue 2; + } + + $embedCount++; + } + + $linkDensity = $node->getLinkDensity(); + $contentLength = mb_strlen($node->getTextContent(true)); + + $haveToRemove = + ($img > 1 && $p / $img < 0.5 && !$node->hasAncestorTag('figure')) || + (!$isList && $li > $p) || + ($input > floor($p / 3)) || + (!$isList && $headingDensity < 0.9 && $contentLength < 25 && ($img === 0 || $img > 2) && !$node->hasAncestorTag('figure')) || + (!$isList && $weight < 25 && $linkDensity > 0.2) || + ($weight >= 25 && $linkDensity > 0.5) || + (($embedCount === 1 && $contentLength < 75) || $embedCount > 1); + + if ($haveToRemove) { + $this->logger->debug(sprintf('[PrepArticle] Removing tag \'%s\'.', $tag)); + + NodeUtility::removeNode($node); + } + } + } + } + + public function _getAllNodesWithTag($node, array $tagNames) { + $nodes = []; + foreach ($tagNames as $tag) { + $nodeList = $node->getElementsByTagName($tag); + foreach ($nodeList as $n) { + $nodes[] = $n; + } + } + return $nodes; + } + + /** + * Clean a node of all elements of type "tag". + * (Unless it's a youtube/vimeo video. People love movies.). + * + * @param $article DOMDocument + * @param $tag string tag to clean + * + * @return void + **/ + public function _clean(DOMDocument $article, $tag) + { + $isEmbed = in_array($tag, ['object', 'embed', 'iframe']); + + $allNodesWithTag = $this->_getAllNodesWithTag($article, [$tag]); + $length = count($allNodesWithTag); + for ($i = 0; $i < $length; $i++) { + $item = $allNodesWithTag[$length - 1 - $i]; + + // Allow youtube and vimeo videos through as people usually want to see those. + if ($isEmbed) { + $attributeValues = []; + foreach ($item->attributes as $value) { + $attributeValues[] = $value->nodeValue; + } + $attributeValues = implode('|', $attributeValues); + + // First, check the elements attributes to see if any of them contain youtube or vimeo + if (preg_match(NodeUtility::$regexps['videos'], $attributeValues)) { + continue; + } + + // For embed with <object> tag, check inner HTML as well. + if ($item->tagName === 'object' && preg_match(NodeUtility::$regexps['videos'], $item->C14N())) { + continue; + } + } + $this->logger->debug(sprintf('[PrepArticle] Removing node \'%s\'.', $item->tagName)); + + NodeUtility::removeNode($item); + } + } + + /** + * Clean out spurious headers from an Element. + * + * @param DOMDocument $article + * + * @return void + **/ + public function _cleanHeaders(DOMDocument $article) + { + $headingNodes = $this->_getAllNodesWithTag($article, ['h1', 'h2']); + /** @var $header DOMElement */ + foreach ($headingNodes as $header) { + $weight = 0; + if ($this->configuration->getWeightClasses()) { + $weight = $header->getClassWeight(); + } + $shouldRemove = $weight < 0; + + if ($shouldRemove) { + $this->logger->debug(sprintf('[PrepArticle] Removing H node with 0 or less weight. Content was: \'%s\'', substr($header->nodeValue, 0, 128))); + + NodeUtility::removeNode($header); + } + } + } + + /** + * Check if this node is an H1 or H2 element whose content is mostly + * the same as the article title. + * + * @param DOMNode the node to check. + * @return boolean indicating whether this is a title-like header. + */ + private function headerDuplicatesTitle($node) { + if ($node->nodeName !== 'h1' && $node->nodeName !== 'h2') { + return false; + } + if (!isset($this->title)) { + return false; + } + $heading = $node->getTextContent(false); + $this->logger->debug(sprintf('Evaluating similarity of header: %s"', $heading)); + return $this->textSimilarity($this->title, $heading) > 0.75; + } + + /** + * Removes the class="" attribute from every element in the given + * subtree. + * + * Readability.js has a special filter to avoid cleaning the classes that the algorithm adds. We don't add classes + * here so no need to filter those. + * + * @param DOMDocument|DOMNode $node + * + * @return void + **/ + public function _cleanClasses($node) + { + if ($node->getAttribute('class') !== '') { + $node->removeAttribute('class'); + } + + for ($node = $node->getFirstElementChild(); $node !== null; $node = $node->nextSibling) { + $this->_cleanClasses($node); + } + } + + /** + * @param DOMDocument $article + * + * @return DOMDocument + */ + public function postProcessContent(DOMDocument $article) + { + $this->logger->info('[PostProcess] PostProcessing content...'); + + // Readability cannot open relative uris so we convert them to absolute uris. + if ($this->configuration->getFixRelativeURLs()) { + foreach (iterator_to_array($article->getElementsByTagName('a')) as $link) { + /** @var DOMElement $link */ + $href = $link->getAttribute('href'); + if ($href) { + // Remove links with javascript: URIs, since + // they won't work after scripts have been removed from the page. + if (strpos($href, 'javascript:') === 0) { + $this->logger->debug(sprintf('[PostProcess] Removing \'javascript:\' link. Content is: \'%s\'', substr($link->textContent, 0, 128))); + + // if the link only contains simple text content, it can be converted to a text node + if ($link->childNodes->length === 1 && $link->childNodes->item(0)->nodeType === XML_TEXT_NODE) { + $text = $article->createTextNode($link->textContent); + $link->parentNode->replaceChild($text, $link); + } else { + // if the link has multiple children, they should all be preserved + $container = $article->createElement('span'); + while ($link->firstChild) { + $container->appendChild($link->firstChild); + } + $link->parentNode->replaceChild($container, $link); + } + } else { + $this->logger->debug(sprintf('[PostProcess] Converting link to absolute URI: \'%s\'', substr($href, 0, 128))); + + $link->setAttribute('href', $this->toAbsoluteURI($href)); + } + } + } + + $medias = $this->_getAllNodesWithTag($article, [ + 'img', 'picture', 'figure', 'video', 'audio', 'source' + ]); + + array_walk($medias, function ($media) { + $src = $media->getAttribute('src'); + $poster = $media->getAttribute('poster'); + $srcset = $media->getAttribute('srcset'); + + if ($src) { + $this->logger->debug(sprintf('[PostProcess] Converting image URL to absolute URI: \'%s\'', substr($src, 0, 128))); + + $media->setAttribute('src', $this->toAbsoluteURI($src)); + } + + if ($poster) { + $this->logger->debug(sprintf('[PostProcess] Converting image URL to absolute URI: \'%s\'', substr($poster, 0, 128))); + + $media->setAttribute('poster', $this->toAbsoluteURI($poster)); + } + + if ($srcset) { + $newSrcset = preg_replace_callback(NodeUtility::$regexps['srcsetUrl'], function ($matches) { + $this->logger->debug(sprintf('[PostProcess] Converting image URL to absolute URI: \'%s\'', substr($matches[1], 0, 128))); + + return $this->toAbsoluteURI($matches[1]) . $matches[2] . $matches[3]; + }, $srcset); + + $media->setAttribute('srcset', $newSrcset); + } + }); + } + + $this->simplifyNestedElements($article); + + if (!$this->configuration->getKeepClasses()) { + $this->_cleanClasses($article); + } + + return $article; + } + + /** + * Iterate over a NodeList, and return the first node that passes + * the supplied test function + * + * @param NodeList nodeList The NodeList. + * @param Function fn The test function. + * @return DOMNode|null + */ + private function findNode(array $nodeList, callable $fn) + { + foreach ($nodeList as $node) { + if ($fn($node)) { + return $node; + } + } + return null; + } + + /** + * @return null|string + */ + public function __toString() + { + return sprintf('<h1>%s</h1>%s', $this->getTitle(), $this->getContent()); + } + + /** + * @return string|null + */ + public function getTitle() + { + return $this->title; + } + + /** + * @param string $title + */ + protected function setTitle($title) + { + $this->title = $title; + } + + /** + * @return string|null + */ + public function getContent() + { + if ($this->content instanceof DOMDocument) { + $html5 = new HTML5(['disable_html_ns' => true]); + // by using childNodes below we make sure HTML5PHP's serialiser + // doesn't output the <!DOCTYPE html> string at the start. + return $html5->saveHTML($this->content->childNodes); + } else { + return null; + } + } + + /** + * @return DOMDocument|null + */ + public function getDOMDocument() + { + return $this->content; + } + + /** + * @param DOMDocument $content + */ + protected function setContent(DOMDocument $content) + { + $this->content = $content; + } + + /** + * @return null|string + */ + public function getExcerpt() + { + return $this->excerpt; + } + + /** + * @param null|string $excerpt + */ + public function setExcerpt($excerpt) + { + $this->excerpt = $excerpt; + } + + /** + * @return string|null + */ + public function getImage() + { + return $this->image; + } + + /** + * @param string $image + */ + protected function setImage($image) + { + $this->image = $image; + } + + /** + * @return string|null + */ + public function getAuthor() + { + return $this->author; + } + + /** + * @param string $author + */ + protected function setAuthor($author) + { + $this->author = $author; + } + + /** + * @return string|null + */ + public function getSiteName() + { + return $this->siteName; + } + + /** + * @param string $siteName + */ + protected function setSiteName($siteName) + { + $this->siteName = $siteName; + } + + /** + * @return null|string + */ + public function getDirection() + { + return $this->direction; + } + + /** + * @param null|string $direction + */ + public function setDirection($direction) + { + $this->direction = $direction; + } +} |