1
|
|
|
<?php |
2
|
|
|
|
3
|
|
|
declare(strict_types=1); |
4
|
|
|
|
5
|
|
|
namespace Doctrine\Inflector; |
6
|
|
|
|
7
|
|
|
use function chr; |
8
|
|
|
use function function_exists; |
9
|
|
|
use function lcfirst; |
10
|
|
|
use function mb_strtolower; |
11
|
|
|
use function ord; |
12
|
|
|
use function preg_match; |
13
|
|
|
use function preg_replace; |
14
|
|
|
use function str_replace; |
15
|
|
|
use function strlen; |
16
|
|
|
use function strtolower; |
17
|
|
|
use function strtr; |
18
|
|
|
use function trim; |
19
|
|
|
use function ucwords; |
20
|
|
|
|
21
|
|
|
class Inflector |
22
|
|
|
{ |
23
|
|
|
/** @var WordInflector */ |
24
|
|
|
private $singularizer; |
25
|
|
|
|
26
|
|
|
/** @var WordInflector */ |
27
|
|
|
private $pluralizer; |
28
|
|
|
|
29
|
1090 |
|
public function __construct(WordInflector $singularizer, WordInflector $pluralizer) |
30
|
|
|
{ |
31
|
1090 |
|
$this->singularizer = $singularizer; |
32
|
1090 |
|
$this->pluralizer = $pluralizer; |
33
|
1090 |
|
} |
34
|
|
|
|
35
|
|
|
/** |
36
|
|
|
* Converts a word into the format for a Doctrine table name. Converts 'ModelName' to 'model_name'. |
37
|
|
|
*/ |
38
|
4 |
|
public function tableize(string $word) : string |
39
|
|
|
{ |
40
|
4 |
|
return mb_strtolower(preg_replace('~(?<=\\w)([A-Z])~u', '_$1', $word)); |
41
|
|
|
} |
42
|
|
|
|
43
|
|
|
/** |
44
|
|
|
* Converts a word into the format for a Doctrine class name. Converts 'table_name' to 'TableName'. |
45
|
|
|
*/ |
46
|
13 |
|
public function classify(string $word) : string |
47
|
|
|
{ |
48
|
13 |
|
return str_replace([' ', '_', '-'], '', ucwords($word, ' _-')); |
49
|
|
|
} |
50
|
|
|
|
51
|
|
|
/** |
52
|
|
|
* Camelizes a word. This uses the classify() method and turns the first character to lowercase. |
53
|
|
|
*/ |
54
|
6 |
|
public function camelize(string $word) : string |
55
|
|
|
{ |
56
|
6 |
|
return lcfirst($this->classify($word)); |
57
|
|
|
} |
58
|
|
|
|
59
|
|
|
/** |
60
|
|
|
* Uppercases words with configurable delimiters between words. |
61
|
|
|
* |
62
|
|
|
* Takes a string and capitalizes all of the words, like PHP's built-in |
63
|
|
|
* ucwords function. This extends that behavior, however, by allowing the |
64
|
|
|
* word delimiters to be configured, rather than only separating on |
65
|
|
|
* whitespace. |
66
|
|
|
* |
67
|
|
|
* Here is an example: |
68
|
|
|
* <code> |
69
|
|
|
* <?php |
70
|
|
|
* $string = 'top-o-the-morning to all_of_you!'; |
71
|
|
|
* echo $inflector->capitalize($string); |
72
|
|
|
* // Top-O-The-Morning To All_of_you! |
73
|
|
|
* |
74
|
|
|
* echo $inflector->capitalize($string, '-_ '); |
75
|
|
|
* // Top-O-The-Morning To All_Of_You! |
76
|
|
|
* ?> |
77
|
|
|
* </code> |
78
|
|
|
* |
79
|
|
|
* @param string $string The string to operate on. |
80
|
|
|
* @param string $delimiters A list of word separators. |
81
|
|
|
* |
82
|
|
|
* @return string The string with all delimiter-separated words capitalized. |
83
|
|
|
*/ |
84
|
3 |
|
public function capitalize(string $string, string $delimiters = " \n\t\r\0\x0B-") : string |
85
|
|
|
{ |
86
|
3 |
|
return ucwords($string, $delimiters); |
87
|
|
|
} |
88
|
|
|
|
89
|
|
|
/** |
90
|
|
|
* Checks if the given string seems like it has utf8 characters in it. |
91
|
|
|
* |
92
|
|
|
* @param string $string The string to check for utf8 characters in. |
93
|
|
|
*/ |
94
|
6 |
|
public function seemsUtf8(string $string) : bool |
95
|
|
|
{ |
96
|
6 |
|
for ($i = 0; $i < strlen($string); $i++) { |
97
|
6 |
|
if (ord($string[$i]) < 0x80) { |
98
|
6 |
|
continue; // 0bbbbbbb |
99
|
5 |
|
} elseif ((ord($string[$i]) & 0xE0) === 0xC0) { |
100
|
5 |
|
$n = 1; // 110bbbbb |
101
|
|
|
} elseif ((ord($string[$i]) & 0xF0) === 0xE0) { |
102
|
|
|
$n = 2; // 1110bbbb |
103
|
|
|
} elseif ((ord($string[$i]) & 0xF8) === 0xF0) { |
104
|
|
|
$n = 3; // 11110bbb |
105
|
|
|
} elseif ((ord($string[$i]) & 0xFC) === 0xF8) { |
106
|
|
|
$n = 4; // 111110bb |
107
|
|
|
} elseif ((ord($string[$i]) & 0xFE) === 0xFC) { |
108
|
|
|
$n = 5; // 1111110b |
109
|
|
|
} else { |
110
|
|
|
return false; // Does not match any model |
111
|
|
|
} |
112
|
|
|
|
113
|
5 |
|
for ($j = 0; $j < $n; $j++) { // n bytes matching 10bbbbbb follow ? |
114
|
5 |
|
if (++$i === strlen($string) || ((ord($string[$i]) & 0xC0) !== 0x80)) { |
115
|
|
|
return false; |
116
|
|
|
} |
117
|
|
|
} |
118
|
|
|
} |
119
|
|
|
|
120
|
6 |
|
return true; |
121
|
|
|
} |
122
|
|
|
|
123
|
|
|
/** |
124
|
|
|
* Remove any illegal characters, accents, etc. |
125
|
|
|
* |
126
|
|
|
* @param string $string String to unaccent |
127
|
|
|
* |
128
|
|
|
* @return string Unaccented string |
129
|
|
|
*/ |
130
|
5 |
|
public function unaccent(string $string) : string |
131
|
|
|
{ |
132
|
5 |
|
if (preg_match('/[\x80-\xff]/', $string) === false) { |
133
|
|
|
return $string; |
134
|
|
|
} |
135
|
|
|
|
136
|
5 |
|
if ($this->seemsUtf8($string)) { |
137
|
|
|
$characters = [ |
138
|
|
|
// Decompositions for Latin-1 Supplement |
139
|
5 |
|
chr(195) . chr(128) => 'A', |
140
|
5 |
|
chr(195) . chr(129) => 'A', |
141
|
5 |
|
chr(195) . chr(130) => 'A', |
142
|
5 |
|
chr(195) . chr(131) => 'A', |
143
|
5 |
|
chr(195) . chr(132) => 'A', |
144
|
5 |
|
chr(195) . chr(133) => 'A', |
145
|
5 |
|
chr(195) . chr(135) => 'C', |
146
|
5 |
|
chr(195) . chr(136) => 'E', |
147
|
5 |
|
chr(195) . chr(137) => 'E', |
148
|
5 |
|
chr(195) . chr(138) => 'E', |
149
|
5 |
|
chr(195) . chr(139) => 'E', |
150
|
5 |
|
chr(195) . chr(140) => 'I', |
151
|
5 |
|
chr(195) . chr(141) => 'I', |
152
|
5 |
|
chr(195) . chr(142) => 'I', |
153
|
5 |
|
chr(195) . chr(143) => 'I', |
154
|
5 |
|
chr(195) . chr(145) => 'N', |
155
|
5 |
|
chr(195) . chr(146) => 'O', |
156
|
5 |
|
chr(195) . chr(147) => 'O', |
157
|
5 |
|
chr(195) . chr(148) => 'O', |
158
|
5 |
|
chr(195) . chr(149) => 'O', |
159
|
5 |
|
chr(195) . chr(150) => 'O', |
160
|
5 |
|
chr(195) . chr(153) => 'U', |
161
|
5 |
|
chr(195) . chr(154) => 'U', |
162
|
5 |
|
chr(195) . chr(155) => 'U', |
163
|
5 |
|
chr(195) . chr(156) => 'U', |
164
|
5 |
|
chr(195) . chr(157) => 'Y', |
165
|
5 |
|
chr(195) . chr(159) => 's', |
166
|
5 |
|
chr(195) . chr(160) => 'a', |
167
|
5 |
|
chr(195) . chr(161) => 'a', |
168
|
5 |
|
chr(195) . chr(162) => 'a', |
169
|
5 |
|
chr(195) . chr(163) => 'a', |
170
|
5 |
|
chr(195) . chr(164) => 'a', |
171
|
5 |
|
chr(195) . chr(165) => 'a', |
172
|
5 |
|
chr(195) . chr(167) => 'c', |
173
|
5 |
|
chr(195) . chr(168) => 'e', |
174
|
5 |
|
chr(195) . chr(169) => 'e', |
175
|
5 |
|
chr(195) . chr(170) => 'e', |
176
|
5 |
|
chr(195) . chr(171) => 'e', |
177
|
5 |
|
chr(195) . chr(172) => 'i', |
178
|
5 |
|
chr(195) . chr(173) => 'i', |
179
|
5 |
|
chr(195) . chr(174) => 'i', |
180
|
5 |
|
chr(195) . chr(175) => 'i', |
181
|
5 |
|
chr(195) . chr(177) => 'n', |
182
|
5 |
|
chr(195) . chr(178) => 'o', |
183
|
5 |
|
chr(195) . chr(179) => 'o', |
184
|
5 |
|
chr(195) . chr(180) => 'o', |
185
|
5 |
|
chr(195) . chr(181) => 'o', |
186
|
5 |
|
chr(195) . chr(182) => 'o', |
187
|
5 |
|
chr(195) . chr(182) => 'o', |
188
|
5 |
|
chr(195) . chr(185) => 'u', |
189
|
5 |
|
chr(195) . chr(186) => 'u', |
190
|
5 |
|
chr(195) . chr(187) => 'u', |
191
|
5 |
|
chr(195) . chr(188) => 'u', |
192
|
5 |
|
chr(195) . chr(189) => 'y', |
193
|
5 |
|
chr(195) . chr(191) => 'y', |
194
|
|
|
// Decompositions for Latin Extended-A |
195
|
5 |
|
chr(196) . chr(128) => 'A', |
196
|
5 |
|
chr(196) . chr(129) => 'a', |
197
|
5 |
|
chr(196) . chr(130) => 'A', |
198
|
5 |
|
chr(196) . chr(131) => 'a', |
199
|
5 |
|
chr(196) . chr(132) => 'A', |
200
|
5 |
|
chr(196) . chr(133) => 'a', |
201
|
5 |
|
chr(196) . chr(134) => 'C', |
202
|
5 |
|
chr(196) . chr(135) => 'c', |
203
|
5 |
|
chr(196) . chr(136) => 'C', |
204
|
5 |
|
chr(196) . chr(137) => 'c', |
205
|
5 |
|
chr(196) . chr(138) => 'C', |
206
|
5 |
|
chr(196) . chr(139) => 'c', |
207
|
5 |
|
chr(196) . chr(140) => 'C', |
208
|
5 |
|
chr(196) . chr(141) => 'c', |
209
|
5 |
|
chr(196) . chr(142) => 'D', |
210
|
5 |
|
chr(196) . chr(143) => 'd', |
211
|
5 |
|
chr(196) . chr(144) => 'D', |
212
|
5 |
|
chr(196) . chr(145) => 'd', |
213
|
5 |
|
chr(196) . chr(146) => 'E', |
214
|
5 |
|
chr(196) . chr(147) => 'e', |
215
|
5 |
|
chr(196) . chr(148) => 'E', |
216
|
5 |
|
chr(196) . chr(149) => 'e', |
217
|
5 |
|
chr(196) . chr(150) => 'E', |
218
|
5 |
|
chr(196) . chr(151) => 'e', |
219
|
5 |
|
chr(196) . chr(152) => 'E', |
220
|
5 |
|
chr(196) . chr(153) => 'e', |
221
|
5 |
|
chr(196) . chr(154) => 'E', |
222
|
5 |
|
chr(196) . chr(155) => 'e', |
223
|
5 |
|
chr(196) . chr(156) => 'G', |
224
|
5 |
|
chr(196) . chr(157) => 'g', |
225
|
5 |
|
chr(196) . chr(158) => 'G', |
226
|
5 |
|
chr(196) . chr(159) => 'g', |
227
|
5 |
|
chr(196) . chr(160) => 'G', |
228
|
5 |
|
chr(196) . chr(161) => 'g', |
229
|
5 |
|
chr(196) . chr(162) => 'G', |
230
|
5 |
|
chr(196) . chr(163) => 'g', |
231
|
5 |
|
chr(196) . chr(164) => 'H', |
232
|
5 |
|
chr(196) . chr(165) => 'h', |
233
|
5 |
|
chr(196) . chr(166) => 'H', |
234
|
5 |
|
chr(196) . chr(167) => 'h', |
235
|
5 |
|
chr(196) . chr(168) => 'I', |
236
|
5 |
|
chr(196) . chr(169) => 'i', |
237
|
5 |
|
chr(196) . chr(170) => 'I', |
238
|
5 |
|
chr(196) . chr(171) => 'i', |
239
|
5 |
|
chr(196) . chr(172) => 'I', |
240
|
5 |
|
chr(196) . chr(173) => 'i', |
241
|
5 |
|
chr(196) . chr(174) => 'I', |
242
|
5 |
|
chr(196) . chr(175) => 'i', |
243
|
5 |
|
chr(196) . chr(176) => 'I', |
244
|
5 |
|
chr(196) . chr(177) => 'i', |
245
|
5 |
|
chr(196) . chr(178) => 'IJ', |
246
|
5 |
|
chr(196) . chr(179) => 'ij', |
247
|
5 |
|
chr(196) . chr(180) => 'J', |
248
|
5 |
|
chr(196) . chr(181) => 'j', |
249
|
5 |
|
chr(196) . chr(182) => 'K', |
250
|
5 |
|
chr(196) . chr(183) => 'k', |
251
|
5 |
|
chr(196) . chr(184) => 'k', |
252
|
5 |
|
chr(196) . chr(185) => 'L', |
253
|
5 |
|
chr(196) . chr(186) => 'l', |
254
|
5 |
|
chr(196) . chr(187) => 'L', |
255
|
5 |
|
chr(196) . chr(188) => 'l', |
256
|
5 |
|
chr(196) . chr(189) => 'L', |
257
|
5 |
|
chr(196) . chr(190) => 'l', |
258
|
5 |
|
chr(196) . chr(191) => 'L', |
259
|
5 |
|
chr(197) . chr(128) => 'l', |
260
|
5 |
|
chr(197) . chr(129) => 'L', |
261
|
5 |
|
chr(197) . chr(130) => 'l', |
262
|
5 |
|
chr(197) . chr(131) => 'N', |
263
|
5 |
|
chr(197) . chr(132) => 'n', |
264
|
5 |
|
chr(197) . chr(133) => 'N', |
265
|
5 |
|
chr(197) . chr(134) => 'n', |
266
|
5 |
|
chr(197) . chr(135) => 'N', |
267
|
5 |
|
chr(197) . chr(136) => 'n', |
268
|
5 |
|
chr(197) . chr(137) => 'N', |
269
|
5 |
|
chr(197) . chr(138) => 'n', |
270
|
5 |
|
chr(197) . chr(139) => 'N', |
271
|
5 |
|
chr(197) . chr(140) => 'O', |
272
|
5 |
|
chr(197) . chr(141) => 'o', |
273
|
5 |
|
chr(197) . chr(142) => 'O', |
274
|
5 |
|
chr(197) . chr(143) => 'o', |
275
|
5 |
|
chr(197) . chr(144) => 'O', |
276
|
5 |
|
chr(197) . chr(145) => 'o', |
277
|
5 |
|
chr(197) . chr(146) => 'OE', |
278
|
5 |
|
chr(197) . chr(147) => 'oe', |
279
|
5 |
|
chr(197) . chr(148) => 'R', |
280
|
5 |
|
chr(197) . chr(149) => 'r', |
281
|
5 |
|
chr(197) . chr(150) => 'R', |
282
|
5 |
|
chr(197) . chr(151) => 'r', |
283
|
5 |
|
chr(197) . chr(152) => 'R', |
284
|
5 |
|
chr(197) . chr(153) => 'r', |
285
|
5 |
|
chr(197) . chr(154) => 'S', |
286
|
5 |
|
chr(197) . chr(155) => 's', |
287
|
5 |
|
chr(197) . chr(156) => 'S', |
288
|
5 |
|
chr(197) . chr(157) => 's', |
289
|
5 |
|
chr(197) . chr(158) => 'S', |
290
|
5 |
|
chr(197) . chr(159) => 's', |
291
|
5 |
|
chr(197) . chr(160) => 'S', |
292
|
5 |
|
chr(197) . chr(161) => 's', |
293
|
5 |
|
chr(197) . chr(162) => 'T', |
294
|
5 |
|
chr(197) . chr(163) => 't', |
295
|
5 |
|
chr(197) . chr(164) => 'T', |
296
|
5 |
|
chr(197) . chr(165) => 't', |
297
|
5 |
|
chr(197) . chr(166) => 'T', |
298
|
5 |
|
chr(197) . chr(167) => 't', |
299
|
5 |
|
chr(197) . chr(168) => 'U', |
300
|
5 |
|
chr(197) . chr(169) => 'u', |
301
|
5 |
|
chr(197) . chr(170) => 'U', |
302
|
5 |
|
chr(197) . chr(171) => 'u', |
303
|
5 |
|
chr(197) . chr(172) => 'U', |
304
|
5 |
|
chr(197) . chr(173) => 'u', |
305
|
5 |
|
chr(197) . chr(174) => 'U', |
306
|
5 |
|
chr(197) . chr(175) => 'u', |
307
|
5 |
|
chr(197) . chr(176) => 'U', |
308
|
5 |
|
chr(197) . chr(177) => 'u', |
309
|
5 |
|
chr(197) . chr(178) => 'U', |
310
|
5 |
|
chr(197) . chr(179) => 'u', |
311
|
5 |
|
chr(197) . chr(180) => 'W', |
312
|
5 |
|
chr(197) . chr(181) => 'w', |
313
|
5 |
|
chr(197) . chr(182) => 'Y', |
314
|
5 |
|
chr(197) . chr(183) => 'y', |
315
|
5 |
|
chr(197) . chr(184) => 'Y', |
316
|
5 |
|
chr(197) . chr(185) => 'Z', |
317
|
5 |
|
chr(197) . chr(186) => 'z', |
318
|
5 |
|
chr(197) . chr(187) => 'Z', |
319
|
5 |
|
chr(197) . chr(188) => 'z', |
320
|
5 |
|
chr(197) . chr(189) => 'Z', |
321
|
5 |
|
chr(197) . chr(190) => 'z', |
322
|
5 |
|
chr(197) . chr(191) => 's', |
323
|
|
|
// Euro Sign |
324
|
5 |
|
chr(226) . chr(130) . chr(172) => 'E', |
325
|
|
|
// GBP (Pound) Sign |
326
|
5 |
|
chr(194) . chr(163) => '', |
327
|
5 |
|
'Ä' => 'Ae', |
328
|
5 |
|
'ä' => 'ae', |
329
|
5 |
|
'Ü' => 'Ue', |
330
|
5 |
|
'ü' => 'ue', |
331
|
5 |
|
'Ö' => 'Oe', |
332
|
5 |
|
'ö' => 'oe', |
333
|
5 |
|
'ß' => 'ss', |
334
|
|
|
// Norwegian characters |
335
|
5 |
|
'Å'=>'Aa', |
336
|
5 |
|
'Æ'=>'Ae', |
337
|
5 |
|
'Ø'=>'O', |
338
|
5 |
|
'æ'=>'a', |
339
|
5 |
|
'ø'=>'o', |
340
|
5 |
|
'å'=>'aa', |
341
|
|
|
]; |
342
|
|
|
|
343
|
5 |
|
$string = strtr($string, $characters); |
344
|
|
|
} else { |
345
|
|
|
$characters = []; |
346
|
|
|
|
347
|
|
|
// Assume ISO-8859-1 if not UTF-8 |
348
|
|
|
$characters['in'] = |
349
|
|
|
chr(128) |
350
|
|
|
. chr(131) |
351
|
|
|
. chr(138) |
352
|
|
|
. chr(142) |
353
|
|
|
. chr(154) |
354
|
|
|
. chr(158) |
355
|
|
|
. chr(159) |
356
|
|
|
. chr(162) |
357
|
|
|
. chr(165) |
358
|
|
|
. chr(181) |
359
|
|
|
. chr(192) |
360
|
|
|
. chr(193) |
361
|
|
|
. chr(194) |
362
|
|
|
. chr(195) |
363
|
|
|
. chr(196) |
364
|
|
|
. chr(197) |
365
|
|
|
. chr(199) |
366
|
|
|
. chr(200) |
367
|
|
|
. chr(201) |
368
|
|
|
. chr(202) |
369
|
|
|
. chr(203) |
370
|
|
|
. chr(204) |
371
|
|
|
. chr(205) |
372
|
|
|
. chr(206) |
373
|
|
|
. chr(207) |
374
|
|
|
. chr(209) |
375
|
|
|
. chr(210) |
376
|
|
|
. chr(211) |
377
|
|
|
. chr(212) |
378
|
|
|
. chr(213) |
379
|
|
|
. chr(214) |
380
|
|
|
. chr(216) |
381
|
|
|
. chr(217) |
382
|
|
|
. chr(218) |
383
|
|
|
. chr(219) |
384
|
|
|
. chr(220) |
385
|
|
|
. chr(221) |
386
|
|
|
. chr(224) |
387
|
|
|
. chr(225) |
388
|
|
|
. chr(226) |
389
|
|
|
. chr(227) |
390
|
|
|
. chr(228) |
391
|
|
|
. chr(229) |
392
|
|
|
. chr(231) |
393
|
|
|
. chr(232) |
394
|
|
|
. chr(233) |
395
|
|
|
. chr(234) |
396
|
|
|
. chr(235) |
397
|
|
|
. chr(236) |
398
|
|
|
. chr(237) |
399
|
|
|
. chr(238) |
400
|
|
|
. chr(239) |
401
|
|
|
. chr(241) |
402
|
|
|
. chr(242) |
403
|
|
|
. chr(243) |
404
|
|
|
. chr(244) |
405
|
|
|
. chr(245) |
406
|
|
|
. chr(246) |
407
|
|
|
. chr(248) |
408
|
|
|
. chr(249) |
409
|
|
|
. chr(250) |
410
|
|
|
. chr(251) |
411
|
|
|
. chr(252) |
412
|
|
|
. chr(253) |
413
|
|
|
. chr(255); |
414
|
|
|
|
415
|
|
|
$characters['out'] = 'EfSZszYcYuAAAAAACEEEEIIIINOOOOOOUUUUYaaaaaaceeeeiiiinoooooouuuuyy'; |
416
|
|
|
|
417
|
|
|
$string = strtr($string, $characters['in'], $characters['out']); |
418
|
|
|
|
419
|
|
|
$doubleChars = []; |
420
|
|
|
|
421
|
|
|
$doubleChars['in'] = [ |
422
|
|
|
chr(140), |
423
|
|
|
chr(156), |
424
|
|
|
chr(198), |
425
|
|
|
chr(208), |
426
|
|
|
chr(222), |
427
|
|
|
chr(223), |
428
|
|
|
chr(230), |
429
|
|
|
chr(240), |
430
|
|
|
chr(254), |
431
|
|
|
]; |
432
|
|
|
|
433
|
|
|
$doubleChars['out'] = ['OE', 'oe', 'AE', 'DH', 'TH', 'ss', 'ae', 'dh', 'th']; |
434
|
|
|
|
435
|
|
|
$string = str_replace($doubleChars['in'], $doubleChars['out'], $string); |
436
|
|
|
} |
437
|
|
|
|
438
|
5 |
|
return $string; |
439
|
|
|
} |
440
|
|
|
|
441
|
|
|
/** |
442
|
|
|
* Convert any passed string to a url friendly string. |
443
|
|
|
* Converts 'My first blog post' to 'my-first-blog-post' |
444
|
|
|
* |
445
|
|
|
* @param string $string String to urlize. |
446
|
|
|
* |
447
|
|
|
* @return string Urlized string. |
448
|
|
|
*/ |
449
|
4 |
|
public function urlize(string $string) : string |
450
|
|
|
{ |
451
|
|
|
// Remove all non url friendly characters with the unaccent function |
452
|
4 |
|
$string = $this->unaccent($string); |
453
|
|
|
|
454
|
4 |
|
if (function_exists('mb_strtolower')) { |
455
|
4 |
|
$string = mb_strtolower($string); |
456
|
|
|
} else { |
457
|
|
|
$string = strtolower($string); |
458
|
|
|
} |
459
|
|
|
|
460
|
|
|
// Remove all none word characters |
461
|
4 |
|
$string = preg_replace('/\W/', ' ', $string); |
462
|
|
|
|
463
|
|
|
// More stripping. Replace spaces with dashes |
464
|
4 |
|
$string = strtolower(preg_replace( |
465
|
4 |
|
'/[^A-Z^a-z^0-9^\/]+/', |
466
|
4 |
|
'-', |
467
|
4 |
|
preg_replace( |
468
|
4 |
|
'/([a-z\d])([A-Z])/', |
469
|
4 |
|
'\1_\2', |
470
|
4 |
|
preg_replace( |
471
|
4 |
|
'/([A-Z]+)([A-Z][a-z])/', |
472
|
4 |
|
'\1_\2', |
473
|
4 |
|
preg_replace('/::/', '/', $string) |
474
|
|
|
) |
475
|
|
|
) |
476
|
|
|
)); |
477
|
|
|
|
478
|
4 |
|
return trim($string, '-'); |
479
|
|
|
} |
480
|
|
|
|
481
|
|
|
/** |
482
|
|
|
* Returns a word in singular form. |
483
|
|
|
* |
484
|
|
|
* @param string $word The word in plural form. |
485
|
|
|
* |
486
|
|
|
* @return string The word in singular form. |
487
|
|
|
*/ |
488
|
532 |
|
public function singularize(string $word) : string |
489
|
|
|
{ |
490
|
532 |
|
return $this->singularizer->inflect($word); |
491
|
|
|
} |
492
|
|
|
|
493
|
|
|
/** |
494
|
|
|
* Returns a word in plural form. |
495
|
|
|
* |
496
|
|
|
* @param string $word The word in singular form. |
497
|
|
|
* |
498
|
|
|
* @return string The word in plural form. |
499
|
|
|
*/ |
500
|
532 |
|
public function pluralize(string $word) : string |
501
|
|
|
{ |
502
|
532 |
|
return $this->pluralizer->inflect($word); |
503
|
|
|
} |
504
|
|
|
} |
505
|
|
|
|