Phing\Io\FileSystem

Complexity

Total Complexity

99

Size/Duplication

Total Lines	900
Duplicated Lines	0 %

Test Coverage

Coverage

47.96%

Importance

Changes

0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	deleteOnExit()	0	3	1
A	setLastModifiedTime()	0	9	2
A	delete()	0	6	2
A	checkAccess()	0	28	6
A	copy()	0	20	3
A	compare()	0	3	1
A	getLastModifiedTime()	0	30	5
A	rename()	0	11	2
A	getLength()	0	13	2
A	canDelete()	0	6	1
A	createNewFile()	0	17	3
A	createDirectory()	0	15	3
B	copyr()	0	33	9
A	deleteFilesOnExit()	0	4	2
A	getFileSystem()	0	16	4
A	canonicalize()	0	3	1
A	symlink()	0	13	2
A	umask()	0	15	2
C	which()	0	51	15
A	touch()	0	15	3
A	chgrp()	0	7	2
C	rmdir()	0	68	12
A	compareMTimes()	0	24	5
A	unlink()	0	8	2
A	listContents()	0	7	1
A	unlock()	0	8	2
A	chown()	0	7	2
A	lock()	0	8	2
A	chmod()	0	8	2

<?php
/**
 * 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>.
 */

namespace Phing\Io;

use Exception;
use FilesystemIterator;
use Phing\Phing;

/**
 * This is an abstract class for platform specific filesystem implementations
 * you have to implement each method in the platform specific filesystem implementation
 * classes Your local filesytem implementation must extend this class.
 * You should also use this class as a template to write your local implementation
 * Some native PHP filesystem specific methods are abstracted here as well. Anyway
 * you _must_ always use this methods via a PhingFile object (that by nature uses the
 * *FileSystem drivers to access the real filesystem via this class using natives.
 *
 * FIXME:
 *  - Error handling reduced to min fallthrough runtime exceptions
 *    more precise errorhandling is done by the PhingFile class
 *
 * @author Charlie Killian <charlie@tizac.com>
 * @author Hans Lellelid <hans@xmpl.org>
 *
 */
abstract class FileSystem
{

    /**
     * @var int
     */
    public const BA_EXISTS = 0x01;

    /**
     * @var int
     */
    public const BA_REGULAR = 0x02;

    /**
     * @var int
     */
    public const BA_DIRECTORY = 0x04;

    /**
     * @var int
     */
    public const BA_HIDDEN = 0x08;

    /**
     * Instance for getFileSystem() method.
     *
     * @var FileSystem
     */
    private static $fs;

    /**
     * @var File[]
     */
    private static $filesToDelete = [];

    /**
     * Static method to return the FileSystem singelton representing
     * this platform's local filesystem driver.
     *
     * @return FileSystem
     * @throws IOException
     */
    public static function getFileSystem()
    {
        if (self::$fs === null) {
            switch (Phing::getProperty('host.fstype')) {
                case 'UNIX':
                    self::$fs = new UnixFileSystem();
                    break;
                case 'WINDOWS':
                    self::$fs = new WindowsFileSystem();
                    break;
                default:
                    throw new IOException("Host uses unsupported filesystem, unable to proceed");
            }
        }

        return self::$fs;
    }

    /* -- Normalization and construction -- */

    /**
     * Return the local filesystem's name-separator character.
     */
    abstract public function getSeparator();

    /**
     * Return the local filesystem's path-separator character.
     */
    abstract public function getPathSeparator();

    /**
     * Convert the given pathname string to normal form.  If the string is
     * already in normal form then it is simply returned.
     *
     * @param string $strPath
     */
    abstract public function normalize($strPath);

    /**
     * Compute the length of this pathname string's prefix.  The pathname
     * string must be in normal form.
     *
     * @param string $pathname
     */
    abstract public function prefixLength($pathname);

