CSVelte\Taster::lickDelimiter()

Complexity

Conditions	9
Paths	4

Size

Total Lines	91
Code Lines	39

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	35
CRAP Score	9.3752

Importance

Changes

0

<?php
    protected function lickDelimiter($eol = "\n")
    {
        $frequencies = [];
        $consistencies = [];

        // build a table of characters and their frequencies for each line. We
        // will use this frequency table to then build a table of frequencies of
        // each frequency (in 10 lines, "tab" occurred 5 times on 7 of those
        // lines, 6 times on 2 lines, and 7 times on 1 line)
        collect(explode($eol, $this->removeQuotedStrings($this->sample)))
            ->walk(function($line, $line_no) use (&$frequencies) {
                collect(str_split($line))
                    ->filter(function($c) { return collect($this->delims)->contains($c); })
                    ->frequency()
                    ->sort()
                    ->reverse()
                    ->walk(function($count, $char) use (&$frequencies, $line_no) {
                        $frequencies[$char][$line_no] = $count;
                    });
            })
            // the above only finds frequencies for characters if they exist in
            // a given line. This will go back and fill in zeroes where a char
            // didn't occur at all in a given line (needed to determine mode)
            ->walk(function($line, $line_no) use (&$frequencies) {
                collect($frequencies)
                    ->walk(function($counts, $char) use ($line_no, &$frequencies) {
                        if (!isset($frequencies[$char][$line_no])) {
                            $frequencies[$char][$line_no] = 0;
                        }
                    });
            });

        // now determine the mode for each char to decide the "expected" amount
        // of times a char (possible delim) will occur on each line...
        $freqs = collect($frequencies);
        $modes = $freqs->mode();
        $freqs->walk(function($f, $chr) use ($modes, &$consistencies) {
            collect($f)->walk(function($num) use ($modes, $chr, &$consistencies) {
                if ($expected = $modes->get($chr)) {
                    if ($num == $expected) {
                        // met the goal, yay!
                        if (!isset($consistencies[$chr])) {
                            $consistencies[$chr] = 0;
                        }
                        $consistencies[$chr]++;
                    }
                }
            });
        });

        $delims = collect($consistencies);
        $max = $delims->max();
        $dups = $delims->duplicates();
        if ($dups->has($max, false)) {
            // if more than one candidate, then look at where the character appeared
            // in the data. Was it relatively evenly distributed or was there a
            // specific area that the character tended to appear? Dates will have a
            // consistent format (e.g. 04-23-1986) and so may easily provide a false
            // positive for delimiter. But the dash will be focused in that one area,
            // whereas the comma character is spread out. You can determine this by
            // finding out the number of chars between each occurrence and getting
            // the average. If the average is wildly different than any given distance
            // than bingo you probably aren't working with a delimiter there...

            // another option to find the delimiter if there is a tie, is to build
            // a table of character position within each line. Then use that to
            // determine if one character is consistently in the same position or
            // at least the same general area. Use the delimiter that is the most
            // consistent in that way...

            /**
             * @todo Add a method here to figure out where duplicate best-match
             *     delimiter(s) fall within each line and then, depending on
             *     which one has the best distribution, return that one.
             */

             $decision = $dups->get($max);
             try {
                 return $this->guessDelimByDistribution($decision, $eol);
             } catch (TasterException $e) {
                 // if somehow we STILL can't come to a consensus, then fall back to a
                 // "preferred delimiters" list...
                 foreach ($this->delims as $key => $val) {
                    if ($delim = array_search($val, $decision)) return $delim;
                 }
             }
        }
        return $delims
            ->sort()
            ->getKeyAtPosition(0);
    }