1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
|
<?php // $Id: filterlib.php,v 1.20.2.1 2006/05/17 16:37:15 tjhunt Exp $
// Contains special functions that are particularly useful to filters
/**
* This is just a little object to define a phrase and some instructions
* for how to process it. Filters can create an array of these to pass
* to the filter_phrases function below.
**/
class filterobject {
var $phrase;
var $hreftagbegin;
var $hreftagend;
var $casesensitive;
var $fullmatch;
var $replacementphrase;
var $work_phrase;
var $work_hreftagbegin;
var $work_hreftagend;
var $work_casesensitive;
var $work_fullmatch;
var $work_replacementphrase;
var $work_calculated;
/// a constructor just because I like constructing
function filterobject($phrase, $hreftagbegin='<span class="highlight">',
$hreftagend='</span>',
$casesensitive=false,
$fullmatch=false,
$replacementphrase=NULL) {
$this->phrase = $phrase;
$this->hreftagbegin = $hreftagbegin;
$this->hreftagend = $hreftagend;
$this->casesensitive = $casesensitive;
$this->fullmatch = $fullmatch;
$this->replacementphrase= $replacementphrase;
$this->work_calculated = false;
}
}
/**
* Process phrases intelligently found within a HTML text (such as adding links)
*
* param text the text that we are filtering
* param link_array an array of filterobjects
* param ignoretagsopen an array of opening tags that we should ignore while filtering
* param ignoretagsclose an array of corresponding closing tags
**/
function filter_phrases ($text, &$link_array, $ignoretagsopen=NULL, $ignoretagsclose=NULL) {
global $CFG;
static $usedphrases;
$ignoretags = array(); //To store all the enclosig tags to be completely ignored
$tags = array(); //To store all the simple tags to be ignored
/// A list of open/close tags that we should not replace within
/// No reason why you can't put full preg expressions in here too
/// eg '<script(.+?)>' to match any type of script tag
$filterignoretagsopen = array('<head>' , '<nolink>' , '<span class="nolink">');
$filterignoretagsclose = array('</head>', '</nolink>', '</span>');
/// Invalid prefixes and suffixes for the fullmatch searches
/// Every "word" character, but the underscore, is a invalid suffix or prefix.
/// (nice to use this because it includes national characters (accents...) as word characters.
$filterinvalidprefixes = '([^\W_])';
$filterinvalidsuffixes = '([^\W_])';
/// Add the user defined ignore tags to the default list
/// Unless specified otherwise, we will not replace within <a></a> tags
if ( $ignoretagsopen === NULL ) {
//$ignoretagsopen = array('<a(.+?)>');
$ignoretagsopen = array('<a[^>]+?>');
$ignoretagsclose = array('</a>');
}
if ( is_array($ignoretagsopen) ) {
foreach ($ignoretagsopen as $open) $filterignoretagsopen[] = $open;
foreach ($ignoretagsclose as $close) $filterignoretagsclose[] = $close;
}
//// Double up some magic chars to avoid "accidental matches"
$text = preg_replace('/([#*%])/','\1\1',$text);
////Remove everything enclosed by the ignore tags from $text
filter_save_ignore_tags($text,$filterignoretagsopen,$filterignoretagsclose,$ignoretags);
/// Remove tags from $text
filter_save_tags($text,$tags);
/// Time to cycle through each phrase to be linked
$size = sizeof($link_array);
for ($n=0; $n < $size; $n++) {
$linkobject =& $link_array[$n];
/// Set some defaults if certain properties are missing
/// Properties may be missing if the filterobject class has not been used to construct the object
if (empty($linkobject->phrase)) {
continue;
}
/// Avoid integers < 1000 to be linked. See bug 1446.
$intcurrent = intval($linkobject->phrase);
if (!empty($intcurrent) && strval($intcurrent) == $linkobject->phrase && $intcurrent < 1000) {
continue;
}
/// All this work has to be done ONLY it it hasn't been done before
if (!$linkobject->work_calculated) {
if (!isset($linkobject->hreftagbegin) or !isset($linkobject->hreftagend)) {
$linkobject->work_hreftagbegin = '<span class="highlight"';
$linkobject->work_hreftagend = '</span>';
} else {
$linkobject->work_hreftagbegin = $linkobject->hreftagbegin;
$linkobject->work_hreftagend = $linkobject->hreftagend;
}
/// Double up chars to protect true duplicates
/// be cleared up before returning to the user.
$linkobject->work_hreftagbegin = preg_replace('/([#*%])/','\1\1',$linkobject->work_hreftagbegin);
if (empty($linkobject->casesensitive)) {
$linkobject->work_casesensitive = false;
} else {
$linkobject->work_casesensitive = true;
}
if (empty($linkobject->fullmatch)) {
$linkobject->work_fullmatch = false;
} else {
$linkobject->work_fullmatch = true;
}
/// Strip tags out of the phrase
$linkobject->work_phrase = strip_tags($linkobject->phrase);
/// Double up chars that might cause a false match -- the duplicates will
/// be cleared up before returning to the user.
$linkobject->work_phrase = preg_replace('/([#*%])/','\1\1',$linkobject->work_phrase);
/// Set the replacement phrase properly
if ($linkobject->replacementphrase) { //We have specified a replacement phrase
/// Strip tags
$linkobject->work_replacementphrase = strip_tags($linkobject->replacementphrase);
} else { //The replacement is the original phrase as matched below
$linkobject->work_replacementphrase = '$1';
}
/// Quote any regular expression characters and the delimiter in the work phrase to be searched
$linkobject->work_phrase = preg_quote($linkobject->work_phrase, '/');
/// Work calculated
$linkobject->work_calculated = true;
}
/// If $CFG->filtermatchoneperpage, avoid previously (request) linked phrases
if (!empty($CFG->filtermatchoneperpage)) {
if (!empty($usedphrases) && in_array($linkobject->work_phrase,$usedphrases)) {
continue;
}
}
/// Regular expression modifiers
$modifiers = ($linkobject->work_casesensitive) ? 's' : 'is';
/// Do we need to do a fullmatch?
/// If yes then go through and remove any non full matching entries
if ($linkobject->work_fullmatch) {
$notfullmatches = array();
$regexp = '/'.$filterinvalidprefixes.'('.$linkobject->work_phrase.')|('.$linkobject->work_phrase.')'.$filterinvalidsuffixes.'/'.$modifiers;
preg_match_all($regexp,$text,$list_of_notfullmatches);
if ($list_of_notfullmatches) {
foreach (array_unique($list_of_notfullmatches[0]) as $key=>$value) {
$notfullmatches['<*'.$key.'*>'] = $value;
}
if (!empty($notfullmatches)) {
$text = str_replace($notfullmatches,array_keys($notfullmatches),$text);
}
}
}
/// Finally we do our highlighting
if (!empty($CFG->filtermatchonepertext) || !empty($CFG->filtermatchoneperpage)) {
$resulttext = preg_replace('/('.$linkobject->work_phrase.')/'.$modifiers,
$linkobject->work_hreftagbegin.
$linkobject->work_replacementphrase.
$linkobject->work_hreftagend, $text, 1);
} else {
$resulttext = preg_replace('/('.$linkobject->work_phrase.')/'.$modifiers,
$linkobject->work_hreftagbegin.
$linkobject->work_replacementphrase.
$linkobject->work_hreftagend, $text);
}
/// If the text has changed we have to look for links again
if ($resulttext != $text) {
/// Set $text to $resulttext
$text = $resulttext;
/// Remove everything enclosed by the ignore tags from $text
filter_save_ignore_tags($text,$filterignoretagsopen,$filterignoretagsclose,$ignoretags);
/// Remove tags from $text
filter_save_tags($text,$tags);
/// If $CFG->filtermatchoneperpage, save linked phrases to request
if (!empty($CFG->filtermatchoneperpage)) {
$usedphrases[] = $linkobject->work_phrase;
}
}
/// Replace the not full matches before cycling to next link object
if (!empty($notfullmatches)) {
$text = str_replace(array_keys($notfullmatches),$notfullmatches,$text);
unset($notfullmatches);
}
}
/// Rebuild the text with all the excluded areas
if (!empty($tags)) {
$text = str_replace(array_keys($tags), $tags, $text);
}
if (!empty($ignoretags)) {
$text = str_replace(array_keys($ignoretags),$ignoretags,$text);
}
//// Remove the protective doubleups
$text = preg_replace('/([#*%])(\1)/','\1',$text);
/// Add missing javascript for popus
$text = filter_add_javascript($text);
return $text;
}
function filter_remove_duplicates($linkarray) {
$concepts = array(); // keep a record of concepts as we cycle through
$lconcepts = array(); // a lower case version for case insensitive
$cleanlinks = array();
foreach ($linkarray as $key=>$filterobject) {
if ($filterobject->casesensitive) {
$exists = in_array($filterobject->phrase, $concepts);
} else {
$exists = in_array(strtolower($filterobject->phrase), $lconcepts);
}
if (!$exists) {
$cleanlinks[] = $filterobject;
$concepts[] = $filterobject->phrase;
$lconcepts[] = strtolower($filterobject->phrase);
}
}
return $cleanlinks;
}
/**
* Extract open/lose tags and their contents to avoid being processed by filters.
* Useful to extract pieces of code like <a>...</a> tags. It returns the text
* converted with some <#x.x#> codes replacing the extracted text. Such extracted
* texts are returned in the ignoretags array (as values), with codes as keys.
*
* param text the text that we are filtering (in/out)
* param filterignoretagsopen an array of open tags to start searching
* param filterignoretagsclose an array of close tags to end searching
* param ignoretags an array of saved strings useful to rebuild the original text (in/out)
**/
function filter_save_ignore_tags(&$text,$filterignoretagsopen,$filterignoretagsclose,&$ignoretags) {
/// Remove everything enclosed by the ignore tags from $text
foreach ($filterignoretagsopen as $ikey=>$opentag) {
$closetag = $filterignoretagsclose[$ikey];
/// form regular expression
$opentag = str_replace('/','\/',$opentag); // delimit forward slashes
$closetag = str_replace('/','\/',$closetag); // delimit forward slashes
$pregexp = '/'.$opentag.'(.+?)'.$closetag.'/is';
preg_match_all($pregexp, $text, $list_of_ignores);
foreach (array_unique($list_of_ignores[0]) as $key=>$value) {
$prefix = (string)(count($ignoretags) + 1);
$ignoretags['<#'.$prefix.'.'.$key.'#>'] = $value;
}
if (!empty($ignoretags)) {
$text = str_replace($ignoretags,array_keys($ignoretags),$text);
}
}
}
/**
* Extract tags (any text enclosed by < and > to avoid being processed by filters.
* It returns the text converted with some <%x.x%> codes replacing the extracted text. Such extracted
* texts are returned in the tags array (as values), with codes as keys.
*
* param text the text that we are filtering (in/out)
* param tags an array of saved strings useful to rebuild the original text (in/out)
**/
function filter_save_tags(&$text,&$tags) {
preg_match_all('/<([^#%*].*?)>/is',$text,$list_of_newtags);
foreach (array_unique($list_of_newtags[0]) as $ntkey=>$value) {
$prefix = (string)(count($tags) + 1);
$tags['<%'.$prefix.'.'.$ntkey.'%>'] = $value;
}
if (!empty($tags)) {
$text = str_replace($tags,array_keys($tags),$text);
}
}
/**
* Add missing openpopup javascript to HTML files.
*/
function filter_add_javascript($text) {
global $CFG;
if (stripos($text, '</html>') === FALSE) {
return $text; // this is not a html file
}
if (strpos($text, 'onclick="return openpopup') === FALSE) {
return $text; // no popup - no need to add javascript
}
$js ="
<script type=\"text/javascript\">
<!--
function openpopup(url,name,options,fullscreen) {
fullurl = \"".$CFG->httpswwwroot."\" + url;
windowobj = window.open(fullurl,name,options);
if (fullscreen) {
windowobj.moveTo(0,0);
windowobj.resizeTo(screen.availWidth,screen.availHeight);
}
windowobj.focus();
return false;
}
// -->
</script>";
if (stripos($text, '</head>') !== FALSE) {
//try to add it into the head element
$text = str_ireplace('</head>', $js.'</head>', $text);
return $text;
}
//last chance - try adding head element
return preg_replace("/<html.*?>/is", "\\0<head>".$js.'</head>', $text);
}
?>
|
