N98\Util\WindowsSystem

Complexity

Total Complexity

16

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getInstance()	0	6	2
A	__construct()	0	3	1
A	getExecuteableExtesions()	0	9	2
A	isExecutableName()	0	17	3
B	isProgramInstalled()	0	33	8

<?php
/**
 * this file is part of magerun
 *
 * @author Tom Klingenberg <https://github.com/ktomk>
 */

namespace N98\Util;

/**
 * Class WindowsSystem
 *
 * Utility class with global static functions.
 *
 * @package N98\Util
 */
final class WindowsSystem
{
    const PATH_SEPARATOR = ';';

    const FORBIDDEN_CHARS = '<>:"/\|?*';

    /**
     * @var WindowsSystem
     */
    private static $instance;

    /**
     * @var array
     */
    private $exts;

    /**
     * an instance is bootstrapped in to prevent initialization overhead
     *
     * @return WindowsSystem
     */
    private static function getInstance()
    {
        self::$instance || self::$instance = new WindowsSystem();

        return self::$instance;
    }

    private function __construct()
    {
    }

    /**
     * @return array keys are uppercase extensions incl. dot
     */
    private function getExecuteableExtesions()
    {
        // PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.PSC1
        $this->exts || $this->exts = array_flip(

The expression $this->exts of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            array_map('strtoupper', explode(self::PATH_SEPARATOR, getenv('PATHEXT')))
        );

        return $this->exts;
    }

    /**
     * a name is executable based on it's extension
     *
     * @param string $name
     *
     * @return bool
     */
    public static function isExecutableName($name)
    {
        // invalid name is never executable
        if (false !== strpbrk($name, self::FORBIDDEN_CHARS)) {
            return false;
        }

        $compare = '.' . strtoupper(pathinfo($name, PATHINFO_EXTENSION));

        if ($compare === '.') {
            return false;
        }

        $exts = self::getInstance()->getExecuteableExtesions();

        return isset($exts[$compare]);
    }

    /**
     * a program (by it's basename) is available on system for execution
     *
     * @param string $program
     * @return bool
     */
    public static function isProgramInstalled($program)
    {
        // programs with an invalid name do not exist
        if (false !== strpbrk($program, self::FORBIDDEN_CHARS)) {
            return false;
        }

        $isExecutable = self::isExecutableName($program);

        $paths = explode(self::PATH_SEPARATOR, getenv('PATH'));
        array_unshift($paths, getcwd());
        $exts = self::getInstance()->getExecuteableExtesions();

        foreach ($paths as $path) {
            if (!is_dir($path)) {
                continue;
            }
            $file = $path . '/' . $program;

            if ($isExecutable && is_readable($file)) {
                return true;
            }

            foreach ($exts as $ext => $index) {
                $fileEx = $file . $ext;
                if (is_readable($fileEx)) {
                    return true;
                }
            }
        }

        return false;
    }
}