yiisoft/yii2

View on GitHub
framework/helpers/BaseFileHelper.php

Summary

Maintainability
F
3 days
Test Coverage

Function copyDirectory has a Cognitive Complexity of 38 (exceeds 5 allowed). Consider refactoring.
Open

    public static function copyDirectory($src, $dst, $options = [])
    {
        $src = static::normalizePath($src);
        $dst = static::normalizePath($dst);

Severity: Minor
Found in framework/helpers/BaseFileHelper.php - About 5 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

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

class BaseFileHelper
{
    const PATTERN_NODIR = 1;
    const PATTERN_ENDSWITH = 4;
    const PATTERN_MUSTBEDIR = 8;
Severity: Minor
Found in framework/helpers/BaseFileHelper.php by phpmd

Since: PHPMD 0.2.5

The Weighted Method Count (WMC) of a class is a good indicator of how much time and effort is required to modify and maintain this class. The WMC metric is defined as the sum of complexities of all methods declared in a class. A large number of methods also means that this class has a greater potential impact on derived classes.

Example:

class Foo {
      public function bar() {
          if ($a == $b)  {
              if ($a1 == $b1) {
                  fiddle();
              } elseif ($a2 == $b2) {
                  fiddle();
              } else {
              }
          }
      }
      public function baz() {
          if ($a == $b) {
              if ($a1 == $b1) {
                  fiddle();
              } elseif ($a2 == $b2) {
                  fiddle();
              } else {
              }
          }
      }
      // Several other complex methods
  }

Source: http://phpmd.org/rules/codesize.txt

Function lastExcludeMatchingFromList has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
Open

    private static function lastExcludeMatchingFromList($basePath, $path, $excludes)
    {
        foreach (array_reverse($excludes) as $exclude) {
            if (is_string($exclude)) {
                $exclude = self::parseExcludePattern($exclude, false);
Severity: Minor
Found in framework/helpers/BaseFileHelper.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 removeDirectory has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
Open

    public static function removeDirectory($dir, $options = [])
    {
        if (!is_dir($dir)) {
            return;
        }
Severity: Minor
Found in framework/helpers/BaseFileHelper.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 normalizePath has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
Open

    public static function normalizePath($path, $ds = DIRECTORY_SEPARATOR)
    {
        $path = rtrim(strtr($path, '/\\', $ds . $ds), $ds);
        if (strpos($ds . $path, "{$ds}.") === false && strpos($path, "{$ds}{$ds}") === false) {
            return $path;
Severity: Minor
Found in framework/helpers/BaseFileHelper.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 matchPathname has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
Open

    private static function matchPathname($path, $basePath, $pattern, $firstWildcard, $flags)
    {
        // match with FNM_PATHNAME; the pattern has base implicitly in front of it.
        if (isset($pattern[0]) && $pattern[0] === '/') {
            $pattern = StringHelper::byteSubstr($pattern, 1, StringHelper::byteLength($pattern));
Severity: Minor
Found in framework/helpers/BaseFileHelper.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

Function findFiles has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
Open

    public static function findFiles($dir, $options = [])
    {
        $dir = self::clearDir($dir);
        $options = self::setBasePath($dir, $options);
        $list = [];
Severity: Minor
Found in framework/helpers/BaseFileHelper.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

Function normalizeOptions has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
Open

    protected static function normalizeOptions(array $options)
    {
        if (!array_key_exists('caseSensitive', $options)) {
            $options['caseSensitive'] = true;
        }
Severity: Minor
Found in framework/helpers/BaseFileHelper.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

Function findDirectories has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
Open

    public static function findDirectories($dir, $options = [])
    {
        $dir = self::clearDir($dir);
        $options = self::setBasePath($dir, $options);
        $list = [];
Severity: Minor
Found in framework/helpers/BaseFileHelper.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

Function filterPath has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
Open

    public static function filterPath($path, $options)
    {
        if (isset($options['filter'])) {
            $result = call_user_func($options['filter'], $path);
            if (is_bool($result)) {
Severity: Minor
Found in framework/helpers/BaseFileHelper.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

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

    public static function unlink($path)
    {
        $isWindows = DIRECTORY_SEPARATOR === '\\';

        if (!$isWindows) {
Severity: Minor
Found in framework/helpers/BaseFileHelper.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

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

    public static function createDirectory($path, $mode = 0775, $recursive = true)
    {
        if (is_dir($path)) {
            return true;
        }
Severity: Minor
Found in framework/helpers/BaseFileHelper.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 parseExcludePattern has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
Open

    private static function parseExcludePattern($pattern, $caseSensitive)
    {
        if (!is_string($pattern)) {
            throw new InvalidArgumentException('Exclude/include pattern must be a string.');
        }
Severity: Minor
Found in framework/helpers/BaseFileHelper.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

Method matchPathname has 5 arguments (exceeds 4 allowed). Consider refactoring.
Open

    private static function matchPathname($path, $basePath, $pattern, $firstWildcard, $flags)
Severity: Minor
Found in framework/helpers/BaseFileHelper.php - About 35 mins to fix

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

        public static function getMimeType($file, $magicFile = null, $checkExtension = true)
        {
            if ($magicFile !== null) {
                $magicFile = Yii::getAlias($magicFile);
            }
    Severity: Minor
    Found in framework/helpers/BaseFileHelper.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

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

        private static function matchBasename($baseName, $pattern, $firstWildcard, $flags)
        {
            if ($firstWildcard === false) {
                if ($pattern === $baseName) {
                    return true;
    Severity: Minor
    Found in framework/helpers/BaseFileHelper.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

    Avoid too many return statements within this method.
    Open

                    return !file_exists($path);
    Severity: Major
    Found in framework/helpers/BaseFileHelper.php - About 30 mins to fix

      Avoid too many return statements within this method.
      Open

              return true;
      Severity: Major
      Found in framework/helpers/BaseFileHelper.php - About 30 mins to fix

        Avoid too many return statements within this method.
        Open

                    return false;
        Severity: Major
        Found in framework/helpers/BaseFileHelper.php - About 30 mins to fix

          Avoid too many return statements within this method.
          Open

                      return false;
          Severity: Major
          Found in framework/helpers/BaseFileHelper.php - About 30 mins to fix

            The method parseExcludePattern() has an NPath complexity of 288. The configured NPath complexity threshold is 200.
            Open

                private static function parseExcludePattern($pattern, $caseSensitive)
                {
                    if (!is_string($pattern)) {
                        throw new InvalidArgumentException('Exclude/include pattern must be a string.');
                    }
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 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: http://phpmd.org/rules/codesize.txt

            The method normalizePath() has an NPath complexity of 432. The configured NPath complexity threshold is 200.
            Open

                public static function normalizePath($path, $ds = DIRECTORY_SEPARATOR)
                {
                    $path = rtrim(strtr($path, '/\\', $ds . $ds), $ds);
                    if (strpos($ds . $path, "{$ds}.") === false && strpos($path, "{$ds}{$ds}") === false) {
                        return $path;
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 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: http://phpmd.org/rules/codesize.txt

            The method matchPathname() has an NPath complexity of 500. The configured NPath complexity threshold is 200.
            Open

                private static function matchPathname($path, $basePath, $pattern, $firstWildcard, $flags)
                {
                    // match with FNM_PATHNAME; the pattern has base implicitly in front of it.
                    if (isset($pattern[0]) && $pattern[0] === '/') {
                        $pattern = StringHelper::byteSubstr($pattern, 1, StringHelper::byteLength($pattern));
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 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: http://phpmd.org/rules/codesize.txt

            The method copyDirectory() has an NPath complexity of 9960. The configured NPath complexity threshold is 200.
            Open

                public static function copyDirectory($src, $dst, $options = [])
                {
                    $src = static::normalizePath($src);
                    $dst = static::normalizePath($dst);
            
            
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 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: http://phpmd.org/rules/codesize.txt

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

                private static function matchPathname($path, $basePath, $pattern, $firstWildcard, $flags)
                {
                    // match with FNM_PATHNAME; the pattern has base implicitly in front of it.
                    if (isset($pattern[0]) && $pattern[0] === '/') {
                        $pattern = StringHelper::byteSubstr($pattern, 1, StringHelper::byteLength($pattern));
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 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: http://phpmd.org/rules/codesize.txt

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

                private static function parseExcludePattern($pattern, $caseSensitive)
                {
                    if (!is_string($pattern)) {
                        throw new InvalidArgumentException('Exclude/include pattern must be a string.');
                    }
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 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: http://phpmd.org/rules/codesize.txt

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

                public static function removeDirectory($dir, $options = [])
                {
                    if (!is_dir($dir)) {
                        return;
                    }
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 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: http://phpmd.org/rules/codesize.txt

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

                private static function lastExcludeMatchingFromList($basePath, $path, $excludes)
                {
                    foreach (array_reverse($excludes) as $exclude) {
                        if (is_string($exclude)) {
                            $exclude = self::parseExcludePattern($exclude, false);
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 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: http://phpmd.org/rules/codesize.txt

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

                public static function filterPath($path, $options)
                {
                    if (isset($options['filter'])) {
                        $result = call_user_func($options['filter'], $path);
                        if (is_bool($result)) {
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 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: http://phpmd.org/rules/codesize.txt

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

                public static function copyDirectory($src, $dst, $options = [])
                {
                    $src = static::normalizePath($src);
                    $dst = static::normalizePath($dst);
            
            
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 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: http://phpmd.org/rules/codesize.txt

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

                public static function normalizePath($path, $ds = DIRECTORY_SEPARATOR)
                {
                    $path = rtrim(strtr($path, '/\\', $ds . $ds), $ds);
                    if (strpos($ds . $path, "{$ds}.") === false && strpos($path, "{$ds}{$ds}") === false) {
                        return $path;
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 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: http://phpmd.org/rules/codesize.txt

            The method getMimeType has a boolean flag argument $checkExtension, which is a certain sign of a Single Responsibility Principle violation.
            Open

                public static function getMimeType($file, $magicFile = null, $checkExtension = true)
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 1.4.0

            A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.

            Example:

            class Foo {
                  public function bar($flag = true) {
                  }
              }

            Source: http://phpmd.org/rules/cleancode.txt

            The method createDirectory has a boolean flag argument $recursive, which is a certain sign of a Single Responsibility Principle violation.
            Open

                public static function createDirectory($path, $mode = 0775, $recursive = true)
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 1.4.0

            A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.

            Example:

            class Foo {
                  public function bar($flag = true) {
                  }
              }

            Source: http://phpmd.org/rules/cleancode.txt

            Similar blocks of code found in 2 locations. Consider refactoring.
            Open

                protected static function loadMimeTypes($magicFile)
                {
                    if ($magicFile === null) {
                        $magicFile = static::$mimeMagicFile;
                    }
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php and 1 other location - About 35 mins to fix
            framework/helpers/BaseFileHelper.php on lines 249..260

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 76.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Similar blocks of code found in 2 locations. Consider refactoring.
            Open

                protected static function loadMimeAliases($aliasesFile)
                {
                    if ($aliasesFile === null) {
                        $aliasesFile = static::$mimeAliasesFile;
                    }
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php and 1 other location - About 35 mins to fix
            framework/helpers/BaseFileHelper.php on lines 227..238

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 76.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            The variable $_mimeAliases is not named in camelCase.
            Open

                protected static function loadMimeAliases($aliasesFile)
                {
                    if ($aliasesFile === null) {
                        $aliasesFile = static::$mimeAliasesFile;
                    }
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 0.2

            It is considered best practice to use the camelCase notation to name variables.

            Example:

            class ClassName {
                  public function doSomething() {
                      $data_module = new DataModule();
                  }
              }

            Source: http://phpmd.org/rules/controversial.txt

            The variable $_mimeAliases is not named in camelCase.
            Open

                protected static function loadMimeAliases($aliasesFile)
                {
                    if ($aliasesFile === null) {
                        $aliasesFile = static::$mimeAliasesFile;
                    }
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 0.2

            It is considered best practice to use the camelCase notation to name variables.

            Example:

            class ClassName {
                  public function doSomething() {
                      $data_module = new DataModule();
                  }
              }

            Source: http://phpmd.org/rules/controversial.txt

            The variable $_mimeTypes is not named in camelCase.
            Open

                protected static function loadMimeTypes($magicFile)
                {
                    if ($magicFile === null) {
                        $magicFile = static::$mimeMagicFile;
                    }
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 0.2

            It is considered best practice to use the camelCase notation to name variables.

            Example:

            class ClassName {
                  public function doSomething() {
                      $data_module = new DataModule();
                  }
              }

            Source: http://phpmd.org/rules/controversial.txt

            The variable $_mimeTypes is not named in camelCase.
            Open

                protected static function loadMimeTypes($magicFile)
                {
                    if ($magicFile === null) {
                        $magicFile = static::$mimeMagicFile;
                    }
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 0.2

            It is considered best practice to use the camelCase notation to name variables.

            Example:

            class ClassName {
                  public function doSomething() {
                      $data_module = new DataModule();
                  }
              }

            Source: http://phpmd.org/rules/controversial.txt

            The variable $_mimeTypes is not named in camelCase.
            Open

                protected static function loadMimeTypes($magicFile)
                {
                    if ($magicFile === null) {
                        $magicFile = static::$mimeMagicFile;
                    }
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 0.2

            It is considered best practice to use the camelCase notation to name variables.

            Example:

            class ClassName {
                  public function doSomething() {
                      $data_module = new DataModule();
                  }
              }

            Source: http://phpmd.org/rules/controversial.txt

            The variable $_mimeAliases is not named in camelCase.
            Open

                protected static function loadMimeAliases($aliasesFile)
                {
                    if ($aliasesFile === null) {
                        $aliasesFile = static::$mimeAliasesFile;
                    }
            Severity: Minor
            Found in framework/helpers/BaseFileHelper.php by phpmd

            Since: PHPMD 0.2

            It is considered best practice to use the camelCase notation to name variables.

            Example:

            class ClassName {
                  public function doSomething() {
                      $data_module = new DataModule();
                  }
              }

            Source: http://phpmd.org/rules/controversial.txt

            There are no issues that match your filters.

            Category
            Status