PathConvert

Complexity

Total Complexity

44

Size/Duplication

Total Lines	388
Duplicated Lines	0 %

Test Coverage

Coverage

61.6%

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	createPath()	0	10	3
A	setDirSep()	0	3	1
A	createMapper()	0	8	2
A	setRefid()	0	7	2
A	setSetonempty()	0	3	1
F	main()	0	97	15
A	mapElement()	0	22	4
A	isReference()	0	3	1
A	setPathSep()	0	3	1
A	setTargetos()	0	4	1
A	createMap()	0	7	1
A	setProperty()	0	3	1
A	__construct()	0	4	1
A	noChildrenAllowed()	0	5	1
B	validateSetup()	0	26	7
A	isPreserveDuplicates()	0	3	1
A	setPreserveDuplicates()	0	3	1

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

/**
 * Converts path and classpath information to a specific target OS
 * format. The resulting formatted path is placed into the specified property.
 *
 * @author Siad Ardroumli <siad.ardroumli@gmail.com>
 *
 * @package phing.tasks.system
 */
class PathConvert extends Task
{
    // Members
    /**
     * Path to be converted
     */
    private $path = null;
    /**
     * Reference to path/fileset to convert
     *
     * @var Reference $refid
     */
    private $refid = null;
    /**
     * The target OS type
     */
    private $targetOS = null;
    /**
     * Set when targetOS is set to windows
     */
    private $targetWindows = false;
    /**
     * Set if we're running on windows
     */
    public $onWindows = false;
    /**
     * Set if we should create a new property even if the result is empty
     */
    private $setonempty = true;
    /**
     * The property to receive the conversion
     */
    private $property = null;
    /**
     * Path prefix map
     *
     * @var MapEntry[]
     */
    private $prefixMap = [];
    /**
     * User override on path sep char
     */
    private $pathSep = null;
    /**
     * User override on directory sep char
     */
    private $dirSep = null;

    public $from = null;
    public $to = null;
    private $mapper;
    private $preserveDuplicates = false;

    /**
     * constructor
     */
    public function __construct()
    {
        parent::__construct();
        $this->onWindows = strncasecmp(PHP_OS, 'WIN', 3) === 0;
    }

    /**
     * Create a nested PATH element
     */
    public function createPath()
    {
        if ($this->isReference()) {
            throw $this->noChildrenAllowed();
        }

        if ($this->path === null) {
            $this->path = new Path($this->getProject());
        }
        return $this->path->createPath();
    }


    /**
     * Create a nested MAP element
     *
     * @return MapEntry a Map to configure
     */
    public function createMap()
    {
        $entry = new MapEntry($this);

        $this->prefixMap[] = $entry;

        return $entry;
    }

    /**
     * Set targetos to a platform to one of
     * "windows", "unix", "netware", or "os/2"; required unless
     * unless pathsep and/or dirsep are specified.
     */
    public function setTargetos($target)
    {
        $this->targetOS = $target;
        $this->targetWindows = $this->targetOS !== 'unix';
    }

    /**
     * Set setonempty
     *
     * If false, don't set the new property if the result is the empty string.
     *
     * @param bool $setonempty true or false
     */
    public function setSetonempty($setonempty)
    {
        $this->setonempty = $setonempty;
    }

    /**
     * The property into which the converted path will be placed.
     */
    public function setProperty($p)
    {
        $this->property = $p;
    }

    /**
     * Adds a reference to a Path, FileSet, DirSet, or FileList defined
     * elsewhere.
     *
     * @param Reference $r
     *
     * @throws BuildException
     */
    public function setRefid(Reference $r)
    {
        if ($this->path !== null) {
            throw $this->noChildrenAllowed();
        }

        $this->refid = $r;
    }


    /**
     * Set the default path separator string;
     * defaults to current JVM
     *
     * @param string $sep path separator string
     */
    public function setPathSep($sep)
    {
        $this->pathSep = $sep;
    }


    /**
     * Set the default directory separator string
     *
     * @param string $sep directory separator string
     */
    public function setDirSep($sep)
    {
        $this->dirSep = $sep;
    }


    /**
     * Has the refid attribute of this element been set?
     *
     * @return true if refid is valid
     */
    public function isReference()
    {
        return $this->refid !== null;

The expression return $this->refid !== null returns the type boolean which is incompatible with the documented return type true.

    }


