<?php
/*
 *  $Id: DirectoryScanner.php 905 2010-10-05 16:28:03Z mrook $
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the LGPL. For more information please see
 * <http://phing.info>.
 */

require_once 'phing/types/selectors/SelectorScanner.php'; 
include_once 'phing/util/StringHelper.php';
include_once 'phing/types/selectors/SelectorUtils.php';

/**
 * Class for scanning a directory for files/directories that match a certain
 * criteria.
 *
 * These criteria consist of a set of include and exclude patterns. With these
 * patterns, you can select which files you want to have included, and which
 * files you want to have excluded.
 *
 * The idea is simple. A given directory is recursively scanned for all files
 * and directories. Each file/directory is matched against a set of include
 * and exclude patterns. Only files/directories that match at least one
 * pattern of the include pattern list, and don't match a pattern of the
 * exclude pattern list will be placed in the list of files/directories found.
 *
 * When no list of include patterns is supplied, "**" will be used, which
 * means that everything will be matched. When no list of exclude patterns is
 * supplied, an empty list is used, such that nothing will be excluded.
 *
 * The pattern matching is done as follows:
 * The name to be matched is split up in path segments. A path segment is the
 * name of a directory or file, which is bounded by DIRECTORY_SEPARATOR
 * ('/' under UNIX, '\' under Windows).
 * E.g. "abc/def/ghi/xyz.php" is split up in the segments "abc", "def", "ghi"
 * and "xyz.php".
 * The same is done for the pattern against which should be matched.
 *
 * Then the segments of the name and the pattern will be matched against each
 * other. When '**' is used for a path segment in the pattern, then it matches
 * zero or more path segments of the name.
 *
 * There are special case regarding the use of DIRECTORY_SEPARATOR at
 * the beginning of the pattern and the string to match:
 * When a pattern starts with a DIRECTORY_SEPARATOR, the string
 * to match must also start with a DIRECTORY_SEPARATOR.
 * When a pattern does not start with a DIRECTORY_SEPARATOR, the
 * string to match may not start with a DIRECTORY_SEPARATOR.
 * When one of these rules is not obeyed, the string will not
 * match.
 *
 * When a name path segment is matched against a pattern path segment, the
 * following special characters can be used:
 *   '*' matches zero or more characters,
 *   '?' matches one character.
 *
 * Examples:
 *
 * "**\*.php" matches all .php files/dirs in a directory tree.
 *
 * "test\a??.php" matches all files/dirs which start with an 'a', then two
 * more characters and then ".php", in a directory called test.
 *
 * "**" matches everything in a directory tree.
 *
 * "**\test\**\XYZ*" matches all files/dirs that start with "XYZ" and where
 * there is a parent directory called test (e.g. "abc\test\def\ghi\XYZ123").
 *
 * Case sensitivity may be turned off if necessary.  By default, it is
 * turned on.
 *
 * Example of usage:
 *   $ds = new DirectroyScanner();
 *   $includes = array("**\*.php");
 *   $excludes = array("modules\*\**");
 *   $ds->SetIncludes($includes);
 *   $ds->SetExcludes($excludes);
 *   $ds->SetBasedir("test");
 *   $ds->SetCaseSensitive(true);
 *   $ds->Scan();
 *
 *   print("FILES:");
 *   $files = ds->GetIncludedFiles();
 *   for ($i = 0; $i < count($files);$i++) {
 *     println("$files[$i]\n");
 *   }
 *
 * This will scan a directory called test for .php files, but excludes all
 * .php files in all directories under a directory called "modules"
 *
 * This class is complete preg/ereg free port of the Java class
 * org.apache.tools.ant.DirectoryScanner. Even functions that use preg/ereg
 * internally (like split()) are not used. Only the _fast_ string functions
 * and comparison operators (=== !=== etc) are used for matching and tokenizing.
 *
 *  @author   Arnout J. Kuiper, ajkuiper@wxs.nl
 *  @author   Magesh Umasankar, umagesh@rediffmail.com
 *  @author   Andreas Aderhold, andi@binarycloud.com
 *
 *  @version   $Revision: 905 $
 *  @package   phing.util
 */
class DirectoryScanner implements SelectorScanner {

    /** default set of excludes */
    protected $DEFAULTEXCLUDES = array(
        "**/*~",
        "**/#*#",
        "**/.#*",
        "**/%*%",
        "**/CVS",
        "**/CVS/**",
        "**/.cvsignore",
        "**/SCCS",
        "**/SCCS/**",
        "**/vssver.scc",
        "**/.svn",
        "**/.svn/**",
        "**/._*",
        "**/.DS_Store",
    );

