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

Complexity

Total Complexity

31

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Test Coverage

Coverage

96.43%

Importance

Changes

0

11 Methods

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

<?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\charge\modifiers\PercentPoint;
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);

It seems like $this->ensureValidValue($value) can also be of type hiqdev\php\billing\charge\modifiers\PercentPoint. However, the property $value is declared as type Money\Money|string. Maybe add an additional type check?

    }

    public function getValue()
    {
        return $this->value instanceof PercentPoint ? $this->value->getNumber() : $this->value;

$this->value is never a sub-type of hiqdev\php\billing\charge\modifiers\PercentPoint.

    }

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

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

    public function isPercentPoint(): bool
    {
        return $this->value instanceof PercentPoint;
    }

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

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

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

        if (is_string($value) && preg_match('/^(\d{1,5}(\.\d+)?)(%|pp| [A-Z]{3})$/', $value, $ms)) {
            if ($ms[3] === '%') {
                return $ms[1];
            }
            if ($ms[3] === 'pp') {
                return new PercentPoint($ms[1]);
            }

            return $this->moneyParser->parse($ms[1], new Currency(trim($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->getValue()*$multiplier);
    }

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

        if ($this->isAbsolute()) {
            $sum = $this->getValue()->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->getValue() + $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)
        ;
    }
}