Money::subtract() - Code Metrics - Inspection of "Daily Inspection: Merge branch 'FET-10619-money-en..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — FET-11170-model-use-money-enti... (00bce3)

unknown

created 2018-01-11 21:27 UTC

Money::subtract() A

↳ Parent: Money

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	8

Duplication

Lines	12
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	8
c	1
b	0
f	0
nc	1
nop	1
dl	12
loc	12
rs	9.4285

<?php

namespace EventEspresso\core\domain\values\currency;

use EventEspresso\core\exceptions\InvalidDataTypeException;
use EventEspresso\core\services\currency\Calculator;
use InvalidArgumentException;

defined('EVENT_ESPRESSO_VERSION') || exit;



/**
 * Class Money
 * Immutable object representing an amount of money for a particular currency
 *
 * @package       Event Espresso
 * @author        Brent Christensen
 * @since         $VID:$
 */
class Money
{

    /**
     * number of decimal places to be added to currencies for internal computations,
     * but removed before any output or formatting is applied.
     * This allows us to avoid rounding errors during calculations.
     */
    const EXTRA_PRECISION = 3;

    /**
     * @var int $amount
     */
    private $amount;

    /**
     * @var Currency $currency
     */
    private $currency;

    /**
     * @var Calculator $calculator
     */
    protected $calculator;



    /**
     * Money constructor.
     *
     * @param float|int|string $amount money amount IN THE STANDARD UNIT FOR THE CURRENCY ie: dollars, Euros, etc
     *                                 example: $12.5 USD would equate to a value amount of 12.50
     * @param Currency         $currency
     * @param Calculator       $calculator
     * @throws InvalidDataTypeException
     */
    public function __construct($amount, Currency $currency, Calculator $calculator)
    {
        $this->currency   = $currency;
        $this->amount     = $this->parseAmount($amount);
        $this->calculator = $calculator;
    }



    /**
     * @return Calculator
     */
    protected function calculator()
    {
        return $this->calculator;
    }



    /**
     * Convert's a standard unit amount into the subunits of the currency
     *
     * @param float|int|string $amount money amount IN THE STANDARD UNIT FOR THE CURRENCY ie: dollars, Euros, etc
     *                                 example: $12.5 USD would equate to a value amount of 12.50
     * @return integer                 in the currency's subunit
     * @throws InvalidDataTypeException
     */
    private function parseAmount($amount)
    {
        if (! in_array(gettype($amount), array('integer', 'double', 'string'), true)) {
            throw new InvalidDataTypeException(
                '$amount',
                $amount,
                'integer (or float or string)'
            );
        }
        if ($this->currency->decimalMark() !== '.') {
            // remove thousands separator and replace decimal place with standard decimal.
            $amount = str_replace(
                array(
                    $this->currency->thousands(),
                    $this->currency->decimalMark(),
                ),
                array(
                    '',
                    '.',
                ),
                $amount
            );
        }
        // remove any non numeric values but leave the decimal
        $amount = (float) preg_replace('/([^0-9\\.-])/', '', $amount);
        // maybe convert the incoming  decimal amount to the currencies subunits
        // ex: 12.5 for a currency with 100 subunits would become 1250
        if ($this->currency()->subunits()) {
            $amount *= $this->currency()->subunits();
        }
        // then shift the decimal position by the number of decimal places used internally
        // so if our extra internal precision was 3, it would become 1250000
        $amount *= pow(10, $this->precision());
        // then round up the remaining value if there is still a fractional amount left
        $amount = round($amount);
        return (int)$amount;
    }



    /**
     * adds or subtracts additional decimal places based on the value of the Money::EXTRA_PRECISION constant
     *
     * @param bool $adding_precision if true, will move the decimal to the right (increase amount)
     *                               if false, will move the decimal to the left (decrease amount)
     * @return integer
     */
    private function precision($adding_precision = true)
    {
        $sign = $adding_precision ? 1 : -1;
        return Money::EXTRA_PRECISION * $sign;
    }