    /** The base directory which should be scanned. */
    protected $basedir;

    /** The patterns for the files that should be included. */
    protected $includes = null;

    /** The patterns for the files that should be excluded. */
    protected $excludes = null;
    
    /** Whether to expand/dereference symbolic links, default is false */
    protected $expandSymbolicLinks = false;

    /**
     * The files that where found and matched at least one includes, and matched
     * no excludes.
     */
    protected $filesIncluded;

    /** The files that where found and did not match any includes. Trie */
    protected $filesNotIncluded;

    /**
     * The files that where found and matched at least one includes, and also
     * matched at least one excludes. Trie object.
     */
    protected $filesExcluded;

    /**
     * The directories that where found and matched at least one includes, and
     * matched no excludes.
     */
    protected $dirsIncluded;

    /** The directories that where found and did not match any includes. */
    protected $dirsNotIncluded;

    /**
     * The files that where found and matched at least one includes, and also
     * matched at least one excludes.
     */
    protected $dirsExcluded;

    /** Have the vars holding our results been built by a slow scan? */
    protected $haveSlowResults = false;

    /** Should the file system be treated as a case sensitive one? */
    protected $isCaseSensitive = true;

    /** Selectors */
    protected $selectors = null;
    
    protected $filesDeselected;
    protected $dirsDeselected;
    
    /** if there are no deselected files */
    protected $everythingIncluded = true;        

    /**
     * Does the path match the start of this pattern up to the first "**".
     * This is a static mehtod and should always be called static
     *
     * This is not a general purpose test and should only be used if you
     * can live with false positives.
     *
     * pattern=**\a and str=b will yield true.
     *
     * @param   pattern             the (non-null) pattern to match against
     * @param   str                 the (non-null) string (path) to match
     * @param   isCaseSensitive     must matches be case sensitive?
     * @return  boolean             true if matches, otherwise false
     */
    function matchPatternStart($pattern, $str, $isCaseSensitive = true) {
        return SelectorUtils::matchPatternStart($pattern, $str, $isCaseSensitive);
    }

    /**
     * Matches a path against a pattern. Static
     *
     * @param pattern            the (non-null) pattern to match against
     * @param str                the (non-null) string (path) to match
     * @param isCaseSensitive    must a case sensitive match be done?
     *
     * @return true when the pattern matches against the string.
     *         false otherwise.
     */
    function matchPath($pattern, $str, $isCaseSensitive = true) {
        return SelectorUtils::matchPath($pattern, $str, $isCaseSensitive);
    }

    /**
     * Matches a string against a pattern. The pattern contains two special
     * characters:
     * '*' which means zero or more characters,
     * '?' which means one and only one character.
     *
     * @param  pattern the (non-null) pattern to match against
     * @param  str     the (non-null) string that must be matched against the
     *                 pattern
     *
     * @return boolean true when the string matches against the pattern,
     *                 false otherwise.
     * @access public
     */
    function match($pattern, $str, $isCaseSensitive = true) {
        return SelectorUtils::match($pattern, $str, $isCaseSensitive);
    }

    /**
     * Sets the basedir for scanning. This is the directory that is scanned
     * recursively. All '/' and '\' characters are replaced by
     * DIRECTORY_SEPARATOR
     *
     * @param basedir the (non-null) basedir for scanning
     */
    function setBasedir($_basedir) {
        $_basedir = str_replace('\\', DIRECTORY_SEPARATOR, $_basedir);
        $_basedir = str_replace('/', DIRECTORY_SEPARATOR, $_basedir);
        $this->basedir = $_basedir;
    }

    /**
     * Gets the basedir that is used for scanning. This is the directory that
     * is scanned recursively.
     *
     * @return the basedir that is used for scanning
     */
    function getBasedir() {
        return $this->basedir;
    }

    /**
     * Sets the case sensitivity of the file system
     *
     * @param specifies if the filesystem is case sensitive
     */
    function setCaseSensitive($_isCaseSensitive) {
        $this->isCaseSensitive = ($_isCaseSensitive) ? true : false;
    }

