fomvasss / laravel-currency

src/Currency.php

<?php

namespace Fomvasss\Currency;

use Illuminate\Support\Arr;

class Currency
{
    protected $config;

    protected $symbol = null;

    protected $userCurrency;

    /**
     * Currency constructor.
     */
    public function __construct(array $config = null)
    {
        if (!$config) {
            $config = config('currency', []);

The function config was not found. Maybe you did not declare it correctly or list all dependencies?

        }

        $this->config = $config;
    }

    /**
     * @param $value
     * @param null $code

Are you sure the doc-type for parameter $code is correct as it would always require null to be passed?

     * @param null $symbol

Are you sure the doc-type for parameter $symbol is correct as it would always require null to be passed?

     * @return string
     */
    public function format($value, $code = null, $symbol = null)
    {
        $code = $this->prepareCode($code);

        $precision = $this->config("currencies.$code.precision", 0);
        $decimalSeparator = $this->config("currencies.$code.decimalSeparator", "");
        $thousandSeparator = $this->config("currencies.$code.thousandSeparator", "");

        $symbol = $symbol ?? $this->config("currencies.$code.symbol", "");

        $value = $this->prepareValue($value, $code);

        $result = number_format($value, $precision, $decimalSeparator, $thousandSeparator);

        if ($symbol) {
            return $this->config("currencies.$code.symbolPlacement") == 'after' ? $result.$symbol : $symbol.$result;

Are you sure $symbol of type Illuminate\Config\Repository|array|mixed can be used in concatenation?

        }

        return $result;
    }

    /**
     * @param $amount
     * @param null $from

Are you sure the doc-type for parameter $from is correct as it would always require null to be passed?

     * @param null $to

Are you sure the doc-type for parameter $to is correct as it would always require null to be passed?

     * @param bool $format
     * @return float|int|string|null
     */
    public function convert($amount, $from = null, $to = null, $format = true)
    {
        // Get currencies involved
        $from = $from ?: $this->config('default');

$from is of type null, thus it always evaluated to false.

        $to = $to ?: $this->getUserCurrency();

$to is of type null, thus it always evaluated to false.

        // Get exchange rates
        $fromRate = $this->getCurrencyProp($from, 'exchangeRate');

It seems like $from can also be of type array; however, parameter $code of Fomvasss\Currency\Currency::getCurrencyProp() does only seem to accept string, maybe add an additional type check?

        $toRate = $this->getCurrencyProp($to, 'exchangeRate');

        // Skip invalid to currency rates
        if ($toRate === null) {

The condition $toRate === null is always false.

            return null;
        }
        // Convert amount
        if ($from === $to) {
            $value = $amount;
        } else {
            $value = ($amount * $toRate) / $fromRate;
        }
        // Should the result be formatted?
        if ($format === true) {
            return $this->format($value, $to);
        }

        // Return value
        return $this->prepareValue($value, $to);
    }

    protected function prepareValue($value, $code)
    {
        if ($this->config("divide_result") && ($coin = $this->config("currencies.$code.coin", 0))) {
            $value = $value / $coin;
        }

        return $value;
    }

    /**
     * Get the given property value from provided currency.
     *
     * @param string $code
     * @param string $key
     * @param mixed  $default
     *
     * @return array
     */
    protected function getCurrencyProp($code, $key, $default = null)
    {
        return Arr::get($this->getCurrency($code), $key, $default);
    }

    /**
     * Return all currencies.
     *
     * @return array
     */
    public function getCurrencies()
    {
        return $this->config('currencies', []);

The expression return $this->config('currencies', array()) also could return the type Illuminate\Config\Repository which is incompatible with the documented return type array.

    }

    /**
     *
     * Determine if the provided currency is valid.
     *
     * @param $code
     * @return bool
     */
    public function issetCurrency($code)
    {
        return array_key_exists(strtoupper($code), $this->getCurrencies());
    }

    /**
     *
     * Determine if the provided currency is active.
     *
     * @param $code
     * @return bool
     */
    public function isActive($code)
    {
        return $code && (bool) Arr::get($this->getCurrency($code), 'active', false);
    }

    /**
     * Return the current currency.
     *
     * @param null $code

Are you sure the doc-type for parameter $code is correct as it would always require null to be passed?

     * @return mixed
     */
    public function getCurrency($code = null)
    {
        $code = $code ?: $this->getUserCurrency();

$code is of type null, thus it always evaluated to false.

        return Arr::get($this->getCurrencies(), strtoupper($code));

It seems like $code can also be of type array; however, parameter $string of strtoupper() does only seem to accept string, maybe add an additional type check?

    }

    public function setUserCurrency($code)
    {
        $this->userCurrency = strtoupper($code);

        return $this;
    }

    /**
     * @return array|\Illuminate\Config\Repository|mixed

The type Illuminate\Config\Repository was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public function getUserCurrency()
    {
        return $this->userCurrency ?? $this->config('default');
    }

    /**
     * Return all active currencies.
     *
     * @return array
     */
    public function getActiveCurrencies()
    {
        return array_filter($this->getCurrencies(), function($currency) {
            return $currency['active'] == true;
        });
    }

    /**
     * Return currencies config.
     *
     * @param null $key

Are you sure the doc-type for parameter $key is correct as it would always require null to be passed?

     * @param null $default

Are you sure the doc-type for parameter $default is correct as it would always require null to be passed?

     * @return array|\Illuminate\Config\Repository|mixed
     */
    protected function config($key = null, $default = null)
    {
        if ($key === null) {

The condition $key === null is always true.

            return $this->config;
        }
        return Arr::get($this->config, $key, $default);
    }

    /**
     * @param null $code

Are you sure the doc-type for parameter $code is correct as it would always require null to be passed?

     * @return null|string
     */
    protected function prepareCode($code = null)
    {
        if (! $code) {

$code is of type null, thus it always evaluated to false.

            $code =  $this->config("default", 'USD');
        }

        if (array_key_exists($code, $this->getCurrencies())) {
            return $code;

The expression return $code also could return the type array which is incompatible with the documented return type null|string.

        }

        return 'USD';
    }
}