shopify-money 0.10.0

data/config/currency_non_iso.json

@@ -0,0 +1,82 @@
+{
+  "jep": {
+    "priority": 100,
+    "iso_code": "JEP",
+    "name": "Jersey Pound",
+    "symbol": "£",
+    "disambiguate_symbol": "JEP",
+    "alternate_symbols": [],
+    "subunit": "Penny",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "£",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "ggp": {
+    "priority": 100,
+    "iso_code": "GGP",
+    "name": "Guernsey Pound",
+    "symbol": "£",
+    "disambiguate_symbol": "GGP",
+    "alternate_symbols": [],
+    "subunit": "Penny",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "£",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "imp": {
+    "priority": 100,
+    "iso_code": "IMP",
+    "name": "Isle of Man Pound",
+    "symbol": "£",
+    "disambiguate_symbol": "IMP",
+    "alternate_symbols": ["M£"],
+    "subunit": "Penny",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "£",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "xfu": {
+    "priority": 100,
+    "iso_code": "XFU",
+    "name": "UIC Franc",
+    "symbol": "",
+    "disambiguate_symbol": "XFU",
+    "alternate_symbols": [],
+    "subunit": "",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": ""
+  },
+  "gbx": {
+    "priority": 100,
+    "iso_code": "GBX",
+    "name": "British Penny",
+    "symbol": "",
+    "disambiguate_symbol": "GBX",
+    "alternate_symbols": [],
+    "subunit": "",
+    "subunit_to_unit": 1,
+    "symbol_first": true,
+    "html_entity": "",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  }
+}

data/dev.yml

@@ -0,0 +1,9 @@
+# For internal use, but the requirements below
+# describe the required dependencies
+---
+name: money
+up:
+- ruby: 2.3.3
+- bundler
+commands:
+  test: bundle exec rspec

data/lib/money.rb

@@ -0,0 +1,10 @@
+require_relative 'money/money_parser'
+require_relative 'money/helpers'
+require_relative 'money/currency'
+require_relative 'money/null_currency'
+require_relative 'money/money'
+require_relative 'money/deprecations'
+require_relative 'money/accounting_money_parser'
+require_relative 'money/core_extensions'
+require_relative 'money_accessor'
+require_relative 'money_column' if defined?(ActiveRecord)

data/lib/money/accounting_money_parser.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AccountingMoneyParser < MoneyParser
+  def parse(input, currency = nil, **options)
+    # set () to mean negativity. ignore $
+    super(input.gsub(/\(\$?(.*?)\)/, '-\1'), currency, **options)
+  end
+end

data/lib/money/core_extensions.rb

@@ -0,0 +1,18 @@
+# Allows Writing of 100.to_money for +Numeric+ types
+#   100.to_money => #<Money @cents=10000>
+#   100.37.to_money => #<Money @cents=10037>
+class Numeric
+  def to_money(currency = nil)
+    Money.new(self, currency)
+  end
+end
+
+# Allows Writing of '100'.to_money for +String+ types
+# Excess characters will be discarded
+#   '100'.to_money => #<Money @cents=10000>
+#   '100.37'.to_money => #<Money @cents=10037>
+class String
+  def to_money(currency = nil)
+    empty? ? Money.empty : Money.parse(self, currency)
+  end
+end

data/lib/money/currency.rb

@@ -0,0 +1,59 @@
+require "money/currency/loader"
+
+class Money
+  class Currency
+    @@mutex = Mutex.new
+    @@loaded_currencies = {}
+
+    class UnknownCurrency < ArgumentError; end
+
+    class << self
+      def new(currency_iso)
+        raise UnknownCurrency, "Currency can't be blank" if currency_iso.nil? || currency_iso.to_s.empty?
+        iso = currency_iso.to_s.downcase
+        @@loaded_currencies[iso] || @@mutex.synchronize { @@loaded_currencies[iso] = super(iso) }
+      end
+      alias_method :find!, :new
+
+      def find(currency_iso)
+        new(currency_iso)
+      rescue UnknownCurrency
+        nil
+      end
+
+      def currencies
+        @@currencies ||= Loader.load_currencies
+      end
+    end
+
+    attr_reader :iso_code, :iso_numeric, :name, :smallest_denomination, :subunit_symbol,
+                :subunit_to_unit, :minor_units, :symbol, :disambiguate_symbol, :decimal_mark
+
+    def initialize(currency_iso)
+      data = self.class.currencies[currency_iso]
+      raise UnknownCurrency, "Invalid iso4217 currency '#{currency_iso}'" unless data
+      @symbol                = data['symbol']
+      @disambiguate_symbol   = data['disambiguate_symbol'] || data['symbol']
+      @subunit_symbol        = data['subunit_symbol']
+      @iso_code              = data['iso_code']
+      @iso_numeric           = data['iso_numeric']
+      @name                  = data['name']
+      @smallest_denomination = data['smallest_denomination']
+      @subunit_to_unit       = data['subunit_to_unit']
+      @decimal_mark          = data['decimal_mark']
+      @minor_units           = subunit_to_unit == 0 ? 0 : Math.log(subunit_to_unit, 10).round.to_i
+      freeze
+    end
+
+    def eql?(other)
+      self.class == other.class && iso_code == other.iso_code
+    end
+
+    def compatible?(other)
+      other.is_a?(NullCurrency) || eql?(other)
+    end
+
+    alias_method :==, :eql?
+    alias_method :to_s, :iso_code
+  end
+end

data/lib/money/currency/loader.rb

@@ -0,0 +1,26 @@
+require 'json'
+
+class Money
+  class Currency
+    module Loader
+      extend self
+
+      CURRENCY_DATA_PATH = File.expand_path("../../../../config", __FILE__)
+
+      def load_currencies
+        currencies = {}
+        currencies.merge! parse_currency_file("currency_historic.json")
+        currencies.merge! parse_currency_file("currency_non_iso.json")
+        currencies.merge! parse_currency_file("currency_iso.json")
+      end
+
+      private
+
+      def parse_currency_file(filename)
+        json = File.read("#{CURRENCY_DATA_PATH}/#{filename}")
+        json.force_encoding(::Encoding::UTF_8) if defined?(::Encoding)
+        JSON.parse(json)
+      end
+    end
+  end
+end

data/lib/money/deprecations.rb

@@ -0,0 +1,18 @@
+Money.class_eval do
+  ACTIVE_SUPPORT_DEFINED = defined?(ActiveSupport)
+
+  def self.active_support_deprecator
+    @active_support_deprecator ||= ActiveSupport::Deprecation.new('1.0.0', 'Shopify/Money')
+  end
+
+  def self.deprecate(message)
+    if ACTIVE_SUPPORT_DEFINED
+      external_callstack = caller_locations.reject do |location|
+        location.to_s.include?('gems/money')
+      end
+      active_support_deprecator.warn("[Shopify/Money] #{message}\n", external_callstack)
+    else
+      Kernel.warn("DEPRECATION WARNING: [Shopify/Money] #{message}\n")
+    end
+  end
+end

data/lib/money/helpers.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+require 'bigdecimal'
+
+class Money
+  module Helpers
+    module_function
+
+    NUMERIC_REGEX = /\A\s*[\+\-]?\d*(\.\d+)?\s*\z/
+    DECIMAL_ZERO = BigDecimal.new(0).freeze
+    MAX_DECIMAL = 21
+
+    def value_to_decimal(num)
+      value =
+        case num
+        when Money
+          num.value
+        when BigDecimal
+          num
+        when nil, 0, ''
+          DECIMAL_ZERO
+        when Integer
+          BigDecimal.new(num)
+        when Float
+          BigDecimal.new(num, Float::DIG)
+        when Rational
+          BigDecimal.new(num, MAX_DECIMAL)
+        when String
+          string_to_decimal(num)
+        else
+          raise ArgumentError, "could not parse as decimal #{num.inspect}"
+        end
+      return DECIMAL_ZERO if value.sign == BigDecimal::SIGN_NEGATIVE_ZERO
+      value
+    end
+
+    def value_to_currency(currency)
+      case currency
+      when Money::Currency, Money::NullCurrency
+        currency
+      when nil, ''
+        default = Money.current_currency || Money.default_currency
+        raise(ArgumentError, 'missing currency') if default.nil? || default == ''
+        value_to_currency(default)
+      when 'xxx', 'XXX'
+        Money::NULL_CURRENCY
+      when String
+        begin
+          Currency.find!(currency)
+        rescue Money::Currency::UnknownCurrency => error
+          Money.deprecate(error.message)
+          Money::NULL_CURRENCY
+        end
+      else
+        raise ArgumentError, "could not parse as currency #{currency.inspect}"
+      end
+    end
+
+    def string_to_decimal(num)
+      if num =~ NUMERIC_REGEX
+        return BigDecimal.new(num)
+      end
+
+      Money.deprecate("using Money.new('#{num}') is deprecated and will raise an ArgumentError in the next major release")
+      begin
+        BigDecimal.new(num)
+      rescue ArgumentError
+        DECIMAL_ZERO
+      end
+    end
+  end
+end

data/lib/money/money.rb

@@ -0,0 +1,408 @@
+class Money
+  include Comparable
+  extend Forwardable
+
+  NULL_CURRENCY = NullCurrency.new.freeze
+
+  attr_reader :value, :currency
+  def_delegators :@value, :zero?, :nonzero?, :positive?, :negative?, :to_i, :to_f, :hash
+
+  class << self
+    attr_accessor :parser, :default_currency
+
+    def new(value = 0, currency = nil)
+      value = Helpers.value_to_decimal(value)
+      currency = Helpers.value_to_currency(currency)
+
+      if value.zero?
+        @@zero_money ||= {}
+        @@zero_money[currency.iso_code] ||= super(Helpers::DECIMAL_ZERO, currency)
+      else
+        super(value, currency)
+      end
+    end
+    alias_method :from_amount, :new
+
+    def zero
+      new(0, NULL_CURRENCY)
+    end
+    alias_method :empty, :zero
+
+    def parse(*args)
+      parser.parse(*args)
+    end
+
+    def from_cents(cents, currency = nil)
+      new(cents.round.to_f / 100, currency)
+    end
+
+    def from_subunits(subunits, currency_iso)
+      currency = Helpers.value_to_currency(currency_iso)
+      value = Helpers.value_to_decimal(subunits) / currency.subunit_to_unit
+      new(value, currency)
+    end
+
+    def rational(money1, money2)
+      money1.send(:arithmetic, money2) do
+        factor = money1.currency.subunit_to_unit * money2.currency.subunit_to_unit
+        Rational((money1.value * factor).to_i, (money2.value * factor).to_i)
+      end
+    end
+
+    def current_currency
+      Thread.current[:money_currency]
+    end
+
+    def current_currency=(currency)
+      Thread.current[:money_currency] = currency
+    end
+
+    # Set Money.default_currency inside the supplied block, resets it to
+    # the previous value when done to prevent leaking state. Similar to
+    # I18n.with_locale and ActiveSupport's Time.use_zone. This won't affect
+    # instances being created with explicitly set currency.
+    def with_currency(new_currency)
+      begin
+        old_currency = Money.current_currency
+        Money.current_currency = new_currency
+        yield
+      ensure
+        Money.current_currency = old_currency
+      end
+    end
+
+    def default_settings
+      self.parser = MoneyParser
+      self.default_currency = Money::NULL_CURRENCY
+    end
+  end
+  default_settings
+
+  def initialize(value, currency)
+    raise ArgumentError if value.nan?
+    @currency = Helpers.value_to_currency(currency)
+    @value = value.round(@currency.minor_units)
+    freeze
+  end
+
+  def init_with(coder)
+    initialize(Helpers.value_to_decimal(coder['value']), coder['currency'])
+  end
+
+  def encode_with(coder)
+    coder['value'] = @value.to_s('F')
+    coder['currency'] = @currency.iso_code
+  end
+
+  def cents
+    # Money.deprecate('`money.cents` is deprecated and will be removed in the next major release. Please use `money.subunits` instead. Keep in mind, subunits are currency aware.')
+    (value * 100).to_i
+  end
+
+  def subunits
+    (@value * @currency.subunit_to_unit).to_i
+  end
+
+  def no_currency?
+    currency.is_a?(NullCurrency)
+  end
+
+  def -@
+    Money.new(-value, currency)
+  end
+
+  def <=>(other)
+    arithmetic(other) do |money|
+      value <=> money.value
+    end
+  end
+
+  def +(other)
+    arithmetic(other) do |money|
+      Money.new(value + money.value, calculated_currency(money.currency))
+    end
+  end
+
+  def -(other)
+    arithmetic(other) do |money|
+      Money.new(value - money.value, calculated_currency(money.currency))
+    end
+  end
+
+  def *(numeric)
+    unless numeric.is_a?(Numeric)
+      Money.deprecate("Multiplying Money with #{numeric.class.name} is deprecated and will be removed in the next major release.")
+    end
+    Money.new(value.to_r * numeric, currency)
+  end
+
+  def /(numeric)
+    raise "[Money] Dividing money objects can lose pennies. Use #split instead"
+  end
+
+  def inspect
+    "#<#{self.class} value:#{self} currency:#{self.currency}>"
+  end
+
+  def ==(other)
+    eql?(other)
+  end
+
+  def eql?(other)
+    return false unless other.is_a?(Money)
+    return false unless currency.compatible?(other.currency)
+    value == other.value
+  end
+
+  class ReverseOperationProxy
+    include Comparable
+
+    def initialize(value)
+      @value = value
+    end
+
+    def <=>(other)
+      -(other <=> @value)
+    end
+
+    def +(other)
+      other + @value
+    end
+
+    def -(other)
+      -(other - @value)
+    end
+
+    def *(other)
+      other * @value
+    end
+  end
+
+  def coerce(other)
+    raise TypeError, "Money can't be coerced into #{other.class}" unless other.is_a?(Numeric)
+    [ReverseOperationProxy.new(other), self]
+  end
+
+  def to_money(_currency = nil)
+    self
+  end
+
+  def to_d
+    value
+  end
+
+  def to_s(style = nil)
+    case style
+    when :legacy_dollars
+      sprintf("%.2f", value)
+    when :amount, nil
+      sprintf("%.#{currency.minor_units}f", value)
+    end
+  end
+
+  def to_liquid
+    cents
+  end
+
+  def to_json(options = {})
+    to_s
+  end
+
+  def as_json(*args)
+    to_s
+  end
+
+  def abs
+    Money.new(value.abs, currency)
+  end
+
+  def floor
+    Money.new(value.floor, currency)
+  end
+
+  def round(ndigits=0)
+    Money.new(value.round(ndigits), currency)
+  end
+
+  def fraction(rate)
+    raise ArgumentError, "rate should be positive" if rate < 0
+
+    result = value / (1 + rate)
+    Money.new(result, currency)
+  end
+
+  # Allocates money between different parties without losing pennies.
+  # After the mathematically split has been performed, left over pennies will
+  # be distributed round-robin amongst the parties. This means that parties
+  # listed first will likely receive more pennies than ones that are listed later
+  #
+  # @param splits [Array<Numeric>]
+  # @return [Array<Money>]
+  #
+  # @example
+  #   Money.new(5, "USD").allocate([0.50, 0.25, 0.25])
+  #     #=> [#<Money value:2.50 currency:USD>, #<Money value:1.25 currency:USD>, #<Money value:1.25 currency:USD>]
+  #   Money.new(5, "USD").allocate([0.3, 0.7])
+  #     #=> [#<Money value:1.50 currency:USD>, #<Money value:3.50 currency:USD>]
+  #   Money.new(100, "USD").allocate([0.33, 0.33, 0.33])
+  #     #=> [#<Money value:33.34 currency:USD>, #<Money value:33.33 currency:USD>, #<Money value:33.33 currency:USD>]
+
+  # @example left over cents distributed to first party due to rounding, and two solutions for a more natural distribution
+  #   Money.new(30, "USD").allocate([0.667, 0.333])
+  #     #=> [#<Money value:20.01 currency:USD>, #<Money value:9.99 currency:USD>]
+  #   Money.new(30, "USD").allocate([0.333, 0.667])
+  #     #=> [#<Money value:20.00 currency:USD>, #<Money value:10.00 currency:USD>]
+  #   Money.new(30, "USD").allocate([Rational(2, 3), Rational(1, 3)])
+  #     #=> [#<Money value:20.00 currency:USD>, #<Money value:10.00 currency:USD>]
+  def allocate(splits)
+    if all_rational?(splits)
+      allocations = splits.inject(0) { |sum, n| sum + n }
+    else
+      allocations = splits.inject(0) { |sum, n| sum + Helpers.value_to_decimal(n) }
+    end
+
+    if (allocations - BigDecimal("1")) > Float::EPSILON
+      raise ArgumentError, "splits add to more than 100%"
+    end
+
+    amounts, left_over = amounts_from_splits(allocations, splits)
+
+    left_over.to_i.times { |i| amounts[i % amounts.length] += 1 }
+
+    amounts.collect { |subunits| Money.from_subunits(subunits, currency) }
+  end
+
+  # Allocates money between different parties up to the maximum amounts specified.
+  # Left over pennies will be assigned round-robin up to the maximum specified.
+  # Pennies are dropped when the maximums are attained.
+  #
+  # @example
+  #   Money.new(30.75).allocate_max_amounts([Money.new(26), Money.new(4.75)])
+  #     #=> [Money.new(26), Money.new(4.75)]
+  #
+  #   Money.new(30.75).allocate_max_amounts([Money.new(26), Money.new(4.74)]
+  #     #=> [Money.new(26), Money.new(4.74)]
+  #
+  #   Money.new(30).allocate_max_amounts([Money.new(15), Money.new(15)]
+  #     #=> [Money.new(15), Money.new(15)]
+  #
+  #   Money.new(1).allocate_max_amounts([Money.new(33), Money.new(33), Money.new(33)])
+  #     #=> [Money.new(0.34), Money.new(0.33), Money.new(0.33)]
+  #
+  #   Money.new(100).allocate_max_amounts([Money.new(5), Money.new(2)])
+  #     #=> [Money.new(5), Money.new(2)]
+  def allocate_max_amounts(maximums)
+    allocation_currency = extract_currency(maximums + [self])
+    maximums = maximums.map { |max| max.to_money(allocation_currency) }
+    maximums_total = maximums.reduce(Money.new(0, allocation_currency), :+)
+
+    splits = maximums.map do |max_amount|
+      next(0) if maximums_total.zero?
+      Money.rational(max_amount, maximums_total)
+    end
+
+    total_allocatable = [
+      value * allocation_currency.subunit_to_unit,
+      maximums_total.value * allocation_currency.subunit_to_unit
+    ].min
+
+    subunits_amounts, left_over = amounts_from_splits(1, splits, total_allocatable)
+
+    subunits_amounts.each_with_index do |amount, index|
+      break unless left_over > 0
+
+      max_amount = maximums[index].value * allocation_currency.subunit_to_unit
+      next unless amount < max_amount
+
+      left_over -= 1
+      subunits_amounts[index] += 1
+    end
+
+    subunits_amounts.map { |cents| Money.from_subunits(cents, allocation_currency) }
+  end
+
+  # Split money amongst parties evenly without losing pennies.
+  #
+  # @param [2] number of parties.
+  #
+  # @return [Array<Money, Money, Money>]
+  #
+  # @example
+  #   Money.new(100, "USD").split(3) #=> [Money.new(34), Money.new(33), Money.new(33)]
+  def split(num)
+    raise ArgumentError, "need at least one party" if num < 1
+    subunits = self.subunits
+    low = Money.from_subunits(subunits / num, currency)
+    high = Money.from_subunits(low.subunits + 1, currency)
+
+    remainder = subunits % num
+    result = []
+
+    num.times do |index|
+      result[index] = index < remainder ? high : low
+    end
+
+    return result
+  end
+
+  # Clamps the value to be within the specified minimum and maximum. Returns
+  # self if the value is within bounds, otherwise a new Money object with the
+  # closest min or max value.
+  #
+  # @example
+  #   Money.new(50, "CAD").clamp(1, 100) #=> Money.new(50, "CAD")
+  #
+  #   Money.new(120, "CAD").clamp(0, 100) #=> Money.new(100, "CAD")
+  def clamp(min, max)
+    raise ArgumentError, 'min cannot be greater than max' if min > max
+
+    clamped_value = min if self.value < min
+    clamped_value = max if self.value > max
+
+    if clamped_value.nil?
+      self
+    else
+      Money.new(clamped_value, self.currency)
+    end
+  end
+
+  private
+
+  def all_rational?(splits)
+    splits.all? { |split| split.is_a?(Rational) }
+  end
+
+  def amounts_from_splits(allocations, splits, subunits_to_split = subunits)
+    left_over = subunits_to_split
+
+    amounts = splits.collect do |ratio|
+      frac = (Helpers.value_to_decimal(subunits_to_split * ratio) / allocations).floor
+      left_over -= frac
+      frac
+    end
+
+    [amounts, left_over]
+  end
+
+  def arithmetic(money_or_numeric)
+    raise TypeError, "#{money_or_numeric.class.name} can't be coerced into Money" unless money_or_numeric.respond_to?(:to_money)
+    other = money_or_numeric.to_money(currency)
+
+    unless currency.compatible?(other.currency)
+      Money.deprecate("mathematical operation not permitted for Money objects with different currencies #{other.currency} and #{currency}.")
+    end
+    yield(other)
+  end
+
+  def calculated_currency(other)
+    no_currency? ? other : currency
+  end
+
+  def extract_currency(money_array)
+    currencies = money_array.lazy.select { |money| money.is_a?(Money) }.reject(&:no_currency?).map(&:currency).to_a.uniq
+    if currencies.size > 1
+      raise ArgumentError, "operation not permitted for Money objects with different currencies #{currencies.join(', ')}"
+    end
+    currencies.first || NULL_CURRENCY
+  end
+end