Mailcode\Mailcode_Factory_Instantiator

Complexity

Total Complexity

39

Size/Duplication

Total Lines	337
Duplicated Lines	0 %

Importance

Changes	5
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	buildIfEquals()	0	7	1
A	buildIfListNotContains()	0	3	1
A	buildIfBiggerThan()	0	7	1
A	filterKeyword()	0	3	1
A	buildIfNotContains()	0	3	1
A	buildIfSmallerThan()	0	7	1
A	buildIfListContains()	0	3	1
A	buildIfNumeric()	0	12	1
A	renderListKeywords()	0	22	4
A	buildIfVar()	0	27	4
A	buildIf()	0	29	3
A	filterVariableName()	0	5	1
A	buildIfNotEmpty()	0	3	1
A	buildIfEmpty()	0	3	1
A	buildIfEndsWith()	0	3	1
A	buildIfBeginsWith()	0	3	1
A	buildIfContains()	0	10	1
A	buildIfSearch()	0	17	2
A	filterLiteral()	0	3	1
A	setEncoding()	0	19	5
A	exceptionUnexpectedType()	0	8	1
A	checkCommand()	0	18	2
A	quoteString()	0	7	3

<?php
/**
 * File containing the {@see Mailcode_Factory_Instantiator} class.
 *
 * @package Mailcode
 * @subpackage Factory
 * @see Mailcode_Factory_Instantiator
 */

declare(strict_types=1);

namespace Mailcode;

use Mailcode\Commands\ParamsException;

/**
 * Factory utility used to create commands.
 *
 * @package Mailcode
 * @subpackage Factory
 * @author Sebastian Mordziol <s.mordziol@mistralys.eu>
 */
class Mailcode_Factory_Instantiator
{
    public function buildIf(string $ifType, string $params, string $type='') : Mailcode_Commands_IfBase
    {
        $stringType = $type;
        
        if(!empty($type))
        {
            $stringType = ' '.$type;
        }
        
        $command = Mailcode::create()->getCommands()->createCommand(
            $ifType,
            $type,
            $params,
            sprintf(
                '{%s%s: %s}',
                strtolower($ifType),
                $stringType,
                $params
            )
        );
        
        $this->checkCommand($command);
        
        if($command instanceof Mailcode_Commands_IfBase)
        {
            return $command;
        }
        
        throw $this->exceptionUnexpectedType('IfBase', $command);
    }
    
    public function buildIfVar(string $ifType, string $variable, string $operand, string $value, bool $quoteValue=false, bool $insensitive=false) : Mailcode_Commands_IfBase
    {
        $variable = $this->filterVariableName($variable);

        if($insensitive)
        {
            $value = mb_strtolower($value);
        }

        if($quoteValue)
        {
            $value = $this->quoteString($value);
        }
        
        $condition = sprintf(
            "%s %s %s",
            $variable,
            $operand,
            $value
        );

        if($insensitive)
        {
            $condition .= ' '.Mailcode_Commands_Keywords::TYPE_INSENSITIVE;
        }

        return $this->buildIf($ifType, $condition, 'variable');
    }
    
    public function buildIfEmpty(string $ifType, string $variable) : Mailcode_Commands_IfBase
    {
        return $this->buildIf($ifType, $this->filterVariableName($variable), 'empty');
    }
    
    public function buildIfNotEmpty(string $ifType, string $variable) : Mailcode_Commands_IfBase
    {
        return $this->buildIf($ifType, $this->filterVariableName($variable), 'not-empty');
    }

    /**
     * @param string $ifType
     * @param string $variable
     * @param string[] $searchTerms
     * @param bool $caseInsensitive
     * @param bool $regexEnabled
     * @param string $containsType
     * @return Mailcode_Commands_IfBase
     * @throws Mailcode_Factory_Exception
     */
    public function buildIfContains(string $ifType, string $variable, array $searchTerms, bool $caseInsensitive=false, bool $regexEnabled=false, string $containsType='contains') : Mailcode_Commands_IfBase
    {
        $condition = sprintf(
            '%s%s"%s"',
            $this->filterVariableName($variable),
            $this->renderListKeywords($caseInsensitive, $regexEnabled),
            implode('" "', array_map(array($this, 'filterLiteral'), $searchTerms))
        );
        
        return $this->buildIf($ifType, $condition, $containsType);
    }

