aboutsummaryrefslogtreecommitdiffhomepage
path: root/inc
diff options
context:
space:
mode:
Diffstat (limited to 'inc')
-rwxr-xr-xinc/Encoding.php262
-rwxr-xr-xinc/JSLikeHTMLElement.php110
-rwxr-xr-xinc/Readability.php1103
-rwxr-xr-xinc/index.html0
-rwxr-xr-xinc/rain.tpl.class.php1043
5 files changed, 2518 insertions, 0 deletions
diff --git a/inc/Encoding.php b/inc/Encoding.php
new file mode 100755
index 00000000..ac107af9
--- /dev/null
+++ b/inc/Encoding.php
@@ -0,0 +1,262 @@
1<?php
2/**
3 * @author "Sebastián Grignoli" <grignoli@framework2.com.ar>
4 * @package Encoding
5 * @version 1.1
6 * @link http://www.framework2.com.ar/dzone/forceUTF8-es/
7 * @example http://www.framework2.com.ar/dzone/forceUTF8-es/
8 */
9
10class Encoding {
11
12 protected static $win1252ToUtf8 = array(
13 128 => "\xe2\x82\xac",
14
15 130 => "\xe2\x80\x9a",
16 131 => "\xc6\x92",
17 132 => "\xe2\x80\x9e",
18 133 => "\xe2\x80\xa6",
19 134 => "\xe2\x80\xa0",
20 135 => "\xe2\x80\xa1",
21 136 => "\xcb\x86",
22 137 => "\xe2\x80\xb0",
23 138 => "\xc5\xa0",
24 139 => "\xe2\x80\xb9",
25 140 => "\xc5\x92",
26
27 142 => "\xc5\xbd",
28
29
30 145 => "\xe2\x80\x98",
31 146 => "\xe2\x80\x99",
32 147 => "\xe2\x80\x9c",
33 148 => "\xe2\x80\x9d",
34 149 => "\xe2\x80\xa2",
35 150 => "\xe2\x80\x93",
36 151 => "\xe2\x80\x94",
37 152 => "\xcb\x9c",
38 153 => "\xe2\x84\xa2",
39 154 => "\xc5\xa1",
40 155 => "\xe2\x80\xba",
41 156 => "\xc5\x93",
42
43 158 => "\xc5\xbe",
44 159 => "\xc5\xb8"
45 );
46
47 protected static $brokenUtf8ToUtf8 = array(
48 "\xc2\x80" => "\xe2\x82\xac",
49
50 "\xc2\x82" => "\xe2\x80\x9a",
51 "\xc2\x83" => "\xc6\x92",
52 "\xc2\x84" => "\xe2\x80\x9e",
53 "\xc2\x85" => "\xe2\x80\xa6",
54 "\xc2\x86" => "\xe2\x80\xa0",
55 "\xc2\x87" => "\xe2\x80\xa1",
56 "\xc2\x88" => "\xcb\x86",
57 "\xc2\x89" => "\xe2\x80\xb0",
58 "\xc2\x8a" => "\xc5\xa0",
59 "\xc2\x8b" => "\xe2\x80\xb9",
60 "\xc2\x8c" => "\xc5\x92",
61
62 "\xc2\x8e" => "\xc5\xbd",
63
64
65 "\xc2\x91" => "\xe2\x80\x98",
66 "\xc2\x92" => "\xe2\x80\x99",
67 "\xc2\x93" => "\xe2\x80\x9c",
68 "\xc2\x94" => "\xe2\x80\x9d",
69 "\xc2\x95" => "\xe2\x80\xa2",
70 "\xc2\x96" => "\xe2\x80\x93",
71 "\xc2\x97" => "\xe2\x80\x94",
72 "\xc2\x98" => "\xcb\x9c",
73 "\xc2\x99" => "\xe2\x84\xa2",
74 "\xc2\x9a" => "\xc5\xa1",
75 "\xc2\x9b" => "\xe2\x80\xba",
76 "\xc2\x9c" => "\xc5\x93",
77
78 "\xc2\x9e" => "\xc5\xbe",
79 "\xc2\x9f" => "\xc5\xb8"
80 );
81
82 protected static $utf8ToWin1252 = array(
83 "\xe2\x82\xac" => "\x80",
84
85 "\xe2\x80\x9a" => "\x82",
86 "\xc6\x92" => "\x83",
87 "\xe2\x80\x9e" => "\x84",
88 "\xe2\x80\xa6" => "\x85",
89 "\xe2\x80\xa0" => "\x86",
90 "\xe2\x80\xa1" => "\x87",
91 "\xcb\x86" => "\x88",
92 "\xe2\x80\xb0" => "\x89",
93 "\xc5\xa0" => "\x8a",
94 "\xe2\x80\xb9" => "\x8b",
95 "\xc5\x92" => "\x8c",
96
97 "\xc5\xbd" => "\x8e",
98
99
100 "\xe2\x80\x98" => "\x91",
101 "\xe2\x80\x99" => "\x92",
102 "\xe2\x80\x9c" => "\x93",
103 "\xe2\x80\x9d" => "\x94",
104 "\xe2\x80\xa2" => "\x95",
105 "\xe2\x80\x93" => "\x96",
106 "\xe2\x80\x94" => "\x97",
107 "\xcb\x9c" => "\x98",
108 "\xe2\x84\xa2" => "\x99",
109 "\xc5\xa1" => "\x9a",
110 "\xe2\x80\xba" => "\x9b",
111 "\xc5\x93" => "\x9c",
112
113 "\xc5\xbe" => "\x9e",
114 "\xc5\xb8" => "\x9f"
115 );
116
117 static function toUTF8($text){
118 /**
119 * Function Encoding::toUTF8
120 *
121 * This function leaves UTF8 characters alone, while converting almost all non-UTF8 to UTF8.
122 *
123 * It assumes that the encoding of the original string is either Windows-1252 or ISO 8859-1.
124 *
125 * It may fail to convert characters to UTF-8 if they fall into one of these scenarios:
126 *
127 * 1) when any of these characters: ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞß
128 * are followed by any of these: ("group B")
129 * ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶•¸¹º»¼½¾¿
130 * For example: %ABREPRESENT%C9%BB. «REPRESENTÉ»
131 * The "«" (%AB) character will be converted, but the "É" followed by "»" (%C9%BB)
132 * is also a valid unicode character, and will be left unchanged.
133 *
134 * 2) when any of these: àáâãäåæçèéêëìíîï are followed by TWO chars from group B,
135 * 3) when any of these: ðñòó are followed by THREE chars from group B.
136 *
137 * @name toUTF8
138 * @param string $text Any string.
139 * @return string The same string, UTF8 encoded
140 *
141 */
142
143 if(is_array($text))
144 {
145 foreach($text as $k => $v)
146 {
147 $text[$k] = self::toUTF8($v);
148 }
149 return $text;
150 } elseif(is_string($text)) {
151
152 $max = strlen($text);
153 $buf = "";
154 for($i = 0; $i < $max; $i++){
155 $c1 = $text{$i};
156 if($c1>="\xc0"){ //Should be converted to UTF8, if it's not UTF8 already
157 $c2 = $i+1 >= $max? "\x00" : $text{$i+1};
158 $c3 = $i+2 >= $max? "\x00" : $text{$i+2};
159 $c4 = $i+3 >= $max? "\x00" : $text{$i+3};
160 if($c1 >= "\xc0" & $c1 <= "\xdf"){ //looks like 2 bytes UTF8
161 if($c2 >= "\x80" && $c2 <= "\xbf"){ //yeah, almost sure it's UTF8 already
162 $buf .= $c1 . $c2;
163 $i++;
164 } else { //not valid UTF8. Convert it.
165 $cc1 = (chr(ord($c1) / 64) | "\xc0");
166 $cc2 = ($c1 & "\x3f") | "\x80";
167 $buf .= $cc1 . $cc2;
168 }
169 } elseif($c1 >= "\xe0" & $c1 <= "\xef"){ //looks like 3 bytes UTF8
170 if($c2 >= "\x80" && $c2 <= "\xbf" && $c3 >= "\x80" && $c3 <= "\xbf"){ //yeah, almost sure it's UTF8 already
171 $buf .= $c1 . $c2 . $c3;
172 $i = $i + 2;
173 } else { //not valid UTF8. Convert it.
174 $cc1 = (chr(ord($c1) / 64) | "\xc0");
175 $cc2 = ($c1 & "\x3f") | "\x80";
176 $buf .= $cc1 . $cc2;
177 }
178 } elseif($c1 >= "\xf0" & $c1 <= "\xf7"){ //looks like 4 bytes UTF8
179 if($c2 >= "\x80" && $c2 <= "\xbf" && $c3 >= "\x80" && $c3 <= "\xbf" && $c4 >= "\x80" && $c4 <= "\xbf"){ //yeah, almost sure it's UTF8 already
180 $buf .= $c1 . $c2 . $c3;
181 $i = $i + 2;
182 } else { //not valid UTF8. Convert it.
183 $cc1 = (chr(ord($c1) / 64) | "\xc0");
184 $cc2 = ($c1 & "\x3f") | "\x80";
185 $buf .= $cc1 . $cc2;
186 }
187 } else { //doesn't look like UTF8, but should be converted
188 $cc1 = (chr(ord($c1) / 64) | "\xc0");
189 $cc2 = (($c1 & "\x3f") | "\x80");
190 $buf .= $cc1 . $cc2;
191 }
192 } elseif(($c1 & "\xc0") == "\x80"){ // needs conversion
193 if(isset(self::$win1252ToUtf8[ord($c1)])) { //found in Windows-1252 special cases
194 $buf .= self::$win1252ToUtf8[ord($c1)];
195 } else {
196 $cc1 = (chr(ord($c1) / 64) | "\xc0");
197 $cc2 = (($c1 & "\x3f") | "\x80");
198 $buf .= $cc1 . $cc2;
199 }
200 } else { // it doesn't need convesion
201 $buf .= $c1;
202 }
203 }
204 return $buf;
205 } else {
206 return $text;
207 }
208 }
209
210 static function toWin1252($text) {
211 if(is_array($text)) {
212 foreach($text as $k => $v) {
213 $text[$k] = self::toWin1252($v);
214 }
215 return $text;
216 } elseif(is_string($text)) {
217 return utf8_decode(str_replace(array_keys(self::$utf8ToWin1252), array_values(self::$utf8ToWin1252), self::toUTF8($text)));
218 } else {
219 return $text;
220 }
221 }
222
223 static function toISO8859($text) {
224 return self::toWin1252($text);
225 }
226
227 static function toLatin1($text) {
228 return self::toWin1252($text);
229 }
230
231 static function fixUTF8($text){
232 if(is_array($text)) {
233 foreach($text as $k => $v) {
234 $text[$k] = self::fixUTF8($v);
235 }
236 return $text;
237 }
238
239 $last = "";
240 while($last <> $text){
241 $last = $text;
242 $text = self::toUTF8(utf8_decode(str_replace(array_keys(self::$utf8ToWin1252), array_values(self::$utf8ToWin1252), $text)));
243 }
244 $text = self::toUTF8(utf8_decode(str_replace(array_keys(self::$utf8ToWin1252), array_values(self::$utf8ToWin1252), $text)));
245 return $text;
246 }
247
248 static function UTF8FixWin1252Chars($text){
249 // If you received an UTF-8 string that was converted from Windows-1252 as it was ISO8859-1
250 // (ignoring Windows-1252 chars from 80 to 9F) use this function to fix it.
251 // See: http://en.wikipedia.org/wiki/Windows-1252
252
253 return str_replace(array_keys(self::$brokenUtf8ToUtf8), array_values(self::$brokenUtf8ToUtf8), $text);
254 }
255
256 static function removeBOM($str=""){
257 if(substr($str, 0,3) == pack("CCC",0xef,0xbb,0xbf)) {
258 $str=substr($str, 3);
259 }
260 return $str;
261 }
262} \ No newline at end of file
diff --git a/inc/JSLikeHTMLElement.php b/inc/JSLikeHTMLElement.php
new file mode 100755
index 00000000..0557205f
--- /dev/null
+++ b/inc/JSLikeHTMLElement.php
@@ -0,0 +1,110 @@
1<?php
2/**
3* JavaScript-like HTML DOM Element
4*
5* This class extends PHP's DOMElement to allow
6* users to get and set the innerHTML property of
7* HTML elements in the same way it's done in
8* JavaScript.
9*
10* Example usage:
11* @code
12* require_once 'JSLikeHTMLElement.php';
13* header('Content-Type: text/plain');
14* $doc = new DOMDocument();
15* $doc->registerNodeClass('DOMElement', 'JSLikeHTMLElement');
16* $doc->loadHTML('<div><p>Para 1</p><p>Para 2</p></div>');
17* $elem = $doc->getElementsByTagName('div')->item(0);
18*
19* // print innerHTML
20* echo $elem->innerHTML; // prints '<p>Para 1</p><p>Para 2</p>'
21* echo "\n\n";
22*
23* // set innerHTML
24* $elem->innerHTML = '<a href="http://fivefilters.org">FiveFilters.org</a>';
25* echo $elem->innerHTML; // prints '<a href="http://fivefilters.org">FiveFilters.org</a>'
26* echo "\n\n";
27*
28* // print document (with our changes)
29* echo $doc->saveXML();
30* @endcode
31*
32* @author Keyvan Minoukadeh - http://www.keyvan.net - keyvan@keyvan.net
33* @see http://fivefilters.org (the project this was written for)
34*/
35class JSLikeHTMLElement extends DOMElement
36{
37 /**
38 * Used for setting innerHTML like it's done in JavaScript:
39 * @code
40 * $div->innerHTML = '<h2>Chapter 2</h2><p>The story begins...</p>';
41 * @endcode
42 */
43 public function __set($name, $value) {
44 if ($name == 'innerHTML') {
45 // first, empty the element
46 for ($x=$this->childNodes->length-1; $x>=0; $x--) {
47 $this->removeChild($this->childNodes->item($x));
48 }
49 // $value holds our new inner HTML
50 if ($value != '') {
51 $f = $this->ownerDocument->createDocumentFragment();
52 // appendXML() expects well-formed markup (XHTML)
53 $result = @$f->appendXML($value); // @ to suppress PHP warnings
54 if ($result) {
55 if ($f->hasChildNodes()) $this->appendChild($f);
56 } else {
57 // $value is probably ill-formed
58 $f = new DOMDocument();
59 $value = mb_convert_encoding($value, 'HTML-ENTITIES', 'UTF-8');
60 // Using <htmlfragment> will generate a warning, but so will bad HTML
61 // (and by this point, bad HTML is what we've got).
62 // We use it (and suppress the warning) because an HTML fragment will
63 // be wrapped around <html><body> tags which we don't really want to keep.
64 // Note: despite the warning, if loadHTML succeeds it will return true.
65 $result = @$f->loadHTML('<htmlfragment>'.$value.'</htmlfragment>');
66 if ($result) {
67 $import = $f->getElementsByTagName('htmlfragment')->item(0);
68 foreach ($import->childNodes as $child) {
69 $importedNode = $this->ownerDocument->importNode($child, true);
70 $this->appendChild($importedNode);
71 }
72 } else {
73 // oh well, we tried, we really did. :(
74 // this element is now empty
75 }
76 }
77 }
78 } else {
79 $trace = debug_backtrace();
80 trigger_error('Undefined property via __set(): '.$name.' in '.$trace[0]['file'].' on line '.$trace[0]['line'], E_USER_NOTICE);
81 }
82 }
83
84 /**
85 * Used for getting innerHTML like it's done in JavaScript:
86 * @code
87 * $string = $div->innerHTML;
88 * @endcode
89 */
90 public function __get($name)
91 {
92 if ($name == 'innerHTML') {
93 $inner = '';
94 foreach ($this->childNodes as $child) {
95 $inner .= $this->ownerDocument->saveXML($child);
96 }
97 return $inner;
98 }
99
100 $trace = debug_backtrace();
101 trigger_error('Undefined property via __get(): '.$name.' in '.$trace[0]['file'].' on line '.$trace[0]['line'], E_USER_NOTICE);
102 return null;
103 }
104
105 public function __toString()
106 {
107 return '['.$this->tagName.']';
108 }
109}
110?> \ No newline at end of file
diff --git a/inc/Readability.php b/inc/Readability.php
new file mode 100755
index 00000000..52a37d50
--- /dev/null
+++ b/inc/Readability.php
@@ -0,0 +1,1103 @@
1<?php
2/**
3* Arc90's Readability ported to PHP for FiveFilters.org
4* Based on readability.js version 1.7.1 (without multi-page support)
5* ------------------------------------------------------
6* Original URL: http://lab.arc90.com/experiments/readability/js/readability.js
7* Arc90's project URL: http://lab.arc90.com/experiments/readability/
8* JS Source: http://code.google.com/p/arc90labs-readability
9* Ported by: Keyvan Minoukadeh, http://www.keyvan.net
10* More information: http://fivefilters.org/content-only/
11* License: Apache License, Version 2.0
12* Requires: PHP5
13* Date: 2011-07-22
14*
15* Differences between the PHP port and the original
16* ------------------------------------------------------
17* Arc90's Readability is designed to run in the browser. It works on the DOM
18* tree (the parsed HTML) after the page's CSS styles have been applied and
19* Javascript code executed. This PHP port does not run inside a browser.
20* We use PHP's ability to parse HTML to build our DOM tree, but we cannot
21* rely on CSS or Javascript support. As such, the results will not always
22* match Arc90's Readability. (For example, if a web page contains CSS style
23* rules or Javascript code which hide certain HTML elements from display,
24* Arc90's Readability will dismiss those from consideration but our PHP port,
25* unable to understand CSS or Javascript, will not know any better.)
26*
27* Another significant difference is that the aim of Arc90's Readability is
28* to re-present the main content block of a given web page so users can
29* read it more easily in their browsers. Correct identification, clean up,
30* and separation of the content block is only a part of this process.
31* This PHP port is only concerned with this part, it does not include code
32* that relates to presentation in the browser - Arc90 already do
33* that extremely well, and for PDF output there's FiveFilters.org's
34* PDF Newspaper: http://fivefilters.org/pdf-newspaper/.
35*
36* Finally, this class contains methods that might be useful for developers
37* working on HTML document fragments. So without deviating too much from
38* the original code (which I don't want to do because it makes debugging
39* and updating more difficult), I've tried to make it a little more
40* developer friendly. You should be able to use the methods here on
41* existing DOMElement objects without passing an entire HTML document to
42* be parsed.
43*/
44
45// This class allows us to do JavaScript like assignements to innerHTML
46require_once(dirname(__FILE__).'/JSLikeHTMLElement.php');
47
48// Alternative usage (for testing only!)
49// uncomment the lines below and call Readability.php in your browser
50// passing it the URL of the page you'd like content from, e.g.:
51// Readability.php?url=http://medialens.org/alerts/09/090615_the_guardian_climate.php
52
53/*
54if (!isset($_GET['url']) || $_GET['url'] == '') {
55 die('Please pass a URL to the script. E.g. Readability.php?url=bla.com/story.html');
56}
57$url = $_GET['url'];
58if (!preg_match('!^https?://!i', $url)) $url = 'http://'.$url;
59$html = file_get_contents($url);
60$r = new Readability($html, $url);
61$r->init();
62echo $r->articleContent->innerHTML;
63*/
64
65
66class Readability
67{
68 /* constants */
69 const FLAG_STRIP_UNLIKELYS = 1;
70 const FLAG_WEIGHT_CLASSES = 2;
71 const FLAG_CLEAN_CONDITIONALLY = 4;
72
73 public $version = '1.7.1-without-multi-page';
74 public $convertLinksToFootnotes = false;
75 public $revertForcedParagraphElements = true;
76 public $articleTitle;
77 public $articleContent;
78 public $dom;
79 public $url = null; // optional - URL where HTML was retrieved
80 public $debug = false;
81 protected $body = null; //
82 protected $bodyCache = null; // Cache the body HTML in case we need to re-use it later
83 protected $flags = FLAG_CLEAN_CONDITIONALLY; // 1 | 2 | 4; // Start with all flags set.
84 protected $success = false; // indicates whether we were able to extract or not
85
86 /**
87 * All of the regular expressions in use within readability.
88 * Defined up here so we don't instantiate them repeatedly in loops.
89 **/
90 public $regexps = array(
91 'unlikelyCandidates' => '/combx|comment|comments|community|disqus|extra|foot|header|menu|remark|rss|shoutbox|sidebar|sponsor|ad-break|agegate|pagination|pager|popup|tweet|twitter/i',
92 'okMaybeItsACandidate' => '/and|article|body|column|main|shadow/i',
93 'positive' => '/article|body|content|entry|hentry|main|page|pagination|post|text|blog|story/i',
94 'negative' => '/combx|comment|comments|com-|contact|foot|footer|footnote|masthead|media|meta|outbrain|promo|related|scroll|shoutbox|sidebar|sponsor|shopping|tags|tool|widget/i',
95 'divToPElements' => '/<(a|blockquote|dl|div|ol|p|pre|table|ul)/i',
96 'replaceBrs' => '/(<br[^>]*>[ \n\r\t]*){2,}/i',
97 'replaceFonts' => '/<(\/?)font[^>]*>/i',
98 // 'trimRe' => '/^\s+|\s+$/g', // PHP has trim()
99 'normalize' => '/\s{2,}/',
100 'killBreaks' => '/(<br\s*\/?>(\s|&nbsp;?)*){1,}/',
101 'video' => '/http:\/\/(www\.)?(youtube|vimeo|dailymotion)\.com/i',
102 'skipFootnoteLink' => '/^\s*(\[?[a-z0-9]{1,2}\]?|^|edit|citation needed)\s*$/i'
103 );
104
105 /**
106 * Create instance of Readability
107 * @param string UTF-8 encoded string
108 * @param string (optional) URL associated with HTML (used for footnotes)
109 */
110 function __construct($html, $url=null)
111 {
112 /* Turn all double br's into p's */
113 $html = preg_replace($this->regexps['replaceBrs'], '</p><p>', $html);
114 $html = preg_replace($this->regexps['replaceFonts'], '<$1span>', $html);
115 $html = mb_convert_encoding($html, 'HTML-ENTITIES', "UTF-8");
116 $this->dom = new DOMDocument();
117 $this->dom->preserveWhiteSpace = false;
118 $this->dom->registerNodeClass('DOMElement', 'JSLikeHTMLElement');
119 if (trim($html) == '') $html = '<html></html>';
120 @$this->dom->loadHTML($html);
121 $this->url = $url;
122 }
123
124 /**
125 * Get article title element
126 * @return DOMElement
127 */
128 public function getTitle() {
129 return $this->articleTitle;
130 }
131
132 /**
133 * Get article content element
134 * @return DOMElement
135 */
136 public function getContent() {
137 return $this->articleContent;
138 }
139
140 /**
141 * Runs readability.
142 *
143 * Workflow:
144 * 1. Prep the document by removing script tags, css, etc.
145 * 2. Build readability's DOM tree.
146 * 3. Grab the article content from the current dom tree.
147 * 4. Replace the current DOM tree with the new one.
148 * 5. Read peacefully.
149 *
150 * @return boolean true if we found content, false otherwise
151 **/
152 public function init()
153 {
154 if (!isset($this->dom->documentElement)) return false;
155 $this->removeScripts($this->dom);
156 //die($this->getInnerHTML($this->dom->documentElement));
157
158 // Assume successful outcome
159 $this->success = true;
160
161 $bodyElems = $this->dom->getElementsByTagName('body');
162 if ($bodyElems->length > 0) {
163 if ($this->bodyCache == null) {
164 $this->bodyCache = $bodyElems->item(0)->innerHTML;
165 }
166 if ($this->body == null) {
167 $this->body = $bodyElems->item(0);
168 }
169 }
170
171 $this->prepDocument();
172
173 //die($this->dom->documentElement->parentNode->nodeType);
174 //$this->setInnerHTML($this->dom->documentElement, $this->getInnerHTML($this->dom->documentElement));
175 //die($this->getInnerHTML($this->dom->documentElement));
176
177 /* Build readability's DOM tree */
178 $overlay = $this->dom->createElement('div');
179 $innerDiv = $this->dom->createElement('div');
180 $articleTitle = $this->getArticleTitle();
181 $articleContent = $this->grabArticle();
182
183 if (!$articleContent) {
184 $this->success = false;
185 $articleContent = $this->dom->createElement('div');
186 $articleContent->setAttribute('id', 'readability-content');
187 $articleContent->innerHTML = '<p>Sorry, Readability was unable to parse this page for content.</p>';
188 }
189
190 $overlay->setAttribute('id', 'readOverlay');
191 $innerDiv->setAttribute('id', 'readInner');
192
193 /* Glue the structure of our document together. */
194 $innerDiv->appendChild($articleTitle);
195 $innerDiv->appendChild($articleContent);
196 $overlay->appendChild($innerDiv);
197
198 /* Clear the old HTML, insert the new content. */
199 $this->body->innerHTML = '';
200 $this->body->appendChild($overlay);
201 //document.body.insertBefore(overlay, document.body.firstChild);
202 $this->body->removeAttribute('style');
203
204 $this->postProcessContent($articleContent);
205
206 // Set title and content instance variables
207 $this->articleTitle = $articleTitle;
208 $this->articleContent = $articleContent;
209
210 return $this->success;
211 }
212
213 /**
214 * Debug
215 */
216 protected function dbg($msg) {
217 if ($this->debug) echo '* ',$msg, '<br />', "\n";
218 }
219
220 /**
221 * Run any post-process modifications to article content as necessary.
222 *
223 * @param DOMElement
224 * @return void
225 */
226 public function postProcessContent($articleContent) {
227 if ($this->convertLinksToFootnotes && !preg_match('/wikipedia\.org/', @$this->url)) {
228 $this->addFootnotes($articleContent);
229 }
230 }
231
232 /**
233 * Get the article title as an H1.
234 *
235 * @return DOMElement
236 */
237 protected function getArticleTitle() {
238 $curTitle = '';
239 $origTitle = '';
240
241 try {
242 $curTitle = $origTitle = $this->getInnerText($this->dom->getElementsByTagName('title')->item(0));
243 } catch(Exception $e) {}
244
245 if (preg_match('/ [\|\-] /', $curTitle))
246 {
247 $curTitle = preg_replace('/(.*)[\|\-] .*/i', '$1', $origTitle);
248
249 if (count(explode(' ', $curTitle)) < 3) {
250 $curTitle = preg_replace('/[^\|\-]*[\|\-](.*)/i', '$1', $origTitle);
251 }
252 }
253 else if (strpos($curTitle, ': ') !== false)
254 {
255 $curTitle = preg_replace('/.*:(.*)/i', '$1', $origTitle);
256
257 if (count(explode(' ', $curTitle)) < 3) {
258 $curTitle = preg_replace('/[^:]*[:](.*)/i','$1', $origTitle);
259 }
260 }
261 else if(strlen($curTitle) > 150 || strlen($curTitle) < 15)
262 {
263 $hOnes = $this->dom->getElementsByTagName('h1');
264 if($hOnes->length == 1)
265 {
266 $curTitle = $this->getInnerText($hOnes->item(0));
267 }
268 }
269
270 $curTitle = trim($curTitle);
271
272 if (count(explode(' ', $curTitle)) <= 4) {
273 $curTitle = $origTitle;
274 }
275
276 $articleTitle = $this->dom->createElement('h1');
277 $articleTitle->innerHTML = $curTitle;
278
279 return $articleTitle;
280 }
281
282 /**
283 * Prepare the HTML document for readability to scrape it.
284 * This includes things like stripping javascript, CSS, and handling terrible markup.
285 *
286 * @return void
287 **/
288 protected function prepDocument() {
289 /**
290 * In some cases a body element can't be found (if the HTML is totally hosed for example)
291 * so we create a new body node and append it to the document.
292 */
293 if ($this->body == null)
294 {
295 $this->body = $this->dom->createElement('body');
296 $this->dom->documentElement->appendChild($this->body);
297 }
298 $this->body->setAttribute('id', 'readabilityBody');
299
300 /* Remove all style tags in head */
301 $styleTags = $this->dom->getElementsByTagName('style');
302 for ($i = $styleTags->length-1; $i >= 0; $i--)
303 {
304 $styleTags->item($i)->parentNode->removeChild($styleTags->item($i));
305 }
306
307 /* Turn all double br's into p's */
308 /* Note, this is pretty costly as far as processing goes. Maybe optimize later. */
309 //document.body.innerHTML = document.body.innerHTML.replace(readability.regexps.replaceBrs, '</p><p>').replace(readability.regexps.replaceFonts, '<$1span>');
310 // We do this in the constructor for PHP as that's when we have raw HTML - before parsing it into a DOM tree.
311 // Manipulating innerHTML as it's done in JS is not possible in PHP.
312 }
313
314 /**
315 * For easier reading, convert this document to have footnotes at the bottom rather than inline links.
316 * @see http://www.roughtype.com/archives/2010/05/experiments_in.php
317 *
318 * @return void
319 **/
320 public function addFootnotes($articleContent) {
321 $footnotesWrapper = $this->dom->createElement('div');
322 $footnotesWrapper->setAttribute('id', 'readability-footnotes');
323 $footnotesWrapper->innerHTML = '<h3>References</h3>';
324
325 $articleFootnotes = $this->dom->createElement('ol');
326 $articleFootnotes->setAttribute('id', 'readability-footnotes-list');
327 $footnotesWrapper->appendChild($articleFootnotes);
328
329 $articleLinks = $articleContent->getElementsByTagName('a');
330
331 $linkCount = 0;
332 for ($i = 0; $i < $articleLinks->length; $i++)
333 {
334 $articleLink = $articleLinks->item($i);
335 $footnoteLink = $articleLink->cloneNode(true);
336 $refLink = $this->dom->createElement('a');
337 $footnote = $this->dom->createElement('li');
338 $linkDomain = @parse_url($footnoteLink->getAttribute('href'), PHP_URL_HOST);
339 if (!$linkDomain && isset($this->url)) $linkDomain = @parse_url($this->url, PHP_URL_HOST);
340 //linkDomain = footnoteLink.host ? footnoteLink.host : document.location.host,
341 $linkText = $this->getInnerText($articleLink);
342
343 if ((strpos($articleLink->getAttribute('class'), 'readability-DoNotFootnote') !== false) || preg_match($this->regexps['skipFootnoteLink'], $linkText)) {
344 continue;
345 }
346
347 $linkCount++;
348
349 /** Add a superscript reference after the article link */
350 $refLink->setAttribute('href', '#readabilityFootnoteLink-' . $linkCount);
351 $refLink->innerHTML = '<small><sup>[' . $linkCount . ']</sup></small>';
352 $refLink->setAttribute('class', 'readability-DoNotFootnote');
353 $refLink->setAttribute('style', 'color: inherit;');
354
355 //TODO: does this work or should we use DOMNode.isSameNode()?
356 if ($articleLink->parentNode->lastChild == $articleLink) {
357 $articleLink->parentNode->appendChild($refLink);
358 } else {
359 $articleLink->parentNode->insertBefore($refLink, $articleLink->nextSibling);
360 }
361
362 $articleLink->setAttribute('style', 'color: inherit; text-decoration: none;');
363 $articleLink->setAttribute('name', 'readabilityLink-' . $linkCount);
364
365 $footnote->innerHTML = '<small><sup><a href="#readabilityLink-' . $linkCount . '" title="Jump to Link in Article">^</a></sup></small> ';
366
367 $footnoteLink->innerHTML = ($footnoteLink->getAttribute('title') != '' ? $footnoteLink->getAttribute('title') : $linkText);
368 $footnoteLink->setAttribute('name', 'readabilityFootnoteLink-' . $linkCount);
369
370 $footnote->appendChild($footnoteLink);
371 if ($linkDomain) $footnote->innerHTML = $footnote->innerHTML . '<small> (' . $linkDomain . ')</small>';
372
373 $articleFootnotes->appendChild($footnote);
374 }
375
376 if ($linkCount > 0) {
377 $articleContent->appendChild($footnotesWrapper);
378 }
379 }
380
381 /**
382 * Reverts P elements with class 'readability-styled'
383 * to text nodes - which is what they were before.
384 *
385 * @param DOMElement
386 * @return void
387 */
388 function revertReadabilityStyledElements($articleContent) {
389 $xpath = new DOMXPath($articleContent->ownerDocument);
390 $elems = $xpath->query('.//p[@class="readability-styled"]', $articleContent);
391 //$elems = $articleContent->getElementsByTagName('p');
392 for ($i = $elems->length-1; $i >= 0; $i--) {
393 $e = $elems->item($i);
394 $e->parentNode->replaceChild($articleContent->ownerDocument->createTextNode($e->textContent), $e);
395 //if ($e->hasAttribute('class') && $e->getAttribute('class') == 'readability-styled') {
396 // $e->parentNode->replaceChild($this->dom->createTextNode($e->textContent), $e);
397 //}
398 }
399 }
400
401 /**
402 * Prepare the article node for display. Clean out any inline styles,
403 * iframes, forms, strip extraneous <p> tags, etc.
404 *
405 * @param DOMElement
406 * @return void
407 */
408 function prepArticle($articleContent) {
409 $this->cleanStyles($articleContent);
410 $this->killBreaks($articleContent);
411 if ($this->revertForcedParagraphElements) {
412 $this->revertReadabilityStyledElements($articleContent);
413 }
414
415 /* Clean out junk from the article content */
416 $this->cleanConditionally($articleContent, 'form');
417 $this->clean($articleContent, 'object');
418 $this->clean($articleContent, 'h1');
419
420 /**
421 * If there is only one h2, they are probably using it
422 * as a header and not a subheader, so remove it since we already have a header.
423 ***/
424 if ($articleContent->getElementsByTagName('h2')->length == 1) {
425 $this->clean($articleContent, 'h2');
426 }
427 $this->clean($articleContent, 'iframe');
428
429 $this->cleanHeaders($articleContent);
430
431 /* Do these last as the previous stuff may have removed junk that will affect these */
432 $this->cleanConditionally($articleContent, 'table');
433 $this->cleanConditionally($articleContent, 'ul');
434 $this->cleanConditionally($articleContent, 'div');
435
436 /* Remove extra paragraphs */
437 $articleParagraphs = $articleContent->getElementsByTagName('p');
438 for ($i = $articleParagraphs->length-1; $i >= 0; $i--)
439 {
440 $imgCount = $articleParagraphs->item($i)->getElementsByTagName('img')->length;
441 $embedCount = $articleParagraphs->item($i)->getElementsByTagName('embed')->length;
442 $objectCount = $articleParagraphs->item($i)->getElementsByTagName('object')->length;
443
444 if ($imgCount === 0 && $embedCount === 0 && $objectCount === 0 && $this->getInnerText($articleParagraphs->item($i), false) == '')
445 {
446 $articleParagraphs->item($i)->parentNode->removeChild($articleParagraphs->item($i));
447 }
448 }
449
450 try {
451 $articleContent->innerHTML = preg_replace('/<br[^>]*>\s*<p/i', '<p', $articleContent->innerHTML);
452 //articleContent.innerHTML = articleContent.innerHTML.replace(/<br[^>]*>\s*<p/gi, '<p');
453 }
454 catch (Exception $e) {
455 $this->dbg("Cleaning innerHTML of breaks failed. This is an IE strict-block-elements bug. Ignoring.: " . $e);
456 }
457 }
458
459 /**
460 * Initialize a node with the readability object. Also checks the
461 * className/id for special names to add to its score.
462 *
463 * @param Element
464 * @return void
465 **/
466 protected function initializeNode($node) {
467 $readability = $this->dom->createAttribute('readability');
468 $readability->value = 0; // this is our contentScore
469 $node->setAttributeNode($readability);
470
471 switch (strtoupper($node->tagName)) { // unsure if strtoupper is needed, but using it just in case
472 case 'DIV':
473 $readability->value += 5;
474 break;
475
476 case 'PRE':
477 case 'TD':
478 case 'BLOCKQUOTE':
479 $readability->value += 3;
480 break;
481
482 case 'ADDRESS':
483 case 'OL':
484 case 'UL':
485 case 'DL':
486 case 'DD':
487 case 'DT':
488 case 'LI':
489 case 'FORM':
490 $readability->value -= 3;
491 break;
492
493 case 'H1':
494 case 'H2':
495 case 'H3':
496 case 'H4':
497 case 'H5':
498 case 'H6':
499 case 'TH':
500 $readability->value -= 5;
501 break;
502 }
503 $readability->value += $this->getClassWeight($node);
504 }
505
506 /***
507 * grabArticle - Using a variety of metrics (content score, classname, element types), find the content that is
508 * most likely to be the stuff a user wants to read. Then return it wrapped up in a div.
509 *
510 * @return DOMElement
511 **/
512 protected function grabArticle($page=null) {
513 $stripUnlikelyCandidates = $this->flagIsActive(self::FLAG_STRIP_UNLIKELYS);
514 if (!$page) $page = $this->dom;
515 $allElements = $page->getElementsByTagName('*');
516 /**
517 * First, node prepping. Trash nodes that look cruddy (like ones with the class name "comment", etc), and turn divs
518 * into P tags where they have been used inappropriately (as in, where they contain no other block level elements.)
519 *
520 * Note: Assignment from index for performance. See http://www.peachpit.com/articles/article.aspx?p=31567&seqNum=5
521 * TODO: Shouldn't this be a reverse traversal?
522 **/
523 $node = null;
524 $nodesToScore = array();
525 for ($nodeIndex = 0; ($node = $allElements->item($nodeIndex)); $nodeIndex++) {
526 //for ($nodeIndex=$targetList->length-1; $nodeIndex >= 0; $nodeIndex--) {
527 //$node = $targetList->item($nodeIndex);
528 $tagName = strtoupper($node->tagName);
529 /* Remove unlikely candidates */
530 if ($stripUnlikelyCandidates) {
531 $unlikelyMatchString = $node->getAttribute('class') . $node->getAttribute('id');
532 if (
533 preg_match($this->regexps['unlikelyCandidates'], $unlikelyMatchString) &&
534 !preg_match($this->regexps['okMaybeItsACandidate'], $unlikelyMatchString) &&
535 $tagName != 'BODY'
536 )
537 {
538 $this->dbg('Removing unlikely candidate - ' . $unlikelyMatchString);
539 //$nodesToRemove[] = $node;
540 $node->parentNode->removeChild($node);
541 $nodeIndex--;
542 continue;
543 }
544 }
545
546 if ($tagName == 'P' || $tagName == 'TD' || $tagName == 'PRE') {
547 $nodesToScore[] = $node;
548 }
549
550 /* Turn all divs that don't have children block level elements into p's */
551 if ($tagName == 'DIV') {
552 if (!preg_match($this->regexps['divToPElements'], $node->innerHTML)) {
553 //$this->dbg('Altering div to p');
554 $newNode = $this->dom->createElement('p');
555 try {
556 $newNode->innerHTML = $node->innerHTML;
557 //$nodesToReplace[] = array('new'=>$newNode, 'old'=>$node);
558 $node->parentNode->replaceChild($newNode, $node);
559 $nodeIndex--;
560 $nodesToScore[] = $node; // or $newNode?
561 }
562 catch(Exception $e) {
563 $this->dbg('Could not alter div to p, reverting back to div.: ' . $e);
564 }
565 }
566 else
567 {
568 // EXPERIMENTAL
569 // TODO: change these p elements back to text nodes after processing
570 for ($i = 0, $il = $node->childNodes->length; $i < $il; $i++) {
571 $childNode = $node->childNodes->item($i);
572 if ($childNode->nodeType == 3) { // XML_TEXT_NODE
573 //$this->dbg('replacing text node with a p tag with the same content.');
574 $p = $this->dom->createElement('p');
575 $p->innerHTML = $childNode->nodeValue;
576 $p->setAttribute('style', 'display: inline;');
577 $p->setAttribute('class', 'readability-styled');
578 $childNode->parentNode->replaceChild($p, $childNode);
579 }
580 }
581 }
582 }
583 }
584
585 /**
586 * Loop through all paragraphs, and assign a score to them based on how content-y they look.
587 * Then add their score to their parent node.
588 *
589 * A score is determined by things like number of commas, class names, etc. Maybe eventually link density.
590 **/
591 $candidates = array();
592 for ($pt=0; $pt < count($nodesToScore); $pt++) {
593 $parentNode = $nodesToScore[$pt]->parentNode;
594 // $grandParentNode = $parentNode ? $parentNode->parentNode : null;
595 $grandParentNode = !$parentNode ? null : (($parentNode->parentNode instanceof DOMElement) ? $parentNode->parentNode : null);
596 $innerText = $this->getInnerText($nodesToScore[$pt]);
597
598 if (!$parentNode || !isset($parentNode->tagName)) {
599 continue;
600 }
601
602 /* If this paragraph is less than 25 characters, don't even count it. */
603 if(strlen($innerText) < 25) {
604 continue;
605 }
606
607 /* Initialize readability data for the parent. */
608 if (!$parentNode->hasAttribute('readability'))
609 {
610 $this->initializeNode($parentNode);
611 $candidates[] = $parentNode;
612 }
613
614 /* Initialize readability data for the grandparent. */
615 if ($grandParentNode && !$grandParentNode->hasAttribute('readability') && isset($grandParentNode->tagName))
616 {
617 $this->initializeNode($grandParentNode);
618 $candidates[] = $grandParentNode;
619 }
620
621 $contentScore = 0;
622
623 /* Add a point for the paragraph itself as a base. */
624 $contentScore++;
625
626 /* Add points for any commas within this paragraph */
627 $contentScore += count(explode(',', $innerText));
628
629 /* For every 100 characters in this paragraph, add another point. Up to 3 points. */
630 $contentScore += min(floor(strlen($innerText) / 100), 3);
631
632 /* Add the score to the parent. The grandparent gets half. */
633 $parentNode->getAttributeNode('readability')->value += $contentScore;
634
635 if ($grandParentNode) {
636 $grandParentNode->getAttributeNode('readability')->value += $contentScore/2;
637 }
638 }
639
640 /**
641 * After we've calculated scores, loop through all of the possible candidate nodes we found
642 * and find the one with the highest score.
643 **/
644 $topCandidate = null;
645 for ($c=0, $cl=count($candidates); $c < $cl; $c++)
646 {
647 /**
648 * Scale the final candidates score based on link density. Good content should have a
649 * relatively small link density (5% or less) and be mostly unaffected by this operation.
650 **/
651 $readability = $candidates[$c]->getAttributeNode('readability');
652 $readability->value = $readability->value * (1-$this->getLinkDensity($candidates[$c]));
653
654 $this->dbg('Candidate: ' . $candidates[$c]->tagName . ' (' . $candidates[$c]->getAttribute('class') . ':' . $candidates[$c]->getAttribute('id') . ') with score ' . $readability->value);
655
656 if (!$topCandidate || $readability->value > (int)$topCandidate->getAttribute('readability')) {
657 $topCandidate = $candidates[$c];
658 }
659 }
660
661 /**
662 * If we still have no top candidate, just use the body as a last resort.
663 * We also have to copy the body node so it is something we can modify.
664 **/
665 if ($topCandidate === null || strtoupper($topCandidate->tagName) == 'BODY')
666 {
667 $topCandidate = $this->dom->createElement('div');
668 if ($page instanceof DOMDocument) {
669 if (!isset($page->documentElement)) {
670 // we don't have a body either? what a mess! :)
671 } else {
672 $topCandidate->innerHTML = $page->documentElement->innerHTML;
673 $page->documentElement->innerHTML = '';
674 $page->documentElement->appendChild($topCandidate);
675 }
676 } else {
677 $topCandidate->innerHTML = $page->innerHTML;
678 $page->innerHTML = '';
679 $page->appendChild($topCandidate);
680 }
681 $this->initializeNode($topCandidate);
682 }
683
684 /**
685 * Now that we have the top candidate, look through its siblings for content that might also be related.
686 * Things like preambles, content split by ads that we removed, etc.
687 **/
688 $articleContent = $this->dom->createElement('div');
689 $articleContent->setAttribute('id', 'readability-content');
690 $siblingScoreThreshold = max(10, ((int)$topCandidate->getAttribute('readability')) * 0.2);
691 $siblingNodes = $topCandidate->parentNode->childNodes;
692 if (!isset($siblingNodes)) {
693 $siblingNodes = new stdClass;
694 $siblingNodes->length = 0;
695 }
696
697 for ($s=0, $sl=$siblingNodes->length; $s < $sl; $s++)
698 {
699 $siblingNode = $siblingNodes->item($s);
700 $append = false;
701
702 $this->dbg('Looking at sibling node: ' . $siblingNode->nodeName . (($siblingNode->nodeType === XML_ELEMENT_NODE && $siblingNode->hasAttribute('readability')) ? (' with score ' . $siblingNode->getAttribute('readability')) : ''));
703
704 //dbg('Sibling has score ' . ($siblingNode->readability ? siblingNode.readability.contentScore : 'Unknown'));
705
706 if ($siblingNode === $topCandidate)
707 // or if ($siblingNode->isSameNode($topCandidate))
708 {
709 $append = true;
710 }
711
712 $contentBonus = 0;
713 /* Give a bonus if sibling nodes and top candidates have the example same classname */
714 if ($siblingNode->nodeType === XML_ELEMENT_NODE && $siblingNode->getAttribute('class') == $topCandidate->getAttribute('class') && $topCandidate->getAttribute('class') != '') {
715 $contentBonus += ((int)$topCandidate->getAttribute('readability')) * 0.2;
716 }
717
718 if ($siblingNode->nodeType === XML_ELEMENT_NODE && $siblingNode->hasAttribute('readability') && (((int)$siblingNode->getAttribute('readability')) + $contentBonus) >= $siblingScoreThreshold)
719 {
720 $append = true;
721 }
722
723 if (strtoupper($siblingNode->nodeName) == 'P') {
724 $linkDensity = $this->getLinkDensity($siblingNode);
725 $nodeContent = $this->getInnerText($siblingNode);
726 $nodeLength = strlen($nodeContent);
727
728 if ($nodeLength > 80 && $linkDensity < 0.25)
729 {
730 $append = true;
731 }
732 else if ($nodeLength < 80 && $linkDensity === 0 && preg_match('/\.( |$)/', $nodeContent))
733 {
734 $append = true;
735 }
736 }
737
738 /* Look for a special classname */
739 if ($siblingNode->nodeType === XML_ELEMENT_NODE && $siblingNode->hasAttribute('class') && $siblingNode->getAttribute('class') != '')
740 {
741 if (preg_match($this->regexps['okMaybeItsACandidate'], $siblingNode->getAttribute('class'))) {
742 $append = true;
743 }
744 }
745
746 /* Look for a special classname */
747 if ($siblingNode->nodeType === XML_ELEMENT_NODE && $siblingNode->hasAttribute('id') && $siblingNode->getAttribute('id') != '')
748 {
749 if (preg_match($this->regexps['okMaybeItsACandidate'], $siblingNode->getAttribute('id'))) {
750 $append = true;
751 }
752 }
753
754
755 if ($append)
756 {
757 $this->dbg('Appending node: ' . $siblingNode->nodeName);
758
759 $nodeToAppend = null;
760 $sibNodeName = strtoupper($siblingNode->nodeName);
761 if ($sibNodeName != 'DIV' && $sibNodeName != 'P') {
762 /* 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. */
763
764 $this->dbg('Altering siblingNode of ' . $sibNodeName . ' to div.');
765 $nodeToAppend = $this->dom->createElement('div');
766 try {
767 $nodeToAppend->setAttribute('id', $siblingNode->getAttribute('id'));
768 $nodeToAppend->innerHTML = $siblingNode->innerHTML;
769 }
770 catch(Exception $e)
771 {
772 $this->dbg('Could not alter siblingNode to div, reverting back to original.');
773 $nodeToAppend = $siblingNode;
774 $s--;
775 $sl--;
776 }
777 } else {
778 $nodeToAppend = $siblingNode;
779 $s--;
780 $sl--;
781 }
782
783 /* To ensure a node does not interfere with readability styles, remove its classnames */
784 $nodeToAppend->removeAttribute('class');
785
786 /* Append sibling and subtract from our list because it removes the node when you append to another node */
787 $articleContent->appendChild($nodeToAppend);
788 }
789 }
790
791 /**
792 * So we have all of the content that we need. Now we clean it up for presentation.
793 **/
794 $this->prepArticle($articleContent);
795
796 /**
797 * Now that we've gone through the full algorithm, check to see if we got any meaningful content.
798 * If we didn't, we may need to re-run grabArticle with different flags set. This gives us a higher
799 * likelihood of finding the content, and the sieve approach gives us a higher likelihood of
800 * finding the -right- content.
801 **/
802 if (strlen($this->getInnerText($articleContent, false)) < 250)
803 {
804 // TODO: find out why element disappears sometimes, e.g. for this URL http://www.businessinsider.com/6-hedge-fund-etfs-for-average-investors-2011-7
805 // in the meantime, we check and create an empty element if it's not there.
806 if (!isset($this->body->childNodes)) $this->body = $this->dom->createElement('body');
807 $this->body->innerHTML = $this->bodyCache;
808
809 if ($this->flagIsActive(self::FLAG_STRIP_UNLIKELYS)) {
810 $this->removeFlag(self::FLAG_STRIP_UNLIKELYS);
811 return $this->grabArticle($this->body);
812 }
813 else if ($this->flagIsActive(self::FLAG_WEIGHT_CLASSES)) {
814 $this->removeFlag(self::FLAG_WEIGHT_CLASSES);
815 return $this->grabArticle($this->body);
816 }
817 else if ($this->flagIsActive(self::FLAG_CLEAN_CONDITIONALLY)) {
818 $this->removeFlag(self::FLAG_CLEAN_CONDITIONALLY);
819 return $this->grabArticle($this->body);
820 }
821 else {
822 return false;
823 }
824 }
825 return $articleContent;
826 }
827
828 /**
829 * Remove script tags from document
830 *
831 * @param DOMElement
832 * @return void
833 */
834 public function removeScripts($doc) {
835 $scripts = $doc->getElementsByTagName('script');
836 for($i = $scripts->length-1; $i >= 0; $i--)
837 {
838 $scripts->item($i)->parentNode->removeChild($scripts->item($i));
839 }
840 }
841
842 /**
843 * Get the inner text of a node.
844 * This also strips out any excess whitespace to be found.
845 *
846 * @param DOMElement $
847 * @param boolean $normalizeSpaces (default: true)
848 * @return string
849 **/
850 public function getInnerText($e, $normalizeSpaces=true) {
851 $textContent = '';
852
853 if (!isset($e->textContent) || $e->textContent == '') {
854 return '';
855 }
856
857 $textContent = trim($e->textContent);
858
859 if ($normalizeSpaces) {
860 return preg_replace($this->regexps['normalize'], ' ', $textContent);
861 } else {
862 return $textContent;
863 }
864 }
865
866 /**
867 * Get the number of times a string $s appears in the node $e.
868 *
869 * @param DOMElement $e
870 * @param string - what to count. Default is ","
871 * @return number (integer)
872 **/
873 public function getCharCount($e, $s=',') {
874 return substr_count($this->getInnerText($e), $s);
875 }
876
877 /**
878 * Remove the style attribute on every $e and under.
879 *
880 * @param DOMElement $e
881 * @return void
882 */
883 public function cleanStyles($e) {
884 if (!is_object($e)) return;
885 $elems = $e->getElementsByTagName('*');
886 foreach ($elems as $elem) {
887 $elem->removeAttribute('style');
888 }
889 }
890
891 /**
892 * Get the density of links as a percentage of the content
893 * This is the amount of text that is inside a link divided by the total text in the node.
894 *
895 * @param DOMElement $e
896 * @return number (float)
897 */
898 public function getLinkDensity($e) {
899 $links = $e->getElementsByTagName('a');
900 $textLength = strlen($this->getInnerText($e));
901 $linkLength = 0;
902 for ($i=0, $il=$links->length; $i < $il; $i++)
903 {
904 $linkLength += strlen($this->getInnerText($links->item($i)));
905 }
906 if ($textLength > 0) {
907 return $linkLength / $textLength;
908 } else {
909 return 0;
910 }
911 }
912
913 /**
914 * Get an elements class/id weight. Uses regular expressions to tell if this
915 * element looks good or bad.
916 *
917 * @param DOMElement $e
918 * @return number (Integer)
919 */
920 public function getClassWeight($e) {
921 if(!$this->flagIsActive(self::FLAG_WEIGHT_CLASSES)) {
922 return 0;
923 }
924
925 $weight = 0;
926
927 /* Look for a special classname */
928 if ($e->hasAttribute('class') && $e->getAttribute('class') != '')
929 {
930 if (preg_match($this->regexps['negative'], $e->getAttribute('class'))) {
931 $weight -= 25;
932 }
933 if (preg_match($this->regexps['positive'], $e->getAttribute('class'))) {
934 $weight += 25;
935 }
936 }
937
938 /* Look for a special ID */
939 if ($e->hasAttribute('id') && $e->getAttribute('id') != '')
940 {
941 if (preg_match($this->regexps['negative'], $e->getAttribute('id'))) {
942 $weight -= 25;
943 }
944 if (preg_match($this->regexps['positive'], $e->getAttribute('id'))) {
945 $weight += 25;
946 }
947 }
948 return $weight;
949 }
950
951 /**
952 * Remove extraneous break tags from a node.
953 *
954 * @param DOMElement $node
955 * @return void
956 */
957 public function killBreaks($node) {
958 $html = $node->innerHTML;
959 $html = preg_replace($this->regexps['killBreaks'], '<br />', $html);
960 $node->innerHTML = $html;
961 }
962
963 /**
964 * Clean a node of all elements of type "tag".
965 * (Unless it's a youtube/vimeo video. People love movies.)
966 *
967 * @param DOMElement $e
968 * @param string $tag
969 * @return void
970 */
971 public function clean($e, $tag) {
972 $targetList = $e->getElementsByTagName($tag);
973 $isEmbed = ($tag == 'object' || $tag == 'embed');
974
975 for ($y=$targetList->length-1; $y >= 0; $y--) {
976 /* Allow youtube and vimeo videos through as people usually want to see those. */
977 if ($isEmbed) {
978 $attributeValues = '';
979 for ($i=0, $il=$targetList->item($y)->attributes->length; $i < $il; $i++) {
980 $attributeValues .= $targetList->item($y)->attributes->item($i)->value . '|'; // DOMAttr? (TODO: test)
981 }
982
983 /* First, check the elements attributes to see if any of them contain youtube or vimeo */
984 if (preg_match($this->regexps['video'], $attributeValues)) {
985 continue;
986 }
987
988 /* Then check the elements inside this element for the same. */
989 if (preg_match($this->regexps['video'], $targetList->item($y)->innerHTML)) {
990 continue;
991 }
992 }
993 $targetList->item($y)->parentNode->removeChild($targetList->item($y));
994 }
995 }
996
997 /**
998 * Clean an element of all tags of type "tag" if they look fishy.
999 * "Fishy" is an algorithm based on content length, classnames,
1000 * link density, number of images & embeds, etc.
1001 *
1002 * @param DOMElement $e
1003 * @param string $tag
1004 * @return void
1005 */
1006 public function cleanConditionally($e, $tag) {
1007 if (!$this->flagIsActive(self::FLAG_CLEAN_CONDITIONALLY)) {
1008 return;
1009 }
1010
1011 $tagsList = $e->getElementsByTagName($tag);
1012 $curTagsLength = $tagsList->length;
1013
1014 /**
1015 * Gather counts for other typical elements embedded within.
1016 * Traverse backwards so we can remove nodes at the same time without effecting the traversal.
1017 *
1018 * TODO: Consider taking into account original contentScore here.
1019 */
1020 for ($i=$curTagsLength-1; $i >= 0; $i--) {
1021 $weight = $this->getClassWeight($tagsList->item($i));
1022 $contentScore = ($tagsList->item($i)->hasAttribute('readability')) ? (int)$tagsList->item($i)->getAttribute('readability') : 0;
1023
1024 $this->dbg('Cleaning Conditionally ' . $tagsList->item($i)->tagName . ' (' . $tagsList->item($i)->getAttribute('class') . ':' . $tagsList->item($i)->getAttribute('id') . ')' . (($tagsList->item($i)->hasAttribute('readability')) ? (' with score ' . $tagsList->item($i)->getAttribute('readability')) : ''));
1025
1026 if ($weight + $contentScore < 0) {
1027 $tagsList->item($i)->parentNode->removeChild($tagsList->item($i));
1028 }
1029 else if ( $this->getCharCount($tagsList->item($i), ',') < 10) {
1030 /**
1031 * If there are not very many commas, and the number of
1032 * non-paragraph elements is more than paragraphs or other ominous signs, remove the element.
1033 **/
1034 $p = $tagsList->item($i)->getElementsByTagName('p')->length;
1035 $img = $tagsList->item($i)->getElementsByTagName('img')->length;
1036 $li = $tagsList->item($i)->getElementsByTagName('li')->length-100;
1037 $input = $tagsList->item($i)->getElementsByTagName('input')->length;
1038
1039 $embedCount = 0;
1040 $embeds = $tagsList->item($i)->getElementsByTagName('embed');
1041 for ($ei=0, $il=$embeds->length; $ei < $il; $ei++) {
1042 if (preg_match($this->regexps['video'], $embeds->item($ei)->getAttribute('src'))) {
1043 $embedCount++;
1044 }
1045 }
1046
1047 $linkDensity = $this->getLinkDensity($tagsList->item($i));
1048 $contentLength = strlen($this->getInnerText($tagsList->item($i)));
1049 $toRemove = false;
1050
1051 if ( $img > $p ) {
1052 $toRemove = true;
1053 } else if ($li > $p && $tag != 'ul' && $tag != 'ol') {
1054 $toRemove = true;
1055 } else if ( $input > floor($p/3) ) {
1056 $toRemove = true;
1057 } else if ($contentLength < 25 && ($img === 0 || $img > 2) ) {
1058 $toRemove = true;
1059 } else if($weight < 25 && $linkDensity > 0.2) {
1060 $toRemove = true;
1061 } else if($weight >= 25 && $linkDensity > 0.5) {
1062 $toRemove = true;
1063 } else if(($embedCount == 1 && $contentLength < 75) || $embedCount > 1) {
1064 $toRemove = true;
1065 }
1066
1067 if ($toRemove) {
1068 $tagsList->item($i)->parentNode->removeChild($tagsList->item($i));
1069 }
1070 }
1071 }
1072 }
1073
1074 /**
1075 * Clean out spurious headers from an Element. Checks things like classnames and link density.
1076 *
1077 * @param DOMElement $e
1078 * @return void
1079 */
1080 public function cleanHeaders($e) {
1081 for ($headerIndex = 1; $headerIndex < 3; $headerIndex++) {
1082 $headers = $e->getElementsByTagName('h' . $headerIndex);
1083 for ($i=$headers->length-1; $i >=0; $i--) {
1084 if ($this->getClassWeight($headers->item($i)) < 0 || $this->getLinkDensity($headers->item($i)) > 0.33) {
1085 $headers->item($i)->parentNode->removeChild($headers->item($i));
1086 }
1087 }
1088 }
1089 }
1090
1091 public function flagIsActive($flag) {
1092 return ($this->flags & $flag) > 0;
1093 }
1094
1095 public function addFlag($flag) {
1096 $this->flags = $this->flags | $flag;
1097 }
1098
1099 public function removeFlag($flag) {
1100 $this->flags = $this->flags & ~$flag;
1101 }
1102}
1103?> \ No newline at end of file
diff --git a/inc/index.html b/inc/index.html
new file mode 100755
index 00000000..e69de29b
--- /dev/null
+++ b/inc/index.html
diff --git a/inc/rain.tpl.class.php b/inc/rain.tpl.class.php
new file mode 100755
index 00000000..ea83b2c1
--- /dev/null
+++ b/inc/rain.tpl.class.php
@@ -0,0 +1,1043 @@
1<?php
2
3/**
4 * RainTPL
5 * -------
6 * Realized by Federico Ulfo & maintained by the Rain Team
7 * Distributed under GNU/LGPL 3 License
8 *
9 * @version 2.7.2
10 */
11
12
13class RainTPL{
14
15 // -------------------------
16 // CONFIGURATION
17 // -------------------------
18
19 /**
20 * Template directory
21 *
22 * @var string
23 */
24 static $tpl_dir = "tpl/";
25
26
27 /**
28 * Cache directory. Is the directory where RainTPL will compile the template and save the cache
29 *
30 * @var string
31 */
32 static $cache_dir = "tmp/";
33
34
35 /**
36 * Template base URL. RainTPL will add this URL to the relative paths of element selected in $path_replace_list.
37 *
38 * @var string
39 */
40 static $base_url = null;
41
42
43 /**
44 * Template extension.
45 *
46 * @var string
47 */
48 static $tpl_ext = "html";
49
50
51 /**
52 * Path replace is a cool features that replace all relative paths of images (<img src="...">), stylesheet (<link href="...">), script (<script src="...">) and link (<a href="...">)
53 * Set true to enable the path replace.
54 *
55 * @var unknown_type
56 */
57 static $path_replace = true;
58
59
60 /**
61 * You can set what the path_replace method will replace.
62 * Avaible options: a, img, link, script, input
63 *
64 * @var array
65 */
66 static $path_replace_list = array( 'a', 'img', 'link', 'script', 'input' );
67
68
69 /**
70 * You can define in the black list what string are disabled into the template tags
71 *
72 * @var unknown_type
73 */
74 static $black_list = array( '\$this', 'raintpl::', 'self::', '_SESSION', '_SERVER', '_ENV', 'eval', 'exec', 'unlink', 'rmdir' );
75
76
77 /**
78 * Check template.
79 * true: checks template update time, if changed it compile them
80 * false: loads the compiled template. Set false if server doesn't have write permission for cache_directory.
81 *
82 */
83 static $check_template_update = true;
84
85
86 /**
87 * PHP tags <? ?>
88 * True: php tags are enabled into the template
89 * False: php tags are disabled into the template and rendered as html
90 *
91 * @var bool
92 */
93 static $php_enabled = false;
94
95
96 /**
97 * Debug mode flag.
98 * True: debug mode is used, syntax errors are displayed directly in template. Execution of script is not terminated.
99 * False: exception is thrown on found error.
100 *
101 * @var bool
102 */
103 static $debug = false;
104
105 // -------------------------
106
107
108 // -------------------------
109 // RAINTPL VARIABLES
110 // -------------------------
111
112 /**
113 * Is the array where RainTPL keep the variables assigned
114 *
115 * @var array
116 */
117 public $var = array();
118
119 protected $tpl = array(), // variables to keep the template directories and info
120 $cache = false, // static cache enabled / disabled
121 $cache_id = null; // identify only one cache
122
123 protected static $config_name_sum = array(); // takes all the config to create the md5 of the file
124
125 // -------------------------
126
127
128
129 const CACHE_EXPIRE_TIME = 3600; // default cache expire time = hour
130
131
132
133 /**
134 * Assign variable
135 * eg. $t->assign('name','mickey');
136 *
137 * @param mixed $variable_name Name of template variable or associative array name/value
138 * @param mixed $value value assigned to this variable. Not set if variable_name is an associative array
139 */
140
141 function assign( $variable, $value = null ){
142 if( is_array( $variable ) )
143 $this->var += $variable;
144 else
145 $this->var[ $variable ] = $value;
146 }
147
148
149
150 /**
151 * Draw the template
152 * eg. $html = $tpl->draw( 'demo', TRUE ); // return template in string
153 * or $tpl->draw( $tpl_name ); // echo the template
154 *
155 * @param string $tpl_name template to load
156 * @param boolean $return_string true=return a string, false=echo the template
157 * @return string
158 */
159
160 function draw( $tpl_name, $return_string = false ){
161
162 try {
163 // compile the template if necessary and set the template filepath
164 $this->check_template( $tpl_name );
165 } catch (RainTpl_Exception $e) {
166 $output = $this->printDebug($e);
167 die($output);
168 }
169
170 // Cache is off and, return_string is false
171 // Rain just echo the template
172
173 if( !$this->cache && !$return_string ){
174 extract( $this->var );
175 include $this->tpl['compiled_filename'];
176 unset( $this->tpl );
177 }
178
179
180 // cache or return_string are enabled
181 // rain get the output buffer to save the output in the cache or to return it as string
182
183 else{
184
185 //----------------------
186 // get the output buffer
187 //----------------------
188 ob_start();
189 extract( $this->var );
190 include $this->tpl['compiled_filename'];
191 $raintpl_contents = ob_get_clean();
192 //----------------------
193
194
195 // save the output in the cache
196 if( $this->cache )
197 file_put_contents( $this->tpl['cache_filename'], "<?php if(!class_exists('raintpl')){exit;}?>" . $raintpl_contents );
198
199 // free memory
200 unset( $this->tpl );
201
202 // return or print the template
203 if( $return_string ) return $raintpl_contents; else echo $raintpl_contents;
204
205 }
206
207 }
208
209
210
211 /**
212 * If exists a valid cache for this template it returns the cache
213 *
214 * @param string $tpl_name Name of template (set the same of draw)
215 * @param int $expiration_time Set after how many seconds the cache expire and must be regenerated
216 * @return string it return the HTML or null if the cache must be recreated
217 */
218
219 function cache( $tpl_name, $expire_time = self::CACHE_EXPIRE_TIME, $cache_id = null ){
220
221 // set the cache_id
222 $this->cache_id = $cache_id;
223
224 if( !$this->check_template( $tpl_name ) && file_exists( $this->tpl['cache_filename'] ) && ( time() - filemtime( $this->tpl['cache_filename'] ) < $expire_time ) )
225 return substr( file_get_contents( $this->tpl['cache_filename'] ), 43 );
226 else{
227 //delete the cache of the selected template
228 if (file_exists($this->tpl['cache_filename']))
229 unlink($this->tpl['cache_filename'] );
230 $this->cache = true;
231 }
232 }
233
234
235
236 /**
237 * Configure the settings of RainTPL
238 *
239 */
240 static function configure( $setting, $value = null ){
241 if( is_array( $setting ) )
242 foreach( $setting as $key => $value )
243 self::configure( $key, $value );
244 else if( property_exists( __CLASS__, $setting ) ){
245 self::$$setting = $value;
246 self::$config_name_sum[ $setting ] = $value; // take trace of all config
247 }
248 }
249
250
251
252 // check if has to compile the template
253 // return true if the template has changed
254 protected function check_template( $tpl_name ){
255
256 if( !isset($this->tpl['checked']) ){
257
258 $tpl_basename = basename( $tpl_name ); // template basename
259 $tpl_basedir = strpos($tpl_name,"/") ? dirname($tpl_name) . '/' : null; // template basedirectory
260 $tpl_dir = self::$tpl_dir . $tpl_basedir; // template directory
261 $this->tpl['tpl_filename'] = $tpl_dir . $tpl_basename . '.' . self::$tpl_ext; // template filename
262 $temp_compiled_filename = self::$cache_dir . $tpl_basename . "." . md5( $tpl_dir . serialize(self::$config_name_sum));
263 $this->tpl['compiled_filename'] = $temp_compiled_filename . '.rtpl.php'; // cache filename
264 $this->tpl['cache_filename'] = $temp_compiled_filename . '.s_' . $this->cache_id . '.rtpl.php'; // static cache filename
265
266 // if the template doesn't exsist throw an error
267 if( self::$check_template_update && !file_exists( $this->tpl['tpl_filename'] ) ){
268 $e = new RainTpl_NotFoundException( 'Template '. $tpl_basename .' not found!' );
269 throw $e->setTemplateFile($this->tpl['tpl_filename']);
270 }
271
272 // file doesn't exsist, or the template was updated, Rain will compile the template
273 if( !file_exists( $this->tpl['compiled_filename'] ) || ( self::$check_template_update && filemtime($this->tpl['compiled_filename']) < filemtime( $this->tpl['tpl_filename'] ) ) ){
274 $this->compileFile( $tpl_basename, $tpl_basedir, $this->tpl['tpl_filename'], self::$cache_dir, $this->tpl['compiled_filename'] );
275 return true;
276 }
277 $this->tpl['checked'] = true;
278 }
279 }
280
281
282 /**
283 * execute stripslaches() on the xml block. Invoqued by preg_replace_callback function below
284 * @access protected
285 */
286 protected function xml_reSubstitution($capture) {
287 return "<?php echo '<?xml ".stripslashes($capture[1])." ?>'; ?>";
288 }
289
290 /**
291 * Compile and write the compiled template file
292 * @access protected
293 */
294 protected function compileFile( $tpl_basename, $tpl_basedir, $tpl_filename, $cache_dir, $compiled_filename ){
295
296 //read template file
297 $this->tpl['source'] = $template_code = file_get_contents( $tpl_filename );
298
299 //xml substitution
300 $template_code = preg_replace( "/<\?xml(.*?)\?>/s", "##XML\\1XML##", $template_code );
301
302 //disable php tag
303 if( !self::$php_enabled )
304 $template_code = str_replace( array("<?","?>"), array("&lt;?","?&gt;"), $template_code );
305
306 //xml re-substitution
307 $template_code = preg_replace_callback ( "/##XML(.*?)XML##/s", array($this, 'xml_reSubstitution'), $template_code );
308
309 //compile template
310 $template_compiled = "<?php if(!class_exists('raintpl')){exit;}?>" . $this->compileTemplate( $template_code, $tpl_basedir );
311
312
313 // fix the php-eating-newline-after-closing-tag-problem
314 $template_compiled = str_replace( "?>\n", "?>\n\n", $template_compiled );
315
316 // create directories
317 if( !is_dir( $cache_dir ) )
318 mkdir( $cache_dir, 0755, true );
319
320 if( !is_writable( $cache_dir ) )
321 throw new RainTpl_Exception ('Cache directory ' . $cache_dir . 'doesn\'t have write permission. Set write permission or set RAINTPL_CHECK_TEMPLATE_UPDATE to false. More details on http://www.raintpl.com/Documentation/Documentation-for-PHP-developers/Configuration/');
322
323 //write compiled file
324 file_put_contents( $compiled_filename, $template_compiled );
325 }
326
327
328
329 /**
330 * Compile template
331 * @access protected
332 */
333 protected function compileTemplate( $template_code, $tpl_basedir ){
334
335 //tag list
336 $tag_regexp = array( 'loop' => '(\{loop(?: name){0,1}="\${0,1}[^"]*"\})',
337 'loop_close' => '(\{\/loop\})',
338 'if' => '(\{if(?: condition){0,1}="[^"]*"\})',
339 'elseif' => '(\{elseif(?: condition){0,1}="[^"]*"\})',
340 'else' => '(\{else\})',
341 'if_close' => '(\{\/if\})',
342 'function' => '(\{function="[^"]*"\})',
343 'noparse' => '(\{noparse\})',
344 'noparse_close'=> '(\{\/noparse\})',
345 'ignore' => '(\{ignore\}|\{\*)',
346 'ignore_close' => '(\{\/ignore\}|\*\})',
347 'include' => '(\{include="[^"]*"(?: cache="[^"]*")?\})',
348 'template_info'=> '(\{\$template_info\})',
349 'function' => '(\{function="(\w*?)(?:.*?)"\})'
350 );
351
352 $tag_regexp = "/" . join( "|", $tag_regexp ) . "/";
353
354 //split the code with the tags regexp
355 $template_code = preg_split ( $tag_regexp, $template_code, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY );
356
357 //path replace (src of img, background and href of link)
358 $template_code = $this->path_replace( $template_code, $tpl_basedir );
359
360 //compile the code
361 $compiled_code = $this->compileCode( $template_code );
362
363 //return the compiled code
364 return $compiled_code;
365
366 }
367
368
369
370 /**
371 * Compile the code
372 * @access protected
373 */
374 protected function compileCode( $parsed_code ){
375
376 //variables initialization
377 $compiled_code = $open_if = $comment_is_open = $ignore_is_open = null;
378 $loop_level = 0;
379
380 //read all parsed code
381 while( $html = array_shift( $parsed_code ) ){
382
383 //close ignore tag
384 if( !$comment_is_open && ( strpos( $html, '{/ignore}' ) !== FALSE || strpos( $html, '*}' ) !== FALSE ) )
385 $ignore_is_open = false;
386
387 //code between tag ignore id deleted
388 elseif( $ignore_is_open ){
389 //ignore the code
390 }
391
392 //close no parse tag
393 elseif( strpos( $html, '{/noparse}' ) !== FALSE )
394 $comment_is_open = false;
395
396 //code between tag noparse is not compiled
397 elseif( $comment_is_open )
398 $compiled_code .= $html;
399
400 //ignore
401 elseif( strpos( $html, '{ignore}' ) !== FALSE || strpos( $html, '{*' ) !== FALSE )
402 $ignore_is_open = true;
403
404 //noparse
405 elseif( strpos( $html, '{noparse}' ) !== FALSE )
406 $comment_is_open = true;
407
408 //include tag
409 elseif( preg_match( '/\{include="([^"]*)"(?: cache="([^"]*)"){0,1}\}/', $html, $code ) ){
410
411 //variables substitution
412 $include_var = $this->var_replace( $code[ 1 ], $left_delimiter = null, $right_delimiter = null, $php_left_delimiter = '".' , $php_right_delimiter = '."', $loop_level );
413
414 // if the cache is active
415 if( isset($code[ 2 ]) ){
416
417 //dynamic include
418 $compiled_code .= '<?php $tpl = new '.get_class($this).';' .
419 'if( $cache = $tpl->cache( $template = basename("'.$include_var.'") ) )' .
420 ' echo $cache;' .
421 'else{' .
422 ' $tpl_dir_temp = self::$tpl_dir;' .
423 ' $tpl->assign( $this->var );' .
424 ( !$loop_level ? null : '$tpl->assign( "key", $key'.$loop_level.' ); $tpl->assign( "value", $value'.$loop_level.' );' ).
425 ' $tpl->draw( dirname("'.$include_var.'") . ( substr("'.$include_var.'",-1,1) != "/" ? "/" : "" ) . basename("'.$include_var.'") );'.
426 '} ?>';
427 }
428 else{
429
430 //dynamic include
431 $compiled_code .= '<?php $tpl = new '.get_class($this).';' .
432 '$tpl_dir_temp = self::$tpl_dir;' .
433 '$tpl->assign( $this->var );' .
434 ( !$loop_level ? null : '$tpl->assign( "key", $key'.$loop_level.' ); $tpl->assign( "value", $value'.$loop_level.' );' ).
435 '$tpl->draw( dirname("'.$include_var.'") . ( substr("'.$include_var.'",-1,1) != "/" ? "/" : "" ) . basename("'.$include_var.'") );'.
436 '?>';
437
438
439 }
440
441 }
442
443 //loop
444 elseif( preg_match( '/\{loop(?: name){0,1}="\${0,1}([^"]*)"\}/', $html, $code ) ){
445
446 //increase the loop counter
447 $loop_level++;
448
449 //replace the variable in the loop
450 $var = $this->var_replace( '$' . $code[ 1 ], $tag_left_delimiter=null, $tag_right_delimiter=null, $php_left_delimiter=null, $php_right_delimiter=null, $loop_level-1 );
451
452 //loop variables
453 $counter = "\$counter$loop_level"; // count iteration
454 $key = "\$key$loop_level"; // key
455 $value = "\$value$loop_level"; // value
456
457 //loop code
458 $compiled_code .= "<?php $counter=-1; if( isset($var) && is_array($var) && sizeof($var) ) foreach( $var as $key => $value ){ $counter++; ?>";
459
460 }
461
462 //close loop tag
463 elseif( strpos( $html, '{/loop}' ) !== FALSE ) {
464
465 //iterator
466 $counter = "\$counter$loop_level";
467
468 //decrease the loop counter
469 $loop_level--;
470
471 //close loop code
472 $compiled_code .= "<?php } ?>";
473
474 }
475
476 //if
477 elseif( preg_match( '/\{if(?: condition){0,1}="([^"]*)"\}/', $html, $code ) ){
478
479 //increase open if counter (for intendation)
480 $open_if++;
481
482 //tag
483 $tag = $code[ 0 ];
484
485 //condition attribute
486 $condition = $code[ 1 ];
487
488 // check if there's any function disabled by black_list
489 $this->function_check( $tag );
490
491 //variable substitution into condition (no delimiter into the condition)
492 $parsed_condition = $this->var_replace( $condition, $tag_left_delimiter = null, $tag_right_delimiter = null, $php_left_delimiter = null, $php_right_delimiter = null, $loop_level );
493
494 //if code
495 $compiled_code .= "<?php if( $parsed_condition ){ ?>";
496
497 }
498
499 //elseif
500 elseif( preg_match( '/\{elseif(?: condition){0,1}="([^"]*)"\}/', $html, $code ) ){
501
502 //tag
503 $tag = $code[ 0 ];
504
505 //condition attribute
506 $condition = $code[ 1 ];
507
508 //variable substitution into condition (no delimiter into the condition)
509 $parsed_condition = $this->var_replace( $condition, $tag_left_delimiter = null, $tag_right_delimiter = null, $php_left_delimiter = null, $php_right_delimiter = null, $loop_level );
510
511 //elseif code
512 $compiled_code .= "<?php }elseif( $parsed_condition ){ ?>";
513 }
514
515 //else
516 elseif( strpos( $html, '{else}' ) !== FALSE ) {
517
518 //else code
519 $compiled_code .= '<?php }else{ ?>';
520
521 }
522
523 //close if tag
524 elseif( strpos( $html, '{/if}' ) !== FALSE ) {
525
526 //decrease if counter
527 $open_if--;
528
529 // close if code
530 $compiled_code .= '<?php } ?>';
531
532 }
533
534 //function
535 elseif( preg_match( '/\{function="(\w*)(.*?)"\}/', $html, $code ) ){
536
537 //tag
538 $tag = $code[ 0 ];
539
540 //function
541 $function = $code[ 1 ];
542
543 // check if there's any function disabled by black_list
544 $this->function_check( $tag );
545
546 if( empty( $code[ 2 ] ) )
547 $parsed_function = $function . "()";
548 else
549 // parse the function
550 $parsed_function = $function . $this->var_replace( $code[ 2 ], $tag_left_delimiter = null, $tag_right_delimiter = null, $php_left_delimiter = null, $php_right_delimiter = null, $loop_level );
551
552 //if code
553 $compiled_code .= "<?php echo $parsed_function; ?>";
554 }
555
556 // show all vars
557 elseif ( strpos( $html, '{$template_info}' ) !== FALSE ) {
558
559 //tag
560 $tag = '{$template_info}';
561
562 //if code
563 $compiled_code .= '<?php echo "<pre>"; print_r( $this->var ); echo "</pre>"; ?>';
564 }
565
566
567 //all html code
568 else{
569
570 //variables substitution (es. {$title})
571 $html = $this->var_replace( $html, $left_delimiter = '\{', $right_delimiter = '\}', $php_left_delimiter = '<?php ', $php_right_delimiter = ';?>', $loop_level, $echo = true );
572 //const substitution (es. {#CONST#})
573 $html = $this->const_replace( $html, $left_delimiter = '\{', $right_delimiter = '\}', $php_left_delimiter = '<?php ', $php_right_delimiter = ';?>', $loop_level, $echo = true );
574 //functions substitution (es. {"string"|functions})
575 $compiled_code .= $this->func_replace( $html, $left_delimiter = '\{', $right_delimiter = '\}', $php_left_delimiter = '<?php ', $php_right_delimiter = ';?>', $loop_level, $echo = true );
576 }
577 }
578
579 if( $open_if > 0 ) {
580 $e = new RainTpl_SyntaxException('Error! You need to close an {if} tag in ' . $this->tpl['tpl_filename'] . ' template');
581 throw $e->setTemplateFile($this->tpl['tpl_filename']);
582 }
583 return $compiled_code;
584 }
585
586
587 /**
588 * Reduce a path, eg. www/library/../filepath//file => www/filepath/file
589 * @param type $path
590 * @return type
591 */
592 protected function reduce_path( $path ){
593 $path = str_replace( "://", "@not_replace@", $path );
594 $path = str_replace( "//", "/", $path );
595 $path = str_replace( "@not_replace@", "://", $path );
596 return preg_replace('/\w+\/\.\.\//', '', $path );
597 }
598
599
600
601 /**
602 * replace the path of image src, link href and a href.
603 * url => template_dir/url
604 * url# => url
605 * http://url => http://url
606 *
607 * @param string $html
608 * @return string html sostituito
609 */
610 protected function path_replace( $html, $tpl_basedir ){
611
612 if( self::$path_replace ){
613
614 $tpl_dir = self::$base_url . self::$tpl_dir . $tpl_basedir;
615
616 // reduce the path
617 $path = $this->reduce_path($tpl_dir);
618
619 $exp = $sub = array();
620
621 if( in_array( "img", self::$path_replace_list ) ){
622 $exp = array( '/<img(.*?)src=(?:")(http|https)\:\/\/([^"]+?)(?:")/i', '/<img(.*?)src=(?:")([^"]+?)#(?:")/i', '/<img(.*?)src="(.*?)"/', '/<img(.*?)src=(?:\@)([^"]+?)(?:\@)/i' );
623 $sub = array( '<img$1src=@$2://$3@', '<img$1src=@$2@', '<img$1src="' . $path . '$2"', '<img$1src="$2"' );
624 }
625
626 if( in_array( "script", self::$path_replace_list ) ){
627 $exp = array_merge( $exp , array( '/<script(.*?)src=(?:")(http|https)\:\/\/([^"]+?)(?:")/i', '/<script(.*?)src=(?:")([^"]+?)#(?:")/i', '/<script(.*?)src="(.*?)"/', '/<script(.*?)src=(?:\@)([^"]+?)(?:\@)/i' ) );
628 $sub = array_merge( $sub , array( '<script$1src=@$2://$3@', '<script$1src=@$2@', '<script$1src="' . $path . '$2"', '<script$1src="$2"' ) );
629 }
630
631 if( in_array( "link", self::$path_replace_list ) ){
632 $exp = array_merge( $exp , array( '/<link(.*?)href=(?:")(http|https)\:\/\/([^"]+?)(?:")/i', '/<link(.*?)href=(?:")([^"]+?)#(?:")/i', '/<link(.*?)href="(.*?)"/', '/<link(.*?)href=(?:\@)([^"]+?)(?:\@)/i' ) );
633 $sub = array_merge( $sub , array( '<link$1href=@$2://$3@', '<link$1href=@$2@' , '<link$1href="' . $path . '$2"', '<link$1href="$2"' ) );
634 }
635
636 if( in_array( "a", self::$path_replace_list ) ){
637 $exp = array_merge( $exp , array( '/<a(.*?)href=(?:")(http\:\/\/|https\:\/\/|javascript:)([^"]+?)(?:")/i', '/<a(.*?)href="(.*?)"/', '/<a(.*?)href=(?:\@)([^"]+?)(?:\@)/i' ) );
638 $sub = array_merge( $sub , array( '<a$1href=@$2$3@', '<a$1href="' . self::$base_url . '$2"', '<a$1href="$2"' ) );
639 }
640
641 if( in_array( "input", self::$path_replace_list ) ){
642 $exp = array_merge( $exp , array( '/<input(.*?)src=(?:")(http|https)\:\/\/([^"]+?)(?:")/i', '/<input(.*?)src=(?:")([^"]+?)#(?:")/i', '/<input(.*?)src="(.*?)"/', '/<input(.*?)src=(?:\@)([^"]+?)(?:\@)/i' ) );
643 $sub = array_merge( $sub , array( '<input$1src=@$2://$3@', '<input$1src=@$2@', '<input$1src="' . $path . '$2"', '<input$1src="$2"' ) );
644 }
645
646 return preg_replace( $exp, $sub, $html );
647
648 }
649 else
650 return $html;
651
652 }
653
654
655
656
657
658 // replace const
659 function const_replace( $html, $tag_left_delimiter, $tag_right_delimiter, $php_left_delimiter = null, $php_right_delimiter = null, $loop_level = null, $echo = null ){
660 // const
661 return preg_replace( '/\{\#(\w+)\#{0,1}\}/', $php_left_delimiter . ( $echo ? " echo " : null ) . '\\1' . $php_right_delimiter, $html );
662 }
663
664
665
666 // replace functions/modifiers on constants and strings
667 function func_replace( $html, $tag_left_delimiter, $tag_right_delimiter, $php_left_delimiter = null, $php_right_delimiter = null, $loop_level = null, $echo = null ){
668
669 preg_match_all( '/' . '\{\#{0,1}(\"{0,1}.*?\"{0,1})(\|\w.*?)\#{0,1}\}' . '/', $html, $matches );
670
671 for( $i=0, $n=count($matches[0]); $i<$n; $i++ ){
672
673 //complete tag ex: {$news.title|substr:0,100}
674 $tag = $matches[ 0 ][ $i ];
675
676 //variable name ex: news.title
677 $var = $matches[ 1 ][ $i ];
678
679 //function and parameters associate to the variable ex: substr:0,100
680 $extra_var = $matches[ 2 ][ $i ];
681
682 // check if there's any function disabled by black_list
683 $this->function_check( $tag );
684
685 $extra_var = $this->var_replace( $extra_var, null, null, null, null, $loop_level );
686
687
688 // check if there's an operator = in the variable tags, if there's this is an initialization so it will not output any value
689 $is_init_variable = preg_match( "/^(\s*?)\=[^=](.*?)$/", $extra_var );
690
691 //function associate to variable
692 $function_var = ( $extra_var and $extra_var[0] == '|') ? substr( $extra_var, 1 ) : null;
693
694 //variable path split array (ex. $news.title o $news[title]) or object (ex. $news->title)
695 $temp = preg_split( "/\.|\[|\-\>/", $var );
696
697 //variable name
698 $var_name = $temp[ 0 ];
699
700 //variable path
701 $variable_path = substr( $var, strlen( $var_name ) );
702
703 //parentesis transform [ e ] in [" e in "]
704 $variable_path = str_replace( '[', '["', $variable_path );
705 $variable_path = str_replace( ']', '"]', $variable_path );
706
707 //transform .$variable in ["$variable"]
708 $variable_path = preg_replace('/\.\$(\w+)/', '["$\\1"]', $variable_path );
709
710 //transform [variable] in ["variable"]
711 $variable_path = preg_replace('/\.(\w+)/', '["\\1"]', $variable_path );
712
713 //if there's a function
714 if( $function_var ){
715
716 // check if there's a function or a static method and separate, function by parameters
717 $function_var = str_replace("::", "@double_dot@", $function_var );
718
719 // get the position of the first :
720 if( $dot_position = strpos( $function_var, ":" ) ){
721
722 // get the function and the parameters
723 $function = substr( $function_var, 0, $dot_position );
724 $params = substr( $function_var, $dot_position+1 );
725
726 }
727 else{
728
729 //get the function
730 $function = str_replace( "@double_dot@", "::", $function_var );
731 $params = null;
732
733 }
734
735 // replace back the @double_dot@ with ::
736 $function = str_replace( "@double_dot@", "::", $function );
737 $params = str_replace( "@double_dot@", "::", $params );
738
739
740 }
741 else
742 $function = $params = null;
743
744 $php_var = $var_name . $variable_path;
745
746 // compile the variable for php
747 if( isset( $function ) ){
748 if( $php_var )
749 $php_var = $php_left_delimiter . ( !$is_init_variable && $echo ? 'echo ' : null ) . ( $params ? "( $function( $php_var, $params ) )" : "$function( $php_var )" ) . $php_right_delimiter;
750 else
751 $php_var = $php_left_delimiter . ( !$is_init_variable && $echo ? 'echo ' : null ) . ( $params ? "( $function( $params ) )" : "$function()" ) . $php_right_delimiter;
752 }
753 else
754 $php_var = $php_left_delimiter . ( !$is_init_variable && $echo ? 'echo ' : null ) . $php_var . $extra_var . $php_right_delimiter;
755
756 $html = str_replace( $tag, $php_var, $html );
757
758 }
759
760 return $html;
761
762 }
763
764
765
766 function var_replace( $html, $tag_left_delimiter, $tag_right_delimiter, $php_left_delimiter = null, $php_right_delimiter = null, $loop_level = null, $echo = null ){
767
768 //all variables
769 if( preg_match_all( '/' . $tag_left_delimiter . '\$(\w+(?:\.\${0,1}[A-Za-z0-9_]+)*(?:(?:\[\${0,1}[A-Za-z0-9_]+\])|(?:\-\>\${0,1}[A-Za-z0-9_]+))*)(.*?)' . $tag_right_delimiter . '/', $html, $matches ) ){
770
771 for( $parsed=array(), $i=0, $n=count($matches[0]); $i<$n; $i++ )
772 $parsed[$matches[0][$i]] = array('var'=>$matches[1][$i],'extra_var'=>$matches[2][$i]);
773
774 foreach( $parsed as $tag => $array ){
775
776 //variable name ex: news.title
777 $var = $array['var'];
778
779 //function and parameters associate to the variable ex: substr:0,100
780 $extra_var = $array['extra_var'];
781
782 // check if there's any function disabled by black_list
783 $this->function_check( $tag );
784
785 $extra_var = $this->var_replace( $extra_var, null, null, null, null, $loop_level );
786
787 // check if there's an operator = in the variable tags, if there's this is an initialization so it will not output any value
788 $is_init_variable = preg_match( "/^[a-z_A-Z\.\[\](\-\>)]*=[^=]*$/", $extra_var );
789
790 //function associate to variable
791 $function_var = ( $extra_var and $extra_var[0] == '|') ? substr( $extra_var, 1 ) : null;
792
793 //variable path split array (ex. $news.title o $news[title]) or object (ex. $news->title)
794 $temp = preg_split( "/\.|\[|\-\>/", $var );
795
796 //variable name
797 $var_name = $temp[ 0 ];
798
799 //variable path
800 $variable_path = substr( $var, strlen( $var_name ) );
801
802 //parentesis transform [ e ] in [" e in "]
803 $variable_path = str_replace( '[', '["', $variable_path );
804 $variable_path = str_replace( ']', '"]', $variable_path );
805
806 //transform .$variable in ["$variable"] and .variable in ["variable"]
807 $variable_path = preg_replace('/\.(\${0,1}\w+)/', '["\\1"]', $variable_path );
808
809 // if is an assignment also assign the variable to $this->var['value']
810 if( $is_init_variable )
811 $extra_var = "=\$this->var['{$var_name}']{$variable_path}" . $extra_var;
812
813
814
815 //if there's a function
816 if( $function_var ){
817
818 // check if there's a function or a static method and separate, function by parameters
819 $function_var = str_replace("::", "@double_dot@", $function_var );
820
821
822 // get the position of the first :
823 if( $dot_position = strpos( $function_var, ":" ) ){
824
825 // get the function and the parameters
826 $function = substr( $function_var, 0, $dot_position );
827 $params = substr( $function_var, $dot_position+1 );
828
829 }
830 else{
831
832 //get the function
833 $function = str_replace( "@double_dot@", "::", $function_var );
834 $params = null;
835
836 }
837
838 // replace back the @double_dot@ with ::
839 $function = str_replace( "@double_dot@", "::", $function );
840 $params = str_replace( "@double_dot@", "::", $params );
841 }
842 else
843 $function = $params = null;
844
845 //if it is inside a loop
846 if( $loop_level ){
847 //verify the variable name
848 if( $var_name == 'key' )
849 $php_var = '$key' . $loop_level;
850 elseif( $var_name == 'value' )
851 $php_var = '$value' . $loop_level . $variable_path;
852 elseif( $var_name == 'counter' )
853 $php_var = '$counter' . $loop_level;
854 else
855 $php_var = '$' . $var_name . $variable_path;
856 }else
857 $php_var = '$' . $var_name . $variable_path;
858
859 // compile the variable for php
860 if( isset( $function ) )
861 $php_var = $php_left_delimiter . ( !$is_init_variable && $echo ? 'echo ' : null ) . ( $params ? "( $function( $php_var, $params ) )" : "$function( $php_var )" ) . $php_right_delimiter;
862 else
863 $php_var = $php_left_delimiter . ( !$is_init_variable && $echo ? 'echo ' : null ) . $php_var . $extra_var . $php_right_delimiter;
864
865 $html = str_replace( $tag, $php_var, $html );
866
867
868 }
869 }
870
871 return $html;
872 }
873
874
875
876 /**
877 * Check if function is in black list (sandbox)
878 *
879 * @param string $code
880 * @param string $tag
881 */
882 protected function function_check( $code ){
883
884 $preg = '#(\W|\s)' . implode( '(\W|\s)|(\W|\s)', self::$black_list ) . '(\W|\s)#';
885
886 // check if the function is in the black list (or not in white list)
887 if( count(self::$black_list) && preg_match( $preg, $code, $match ) ){
888
889 // find the line of the error
890 $line = 0;
891 $rows=explode("\n",$this->tpl['source']);
892 while( !strpos($rows[$line],$code) )
893 $line++;
894
895 // stop the execution of the script
896 $e = new RainTpl_SyntaxException('Unallowed syntax in ' . $this->tpl['tpl_filename'] . ' template');
897 throw $e->setTemplateFile($this->tpl['tpl_filename'])
898 ->setTag($code)
899 ->setTemplateLine($line);
900 }
901
902 }
903
904 /**
905 * Prints debug info about exception or passes it further if debug is disabled.
906 *
907 * @param RainTpl_Exception $e
908 * @return string
909 */
910 protected function printDebug(RainTpl_Exception $e){
911 if (!self::$debug) {
912 throw $e;
913 }
914 $output = sprintf('<h2>Exception: %s</h2><h3>%s</h3><p>template: %s</p>',
915 get_class($e),
916 $e->getMessage(),
917 $e->getTemplateFile()
918 );
919 if ($e instanceof RainTpl_SyntaxException) {
920 if (null != $e->getTemplateLine()) {
921 $output .= '<p>line: ' . $e->getTemplateLine() . '</p>';
922 }
923 if (null != $e->getTag()) {
924 $output .= '<p>in tag: ' . htmlspecialchars($e->getTag()) . '</p>';
925 }
926 if (null != $e->getTemplateLine() && null != $e->getTag()) {
927 $rows=explode("\n", htmlspecialchars($this->tpl['source']));
928 $rows[$e->getTemplateLine()] = '<font color=red>' . $rows[$e->getTemplateLine()] . '</font>';
929 $output .= '<h3>template code</h3>' . implode('<br />', $rows) . '</pre>';
930 }
931 }
932 $output .= sprintf('<h3>trace</h3><p>In %s on line %d</p><pre>%s</pre>',
933 $e->getFile(), $e->getLine(),
934 nl2br(htmlspecialchars($e->getTraceAsString()))
935 );
936 return $output;
937 }
938}
939
940
941/**
942 * Basic Rain tpl exception.
943 */
944class RainTpl_Exception extends Exception{
945 /**
946 * Path of template file with error.
947 */
948 protected $templateFile = '';
949
950 /**
951 * Returns path of template file with error.
952 *
953 * @return string
954 */
955 public function getTemplateFile()
956 {
957 return $this->templateFile;
958 }
959
960 /**
961 * Sets path of template file with error.
962 *
963 * @param string $templateFile
964 * @return RainTpl_Exception
965 */
966 public function setTemplateFile($templateFile)
967 {
968 $this->templateFile = (string) $templateFile;
969 return $this;
970 }
971}
972
973/**
974 * Exception thrown when template file does not exists.
975 */
976class RainTpl_NotFoundException extends RainTpl_Exception{
977}
978
979/**
980 * Exception thrown when syntax error occurs.
981 */
982class RainTpl_SyntaxException extends RainTpl_Exception{
983 /**
984 * Line in template file where error has occured.
985 *
986 * @var int | null
987 */
988 protected $templateLine = null;
989
990 /**
991 * Tag which caused an error.
992 *
993 * @var string | null
994 */
995 protected $tag = null;
996
997 /**
998 * Returns line in template file where error has occured
999 * or null if line is not defined.
1000 *
1001 * @return int | null
1002 */
1003 public function getTemplateLine()
1004 {
1005 return $this->templateLine;
1006 }
1007
1008 /**
1009 * Sets line in template file where error has occured.
1010 *
1011 * @param int $templateLine
1012 * @return RainTpl_SyntaxException
1013 */
1014 public function setTemplateLine($templateLine)
1015 {
1016 $this->templateLine = (int) $templateLine;
1017 return $this;
1018 }
1019
1020 /**
1021 * Returns tag which caused an error.
1022 *
1023 * @return string
1024 */
1025 public function getTag()
1026 {
1027 return $this->tag;
1028 }
1029
1030 /**
1031 * Sets tag which caused an error.
1032 *
1033 * @param string $tag
1034 * @return RainTpl_SyntaxException
1035 */
1036 public function setTag($tag)
1037 {
1038 $this->tag = (string) $tag;
1039 return $this;
1040 }
1041}
1042
1043// -- end
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-01 02:19:26 +0000