Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
Complex classes like Parser often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use Parser, and based on these observations, apply Extract Interface, too.
1 | <?php |
||
16 | abstract class Parser |
||
17 | { |
||
18 | /** |
||
19 | * @var integer the maximum nesting level for language elements. |
||
20 | */ |
||
21 | public $maximumNestingLevel = 32; |
||
22 | |||
23 | /** |
||
24 | * @var string the current context the parser is in. |
||
25 | * TODO remove in favor of absy |
||
26 | */ |
||
27 | protected $context = []; |
||
28 | /** |
||
29 | * @var array these are "escapeable" characters. When using one of these prefixed with a |
||
30 | * backslash, the character will be outputted without the backslash and is not interpreted |
||
31 | * as markdown. |
||
32 | */ |
||
33 | protected $escapeCharacters = [ |
||
34 | '\\', // backslash |
||
35 | ]; |
||
36 | |||
37 | private $_depth = 0; |
||
38 | |||
39 | |||
40 | /** |
||
41 | * Parses the given text considering the full language. |
||
42 | * |
||
43 | * This includes parsing block elements as well as inline elements. |
||
44 | * |
||
45 | * @param string $text the text to parse |
||
46 | * @return string parsed markup |
||
47 | */ |
||
48 | 201 | public function parse($text) |
|
49 | { |
||
50 | 201 | $this->prepare(); |
|
51 | |||
52 | 201 | if (ltrim($text) === '') { |
|
53 | return ''; |
||
54 | } |
||
55 | |||
56 | 201 | $text = str_replace(["\r\n", "\n\r", "\r"], "\n", $text); |
|
57 | |||
58 | 201 | $this->prepareMarkers($text); |
|
59 | |||
60 | 201 | $absy = $this->parseBlocks(explode("\n", $text)); |
|
61 | 201 | $markup = $this->renderAbsy($absy); |
|
62 | |||
63 | 201 | $this->cleanup(); |
|
64 | 201 | return $markup; |
|
65 | } |
||
66 | |||
67 | /** |
||
68 | * Parses a paragraph without block elements (block elements are ignored). |
||
69 | * |
||
70 | * @param string $text the text to parse |
||
71 | * @return string parsed markup |
||
72 | */ |
||
73 | 48 | public function parseParagraph($text) |
|
74 | { |
||
75 | 48 | $this->prepare(); |
|
76 | |||
77 | 48 | if (ltrim($text) === '') { |
|
78 | return ''; |
||
79 | } |
||
80 | |||
81 | 48 | $text = str_replace(["\r\n", "\n\r", "\r"], "\n", $text); |
|
82 | |||
83 | 48 | $this->prepareMarkers($text); |
|
84 | |||
85 | 48 | $absy = $this->parseInline($text); |
|
86 | 48 | $markup = $this->renderAbsy($absy); |
|
87 | |||
88 | 48 | $this->cleanup(); |
|
89 | 48 | return $markup; |
|
90 | } |
||
91 | |||
92 | /** |
||
93 | * This method will be called before `parse()` and `parseParagraph()`. |
||
94 | * You can override it to do some initialization work. |
||
95 | */ |
||
96 | 3 | protected function prepare() |
|
97 | { |
||
98 | 3 | } |
|
99 | |||
100 | /** |
||
101 | * This method will be called after `parse()` and `parseParagraph()`. |
||
102 | * You can override it to do cleanup. |
||
103 | */ |
||
104 | 204 | protected function cleanup() |
|
105 | { |
||
106 | 204 | } |
|
107 | |||
108 | |||
109 | // block parsing |
||
110 | |||
111 | private $_blockTypes; |
||
112 | |||
113 | /** |
||
114 | * @return array a list of block element types available. |
||
115 | */ |
||
116 | 201 | protected function blockTypes() |
|
117 | { |
||
118 | 201 | if ($this->_blockTypes === null) { |
|
119 | // detect block types via "identify" functions |
||
120 | 201 | $reflection = new \ReflectionClass($this); |
|
121 | 201 | $this->_blockTypes = array_filter(array_map(function($method) { |
|
122 | 201 | $name = $method->getName(); |
|
123 | 201 | return strncmp($name, 'identify', 8) === 0 ? strtolower(substr($name, 8)) : false; |
|
124 | 201 | }, $reflection->getMethods(ReflectionMethod::IS_PROTECTED))); |
|
125 | |||
126 | 201 | sort($this->_blockTypes); |
|
127 | } |
||
128 | 201 | return $this->_blockTypes; |
|
129 | } |
||
130 | |||
131 | /** |
||
132 | * Given a set of lines and an index of a current line it uses the registed block types to |
||
133 | * detect the type of this line. |
||
134 | * @param array $lines |
||
135 | * @param integer $current |
||
136 | * @return string name of the block type in lower case |
||
137 | */ |
||
138 | 201 | protected function detectLineType($lines, $current) |
|
139 | { |
||
140 | 201 | $line = $lines[$current]; |
|
141 | 201 | $blockTypes = $this->blockTypes(); |
|
142 | 201 | foreach($blockTypes as $blockType) { |
|
143 | 199 | if ($this->{'identify' . $blockType}($line, $lines, $current)) { |
|
144 | 199 | return $blockType; |
|
145 | } |
||
146 | } |
||
147 | // consider the line a normal paragraph if no other block type matches |
||
148 | 200 | return 'paragraph'; |
|
149 | } |
||
150 | |||
151 | /** |
||
152 | * Parse block elements by calling `detectLineType()` to identify them |
||
153 | * and call consume function afterwards. |
||
154 | */ |
||
155 | 201 | protected function parseBlocks($lines) |
|
156 | { |
||
157 | 201 | if ($this->_depth >= $this->maximumNestingLevel) { |
|
158 | // maximum depth is reached, do not parse input |
||
159 | return [['text', implode("\n", $lines)]]; |
||
160 | } |
||
161 | 201 | $this->_depth++; |
|
162 | |||
163 | 201 | $blocks = []; |
|
164 | |||
165 | // convert lines to blocks |
||
166 | 201 | for ($i = 0, $count = count($lines); $i < $count; $i++) { |
|
167 | 201 | $line = $lines[$i]; |
|
168 | 201 | if ($line !== '' && rtrim($line) !== '') { // skip empty lines |
|
169 | // identify a blocks beginning and parse the content |
||
170 | 201 | list($block, $i) = $this->parseBlock($lines, $i); |
|
171 | 201 | if ($block !== false) { |
|
172 | 201 | $blocks[] = $block; |
|
173 | } |
||
174 | } |
||
175 | } |
||
176 | |||
177 | 201 | $this->_depth--; |
|
178 | |||
179 | 201 | return $blocks; |
|
180 | } |
||
181 | |||
182 | /** |
||
183 | * Parses the block at current line by identifying the block type and parsing the content |
||
184 | * @param $lines |
||
185 | * @param $current |
||
186 | * @return array Array of two elements, the first element contains the block, |
||
187 | * the second contains the next line index to be parsed. |
||
188 | */ |
||
189 | 201 | protected function parseBlock($lines, $current) |
|
197 | |||
198 | 204 | protected function renderAbsy($blocks) |
|
199 | { |
||
200 | 204 | $output = ''; |
|
201 | 204 | foreach ($blocks as $block) { |
|
202 | 204 | array_unshift($this->context, $block[0]); |
|
203 | 204 | $output .= $this->{'render' . $block[0]}($block); |
|
204 | 204 | array_shift($this->context); |
|
205 | } |
||
206 | 204 | return $output; |
|
207 | } |
||
208 | |||
209 | /** |
||
210 | * Consume lines for a paragraph |
||
211 | * |
||
212 | * @param $lines |
||
213 | * @param $current |
||
214 | * @return array |
||
215 | */ |
||
216 | 2 | protected function consumeParagraph($lines, $current) |
|
217 | { |
||
218 | // consume until newline |
||
219 | 2 | $content = []; |
|
220 | 2 | for ($i = $current, $count = count($lines); $i < $count; $i++) { |
|
221 | 2 | if (ltrim($lines[$i]) !== '') { |
|
222 | 2 | $content[] = $lines[$i]; |
|
223 | } else { |
||
224 | break; |
||
225 | } |
||
226 | } |
||
227 | $block = [ |
||
228 | 2 | 'paragraph', |
|
229 | 2 | 'content' => $this->parseInline(implode("\n", $content)), |
|
230 | ]; |
||
231 | 2 | return [$block, --$i]; |
|
232 | } |
||
233 | |||
234 | /** |
||
235 | * Render a paragraph block |
||
236 | * |
||
237 | * @param $block |
||
238 | * @return string |
||
239 | */ |
||
240 | 199 | protected function renderParagraph($block) |
|
244 | |||
245 | |||
246 | // inline parsing |
||
247 | |||
248 | |||
249 | /** |
||
250 | * @var array the set of inline markers to use in different contexts. |
||
251 | */ |
||
252 | private $_inlineMarkers = []; |
||
253 | |||
254 | /** |
||
255 | * Returns a map of inline markers to the corresponding parser methods. |
||
256 | * |
||
257 | * This array defines handler methods for inline markdown markers. |
||
258 | * When a marker is found in the text, the handler method is called with the text |
||
259 | * starting at the position of the marker. |
||
260 | * |
||
261 | * Note that markers starting with whitespace may slow down the parser, |
||
262 | * you may want to use [[renderText]] to deal with them. |
||
263 | * |
||
264 | * You may override this method to define a set of markers and parsing methods. |
||
265 | * The default implementation looks for protected methods starting with `parse` that |
||
266 | * also have an `@marker` annotation in PHPDoc. |
||
267 | * |
||
268 | * @return array a map of markers to parser methods |
||
269 | */ |
||
270 | 201 | protected function inlineMarkers() |
|
271 | { |
||
272 | 201 | $markers = []; |
|
273 | // detect "parse" functions |
||
274 | 201 | $reflection = new \ReflectionClass($this); |
|
275 | 201 | foreach($reflection->getMethods(ReflectionMethod::IS_PROTECTED) as $method) { |
|
276 | 201 | $methodName = $method->getName(); |
|
277 | 201 | if (strncmp($methodName, 'parse', 5) === 0) { |
|
278 | 201 | preg_match_all('/@marker ([^\s]+)/', $method->getDocComment(), $matches); |
|
279 | 201 | foreach($matches[1] as $match) { |
|
280 | 201 | $markers[$match] = $methodName; |
|
281 | } |
||
282 | } |
||
283 | } |
||
284 | 201 | return $markers; |
|
285 | } |
||
286 | |||
287 | /** |
||
288 | * Prepare markers that are used in the text to parse |
||
289 | * |
||
290 | * Add all markers that are present in markdown. |
||
291 | * Check is done to avoid iterations in parseInline(), good for huge markdown files |
||
292 | * @param string $text |
||
293 | */ |
||
294 | 204 | protected function prepareMarkers($text) |
|
295 | { |
||
296 | 204 | $this->_inlineMarkers = []; |
|
297 | 204 | foreach ($this->inlineMarkers() as $marker => $method) { |
|
298 | 203 | if (strpos($text, $marker) !== false) { |
|
299 | 145 | $m = $marker[0]; |
|
300 | // put the longest marker first |
||
301 | 145 | if (isset($this->_inlineMarkers[$m])) { |
|
302 | 1 | reset($this->_inlineMarkers[$m]); |
|
303 | 1 | if (strlen($marker) > strlen(key($this->_inlineMarkers[$m]))) { |
|
304 | 1 | $this->_inlineMarkers[$m] = array_merge([$marker => $method], $this->_inlineMarkers[$m]); |
|
305 | 1 | continue; |
|
306 | } |
||
307 | } |
||
308 | 203 | $this->_inlineMarkers[$m][$marker] = $method; |
|
309 | } |
||
310 | } |
||
311 | 204 | } |
|
312 | |||
313 | /** |
||
314 | * Parses inline elements of the language. |
||
315 | * |
||
316 | * @param string $text the inline text to parse. |
||
317 | * @return array |
||
318 | */ |
||
319 | 203 | protected function parseInline($text) |
|
320 | { |
||
321 | 203 | if ($this->_depth >= $this->maximumNestingLevel) { |
|
322 | // maximum depth is reached, do not parse input |
||
323 | 1 | return [['text', $text]]; |
|
324 | } |
||
325 | 203 | $this->_depth++; |
|
326 | |||
327 | 203 | $markers = implode('', array_keys($this->_inlineMarkers)); |
|
328 | |||
329 | 203 | $paragraph = []; |
|
330 | |||
331 | 203 | while (!empty($markers) && ($found = strpbrk($text, $markers)) !== false) { |
|
332 | |||
333 | 101 | $pos = strpos($text, $found); |
|
334 | |||
335 | // add the text up to next marker to the paragraph |
||
336 | 101 | View Code Duplication | if ($pos !== 0) { |
337 | 85 | $paragraph[] = ['text', substr($text, 0, $pos)]; |
|
338 | } |
||
339 | 101 | $text = $found; |
|
340 | |||
341 | 101 | $parsed = false; |
|
342 | 101 | foreach ($this->_inlineMarkers[$text[0]] as $marker => $method) { |
|
343 | 101 | if (strncmp($text, $marker, strlen($marker)) === 0) { |
|
344 | // parse the marker |
||
345 | 101 | array_unshift($this->context, $method); |
|
346 | 101 | list($output, $offset) = $this->$method($text); |
|
347 | 101 | array_shift($this->context); |
|
348 | |||
349 | 101 | $paragraph[] = $output; |
|
350 | 101 | $text = substr($text, $offset); |
|
351 | 101 | $parsed = true; |
|
352 | 101 | break; |
|
353 | } |
||
354 | } |
||
355 | 101 | View Code Duplication | if (!$parsed) { |
356 | 15 | $paragraph[] = ['text', substr($text, 0, 1)]; |
|
357 | 15 | $text = substr($text, 1); |
|
358 | } |
||
359 | } |
||
360 | |||
361 | 203 | $paragraph[] = ['text', $text]; |
|
362 | |||
363 | 203 | $this->_depth--; |
|
364 | |||
365 | 203 | return $paragraph; |
|
366 | } |
||
367 | |||
368 | /** |
||
369 | * Parses escaped special characters. |
||
370 | * @marker \ |
||
371 | */ |
||
372 | 17 | protected function parseEscape($text) |
|
379 | |||
380 | /** |
||
381 | * This function renders plain text sections in the markdown text. |
||
382 | * It can be used to work on normal text sections for example to highlight keywords or |
||
383 | * do special escaping. |
||
384 | */ |
||
385 | 3 | protected function renderText($block) |
|
389 | } |
||
390 |