    /**
     * Resolve the child pathname string against the parent.
     * Both strings must be in normal form, and the result
     * will be a string in normal form.
     *
     * @param string $parent
     * @param string $child
     */
    abstract public function resolve($parent, $child);

    /**
     * Resolve the given abstract pathname into absolute form.  Invoked by the
     * getAbsolutePath and getCanonicalPath methods in the PhingFile class.
     *
     * @param File $f
     */
    abstract public function resolveFile(File $f);

    /**
     * Return the parent pathname string to be used when the parent-directory
     * argument in one of the two-argument PhingFile constructors is the empty
     * pathname.
     */
    abstract public function getDefaultParent();

    /**
     * Post-process the given URI path string if necessary.  This is used on
     * win32, e.g., to transform "/c:/foo" into "c:/foo".  The path string
     * still has slash separators; code in the PhingFile class will translate them
     * after this method returns.
     *
     * @param string $path
     */
    abstract public function fromURIPath($path);

    /* -- Path operations -- */

    /**
     * Tell whether or not the given abstract pathname is absolute.
     *
     * @param File $f
     */
    abstract public function isAbsolute(File $f);

    /**
     * canonicalize filename by checking on disk
     *
     * @param  string $strPath
     * @return mixed  Canonical path or false if the file doesn't exist.
     */
    public function canonicalize($strPath)
    {
        return @realpath($strPath);
    }

    /* -- Attribute accessors -- */

    /**
     * Check whether the file or directory denoted by the given abstract
     * pathname may be accessed by this process.  If the second argument is
     * false, then a check for read access is made; if the second
     * argument is true, then a check for write (not read-write)
     * access is made.  Return false if access is denied or an I/O error
     * occurs.
     *
     * @param  File    $f
     * @param  boolean $write
     * @return bool
     */
    public function checkAccess(File $f, $write = false)
    {
        // we clear stat cache, its expensive to look up from scratch,
        // but we need to be sure
        @clearstatcache();

It seems like you do not handle an error condition for clearstatcache(). This can introduce security issues, and is generally not recommended.

Are you sure the usage of clearstatcache() is correct as it seems to always return null.

        // Shouldn't this be $f->GetAbsolutePath() ?
        // And why doesn't GetAbsolutePath() work?

        $strPath = (string) $f->getPath();

        // FIXME
        // if file object does denote a file that yet not existst
        // path rights are checked
        if (!@file_exists($strPath) && !is_dir($strPath)) {
            $strPath = $f->getParent();
            if ($strPath === null || !is_dir($strPath)) {
                $strPath = Phing::getProperty("user.dir");
            }
            //$strPath = dirname($strPath);
        }

        if (!$write) {
            return (bool) @is_readable($strPath);
        }

        return (bool) @is_writable($strPath);
    }

    /**
     * Whether file can be deleted.
     *
     * @param  File $f
     * @return boolean
     */
    public function canDelete(File $f)
    {
        clearstatcache();
        $dir = dirname($f->getAbsolutePath());

        return @is_writable($dir);
    }

    /**
     * Return the time at which the file or directory denoted by the given
     * abstract pathname was last modified, or zero if it does not exist or
     * some other I/O error occurs.
     *
     * @param  File $f
     * @return int
     * @throws IOException
     */
    public function getLastModifiedTime(File $f)
    {
        if (!$f->exists()) {
            return 0;
        }

        @clearstatcache();

It seems like you do not handle an error condition for clearstatcache(). This can introduce security issues, and is generally not recommended.

Are you sure the usage of clearstatcache() is correct as it seems to always return null.

        error_clear_last();
        $strPath = (string) $f->getPath();

        if (@is_link($strPath)) {
            $stats = @lstat($strPath);

            if (!isset($stats['mtime'])) {
                $mtime = false;
            } else {
                $mtime = $stats['mtime'];
            }
        } else {
            $mtime = @filemtime($strPath);
        }

        if (false === $mtime) {
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';
            $msg = "FileSystem::getLastModifiedTime() FAILED. Can not get modified time of $strPath. $errormsg";
            throw new IOException($msg);
        }

        return (int) $mtime;
    }

