1: <?php
  2: /*
  3:  You may not change or alter any portion of this comment or credits
  4:  of supporting developers from this source code or any supporting source code
  5:  which is considered copyrighted (c) material of the original comment or credit authors.
  6: 
  7:  This program is distributed in the hope that it will be useful,
  8:  but WITHOUT ANY WARRANTY; without even the implied warranty of
  9:  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 10:  */
 11: 
 12: namespace Xmf;
 13: 
 14: /**
 15:  * Metagen facilitates generating and assigning page meta tags
 16:  *
 17:  * @category  Xmf\Module\Metagen
 18:  * @package   Xmf
 19:  * @author    Richard Griffith <richard@geekwright.com>
 20:  * @author    trabis <lusopoemas@gmail.com>
 21:  * @copyright 2011-2014 XOOPS Project (http://xoops.org)
 22:  * @license   GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 23:  * @version   Release: 1.0
 24:  * @link      http://xoops.org
 25:  * @since     1.0
 26:  */
 27: class Metagen
 28: {
 29: 
 30:     /**
 31:      * Unicode horizontal ellipsis U+2026
 32:      * This will be used to replace omitted text.
 33:      */
 34:     const ELLIPSIS = "…"; // unicode horizontal ellipsis U+2026
 35: 
 36:     /**
 37:      * assignTitle set the page title
 38:      *
 39:      * @param string $title page title
 40:      *
 41:      * @return void
 42:      */
 43:     public static function assignTitle($title)
 44:     {
 45:         global $xoopsTpl, $xoTheme;
 46: 
 47:         $title = trim($title);
 48:         $title = self::asPlainText($title);
 49:         if (!empty($title)) {
 50:             if (is_object($xoTheme)) {
 51:                 $xoTheme->addMeta('meta', 'title', $title);
 52:             }
 53:             $xoopsTpl->assign('xoops_pagetitle', $title);
 54:         }
 55:     }
 56: 
 57:     /**
 58:      * assignKeywords set the meta keywords tag
 59:      *
 60:      * @param array $keywords keywords for page
 61:      *
 62:      * @return void
 63:      */
 64:     public static function assignKeywords($keywords)
 65:     {
 66:         global $xoopsTpl, $xoTheme;
 67: 
 68:         if (!empty($keywords) && is_array($keywords)) {
 69:             $keyword_tag = implode(', ', $keywords);
 70: 
 71:             if (!empty($keyword_tag)) {
 72:                 if (is_object($xoTheme)) {
 73:                     $xoTheme->addMeta('meta', 'keywords', $keyword_tag);
 74:                 } else {
 75:                     $xoopsTpl->assign('xoops_meta_keywords', $keyword_tag);
 76:                 }
 77:             }
 78:         }
 79:     }
 80: 
 81:     /**
 82:      * assignDescription set the meta description tag
 83:      *
 84:      * @param string $description page description
 85:      *
 86:      * @return void
 87:      */
 88:     public static function assignDescription($description)
 89:     {
 90:         global $xoopsTpl, $xoTheme;
 91: 
 92:         $description = trim($description);
 93:         if (!empty($description)) {
 94:             if (is_object($xoTheme)) {
 95:                 $xoTheme->addMeta('meta', 'description', $description);
 96:             } else {
 97:                 $xoopsTpl->assign('xoops_meta_description', $description);
 98:             }
 99:         }
100:     }
101: 
102:     /**
103:      * generateKeywords builds a set of keywords from text body
104:      *
105:      * @param string        $body      text to extract keywords from
106:      * @param integer       $count     number of keywords to use
107:      * @param integer       $minLength minimum length of word to consider as a keyword
108:      * @param string[]|null $forceKeys array of keywords to force use, or null for none
109:      *
110:      * @return array of keywords
111:      */
112:     public static function generateKeywords(
113:         $body,
114:         $count = 20,
115:         $minLength = 4,
116:         $forceKeys = null
117:     ) {
118:         $keyCount = array();
119:         if (!is_array($forceKeys)) {
120:             $forceKeys = array();
121:         }
122: 
123:         $text = self::asPlainText($body);
124:         $text = mb_strtolower($text);
125: 
126:         $originalKeywords = preg_split(
127:             '/[^a-zA-Z\'"-]+/',
128:             $text,
129:             -1,
130:             PREG_SPLIT_NO_EMPTY
131:         );
132: 
133:         foreach ($originalKeywords as $originalKeyword) {
134:             if (self::checkStopWords($originalKeyword)) {
135:                 $secondRoundKeywords = explode("'", $originalKeyword);
136:                 foreach ($secondRoundKeywords as $secondRoundKeyword) {
137:                     if (self::checkStopWords($secondRoundKeyword)
138:                         && strlen($secondRoundKeyword) >= $minLength
139:                     ) {
140:                         $keyCount[$secondRoundKeyword] =
141:                             empty($keyCount[$secondRoundKeyword]) ? 1 : $keyCount[$secondRoundKeyword] + 1;
142:                     }
143:                 }
144:             }
145:         }
146: 
147:         while (!empty($forceKeys)) {
148:             $tempKey = strtolower(array_pop($forceKeys));
149:             $keyCount[$tempKey] = 999999;
150:         }
151: 
152:         arsort($keyCount, SORT_NUMERIC);
153:         $key = array_keys($keyCount);
154:         $keywords = array_slice($key, 0, $count);
155: 
156:         return $keywords;
157:     }
158: 
159:     /**
160:      * checkStopWords - look up a word in a list of stop words and
161:      * classify it as a significant word or a stop word.
162:      *
163:      * @param string $key the word to check
164:      *
165:      * @return bool True if word is significant, false if it is a stop word
166:      */
167:     protected static function checkStopWords($key)
168:     {
169:         static $stopwords = null;
170: 
171:         if (!$stopwords) {
172:             if (!defined('_XMF_STOPWORDS')) {
173:                 \Xmf\Language::load('stopwords', 'xmf');
174:             }
175:             if (defined('_XMF_STOPWORDS')) {
176:                 $sw = explode(' ', _XMF_STOPWORDS);
177:                 $stopwords = array_fill_keys($sw, true);
178:             } else {
179:                 $stopwords = array('_'=> true);
180:             }
181:         }
182:         if ($stopwords) {
183:             return !isset($stopwords[mb_strtolower($key)]);
184:         }
185:         return true;
186:     }
187: 
188:     /**
189:      * generateDescription - generate a short description from a body of text
190:      *
191:      * @param string  $body      body text
192:      * @param integer $wordCount maximum word count for description
193:      *
194:      * @return string
195:      */
196:     public static function generateDescription($body, $wordCount = 100)
197:     {
198:         $text = self::asPlainText($body);
199: 
200:         $words = explode(" ", $text);
201: 
202:         // Only keep $maxWords words
203:         $newWords = array();
204:         $i = 0;
205:         while ($i < $wordCount - 1 && $i < count($words)) {
206:             $newWords[] = $words[$i];
207:             ++$i;
208:         }
209:         $ret = implode(' ', $newWords);
210:         $len = mb_strlen($ret);
211:         $lastPeriod = mb_strrpos($ret, '.');
212:         $ret .= ($lastPeriod === false) ? self::ELLIPSIS : '';
213:         if ($len>100 && ($len-$lastPeriod)<30) {
214:             $ret = mb_substr($ret, 0, $lastPeriod+1);
215:         }
216: 
217:         return $ret;
218:     }
219: 
220:     /**
221:      * generateMetaTags - generate and assign all meta tags
222:      *
223:      * @param string        $title     title
224:      * @param string        $body      body text
225:      * @param int           $count     maximum keywords to use
226:      * @param int           $minLength minimum length of word to consider as keyword
227:      * @param int           $wordCount maximum word count for description summary
228:      * @param string[]|null $forceKeys associative array of keywords to force use
229:      *
230:      * @return void
231:      */
232:     public static function generateMetaTags(
233:         $title,
234:         $body,
235:         $count = 20,
236:         $minLength = 4,
237:         $wordCount = 100,
238:         $forceKeys = null
239:     ) {
240:         $title_keywords = self::generateKeywords($title, $count, 3, $forceKeys);
241:         $keywords = self::generateKeywords($body, $count, $minLength, $title_keywords);
242:         $description = self::generateDescription($body, $wordCount);
243:         self::assignTitle($title);
244:         self::assignKeywords($keywords);
245:         self::assignDescription($description);
246:     }
247: 
248:     /**
249:      * Return true if the string is length > 0
250:      *
251:      * @param string $var to test
252:      *
253:      * @return boolean
254:      *
255:      * @author psylove
256:      */
257:     protected static function nonEmptyString($var)
258:     {
259:         return (strlen($var) > 0);
260:     }
261: 
262:     /**
263:      * Create a title for the short_url field of an article
264:      *
265:      * @param string $title     title of the article
266:      * @param string $extension extension to add
267:      *
268:      * @return string sort_url for the article
269:      *
270:      * @author psylove
271:      */
272:     public static function generateSeoTitle($title = '', $extension = '')
273:     {
274:         $title = preg_replace("/[^a-zA-Z0-9]/", "-", $title);
275:         $title = \Normalizer::normalize($title, \Normalizer::FORM_C);
276: 
277:         $tableau = explode("-", $title);
278:         $tableau = array_filter($tableau, 'self::nonEmptyString');
279:         $tableau = array_filter($tableau, 'self::checkStopWords');
280:         $title = implode("-", $tableau);
281: 
282:         $title = (empty($title)) ? '' : $title . $extension;
283:         return $title;
284:     }
285: 
286:     /**
287:      * getSearchSummary splits a string into string no larger than a
288:      * specified length, and centered around the first occurrence
289:      * of any of an array of needles, or starting at the beginning
290:      * of the string if no needles are specified or found.
291:      *
292:      * The string will be broken on spaces and an ellipsis (…) will be
293:      * added to the string when broken.
294:      *
295:      * @param string $haystack the string to summarize
296:      * @param mixed  $needles  search term, array of search terms, or null
297:      * @param int    $length   maximum length for the summary
298:      *
299:      * @return string a substring of haystack
300:      */
301:     public static function getSearchSummary($haystack, $needles = null, $length = 120)
302:     {
303:         $encoding = 'UTF-8';
304: 
305:         $haystack = self::asPlainText($haystack);
306:         $pos = self::getNeedlePositions($haystack, $needles);
307: 
308:         $start = empty($pos) ? 0 : min($pos);
309: 
310:         $start = max($start - (int)($length/2), 0);
311: 
312:         $pre = ($start > 0); // need an ellipsis in front?
313:         if ($pre) {
314:             // we are not at the beginning so find first blank
315:             $temp = mb_strpos($haystack, ' ', $start, $encoding);
316:             $start = ($temp === false) ? $start : $temp;
317:             $haystack = mb_substr($haystack, $start, null, $encoding);
318:         }
319: 
320:         $post = !(mb_strlen($haystack, $encoding) < $length);  // need an ellipsis in back?
321:         if ($post) {
322:             $haystack = mb_substr($haystack, 0, $length, $encoding);
323:             $end = mb_strrpos($haystack, ' ', 0, $encoding);
324:             if ($end) {
325:                 $haystack = mb_substr($haystack, 0, $end, $encoding);
326:             }
327:         }
328: 
329:         $haystack = ($pre ? self::ELLIPSIS : '') . trim($haystack) . ($post ? self::ELLIPSIS : '');
330:         return $haystack;
331:     }
332: 
333:     /**
334:      * asPlainText - clean string to be plain text, without control characters
335:      * such as newlines, html markup, or leading trailing or repeating spaces.
336:      *
337:      * @param string $rawText a text string to be cleaned
338:      *
339:      * @return string
340:      */
341:     protected static function asPlainText($rawText)
342:     {
343:         $text = $rawText;
344:         $utilities = new Utilities();
345:         $text = $utilities->html2text($text);
346:         $text = $utilities->purifyText($text);
347: 
348:         $text = str_replace(array("\n", "\r"), ' ', $text);
349:         $text = preg_replace('/[ ]* [ ]*/', ' ', $text);
350: 
351:         return trim($text);
352:     }
353: 
354:     /**
355:      * getNeedlePositions - Essentially this is a strpos() for an array of needles.
356:      * Given a haystack and an array of needles, return an array of all initial
357:      * positions, if any, of those needles in that haystack.
358:      *
359:      * @param string $haystack the string to summarize
360:      * @param mixed  $needles  search term, array of search terms, or null
361:      *
362:      * @return integer[] array of initial positions of substring of haystack
363:      */
364:     private static function getNeedlePositions($haystack, $needles)
365:     {
366:         $pos=array();
367:         $needles = empty($needles) ? array() : (array) $needles;
368:         foreach ($needles as $needle) {
369:             $i = mb_stripos($haystack, $needle, 0, 'UTF-8');
370:             if ($i!==false) {
371:                 $pos[] = $i; // only store matches
372:             }
373:         }
374:         return $pos;
375:     }
376: }
377: