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 | 201 | } |
|
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 | 118 | return $blockType; |
|
145 | } |
||
146 | 201 | } |
|
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 | 201 | } |
|
174 | 201 | } |
|
175 | 201 | } |
|
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); |
|
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) |
|
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() |
|
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) |
|
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) |
|
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 |