<?php/* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */namespace Symfony\Component\Finder;use Symfony\Component\Finder\Comparator\DateComparator;use Symfony\Component\Finder\Comparator\NumberComparator;use Symfony\Component\Finder\Exception\DirectoryNotFoundException;use Symfony\Component\Finder\Iterator\CustomFilterIterator;use Symfony\Component\Finder\Iterator\DateRangeFilterIterator;use Symfony\Component\Finder\Iterator\DepthRangeFilterIterator;use Symfony\Component\Finder\Iterator\ExcludeDirectoryFilterIterator;use Symfony\Component\Finder\Iterator\FilecontentFilterIterator;use Symfony\Component\Finder\Iterator\FilenameFilterIterator;use Symfony\Component\Finder\Iterator\LazyIterator;use Symfony\Component\Finder\Iterator\SizeRangeFilterIterator;use Symfony\Component\Finder\Iterator\SortableIterator;/** * Finder allows to build rules to find files and directories. * * It is a thin wrapper around several specialized iterator classes. * * All rules may be invoked several times. * * All methods return the current Finder object to allow chaining: * *     $finder = Finder::create()->files()->name('*.php')->in(__DIR__); * * @author Fabien Potencier <fabien@symfony.com> */class Finder implements \IteratorAggregate, \Countable{    public const IGNORE_VCS_FILES = 1;    public const IGNORE_DOT_FILES = 2;    public const IGNORE_VCS_IGNORED_FILES = 4;    private $mode = 0;    private $names = [];    private $notNames = [];    private $exclude = [];    private $filters = [];    private $depths = [];    private $sizes = [];    private $followLinks = false;    private $reverseSorting = false;    private $sort = false;    private $ignore = 0;    private $dirs = [];    private $dates = [];    private $iterators = [];    private $contains = [];    private $notContains = [];    private $paths = [];    private $notPaths = [];    private $ignoreUnreadableDirs = false;    private static $vcsPatterns = ['.svn', '_svn', 'CVS', '_darcs', '.arch-params', '.monotone', '.bzr', '.git', '.hg'];

			Why this impedes flexibility

Global variables
Note: A future update will differentiate between private static variables and public static or global variables as private static variables do not cause as much of a problem.
Summary
Hidden dependencies
Broken encapsulation
One component can accidentally overwrite data required by another component (action at a distance)
You can only every have one copy of the variable
Adding code requires knowing exactly what variables are already in use
When working in teams, name clashes can be easily introduced
Global state makes it difficult to reuse the code. E.g. having two files open at the same time would require writing the code twice, three times for three files, etc.
Background
The identification of global variables as a bad practice dates as far back at least as far back as 1973[1] and are one of the most widespread and well known bad practices related to flexibility. This is likely due to being available in almost every programming language, ease of use and speed to learn. They also cause severe problems in code and it's very easy to get caught out by using them, even in a small application.
Global vairables are widely labelled "bad practice" and have been for some time, for example back in 1999 Kernighan wrote:
Avoid global variables; wherever possible it is better to pass references to all data through function arguments
Kernighan[2]
And Hevery[3] states:
I hope that by now most developers agree that global state should be treated like GOTO.
This attitude is widespread and Sayfan[4] sums up the problem:
Whenever shared mutable state is involved, it is easy for components to step on each other's toes.
Although "global variables are bad" is a common thing to here, for novice developers it's not immediately obvious why this is. However, the reasons have been covered frequently by developers of varying prominence. While writing about desiging the Eiffel programming language, [5] stated several problems with global variables:
Since global variables are shared by different modules, they make each of these modules more difficult to understand separately, diminishing readability and hence hampering maintenance.
As global variables constitute a form of undercover dependency between modules, they are a major obstacle to software evolution, since they make it harder to modify a module without impacting others.
They are a major source of nasty errors. Through a global variable, an error in a module may propagate to many others. As a result, the manifestation of the error may be quite remote from its cause in the software architecture, making it very hard to trace down errors and correct them. This problem is particularly serious in environments where incorrect array references may pollute other data.
Action at a distance
This problem is commonly referred to as action at a distance and described by Hevery[6] as:
Spooky Action at a Distance is when we run one thing that we believe is isolated (since we did not pass any references in) but unexpected interactions and state changes happen in distant locations of the system which we did not tell the object about. This can only happen via global state.
Broken encapsulation
The biggest issue with global variables (even private static variables) is that they break encapsulation. A class no longer has its own state and one instance of a class can affect the state of another. Although private static variables are the by far the least worst type of global variables they should still be refactored out where possible.

> Encapsulation refers to the bundling of data with the methods that operate on that data
By making the data globally accessible, encapsulation has been lost. Any part of the program has access to the data and can modify it. Even when using private static variables, each instance no longer has control of its own sate.
Tight coupling
Global variables introduce  tight coupling. In Object Oriented Programming an object should be self-contained[7][8]. If a class depends on a global (or static) variable, then moving the class to a different project requires defining the required global variables in the new project. Private static variables do not not introduce additional coupling.
Name Clashes
Global variables can introduce name clashes:
everywhere in the program, you would have to keep track of the names of all the variables declared anywhere else in the program, so that you didn't accidentally re-use one.
Summit[9]
The problem of name clashes is magnified by the size of a team. If two people are working on a piece of software and both use global variables, it's possible they'll write some code using the same variable names. During execution this might cause the two peices of code to interfere with each other.
Examples
As a very crude example, imagine the following:

 function getUser($id) {
    $connection = Database::$connection;

    $connection->query('SELET * FROM user ...')
}


This code assumes that Database::$connection has been set correctly and not overwritten. If any part of the application accidently runs the code Database::$connection = null; (or sets it to anything other than a database connection) then the code will fail. This is due to broken encapsulation and action and a distance.
Anything in the code is able to change the property and cause unexpected behaviour when further methods are called on the instance.
This can also happen with private static properties:

 
class FileReadWrite {
    private static $fileName;

    public function __construct(string $file) {
        self::$fileName = $file;
    }

    public function read() {
        return file_get_contents(self::$fileName);
    }

    public function write(string $data) {
        file_put_contents(self::$fileName, $data);
    }
}


 
//Works as expected:

$file = new FileReadWrite('./one.txt');
$file->write('data');


//cause a problem

$file1 = new FileReadWrite('./one.txt');
$file2 = new FileReadWrite('./two.txt');

$file1->write('data1');
$file2->write('data2');

This causes a problem because there is a global variable storing the file name. Assuming a class requires only one value of a variable across the whole application always limits flexibility. There are occasionally practical reasons for this such as keeping track of and limiting the number of open files/connections but flexibility is always reduced. Even in these practical exceptions, it introduces a new issue of separation of concerns: Should the class be concerned with the number of open connections throughout the application or should that be managed at an application level rather than a class level?
Although this is a contrived example, the same kind of bugs can occur any time a static variable is used. If it's set by one instance and read by another then unexpected changes can cause bugs.
Further reading
What is tight coupling?
Why Static is Bad and How to Avoid It
Flaw: Brittle Global State & Singletons
What's Wrong With Global Variables
References
Wulf, W., Shaw, M. (1973) Global varaibles considered harmful. ACM SIGPLAN Notices , pp.28-34.
Kernighan, B. (1999) The Practice of Programming ISBN: 978-0201615869. Addison Wesley.
Hevery, M. (2008) Top 10 things which make your code hard to test [online]. Available from: http://misko.hevery.com/2008/07/30/top-10-things-which-make-your-code-hard-to-test/ 
Sayfan, M. (n.d.) Avoid Global Variables, Environment Variables, and Singletons [online]. Available from: https://sites.google.com/site/michaelsafyan/software-engineering/avoid-global-variables-environment-variables-and-singletons 
Meyer, B. (1988) Bidding farewell to globals. JOOP(Journal of Object-Oriented Programming) , pp.73-77.
Hevery, M. (2008) Brittle Global State & Singletons [online]. Available from: http://misko.hevery.com/code-reviewers-guide/flaw-brittle-global-state-singletons/ 
Yaiser, M. (2011) Object-oriented programming concepts: Objects and classes [online]. Available from: http://www.adobe.com/devnet/actionscript/learning/oop-concepts/objects-and-classes.html 
Caromel, D. (1993) Toward a method of object-oriented concurrent programming. Communications of the ACM , pp.90-102.
Summit, S. (1997) Visibility and Lifetime (Global Variables, etc.) [online]. Available from: https://www.eskimo.com/~scs/cclass/notes/sx4b.html 
    public function __construct()    {        $this->ignore = static::IGNORE_VCS_FILES | static::IGNORE_DOT_FILES;    }    /**     * Creates a new Finder.     *     * @return static     */    public static function create()

			Why this impedes flexibility

Static methods
Summary of issues
Tight Coupling
Hidden dependencies
Global state (if also using static variables)
Tight Coupling
Use of static methods always reduces flexibility by introducing tight coupling[1]. A static method tightly couples the calling code to the specific class the method exists in.

 
function totalAbs(double value, double value2) {
    return abs(value) + abs(value2);
}

Here, the method totalAbs has a dependency on the Math class and the .abs() method will always be called. Although for testing purposes this may not be a problem, the coupling reduces flexibility because the total method can only work with doubles/integers, as that's all the Math.abs() function can use. Although type coercion will allow the use of any primitive numeric type, these types have limitations. It's impossible to use another class such as BigInteger or a class for dealing with greater precision decimals or even alternative numbering systems such as Roman numerals.
The totalAbs function takes two doubles and converts them to their absolute values before adding them. This is inflexible because it only works with doubles. It's tied to doubles because that's what the Math.abs() static method requires. If, instead, using OOP an interface was created to handle any number that had this method:

 interface Numeric {
    public function abs(): Numeric;
}

It would then be possible to rewrite the totalAbs method to work with any kind of number:

 function totalAbs(Numeric value, Numeric value): Numeric {
    return value.abs() + value2.abs();
}


By removing the static method and using an instance method in its place the totalAbs method is now agnostic about the type of number it is dealing with. It could be called with any of the following (assuming they implement the Numeric interface)

 
totalAbs(new Integer(4), new Integer(-53));

totalAbs(new Double(34.4), new Integer(-2));

totalAbs(new BigInteger('123445454564765739878989343225778'), new Integer(2343));

totalAbs(new RomanNumeral('VII'), new RomanNumeral('CXV'));


Making the method reusable in a way that it wasn't when static methods were being used. By changing the static methods to instance methods, flexibility has been enhanced as the method can be used with any numeric type, not just numeric types that are supported by the Math.abs() method.
Broken encapsulation
Static methods also break encapsulation. Encapsulation is defined by Rogers[2] as:
the bundling of data with the methods that operate on that data
By passing the numeric value into the abs method, the data being operated on is being separated from the methods that operate on it, breaking encapsulation. Instead using num.abs() the data is encapsulated in the num instance and its type is not visible or relevant to the outside world. abs() will work on the data and work regardless of num's type, providing it implements the abs method.
This is a simple example, but applies to all static methods. Use of polymorphic instance methods that work on encapsulated data will always be more flexible than static method calls which can only ever deal with specific pre-defined types.
Further reading
What is tight coupling?
Why Static is Bad and How to Avoid It
Static Methods Will Shock You
Flaw: Brittle Global State & Singletons
Static Methods are Death to Testability
Exceptions
The only exception to this rule is when a static method is used for object creation in place of the new keyword[3]. This is because the new keyword is already a static call. However, even here a non-static factory is often preferable for testing purposes[4][5].
References
Popov, N. (2014) Don't be STUPID: GRASP SOLID!  [online]. Available from: https://nikic.github.io/2011/12/27/Dont-be-STUPID-GRASP-SOLID.html 
Rogers, P. (2001) Encapsulation is not information hiding [online]. Available from: http://www.javaworld.com/article/2075271/core-java/encapsulation-is-not-information-hiding.html 
Sonmez, J. (2010)  Static Methods Will Shock You  [online]. Available from: http://simpleprogrammer.com/2010/01/29/static-methods-will-shock-you/ 
Hevery, M. (2008) Static Methods are Death to Testability [online]. Available from: http://misko.hevery.com/2008/12/15/static-methods-are-death-to-testability/ 
Butler, T. (2013) Are Static Methods/Variables bad practice? [online]. Available from: https://r.je/static-methods-bad-practice.html 
    {        return new static();

			Why this impedes flexibility

Global variables
Note: A future update will differentiate between private static variables and public static or global variables as private static variables do not cause as much of a problem.
Summary
Hidden dependencies
Broken encapsulation
One component can accidentally overwrite data required by another component (action at a distance)
You can only every have one copy of the variable
Adding code requires knowing exactly what variables are already in use
When working in teams, name clashes can be easily introduced
Global state makes it difficult to reuse the code. E.g. having two files open at the same time would require writing the code twice, three times for three files, etc.
Background
The identification of global variables as a bad practice dates as far back at least as far back as 1973[1] and are one of the most widespread and well known bad practices related to flexibility. This is likely due to being available in almost every programming language, ease of use and speed to learn. They also cause severe problems in code and it's very easy to get caught out by using them, even in a small application.
Global vairables are widely labelled "bad practice" and have been for some time, for example back in 1999 Kernighan wrote:
Avoid global variables; wherever possible it is better to pass references to all data through function arguments
Kernighan[2]
And Hevery[3] states:
I hope that by now most developers agree that global state should be treated like GOTO.
This attitude is widespread and Sayfan[4] sums up the problem:
Whenever shared mutable state is involved, it is easy for components to step on each other's toes.
Although "global variables are bad" is a common thing to here, for novice developers it's not immediately obvious why this is. However, the reasons have been covered frequently by developers of varying prominence. While writing about desiging the Eiffel programming language, [5] stated several problems with global variables:
Since global variables are shared by different modules, they make each of these modules more difficult to understand separately, diminishing readability and hence hampering maintenance.
As global variables constitute a form of undercover dependency between modules, they are a major obstacle to software evolution, since they make it harder to modify a module without impacting others.
They are a major source of nasty errors. Through a global variable, an error in a module may propagate to many others. As a result, the manifestation of the error may be quite remote from its cause in the software architecture, making it very hard to trace down errors and correct them. This problem is particularly serious in environments where incorrect array references may pollute other data.
Action at a distance
This problem is commonly referred to as action at a distance and described by Hevery[6] as:
Spooky Action at a Distance is when we run one thing that we believe is isolated (since we did not pass any references in) but unexpected interactions and state changes happen in distant locations of the system which we did not tell the object about. This can only happen via global state.
Broken encapsulation
The biggest issue with global variables (even private static variables) is that they break encapsulation. A class no longer has its own state and one instance of a class can affect the state of another. Although private static variables are the by far the least worst type of global variables they should still be refactored out where possible.

> Encapsulation refers to the bundling of data with the methods that operate on that data
By making the data globally accessible, encapsulation has been lost. Any part of the program has access to the data and can modify it. Even when using private static variables, each instance no longer has control of its own sate.
Tight coupling
Global variables introduce  tight coupling. In Object Oriented Programming an object should be self-contained[7][8]. If a class depends on a global (or static) variable, then moving the class to a different project requires defining the required global variables in the new project. Private static variables do not not introduce additional coupling.
Name Clashes
Global variables can introduce name clashes:
everywhere in the program, you would have to keep track of the names of all the variables declared anywhere else in the program, so that you didn't accidentally re-use one.
Summit[9]
The problem of name clashes is magnified by the size of a team. If two people are working on a piece of software and both use global variables, it's possible they'll write some code using the same variable names. During execution this might cause the two peices of code to interfere with each other.
Examples
As a very crude example, imagine the following:

 function getUser($id) {
    $connection = Database::$connection;

    $connection->query('SELET * FROM user ...')
}


This code assumes that Database::$connection has been set correctly and not overwritten. If any part of the application accidently runs the code Database::$connection = null; (or sets it to anything other than a database connection) then the code will fail. This is due to broken encapsulation and action and a distance.
Anything in the code is able to change the property and cause unexpected behaviour when further methods are called on the instance.
This can also happen with private static properties:

 
class FileReadWrite {
    private static $fileName;

    public function __construct(string $file) {
        self::$fileName = $file;
    }

    public function read() {
        return file_get_contents(self::$fileName);
    }

    public function write(string $data) {
        file_put_contents(self::$fileName, $data);
    }
}


 
//Works as expected:

$file = new FileReadWrite('./one.txt');
$file->write('data');


//cause a problem

$file1 = new FileReadWrite('./one.txt');
$file2 = new FileReadWrite('./two.txt');

$file1->write('data1');
$file2->write('data2');

This causes a problem because there is a global variable storing the file name. Assuming a class requires only one value of a variable across the whole application always limits flexibility. There are occasionally practical reasons for this such as keeping track of and limiting the number of open files/connections but flexibility is always reduced. Even in these practical exceptions, it introduces a new issue of separation of concerns: Should the class be concerned with the number of open connections throughout the application or should that be managed at an application level rather than a class level?
Although this is a contrived example, the same kind of bugs can occur any time a static variable is used. If it's set by one instance and read by another then unexpected changes can cause bugs.
Further reading
What is tight coupling?
Why Static is Bad and How to Avoid It
Flaw: Brittle Global State & Singletons
What's Wrong With Global Variables
References
Wulf, W., Shaw, M. (1973) Global varaibles considered harmful. ACM SIGPLAN Notices , pp.28-34.
Kernighan, B. (1999) The Practice of Programming ISBN: 978-0201615869. Addison Wesley.
Hevery, M. (2008) Top 10 things which make your code hard to test [online]. Available from: http://misko.hevery.com/2008/07/30/top-10-things-which-make-your-code-hard-to-test/ 
Sayfan, M. (n.d.) Avoid Global Variables, Environment Variables, and Singletons [online]. Available from: https://sites.google.com/site/michaelsafyan/software-engineering/avoid-global-variables-environment-variables-and-singletons 
Meyer, B. (1988) Bidding farewell to globals. JOOP(Journal of Object-Oriented Programming) , pp.73-77.
Hevery, M. (2008) Brittle Global State & Singletons [online]. Available from: http://misko.hevery.com/code-reviewers-guide/flaw-brittle-global-state-singletons/ 
Yaiser, M. (2011) Object-oriented programming concepts: Objects and classes [online]. Available from: http://www.adobe.com/devnet/actionscript/learning/oop-concepts/objects-and-classes.html 
Caromel, D. (1993) Toward a method of object-oriented concurrent programming. Communications of the ACM , pp.90-102.
Summit, S. (1997) Visibility and Lifetime (Global Variables, etc.) [online]. Available from: https://www.eskimo.com/~scs/cclass/notes/sx4b.html 
    }    /**     * Restricts the matching to directories only.     *     * @return $this     */    public function directories()    {        $this->mode = Iterator\FileTypeFilterIterator::ONLY_DIRECTORIES;        return $this;    }    /**     * Restricts the matching to files only.     *     * @return $this     */    public function files()    {        $this->mode = Iterator\FileTypeFilterIterator::ONLY_FILES;        return $this;    }    /**     * Adds tests for the directory depth.     *     * Usage:     *     *     $finder->depth('> 1') // the Finder will start matching at level 1.     *     $finder->depth('< 3') // the Finder will descend at most 3 levels of directories below the starting point.     *     $finder->depth(['>= 1', '< 3'])     *     * @param string|int|string[]|int[] $levels The depth level expression or an array of depth levels     *     * @return $this     *     * @see DepthRangeFilterIterator     * @see NumberComparator     */    public function depth($levels)    {        foreach ((array) $levels as $level) {            $this->depths[] = new Comparator\NumberComparator($level);        }        return $this;    }    /**     * Adds tests for file dates (last modified).     *     * The date must be something that strtotime() is able to parse:     *     *     $finder->date('since yesterday');     *     $finder->date('until 2 days ago');     *     $finder->date('> now - 2 hours');     *     $finder->date('>= 2005-10-15');     *     $finder->date(['>= 2005-10-15', '<= 2006-05-27']);     *     * @param string|string[] $dates A date range string or an array of date ranges     *     * @return $this     *     * @see strtotime     * @see DateRangeFilterIterator     * @see DateComparator     */    public function date($dates)    {        foreach ((array) $dates as $date) {            $this->dates[] = new Comparator\DateComparator($date);        }        return $this;    }    /**     * Adds rules that files must match.     *     * You can use patterns (delimited with / sign), globs or simple strings.     *     *     $finder->name('*.php')     *     $finder->name('/\.php$/') // same as above     *     $finder->name('test.php')     *     $finder->name(['test.py', 'test.php'])     *     * @param string|string[] $patterns A pattern (a regexp, a glob, or a string) or an array of patterns     *     * @return $this     *     * @see FilenameFilterIterator     */    public function name($patterns)    {        $this->names = array_merge($this->names, (array) $patterns);        return $this;    }    /**     * Adds rules that files must not match.     *     * @param string|string[] $patterns A pattern (a regexp, a glob, or a string) or an array of patterns     *     * @return $this     *     * @see FilenameFilterIterator     */    public function notName($patterns)    {        $this->notNames = array_merge($this->notNames, (array) $patterns);        return $this;    }    /**     * Adds tests that file contents must match.     *     * Strings or PCRE patterns can be used:     *     *     $finder->contains('Lorem ipsum')     *     $finder->contains('/Lorem ipsum/i')     *     $finder->contains(['dolor', '/ipsum/i'])     *     * @param string|string[] $patterns A pattern (string or regexp) or an array of patterns     *     * @return $this     *     * @see FilecontentFilterIterator     */    public function contains($patterns)    {        $this->contains = array_merge($this->contains, (array) $patterns);        return $this;    }    /**     * Adds tests that file contents must not match.     *     * Strings or PCRE patterns can be used:     *     *     $finder->notContains('Lorem ipsum')     *     $finder->notContains('/Lorem ipsum/i')     *     $finder->notContains(['lorem', '/dolor/i'])     *     * @param string|string[] $patterns A pattern (string or regexp) or an array of patterns     *     * @return $this     *     * @see FilecontentFilterIterator     */    public function notContains($patterns)    {        $this->notContains = array_merge($this->notContains, (array) $patterns);        return $this;    }    /**     * Adds rules that filenames must match.     *     * You can use patterns (delimited with / sign) or simple strings.     *     *     $finder->path('some/special/dir')     *     $finder->path('/some\/special\/dir/') // same as above     *     $finder->path(['some dir', 'another/dir'])     *     * Use only / as dirname separator.     *     * @param string|string[] $patterns A pattern (a regexp or a string) or an array of patterns     *     * @return $this     *     * @see FilenameFilterIterator     */    public function path($patterns)    {        $this->paths = array_merge($this->paths, (array) $patterns);        return $this;    }    /**     * Adds rules that filenames must not match.     *     * You can use patterns (delimited with / sign) or simple strings.     *     *     $finder->notPath('some/special/dir')     *     $finder->notPath('/some\/special\/dir/') // same as above     *     $finder->notPath(['some/file.txt', 'another/file.log'])     *     * Use only / as dirname separator.     *     * @param string|string[] $patterns A pattern (a regexp or a string) or an array of patterns     *     * @return $this     *     * @see FilenameFilterIterator     */    public function notPath($patterns)    {        $this->notPaths = array_merge($this->notPaths, (array) $patterns);        return $this;    }    /**     * Adds tests for file sizes.     *     *     $finder->size('> 10K');     *     $finder->size('<= 1Ki');     *     $finder->size(4);     *     $finder->size(['> 10K', '< 20K'])     *     * @param string|int|string[]|int[] $sizes A size range string or an integer or an array of size ranges     *     * @return $this     *     * @see SizeRangeFilterIterator     * @see NumberComparator     */    public function size($sizes)    {        foreach ((array) $sizes as $size) {            $this->sizes[] = new Comparator\NumberComparator($size);        }        return $this;    }    /**     * Excludes directories.     *     * Directories passed as argument must be relative to the ones defined with the `in()` method. For example:     *     *     $finder->in(__DIR__)->exclude('ruby');     *     * @param string|array $dirs A directory path or an array of directories     *     * @return $this     *     * @see ExcludeDirectoryFilterIterator     */    public function exclude($dirs)    {        $this->exclude = array_merge($this->exclude, (array) $dirs);        return $this;    }    /**     * Excludes "hidden" directories and files (starting with a dot).     *     * This option is enabled by default.     *     * @return $this     *     * @see ExcludeDirectoryFilterIterator     */    public function ignoreDotFiles(bool $ignoreDotFiles)    {        if ($ignoreDotFiles) {            $this->ignore |= static::IGNORE_DOT_FILES;        } else {            $this->ignore &= ~static::IGNORE_DOT_FILES;        }        return $this;    }    /**     * Forces the finder to ignore version control directories.     *     * This option is enabled by default.     *     * @return $this     *     * @see ExcludeDirectoryFilterIterator     */    public function ignoreVCS(bool $ignoreVCS)    {        if ($ignoreVCS) {            $this->ignore |= static::IGNORE_VCS_FILES;        } else {            $this->ignore &= ~static::IGNORE_VCS_FILES;        }        return $this;    }    /**     * Forces Finder to obey .gitignore and ignore files based on rules listed there.     *     * This option is disabled by default.     *     * @return $this     */    public function ignoreVCSIgnored(bool $ignoreVCSIgnored)    {        if ($ignoreVCSIgnored) {            $this->ignore |= static::IGNORE_VCS_IGNORED_FILES;        } else {            $this->ignore &= ~static::IGNORE_VCS_IGNORED_FILES;        }        return $this;    }    /**     * Adds VCS patterns.     *     * @see ignoreVCS()     *     * @param string|string[] $pattern VCS patterns to ignore     */    public static function addVCSPattern($pattern)

			Why this impedes flexibility

Static methods
Summary of issues
Tight Coupling
Hidden dependencies
Global state (if also using static variables)
Tight Coupling
Use of static methods always reduces flexibility by introducing tight coupling[1]. A static method tightly couples the calling code to the specific class the method exists in.

 
function totalAbs(double value, double value2) {
    return abs(value) + abs(value2);
}

Here, the method totalAbs has a dependency on the Math class and the .abs() method will always be called. Although for testing purposes this may not be a problem, the coupling reduces flexibility because the total method can only work with doubles/integers, as that's all the Math.abs() function can use. Although type coercion will allow the use of any primitive numeric type, these types have limitations. It's impossible to use another class such as BigInteger or a class for dealing with greater precision decimals or even alternative numbering systems such as Roman numerals.
The totalAbs function takes two doubles and converts them to their absolute values before adding them. This is inflexible because it only works with doubles. It's tied to doubles because that's what the Math.abs() static method requires. If, instead, using OOP an interface was created to handle any number that had this method:

 interface Numeric {
    public function abs(): Numeric;
}

It would then be possible to rewrite the totalAbs method to work with any kind of number:

 function totalAbs(Numeric value, Numeric value): Numeric {
    return value.abs() + value2.abs();
}


By removing the static method and using an instance method in its place the totalAbs method is now agnostic about the type of number it is dealing with. It could be called with any of the following (assuming they implement the Numeric interface)

 
totalAbs(new Integer(4), new Integer(-53));

totalAbs(new Double(34.4), new Integer(-2));

totalAbs(new BigInteger('123445454564765739878989343225778'), new Integer(2343));

totalAbs(new RomanNumeral('VII'), new RomanNumeral('CXV'));


Making the method reusable in a way that it wasn't when static methods were being used. By changing the static methods to instance methods, flexibility has been enhanced as the method can be used with any numeric type, not just numeric types that are supported by the Math.abs() method.
Broken encapsulation
Static methods also break encapsulation. Encapsulation is defined by Rogers[2] as:
the bundling of data with the methods that operate on that data
By passing the numeric value into the abs method, the data being operated on is being separated from the methods that operate on it, breaking encapsulation. Instead using num.abs() the data is encapsulated in the num instance and its type is not visible or relevant to the outside world. abs() will work on the data and work regardless of num's type, providing it implements the abs method.
This is a simple example, but applies to all static methods. Use of polymorphic instance methods that work on encapsulated data will always be more flexible than static method calls which can only ever deal with specific pre-defined types.
Further reading
What is tight coupling?
Why Static is Bad and How to Avoid It
Static Methods Will Shock You
Flaw: Brittle Global State & Singletons
Static Methods are Death to Testability
Exceptions
The only exception to this rule is when a static method is used for object creation in place of the new keyword[3]. This is because the new keyword is already a static call. However, even here a non-static factory is often preferable for testing purposes[4][5].
References
Popov, N. (2014) Don't be STUPID: GRASP SOLID!  [online]. Available from: https://nikic.github.io/2011/12/27/Dont-be-STUPID-GRASP-SOLID.html 
Rogers, P. (2001) Encapsulation is not information hiding [online]. Available from: http://www.javaworld.com/article/2075271/core-java/encapsulation-is-not-information-hiding.html 
Sonmez, J. (2010)  Static Methods Will Shock You  [online]. Available from: http://simpleprogrammer.com/2010/01/29/static-methods-will-shock-you/ 
Hevery, M. (2008) Static Methods are Death to Testability [online]. Available from: http://misko.hevery.com/2008/12/15/static-methods-are-death-to-testability/ 
Butler, T. (2013) Are Static Methods/Variables bad practice? [online]. Available from: https://r.je/static-methods-bad-practice.html 
    {        foreach ((array) $pattern as $p) {            self::$vcsPatterns[] = $p;        }        self::$vcsPatterns = array_unique(self::$vcsPatterns);    }    /**     * Sorts files and directories by an anonymous function.     *     * The anonymous function receives two \SplFileInfo instances to compare.     *     * This can be slow as all the matching files and directories must be retrieved for comparison.     *     * @return $this     *     * @see SortableIterator     */    public function sort(\Closure $closure)    {        $this->sort = $closure;        return $this;    }    /**     * Sorts files and directories by name.     *     * This can be slow as all the matching files and directories must be retrieved for comparison.     *     * @return $this     *     * @see SortableIterator     */    public function sortByName(bool $useNaturalSort = false)    {        $this->sort = $useNaturalSort ? Iterator\SortableIterator::SORT_BY_NAME_NATURAL : Iterator\SortableIterator::SORT_BY_NAME;        return $this;    }    /**     * Sorts files and directories by type (directories before files), then by name.     *     * This can be slow as all the matching files and directories must be retrieved for comparison.     *     * @return $this     *     * @see SortableIterator     */    public function sortByType()    {        $this->sort = Iterator\SortableIterator::SORT_BY_TYPE;        return $this;    }    /**     * Sorts files and directories by the last accessed time.     *     * This is the time that the file was last accessed, read or written to.     *     * This can be slow as all the matching files and directories must be retrieved for comparison.     *     * @return $this     *     * @see SortableIterator     */    public function sortByAccessedTime()    {        $this->sort = Iterator\SortableIterator::SORT_BY_ACCESSED_TIME;        return $this;    }    /**     * Reverses the sorting.     *     * @return $this     */    public function reverseSorting()    {        $this->reverseSorting = true;        return $this;    }    /**     * Sorts files and directories by the last inode changed time.     *     * This is the time that the inode information was last modified (permissions, owner, group or other metadata).     *     * On Windows, since inode is not available, changed time is actually the file creation time.     *     * This can be slow as all the matching files and directories must be retrieved for comparison.     *     * @return $this     *     * @see SortableIterator     */    public function sortByChangedTime()    {        $this->sort = Iterator\SortableIterator::SORT_BY_CHANGED_TIME;        return $this;    }    /**     * Sorts files and directories by the last modified time.     *     * This is the last time the actual contents of the file were last modified.     *     * This can be slow as all the matching files and directories must be retrieved for comparison.     *     * @return $this     *     * @see SortableIterator     */    public function sortByModifiedTime()    {        $this->sort = Iterator\SortableIterator::SORT_BY_MODIFIED_TIME;        return $this;    }    /**     * Filters the iterator with an anonymous function.     *     * The anonymous function receives a \SplFileInfo and must return false     * to remove files.     *     * @return $this     *     * @see CustomFilterIterator     */    public function filter(\Closure $closure)    {        $this->filters[] = $closure;        return $this;    }    /**     * Forces the following of symlinks.     *     * @return $this     */    public function followLinks()    {        $this->followLinks = true;        return $this;    }    /**     * Tells finder to ignore unreadable directories.     *     * By default, scanning unreadable directories content throws an AccessDeniedException.     *     * @return $this     */    public function ignoreUnreadableDirs(bool $ignore = true)    {        $this->ignoreUnreadableDirs = $ignore;        return $this;    }    /**     * Searches files and directories which match defined rules.     *     * @param string|string[] $dirs A directory path or an array of directories     *     * @return $this     *     * @throws DirectoryNotFoundException if one of the directories does not exist     */    public function in($dirs)    {        $resolvedDirs = [];        foreach ((array) $dirs as $dir) {            if (is_dir($dir)) {                $resolvedDirs[] = $this->normalizeDir($dir);            } elseif ($glob = glob($dir, (\defined('GLOB_BRACE') ? \GLOB_BRACE : 0) | \GLOB_ONLYDIR | \GLOB_NOSORT)) {                sort($glob);                $resolvedDirs = array_merge($resolvedDirs, array_map([$this, 'normalizeDir'], $glob));            } else {                throw new DirectoryNotFoundException(sprintf('The "%s" directory does not exist.', $dir));            }        }        $this->dirs = array_merge($this->dirs, $resolvedDirs);        return $this;    }    /**     * Returns an Iterator for the current Finder configuration.     *     * This method implements the IteratorAggregate interface.     *     * @return \Iterator|SplFileInfo[] An iterator     *     * @throws \LogicException if the in() method has not been called     */    #[\ReturnTypeWillChange]    public function getIterator()    {        if (0 === \count($this->dirs) && 0 === \count($this->iterators)) {            throw new \LogicException('You must call one of in() or append() methods before iterating over a Finder.');        }        if (1 === \count($this->dirs) && 0 === \count($this->iterators)) {            $iterator = $this->searchInDirectory($this->dirs[0]);            if ($this->sort || $this->reverseSorting) {                $iterator = (new Iterator\SortableIterator($iterator, $this->sort, $this->reverseSorting))->getIterator();            }            return $iterator;        }        $iterator = new \AppendIterator();        foreach ($this->dirs as $dir) {            $iterator->append(new \IteratorIterator(new LazyIterator(function () use ($dir) {                return $this->searchInDirectory($dir);            })));        }        foreach ($this->iterators as $it) {            $iterator->append($it);        }        if ($this->sort || $this->reverseSorting) {            $iterator = (new Iterator\SortableIterator($iterator, $this->sort, $this->reverseSorting))->getIterator();        }        return $iterator;    }    /**     * Appends an existing set of files/directories to the finder.     *     * The set can be another Finder, an Iterator, an IteratorAggregate, or even a plain array.     *     * @return $this     *     * @throws \InvalidArgumentException when the given argument is not iterable     */    public function append(iterable $iterator)    {        if ($iterator instanceof \IteratorAggregate) {            $this->iterators[] = $iterator->getIterator();        } elseif ($iterator instanceof \Iterator) {            $this->iterators[] = $iterator;        } elseif (is_iterable($iterator)) {            $it = new \ArrayIterator();            foreach ($iterator as $file) {                $file = $file instanceof \SplFileInfo ? $file : new \SplFileInfo($file);                $it[$file->getPathname()] = $file;            }            $this->iterators[] = $it;        } else {            throw new \InvalidArgumentException('Finder::append() method wrong argument type.');        }        return $this;    }    /**     * Check if any results were found.     *     * @return bool     */    public function hasResults()    {        foreach ($this->getIterator() as $_) {            return true;        }        return false;    }    /**     * Counts all the results collected by the iterators.     *     * @return int     */    #[\ReturnTypeWillChange]    public function count()    {        return iterator_count($this->getIterator());    }    private function searchInDirectory(string $dir): \Iterator    {        $exclude = $this->exclude;        $notPaths = $this->notPaths;        if (static::IGNORE_VCS_FILES === (static::IGNORE_VCS_FILES & $this->ignore)) {            $exclude = array_merge($exclude, self::$vcsPatterns);        }        if (static::IGNORE_DOT_FILES === (static::IGNORE_DOT_FILES & $this->ignore)) {            $notPaths[] = '#(^|/)\..+(/|$)#';        }        if (static::IGNORE_VCS_IGNORED_FILES === (static::IGNORE_VCS_IGNORED_FILES & $this->ignore)) {            $gitignoreFilePath = sprintf('%s/.gitignore', $dir);            if (!is_readable($gitignoreFilePath)) {                throw new \RuntimeException(sprintf('The "ignoreVCSIgnored" option cannot be used by the Finder as the "%s" file is not readable.', $gitignoreFilePath));            }            $notPaths = array_merge($notPaths, [Gitignore::toRegex(file_get_contents($gitignoreFilePath))]);        }        $minDepth = 0;        $maxDepth = \PHP_INT_MAX;        foreach ($this->depths as $comparator) {            switch ($comparator->getOperator()) {                case '>':                    $minDepth = $comparator->getTarget() + 1;                    break;                case '>=':                    $minDepth = $comparator->getTarget();                    break;                case '<':                    $maxDepth = $comparator->getTarget() - 1;                    break;                case '<=':                    $maxDepth = $comparator->getTarget();                    break;                default:                    $minDepth = $maxDepth = $comparator->getTarget();            }        }        $flags = \RecursiveDirectoryIterator::SKIP_DOTS;        if ($this->followLinks) {            $flags |= \RecursiveDirectoryIterator::FOLLOW_SYMLINKS;        }        $iterator = new Iterator\RecursiveDirectoryIterator($dir, $flags, $this->ignoreUnreadableDirs);        if ($exclude) {            $iterator = new Iterator\ExcludeDirectoryFilterIterator($iterator, $exclude);        }        $iterator = new \RecursiveIteratorIterator($iterator, \RecursiveIteratorIterator::SELF_FIRST);        if ($minDepth > 0 || $maxDepth < \PHP_INT_MAX) {            $iterator = new Iterator\DepthRangeFilterIterator($iterator, $minDepth, $maxDepth);        }        if ($this->mode) {            $iterator = new Iterator\FileTypeFilterIterator($iterator, $this->mode);        }        if ($this->names || $this->notNames) {            $iterator = new Iterator\FilenameFilterIterator($iterator, $this->names, $this->notNames);        }        if ($this->contains || $this->notContains) {            $iterator = new Iterator\FilecontentFilterIterator($iterator, $this->contains, $this->notContains);        }        if ($this->sizes) {            $iterator = new Iterator\SizeRangeFilterIterator($iterator, $this->sizes);        }        if ($this->dates) {            $iterator = new Iterator\DateRangeFilterIterator($iterator, $this->dates);        }        if ($this->filters) {            $iterator = new Iterator\CustomFilterIterator($iterator, $this->filters);        }        if ($this->paths || $notPaths) {            $iterator = new Iterator\PathFilterIterator($iterator, $this->paths, $notPaths);        }        return $iterator;    }    /**     * Normalizes given directory names by removing trailing slashes.     *     * Excluding: (s)ftp:// or ssh2.(s)ftp:// wrapper     */    private function normalizeDir(string $dir): string    {        if ('/' === $dir) {            return $dir;        }        $dir = rtrim($dir, '/'.\DIRECTORY_SEPARATOR);        if (preg_match('#^(ssh2\.)?s?ftp://#', $dir)) {            $dir .= '/';        }        return $dir;    }}