AbstractDiff::convertHtmlToListOfWords() - Code Metrics - Inspection of "Merge pull request #24 from caxy/feature/list-diff..." - caxy/php-htmldiff - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 24da9e...18bd75 )

by Josh

created 2016-01-12 19:35 UTC

AbstractDiff::convertHtmlToListOfWords() C

↳ Parent: AbstractDiff

Complexity

Conditions	22
Paths	32

Size

Total Lines	74
Code Lines	57

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	74
rs	5.3019
cc	22
eloc	57
nc	32
nop	1

How to fix Long Method Complexity

<?php

namespace Caxy\HtmlDiff;

abstract class AbstractDiff
{
    public static $defaultSpecialCaseTags = array('strong', 'b', 'i', 'big', 'small', 'u', 'sub', 'sup', 'strike', 's', 'p');
$a = "a";
$ab = "ab";
$abc = "abc";
    public static $defaultSpecialCaseChars = array('.', ',', '(', ')', '\'');
    public static $defaultGroupDiffs = true;
$a = "a";
$ab = "ab";
$abc = "abc";

    protected $content;
    protected $oldText;
    protected $newText;
    protected $oldWords = array();
    protected $newWords = array();
    protected $encoding;
    protected $specialCaseOpeningTags = array();
    protected $specialCaseClosingTags = array();
    protected $specialCaseTags;
    protected $specialCaseChars;
    protected $groupDiffs;
    protected $matchThreshold = 80;

    public function __construct($oldText, $newText, $encoding = 'UTF-8', $specialCaseTags = null, $groupDiffs = null)
    {
        if ($specialCaseTags === null) {
            $specialCaseTags = static::$defaultSpecialCaseTags;
        }

        if ($groupDiffs === null) {
            $groupDiffs = static::$defaultGroupDiffs;
        }

        $this->oldText = $this->purifyHtml(trim($oldText));
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->newText = $this->purifyHtml(trim($newText));
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->encoding = $encoding;
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->content = '';
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->groupDiffs = $groupDiffs;
        $this->setSpecialCaseTags($specialCaseTags);
        $this->setSpecialCaseChars(static::$defaultSpecialCaseChars);
    }

    /**
     * @return int
     */
    public function getMatchThreshold()
    {
        return $this->matchThreshold;
    }

    /**
     * @param int $matchThreshold
     *
     * @return AbstractDiff
     */
    public function setMatchThreshold($matchThreshold)
    {
        $this->matchThreshold = $matchThreshold;

        return $this;
    }



    public function setSpecialCaseChars(array $chars)
    {
        $this->specialCaseChars = $chars;
    }

    public function getSpecialCaseChars()
    {
        return $this->specialCaseChars;
    }

    public function addSpecialCaseChar($char)
    {
        if (!in_array($char, $this->specialCaseChars)) {
            $this->specialCaseChars[] = $char;
        }
    }

    public function removeSpecialCaseChar($char)
    {
        $key = array_search($char, $this->specialCaseChars);
        if ($key !== false) {
            unset($this->specialCaseChars[$key]);
        }
    }

    public function setSpecialCaseTags(array $tags = array())
    {
        $this->specialCaseTags = $tags;

        foreach ($this->specialCaseTags as $tag) {
            $this->addSpecialCaseTag($tag);
        }
    }

    public function addSpecialCaseTag($tag)
    {
        if (!in_array($tag, $this->specialCaseTags)) {
            $this->specialCaseTags[] = $tag;
        }

        $opening = $this->getOpeningTag($tag);
        $closing = $this->getClosingTag($tag);

        if (!in_array($opening, $this->specialCaseOpeningTags)) {
            $this->specialCaseOpeningTags[] = $opening;
        }
        if (!in_array($closing, $this->specialCaseClosingTags)) {
            $this->specialCaseClosingTags[] = $closing;
        }
    }

    public function removeSpecialCaseTag($tag)
    {
        if (($key = array_search($tag, $this->specialCaseTags)) !== false) {
            unset($this->specialCaseTags[$key]);

            $opening = $this->getOpeningTag($tag);
            $closing = $this->getClosingTag($tag);

            if (($key = array_search($opening, $this->specialCaseOpeningTags)) !== false) {
                unset($this->specialCaseOpeningTags[$key]);
            }
            if (($key = array_search($closing, $this->specialCaseClosingTags)) !== false) {
                unset($this->specialCaseClosingTags[$key]);
            }
        }
    }

    public function getSpecialCaseTags()
    {
        return $this->specialCaseTags;
    }

    public function getOldHtml()

    {
        return $this->oldText;
    }

    public function getNewHtml()

    {
        return $this->newText;
    }

    public function getDifference()
    {
        return $this->content;
    }

    public function setGroupDiffs($boolean)
    {
        $this->groupDiffs = $boolean;
    }

    public function isGroupDiffs()

    {
        return $this->groupDiffs;
    }

    protected function getOpeningTag($tag)
    {
        return "/<".$tag."[^>]*/i";
    }

    protected function getClosingTag($tag)
    {
        return "</".$tag.">";
    }

    protected function getStringBetween($str, $start, $end)
    {
        $expStr = explode( $start, $str, 2 );
        if ( count( $expStr ) > 1 ) {
            $expStr = explode( $end, $expStr[ 1 ] );
            if ( count( $expStr ) > 1 ) {
                array_pop( $expStr );

                return implode( $end, $expStr );
            }
        }

        return '';
    }

    protected function purifyHtml($html, $tags = null)

