Phing\Tasks\System\AppendTask

Complexity

Total Complexity

79

Size/Duplication

Total Lines	412
Duplicated Lines	0 %

Test Coverage

Coverage

77.84%

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
B	appendFile()	0	17	7
B	appendFiles()	0	33	10
B	checkFilename()	0	31	9
A	appendFooter()	0	13	3
A	appendHeader()	0	14	3
B	setEol()	0	11	7
A	addHeader()	0	3	1
A	setFiltering()	0	3	1
A	setFile()	0	3	1
A	setFixLastLine()	0	3	1
A	addText()	0	3	1
A	getFilteredReader()	0	3	1
A	sanitizeText()	0	4	3
A	addFooter()	0	3	1
F	main()	0	74	16
A	createPath()	0	5	1
A	setOverwrite()	0	3	1
A	setDestFile()	0	3	1
A	setAppend()	0	3	1
A	setText()	0	3	1
B	validate()	0	14	9

<?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\Tasks\System;

use Exception;
use Phing\Exception\BuildException;
use Phing\Exception\NullPointerException;
use Phing\Io\FileReader;
use Phing\Io\FileUtils;
use Phing\Io\FileWriter;
use Phing\Io\IOException;
use Phing\Io\LogWriter;
use Phing\Io\File;
use Phing\Io\Reader;
use Phing\Io\StringReader;
use Phing\Io\Writer;
use Phing\Project;
use Phing\Task;
use Phing\Tasks\System\AppendTask\TextElement;
use Phing\Type\Element\FileListAware;
use Phing\Type\Element\FileSetAware;
use Phing\Type\Element\FilterChainAware;
use Phing\Type\FileSet;
use Phing\Type\Path;
use Phing\Util\Register;

/**
 *  Appends text, contents of a file or set of files defined by a filelist to a destination file.
 *
 * <code>
 * <append text="And another thing\n" destfile="badthings.log"/>
 * </code>
 * OR
 * <code>
 * <append file="header.html" destfile="fullpage.html"/>
 * <append file="body.html" destfile="fullpage.html"/>
 * <append file="footer.html" destfile="fullpage.html"/>
 * </code>
 * OR
 * <code>
 * <append destfile="${process.outputfile}">
 *    <filterchain>
 *        <xsltfilter style="${process.stylesheet}">
 *            <param name="mode" expression="${process.xslt.mode}"/>
 *            <param name="file_name" expression="%{task.append.current_file.basename}"/> <!-- Example of using a RegisterSlot variable -->
 *        </xsltfilter>
 *    </filterchain>
 *     <filelist dir="book/" listfile="book/PhingGuide.book"/>
 * </append>
 * </code>
 *
 * @package phing.tasks.system
 */
class AppendTask extends Task
{
    use FileListAware;
    use FileSetAware;
    use FilterChainAware;

    /**
     * Append stuff to this file.
     */
    private $to;

    /**
     * Explicit file to append.
     */
    private $file;

    /**
     * Text to append. (cannot be used in conjunction w/ files or filesets)
     */
    private $text;

    private $filtering = true;

    /**
     * @var TextElement $header
     */
    private $header;

    /**
     * @var TextElement $footer
     */
    private $footer;

    private $append = true;

    private $fixLastLine = false;

    private $overwrite = true;

    private $eolString;

    /**
     * @param bool $filtering
     */
    public function setFiltering(bool $filtering)
    {
        $this->filtering = $filtering;
    }

    /**
     * @param bool $overwrite
     */
    public function setOverwrite($overwrite)
    {
        $this->overwrite = $overwrite;
    }

    /**
     * The more conventional naming for method to set destination file.
     *
     * @param File $f
     *
     * @return void
     */
    public function setDestFile(File $f)
    {
        $this->to = $f;
    }

    /**
     * Sets the behavior when the destination exists. If set to
     * <code>true</code> the task will append the stream data an
     * {@link Appendable} resource; otherwise existing content will be
     * overwritten. Defaults to <code>false</code>.
     *
     * @param bool $append if true append output.
     */
    public function setAppend($append)
    {
        $this->append = $append;
    }