    /**
     * Do the execution.
     *
     * @throws BuildException if something is invalid
     */
    public function main()
    {
        $savedPath = $this->path;
        $savedPathSep = $this->pathSep;// may be altered in validateSetup
        $savedDirSep = $this->dirSep;// may be altered in validateSetup

        try {
            // If we are a reference, create a Path from the reference
            if ($this->isReference()) {
                $this->path = new Path($this->getProject());
                $this->path = $this->path->createPath();

                $obj = $this->refid->getReferencedObject($this->getProject());

                if ($obj instanceof Path) {
                    $this->path->setRefid($this->refid);
                } elseif ($obj instanceof FileSet) {
                    $fs = $obj;

                    $this->path->addFileset($fs);
                } elseif ($obj instanceof DirSet) {
                    $ds = $obj;

                    $this->path->addDirset($ds);
                } elseif ($obj instanceof FileList) {
                    $fl = $obj;

                    $this->path->addFilelist($fl);
                } else {
                    throw new BuildException(
                        "'refid' does not refer to a "
                        . "path, fileset, dirset, or "
                        . "filelist."
                    );
                }
            }

            $this->validateSetup();// validate our setup

            // Currently, we deal with only two path formats: Unix and Windows
            // And Unix is everything that is not Windows
            // (with the exception for NetWare and OS/2 below)

            // for NetWare and OS/2, piggy-back on Windows, since here and
            // in the apply code, the same assumptions can be made as with
            // windows - that \\ is an OK separator, and do comparisons
            // case-insensitive.
            $fromDirSep = $this->onWindows ? "\\" : "/";

            $rslt = '';

            // Get the list of path components in canonical form
            $elems = $this->path->listPaths($this->isPreserveDuplicates());

            $mapperImpl = $this->mapper === null ? new IdentityMapper() : $this->mapper->getImplementation();
            foreach ($elems as &$elem) {
                $mapped = $mapperImpl->main($elem);
                for ($m = 0; $mapped !== null && $m < count($mapped); ++$m) {
                    $elem = $mapped[$m];
                }
            }
            unset($elem);
            foreach ($elems as $key => $elem) {
                $elem = $this->mapElement($elem);// Apply the path prefix map

                // Now convert the path and file separator characters from the
                // current os to the target os.

                if ($key !== 0) {
                    $rslt .= $this->pathSep;
                }

                $rslt .= str_replace($fromDirSep, $this->dirSep, $elem);
            }

            // Place the result into the specified property,
            // unless setonempty == false
            $value = $rslt;
            if ($this->setonempty) {
                $this->log(
                    "Set property " . $this->property . " = " . $value,
                    Project::MSG_VERBOSE
                );
                $this->getProject()->setNewProperty($this->property, $value);
            } else {
                if ($rslt !== '') {
                    $this->log(
                        "Set property " . $this->property . " = " . $value,
                        Project::MSG_VERBOSE
                    );
                    $this->getProject()->setNewProperty($this->property, $value);
                }
            }
        } finally {
            $this->path = $savedPath;
            $this->dirSep = $savedDirSep;
            $this->pathSep = $savedPathSep;
        }
    }

    /**
     * Apply the configured map to a path element. The map is used to convert
     * between Windows drive letters and Unix paths. If no map is configured,
     * then the input string is returned unchanged.
     *
     * @param  string $elem The path element to apply the map to
     * @return String Updated element
     */
    private function mapElement($elem)
    {
        $size = count($this->prefixMap);

        if ($size !== 0) {
            // Iterate over the map entries and apply each one.
            // Stop when one of the entries actually changes the element.

            foreach ($this->prefixMap as $entry) {
                $newElem = $entry->apply((string) $elem);

                // Note I'm using "!=" to see if we got a new object back from
                // the apply method.

                if ($newElem !== (string) $elem) {
                    $elem = $newElem;
                    break;// We applied one, so we're done
                }
            }
        }

        return $elem;
    }

    /**
     * @throws BuildException
     * @throws IOException
     */
    public function createMapper()
    {
        if ($this->mapper !== null) {
            throw new BuildException("Cannot define more than one mapper", $this->getLocation());
        }
        $this->mapper = new Mapper($this->project);

        return $this->mapper;
    }

    /**
     * Validate that all our parameters have been properly initialized.
     *
     * @throws BuildException if something is not setup properly
     */
    private function validateSetup()
    {
        if ($this->path === null) {
            throw new BuildException("You must specify a path to convert");
        }

        // Determine the separator strings.  The dirsep and pathsep attributes
        // override the targetOS settings.
        $dsep = FileUtils::getSeparator();
        $psep = FileUtils::getPathSeparator();

        if ($this->targetOS !== null) {
            $psep = $this->targetWindows ? ";" : ":";
            $dsep = $this->targetWindows ? "\\" : "/";
        }

        if ($this->pathSep !== null) {// override with pathsep=
            $psep = $this->pathSep;
        }

        if ($this->dirSep !== null) {// override with dirsep=
            $dsep = $this->dirSep;
        }

        $this->pathSep = $psep;
        $this->dirSep = $dsep;
    }


    /**
     * Creates an exception that indicates that this XML element must not have
     * child elements if the refid attribute is set.
     */
    private function noChildrenAllowed()
    {
        return new BuildException(
            "You must not specify nested <path> "
            . "elements when using the refid attribute."
        );
    }

    /**
     * Get the preserveDuplicates.
     *
     * @return boolean
     */
    public function isPreserveDuplicates(): bool
    {
        return $this->preserveDuplicates;
    }

    /**
     * @param bool $preserveDuplicates
     */
    public function setPreserveDuplicates(bool $preserveDuplicates): void
    {
        $this->preserveDuplicates = $preserveDuplicates;
    }
}