WordWrapper::longestWordLength() - Code Metrics - Inspection of "Refine wordwrapping columns that have very long wo..." - consolidation/output-formatters - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#45)

by Greg

created 2016-11-18 22:49 UTC

WordWrapper::longestWordLength() A

↳ Parent: WordWrapper

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	6
rs	9.4285
cc	1
eloc	4
nc	1
nop	1

<?php
namespace Consolidation\OutputFormatters\Transformations;

use Symfony\Component\Console\Helper\TableStyle;

class WordWrapper
{
    protected $width;
    protected $minimumWidths = [];

    // For now, hardcode these to match what the Symfony Table helper does.
    // Note that these might actually need to be adjusted depending on the
    // table style.
    protected $extraPaddingAtBeginningOfLine = 0;
    protected $extraPaddingAtEndOfLine = 0;
    protected $paddingInEachCell = 3;

    public function __construct($width)
    {
        $this->width = $width;
    }

    /**
     * Calculate our padding widths from the specified table style.
     * @param TableStyle $style
     */
    public function setPaddingFromStyle(TableStyle $style)
    {
        $verticalBorderLen = strlen(sprintf($style->getBorderFormat(), $style->getVerticalBorderChar()));
        $paddingLen = strlen($style->getPaddingChar());

        $this->extraPaddingAtBeginningOfLine = 0;
        $this->extraPaddingAtEndOfLine = $verticalBorderLen;
        $this->paddingInEachCell = $verticalBorderLen + $paddingLen + 1;
    }

    /**
     * If columns have minimum widths, then set them here.
     * @param array $minimumWidths
     */
    public function setMinimumWidths($minimumWidths)
    {
        $this->minimumWidths = $minimumWidths;
    }

    /**
     * Wrap the cells in each part of the provided data table
     * @param array $rows
     * @return array
     */
    public function wrap($rows, $widths = [])
    {
        // If the width was not set, then disable wordwrap.
        if (!$this->width) {
            return $rows;
        }

        // Calculate the column widths to use based on the content.
        $auto_widths = $this->columnAutowidth($rows, $widths);

        // Do wordwrap on all cells.
        $newrows = array();
        foreach ($rows as $rowkey => $row) {
            foreach ($row as $colkey => $cell) {
                $newrows[$rowkey][$colkey] = $this->wrapCell($cell, $auto_widths[$colkey]);
            }
        }

        return $newrows;
    }

    /**
     * Wrap one cell.  Guard against modifying non-strings and
     * then call through to wordwrap().
     *
     * @param mixed $cell
     * @param string $cellWidth
     * @return mixed
     */
    protected function wrapCell($cell, $cellWidth)
    {
        if (!is_string($cell)) {
            return $cell;
        }
        return wordwrap($cell, $cellWidth, "\n", true);
    }