    /**
     * Return the length in bytes of the file denoted by the given abstract
     * pathname, or zero if it does not exist, is a directory, or some other
     * I/O error occurs.
     *
     * @param  File $f
     * @return int
     * @throws IOException
     */
    public function getLength(File $f)
    {
        error_clear_last();
        $strPath = (string) $f->getAbsolutePath();
        $fs = filesize((string) $strPath);
        if ($fs !== false) {
            return $fs;
        }

        $lastError = error_get_last();
        $errormsg = $lastError['message'] ?? 'unknown error';
        $msg = "FileSystem::Read() FAILED. Cannot get filesize of $strPath. $errormsg";
        throw new IOException($msg);
    }

    /* -- File operations -- */

    /**
     * Create a new empty file with the given pathname.  Return
     * true if the file was created and false if a
     * file or directory with the given pathname already exists.  Throw an
     * IOException if an I/O error occurs.
     *
     * @param  string $strPathname Path of the file to be created.
     * @return boolean
     * @throws IOException
     */
    public function createNewFile($strPathname)
    {
        if (@file_exists($strPathname)) {
            return false;
        }

        // Create new file
        $fp = @fopen($strPathname, "w");
        if ($fp === false) {
            $error = error_get_last();
            throw new IOException(
                "The file \"$strPathname\" could not be created: " . $error['message'] ?? 'unknown error'
            );
        }
        @fclose($fp);

It seems like you do not handle an error condition for fclose(). This can introduce security issues, and is generally not recommended.

        return true;
    }

    /**
     * Delete the file or directory denoted by the given abstract pathname,
     * returning true if and only if the operation succeeds.
     *
     * @param  File    $f
     * @param  boolean $recursive
     * @throws IOException
     */
    public function delete(File $f, $recursive = false)
    {
        if ($f->isDirectory()) {
            $this->rmdir($f->getPath(), $recursive);
        } else {
            $this->unlink($f->getPath());
        }
    }

    /**
     * Arrange for the file or directory denoted by the given abstract
     * pathname to be deleted when Phing::shutdown is called, returning
     * true if and only if the operation succeeds.
     *
     * @param  File $f
     * @throws IOException
     */
    public function deleteOnExit(File $f)
    {
        self::$filesToDelete[] = $f;
    }

    public static function deleteFilesOnExit()
    {
        foreach (self::$filesToDelete as $file) {
            $file->delete();
        }
    }

    /**
     * Create a new directory denoted by the given abstract pathname,
     * returning true if and only if the operation succeeds.
     *
     * The behaviour is the same as of "mkdir" command in Linux.
     * Without $mode argument, the directory is created with permissions
     * corresponding to the umask setting.
     * If $mode argument is specified, umask setting is ignored and
     * the permissions are set according to the $mode argument using chmod().
     *
     * @param  File     $f
     * @param  int|null $mode
     * @return boolean
     */
    public function createDirectory(&$f, $mode = null)
    {
        if ($mode === null) {
            $return = @mkdir($f->getAbsolutePath());
        } else {
            // If the $mode is specified, mkdir() is called with the $mode
            // argument so that the new directory does not temporarily have
            // higher permissions than it should before chmod() is called.
            $return = @mkdir($f->getAbsolutePath(), $mode);
            if ($return) {
                chmod($f->getAbsolutePath(), $mode);
            }
        }

        return $return;
    }

    /**
     * Rename the file or directory denoted by the first abstract pathname to
     * the second abstract pathname, returning true if and only if
     * the operation succeeds.
     *
     * @param  File $f1 abstract source file
     * @param  File $f2 abstract destination file
     * @return void
     * @throws IOException if rename cannot be performed
     */
    public function rename(File $f1, File $f2)
    {
        error_clear_last();
        // get the canonical paths of the file to rename
        $src = $f1->getAbsolutePath();
        $dest = $f2->getAbsolutePath();
        if (false === @rename($src, $dest)) {
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';
            $msg = "Rename FAILED. Cannot rename $src to $dest. $errormsg";
            throw new IOException($msg);
        }
    }