    {
        if ( class_exists( 'Tidy' ) && false ) {
            $config = array( 'output-xhtml'   => true, 'indent' => false );
            $tidy = new tidy();
$a = "a";
$ab = "ab";
$abc = "abc";
            $tidy->parseString( $html, $config, 'utf8' );
            $html = (string) $tidy;

            return $this->getStringBetween( $html, '<body>' );

        }

        return $html;
    }

    protected function splitInputsToWords()
    {
        $this->oldWords = $this->convertHtmlToListOfWords( $this->explode( $this->oldText ) );
        $this->newWords = $this->convertHtmlToListOfWords( $this->explode( $this->newText ) );
    }

    protected function isPartOfWord($text)
    {
        return ctype_alnum(str_replace($this->specialCaseChars, '', $text));
    }

    protected function convertHtmlToListOfWords($characterString)
    {
        $mode = 'character';
$a = "a";
$ab = "ab";
$abc = "abc";
        $current_word = '';

        $words = array();
$a = "a";
$ab = "ab";
$abc = "abc";
        foreach ($characterString as $i => $character) {
            switch ($mode) {
                case 'character':
                if ( $this->isStartOfTag( $character ) ) {
                    if ($current_word != '') {

                        $words[] = $current_word;

                    }
                    $current_word = "<";

                    $mode = 'tag';
$a = "a";
$ab = "ab";
$abc = "abc";
                } elseif ( preg_match( "[^\s]", $character ) > 0 ) {
                    if ($current_word != '') {

                        $words[] = $current_word;

                    }
                    $current_word = $character;

                    $mode = 'whitespace';
$a = "a";
$ab = "ab";
$abc = "abc";
                } else {
                    if (
                        (ctype_alnum($character) && (strlen($current_word) == 0 || $this->isPartOfWord($current_word))) ||

                        (in_array($character, $this->specialCaseChars) && isset($characterString[$i+1]) && $this->isPartOfWord($characterString[$i+1]))
                    ) {
                        $current_word .= $character;

                    } else {
                        $words[] = $current_word;
$a = "a";
$ab = "ab";
$abc = "abc";
                        $current_word = $character;

                    }
                }
                break;
                case 'tag' :
switch ($selector) {
    case "A": //right
        doSomething();
        break;
    case "B" : //wrong
        doSomethingElse();
        break;
}
                if ( $this->isEndOfTag( $character ) ) {
                    $current_word .= ">";

                    $words[] = $current_word;
$a = "a";
$ab = "ab";
$abc = "abc";
                    $current_word = "";
$a = "a";
$ab = "ab";
$abc = "abc";

                    if ( !preg_match('[^\s]', $character ) ) {
                        $mode = 'whitespace';
                    } else {
                        $mode = 'character';
                    }
                } else {
                    $current_word .= $character;

                }
                break;
                case 'whitespace':
                if ( $this->isStartOfTag( $character ) ) {
                    if ($current_word != '') {

                        $words[] = $current_word;

                    }
                    $current_word = "<";

                    $mode = 'tag';
$a = "a";
$ab = "ab";
$abc = "abc";
                } elseif ( preg_match( "[^\s]", $character ) ) {
                    $current_word .= $character;

                } else {
                    if ($current_word != '') {

                        $words[] = $current_word;

                    }
                    $current_word = $character;

                    $mode = 'character';
$a = "a";
$ab = "ab";
$abc = "abc";
                }
                break;
                default:
                break;
            }
        }
        if ($current_word != '') {

            $words[] = $current_word;

        }

        return $words;
    }

    protected function isStartOfTag($val)
    {
        return $val == "<";
    }

    protected function isEndOfTag($val)
    {
        return $val == ">";
    }

    protected function isWhiteSpace($value)
    {
        return !preg_match( '[^\s]', $value );
    }

    protected function explode($value)
    {
        // as suggested by @onassar
        return preg_split( '//u', $value );
    }
}


1			<?php
2
3			namespace Caxy\HtmlDiff;
4
5			abstract class AbstractDiff
6			{
7			public static $defaultSpecialCaseTags = array('strong', 'b', 'i', 'big', 'small', 'u', 'sub', 'sup', 'strike', 's', 'p');
			0 ignored issues – show Coding Style introduced 2015-11-24 18:02 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
8			public static $defaultSpecialCaseChars = array('.', ',', '(', ')', '\'');
9			public static $defaultGroupDiffs = true;
			0 ignored issues – show Coding Style introduced 2015-11-24 18:02 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
10
11			protected $content;
12			protected $oldText;
13			protected $newText;
14			protected $oldWords = array();
15			protected $newWords = array();
16			protected $encoding;
17			protected $specialCaseOpeningTags = array();
18			protected $specialCaseClosingTags = array();
19			protected $specialCaseTags;
20			protected $specialCaseChars;
21			protected $groupDiffs;
22			protected $matchThreshold = 80;
23
24			public function __construct($oldText, $newText, $encoding = 'UTF-8', $specialCaseTags = null, $groupDiffs = null)
25			{
26			if ($specialCaseTags === null) {
27			$specialCaseTags = static::$defaultSpecialCaseTags;
28			}
29
30			if ($groupDiffs === null) {
31			$groupDiffs = static::$defaultGroupDiffs;
32			}
33
34			$this->oldText = $this->purifyHtml(trim($oldText));
			0 ignored issues – show Coding Style introduced 2015-11-24 18:02 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
35			$this->newText = $this->purifyHtml(trim($newText));
			0 ignored issues – show Coding Style introduced 2015-11-24 18:02 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
36			$this->encoding = $encoding;

caxy / php-htmldiff

Push — master ( 24da9e...18bd75 )

AbstractDiff::convertHtmlToListOfWords() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like