    /**
     * Returns the money amount as an unformatted float
     * @return float
     */
    public function floatAmount()
    {
        // shift the decimal position BACK by the number of decimal places used internally
        // ex: if our extra internal precision was 3, then 1250000 would become 1250
        $amount = $this->amount * pow(10, $this->precision(false));
        // then maybe adjust for the currencies subunits
        // ex: 1250 for a currency with 100 subunits would become 12.50
        if ($this->currency()->subunits()) {
            $amount /= $this->currency()->subunits();
        }
        // then shave off our extra internal precision using the number of decimal places for the currency
        return $amount;
    }



    /**
     * Returns the money amount as an unformatted string
     * IF YOU REQUIRE A FORMATTED STRING, THEN USE Money::format()
     * In the currency's standard units
     *
     * @return string
     */
    public function amount()
    {
        return (string) round($this->floatAmount(), $this->currency()->decimalPlaces());
    }



    /**
     * Returns the money SUBUNITS amount as an INTEGER
     *
     * @return integer
     */
    public function amountInSubunits()
    {
        // shift the decimal position BACK by the number of decimal places used internally
        // for extra internal precision, but NOT for the number of decimals used by the currency
        // ex: if our extra internal precision was 3, then 1250000 would become 1250
        // and even if the currency used 100 subunits, we would return 1250 and NOT 12.50
        $amount = (string) $this->amount * pow(10, $this->precision(false));
        // then shave off anything after the decimal
        $amount = round($amount);
        return (int) $amount;
    }



    /**
     * Returns the Currency object for this money
     *
     * @return Currency
     */
    public function currency()
    {
        return $this->currency;
    }



    /**
     * adds the supplied Money amount to this Money amount
     * and returns a new Money object
     *
     * @param Money $other
     * @return Money
     * @throws InvalidArgumentException
     */
    public function add(Money $other)
    {
        $this->verifySameCurrency($other->currency());
        return new Money(
            $this->calculator()->add(
                $this->amount(),
                $other->amount()
            ),
            $this->currency(),
            $this->calculator()
        );
    }



    /**
     * subtracts the supplied Money amount from this Money amount
     * and returns a new Money object
     *
     * @param Money $other
     * @return Money
     * @throws InvalidArgumentException
     */
    public function subtract(Money $other)
    {
        $this->verifySameCurrency($other->currency());
        return new Money(
            $this->calculator()->subtract(
                $this->amount(),
                $other->amount()
            ),
            $this->currency(),
            $this->calculator()
        );
    }


    /**
     * multiplies this Money amount by the supplied $multiplier
     * and returns a new Money object
     *
     * @param float|int|string $multiplier
     * @param int              $rounding_mode
     * @return Money
     * @throws InvalidDataTypeException
     */
    public function multiply($multiplier, $rounding_mode = Calculator::ROUND_HALF_UP)
    {
        return new Money(
            $this->calculator()->multiply(
                $this->amount(),
                $multiplier,
                $this->precision(),
                $rounding_mode
            ),
            $this->currency(),
            $this->calculator()
        );
    }


    /**
     * divides this Money amount by the supplied $divisor
     * and returns a new Money object
     *
     * @param float|int|string $divisor
     * @param int              $rounding_mode
     * @return Money
     * @throws InvalidDataTypeException
     */
    public function divide($divisor, $rounding_mode = Calculator::ROUND_HALF_UP)
    {
        return new Money(
            $this->calculator()->divide(
                $this->amount(),
                $divisor,
                $this->precision(),
                $rounding_mode
            ),
            $this->currency(),
            $this->calculator()
        );
    }



    /**
     * @param Currency $other_currency
     * @throws InvalidArgumentException
     */
    public function verifySameCurrency(Currency $other_currency)
    {
        if ($this->currency()->equals($other_currency) !== true) {
            throw new InvalidArgumentException(
                esc_html__(
                    'Currencies must be the same in order to add or subtract their values.',
                    'event_espresso'
                )
            );
        }
    }



    /**
     * @return string
     */
    public function __toString()
    {
        return $this->amount();
    }
}