    private function renderListKeywords(bool $caseInsensitive=false, bool $regexEnabled=false) : string
    {
        $keywords = array();

        if($caseInsensitive)
        {
            $keywords[] = Mailcode_Commands_Keywords::TYPE_INSENSITIVE;
        }

        if($regexEnabled)
        {
            $keywords[] = Mailcode_Commands_Keywords::TYPE_REGEX;
        }

        $keywordsString = '';

        if(!empty($keywords))
        {
            $keywordsString = ' '.implode(' ', $keywords);
        }

        return $keywordsString;
    }

    /**
     * @param string $ifType
     * @param string $variable
     * @param string[] $searchTerms
     * @param bool $caseInsensitive
     * @param bool $regexEnabled
     * @return Mailcode_Commands_IfBase
     * @throws Mailcode_Factory_Exception
     */
    public function buildIfNotContains(string $ifType, string $variable, array $searchTerms, bool $caseInsensitive=false, bool $regexEnabled=false) : Mailcode_Commands_IfBase
    {
        return $this->buildIfContains($ifType, $variable, $searchTerms, $caseInsensitive, $regexEnabled, 'not-contains');
    }

    /**
     * @param string $ifType
     * @param string $variable
     * @param string[] $searchTerms
     * @param bool $caseInsensitive
     * @param bool $regexEnabled
     * @param string $containsType
     * @return Mailcode_Commands_IfBase
     * @throws Mailcode_Factory_Exception
     */
    public function buildIfListContains(string $ifType, string $variable, array $searchTerms, bool $caseInsensitive=false, bool $regexEnabled=false, string $containsType='list-contains') : Mailcode_Commands_IfBase
    {
        return $this->buildIfContains($ifType, $variable, $searchTerms, $caseInsensitive, $regexEnabled, $containsType);
    }

    /**
     * @param string $ifType
     * @param string $variable
     * @param string[] $searchTerms
     * @param bool $caseInsensitive
     * @param bool $regexEnabled
     * @return Mailcode_Commands_IfBase
     * @throws Mailcode_Factory_Exception
     */
    public function buildIfListNotContains(string $ifType, string $variable, array $searchTerms, bool $caseInsensitive=false, bool $regexEnabled=false) : Mailcode_Commands_IfBase
    {
        return $this->buildIfContains($ifType, $variable, $searchTerms, $caseInsensitive, $regexEnabled, 'list-not-contains');
    }

    public function buildIfBeginsWith(string $ifType, string $variable, string $search, bool $caseInsensitive=false) : Mailcode_Commands_IfBase
    {
        return $this->buildIfSearch($ifType, 'begins-with', $variable, $search, $caseInsensitive);
    }
    
    public function buildIfEndsWith(string $ifType, string $variable, string $search, bool $caseInsensitive=false) : Mailcode_Commands_IfBase
    {
        return $this->buildIfSearch($ifType, 'ends-with', $variable, $search, $caseInsensitive);
    }

    private function buildIfNumeric(string $ifType, string $variable, string $value, string $type) : Mailcode_Commands_IfBase
    {
        $params = sprintf(
            '%1$s "%2$s"',
            dollarize($variable),
            $value
        );

        return $this->buildIf(
            $ifType,
            $params,
            $type
        );
    }

    public function buildIfBiggerThan(string $ifType, string $variable, string $value) : Mailcode_Commands_IfBase
    {
        return $this->buildIfNumeric(
            $ifType,
            $variable,
            $value,
            'bigger-than'
        );
    }

