hiqdev\php\billing\charge\modifiers\addons\Discount

Complexity

Total Complexity

28

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Test Coverage

Coverage

98.08%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	isRelative()	0	3	1
A	getValue()	0	3	1
A	isAbsolute()	0	3	1
A	__construct()	0	4	1
B	ensureValidValue()	0	24	8
A	add()	0	14	3
A	multiply()	0	7	3
A	ensureSameType()	0	7	5
A	compare()	0	11	3
A	calculateSum()	0	5	2

<?php
/**
 * PHP Billing Library
 *
 * @link      https://github.com/hiqdev/php-billing
 * @package   php-billing
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2017-2018, HiQDev (http://hiqdev.com/)
 */

namespace hiqdev\php\billing\charge\modifiers\addons;

use hiqdev\php\billing\charge\ChargeInterface;
use hiqdev\php\billing\charge\modifiers\AddonInterface;
use hiqdev\php\billing\formula\FormulaSemanticsError;
use Money\Currencies\ISOCurrencies;
use Money\Currency;
use Money\Money;
use Money\Parser\DecimalMoneyParser;

/**
 * Discount addon.
 *
 * @author Andrii Vasyliev <sol@hiqdev.com>
 */
class Discount implements AddonInterface
{
    protected static $name = 'discount';

    /**
     * @var string|Money
     */
    protected $value;

    protected $moneyParser;

    public function __construct($value)
    {
        $this->moneyParser = new DecimalMoneyParser(new ISOCurrencies());
        $this->value = $this->ensureValidValue($value);
    }

    public function getValue()
    {
        return $this->value;
    }

    public function isAbsolute()
    {
        return $this->value instanceof Money;
    }

    public function isRelative()
    {
        return !$this->isAbsolute();
    }

    public function ensureValidValue($value)
    {
        if ($value instanceof static) {
            return $value->getValue();
        }

        if ($value instanceof Money) {
            return $value;
        }

        if (is_numeric($value)) {
            return (string) $value;
        }

        if (is_string($value) && preg_match('/^(\d{1,5}(\.\d+)?)%$/', $value, $ms)) {
            return $ms[1];
        }

        if (is_string($value) && preg_match('/^(\d{1,5}(\.\d+)?) ([A-Z]{3})$/', $value, $ms)) {
            return $this->moneyParser->parse($ms[1], new Currency($ms[3]));
        }

        $name = static::$name;
        throw new FormulaSemanticsError("invalid $name value: $value");
    }

    public function multiply($multiplier)
    {
        if (!is_numeric($multiplier)) {
            throw new FormulaSemanticsError('multiplier for discount must be numeric');
        }

        return new static($this->isAbsolute() ? $this->value->multiply($multiplier) : $this->value*$multiplier);
    }

    public function add($addend)
    {
        if (!$addend instanceof self) {
            $addend = new self($addend);
        }
        $this->ensureSameType($addend, 'addend');

        if ($this->isAbsolute()) {
            $sum = $this->value->add($addend->getValue());

It seems like $addend->getValue() can also be of type string; however, parameter $addend of Money\Money::add() does only seem to accept Money\Money, maybe add an additional type check?

        } else {
            $sum = $this->value + $addend->getValue();
        }

        return new static($sum);
    }

    public function compare($other)
    {
        if (!$other instanceof self) {
            $other = new self($other);
        }
        $this->ensureSameType($other, 'comparison argument');

        if ($this->isAbsolute()) {
            return $this->value->compare($other->getValue());

It seems like $other->getValue() can also be of type string; however, parameter $other of Money\Money::compare() does only seem to accept Money\Money, maybe add an additional type check?

        } else {
            return $this->value - $other->getValue();
        }
    }

    public function ensureSameType(self $other, $name)
    {
        if ($this->isRelative() && !$other->isRelative()) {
            throw new FormulaSemanticsError("$name must be relative");
        }
        if ($this->isAbsolute() && !$other->isAbsolute()) {
            throw new FormulaSemanticsError("$name must be absolute");
        }
    }

    public function calculateSum(ChargeInterface $charge): Money
    {
        return $this->value instanceof Money
            ? $this->value->multiply($charge->getUsage()->getQuantity())
            : $charge->getSum()->multiply($this->value * 0.01)
        ;
    }
}