    /**
     * Set the last-modified time of the file or directory denoted by the
     * given abstract pathname returning true if and only if the
     * operation succeeds.
     *
     * @param  File $f
     * @param  int  $time
     * @return void
     * @throws IOException
     */
    public function setLastModifiedTime(File $f, $time)
    {
        error_clear_last();
        $path = $f->getPath();
        $success = @touch($path, $time);
        if (!$success) {
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';
            throw new IOException("Could not touch '" . $path . "' due to: $errormsg");
        }
    }

    /* -- Basic infrastructure -- */

    /**
     * Compare two abstract pathnames lexicographically.
     *
     * @param  File $f1
     * @param  File $f2
     * @return int
     * @throws IOException
     */
    public function compare(File $f1, File $f2)
    {
        throw new IOException("compare() not implemented by local fs driver");
    }

    /**
     * Copy a file.
     *
     * @param File $src  Source path and name file to copy.
     * @param File $dest Destination path and name of new file.
     *
     * @return void
     *
     * @throws IOException if file cannot be copied.
     */
    public function copy(File $src, File $dest)
    {
        // Recursively copy a directory
        if ($src->isDirectory()) {
            $this->copyr($src->getAbsolutePath(), $dest->getAbsolutePath());
        }

        $srcPath = $src->getAbsolutePath();
        $destPath = $dest->getAbsolutePath();

        error_clear_last();
        if (false === @copy($srcPath, $destPath)) { // Copy FAILED. Log and return err.
            // Add error from php to end of log message. $errormsg.
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';
            $msg = "FileSystem::copy() FAILED. Cannot copy $srcPath to $destPath. $errormsg";
            throw new IOException($msg);
        }

        $dest->setMode($src->getMode());
    }

    /**
     * Copy a file, or recursively copy a folder and its contents
     *
     * @param string $source Source path
     * @param string $dest   Destination path
     *
     * @return  bool   Returns TRUE on success, FALSE on failure
     * @author  Aidan Lister <aidan@php.net>
     * @version 1.0.1
     * @link    http://aidanlister.com/repos/v/function.copyr.php
     */
    public function copyr($source, $dest)
    {
        // Check for symlinks
        if (is_link($source)) {
            return symlink(readlink($source), $dest);
        }

        // Simple copy for a file
        if (is_file($source)) {
            return copy($source, $dest);
        }

        // Make destination directory
        if (!is_dir($dest) && !mkdir($dest) && !is_dir($dest)) {
            return false;
        }

        // Loop through the folder
        $dir = dir($source);
        while (false !== $entry = $dir->read()) {
            // Skip pointers
            if ($entry == '.' || $entry == '..') {
                continue;
            }

            // Deep copy directories
            $this->copyr("$source/$entry", "$dest/$entry");
        }

        // Clean up
        $dir->close();

        return true;
    }

    /**
     * Change the ownership on a file or directory.
     *
     * @param string $pathname Path and name of file or directory.
     * @param string $user     The user name or number of the file or directory. See http://us.php.net/chown
     *
     * @return void
     *
     * @throws IOException if operation failed.
     */
    public function chown($pathname, $user)
    {
        error_clear_last();
        if (false === @chown($pathname, $user)) { // FAILED.
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';
            throw new IOException("FileSystem::chown() FAILED. Cannot chown $pathname. User $user $errormsg");
        }
    }

