The requested page could not be found.
70 |You have probably clicked on a link that is outdated and points to a page that does not exist any more or you have made an typing error in the address.
71 |To continue please try to find requested page in the menu, or use search field on the top.
72 |Segments sentences. 72 | Clipping may not be perfect. 73 | Sentence count should be VERY close to the truth.
74 | 75 |Multibyte safe (atleast for UTF-8), but rules based on germanic 76 | language stucture (English, Dutch, German). Should work for most 77 | latin-alphabet languages.
78 |
105 | public
106 |
107 | array
108 |
109 |
110 | |
111 |
112 | 144 | |
148 | public
149 |
150 | integer
151 |
152 |
153 | |
154 |
155 | 183 | |
integer |
198 |
199 |
200 | SPLIT_TRIM
201 |
202 |
203 |
204 |
206 |
207 |
211 | Specify this flag with the split method to trim whitespace. 205 | |
212 |
213 |
214 | #
215 |
217 | 0x1
216 | |
218 |
Generated by PHPUnit_SkeletonGenerator on 2015-02-16 at 20:05:00.
72 |
82 | SentenceTest
83 |
84 |
85 |
112 | protected
113 |
114 |
115 |
116 |
117 | |
118 |
119 | 140 | |
144 | public
145 |
146 |
147 |
148 |
149 | |
150 |
151 | 174 | |
178 | public
179 |
180 |
181 |
182 |
183 | |
184 |
185 | 208 | |
212 | public
213 |
214 |
215 |
216 |
217 | |
218 |
219 | 242 | |
246 | public
247 |
248 |
249 |
250 |
251 | |
252 |
253 | 276 | |
280 | public
281 |
282 |
283 |
284 |
285 | |
286 |
287 | 310 | |
314 | public
315 |
316 |
317 |
318 |
319 | |
320 |
321 | 344 | |
348 | public
349 |
350 |
351 |
352 |
353 | |
354 |
355 | 378 | |
382 | public
383 |
384 |
385 |
386 |
387 | |
388 |
389 | 412 | |
416 | public
417 |
418 |
419 |
420 |
421 | |
422 |
423 | 446 | |
450 | public
451 |
452 |
453 |
454 |
455 | |
456 |
457 | 480 | |
484 | public
485 |
486 |
487 |
488 |
489 | |
490 |
491 | 514 | |
518 | public
519 |
520 |
521 |
522 |
523 | |
524 |
525 | 548 | |
552 | public
553 |
554 |
555 |
556 |
557 | |
558 |
559 | 582 | |
586 | public
587 |
588 |
589 |
590 |
591 | |
592 |
593 | 616 | |
634 | protected
635 | |
637 |
638 |
639 | $object
640 |
641 |
642 |
643 |
644 |
645 |
649 | |
650 |
651 |
652 | #
653 |
655 | |
656 |
Classloader for the library
72 |string |
94 | $class |
95 | 96 | |
| Sentence | 75 |Segments sentences. 76 | Clipping may not be perfect. 77 | Sentence count should be VERY close to the truth. |
78 |
| SentenceTest | 81 |Generated by PHPUnit_SkeletonGenerator on 2015-02-16 at 20:05:00. | 82 |
| Sentence_autoloader | 93 |Classloader for the library | 94 |
1: <?php
68 | 2:
69 | 3: /**
70 | 4: * Segments sentences.
71 | 5: * Clipping may not be perfect.
72 | 6: * Sentence count should be VERY close to the truth.
73 | 7: *
74 | 8: * Multibyte safe (atleast for UTF-8), but rules based on germanic
75 | 9: * language stucture (English, Dutch, German). Should work for most
76 | 10: * latin-alphabet languages.
77 | 11: */
78 | 12: class Sentence {
79 | 13: /**
80 | 14: * Specify this flag with the split method to trim whitespace.
81 | 15: */
82 | 16: const SPLIT_TRIM = 0x1;
83 | 17:
84 | 18: /**
85 | 19: * List of characters used to terminate sentences.
86 | 20: * @var array
87 | 21: */
88 | 22: private $terminals = array('.', '!', '?');
89 | 23:
90 | 24: /**
91 | 25: * List of characters used for abbreviations.
92 | 26: * @var array
93 | 27: */
94 | 28: private $abbreviators = array('.');
95 | 29:
96 | 30: /**
97 | 31: * Multibyte safe version of standard trim() function.
98 | 32: * @param string $string
99 | 33: * @return string
100 | 34: */
101 | 35: private static function mbTrim($string) {
102 | 36: return mb_ereg_replace('^\s*([\s\S]*?)\s*$', '\1', $string);
103 | 37: }
104 | 38:
105 | 39: /**
106 | 40: * A cross between mb_split and preg_split, adding the preg_split flags
107 | 41: * to mb_split.
108 | 42: * @param string $pattern
109 | 43: * @param string $string
110 | 44: * @param int $limit
111 | 45: * @param int $flags
112 | 46: * @return array
113 | 47: */
114 | 48: private static function mbSplit($pattern, $string, $limit = -1, $flags = 0) {
115 | 49: $strlen = strlen($string); // bytes!
116 | 50: mb_ereg_search_init($string);
117 | 51:
118 | 52: $lengths = array();
119 | 53: $position = 0;
120 | 54: while (($array = mb_ereg_search_pos($pattern, '')) !== false) {
121 | 55: // capture split
122 | 56: $lengths[] = array($array[0] - $position, false, null);
123 | 57:
124 | 58: // move position
125 | 59: $position = $array[0] + $array[1];
126 | 60:
127 | 61: // capture delimiter
128 | 62: $regs = mb_ereg_search_getregs();
129 | 63: $lengths[] = array($array[1], true, isset($regs[1]) && $regs[1]);
130 | 64:
131 | 65: // Continue on?
132 | 66: if ($position >= $strlen) {
133 | 67: break;
134 | 68: }
135 | 69: }
136 | 70:
137 | 71: // Add last bit, if not ending with split
138 | 72: $lengths[] = array($strlen - $position, false, null);
139 | 73:
140 | 74: // Substrings
141 | 75: $parts = array();
142 | 76: $position = 0;
143 | 77: $count = 1;
144 | 78: foreach ($lengths as $length) {
145 | 79: $is_delimiter = $length[1];
146 | 80: $is_captured = $length[2];
147 | 81:
148 | 82: if ($limit > 0 && !$is_delimiter && ($length[0] || ~$flags & PREG_SPLIT_NO_EMPTY) && ++$count > $limit) {
149 | 83: if ($length[0] > 0 || ~$flags & PREG_SPLIT_NO_EMPTY) {
150 | 84: $parts[] = $flags & PREG_SPLIT_OFFSET_CAPTURE
151 | 85: ? array(mb_strcut($string, $position), $position)
152 | 86: : mb_strcut($string, $position);
153 | 87: }
154 | 88: break;
155 | 89: } elseif ((!$is_delimiter || ($flags & PREG_SPLIT_DELIM_CAPTURE && $is_captured))
156 | 90: && ($length[0] || ~$flags & PREG_SPLIT_NO_EMPTY)) {
157 | 91: $parts[] = $flags & PREG_SPLIT_OFFSET_CAPTURE
158 | 92: ? array(mb_strcut($string, $position, $length[0]), $position)
159 | 93: : mb_strcut($string, $position, $length[0]);
160 | 94: }
161 | 95:
162 | 96: $position += $length[0];
163 | 97: }
164 | 98:
165 | 99: return $parts;
166 | 100: }
167 | 101:
168 | 102: /**
169 | 103: * Breaks a piece of text into lines by linebreak.
170 | 104: * Eats up any linebreak characters as if one.
171 | 105: *
172 | 106: * Multibyte safe
173 | 107: *
174 | 108: * @param string $text
175 | 109: * @return array
176 | 110: */
177 | 111: private static function linebreakSplit($text) {
178 | 112: $lines = array();
179 | 113: $line = '';
180 | 114:
181 | 115: foreach (self::mbSplit('([\r\n]+)', $text, -1, PREG_SPLIT_DELIM_CAPTURE) as $part) {
182 | 116: $line .= $part;
183 | 117: if (self::mbTrim($part) === '') {
184 | 118: $lines[] = $line;
185 | 119: $line = '';
186 | 120: }
187 | 121: }
188 | 122: $lines[] = $line;
189 | 123:
190 | 124: return $lines;
191 | 125: }
192 | 126:
193 | 127: /**
194 | 128: * Splits an array of lines by (consecutive sequences of)
195 | 129: * terminals, keeping terminals.
196 | 130: *
197 | 131: * Multibyte safe (atleast for UTF-8)
198 | 132: *
199 | 133: * For example:
200 | 134: * "There ... is. More!"
201 | 135: * ... becomes ...
202 | 136: * [ "There ", "...", " is", ".", " More", "!" ]
203 | 137: *
204 | 138: * @param array $lines
205 | 139: * @return array
206 | 140: */
207 | 141: private function punctuationSplit($line) {
208 | 142: $parts = array();
209 | 143:
210 | 144: $chars = preg_split('//u', $line, -1, PREG_SPLIT_NO_EMPTY); // This is UTF8 multibyte safe!
211 | 145: $is_terminal = in_array($chars[0], $this->terminals);
212 | 146:
213 | 147: $part = '';
214 | 148: foreach ($chars as $index => $char) {
215 | 149: if (in_array($char, $this->terminals) !== $is_terminal) {
216 | 150: $parts[] = $part;
217 | 151: $part = '';
218 | 152: $is_terminal = !$is_terminal;
219 | 153: }
220 | 154: $part .= $char;
221 | 155: }
222 | 156:
223 | 157: if (!empty($part)) {
224 | 158: $parts[] = $part;
225 | 159: }
226 | 160:
227 | 161: return $parts;
228 | 162: }
229 | 163:
230 | 164: /**
231 | 165: * Appends each terminal item after it's preceding
232 | 166: * non-terminals.
233 | 167: *
234 | 168: * Multibyte safe (atleast for UTF-8)
235 | 169: *
236 | 170: * For example:
237 | 171: * [ "There ", "...", " is", ".", " More", "!" ]
238 | 172: * ... becomes ...
239 | 173: * [ "There ... is.", "More!" ]
240 | 174: *
241 | 175: * @param array $punctuations
242 | 176: * @return array
243 | 177: */
244 | 178: private function punctuationMerge($punctuations) {
245 | 179: $definite_terminals = array_diff($this->terminals, $this->abbreviators);
246 | 180:
247 | 181: $merges = array();
248 | 182: $merge = '';
249 | 183:
250 | 184: foreach ($punctuations as $punctuation) {
251 | 185: if ($punctuation !== '') {
252 | 186: $merge.= $punctuation;
253 | 187: if (mb_strlen($punctuation) === 1 && in_array($punctuation, $this->terminals)) {
254 | 188: $merges[] = $merge;
255 | 189: $merge = '';
256 | 190: } else {
257 | 191: foreach ($definite_terminals as $terminal) {
258 | 192: if (mb_strpos($punctuation, $terminal) !== false) {
259 | 193: $merges[] = $merge;
260 | 194: $merge = '';
261 | 195: break;
262 | 196: }
263 | 197: }
264 | 198: }
265 | 199: }
266 | 200: }
267 | 201: if (!empty($merge)) {
268 | 202: $merges[] = $merge;
269 | 203: }
270 | 204:
271 | 205: return $merges;
272 | 206: }
273 | 207:
274 | 208: /**
275 | 209: * Merges any one-word items with it's preceding items.
276 | 210: *
277 | 211: * Multibyte safe
278 | 212: *
279 | 213: * For example:
280 | 214: * [ "There ... is.", "More!" ]
281 | 215: * ... becomes ...
282 | 216: * [ "There ... is. More!" ]
283 | 217: *
284 | 218: * @param array $fragments
285 | 219: * @return array
286 | 220: */
287 | 221: private function abbreviationMerge($fragments) {
288 | 222: $non_abbreviating_terminals = array_diff($this->terminals, $this->abbreviators);
289 | 223:
290 | 224: $abbreviations = array();
291 | 225:
292 | 226: $abbreviation = '';
293 | 227:
294 | 228: $previous_word_count = null;
295 | 229: $previous_word_ending = null;
296 | 230: foreach ($fragments as $fragment) {
297 | 231: $word_count = count(mb_split('\s+', self::mbTrim($fragment)));
298 | 232: $starts_with_space = mb_ereg_match('^\s+', $fragment);
299 | 233: $after_non_abbreviating_terminal = in_array($previous_word_ending, $non_abbreviating_terminals);
300 | 234:
301 | 235: if ($after_non_abbreviating_terminal || ($previous_word_count !== null && ($previous_word_count !== 1 || $word_count !== 1) && $starts_with_space)) {
302 | 236: $abbreviations[] = $abbreviation;
303 | 237: $abbreviation = '';
304 | 238: }
305 | 239:
306 | 240: $abbreviation .= $fragment;
307 | 241: $previous_word_count = $word_count;
308 | 242: $previous_word_ending = mb_substr($fragment, -1);
309 | 243: }
310 | 244: if ($abbreviation !== '') {
311 | 245: $abbreviations[] = $abbreviation;
312 | 246: }
313 | 247:
314 | 248: return $abbreviations;
315 | 249: }
316 | 250:
317 | 251: /**
318 | 252: * Merges items into larger sentences.
319 | 253: *
320 | 254: * Multibyte safe
321 | 255: *
322 | 256: * @param array $shorts
323 | 257: * @return array
324 | 258: */
325 | 259: private function sentenceMerge($shorts) {
326 | 260: $non_abbreviating_terminals = array_diff($this->terminals, $this->abbreviators);
327 | 261:
328 | 262: $sentences = array();
329 | 263:
330 | 264: $sentence = '';
331 | 265: $has_words = false;
332 | 266: $previous_word_ending = null;
333 | 267: foreach ($shorts as $short) {
334 | 268: $word_count = count(mb_split('\s+', self::mbTrim($short)));
335 | 269: $after_non_abbreviating_terminal = in_array($previous_word_ending, $non_abbreviating_terminals);
336 | 270:
337 | 271: if ($after_non_abbreviating_terminal || ($has_words && $word_count > 1)) {
338 | 272: $sentences[] = $sentence;
339 | 273: $sentence = '';
340 | 274: $has_words = $word_count > 1;
341 | 275: } else {
342 | 276: $has_words = $has_words || $word_count > 1;
343 | 277: }
344 | 278:
345 | 279: $sentence.= $short;
346 | 280: $previous_word_ending = mb_substr($short, -1);
347 | 281: }
348 | 282: if (!empty($sentence)) {
349 | 283: $sentences[] = $sentence;
350 | 284: }
351 | 285:
352 | 286: return $sentences;
353 | 287: }
354 | 288:
355 | 289: /**
356 | 290: * Return the sentences sentences detected in the provided text.
357 | 291: * Set the Sentence::SPLIT_TRIM flag to trim whitespace.
358 | 292: * @param string $text
359 | 293: * @param integer $flags
360 | 294: * @return array
361 | 295: */
362 | 296: public function split($text, $flags = 0) {
363 | 297: $sentences = array();
364 | 298:
365 | 299: // Split
366 | 300: foreach (self::linebreakSplit($text) as $line) {
367 | 301: if (self::mbTrim($line) !== '') {
368 | 302: $punctuations = $this->punctuationSplit($line);
369 | 303: $merges = $this->punctuationMerge($punctuations);
370 | 304: $shorts = $this->abbreviationMerge($merges);
371 | 305: $sentences = array_merge($sentences, $this->sentenceMerge($shorts));
372 | 306: }
373 | 307: }
374 | 308:
375 | 309: // Post process
376 | 310: if ($flags & self::SPLIT_TRIM) {
377 | 311: foreach ($sentences as &$sentence) {
378 | 312: $sentence = self::mbTrim($sentence);
379 | 313: }
380 | 314: unset($sentence);
381 | 315: }
382 | 316:
383 | 317: return $sentences;
384 | 318: }
385 | 319:
386 | 320: /**
387 | 321: * Return the number of sentences detected in the provided text.
388 | 322: * @param string $text
389 | 323: * @return integer
390 | 324: */
391 | 325: public function count($text) {
392 | 326: return count($this->split($text));
393 | 327: }
394 | 328: } 1: <?php
68 | 2:
69 | 3: /**
70 | 4: * Generated by PHPUnit_SkeletonGenerator on 2015-02-16 at 20:05:00.
71 | 5: */
72 | 6: class SentenceTest extends PHPUnit_Framework_TestCase {
73 | 7:
74 | 8: /**
75 | 9: * @var Sentence
76 | 10: */
77 | 11: protected $object;
78 | 12:
79 | 13: /**
80 | 14: * Sets up the fixture, for example, opens a network connection.
81 | 15: * This method is called before a test is executed.
82 | 16: */
83 | 17: protected function setUp() {
84 | 18: $this->object = new Sentence;
85 | 19: }
86 | 20:
87 | 21: /**
88 | 22: * @covers Sentence::count
89 | 23: */
90 | 24: public function testCountEmpty() {
91 | 25: $this->assertSame(0, $this->object->count(''));
92 | 26: $this->assertSame(0, $this->object->count(' '));
93 | 27: $this->assertSame(0, $this->object->count("\n"));
94 | 28: }
95 | 29:
96 | 30: /**
97 | 31: * @covers Sentence::count
98 | 32: */
99 | 33: public function testCountWord() {
100 | 34: $this->assertSame(1, $this->object->count('Hello'));
101 | 35: $this->assertSame(1, $this->object->count('Hello.'));
102 | 36: $this->assertSame(1, $this->object->count('Hello...'));
103 | 37: $this->assertSame(1, $this->object->count('Hello!'));
104 | 38: $this->assertSame(1, $this->object->count('Hello?'));
105 | 39: $this->assertSame(1, $this->object->count('Hello?!'));
106 | 40: }
107 | 41:
108 | 42: /**
109 | 43: * @covers Sentence::count
110 | 44: */
111 | 45: public function testCountTwoWords() {
112 | 46: $this->assertSame(1, $this->object->count('Hello world'));
113 | 47: $this->assertSame(1, $this->object->count('Hello world.'));
114 | 48: $this->assertSame(1, $this->object->count('Hello world...'));
115 | 49: $this->assertSame(1, $this->object->count('Hello world!'));
116 | 50: $this->assertSame(1, $this->object->count('Hello world?'));
117 | 51: $this->assertSame(1, $this->object->count('Hello world?!'));
118 | 52: }
119 | 53:
120 | 54: /**
121 | 55: * @covers Sentence::count
122 | 56: */
123 | 57: public function testCountMultipleWords() {
124 | 58: $this->assertSame(2, $this->object->count('Hello world. Are you there'));
125 | 59: $this->assertSame(2, $this->object->count('Hello world. Are you there?'));
126 | 60: $this->assertSame(1, $this->object->count('Hello world, Are you there?'));
127 | 61: $this->assertSame(1, $this->object->count('Hello world: Are you there?'));
128 | 62: $this->assertSame(1, $this->object->count('Hello world... Are you there?'));
129 | 63: }
130 | 64:
131 | 65: /**
132 | 66: * @covers Sentence::count
133 | 67: */
134 | 68: public function testCountLinebreaks() {
135 | 69: $this->assertSame(2, $this->object->count("Hello world...\rAre you there?"));
136 | 70: $this->assertSame(2, $this->object->count("Hello world...\nAre you there?"));
137 | 71: $this->assertSame(2, $this->object->count("Hello world...\r\nAre you there?"));
138 | 72: $this->assertSame(2, $this->object->count("Hello world...\r\n\rAre you there?"));
139 | 73: $this->assertSame(2, $this->object->count("Hello world...\n\r\nAre you there?"));
140 | 74: $this->assertSame(2, $this->object->count("Hello world...\n\nAre you there?"));
141 | 75: $this->assertSame(2, $this->object->count("Hello world...\r\rAre you there?"));
142 | 76: }
143 | 77:
144 | 78: /**
145 | 79: * @covers Sentence::count
146 | 80: */
147 | 81: public function testCountAbreviations() {
148 | 82: $this->assertSame(1, $this->object->count("Hello mr. Smith."));
149 | 83: $this->assertSame(1, $this->object->count("Hello, OMG Kittens!"));
150 | 84: $this->assertSame(1, $this->object->count("Hello, abbrev. Kittens!"));
151 | 85: $this->assertSame(1, $this->object->count("Hello, O.M.G. Kittens!"));
152 | 86: }
153 | 87:
154 | 88: /**
155 | 89: * @covers Sentence::count
156 | 90: */
157 | 91: public function testCountMultiplePunctuation() {
158 | 92: $this->assertSame(2, $this->object->count("Hello there. Brave new world."));
159 | 93: $this->assertSame(1, $this->object->count("Hello there... Brave new world."));
160 | 94: $this->assertSame(2, $this->object->count("Hello there?... Brave new world."));
161 | 95: $this->assertSame(2, $this->object->count("Hello there!... Brave new world."));
162 | 96: $this->assertSame(2, $this->object->count("Hello there!!! Brave new world."));
163 | 97: $this->assertSame(2, $this->object->count("Hello there??? Brave new world."));
164 | 98: }
165 | 99:
166 | 100: /**
167 | 101: * @covers Sentence::count
168 | 102: */
169 | 103: public function testCountOneWordSentences() {
170 | 104: $this->assertSame(2, $this->object->count("You? Smith?"));
171 | 105: $this->assertSame(2, $this->object->count("You there? Smith?"));
172 | 106: $this->assertSame(1, $this->object->count("You mr. Smith?"));
173 | 107: //$this->assertSame(2, $this->object->count("Are you there. Smith?"); // Confuses "there." for an abbreviation.
174 | 108: $this->assertSame(2, $this->object->count("Are you there. Smith, sir?"));
175 | 109: $this->assertSame(2, $this->object->count("Are you there. Mr. Smith?"));
176 | 110: }
177 | 111:
178 | 112: /**
179 | 113: * @covers Sentence::split
180 | 114: */
181 | 115: public function testSplitEmpty() {
182 | 116: $this->assertSame(array(), $this->object->split(''));
183 | 117: $this->assertSame(array(), $this->object->split(' '));
184 | 118: $this->assertSame(array(), $this->object->split("\n"));
185 | 119: }
186 | 120:
187 | 121: /**
188 | 122: * @covers Sentence::split
189 | 123: */
190 | 124: public function testSplitWord() {
191 | 125: $this->assertSame(array('Hello'), $this->object->split('Hello'));
192 | 126: $this->assertSame(array('Hello.'), $this->object->split('Hello.'));
193 | 127: $this->assertSame(array('Hello...'), $this->object->split('Hello...'));
194 | 128: $this->assertSame(array('Hello!'), $this->object->split('Hello!'));
195 | 129: $this->assertSame(array('Hello?'), $this->object->split('Hello?'));
196 | 130: $this->assertSame(array('Hello?!'), $this->object->split('Hello?!'));
197 | 131: }
198 | 132:
199 | 133: /**
200 | 134: * @covers Sentence::split
201 | 135: */
202 | 136: public function testSplitMultipleWords() {
203 | 137: $this->assertSame(array('Hello world.', ' Are you there'), $this->object->split('Hello world. Are you there'));
204 | 138: $this->assertSame(array('Hello world.', ' Are you there?'), $this->object->split('Hello world. Are you there?'));
205 | 139: $this->assertSame(array('Hello world.', 'Are you there'), $this->object->split('Hello world. Are you there', Sentence::SPLIT_TRIM));
206 | 140: $this->assertSame(array('Hello world.', 'Are you there?'), $this->object->split('Hello world. Are you there?', Sentence::SPLIT_TRIM));
207 | 141: $this->assertSame(array('Hello world, Are you there?'), $this->object->split('Hello world, Are you there?'));
208 | 142: $this->assertSame(array('Hello world: Are you there?'), $this->object->split('Hello world: Are you there?'));
209 | 143: $this->assertSame(array('Hello world... Are you there?'), $this->object->split('Hello world... Are you there?'));
210 | 144: }
211 | 145:
212 | 146: /**
213 | 147: * @covers Sentence::split
214 | 148: */
215 | 149: public function testSplitLinebreaks() {
216 | 150: $this->assertSame(array("Hello world...\r", "Are you there?"), $this->object->split("Hello world...\rAre you there?"));
217 | 151: $this->assertSame(array("Hello world...\n", " Are you there?"), $this->object->split("Hello world...\n Are you there?"));
218 | 152: $this->assertSame(array("Hello world...\n", "Are you there?"), $this->object->split("Hello world...\nAre you there?"));
219 | 153: $this->assertSame(array("Hello world...\r\n", "Are you there?"), $this->object->split("Hello world...\r\nAre you there?"));
220 | 154: $this->assertSame(array("Hello world...\r\n\r", "Are you there?"), $this->object->split("Hello world...\r\n\rAre you there?"));
221 | 155: $this->assertSame(array("Hello world...\n\r\n", "Are you there?"), $this->object->split("Hello world...\n\r\nAre you there?"));
222 | 156: $this->assertSame(array("Hello world...\n\n", "Are you there?"), $this->object->split("Hello world...\n\nAre you there?"));
223 | 157: $this->assertSame(array("Hello world...\r\r", "Are you there?"), $this->object->split("Hello world...\r\rAre you there?"));
224 | 158: }
225 | 159:
226 | 160: /**
227 | 161: * @covers Sentence::split
228 | 162: */
229 | 163: public function testSplitAbreviations() {
230 | 164: $this->markTestIncomplete('This test has not been implemented yet.');
231 | 165: $this->assertSame(array('Hello mr. Smith.'), $this->object->split("Hello mr. Smith."));
232 | 166: $this->assertSame(array('Hello, OMG Kittens!'), $this->object->split("Hello, OMG Kittens!"));
233 | 167: $this->assertSame(array('Hello, abbrev. Kittens!'), $this->object->split("Hello, abbrev. Kittens!"));
234 | 168: $this->assertSame(array('Hello, O.M.G. Kittens!'), $this->object->split("Hello, O.M.G. Kittens!"));
235 | 169: }
236 | 170:
237 | 171: /**
238 | 172: * @covers Sentence::split
239 | 173: */
240 | 174: public function testSplitOneWordSentences() {
241 | 175: $this->assertSame(array("You?", " Smith?"), $this->object->split("You? Smith?"));
242 | 176: $this->assertSame(array("You there?", " Smith?"), $this->object->split("You there? Smith?"));
243 | 177: $this->assertSame(array("You mr. Smith?"), $this->object->split("You mr. Smith?"));
244 | 178: //$this->assertSame(2, $this->object->count("Are you there. Smith?"); // Confuses "there." for an abbreviation.
245 | 179: $this->assertSame(array("Are you there.", " Smith, sir?"), $this->object->split("Are you there. Smith, sir?"));
246 | 180: $this->assertSame(array("Are you there.", " Mr. Smith?"), $this->object->split("Are you there. Mr. Smith?"));
247 | 181: }
248 | 182: }
249 | 183: 1: <?php
68 | 2: /**
69 | 3: * phpSentence
70 | 4: * Splits up text into sentences.
71 | 5: *
72 | 6: * @author Martijn W. van der Lee <martijn-at-vanderlee-dot-com>
73 | 7: * @copyright Copyright (c) 2016, Martijn W. van der Lee
74 | 8: * @license http://www.opensource.org/licenses/mit-license.php
75 | 9: */
76 | 10:
77 | 11: /**
78 | 12: * Classloader for the library
79 | 13: * @param string $class
80 | 14: */
81 | 15: function Sentence_autoloader($class) {
82 | 16: if (!class_exists($class) && is_file(dirname(__FILE__). '/' . $class . '.php')) {
83 | 17: require dirname(__FILE__). '/' . $class . '.php';
84 | 18: }
85 | 19: }
86 | 20:
87 | 21: spl_autoload_register('Sentence_autoloader');
88 | 22: 
190 |
191 |
192 |
193 |