Muffin\Conditions\AbstractComparisonOperatorCondition

Complexity

Total Complexity

9

Size/Duplication

Total Lines	63
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	toString()	0	14	2
A	generateFieldOperand()	0	4	1
A	generateRightOperand()	0	9	2
A	isEmpty()	0	6	1
	getConditionOperator()	0	1	?
A	escapeValue()	0	11	2

<?php

namespace Muffin\Conditions;

use Muffin\Escaper;
use Muffin\Type;

abstract class AbstractComparisonOperatorCondition extends AbstractCondition
{
    protected
        $leftOperand,
        $rightOperand;

    public function __construct(Type $leftOperand, $rightOperand)
    {
        $this->leftOperand = $leftOperand;
        $this->rightOperand = $rightOperand;
    }

    public function toString(Escaper $escaper)
    {
        if($this->isEmpty())
        {
            return '';
        }

        return sprintf(
            '%s %s %s',
            $this->generateFieldOperand($this->leftOperand),
            $this->getConditionOperator(),
            $this->generateRightOperand($escaper)
        );
    }

    private function generateFieldOperand(Type $field)
    {
        return $field->getName();
    }

    private function generateRightOperand(Escaper $escaper)
    {
        if($this->rightOperand instanceof Type)
        {
            return $this->generateFieldOperand($this->rightOperand);
        }

        return $this->escapeValue($this->rightOperand, $escaper);
    }

    public function isEmpty()
    {
        $columnName = $this->leftOperand->getName();

        return empty($columnName);
    }

    abstract protected function getConditionOperator();

    private function escapeValue($value, Escaper $escaper)
    {
        $value = $this->leftOperand->format($value);

        if($this->leftOperand->isEscapeRequired())
        {
            $value = $escaper->escape($value);
        }

        return $value;
    }
}