    /**
     * Change the group on a file or directory.
     *
     * @param string $pathname Path and name of file or directory.
     * @param string $group    The group of the file or directory. See http://us.php.net/chgrp
     *
     * @return void
     * @throws IOException if operation failed.
     */
    public function chgrp($pathname, $group)
    {
        error_clear_last();
        if (false === @chgrp($pathname, $group)) { // FAILED.
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';
            throw new IOException("FileSystem::chgrp() FAILED. Cannot chown $pathname. Group $group $errormsg");
        }
    }

    /**
     * Change the permissions on a file or directory.
     *
     * @param string $pathname Path and name of file or directory.
     * @param int    $mode     The mode (permissions) of the file or
     *                         directory. If using octal add leading
     *                         0. eg. 0777. Mode is affected by the
     *                         umask system setting.
     *
     * @return void
     * @throws IOException if operation failed.
     */
    public function chmod($pathname, $mode)
    {
        error_clear_last();
        $str_mode = decoct($mode); // Show octal in messages.
        if (false === @chmod($pathname, $mode)) { // FAILED.
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';
            throw new IOException("FileSystem::chmod() FAILED. Cannot chmod $pathname. Mode $str_mode $errormsg");
        }
    }

    /**
     * Locks a file and throws an Exception if this is not possible.
     *
     * @param  File $f
     * @return void
     * @throws IOException
     */
    public function lock(File $f)
    {
        $filename = $f->getPath();
        $fp = @fopen($filename, "w");
        $result = @flock($fp, LOCK_EX);

It seems like $fp can also be of type false; however, parameter $stream of flock() does only seem to accept resource, maybe add an additional type check?

        @fclose($fp);

It seems like $fp can also be of type false; however, parameter $stream of fclose() does only seem to accept resource, maybe add an additional type check?

It seems like you do not handle an error condition for fclose(). This can introduce security issues, and is generally not recommended.

        if (!$result) {
            throw new IOException("Could not lock file '$filename'");
        }
    }

    /**
     * Unlocks a file and throws an IO Error if this is not possible.
     *
     * @param  File $f
     * @return void
     * @throws IOException
     */
    public function unlock(File $f)
    {
        $filename = $f->getPath();
        $fp = @fopen($filename, "w");
        $result = @flock($fp, LOCK_UN);

It seems like $fp can also be of type false; however, parameter $stream of flock() does only seem to accept resource, maybe add an additional type check?

        fclose($fp);

It seems like $fp can also be of type false; however, parameter $stream of fclose() does only seem to accept resource, maybe add an additional type check?

        if (!$result) {
            throw new IOException("Could not unlock file '$filename'");
        }
    }

    /**
     * Delete a file.
     *
     * @param string $file Path and/or name of file to delete.
     *
     * @return void
     * @throws IOException - if an error is encountered.
     */
    public function unlink($file)
    {
        error_clear_last();
        if (false === @unlink($file)) {
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';
            $msg = "FileSystem::unlink() FAILED. Cannot unlink '$file'. $errormsg";
            throw new IOException($msg);
        }
    }

    /**
     * Symbolically link a file to another name.
     *
     * Currently symlink is not implemented on Windows. Don't use if the application is to be portable.
     *
     * @param  string $target Path and/or name of file to link.
     * @param  string $link   Path and/or name of link to be created.
     * @return void
     * @throws IOException
     */
    public function symlink($target, $link)
    {

        error_clear_last();
        // If Windows OS then symlink() will report it is not supported in
        // the build. Use this error instead of checking for Windows as the OS.

        if (false === @symlink($target, $link)) {
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';
            // Add error from php to end of log message.
            $msg = "FileSystem::Symlink() FAILED. Cannot symlink '$target' to '$link'. $errormsg";
            throw new IOException($msg);
        }
    }

    /**
     * Set the modification and access time on a file to the present time.
     *
     * @param  string $file Path and/or name of file to touch.
     * @param  int    $time
     * @return void
     * @throws Exception
     */
    public function touch($file, $time = null)
    {
        error_clear_last();
        if (null === $time) {
            $error = @touch($file);
        } else {
            $error = @touch($file, $time);
        }

        if (false === $error) { // FAILED.
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';
            // Add error from php to end of log message.
            $msg = "FileSystem::touch() FAILED. Cannot touch '$file'. $errormsg";
            throw new Exception($msg);
        }
    }

