shopify-money 0.10.0

data/lib/money/money_parser.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# Parse an amount from a string
+class MoneyParser
+  class MoneyFormatError < ArgumentError; end
+
+  MARKS = %w[. , · ’ ˙ '] + [' ']
+
+  ESCAPED_MARKS = Regexp.escape(MARKS.join)
+  ESCAPED_NON_SPACE_MARKS = Regexp.escape((MARKS - [' ']).join)
+  ESCAPED_NON_DOT_MARKS = Regexp.escape((MARKS - ['.']).join)
+  ESCAPED_NON_COMMA_MARKS = Regexp.escape((MARKS - [',']).join)
+
+  NUMERIC_REGEX = /(
+    [\+\-]?
+    [\d#{ESCAPED_NON_SPACE_MARKS}][\d#{ESCAPED_MARKS}]*
+  )/ix
+
+  # 1,234,567.89
+  DOT_DECIMAL_REGEX = /\A
+    [\+\-]?
+    (?:
+      (?:\d+)
+      (?:[#{ESCAPED_NON_DOT_MARKS}]\d{3})+
+      (?:\.\d{2,})?
+    )
+  \z/ix
+
+  # 1.234.567,89
+  COMMA_DECIMAL_REGEX = /\A
+    [\+\-]?
+    (?:
+      (?:\d+)
+      (?:[#{ESCAPED_NON_COMMA_MARKS}]\d{3})+
+      (?:\,\d{2,})?
+    )
+  \z/ix
+
+  # 12,34,567.89
+  INDIAN_NUMERIC_REGEX = /\A
+    [\+\-]?
+    (?:
+      (?:\d+)
+      (?:\,\d{2})+
+      (?:\,\d{3})
+      (?:\.\d{2})?
+    )
+  \z/ix
+
+  # 1,1123,4567.89
+  CHINESE_NUMERIC_REGEX = /\A
+    [\+\-]?
+    (?:
+      (?:\d+)
+      (?:\,\d{4})+
+      (?:\.\d{2})?
+    )
+  \z/ix
+
+  def self.parse(input, currency = nil, **options)
+    new.parse(input, currency, **options)
+  end
+
+  def parse(input, currency = nil, strict: false)
+    currency = Money::Helpers.value_to_currency(currency)
+    amount = extract_money(input.to_s, currency, strict)
+    Money.new(amount, currency)
+  end
+
+  private
+
+  def extract_money(input, currency, strict)
+    if input.empty?
+      return '0'
+    end
+
+    number = input.scan(NUMERIC_REGEX).flatten.first
+    number = number.to_s.strip
+
+    if number.empty?
+      raise MoneyFormatError, "invalid money string: #{input}" if strict
+      Money.deprecate("invalid money strings will raise in the next major release \"#{input}\"")
+      return '0'
+    end
+
+    marks = number.scan(/[#{ESCAPED_MARKS}]/).flatten
+    if marks.empty?
+      return number
+    end
+
+    if marks.size == 1
+      return normalize_number(number, marks, currency)
+    end
+
+    # remove end of string mark
+    number.sub!(/[#{ESCAPED_MARKS}]\z/, '')
+
+    if amount = number[DOT_DECIMAL_REGEX] || number[INDIAN_NUMERIC_REGEX] || number[CHINESE_NUMERIC_REGEX]
+      return amount.tr(ESCAPED_NON_DOT_MARKS, '')
+    end
+
+    if amount = number[COMMA_DECIMAL_REGEX]
+      return amount.tr(ESCAPED_NON_COMMA_MARKS, '').sub(',', '.')
+    end
+
+    raise MoneyFormatError, "invalid money string: #{input}" if strict
+    Money.deprecate("invalid money strings will raise in the next major release \"#{input}\"")
+
+    normalize_number(number, marks, currency)
+  end
+
+  def normalize_number(number, marks, currency)
+    digits = number.rpartition(marks.last)
+    digits.first.tr!(ESCAPED_MARKS, '')
+
+    if last_digits_decimals?(digits, marks, currency)
+      "#{digits.first}.#{digits.last}"
+    else
+      "#{digits.first}#{digits.last}"
+    end
+  end
+
+  def last_digits_decimals?(digits, marks, currency)
+    # Thousands marks are always different from decimal marks
+    # Example: 1,234,456
+    *other_marks, last_mark = marks
+    other_marks.uniq!
+    if other_marks.size == 1
+      return other_marks.first != last_mark
+    end
+
+    # Thousands always have more than 2 digits
+    # Example: 1,23 must be 1 dollar and 23 cents
+    if digits.last.size < 3
+      return !digits.last.empty?
+    end
+
+    # 0 before the final mark indicates last digits are decimals
+    # Example: 0,23
+    if digits.first.to_i.zero?
+      return true
+    end
+
+    # legacy support for 1.000 USD
+    if digits.last.size == 3 && digits.first.size <= 3 && currency.minor_units < 3
+      return false
+    end
+
+    # The last mark matches the one used by the provided currency to delimiter decimals
+    currency.decimal_mark == last_mark
+  end
+end

data/lib/money/null_currency.rb

@@ -0,0 +1,35 @@
+class Money
+  class NullCurrency
+
+    attr_reader :iso_code, :iso_numeric, :name, :smallest_denomination, :subunit_symbol,
+                :subunit_to_unit, :minor_units, :symbol, :disambiguate_symbol, :decimal_mark
+
+    def initialize
+      @symbol                = '$'
+      @disambiguate_symbol   = nil
+      @subunit_symbol        = nil
+      @iso_code              = 'XXX' # Valid ISO4217
+      @iso_numeric           = '999'
+      @name                  = 'No Currency'
+      @smallest_denomination = 1
+      @subunit_to_unit       = 100
+      @minor_units           = 2
+      @decimal_mark          = '.'
+      freeze
+    end
+
+    def compatible?(other)
+      other.is_a?(Currency) || other.is_a?(NullCurrency)
+    end
+
+    def eql?(other)
+      self.class == other.class && iso_code == other.iso_code
+    end
+
+    def to_s
+      ''
+    end
+
+    alias_method :==, :eql?
+  end
+end

data/lib/money/version.rb

@@ -0,0 +1,3 @@
+class Money
+  VERSION = "0.10.0"
+end

data/lib/money_accessor.rb

@@ -0,0 +1,32 @@
+module MoneyAccessor
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def money_accessor(*columns)
+      variable_get = self <= Struct ? :[]  : :instance_variable_get
+      variable_set = self <= Struct ? :[]= : :instance_variable_set
+
+      Array(columns).flatten.each do |name|
+        variable_name = self <= Struct ? name : "@#{name}"
+
+        define_method(name) do
+          value = public_send(variable_get, variable_name)
+          value.blank? ? nil : Money.new(value)
+        end
+
+        define_method("#{name}=") do |value|
+          if value.blank? || !value.respond_to?(:to_money)
+            public_send(variable_set, variable_name, nil)
+            nil
+          else
+            money = value.to_money
+            public_send(variable_set, variable_name, money.value)
+            money
+          end
+        end
+      end
+    end
+  end
+end

data/lib/money_column.rb

@@ -0,0 +1,3 @@
+require_relative 'money_column/active_record_hooks'
+require_relative 'money_column/active_record_type'
+require_relative 'money_column/railtie'

data/lib/money_column/active_record_hooks.rb

@@ -0,0 +1,95 @@
+module MoneyColumn
+  module ActiveRecordHooks
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def reload(*)
+      clear_money_column_cache
+      super
+    end
+
+    def initialize_dup(*)
+      @money_column_cache = {}
+      super
+    end
+
+    private
+
+    def clear_money_column_cache
+      @money_column_cache.clear if persisted?
+    end
+
+    def init_internals
+      @money_column_cache = {}
+      super
+    end
+
+    module ClassMethods
+      def money_column(*columns, currency_column: nil, currency: nil, currency_read_only: false, coerce_null: false)
+        raise ArgumentError, 'cannot set both currency_column and a fixed currency' if currency && currency_column
+
+        if currency
+          currency_iso = Money::Currency.find!(currency).to_s
+          currency_read_only = true
+        elsif currency_column
+          clear_cache_on_currency_change(currency_column)
+        else
+          raise ArgumentError, 'must set one of :currency_column or :currency options'
+        end
+        currency_column = currency_column.to_s.freeze
+
+        columns.flatten.each do |column|
+          column_string = column.to_s.freeze
+          attribute(column_string, MoneyColumn::ActiveRecordType.new)
+          money_column_reader(column_string, currency_column, currency_iso, coerce_null)
+          money_column_writer(column_string, currency_column, currency_iso, currency_read_only)
+        end
+      end
+
+      private
+
+      def clear_cache_on_currency_change(currency_column)
+        define_method "#{currency_column}=" do |value|
+          @money_column_cache.clear
+          super(value)
+        end
+      end
+
+      def money_column_reader(column, currency_column, currency_iso, coerce_null)
+        define_method column do
+          return @money_column_cache[column] if @money_column_cache[column]
+          value = read_attribute(column)
+          return if value.nil? && !coerce_null
+          iso = currency_iso || send(currency_column)
+          @money_column_cache[column] = Money.new(value, iso)
+        end
+      end
+
+      def money_column_writer(column, currency_column, currency_iso, currency_read_only)
+        define_method "#{column}=" do |money|
+          @money_column_cache[column] = nil
+
+          if money.blank?
+            write_attribute(column, nil)
+            return nil
+          end
+
+          currency_raw_source = currency_iso || (send(currency_column) rescue nil)
+          currency_source = Money::Helpers.value_to_currency(currency_raw_source)
+
+          if !money.is_a?(Money)
+            return write_attribute(column, Money.new(money, currency_source).value)
+          end
+
+          if currency_raw_source && !currency_source.compatible?(money.currency)
+            Money.deprecate("[money_column] currency mismatch between #{currency_source} and #{money.currency}.")
+          end
+
+          write_attribute(column, money.value)
+          write_attribute(currency_column, money.currency.to_s) unless currency_read_only || money.no_currency?
+        end
+      end
+    end
+  end
+end

data/lib/money_column/active_record_type.rb

@@ -0,0 +1,6 @@
+class MoneyColumn::ActiveRecordType < ActiveRecord::Type::Decimal
+  def serialize(money)
+    return nil unless money
+    super(money.to_d)
+  end
+end

data/lib/money_column/railtie.rb

@@ -0,0 +1,7 @@
+module MoneyColumn
+  class Railtie < Rails::Railtie
+    ActiveSupport.on_load :active_record do
+      ActiveRecord::Base.send(:include, MoneyColumn::ActiveRecordHooks)
+    end
+  end
+end

data/money.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require_relative "lib/money/version"
+
+Gem::Specification.new do |s|
+  s.name = "shopify-money"
+  s.version = Money::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Shopify Inc"]
+  s.email = "gems@shopify.com"
+  s.description = "Manage money in Shopify with a class that wont lose pennies during division!"
+  s.homepage = "https://github.com/Shopify/money"
+  s.licenses = "MIT"
+  s.summary = "Shopify's money gem"
+
+  s.add_development_dependency("bundler", ">= 1.5")
+  s.add_development_dependency("simplecov", ">= 0")
+  s.add_development_dependency("rails", "~> 5.0")
+  s.add_development_dependency("rspec", "~> 3.2")
+  s.add_development_dependency("database_cleaner", "~> 1.6")
+  s.add_development_dependency("sqlite3", "~> 1.3")
+  s.add_development_dependency("bigdecimal", ">= 1.3.2")
+
+  s.files = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+end

data/spec/accounting_money_parser_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+RSpec.describe AccountingMoneyParser do
+  describe "parsing of amounts with period decimal separator" do
+    before(:each) do
+      @parser = AccountingMoneyParser.new
+    end
+
+    it "parses parenthesis as a negative amount eg (99.00)" do
+      expect(@parser.parse("(99.00)")).to eq(Money.new(-99.00))
+    end
+
+    it "parses parenthesis as a negative amount regardless of currency sign" do
+      expect(@parser.parse("($99.00)")).to eq(Money.new(-99.00))
+    end
+
+    it "parses an empty string to $0" do
+      expect(@parser.parse("")).to eq(Money.new)
+    end
+
+    it "parses an invalid string to $0" do
+      expect(Money).to receive(:deprecate).once
+      expect(@parser.parse("no money")).to eq(Money.new)
+    end
+
+    it "parses a single digit integer string" do
+      expect(@parser.parse("1")).to eq(Money.new(1.00))
+    end
+
+    it "parses a double digit integer string" do
+      expect(@parser.parse("10")).to eq(Money.new(10.00))
+    end
+
+    it "parses an integer string amount with a leading $" do
+      expect(@parser.parse("$1")).to eq(Money.new(1.00))
+    end
+
+    it "parses a float string amount" do
+      expect(@parser.parse("1.37")).to eq(Money.new(1.37))
+    end
+
+    it "parses a float string amount with a leading $" do
+      expect(@parser.parse("$1.37")).to eq(Money.new(1.37))
+    end
+
+    it "parses a float string with a single digit after the decimal" do
+      expect(@parser.parse("10.0")).to eq(Money.new(10.00))
+    end
+
+    it "parses a float string with two digits after the decimal" do
+      expect(@parser.parse("10.00")).to eq(Money.new(10.00))
+    end
+
+    it "parses the amount from an amount surrounded by whitespace and garbage" do
+      expect(@parser.parse("Rubbish $1.00 Rubbish")).to eq(Money.new(1.00))
+    end
+
+    it "parses the amount from an amount surrounded by garbage" do
+      expect(@parser.parse("Rubbish$1.00Rubbish")).to eq(Money.new(1.00))
+    end
+
+    it "parses a negative integer amount in the hundreds" do
+      expect(@parser.parse("-100")).to eq(Money.new(-100.00))
+    end
+
+    it "parses an integer amount in the hundreds" do
+      expect(@parser.parse("410")).to eq(Money.new(410.00))
+    end
+
+    it "parses a positive amount with a thousands separator" do
+      expect(@parser.parse("100,000.00")).to eq(Money.new(100_000.00))
+    end
+
+    it "parses a negative amount with a thousands separator" do
+      expect(@parser.parse("-100,000.00")).to eq(Money.new(-100_000.00))
+    end
+
+    it "parses negative $1.00" do
+      expect(@parser.parse("-1.00")).to eq(Money.new(-1.00))
+    end
+
+    it "parses a negative cents amount" do
+      expect(@parser.parse("-0.90")).to eq(Money.new(-0.90))
+    end
+
+    it "parses amount with 3 decimals and 0 dollar amount" do
+      expect(@parser.parse("0.123")).to eq(Money.new(0.12))
+    end
+
+    it "parses negative amount with 3 decimals and 0 dollar amount" do
+      expect(@parser.parse("-0.123")).to eq(Money.new(-0.12))
+    end
+
+    it "parses negative amount with multiple leading - signs" do
+      expect(@parser.parse("--0.123")).to eq(Money.new(-0.12))
+    end
+
+    it "parses negative amount with multiple - signs" do
+      expect(@parser.parse("--0.123--")).to eq(Money.new(-0.12))
+    end
+  end
+
+  describe "parsing of amounts with comma decimal separator" do
+    before(:each) do
+      @parser = AccountingMoneyParser.new
+    end
+
+    it "parses dollar amount $1,00 with leading $" do
+      expect(@parser.parse("$1,00")).to eq(Money.new(1.00))
+    end
+
+    it "parses dollar amount $1,37 with leading $, and non-zero cents" do
+      expect(@parser.parse("$1,37")).to eq(Money.new(1.37))
+    end
+
+    it "parses the amount from an amount surrounded by whitespace and garbage" do
+      expect(@parser.parse("Rubbish $1,00 Rubbish")).to eq(Money.new(1.00))
+    end
+
+    it "parses the amount from an amount surrounded by garbage" do
+      expect(@parser.parse("Rubbish$1,00Rubbish")).to eq(Money.new(1.00))
+    end
+
+    it "parses thousands amount" do
+      Money.with_currency(Money::NULL_CURRENCY) do
+        expect(@parser.parse("1.000")).to eq(Money.new(1000.00))
+      end
+    end
+
+    it "parses negative hundreds amount" do
+      expect(@parser.parse("-100,00")).to eq(Money.new(-100.00))
+    end
+
+    it "parses positive hundreds amount" do
+      expect(@parser.parse("410,00")).to eq(Money.new(410.00))
+    end
+
+    it "parses a positive amount with a thousands separator" do
+      expect(@parser.parse("100.000,00")).to eq(Money.new(100_000.00))
+    end
+
+    it "parses a negative amount with a thousands separator" do
+      expect(@parser.parse("-100.000,00")).to eq(Money.new(-100_000.00))
+    end
+
+    it "parses amount with 3 decimals and 0 dollar amount" do
+      expect(@parser.parse("0,123")).to eq(Money.new(0.12))
+    end
+
+    it "parses negative amount with 3 decimals and 0 dollar amount" do
+      expect(@parser.parse("-0,123")).to eq(Money.new(-0.12))
+    end
+  end
+
+  describe "parsing of decimal cents amounts from 0 to 10" do
+    before(:each) do
+      @parser = AccountingMoneyParser.new
+    end
+
+    it "parses 50.0" do
+      expect(@parser.parse("50.0")).to eq(Money.new(50.00))
+    end
+
+    it "parses 50.1" do
+      expect(@parser.parse("50.1")).to eq(Money.new(50.10))
+    end
+
+    it "parses 50.2" do
+      expect(@parser.parse("50.2")).to eq(Money.new(50.20))
+    end
+
+    it "parses 50.3" do
+      expect(@parser.parse("50.3")).to eq(Money.new(50.30))
+    end
+
+    it "parses 50.4" do
+      expect(@parser.parse("50.4")).to eq(Money.new(50.40))
+    end
+
+    it "parses 50.5" do
+      expect(@parser.parse("50.5")).to eq(Money.new(50.50))
+    end
+
+    it "parses 50.6" do
+      expect(@parser.parse("50.6")).to eq(Money.new(50.60))
+    end
+
+    it "parses 50.7" do
+      expect(@parser.parse("50.7")).to eq(Money.new(50.70))
+    end
+
+    it "parses 50.8" do
+      expect(@parser.parse("50.8")).to eq(Money.new(50.80))
+    end
+
+    it "parses 50.9" do
+      expect(@parser.parse("50.9")).to eq(Money.new(50.90))
+    end
+
+    it "parses 50.10" do
+      expect(@parser.parse("50.10")).to eq(Money.new(50.10))
+    end
+  end
+end