peacefulbit /
packet-lite
| Conditions | 23 |
| Paths | 1 |
| Total Lines | 119 |
| Code Lines | 69 |
| Lines | 16 |
| Ratio | 13.45 % |
| Changes | 1 | ||
| Bugs | 1 | Features | 0 |
Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.
For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.
Commonly applied refactorings include:
If many parameters/temporary variables are present:
| 1 | <?php |
||
| 81 | public function tokenize($code) |
||
| 82 | { |
||
| 83 | // Initial state of parser |
||
| 84 | $baseIter = tail(function ($rest, $acc) use (&$baseIter, &$symbolIter, &$stringIter, &$commentIter) { |
||
| 85 | if (sizeof($rest) == 0) { |
||
| 86 | return $acc; |
||
| 87 | } |
||
| 88 | list ($head, $tail) = toHeadTail($rest); |
||
| 89 | switch ($head) { |
||
| 90 | // We got '(', so we just add it to accumulator. |
||
| 91 | case self::TOKEN_OPEN_BRACKET: |
||
| 92 | return $baseIter($tail, append($acc, new Tokens\OpenBracketToken)); |
||
| 93 | // We got ')', and doing the same as in previous case. |
||
| 94 | case self::TOKEN_CLOSE_BRACKET: |
||
| 95 | return $baseIter($tail, append($acc, new Tokens\CloseBracketToken)); |
||
| 96 | // We got '"'. That means that we're in the beginning of the string. |
||
| 97 | // So we switch our state to stringIter. |
||
| 98 | case self::TOKEN_DOUBLE_QUOTE: |
||
| 99 | return $stringIter($tail, '', $acc); |
||
| 100 | // We got ';'. And that means that comment is starting here. So we |
||
| 101 | // change our state to commentIter. |
||
| 102 | case self::TOKEN_SEMICOLON: |
||
| 103 | return $commentIter($tail, '', $acc); |
||
| 104 | default: |
||
| 105 | // If current char is a delimiter, we ignore it. |
||
| 106 | if ($this->isDelimiter($head)) { |
||
| 107 | return $baseIter($tail, $acc); |
||
| 108 | } |
||
| 109 | // In all other cases we interpret current char as first char |
||
| 110 | // of symbol and change our state to symbolIter. |
||
| 111 | return $symbolIter($tail, $head, $acc); |
||
| 112 | } |
||
| 113 | }); |
||
| 114 | |||
| 115 | // State when parser parses any symbol |
||
| 116 | $symbolIter = tail(function ($rest, $buffer, $acc) use (&$symbolIter, &$baseIter, &$preDotSymbolIter) { |
||
| 117 | if (sizeof($rest) > 0) { |
||
| 118 | list ($head, $tail) = toHeadTail($rest); |
||
| 119 | if ($head == self::CHAR_DOT) { |
||
| 120 | return $preDotSymbolIter($tail, $buffer . $head, $acc); |
||
| 121 | } |
||
| 122 | if ($this->isSymbol($head)) { |
||
| 123 | return $symbolIter($tail, $buffer . $head, $acc); |
||
| 124 | } |
||
| 125 | } |
||
| 126 | if (is_numeric($buffer)) { |
||
| 127 | $symbolToken = new Tokens\NumericToken($buffer); |
||
| 128 | } else { |
||
| 129 | $symbolToken = new Tokens\IdentifierToken($buffer); |
||
| 130 | } |
||
| 131 | return $baseIter($rest, append($acc, $symbolToken)); |
||
| 132 | }); |
||
| 133 | |||
| 134 | View Code Duplication | $preDotSymbolIter = tail(function ($rest, $buffer, $acc) use (&$baseIter, &$dotSymbolIter) { |
|
| 135 | if (sizeof($rest) > 0) { |
||
| 136 | list ($head, $tail) = toHeadTail($rest); |
||
| 137 | if ($this->isSymbol($head)) { |
||
| 138 | return $dotSymbolIter($tail, $buffer . $head, $acc); |
||
| 139 | } |
||
| 140 | } |
||
| 141 | throw new TokenizerException("Unexpected dot at the end of identifier"); |
||
| 142 | }); |
||
| 143 | |||
| 144 | // State when parser parses any symbol |
||
| 145 | $dotSymbolIter = tail(function ($rest, $buffer, $acc) use (&$baseIter, &$dotSymbolIter) { |
||
| 146 | if (sizeof($rest) > 0) { |
||
| 147 | list ($head, $tail) = toHeadTail($rest); |
||
| 148 | if ($head == '.') { |
||
| 149 | throw new TokenizerException("Only one dot allowed"); |
||
| 150 | } |
||
| 151 | if ($this->isSymbol($head)) { |
||
| 152 | return $dotSymbolIter($tail, $buffer . $head, $acc); |
||
| 153 | } |
||
| 154 | } |
||
| 155 | if (is_numeric($buffer)) { |
||
| 156 | $symbolToken = new Tokens\NumericToken($buffer); |
||
| 157 | } else { |
||
| 158 | $symbolToken = new Tokens\DotIdentifierToken($buffer); |
||
| 159 | } |
||
| 160 | return $baseIter($rest, append($acc, $symbolToken)); |
||
| 161 | }); |
||
| 162 | |||
| 163 | // State when parser parses string |
||
| 164 | $stringIter = tail(function ($rest, $buffer, $acc) use (&$stringIter, &$baseIter, &$escapeIter) { |
||
| 165 | if (sizeof($rest) == 0) { |
||
| 166 | throw new TokenizerException("Unexpected end of string"); |
||
| 167 | } |
||
| 168 | list ($head, $tail) = toHeadTail($rest); |
||
| 169 | if ($head == self::TOKEN_DOUBLE_QUOTE) { |
||
| 170 | return $baseIter($tail, append($acc, new Tokens\StringToken($buffer))); |
||
| 171 | } |
||
| 172 | if ($head == Tokenizer::TOKEN_BACK_SLASH) { |
||
| 173 | return $escapeIter($tail, $buffer, $acc); |
||
| 174 | } |
||
| 175 | return $stringIter($tail, $buffer . $head, $acc); |
||
| 176 | }); |
||
| 177 | |||
| 178 | // State when parser parses escaped symbol |
||
| 179 | View Code Duplication | $escapeIter = tail(function ($rest, $buffer, $acc) use (&$stringIter) { |
|
| 180 | if (sizeof($rest) == 0) { |
||
| 181 | throw new TokenizerException("Unused escape character"); |
||
| 182 | } |
||
| 183 | list ($head, $tail) = toHeadTail($rest); |
||
| 184 | return $stringIter($tail, $buffer . $head, $acc); |
||
| 185 | }); |
||
| 186 | |||
| 187 | // State when parser ignores comments |
||
| 188 | $commentIter = function ($rest, $buffer, $acc) use (&$commentIter, &$baseIter) { |
||
| 189 | if (sizeof($rest) > 0) { |
||
| 190 | list ($head, $tail) = toHeadTail($rest); |
||
| 191 | if ($head != Tokenizer::TOKEN_NEW_LINE) { |
||
| 192 | return $commentIter($tail, $buffer . $head, $acc); |
||
| 193 | } |
||
| 194 | } |
||
| 195 | return $baseIter($rest, $acc); |
||
| 196 | }; |
||
| 197 | |||
| 198 | return $baseIter(toArray($code), []); |
||
| 199 | } |
||
| 200 | } |
||
| 201 |
Loading history...
Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation.
You can also find more detailed suggestions in the “Code” section of your repository.