    /**
     * Specify the end of line to find and to add if
     * not present at end of each input file. This attribute
     * is used in conjunction with fixlastline.
     *
     * @param string $crlf the type of new line to add -
     *              cr, mac, lf, unix, crlf, or dos
     */
    public function setEol($crlf)
    {
        $s = $crlf;
        if ($s === "cr" || $s === "mac") {
            $this->eolString = "\r";
        } elseif ($s === "lf" || $s === "unix") {
            $this->eolString = "\n";
        } elseif ($s === "crlf" || $s === "dos") {
            $this->eolString = "\r\n";
        } else {
            $this->eolString = $this->getProject()->getProperty('line.separator');
        }
    }

    /**
     * Sets specific file to append.
     *
     * @param File $f
     */
    public function setFile(File $f)
    {
        $this->file = $f;
    }

    public function createPath()
    {
        $path = new Path($this->getProject());
        $this->filesets[] = $path;
        return $path;
    }

    /**
     * Sets text to append.  (cannot be used in conjunction w/ files or filesets).
     *
     * @param string $txt
     *
     * @return void
     */
    public function setText($txt)
    {
        $this->text = (string) $txt;
    }

    /**
     * Sets text to append. Supports CDATA.
     *
     * @param string $txt
     *
     * @return void
     */
    public function addText($txt)
    {
        $this->text .= (string) $txt;
    }

    public function addHeader(TextElement $headerToAdd)
    {
        $this->header = $headerToAdd;
    }

    public function addFooter(TextElement $footerToAdd)
    {
        $this->footer = $footerToAdd;
    }

    /**
     * Append line.separator to files that do not end
     * with a line.separator, default false.
     *
     * @param bool $fixLastLine if true make sure each input file has
     *                          new line on the concatenated stream
     */
    public function setFixLastLine($fixLastLine)
    {
        $this->fixLastLine = $fixLastLine;
    }

    /**
     * Append the file(s).
     *
     * {@inheritdoc}
     */
    public function main()
    {
        $this->validate();

        try {
            if ($this->to !== null) {
                // create a file writer to append to "to" file.
                $writer = new FileWriter($this->to, $this->append);
            } else {
                $writer = new LogWriter($this);
            }

            if ($this->text !== null) {
                // simply append the text
                if ($this->to instanceof File) {
                    $this->log("Appending string to " . $this->to->getPath());
                }

                $text = $this->text;
                if ($this->filtering) {
                    $fr = $this->getFilteredReader(new StringReader($text));
                    $text = $fr->read();
                }

                $text = $this->appendHeader($text);
                $text = $this->appendFooter($text);
                $writer->write($text);
            } else {
                // append explicitly-specified file
                if ($this->file !== null) {
                    try {
                        $this->appendFile($writer, $this->file);
                    } catch (Exception $ioe) {
                        $this->log(
                            "Unable to append contents of file " . $this->file->getAbsolutePath() . ": " . $ioe->getMessage(),
                            Project::MSG_WARN
                        );
                    }
                }

                // append any files in filesets
                foreach ($this->filesets as $fs) {
                    try {
                        if ($fs instanceof Path) {
                            $files = $fs->listPaths();
                            $this->appendFiles($writer, $files);
                        } elseif ($fs instanceof FileSet) {
                            $files = $fs->getDirectoryScanner($this->project)->getIncludedFiles();
                            $this->appendFiles($writer, $files, $fs->getDir($this->project));
                        }
                    } catch (BuildException $be) {
                        if (strpos($be->getMessage(), 'is the same as the output file') === false) {
                            $this->log($be->getMessage(), Project::MSG_WARN);
                        } else {
                            throw new BuildException($be->getMessage());
                        }
                    } catch (IOException $ioe) {
                        throw new BuildException($ioe);
                    }
                }

                foreach ($this->filelists as $list) {
                    $dir = $list->getDir($this->project);
                    $files = $list->getFiles($this->project);
                    foreach ($files as $file) {
                        $this->appendFile($writer, new File($dir, $file));
                    }
                }
            }
        } catch (Exception $e) {
            throw new BuildException($e);
        }

        $writer->close();
    }

    private function appendHeader($string)
    {
        $result = $string;
        if ($this->header !== null) {
            $header = $this->header->getValue();
            if ($this->header->filtering) {
                $fr = $this->getFilteredReader(new StringReader($header));
                $header = $fr->read();
            }

            $result = $header . $string;
        }

        return $result;
    }