    /**
     * Sets the set of include patterns to use. All '/' and '\' characters are
     * replaced by DIRECTORY_SEPARATOR. So the separator used need
     * not match DIRECTORY_SEPARATOR.
     *
     * When a pattern ends with a '/' or '\', "**" is appended.
     *
     * @param includes list of include patterns
     */
    function setIncludes($_includes = array()) {
        if (empty($_includes) || is_null($_includes)) {
            $this->includes = null;
        } else {
            for ($i = 0; $i < count($_includes); $i++) {
                $pattern = null;
                $pattern = str_replace('\\', DIRECTORY_SEPARATOR, $_includes[$i]);
                $pattern = str_replace('/', DIRECTORY_SEPARATOR, $pattern);
                if (StringHelper::endsWith(DIRECTORY_SEPARATOR, $pattern)) {
                    $pattern .= "**";
                }
                $this->includes[] = $pattern;
            }
        }
    }

    /**
     * Sets the set of exclude patterns to use. All '/' and '\' characters are
     * replaced by <code>File.separatorChar</code>. So the separator used need
     * not match <code>File.separatorChar</code>.
     *
     * When a pattern ends with a '/' or '\', "**" is appended.
     *
     * @param excludes list of exclude patterns
     */

    function setExcludes($_excludes = array()) {
        if (empty($_excludes) || is_null($_excludes)) {
            $this->excludes = null;
        } else {
            for ($i = 0; $i < count($_excludes); $i++) {
                $pattern = null;
                $pattern = str_replace('\\', DIRECTORY_SEPARATOR, $_excludes[$i]);
                $pattern = str_replace('/', DIRECTORY_SEPARATOR, $pattern);
                if (StringHelper::endsWith(DIRECTORY_SEPARATOR, $pattern)) {
                    $pattern .= "**";
                }
                $this->excludes[] = $pattern;
            }
        }
    }
    
    /**
     * Sets whether to expand/dereference symbolic links
     *
     * @param expandSymbolicLinks boolean value
     */
    function setExpandSymbolicLinks($expandSymbolicLinks)
    {
        $this->expandSymbolicLinks = $expandSymbolicLinks;
    }

    /**
     * Scans the base directory for files that match at least one include
     * pattern, and don't match any exclude patterns.
     *
     */
    function scan() {
    
        if ((empty($this->basedir)) || (!@is_dir($this->basedir))) {
            return false;
        }

        if ($this->includes === null) {
            // No includes supplied, so set it to 'matches all'
            $this->includes = array("**");
        }
        if (is_null($this->excludes)) {
            $this->excludes = array();
        }

        $this->filesIncluded = array();
        $this->filesNotIncluded = array();
        $this->filesExcluded = array();
        $this->dirsIncluded = array();
        $this->dirsNotIncluded = array();
        $this->dirsExcluded = array();
        $this->dirsDeselected = array();
        $this->filesDeselected = array();
        
        if ($this->isIncluded("")) {
            if (!$this->isExcluded("")) {
                if ($this->isSelected("", $this->basedir)) {
                    $this->dirsIncluded[] = "";
                } else {
                    $this->dirsDeselected[] = "";
                }                
            } else {
                $this->dirsExcluded[] = "";
            }
        } else {
            $this->dirsNotIncluded[] = "";
        }

        $this->scandir($this->basedir, "", true);
        return true;
    }

    /**
     * Toplevel invocation for the scan.
     *
     * Returns immediately if a slow scan has already been requested.
     */
    protected function slowScan() {

        if ($this->haveSlowResults) {
            return;
        }

        // copy trie object add CopyInto() method
        $excl    = $this->dirsExcluded;
        $notIncl = $this->dirsNotIncluded;

        for ($i=0, $_i=count($excl); $i < $_i; $i++) {
            if (!$this->couldHoldIncluded($excl[$i])) {
                $this->scandir($this->basedir.$excl[$i], $excl[$i].DIRECTORY_SEPARATOR, false);
            }
        }

        for ($i=0, $_i=count($notIncl); $i < $_i; $i++) {
            if (!$this->couldHoldIncluded($notIncl[$i])) {
                $this->scandir($this->basedir.$notIncl[$i], $notIncl[$i].DIRECTORY_SEPARATOR, false);
            }
        }

        $this->haveSlowResults = true;
    }

    /**
     * Lists contens of a given directory and returns array with entries
     *
     * @param   src String. Source path and name file to copy.
     *
     * @access  public
     * @return  array  directory entries
     * @author  Albert Lash, alash@plateauinnovation.com
     */

    function listDir($_dir) {
        $d = dir($_dir);
        $list = array();
        while(($entry = $d->read()) !== false) {
            if ($entry != "." && $entry != "..") {
                $list[] = $entry;
            }
        }
        $d->close();
        return $list;
    }