    public function buildIfSmallerThan(string $ifType, string $variable, string $value) : Mailcode_Commands_IfBase
    {
        return $this->buildIfNumeric(
            $ifType,
            $variable,
            $value,
            'smaller-than'
        );
    }

    public function buildIfEquals(string $ifType, string $variable, string $value) : Mailcode_Commands_IfBase
    {
        return $this->buildIfNumeric(
            $ifType,
            $variable,
            $value,
            'equals-number'
        );
    }

    private function buildIfSearch(string $ifType, string $subType, string $variable, string $search, bool $caseInsensitive=false) : Mailcode_Commands_IfBase
    {
        $keyword = ' ';
        
        if($caseInsensitive)
        {
            $keyword = ' '.Mailcode_Commands_Keywords::TYPE_INSENSITIVE;
        }
        
        $condition = sprintf(
            '%s%s"%s"',
            $this->filterVariableName($variable),
            $keyword,
            $this->filterLiteral($search)
        );
        
        return $this->buildIf($ifType, $condition, $subType);
    }

    public function filterKeyword(string $keyword) : string
    {
        return rtrim($keyword, ':').':';
    }

    public function filterLiteral(string $term) : string
    {
        return str_replace('"', '\"', $term);
    }
    
    public function filterVariableName(string $name) : string
    {
        $name = (string)preg_replace('/\s/', '', $name);
        
        return dollarize($name);
    }

    /**
     * @param Mailcode_Commands_Command $command
     * @return void
     * @throws Mailcode_Factory_Exception {@see Mailcode_Factory::ERROR_INVALID_COMMAND_CREATED}
     */
    public function checkCommand(Mailcode_Commands_Command $command) : void
    {
        if($command->isValid())
        {
            return;
        }
        
        throw new Mailcode_Factory_Exception(
            'Invalid command created.',
            sprintf(
                'Command: %s'.PHP_EOL.
                'Validation message: %s',
                $command->getMatchedText(),
                $command->getValidationResult()->getErrorMessage()
            ),
            Mailcode_Factory::ERROR_INVALID_COMMAND_CREATED,
            null,
            $command
        );
    }

    /**
     * Configures the command's URL encoding or decoding, depending
     * on the selected mode.
     *
     * @param Mailcode_Commands_Command $cmd
     * @param string $urlEncoding
     *
     * @throws ParamsException
     *
     * @see Mailcode_Factory::URL_ENCODING_NONE
     * @see Mailcode_Factory::URL_ENCODING_ENCODE
     * @see Mailcode_Factory::URL_ENCODING_DECODE
     */
    public function setEncoding(Mailcode_Commands_Command $cmd, string $urlEncoding) : void
    {
        if($cmd instanceof Mailcode_Interfaces_Commands_Validation_URLEncode)
        {
            $cmd->setURLEncoding(false);

            if ($urlEncoding === Mailcode_Factory::URL_ENCODING_ENCODE)
            {
                $cmd->setURLEncoding();
            }
        }

        if($cmd instanceof Mailcode_Interfaces_Commands_Validation_URLDecode)
        {
            $cmd->setURLDecoding(false);

            if ($urlEncoding === Mailcode_Factory::URL_ENCODING_DECODE)
            {
                $cmd->setURLDecoding();
            }
        }
    }

    /**
     * Quotes a string literal: adds the quotes, and escapes any quotes already present in it.
     *
     * @param string $string
     * @return string
     */
    public function quoteString(string $string) : string
    {
        if(substr($string, 0, 1) === '"' && substr($string, -1, 1) === '"') {
            return $string;
        }

        return '"'.$this->filterLiteral($string).'"';
    }
    
    public function exceptionUnexpectedType(string $type, Mailcode_Commands_Command $command) : Mailcode_Factory_Exception
    {
        return new Mailcode_Factory_Exception(
            'Invalid command class type created.',
            sprintf('Excepted type [%s], but created class [%s].', $type, get_class($command)),
            Mailcode_Factory::ERROR_UNEXPECTED_COMMAND_TYPE,
            null,
            $command
        );
    }
}