    /**
     * Determine the best fit for column widths. Ported from Drush.
     *
     * @param array $rows The rows to use for calculations.
     * @param array $widths Manually specified widths of each column
     *   (in characters) - these will be left as is.
     */
    protected function columnAutowidth($rows, $widths)
    {
        $auto_widths = $widths;

        // First we determine the distribution of row lengths in each column.
        // This is an array of descending character length keys (i.e. starting at
        // the rightmost character column), with the value indicating the number
        // of rows where that character column is present.
        $col_dist = [];
        // We will also calculate the longest word in each column
        $max_word_lens = [];
        foreach ($rows as $rowkey => $row) {
            foreach ($row as $col_id => $cell) {
                $longest_word_len = static::longestWordLength($cell);
                if ((!isset($max_word_lens[$col_id]) || ($max_word_lens[$col_id] < $longest_word_len))) {
                    $max_word_lens[$col_id] = $longest_word_len;
                }
                if (empty($widths[$col_id])) {
                    $length = strlen($cell);
                    if ($length == 0) {
                        $col_dist[$col_id][0] = 0;
                    }
                    while ($length > 0) {
                        if (!isset($col_dist[$col_id][$length])) {
                            $col_dist[$col_id][$length] = 0;
                        }
                        $col_dist[$col_id][$length]++;
                        $length--;
                    }
                }
            }
        }

        foreach ($col_dist as $col_id => $count) {
            // Sort the distribution in decending key order.
            krsort($col_dist[$col_id]);
            // Initially we set all columns to their "ideal" longest width
            // - i.e. the width of their longest column.
            $auto_widths[$col_id] = max(array_keys($col_dist[$col_id]));
        }

        // We determine what width we have available to use, and what width the
        // above "ideal" columns take up.
        $available_width = $this->width - ($this->extraPaddingAtBeginningOfLine + $this->extraPaddingAtEndOfLine + (count($auto_widths) * $this->paddingInEachCell));
        $auto_width_current = array_sum($auto_widths);

        // If we cannot fit into the minimum width anyway, then just return
        // the max word length of each column as the 'ideal'
        $minimumIdealLength = array_sum($this->minimumWidths);
        if ($minimumIdealLength && ($available_width < $minimumIdealLength)) {
            return $max_word_lens;
        }

        // If we need to reduce a column so that we can fit the space we use this
        // loop to figure out which column will cause the "least wrapping",
        // (relative to the other columns) and reduce the width of that column.
        while ($auto_width_current > $available_width) {

            list($column, $count, $width) = $this->selectColumnToReduce($col_dist, $auto_widths, $max_word_lens);
<?php

function returnThreeValues() {
    return array('a', 'b', 'c');
}

list($a, $b, $c) = returnThreeValues();

print $a . " - " . $c;

            if (!$column || $width <= 1) {
                // If we have reached a width of 1 then give up, so wordwrap can still progress.
                break;
            }
            // Reduce the width of the selected column.
            $auto_widths[$column]--;
            // Reduce our overall table width counter.
            $auto_width_current--;
            // Remove the corresponding data from the disctribution, so next time
            // around we use the data for the row to the left.
            unset($col_dist[$column][$width]);
        }
        return $auto_widths;
    }

    protected function selectColumnToReduce($col_dist, $auto_widths, $max_word_lens)
    {
        $column = false;
        $count = 0;
        $width = 0;
        foreach ($col_dist as $col_id => $counts) {
            // Of the columns whose length is still > than the the lenght
            // of their maximum word length
            if ($auto_widths[$col_id] > $max_word_lens[$col_id]) {
                if ($this->shouldSelectThisColumn($count, $counts, $width)) {

                    $column = $col_id;
                    $count = current($counts);
                    $width = key($counts);
                }
            }
        }
        if ($column !== false) {
            return [$column, $count, $width];
        }
        foreach ($col_dist as $col_id => $counts) {
            if (empty($this->minimumWidths) || ($auto_widths[$col_id] > $this->minimumWidths[$col_id])) {
                if ($this->shouldSelectThisColumn($count, $counts, $width)) {

                    $column = $col_id;
                    $count = current($counts);
                    $width = key($counts);
                }
            }
        }
        return [$column, $count, $width];
    }

    protected function shouldSelectThisColumn($count, $counts, $width)
    {
        return
            // If we are just starting out, select the first column.
            ($count == 0) ||
            // OR: if this column would cause less wrapping than the currently
            // selected column, then select it.
            (current($counts) < $count) ||
            // OR: if this column would cause the same amount of wrapping, but is
            // longer, then we choose to wrap the longer column (proportionally
            // less wrapping, and helps avoid triple line wraps).
            (current($counts) == $count && key($counts) > $width);
    }

    /**
     * Remove from consideration any short column (max word length less than
     * 1/4th the available width, and current length <= max word length) from
     * consideration this time through the loop.  Once all columns are in this
     * state, then return all again.
     *
     * @param array $col_dist
     * @param array $auto_widths
     * @param array $max_word_lens
     * @param int $available_width
     * @return array
     */
    protected static function removeSmallColumns($col_dist, $auto_widths, $max_word_lens, $available_width)