    private function appendFooter($string)
    {
        $result = $string;
        if ($this->footer !== null) {
            $footer = $this->footer->getValue();
            if ($this->footer->filtering) {
                $fr = $this->getFilteredReader(new StringReader($footer));
                $footer = $fr->read();
            }

            $result = $string . $footer;
        }
        return $result;
    }

    private function validate()
    {
        $this->sanitizeText();

        if ($this->file === null && $this->text === null && count($this->filesets) === 0 && count($this->filelists) === 0) {
            throw new BuildException("You must specify a file, use a filelist/fileset, or specify a text value.");
        }

        if ($this->text !== null && ($this->file !== null || count($this->filesets) > 0)) {
            throw new BuildException("Cannot use text attribute in conjunction with file or fileset");
        }

        if (!$this->eolString) {
            $this->eolString = $this->getProject()->getProperty('line.separator');
        }
    }

    private function sanitizeText()
    {
        if ($this->text !== null && "" === trim($this->text)) {
            $this->text = null;
        }
    }

    private function getFilteredReader(Reader $r)
    {
        return FileUtils::getChainedReader($r, $this->filterChains, $this->getProject());
    }

    /**
     * Append an array of files in a directory.
     *
     * @param Writer $writer The FileWriter that is appending to target file.
     * @param array $files array of files to delete; can be of zero length
     * @param File $dir directory to work from
     *
     * @return void
     */
    private function appendFiles(Writer $writer, $files, File $dir = null)
    {
        if (!empty($files)) {
            $this->log(
                "Attempting to append " . count(
                    $files
                ) . " files" . ($dir !== null ? ", using basedir " . $dir->getPath() : "")
            );
            $basenameSlot = Register::getSlot("task.append.current_file");
            $pathSlot = Register::getSlot("task.append.current_file.path");
            foreach ($files as $file) {
                try {
                    if (!$this->checkFilename($file, $dir)) {
                        continue;
                    }

                    if ($dir !== null) {
                        $file = is_string($file) ? new File($dir->getPath(), $file) : $file;
                    } else {
                        $file = is_string($file) ? new File($file) : $file;
                    }
                    $basenameSlot->setValue($file);
                    $pathSlot->setValue($file->getPath());
                    $this->appendFile($writer, $file);
                } catch (IOException $ioe) {
                    $this->log(
                        "Unable to append contents of file " . $file . ": " . $ioe->getMessage(),
                        Project::MSG_WARN
                    );
                } catch (NullPointerException $npe) {
                    $this->log(
                        "Unable to append contents of file " . $file . ": " . $npe->getMessage(),
                        Project::MSG_WARN
                    );
                }
            }
        }
    }

    private function checkFilename($filename, $dir = null)
    {
        if ($dir !== null) {
            $f = new File($dir, $filename);
        } else {
            $f = new File($filename);
        }

        if (!$f->exists()) {
            $this->log("File " . (string) $f . " does not exist.", Project::MSG_ERR);
            return false;
        }
        if ($this->to !== null && $f->equals($this->to)) {
            throw new BuildException(
                "Input file \""
                . $f . "\" "
                . "is the same as the output file."
            );
        }

        if (
            $this->to !== null
            && !$this->overwrite
            && $this->to->exists()
            && $f->lastModified() > $this->to->lastModified()
        ) {
            $this->log((string) $this->to . " is up-to-date.", Project::MSG_VERBOSE);
            return false;
        }

        return true;
    }

    /**
     * @param FileWriter $writer
     * @param File $f
     *
     * @return void
     */
    private function appendFile(Writer $writer, File $f)
    {
        $in = $this->getFilteredReader(new FileReader($f));

        $text = '';
        while (-1 !== ($buffer = $in->read())) { // -1 indicates EOF
            $text .= $buffer;
        }
        if ($this->fixLastLine && ($text[strlen($text) - 1] !== "\n" || $text[strlen($text) - 1] !== "\r")) {
            $text .= $this->eolString;
        }

        $text = $this->appendHeader($text);
        $text = $this->appendFooter($text);
        $writer->write($text);
        if ($f instanceof File && $this->to instanceof File) {
            $this->log("Appending contents of " . $f->getPath() . " to " . $this->to->getPath());
        }
    }
}