Complex classes like Taster 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 Taster, and based on these observations, apply Extract Interface, too.
1 | <?php |
||
52 | class Taster |
||
53 | { |
||
54 | /** |
||
55 | * End-of-line constants |
||
56 | */ |
||
57 | const EOL_UNIX = 'lf'; |
||
58 | const EOL_TRS80 = 'cr'; |
||
59 | const EOL_WINDOWS = 'crlf'; |
||
60 | |||
61 | /** |
||
62 | * ASCII character codes for "invisibles" |
||
63 | */ |
||
64 | const HORIZONTAL_TAB = 9; |
||
65 | const LINE_FEED = 10; |
||
66 | const CARRIAGE_RETURN = 13; |
||
67 | const SPACE = 32; |
||
68 | |||
69 | /** |
||
70 | * Data types -- Used within the lickQuotingStyle method |
||
71 | */ |
||
72 | const DATA_NONNUMERIC = 'nonnumeric'; |
||
73 | const DATA_SPECIAL = 'special'; |
||
74 | const DATA_UNKNOWN = 'unknown'; |
||
75 | |||
76 | /** |
||
77 | * Placeholder strings -- hold the place of newlines and delimiters contained |
||
78 | * within quoted text so that the explode method doesn't split incorrectly |
||
79 | */ |
||
80 | const PLACEHOLDER_NEWLINE = '[__NEWLINE__]'; |
||
81 | const PLACEHOLDER_DELIM = '[__DELIM__]'; |
||
82 | |||
83 | /** |
||
84 | * Recommended data sample size |
||
85 | */ |
||
86 | const SAMPLE_SIZE = 2500; |
||
87 | |||
88 | /** |
||
89 | * Column data types -- used within the lickHeader method to determine |
||
90 | * whether the first row contains different types of data than the rest of |
||
91 | * the rows (and thus, is likely a header row) |
||
92 | */ |
||
93 | // +-987 |
||
94 | const TYPE_NUMBER = 'number'; |
||
95 | // +-12.387 |
||
96 | const TYPE_DOUBLE = 'double'; |
||
97 | // I am a string. I can contain all kinds of stuff. |
||
98 | const TYPE_STRING = 'string'; |
||
99 | // 2010-04-23 04:23:00 |
||
100 | const TYPE_DATETIME = 'datetime'; |
||
101 | // 10-Jul-15, 9/1/2007, April 1st, 2006, etc. |
||
102 | const TYPE_DATE = 'date'; |
||
103 | // 10:00pm, 5pm, 13:08, etc. |
||
104 | const TYPE_TIME = 'time'; |
||
105 | // $98.96, ¥12389, £6.08, €87.00 |
||
106 | const TYPE_CURRENCY = 'currency'; |
||
107 | // 12ab44m1n2_asdf |
||
108 | const TYPE_ALNUM = 'alnum'; |
||
109 | // abababab |
||
110 | const TYPE_ALPHA = 'alpha'; |
||
111 | |||
112 | /** @var Contract\Streamable The source of data to examine */ |
||
113 | protected $input; |
||
114 | |||
115 | /** @var string Sample of CSV data to use for tasting (determining CSV flavor) */ |
||
116 | protected $sample; |
||
117 | |||
118 | /** @var array Possible delimiter characters in (roughly) the order of likelihood */ |
||
119 | protected $delims = [",", "\t", ";", "|", ":", "-", "_", "#", "/", '\\', '$', '+', '=', '&', '@']; |
||
120 | |||
121 | /** |
||
122 | * Class constructor--accepts a CSV input source |
||
123 | * |
||
124 | * @param Contract\Streamable The source of CSV data |
||
125 | * @throws TasterException |
||
126 | * @todo It may be a good idea to skip the first line or two for the sample |
||
127 | * so that the header line(s) don't throw things off (with the exception |
||
128 | * of lickHeader() obviously) |
||
129 | */ |
||
130 | 22 | public function __construct(Streamable $input) |
|
137 | |||
138 | /** |
||
139 | * "Invoke" magic method. |
||
140 | * |
||
141 | * Called when an object is invoked as if it were a function. So, for instance, |
||
142 | * This is simply an alias to the lick method. |
||
143 | * |
||
144 | * @return Flavor A flavor object |
||
145 | * @throws TasterException |
||
146 | */ |
||
147 | 20 | public function __invoke() |
|
151 | |||
152 | /** |
||
153 | * Examine the input source and determine what "Flavor" of CSV it contains. |
||
154 | * The CSV format, while having an RFC (https://tools.ietf.org/html/rfc4180), |
||
155 | * doesn't necessarily always conform to it. And it doesn't provide meta such as the delimiting character, quote character, or what types of data are quoted. |
||
156 | * such as the delimiting character, quote character, or what types of data are quoted. |
||
157 | * are quoted. |
||
158 | * |
||
159 | * @return Flavor The metadata that the CSV format doesn't provide |
||
160 | * @throws TasterException |
||
161 | * @todo Implement a lickQuote method for when lickQuoteAndDelim method fails |
||
162 | * @todo Should there bea lickEscapeChar method? the python module that inspired |
||
163 | * this library doesn't include one... |
||
164 | * @todo This should cache the results and only regenerate if $this->sample |
||
165 | * changes (or $this->input) |
||
166 | */ |
||
167 | 21 | public function lick() |
|
185 | |||
186 | /** |
||
187 | * Replaces all quoted columns with a blank string. I was using this method |
||
188 | * to prevent explode() from incorrectly splitting at delimiters and newlines |
||
189 | * within quotes when parsing a file. But this was before I wrote the |
||
190 | * replaceQuotedSpecialChars method which (at least to me) makes more sense. |
||
191 | * |
||
192 | * @param string $data The string to replace quoted strings within |
||
193 | * @return string The input string with quoted strings removed |
||
194 | * @todo Replace code that uses this method with the replaceQuotedSpecialChars |
||
195 | * method instead. I think it's cleaner. |
||
196 | */ |
||
197 | 21 | protected function removeQuotedStrings($data) |
|
201 | |||
202 | /** |
||
203 | * Examine the input source to determine which character(s) are being used |
||
204 | * as the end-of-line character |
||
205 | * |
||
206 | * @return string The end-of-line char for the input data |
||
207 | * @credit pulled from stackoverflow thread *tips hat to username "Harm"* |
||
208 | * @todo This should throw an exception if it cannot determine the line ending |
||
209 | * @todo I probably will make this method protected when I'm done with testing... |
||
210 | * @todo If there is any way for this method to fail (for instance if a file ) |
||
211 | * is totally empty or contains no line breaks), then it needs to throw |
||
212 | * a relevant TasterException |
||
213 | * @todo Use replaceQuotedSpecialChars rather than removeQuotedStrings() |
||
214 | */ |
||
215 | 21 | protected function lickLineEndings() |
|
235 | |||
236 | /** |
||
237 | * The best way to determine quote and delimiter characters is when columns |
||
238 | * are quoted, often you can seek out a pattern of delim, quote, stuff, quote, delim |
||
239 | * but this only works if you have quoted columns. If you don't you have to |
||
240 | * determine these characters some other way... (see lickDelimiter) |
||
241 | * |
||
242 | * @return array A two-row array containing quotechar, delimchar |
||
243 | * @throws TasterException |
||
244 | * @todo make protected |
||
245 | * @todo This should throw an exception if it cannot determine the delimiter |
||
246 | * this way. |
||
247 | * @todo This should check for any line endings not just \n |
||
248 | */ |
||
249 | 21 | protected function lickQuoteAndDelim() |
|
294 | |||
295 | /** |
||
296 | * Take a list of likely delimiter characters and find the one that occurs |
||
297 | * the most consistent amount of times within the provided data. |
||
298 | * |
||
299 | * @param string $eol The character(s) used for newlines |
||
300 | * @return string One of four Flavor::QUOTING_* constants |
||
301 | * @see Flavor for possible quote style constants |
||
302 | * @todo Refactor this method--It needs more thorough testing against a wider |
||
303 | * variety of CSV data to be sure it works reliably. And I'm sure there |
||
304 | * are many performance and logic improvements that could be made. This |
||
305 | * is essentially a first draft. |
||
306 | * @todo Can't use replaceQuotedSpecialChars rather than removeQuotedStrings |
||
307 | * because the former requires u to know the delimiter |
||
308 | */ |
||
309 | 6 | protected function lickDelimiter($eol = "\n") |
|
400 | |||
401 | /** |
||
402 | * Compare positional consistency of several characters to determine the |
||
403 | * probable delimiter character. The idea behind this is that the delimiter |
||
404 | * character is likely more consistently distributed than false-positive |
||
405 | * delimiter characters produced by lickDelimiter(). For instance, consider |
||
406 | * a series of rows similar to the following: |
||
407 | * |
||
408 | * 1,luke,visinoni,[email protected],(530) 413-3076,04-23-1986 |
||
409 | * |
||
410 | * The lickDelimiter() method will often not be able to determine whether the |
||
411 | * delimiter is a comma or a dash because they occur the same number of times |
||
412 | * on just about every line (5 for comma, 3 for dash). The difference is |
||
413 | * obvious to you, no doubt. But us humans are pattern-recognition machines! |
||
414 | * The difference between the comma and the dash are that the comma is dist- |
||
415 | * ributed almost evenly throughout the line. The dash characters occur |
||
416 | * entirely at the end of the line. This method accepts any number of possible |
||
417 | * delimiter characters and returns the one that is distributed |
||
418 | * |
||
419 | * If delim character cannot be determined by lickQuoteAndDelim(), taster |
||
420 | * tries lickDelimiter(). When that method runs into a tie, it will use this |
||
421 | * as a tie-breaker. |
||
422 | * |
||
423 | * @param array $delims Possible delimiter characters (method chooses from |
||
424 | * this array of characters) |
||
425 | * @param string $eol The end-of-line character (or set of characters) |
||
426 | * @return string The probable delimiter character |
||
427 | * @throws TasterException |
||
428 | */ |
||
429 | protected function guessDelimByDistribution(array $delims, $eol = "\n") |
||
459 | |||
460 | /** |
||
461 | * Determine the "style" of data quoting. The CSV format, while having an RFC |
||
462 | * (https://tools.ietf.org/html/rfc4180), doesn't necessarily always conform |
||
463 | * to it. And it doesn't provide metadata such as the delimiting character, |
||
464 | * quote character, or what types of data are quoted. So this method makes a |
||
465 | * logical guess by finding which columns have been quoted (if any) and |
||
466 | * examining their data type. Most often, CSV files will only use quotes |
||
467 | * around columns that contain special characters such as the dilimiter, |
||
468 | * the quoting character, newlines, etc. (we refer to this style as ) |
||
469 | * QUOTE_MINIMAL), but some quote all columns that contain nonnumeric data |
||
470 | * (QUOTE_NONNUMERIC). Then there are CSV files that quote all columns |
||
471 | * (QUOTE_ALL) and those that quote none (QUOTE_NONE). |
||
472 | * |
||
473 | * @param string $delim The character used as the column delimiter |
||
474 | * @param string $eol The character used for newlines |
||
475 | * @return string One of four "QUOTING_" constants defined above--see this |
||
476 | * method's description for more info. |
||
477 | * @todo Refactor this method--It needs more thorough testing against a wider |
||
478 | * variety of CSV data to be sure it works reliably. And I'm sure there |
||
479 | * are many performance and logic improvements that could be made. This |
||
480 | * is essentially a first draft. |
||
481 | */ |
||
482 | 21 | protected function lickQuotingStyle($delim, $eol) |
|
549 | |||
550 | /** |
||
551 | * Remove quotes around a piece of text (if there are any) |
||
552 | * |
||
553 | * @param string $data The data to "unquote" |
||
554 | * @return string The data passed in, only with quotes stripped (off the edges) |
||
555 | */ |
||
556 | 21 | protected function unQuote($data) |
|
560 | |||
561 | /** |
||
562 | * Determine whether a particular string of data has quotes around it. |
||
563 | * |
||
564 | * @param string $data The data to check |
||
565 | * @return boolean Whether the data is quoted or not |
||
566 | */ |
||
567 | 21 | protected function isQuoted($data) |
|
571 | |||
572 | /** |
||
573 | * Determine what type of data is contained within a variable |
||
574 | * Possible types: |
||
575 | * - nonnumeric - only numbers |
||
576 | * - special - contains characters that could potentially need to be quoted (possible delimiter characters) |
||
577 | * - unknown - everything else |
||
578 | * This method is really only used within the "lickQuotingStyle" method to |
||
579 | * help determine whether a particular column has been quoted due to it being |
||
580 | * nonnumeric or because it has some special character in it such as a delimiter |
||
581 | * or newline or quote. |
||
582 | * |
||
583 | * @param string $data The data to determine the type of |
||
584 | * @return string The type of data (one of the "DATA_" constants above) |
||
585 | * @todo I could probably eliminate this method and use an anonymous function |
||
586 | * instead. It isn't used anywhere else and its name could be misleading. |
||
587 | * Especially since I also have a lickType method that is used within the |
||
588 | * lickHeader method. |
||
589 | */ |
||
590 | 21 | protected function lickDataType($data) |
|
601 | |||
602 | /** |
||
603 | * Replace all instances of newlines and whatever character you specify (as |
||
604 | * the delimiter) that are contained within quoted text. The replacements are |
||
605 | * simply a special placeholder string. This is done so that I can use the |
||
606 | * very unsmart "explode" function and not have to worry about it exploding |
||
607 | * on delimiters or newlines within quotes. Once I have exploded, I typically |
||
608 | * sub back in the real characters before doing anything else. Although |
||
609 | * currently there is no dedicated method for doing so I just use str_replace |
||
610 | * |
||
611 | * @param string $data The string to do the replacements on |
||
612 | * @param string $delim The delimiter character to replace |
||
613 | * @return string The data with replacements performed |
||
614 | * @todo I could probably pass in (maybe optionally) the newline character I |
||
615 | * want to replace as well. I'll do that if I need to. |
||
616 | */ |
||
617 | 21 | protected function replaceQuotedSpecialChars($data, $delim) |
|
625 | |||
626 | /** |
||
627 | * Determine the "type" of a particular string of data. Used for the lickHeader |
||
628 | * method to assign a type to each column to try to determine whether the |
||
629 | * first for is different than a consistent column type. |
||
630 | * |
||
631 | * @todo As I'm writing this method I'm beginning ot realize how expensive |
||
632 | * the lickHeader method is going to end up being since it has to apply all |
||
633 | * these regexes (potentially) to every column. I may end up writing a much |
||
634 | * simpler type-checking method than this if it proves to be too expensive |
||
635 | * to be practical. |
||
636 | * |
||
637 | * @param string $data The string of data to check the type of |
||
638 | * @return string One of the TYPE_ string constants above |
||
639 | */ |
||
640 | 21 | protected function lickType($data) |
|
684 | |||
685 | /** |
||
686 | * Examines the contents of the CSV data to make a determination of whether |
||
687 | * or not it contains a header row. To make this determination, it creates |
||
688 | * an array of each column's (in each row)'s data type and length and then |
||
689 | * compares them. If all of the rows except the header look similar, it will |
||
690 | * return true. This is only a guess though. There is no programmatic way to |
||
691 | * determine 100% whether a CSV file has a header. The format does not |
||
692 | * provide metadata such as that. |
||
693 | * |
||
694 | * @param string $delim The CSV data's delimiting char (can be a variety of chars but) |
||
695 | * typically is either a comma or a tab, sometimes a pipe) |
||
696 | * @param string $eol The CSV data's end-of-line char(s) (\n \r or \r\n) |
||
697 | * @return boolean True if the data (most likely) contains a header row |
||
698 | * @todo This method needs a total refactor. It's not necessary to loop twice |
||
699 | * You could get away with one loop and that would allow for me to do |
||
700 | * something like only examining enough rows to get to a particular |
||
701 | * "hasHeader" score (+-100 for instance) & then just return true|false |
||
702 | * @todo Also, break out of the first loop after a certain (perhaps even a |
||
703 | * configurable) amount of lines (you only need to examine so much data ) |
||
704 | * to reliably make a determination and this is an expensive method) |
||
705 | * @todo I could remove the need for quote, delim, and eol by "licking" the |
||
706 | * data sample provided in the first argument. Also, I could actually |
||
707 | * create a Reader object to read the data here. |
||
708 | */ |
||
709 | 22 | public function lickHeader($delim, $eol) |
|
757 | } |
||
758 |