    {
        $col_dist_subset = [];

        // Start by removing columns whose length is <= their max word length
        foreach ($col_dist as $col_id => $counts) {
            $length = $auto_widths[$col_id];
            $max_word_len = $max_word_lens[$col_id];
            if ($length > $max_word_len) {
                $col_dist_subset[$col_id] = $counts;
            }
        }
        if (!empty($col_dist_subset)) {
            return $col_dist_subset;
        }
        // Next, remove columns whose max word length is smallest -- or
        // at least smaller than the average max length.
        $average_of_max_lens = static::average($max_word_lens);

        foreach ($col_dist as $col_id => $counts) {
            if ($max_word_lens[$col_id] >= $average_of_max_lens) {
                $col_dist_subset[$col_id] = $counts;
            }
        }
        if (!empty($col_dist_subset)) {
            return $col_dist_subset;
        }
        return $col_dist;
    }

    /**
     * Return the length of the longest word in the string.
     * @param string $str
     * @return int
     */
    protected static function longestWordLength($str)
    {
        $words = preg_split('/[ -]/', $str);
        $lengths = array_map(function ($s) { return strlen($s); }, $words);
        return max($lengths);
    }
}


1		<?php
2		namespace Consolidation\OutputFormatters\Transformations;
3
4		use Symfony\Component\Console\Helper\TableStyle;
5
6		class WordWrapper
7		{
8		protected $width;
9		protected $minimumWidths = [];
10
11		// For now, hardcode these to match what the Symfony Table helper does.
12		// Note that these might actually need to be adjusted depending on the
13		// table style.
14		protected $extraPaddingAtBeginningOfLine = 0;
15		protected $extraPaddingAtEndOfLine = 0;
16		protected $paddingInEachCell = 3;
17
18		public function __construct($width)
19		{
20		$this->width = $width;
21		}
22
23		/**
24		* Calculate our padding widths from the specified table style.
25		* @param TableStyle $style
26		*/
27		public function setPaddingFromStyle(TableStyle $style)
28		{
29		$verticalBorderLen = strlen(sprintf($style->getBorderFormat(), $style->getVerticalBorderChar()));
30		$paddingLen = strlen($style->getPaddingChar());
31
32		$this->extraPaddingAtBeginningOfLine = 0;
33		$this->extraPaddingAtEndOfLine = $verticalBorderLen;
34		$this->paddingInEachCell = $verticalBorderLen + $paddingLen + 1;
35		}
36
37		/**
38		* If columns have minimum widths, then set them here.
39		* @param array $minimumWidths
40		*/
41		public function setMinimumWidths($minimumWidths)
42		{
43		$this->minimumWidths = $minimumWidths;
44		}
45
46		/**
47		* Wrap the cells in each part of the provided data table
48		* @param array $rows
49		* @return array
50		*/
51		public function wrap($rows, $widths = [])
52		{
53		// If the width was not set, then disable wordwrap.
54		if (!$this->width) {
55		return $rows;
56		}
57
58		// Calculate the column widths to use based on the content.
59		$auto_widths = $this->columnAutowidth($rows, $widths);
60
61		// Do wordwrap on all cells.
62		$newrows = array();
63		foreach ($rows as $rowkey => $row) {
64		foreach ($row as $colkey => $cell) {
65		$newrows[$rowkey][$colkey] = $this->wrapCell($cell, $auto_widths[$colkey]);
66		}
67		}
68
69		return $newrows;
70		}
71
72		/**
73		* Wrap one cell. Guard against modifying non-strings and
74		* then call through to wordwrap().
75		*
76		* @param mixed $cell
77		* @param string $cellWidth
78		* @return mixed
79		*/
80		protected function wrapCell($cell, $cellWidth)
81		{
82		if (!is_string($cell)) {
83		return $cell;
84		}
85		return wordwrap($cell, $cellWidth, "\n", true);
86		}
87
88		/**
89		* Determine the best fit for column widths. Ported from Drush.
90		*
91		* @param array $rows The rows to use for calculations.
92		* @param array $widths Manually specified widths of each column
93		* (in characters) - these will be left as is.
94		*/
95		protected function columnAutowidth($rows, $widths)
96		{
97		$auto_widths = $widths;
98
99		// First we determine the distribution of row lengths in each column.
100		// This is an array of descending character length keys (i.e. starting at
101		// the rightmost character column), with the value indicating the number
102		// of rows where that character column is present.
103		$col_dist = [];
104		// We will also calculate the longest word in each column
105		$max_word_lens = [];
106		foreach ($rows as $rowkey => $row) {
107		foreach ($row as $col_id => $cell) {
108		$longest_word_len = static::longestWordLength($cell);
109		if ((!isset($max_word_lens[$col_id]) \|\| ($max_word_lens[$col_id] < $longest_word_len))) {
110		$max_word_lens[$col_id] = $longest_word_len;
111		}
112		if (empty($widths[$col_id])) {
113		$length = strlen($cell);
114		if ($length == 0) {
115		$col_dist[$col_id][0] = 0;
116		}
117		while ($length > 0) {
118		if (!isset($col_dist[$col_id][$length])) {
119		$col_dist[$col_id][$length] = 0;
120		}
121		$col_dist[$col_id][$length]++;
122		$length--;
123		}
124		}
125		}
126		}
127
128		foreach ($col_dist as $col_id => $count) {
129		// Sort the distribution in decending key order.
130		krsort($col_dist[$col_id]);
131		// Initially we set all columns to their "ideal" longest width
132		// - i.e. the width of their longest column.
133		$auto_widths[$col_id] = max(array_keys($col_dist[$col_id]));
134		}
135
136		// We determine what width we have available to use, and what width the
137		// above "ideal" columns take up.
138		$available_width = $this->width - ($this->extraPaddingAtBeginningOfLine + $this->extraPaddingAtEndOfLine + (count($auto_widths) * $this->paddingInEachCell));
139		$auto_width_current = array_sum($auto_widths);
140
141		// If we cannot fit into the minimum width anyway, then just return
142		// the max word length of each column as the 'ideal'
143		$minimumIdealLength = array_sum($this->minimumWidths);
144		if ($minimumIdealLength && ($available_width < $minimumIdealLength)) {
145		return $max_word_lens;
146		}
147
148		// If we need to reduce a column so that we can fit the space we use this
149		// loop to figure out which column will cause the "least wrapping",
150		// (relative to the other columns) and reduce the width of that column.
151		while ($auto_width_current > $available_width) {
152
153		list($column, $count, $width) = $this->selectColumnToReduce($col_dist, $auto_widths, $max_word_lens);
		0 ignored issues – show Unused Code introduced 2016-11-18 22:51 UTC by Report Bug Copy Issue Report The assignment to `$count` is unused. Consider omitting it like so `list($first,,$third)`. This checks looks for assignemnts to variables using the `list(...)` function, where not all assigned variables are subsequently used. Consider the following code example. <?php function returnThreeValues() { return array('a', 'b', 'c'); } list($a, $b, $c) = returnThreeValues(); print $a . " - " . $c; Only the variables `$a` and `$c` are used. There was no need to assign `$b`. Instead, the list call could have been. list($a,, $c) = returnThreeValues(); Loading history...
154
155		if (!$column \|\| $width <= 1) {
156		// If we have reached a width of 1 then give up, so wordwrap can still progress.
157		break;
158		}
159		// Reduce the width of the selected column.
160		$auto_widths[$column]--;
161		// Reduce our overall table width counter.
162		$auto_width_current--;
163		// Remove the corresponding data from the disctribution, so next time
164		// around we use the data for the row to the left.
165		unset($col_dist[$column][$width]);
166		}
167		return $auto_widths;
168		}
169
170		protected function selectColumnToReduce($col_dist, $auto_widths, $max_word_lens)
171		{
172		$column = false;
173		$count = 0;
174		$width = 0;
175		foreach ($col_dist as $col_id => $counts) {
176		// Of the columns whose length is still > than the the lenght
177		// of their maximum word length
178		if ($auto_widths[$col_id] > $max_word_lens[$col_id]) {
179	View Code Duplication	if ($this->shouldSelectThisColumn($count, $counts, $width)) {
		0 ignored issues – show Duplication introduced 2016-11-18 22:51 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. 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. Loading history...
180		$column = $col_id;
181		$count = current($counts);
182		$width = key($counts);
183		}
184		}
185		}
186		if ($column !== false) {
187		return [$column, $count, $width];
188		}
189		foreach ($col_dist as $col_id => $counts) {
190		if (empty($this->minimumWidths) \|\| ($auto_widths[$col_id] > $this->minimumWidths[$col_id])) {
191	View Code Duplication	if ($this->shouldSelectThisColumn($count, $counts, $width)) {
		0 ignored issues – show Duplication introduced 2016-11-18 22:51 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. 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. Loading history...
192		$column = $col_id;
193		$count = current($counts);
194		$width = key($counts);
195		}
196		}
197		}
198		return [$column, $count, $width];
199		}
200
201		protected function shouldSelectThisColumn($count, $counts, $width)
202		{
203		return
204		// If we are just starting out, select the first column.
205		($count == 0) \|\|
206		// OR: if this column would cause less wrapping than the currently
207		// selected column, then select it.
208		(current($counts) < $count) \|\|
209		// OR: if this column would cause the same amount of wrapping, but is
210		// longer, then we choose to wrap the longer column (proportionally
211		// less wrapping, and helps avoid triple line wraps).
212		(current($counts) == $count && key($counts) > $width);
213		}
214
215		/**
216		* Remove from consideration any short column (max word length less than
217		* 1/4th the available width, and current length <= max word length) from
218		* consideration this time through the loop. Once all columns are in this
219		* state, then return all again.
220		*
221		* @param array $col_dist
222		* @param array $auto_widths
223		* @param array $max_word_lens
224		* @param int $available_width
225		* @return array
226		*/
227		protected static function removeSmallColumns($col_dist, $auto_widths, $max_word_lens, $available_width)
		0 ignored issues – show Unused Code introduced 2016-11-18 22:51 UTC by Report Bug Copy Issue Report The parameter `$available_width` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
228		{
229		$col_dist_subset = [];
230
231		// Start by removing columns whose length is <= their max word length
232		foreach ($col_dist as $col_id => $counts) {
233		$length = $auto_widths[$col_id];
234		$max_word_len = $max_word_lens[$col_id];
235		if ($length > $max_word_len) {
236		$col_dist_subset[$col_id] = $counts;
237		}
238		}
239		if (!empty($col_dist_subset)) {
240		return $col_dist_subset;
241		}
242		// Next, remove columns whose max word length is smallest -- or
243		// at least smaller than the average max length.
244		$average_of_max_lens = static::average($max_word_lens);
		0 ignored issues – show Bug introduced 2016-11-18 22:51 UTC by Report Bug Copy Issue Report The method `average()` does not seem to exist on `object<Consolidation\Out...formations\WordWrapper>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
245		foreach ($col_dist as $col_id => $counts) {
246		if ($max_word_lens[$col_id] >= $average_of_max_lens) {
247		$col_dist_subset[$col_id] = $counts;
248		}
249		}
250		if (!empty($col_dist_subset)) {
251		return $col_dist_subset;
252		}
253		return $col_dist;
254		}
255
256		/**
257		* Return the length of the longest word in the string.
258		* @param string $str
259		* @return int
260		*/
261		protected static function longestWordLength($str)
262		{
263		$words = preg_split('/[ -]/', $str);
264		$lengths = array_map(function ($s) { return strlen($s); }, $words);
265		return max($lengths);
266		}
267		}
268

consolidation / output-formatters

Pull Request — master (#45)

WordWrapper::longestWordLength() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like