RegexTask::doReplace() - Code Metrics - Inspection of "Move property tasks to system namespace" - phingofficial/phing - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 7a9799...2aee06 )

by Michiel
created 2021-01-27 10:18 UTC
RegexTask::doReplace() A

↳ Parent: RegexTask
Complexity

Conditions	3
Paths	3
Size

Total Lines	18
Code Lines	12
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	9
CRAP Score	3.1406
Importance

Changes
Metric	Value
eloc	12
dl	0
loc	18
rs	9.8666
c	0
b	0
f	0
ccs	9
cts	12
cp	0.75
cc	3
nc	3
nop	0
crap	3.1406
<?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\Task\System\Property;

use Exception;
use Phing\Exception\BuildException;
use Phing\Project;
use Phing\Task\System\Property\AbstractPropertySetterTask;
use Phing\Util\Regexp;

/**
 * Regular Expression Task for properties.
 *
 * <pre>
 *   <propertyregex property="pack.name"
 *                  subject="package.ABC.name"
 *                  pattern="package\.([^.]*)\.name"
 *                  match="$1"
 *                  casesensitive="false"
 *                  defaultvalue="test1"/>
 *
 *   <echo message="${pack.name}"/>
 *
 *   <propertyregex property="pack.name"
 *                  override="true"
 *                  subject="package.ABC.name"
 *                  pattern="(package)\.[^.]*\.(name)"
 *                  replace="$1.DEF.$2"
 *                  casesensitive="false"
 *                  defaultvalue="test2"/>
 *
 *   <echo message="${pack.name}"/>
 *
 * </pre>
 *
 * @author  Siad Ardroumli <[email protected]>
 * @package phing.tasks.regex
 */
class RegexTask extends AbstractPropertySetterTask
{
    /**
     * @var string $subject
     */
    private $subject;

    /**
     * @var string $pattern
     */
    private $pattern;

    /**
     * @var string $match
     */
    private $match;

    /**
     * @var string $replace
     */
    private $replace;

    /**
     * @var string $defaultValue
     */
    private $defaultValue;

    /**
     * @var bool $caseSensitive
     */
    private $caseSensitive = true;

    /**
     * @var array $modifiers
     */
    private $modifiers = '';

    /**
     * @var Regexp $reg
     */
    private $reg;

    /**
     * @var int $limit
     */
    private $limit = -1;

    public function init()
    {
        $this->reg = new Regexp();
    }

    /**
     * @param int $limit
     */
    public function setLimit($limit)
    {
        $this->limit = $limit;
    }

    /**
     * @param string $subject
     */
    public function setSubject($subject)
    {
        $this->subject = $subject;
    }

    /**
     * @param string $defaultValue
     */
    public function setDefaultValue($defaultValue)
    {
        $this->log('Set default value to ' . $defaultValue, Project::MSG_DEBUG);

        $this->defaultValue = $defaultValue;
    }

    /**
     * @param string $pattern
     * @throws BuildException
     */
    public function setPattern($pattern)
    {
        if ($this->pattern !== null) {
            throw new BuildException(
                'Cannot specify more than one regular expression'
            );
        }

        $this->log('Set pattern to ' . $pattern, Project::MSG_DEBUG);

        $this->pattern = $pattern;
    }

    /**
     * @param $replace
     * @throws BuildException
     */
    public function setReplace($replace)
    {
        if ($this->replace !== null) {
            throw new BuildException(
                'Cannot specify more than one replace expression'
            );
        }
        if ($this->match !== null) {
            throw new BuildException(
                'You cannot specify both a select and replace expression'
            );
        }

        $this->log('Set replace to ' . $replace, Project::MSG_DEBUG);

        $this->replace = $replace;
    }

    /**
     * @param $match
     * @throws BuildException
     */
    public function setMatch($match)
    {
        if ($this->match !== null) {
            throw new BuildException(
                'Cannot specify more than one match expression'
            );
        }

        $this->log('Set match to ' . $match, Project::MSG_DEBUG);

        $this->match = $match;
    }

    /**
     * @param $caseSensitive
     */
    public function setCaseSensitive($caseSensitive)
    {
        $this->log("Set case-sensitive to $caseSensitive", Project::MSG_DEBUG);

        $this->caseSensitive = $caseSensitive;
    }

    /**
     * @return mixed|string
     * @throws BuildException
     */
    protected function doReplace()
    {
        if ($this->replace === null) {
            throw new BuildException('No replace expression specified.');
        }
        $this->reg->setPattern($this->pattern);
        $this->reg->setReplace($this->replace);
        $this->reg->setModifiers($this->modifiers);
        $this->reg->setModifiers(/** @scrutinizer ignore-type */ $this->modifiers);
        $this->reg->setIgnoreCase(!$this->caseSensitive);
        $this->reg->setLimit($this->limit);

        try {
            $output = $this->reg->replace($this->subject);
        } catch (Exception $e) {
            $output = $this->defaultValue;
        }

        return $output;
    }

    /**
     * @return string
     *
     * @throws BuildException
     */
    protected function doSelect()
    {
        $this->reg->setPattern($this->pattern);
        $this->reg->setModifiers($this->modifiers);
        $this->reg->setModifiers(/** @scrutinizer ignore-type */ $this->modifiers);
        $this->reg->setIgnoreCase(!$this->caseSensitive);

        $output = $this->defaultValue;

        try {
            if ($this->reg->matches($this->subject)) {
                $output = $this->reg->getGroup((int) ltrim($this->match, '$'));
            }
        } catch (Exception $e) {
            throw new BuildException($e);
        }

        return $output;
    }

    /**
     * @throws BuildException
     */
    protected function validate()
    {
        if ($this->pattern === null) {
            throw new BuildException('No match expression specified.');
        }
        if ($this->replace === null && $this->match === null) {
            throw new BuildException(
                'You must specify either a preg_replace or preg_match pattern'
            );
        }
    }

    /**
     * @throws BuildException
     */
    public function main()
    {
        $this->validate();

        $output = $this->match;


        if ($this->replace !== null) {
            $output = $this->doReplace();
        } else {
            $output = $this->doSelect();
        }

        if ($output !== null) {

            $this->setPropertyValue($output);
        }
    }
}

phingofficial / phing

Push — master ( 7a9799...2aee06 )

RegexTask::doReplace() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