1		<?php
2
3		namespace EventEspresso\core\domain\values\currency;
4
5		use EventEspresso\core\exceptions\InvalidDataTypeException;
6		use EventEspresso\core\services\currency\Calculator;
7		use InvalidArgumentException;
8
9		defined('EVENT_ESPRESSO_VERSION') \|\| exit;
10
11
12
13		/**
14		* Class Money
15		* Immutable object representing an amount of money for a particular currency
16		*
17		* @package Event Espresso
18		* @author Brent Christensen
19		* @since $VID:$
20		*/
21		class Money
22		{
23
24		/**
25		* number of decimal places to be added to currencies for internal computations,
26		* but removed before any output or formatting is applied.
27		* This allows us to avoid rounding errors during calculations.
28		*/
29		const EXTRA_PRECISION = 3;
30
31		/**
32		* @var int $amount
33		*/
34		private $amount;
35
36		/**
37		* @var Currency $currency
38		*/
39		private $currency;
40
41		/**
42		* @var Calculator $calculator
43		*/
44		protected $calculator;
45
46
47
48		/**
49		* Money constructor.
50		*
51		* @param float\|int\|string $amount money amount IN THE STANDARD UNIT FOR THE CURRENCY ie: dollars, Euros, etc
52		* example: $12.5 USD would equate to a value amount of 12.50
53		* @param Currency $currency
54		* @param Calculator $calculator
55		* @throws InvalidDataTypeException
56		*/
57		public function __construct($amount, Currency $currency, Calculator $calculator)
58		{
59		$this->currency = $currency;
60		$this->amount = $this->parseAmount($amount);
61		$this->calculator = $calculator;
62		}
63
64
65
66		/**
67		* @return Calculator
68		*/
69		protected function calculator()
70		{
71		return $this->calculator;
72		}
73
74
75
76		/**
77		* Convert's a standard unit amount into the subunits of the currency
78		*
79		* @param float\|int\|string $amount money amount IN THE STANDARD UNIT FOR THE CURRENCY ie: dollars, Euros, etc
80		* example: $12.5 USD would equate to a value amount of 12.50
81		* @return integer in the currency's subunit
82		* @throws InvalidDataTypeException
83		*/
84		private function parseAmount($amount)
85		{
86		if (! in_array(gettype($amount), array('integer', 'double', 'string'), true)) {
87		throw new InvalidDataTypeException(
88		'$amount',
89		$amount,
90		'integer (or float or string)'
91		);
92		}
93		if ($this->currency->decimalMark() !== '.') {
94		// remove thousands separator and replace decimal place with standard decimal.
95		$amount = str_replace(
96		array(
97		$this->currency->thousands(),
98		$this->currency->decimalMark(),
99		),
100		array(
101		'',
102		'.',
103		),
104		$amount
105		);
106		}
107		// remove any non numeric values but leave the decimal
108		$amount = (float) preg_replace('/([^0-9\\.-])/', '', $amount);
109		// maybe convert the incoming decimal amount to the currencies subunits
110		// ex: 12.5 for a currency with 100 subunits would become 1250
111		if ($this->currency()->subunits()) {
112		$amount *= $this->currency()->subunits();
113		}
114		// then shift the decimal position by the number of decimal places used internally
115		// so if our extra internal precision was 3, it would become 1250000
116		$amount *= pow(10, $this->precision());
117		// then round up the remaining value if there is still a fractional amount left
118		$amount = round($amount);
119		return (int)$amount;
120		}
121
122
123
124		/**
125		* adds or subtracts additional decimal places based on the value of the Money::EXTRA_PRECISION constant
126		*
127		* @param bool $adding_precision if true, will move the decimal to the right (increase amount)
128		* if false, will move the decimal to the left (decrease amount)
129		* @return integer
130		*/
131		private function precision($adding_precision = true)
132		{
133		$sign = $adding_precision ? 1 : -1;
134		return Money::EXTRA_PRECISION * $sign;
135		}
136
137		/**
138		* Returns the money amount as an unformatted float
139		* @return float
140		*/
141		public function floatAmount()
142		{
143		// shift the decimal position BACK by the number of decimal places used internally
144		// ex: if our extra internal precision was 3, then 1250000 would become 1250
145		$amount = $this->amount * pow(10, $this->precision(false));
146		// then maybe adjust for the currencies subunits
147		// ex: 1250 for a currency with 100 subunits would become 12.50
148		if ($this->currency()->subunits()) {
149		$amount /= $this->currency()->subunits();
150		}
151		// then shave off our extra internal precision using the number of decimal places for the currency
152		return $amount;
153		}
154
155
156
157		/**
158		* Returns the money amount as an unformatted string
159		* IF YOU REQUIRE A FORMATTED STRING, THEN USE Money::format()
160		* In the currency's standard units
161		*
162		* @return string
163		*/
164		public function amount()
165		{
166		return (string) round($this->floatAmount(), $this->currency()->decimalPlaces());
167		}
168
169
170
171		/**
172		* Returns the money SUBUNITS amount as an INTEGER
173		*
174		* @return integer
175		*/
176		public function amountInSubunits()
177		{
178		// shift the decimal position BACK by the number of decimal places used internally
179		// for extra internal precision, but NOT for the number of decimals used by the currency
180		// ex: if our extra internal precision was 3, then 1250000 would become 1250
181		// and even if the currency used 100 subunits, we would return 1250 and NOT 12.50
182		$amount = (string) $this->amount * pow(10, $this->precision(false));
183		// then shave off anything after the decimal
184		$amount = round($amount);
185		return (int) $amount;
186		}
187
188
189
190		/**
191		* Returns the Currency object for this money
192		*
193		* @return Currency
194		*/
195		public function currency()
196		{
197		return $this->currency;
198		}
199
200
201
202		/**
203		* adds the supplied Money amount to this Money amount
204		* and returns a new Money object
205		*
206		* @param Money $other
207		* @return Money
208		* @throws InvalidArgumentException
209		*/
210	View Code Duplication	public function add(Money $other)
211		{
212		$this->verifySameCurrency($other->currency());
213		return new Money(
214		$this->calculator()->add(
215		$this->amount(),
216		$other->amount()
217		),
218		$this->currency(),
219		$this->calculator()
220		);
221		}
222
223
224
225		/**
226		* subtracts the supplied Money amount from this Money amount
227		* and returns a new Money object
228		*
229		* @param Money $other
230		* @return Money
231		* @throws InvalidArgumentException
232		*/
233	View Code Duplication	public function subtract(Money $other)
234		{
235		$this->verifySameCurrency($other->currency());
236		return new Money(
237		$this->calculator()->subtract(
238		$this->amount(),
239		$other->amount()
240		),
241		$this->currency(),
242		$this->calculator()
243		);
244		}
245
246
247		/**
248		* multiplies this Money amount by the supplied $multiplier
249		* and returns a new Money object
250		*
251		* @param float\|int\|string $multiplier
252		* @param int $rounding_mode
253		* @return Money
254		* @throws InvalidDataTypeException
255		*/
256	View Code Duplication	public function multiply($multiplier, $rounding_mode = Calculator::ROUND_HALF_UP)
257		{
258		return new Money(
259		$this->calculator()->multiply(
260		$this->amount(),
261		$multiplier,
262		$this->precision(),
263		$rounding_mode
264		),
265		$this->currency(),
266		$this->calculator()
267		);
268		}
269
270
271		/**
272		* divides this Money amount by the supplied $divisor
273		* and returns a new Money object
274		*
275		* @param float\|int\|string $divisor
276		* @param int $rounding_mode
277		* @return Money
278		* @throws InvalidDataTypeException
279		*/
280	View Code Duplication	public function divide($divisor, $rounding_mode = Calculator::ROUND_HALF_UP)
281		{
282		return new Money(
283		$this->calculator()->divide(
284		$this->amount(),
285		$divisor,
286		$this->precision(),
287		$rounding_mode
288		),
289		$this->currency(),
290		$this->calculator()
291		);
292		}
293
294
295
296		/**
297		* @param Currency $other_currency
298		* @throws InvalidArgumentException
299		*/
300		public function verifySameCurrency(Currency $other_currency)
301		{
302		if ($this->currency()->equals($other_currency) !== true) {
303		throw new InvalidArgumentException(
304		esc_html__(
305		'Currencies must be the same in order to add or subtract their values.',
306		'event_espresso'
307		)
308		);
309		}
310		}
311
312
313
314		/**
315		* @return string
316		*/
317		public function __toString()
318		{
319		return $this->amount();
320		}
321		}
322

eventespresso / event-espresso-core

Branch — FET-11170-model-use-money-enti... (00bce3)

Money::subtract() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like