    /**
     * Scans the passed dir for files and directories. Found files and
     * directories are placed in their respective collections, based on the
     * matching of includes and excludes. When a directory is found, it is
     * scanned recursively.
     *
     * @param dir   the directory to scan
     * @param vpath the path relative to the basedir (needed to prevent
     *              problems with an absolute path when using dir)
     *
     * @access private
     * @see #filesIncluded
     * @see #filesNotIncluded
     * @see #filesExcluded
     * @see #dirsIncluded
     * @see #dirsNotIncluded
     * @see #dirsExcluded
     */
    private function scandir($_rootdir, $_vpath, $_fast) {
        
        if (!is_readable($_rootdir)) {
            return;
        }                                
        
        $newfiles = self::listDir($_rootdir);
        
        for ($i=0,$_i=count($newfiles); $i < $_i; $i++) {
            
            $file = $_rootdir . DIRECTORY_SEPARATOR . $newfiles[$i];
            $name = $_vpath . $newfiles[$i];

            if (@is_link($file) && !$this->expandSymbolicLinks)
            {
                if ($this->isIncluded($name)) {
                    if (!$this->isExcluded($name)) {
                        if ($this->isSelected($name, $file)) {
                            $this->filesIncluded[] = $name;
                        } else {
                            $this->everythingIncluded = false;
                            $this->filesDeselected[] = $name;
                        }                        
                    } else {
                        $this->everythingIncluded = false;
                        $this->filesExcluded[] = $name;
                    }
                } else {
                    $this->everythingIncluded = false;
                    $this->filesNotIncluded[] = $name;
                }
            }
            else
            if (@is_dir($file)) {
                if ($this->isIncluded($name)) {
                    if (!$this->isExcluded($name)) {
                        if ($this->isSelected($name, $file)) {
                            $this->dirsIncluded[] = $name;
                            if ($_fast) {
                                $this->scandir($file, $name.DIRECTORY_SEPARATOR, $_fast);
                            }
                        } else {
                            $this->everythingIncluded = false;
                            $this->dirsDeselected[] = $name;
                            if ($_fast && $this->couldHoldIncluded($name)) {
                                $this->scandir($file, $name.DIRECTORY_SEPARATOR, $_fast);
                            }                            
                        }                                                
                    } else {
                        $this->everythingIncluded = false;
                        $this->dirsExcluded[] = $name;
                        if ($_fast && $this->couldHoldIncluded($name)) {
                            $this->scandir($file, $name.DIRECTORY_SEPARATOR, $_fast);
                        }
                    }
                } else {
                    $this->everythingIncluded = false;
                    $this->dirsNotIncluded[] = $name;
                    if ($_fast && $this->couldHoldIncluded($name)) {
                        $this->scandir($file, $name.DIRECTORY_SEPARATOR, $_fast);
                    }
                }
                
                if (!$_fast) {
                    $this->scandir($file, $name.DIRECTORY_SEPARATOR, $_fast);
                }
                
            } elseif (@is_file($file)) {
                if ($this->isIncluded($name)) {
                    if (!$this->isExcluded($name)) {
                        if ($this->isSelected($name, $file)) {
                            $this->filesIncluded[] = $name;
                        } else {
                            $this->everythingIncluded = false;
                            $this->filesDeselected[] = $name;
                        }                        
                    } else {
                        $this->everythingIncluded = false;
                        $this->filesExcluded[] = $name;
                    }
                } else {
                    $this->everythingIncluded = false;
                    $this->filesNotIncluded[] = $name;
                }
            }
        }
    }