    /**
     * Delete an empty directory OR a directory and all of its contents.
     *
     * @param string $dir      Path and/or name of directory to delete.
     * @param bool   $children False: don't delete directory contents.
     *                         True: delete directory contents.
     *
     * @return void
     * @throws Exception
     */
    public function rmdir($dir, $children = false)
    {
        error_clear_last();

        // If children=FALSE only delete dir if empty.
        if (false === $children) {
            if (false === @rmdir($dir)) { // FAILED.
                $lastError = error_get_last();
                $errormsg = $lastError['message'] ?? 'unknown error';
                // Add error from php to end of log message.
                $msg = "FileSystem::rmdir() FAILED. Cannot rmdir $dir. $errormsg";
                throw new Exception($msg);
            }
        } else { // delete contents and dir.
            $handle = @opendir($dir);
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';

            if (false === $handle) { // Error.
                $msg = "FileSystem::rmdir() FAILED. Cannot opendir() $dir. $errormsg";
                throw new Exception($msg);
            }
            // Read from handle.
            // Don't error on readdir().
            while (false !== ($entry = @readdir($handle))) {
                if ($entry != '.' && $entry != '..') {
                    // Only add / if it isn't already the last char.
                    // This ONLY serves the purpose of making the Logger
                    // output look nice:)

                    if (strpos(strrev($dir), DIRECTORY_SEPARATOR) === 0) { // there is a /
                        $next_entry = $dir . $entry;
                    } else { // no /
                        $next_entry = $dir . DIRECTORY_SEPARATOR . $entry;
                    }

                    // NOTE: As of php 4.1.1 is_dir doesn't return FALSE it
                    // returns 0. So use == not ===.

                    // Don't error on is_dir()
                    if (false == @is_dir($next_entry)) { // Is file.

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

                        try {
                            $this->unlink($next_entry); // Delete.
                        } catch (Exception $e) {
                            $msg = "FileSystem::Rmdir() FAILED. Cannot FileSystem::Unlink() $next_entry. " . $e->getMessage();
                            throw new Exception($msg);
                        }
                    } else { // Is directory.
                        try {
                            $this->rmdir($next_entry, true); // Delete
                        } catch (Exception $e) {
                            $msg = "FileSystem::rmdir() FAILED. Cannot FileSystem::rmdir() $next_entry. " . $e->getMessage();
                            throw new Exception($msg);
                        }
                    }
                }
            }

            // Don't error on closedir()
            @closedir($handle);

It seems like you do not handle an error condition for closedir(). This can introduce security issues, and is generally not recommended.

Are you sure the usage of closedir($handle) is correct as it seems to always return null.

            error_clear_last();
            if (false === @rmdir($dir)) { // FAILED.
                // Add error from php to end of log message.
                $lastError = error_get_last();
                $errormsg = $lastError['message'] ?? 'unknown error';
                $msg = "FileSystem::rmdir() FAILED. Cannot rmdir $dir. $errormsg";
                throw new Exception($msg);
            }
        }
    }

    /**
     * Set the umask for file and directory creation.
     *
     * @param    Int $mode
     * @return   void
     * @throws   Exception
     * @internal param Int $mode . Permissions usually in ocatal. Use leading 0 for
     *                    octal. Number between 0 and 0777.
     */
    public function umask($mode)
    {
        error_clear_last();
        // CONSIDERME:
        // Throw a warning if mode is 0. PHP converts illegal octal numbers to
        // 0 so 0 might not be what the user intended.

        $str_mode = decoct($mode); // Show octal in messages.

        if (false === @umask($mode)) { // FAILED.
            $lastError = error_get_last();
            $errormsg = $lastError['message'] ?? 'unknown error';
            // Add error from php to end of log message.
            $msg = "FileSystem::Umask() FAILED. Value $str_mode. $errormsg";
            throw new Exception($msg);
        }
    }

