Sign upLogin

elboletaire/Watimage

View on GitHub
Star
src/Normalize.php

Summary

Maintainability
D
1 day
Test Coverage

The class Normalize has an overall complexity of 72 which is very high. The configured complexity threshold is 50.
Open

class Normalize
{
    /**
     * Returns the proper color array for the given color.
     *
Severity: Minor
Found in src/Normalize.php by phpmd

Method color has 61 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    public static function color($color)
    {
        if ($color === Image::COLOR_TRANSPARENT) {
            return [
                'r' => 0,
Severity: Major
Found in src/Normalize.php - About 2 hrs to fix

    File Normalize.php has 260 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    <?php
namespace Elboletaire\Watimage;

use Elboletaire\Watimage\Exception\InvalidArgumentException;
    Severity: Minor
    Found in src/Normalize.php - About 2 hrs to fix

      Function size has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
      Open

          public static function size($width, $height = null)
    {
        if (!isset($height) && is_array($width)) {
            $allowedKeys = [
                [0, 1],
      Severity: Minor
      Found in src/Normalize.php - About 2 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function color has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
      Open

          public static function color($color)
    {
        if ($color === Image::COLOR_TRANSPARENT) {
            return [
                'r' => 0,
      Severity: Minor
      Found in src/Normalize.php - About 1 hr to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Method cropMeasures has 32 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          public static function cropMeasures($ox, $oy = null, $dx = null, $dy = null)
    {
        if (!isset($oy, $dx, $dy, $width, $height) && is_array($ox)) {
            $values = $ox;
            $allowedKeys = [
      Severity: Minor
      Found in src/Normalize.php - About 1 hr to fix

        Method size has 31 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            public static function size($width, $height = null)
    {
        if (!isset($height) && is_array($width)) {
            $allowedKeys = [
                [0, 1],
        Severity: Minor
        Found in src/Normalize.php - About 1 hr to fix

          Function position has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
          Open

              public static function position($x, $y = null)
    {
        if (is_array($x)) {
            if (isset($x['x']) || isset($x['y'])) {
                extract($x);
          Severity: Minor
          Found in src/Normalize.php - About 1 hr to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Method crop has 26 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              public static function crop($x, $y = null, $width = null, $height = null)
    {
        if (!isset($y, $width, $height) && is_array($x)) {
            $values = $x;
            $allowedKeys = [
          Severity: Minor
          Found in src/Normalize.php - About 1 hr to fix

            Function cropMeasures has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
            Open

                public static function cropMeasures($ox, $oy = null, $dx = null, $dy = null)
    {
        if (!isset($oy, $dx, $dy, $width, $height) && is_array($ox)) {
            $values = $ox;
            $allowedKeys = [
            Severity: Minor
            Found in src/Normalize.php - About 55 mins to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function crop has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
            Open

                public static function crop($x, $y = null, $width = null, $height = null)
    {
        if (!isset($y, $width, $height) && is_array($x)) {
            $values = $x;
            $allowedKeys = [
            Severity: Minor
            Found in src/Normalize.php - About 45 mins to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function cssPosition has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
            Open

                public static function cssPosition($position)
    {
        try {
            $position = self::position($position);
        } catch (InvalidArgumentException $e) {
            Severity: Minor
            Found in src/Normalize.php - About 35 mins to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            The method color() has an NPath complexity of 336. The configured NPath complexity threshold is 200.
            Open

                public static function color($color)
    {
        if ($color === Image::COLOR_TRANSPARENT) {
            return [
                'r' => 0,
            Severity: Minor
            Found in src/Normalize.php by phpmd

            NPathComplexity

            Since: 0.1

            The NPath complexity of a method is the number of acyclic execution paths through that method. A threshold of 200 is generally considered the point where measures should be taken to reduce complexity.

            Example

            class Foo {
    function bar() {
        // lots of complicated code
    }
}

            Source https://phpmd.org/rules/codesize.html#npathcomplexity

            The method color() has a Cyclomatic Complexity of 12. The configured cyclomatic complexity threshold is 10.
            Open

                public static function color($color)
    {
        if ($color === Image::COLOR_TRANSPARENT) {
            return [
                'r' => 0,
            Severity: Minor
            Found in src/Normalize.php by phpmd

            CyclomaticComplexity

            Since: 0.1

            Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.

            Example

            // Cyclomatic Complexity = 11
class Foo {
1   public function example() {
2       if ($a == $b) {
3           if ($a1 == $b1) {
                fiddle();
4           } elseif ($a2 == $b2) {
                fiddle();
            } else {
                fiddle();
            }
5       } elseif ($c == $d) {
6           while ($c == $d) {
                fiddle();
            }
7        } elseif ($e == $f) {
8           for ($n = 0; $n < $h; $n++) {
                fiddle();
            }
        } else {
            switch ($z) {
9               case 1:
                    fiddle();
                    break;
10              case 2:
                    fiddle();
                    break;
11              case 3:
                    fiddle();
                    break;
                default:
                    fiddle();
                    break;
            }
        }
    }
}

            Source https://phpmd.org/rules/codesize.html#cyclomaticcomplexity

            The method size() has a Cyclomatic Complexity of 11. The configured cyclomatic complexity threshold is 10.
            Open

                public static function size($width, $height = null)
    {
        if (!isset($height) && is_array($width)) {
            $allowedKeys = [
                [0, 1],
            Severity: Minor
            Found in src/Normalize.php by phpmd

            CyclomaticComplexity

            Since: 0.1

            Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.

            Example

            // Cyclomatic Complexity = 11
class Foo {
1   public function example() {
2       if ($a == $b) {
3           if ($a1 == $b1) {
                fiddle();
4           } elseif ($a2 == $b2) {
                fiddle();
            } else {
                fiddle();
            }
5       } elseif ($c == $d) {
6           while ($c == $d) {
                fiddle();
            }
7        } elseif ($e == $f) {
8           for ($n = 0; $n < $h; $n++) {
                fiddle();
            }
        } else {
            switch ($z) {
9               case 1:
                    fiddle();
                    break;
10              case 2:
                    fiddle();
                    break;
11              case 3:
                    fiddle();
                    break;
                default:
                    fiddle();
                    break;
            }
        }
    }
}

            Source https://phpmd.org/rules/codesize.html#cyclomaticcomplexity

            The method flip() has a Cyclomatic Complexity of 12. The configured cyclomatic complexity threshold is 10.
            Open

                public static function flip($type)
    {
        switch (strtolower($type)) {
            case 'x':
            case 'h':
            Severity: Minor
            Found in src/Normalize.php by phpmd

            CyclomaticComplexity

            Since: 0.1

            Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.

            Example

            // Cyclomatic Complexity = 11
class Foo {
1   public function example() {
2       if ($a == $b) {
3           if ($a1 == $b1) {
                fiddle();
4           } elseif ($a2 == $b2) {
                fiddle();
            } else {
                fiddle();
            }
5       } elseif ($c == $d) {
6           while ($c == $d) {
                fiddle();
            }
7        } elseif ($e == $f) {
8           for ($n = 0; $n < $h; $n++) {
                fiddle();
            }
        } else {
            switch ($z) {
9               case 1:
                    fiddle();
                    break;
10              case 2:
                    fiddle();
                    break;
11              case 3:
                    fiddle();
                    break;
                default:
                    fiddle();
                    break;
            }
        }
    }
}

            Source https://phpmd.org/rules/codesize.html#cyclomaticcomplexity

            Avoid unused local variables such as '$width'.
            Open

                    if (!isset($oy, $dx, $dy, $width, $height) && is_array($ox)) {
            Severity: Minor
            Found in src/Normalize.php by phpmd

            UnusedLocalVariable

            Since: 0.2

            Detects when a local variable is declared and/or assigned, but not used.

            Example

            class Foo {
    public function doSomething()
    {
        $i = 5; // Unused
    }
}

            Source https://phpmd.org/rules/unusedcode.html#unusedlocalvariable

            Avoid unused local variables such as '$height'.
            Open

                    if (!isset($oy, $dx, $dy, $width, $height) && is_array($ox)) {
            Severity: Minor
            Found in src/Normalize.php by phpmd

            UnusedLocalVariable

            Since: 0.2

            Detects when a local variable is declared and/or assigned, but not used.

            Example

            class Foo {
    public function doSomething()
    {
        $i = 5; // Unused
    }
}

            Source https://phpmd.org/rules/unusedcode.html#unusedlocalvariable

            Avoid variables with short names like $r. Configured minimum length is 3.
            Open

                            list($r, $g, $b, $a) = $keys;
            Severity: Minor
            Found in src/Normalize.php by phpmd

            ShortVariable

            Since: 0.2

            Detects when a field, local, or parameter has a very short name.

            Example

            class Something {
    private $q = 15; // VIOLATION - Field
    public static function main( array $as ) { // VIOLATION - Formal
        $r = 20 + $this->q; // VIOLATION - Local
        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
            $r += $this->q;
        }
    }
}

            Source https://phpmd.org/rules/naming.html#shortvariable

            Avoid variables with short names like $a. Configured minimum length is 3.
            Open

                            list($r, $g, $b, $a) = $keys;
            Severity: Minor
            Found in src/Normalize.php by phpmd

            ShortVariable

            Since: 0.2

            Detects when a field, local, or parameter has a very short name.

            Example

            class Something {
    private $q = 15; // VIOLATION - Field
    public static function main( array $as ) { // VIOLATION - Formal
        $r = 20 + $this->q; // VIOLATION - Local
        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
            $r += $this->q;
        }
    }
}

            Source https://phpmd.org/rules/naming.html#shortvariable

            Avoid variables with short names like $oy. Configured minimum length is 3.
            Open

                public static function cropMeasures($ox, $oy = null, $dx = null, $dy = null)
            Severity: Minor
            Found in src/Normalize.php by phpmd

            ShortVariable

            Since: 0.2

            Detects when a field, local, or parameter has a very short name.

            Example

            class Something {
    private $q = 15; // VIOLATION - Field
    public static function main( array $as ) { // VIOLATION - Formal
        $r = 20 + $this->q; // VIOLATION - Local
        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
            $r += $this->q;
        }
    }
}

            Source https://phpmd.org/rules/naming.html#shortvariable

            Avoid variables with short names like $b. Configured minimum length is 3.
            Open

                            list($r, $g, $b, $a) = $keys;
            Severity: Minor
            Found in src/Normalize.php by phpmd

            ShortVariable

            Since: 0.2

            Detects when a field, local, or parameter has a very short name.

            Example

            class Something {
    private $q = 15; // VIOLATION - Field
    public static function main( array $as ) { // VIOLATION - Formal
        $r = 20 + $this->q; // VIOLATION - Local
        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
            $r += $this->q;
        }
    }
}

            Source https://phpmd.org/rules/naming.html#shortvariable

            Avoid variables with short names like $ox. Configured minimum length is 3.
            Open

                public static function cropMeasures($ox, $oy = null, $dx = null, $dy = null)
            Severity: Minor
            Found in src/Normalize.php by phpmd

            ShortVariable

            Since: 0.2

            Detects when a field, local, or parameter has a very short name.

            Example

            class Something {
    private $q = 15; // VIOLATION - Field
    public static function main( array $as ) { // VIOLATION - Formal
        $r = 20 + $this->q; // VIOLATION - Local
        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
            $r += $this->q;
        }
    }
}

            Source https://phpmd.org/rules/naming.html#shortvariable

            Avoid variables with short names like $dy. Configured minimum length is 3.
            Open

                public static function cropMeasures($ox, $oy = null, $dx = null, $dy = null)
            Severity: Minor
            Found in src/Normalize.php by phpmd

            ShortVariable

            Since: 0.2

            Detects when a field, local, or parameter has a very short name.

            Example

            class Something {
    private $q = 15; // VIOLATION - Field
    public static function main( array $as ) { // VIOLATION - Formal
        $r = 20 + $this->q; // VIOLATION - Local
        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
            $r += $this->q;
        }
    }
}

            Source https://phpmd.org/rules/naming.html#shortvariable

            Avoid variables with short names like $dx. Configured minimum length is 3.
            Open

                public static function cropMeasures($ox, $oy = null, $dx = null, $dy = null)
            Severity: Minor
            Found in src/Normalize.php by phpmd

            ShortVariable

            Since: 0.2

            Detects when a field, local, or parameter has a very short name.

            Example

            class Something {
    private $q = 15; // VIOLATION - Field
    public static function main( array $as ) { // VIOLATION - Formal
        $r = 20 + $this->q; // VIOLATION - Local
        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
            $r += $this->q;
        }
    }
}

            Source https://phpmd.org/rules/naming.html#shortvariable

            Avoid variables with short names like $g. Configured minimum length is 3.
            Open

                            list($r, $g, $b, $a) = $keys;
            Severity: Minor
            Found in src/Normalize.php by phpmd

            ShortVariable

            Since: 0.2

            Detects when a field, local, or parameter has a very short name.

            Example

            class Something {
    private $q = 15; // VIOLATION - Field
    public static function main( array $as ) { // VIOLATION - Formal
        $r = 20 + $this->q; // VIOLATION - Local
        for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
            $r += $this->q;
        }
    }
}

            Source https://phpmd.org/rules/naming.html#shortvariable

            There are no issues that match your filters.

            Category
            Status