    /**
     * Tests whether a name matches against at least one include pattern.
     *
     * @param name the name to match
     * @return <code>true</code> when the name matches against at least one
     *         include pattern, <code>false</code> otherwise.
     */
    protected function isIncluded($_name) {
        for ($i=0, $_i=count($this->includes); $i < $_i; $i++) {
            if (DirectoryScanner::matchPath($this->includes[$i], $_name, $this->isCaseSensitive)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Tests whether a name matches the start of at least one include pattern.
     *
     * @param name the name to match
     * @return <code>true</code> when the name matches against at least one
     *         include pattern, <code>false</code> otherwise.
     */
    protected function couldHoldIncluded($_name) {
        for ($i = 0; $i < count($this->includes); $i++) {
            if (DirectoryScanner::matchPatternStart($this->includes[$i], $_name, $this->isCaseSensitive)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Tests whether a name matches against at least one exclude pattern.
     *
     * @param name the name to match
     * @return <code>true</code> when the name matches against at least one
     *         exclude pattern, <code>false</code> otherwise.
     */
    protected function isExcluded($_name) {
        for ($i = 0; $i < count($this->excludes); $i++) {
            if (DirectoryScanner::matchPath($this->excludes[$i], $_name, $this->isCaseSensitive)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Get the names of the files that matched at least one of the include
     * patterns, and matched none of the exclude patterns.
     * The names are relative to the basedir.
     *
     * @return the names of the files
     */
    function getIncludedFiles() {
        return $this->filesIncluded;        
    }

    /**
     * Get the names of the files that matched at none of the include patterns.
     * The names are relative to the basedir.
     *
     * @return the names of the files
     */
    function getNotIncludedFiles() {
        $this->slowScan();
        return $this->filesNotIncluded;
    }

    /**
     * Get the names of the files that matched at least one of the include
     * patterns, an matched also at least one of the exclude patterns.
     * The names are relative to the basedir.
     *
     * @return the names of the files
     */

    function getExcludedFiles() {
        $this->slowScan();
        return $this->filesExcluded;
    }

    /**
     * <p>Returns the names of the files which were selected out and
     * therefore not ultimately included.</p>
     *
     * <p>The names are relative to the base directory. This involves
     * performing a slow scan if one has not already been completed.</p>
     *
     * @return the names of the files which were deselected.
     *
     * @see #slowScan
     */
    public function getDeselectedFiles() {
        $this->slowScan();        
        return $this->filesDeselected;
    }

    /**
     * Get the names of the directories that matched at least one of the include
     * patterns, an matched none of the exclude patterns.
     * The names are relative to the basedir.
     *
     * @return the names of the directories
     */

    function getIncludedDirectories() {
        return $this->dirsIncluded;        
    }

    /**
     * Get the names of the directories that matched at none of the include
     * patterns.
     * The names are relative to the basedir.
     *
     * @return the names of the directories
     */
    function getNotIncludedDirectories() {
        $this->slowScan();
        return $this->dirsNotIncluded;        
    }

    /**
     * <p>Returns the names of the directories which were selected out and
     * therefore not ultimately included.</p>
     *
     * <p>The names are relative to the base directory. This involves
     * performing a slow scan if one has not already been completed.</p>
     *
     * @return the names of the directories which were deselected.
     *
     * @see #slowScan
     */
    public function getDeselectedDirectories() {
        $this->slowScan();
        return $this->dirsDeselected;
    }
    
    /**
     * Get the names of the directories that matched at least one of the include
     * patterns, an matched also at least one of the exclude patterns.
     * The names are relative to the basedir.
     *
     * @return the names of the directories
     */
    function getExcludedDirectories() {
        $this->slowScan();
        return $this->dirsExcluded;        
    }

    /**
     * Adds the array with default exclusions to the current exclusions set.
     *
     */
    function addDefaultExcludes() {
        //$excludesLength = ($this->excludes == null) ? 0 : count($this->excludes);
        foreach($this->DEFAULTEXCLUDES as $pattern) {
            $pattern = str_replace('\\', DIRECTORY_SEPARATOR, $pattern);
            $pattern = str_replace('/', DIRECTORY_SEPARATOR, $pattern);
            $this->excludes[] = $pattern;
        }
    }
    
    /**
     * Sets the selectors that will select the filelist.
     *
     * @param selectors specifies the selectors to be invoked on a scan
     */
    public function setSelectors($selectors) {
        $this->selectors = $selectors;
    }

    /**
     * Returns whether or not the scanner has included all the files or
     * directories it has come across so far.
     *
     * @return <code>true</code> if all files and directories which have
     *         been found so far have been included.
     */
    public function isEverythingIncluded() {
        return $this->everythingIncluded;
    }
        
    /**
     * Tests whether a name should be selected.
     *
     * @param string $name The filename to check for selecting.
     * @param string $file The full file path.
     * @return boolean False when the selectors says that the file
     *         should not be selected, True otherwise.
     */
    protected function isSelected($name, $file) {
        if ($this->selectors !== null) {
            $basedir = new PhingFile($this->basedir);
            $file = new PhingFile($file);
            if (!$file->canRead())
                return false;
            
            foreach($this->selectors as $selector) {
                if (!$selector->isSelected($basedir, $name, $file)) {
                    return false;
                }
            }
        }
        return true;
    }

}