    /**
     * Compare the modified time of two files.
     *
     * @param string $file1 Path and name of file1.
     * @param string $file2 Path and name of file2.
     *
     * @return int  1 if file1 is newer.
     *              -1 if file2 is newer.
     *              0 if files have the same time.
     *              Err object on failure.
     *
     * @throws Exception - if cannot get modified time of either file.
     */
    public function compareMTimes($file1, $file2)
    {
        $mtime1 = filemtime($file1);
        $mtime2 = filemtime($file2);

        if ($mtime1 === false) { // FAILED. Log and return err.
            // Add error from php to end of log message.
            $msg = "FileSystem::compareMTimes() FAILED. Cannot can not get modified time of $file1.";
            throw new Exception($msg);
        }

        if ($mtime2 === false) { // FAILED. Log and return err.
            // Add error from php to end of log message.
            $msg = "FileSystem::compareMTimes() FAILED. Cannot can not get modified time of $file2.";
            throw new Exception($msg);
        }

        // Worked. Log and return compare.
        // Compare mtimes.
        if ($mtime1 == $mtime2) {
            return 0;
        }

        return ($mtime1 < $mtime2) ? -1 : 1; // end compare
    }

    /**
     * returns the contents of a directory in an array
     *
     * @param  File $f
     * @return string[]
     */
    public function listContents(File $f)
    {
        return array_keys(
            iterator_to_array(
                new FilesystemIterator(
                    $f->getAbsolutePath(),
                    FilesystemIterator::KEY_AS_FILENAME
                )
            )
        );
    }

    /**
     * PHP implementation of the 'which' command.
     *
     * Used to retrieve/determine the full path for a command.
     *
     * @param string $executable Executable file to search for
     * @param mixed  $fallback   Default to fallback to.
     *
     * @return string Full path for the specified executable/command.
     */
    public function which($executable, $fallback = false)
    {
        if (is_string($executable)) {

The condition is_string($executable) is always true.

            if (trim($executable) === '') {
                return $fallback;

The expression return $fallback could also return false which is incompatible with the documented return type string. Did you maybe forget to handle an error condition?

            }
        } else {
            return $fallback;
        }
        if (basename($executable) === $executable) {
            $path = getenv("PATH");
        } else {
            $path = dirname($executable);
        }
        $dirSeparator = $this->getSeparator();
        $pathSeparator = $this->getPathSeparator();
        $elements = explode($pathSeparator, $path);
        $amount = count($elements);
        $fstype = Phing::getProperty('host.fstype');
        switch ($fstype) {
            case 'UNIX':
                for ($count = 0; $count < $amount; ++$count) {
                    $file = $elements[$count] . $dirSeparator . $executable;
                    if (file_exists($file) && is_executable($file)) {
                        return $file;
                    }
                }
                break;
            case 'WINDOWS':
                $exts = getenv('PATHEXT');
                if ($exts === false) {
                    $exts = ['.exe', '.bat', '.cmd', '.com'];
                } else {
                    $exts = explode($pathSeparator, $exts);
                }
                for ($count = 0; $count < $amount; $count++) {
                    foreach ($exts as $ext) {
                        $file = $elements[$count] . $dirSeparator . $executable . $ext;
                        // Not all of the extensions above need to be set executable on Windows for them to be executed.
                        // I'm sure there's a joke here somewhere.
                        if (file_exists($file)) {
                            return $file;
                        }
                    }
                }
                break;
        }
        if (file_exists($executable) && is_executable($executable)) {
            return $executable;
        }
        return $fallback;

The expression return $fallback could also return false which is incompatible with the documented return type string. Did you maybe forget to handle an error condition?

    }
}