shopify-money 1.0.1.pre → 1.0.2.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae5e66176d7c6e79d5c6346a3ca6915489d3750d7bb67aa68973c52a0198cb3f
-  data.tar.gz: 7219d1edd8665498e64eb06e6212028d8ec559dd5ce9206cbe698e5b1e42d2ed
+  metadata.gz: 23562c524ba9f0d8219d01779505a75309d8825ed8f8839f1efdd71fbf5a1e89
+  data.tar.gz: ca1b6ea90e7a556970d135bbebc74c9cf6eb417cd475607ef58923751e2969b3
 SHA512:
-  metadata.gz: 4188d1251f442d347b287b3b3ac69c08f716b149ef9cc8a78f2c8e75fb563524f3818a9b8116cf2d433117a9e66cbb96b428aed9bf8cd9f9e79eaefa94ca5c45
-  data.tar.gz: 9e70a02a0acdf5eca299ad5f4b201b3fb44a98977d972d08db4167938f24793b732a55f25d6ea3585c8c63d92b014bc108083cce1aef1659b65c628f3ab0b27f
+  metadata.gz: 81f2eb5e04d1cf082cf3eaadd5d609d4abcdef1841d1dde9b2eee68c0b8e570b7c0c72dd0a2a05c7213b0c611a267a2b6fbca044d2a86711765aa91f8e2ea763
+  data.tar.gz: cf7864860eb1fab370902861200b23150d08b1d135f614896a9c32fe20ea9e1edc7070563325c4a102a4af64c986c308892e13aefe9ad2590e4ac75d17f30a22

data/UPGRADING.md

@@ -12,6 +12,8 @@ end
 
 Remove each legacy setting making sure your app functions as expected.
 
+Replace `Money.parse` with `Money::Parser::Fuzzy.parse`.
+
 ### Legacy support
 
 #### legacy_default_currency!

data/lib/money/config.rb

@@ -2,7 +2,7 @@
 
 class Money
   class Config
-    attr_accessor :parser, :default_currency, :legacy_json_format, :legacy_deprecations
+    attr_accessor :default_currency, :legacy_json_format, :legacy_deprecations
 
     def legacy_default_currency!
       @default_currency ||= Money::NULL_CURRENCY
@@ -17,7 +17,6 @@ class Money
     end
 
     def initialize
-      @parser = MoneyParser
       @default_currency = nil
       @legacy_json_format = false
       @legacy_deprecations = false

data/lib/money/core_extensions.rb

@@ -14,6 +14,6 @@ end
 #   '100.37'.to_money => #<Money @cents=10037>
 class String
   def to_money(currency = nil)
-    Money.parse(self, currency)
+    Money::Parser::Fuzzy.parse(self, currency)
   end
 end

data/lib/money/money.rb

@@ -13,7 +13,7 @@ class Money
   class << self
     extend Forwardable
     attr_accessor :config
-    def_delegators :@config, :parser, :parser=, :default_currency, :default_currency=
+    def_delegators :@config, :default_currency, :default_currency=
 
     def configure
       self.config ||= Config.new
@@ -33,10 +33,6 @@ class Money
     end
     alias_method :from_amount, :new
 
-    def parse(*args, **kwargs)
-      parser.parse(*args, **kwargs)
-    end
-
     def from_subunits(subunits, currency_iso, format: :iso4217)
       currency = Helpers.value_to_currency(currency_iso)
 

data/lib/money/parser/accounting.rb

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

data/lib/money/parser/fuzzy.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+class Money
+  module Parser
+    class Fuzzy
+      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
+
+      # Parses an input string and attempts to find the decimal separator based on certain heuristics, like the amount
+      # decimals for the fractional part a currency has or the incorrect notion a currency has a defined decimal
+      # separator (this is a property of the locale). While these heuristics can lead to the expected result for some
+      # cases, the other cases can lead to surprising results such as parsed amounts being 1000x larger than intended.
+      # @deprecated Use {LocaleAware.parse} or {Simple.parse} instead.
+      # @param input [String]
+      # @param currency [String, Money::Currency, nil]
+      # @param strict [Boolean]
+      # @return [Money]
+      # @raise [MoneyFormatError]
+      def parse(input, currency = nil, strict: false)
+        currency = Money::Helpers.value_to_currency(currency)
+        amount = extract_amount_from_string(input, currency, strict)
+        Money.new(amount, currency)
+      end
+
+      private
+
+      def extract_amount_from_string(input, currency, strict)
+        unless input.is_a?(String)
+          return input
+        end
+
+        if input.strip.empty?
+          return '0'
+        end
+
+        number = input.scan(NUMERIC_REGEX).flatten.first
+        number = number.to_s.strip
+
+        if number.empty?
+          if Money.config.legacy_deprecations && !strict
+            Money.deprecate("invalid money strings will raise in the next major release \"#{input}\"")
+            return '0'
+          else
+            raise MoneyFormatError, "invalid money string: #{input}"
+          end
+        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
+
+        if Money.config.legacy_deprecations && !strict
+          Money.deprecate("invalid money strings will raise in the next major release \"#{input}\"")
+        else
+          raise MoneyFormatError, "invalid money string: #{input}"
+        end
+
+        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)
+        # Grouping 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
+  end
+end

data/lib/money/parser/locale_aware.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+class Money
+  module Parser
+    class LocaleAware
+      @decimal_separator_resolver = nil
+
+      class << self
+        # The +Proc+ called to get the current locale decimal separator. In Rails apps this defaults to the same lookup
+        # ActionView's +number_to_currency+ helper will use to format the monetary amount for display.
+        def decimal_separator_resolver
+          @decimal_separator_resolver
+        end
+
+        # Set the default +Proc+ to determine the current locale decimal separator.
+        #
+        # @example
+        #   Money::Parser::LocaleAware.decimal_separator_resolver =
+        #     ->() { MyFormattingLibrary.current_locale.decimal.separator }
+        def decimal_separator_resolver=(proc)
+          @decimal_separator_resolver = proc
+        end
+
+        # Parses an input string, normalizing some non-ASCII characters to their equivalent ASCII, then discarding any
+        # character that is not a digit, hyphen-minus or the decimal separator. To prevent user confusion, make sure
+        # that formatted Money strings can be parsed back into equivalent Money objects.
+        #
+        # @param input [String]
+        # @param currency [String, Money::Currency]
+        # @param strict [Boolean]
+        # @param decimal_separator [String]
+        # @return [Money, nil]
+        def parse(input, currency, strict: false, decimal_separator: decimal_separator_resolver&.call)
+          raise ArgumentError, "decimal separator cannot be nil" unless decimal_separator
+
+          currency = Money::Helpers.value_to_currency(currency)
+          return unless currency
+
+          normalized_input = input
+            .tr('－０-９．，、､', '-0-9.,,,')
+            .gsub(/[^\d\-#{Regexp.escape(decimal_separator)}]/, '')
+            .gsub(decimal_separator, '.')
+          amount = BigDecimal(normalized_input, exception: false)
+          if amount
+            Money.new(amount, currency)
+          elsif strict
+            raise ArgumentError, "unable to parse input=\"#{input}\" currency=\"#{currency}\""
+          end
+        end
+      end
+    end
+  end
+end

data/lib/money/parser/simple.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+class Money
+  module Parser
+    class Simple
+      SIGNED_DECIMAL_MATCHER = /\A-?\d*(?:\.\d*)?\z/.freeze
+
+      class << self
+        # Parses an input string using BigDecimal, it always expects a dot character as a decimal separator and
+        # generally does not accept other characters other than minus-hyphen and digits. It is useful for APIs, interop
+        # with other languages and other use cases where you expect well-formatted input and do not need to take user
+        # locale into consideration.
+        # @param input [String]
+        # @param currency [String, Money::Currency]
+        # @param strict [Boolean]
+        # @return [Money, nil]
+        def parse(input, currency, strict: false)
+          currency = Money::Helpers.value_to_currency(currency)
+          return unless currency
+
+          coerced = input.to_s
+          if SIGNED_DECIMAL_MATCHER.match?(coerced) && (amount = BigDecimal(coerced, exception: false))
+            Money.new(amount, currency)
+          elsif strict
+            raise ArgumentError, "unable to parse input=\"#{input}\" currency=\"#{currency}\""
+          end
+        end
+      end
+    end
+  end
+end

data/lib/money/railtie.rb

@@ -8,5 +8,12 @@ class Money
         ActiveJob::Serializers.add_serializers ::Money::Rails::JobArgumentSerializer
       end
     end
+
+    initializer "shopify-money.setup_locale_aware_parser" do
+      ActiveSupport.on_load(:action_view) do
+        Money::Parser::LocaleAware.decimal_separator_resolver =
+          -> { ::I18n.translate("number.currency.format.separator") }
+      end
+    end
   end
 end

data/lib/money/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 class Money
-  VERSION = "1.0.1.pre"
+  VERSION = "1.0.2.pre"
 end

data/lib/money.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 require_relative 'money/version'
-require_relative 'money/money_parser'
+require_relative 'money/parser/fuzzy'
 require_relative 'money/helpers'
 require_relative 'money/currency'
 require_relative 'money/null_currency'
@@ -9,7 +9,9 @@ require_relative 'money/config'
 require_relative 'money/money'
 require_relative 'money/errors'
 require_relative 'money/deprecations'
-require_relative 'money/accounting_money_parser'
+require_relative 'money/parser/accounting'
+require_relative 'money/parser/locale_aware'
+require_relative 'money/parser/simple'
 require_relative 'money/core_extensions'
 require_relative 'money_column' if defined?(ActiveRecord)
 require_relative 'money/railtie' if defined?(Rails::Railtie)

data/spec/config_spec.rb

@@ -32,18 +32,6 @@ RSpec.describe "Money::Config" do
     end
   end
 
-  describe 'parser' do
-    it 'defaults to MoneyParser' do
-      expect(Money::Config.new.parser).to eq(MoneyParser)
-    end
-
-    it 'can be set to a new parser' do
-      configure(parser: AccountingMoneyParser) do
-        expect(Money.config.parser).to eq(AccountingMoneyParser)
-      end
-    end
-  end
-
   describe 'default_currency' do
     it 'defaults to nil' do
       configure do

data/spec/money_spec.rb

@@ -794,22 +794,6 @@ RSpec.describe "Money" do
     end
   end
 
-  describe "parser dependency injection" do
-    around(:each) { |test| configure(parser: AccountingMoneyParser, default_currency: 'CAD') { test.run }}
-
-    it "keeps AccountingMoneyParser class on new money objects" do
-      expect(Money.new.class.parser).to eq(AccountingMoneyParser)
-    end
-
-    it "supports parenthesis from AccountingMoneyParser" do
-      expect(Money.parse("($5.00)")).to eq(Money.new(-5))
-    end
-
-    it "supports parenthesis from AccountingMoneyParser for .to_money" do
-      expect("($5.00)".to_money).to eq(Money.new(-5))
-    end
-  end
-
   describe "round" do
 
     it "rounds to 0 decimal places by default" do

data/spec/{accounting_money_parser_spec.rb → parser/accounting_spec.rb}

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 require 'spec_helper'
 
-RSpec.describe AccountingMoneyParser do
-  describe "parsing of amounts with period decimal separator" do
-    before(:each) do
-      @parser = AccountingMoneyParser.new
-    end
+RSpec.describe Money::Parser::Accounting do
+  before(:each) do
+    @parser = described_class
+  end
 
+  describe "parsing of amounts with period decimal separator" do
     it "parses parenthesis as a negative amount eg (99.00)" do
       expect(@parser.parse("(99.00)")).to eq(Money.new(-99.00))
     end
@@ -104,10 +104,6 @@ RSpec.describe AccountingMoneyParser do
   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
@@ -156,10 +152,6 @@ RSpec.describe AccountingMoneyParser do
   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

data/spec/{money_parser_spec.rb → parser/fuzzy_spec.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 require 'spec_helper'
 
-RSpec.describe MoneyParser do
+RSpec.describe Money::Parser::Fuzzy do
   before(:each) do
-    @parser = MoneyParser
+    @parser = described_class
   end
 
   describe "parsing of amounts with period decimal separator" do
@@ -20,8 +20,8 @@ RSpec.describe MoneyParser do
     end
 
     it "parses raise with an invalid string and strict option" do
-      expect { @parser.parse("no money", strict: true) }.to raise_error(MoneyParser::MoneyFormatError)
-      expect { @parser.parse("1..1", strict: true) }.to raise_error(MoneyParser::MoneyFormatError)
+      expect { @parser.parse("no money", strict: true) }.to raise_error(described_class::MoneyFormatError)
+      expect { @parser.parse("1..1", strict: true) }.to raise_error(described_class::MoneyFormatError)
     end
 
     it "parses raise with an invalid when a currency is missing" do
@@ -159,7 +159,7 @@ RSpec.describe MoneyParser do
     end
 
     it "parses raises with multiple inconsistent thousands delimiters and strict option" do
-      expect { @parser.parse("1.1.11.111", strict: true) }.to raise_error(MoneyParser::MoneyFormatError)
+      expect { @parser.parse("1.1.11.111", strict: true) }.to raise_error(described_class::MoneyFormatError)
     end
   end
 
@@ -233,7 +233,7 @@ RSpec.describe MoneyParser do
     end
 
     it "parses raises with multiple inconsistent thousands delimiters and strict option" do
-      expect { @parser.parse("1,1,11,111", strict: true) }.to raise_error(MoneyParser::MoneyFormatError)
+      expect { @parser.parse("1,1,11,111", strict: true) }.to raise_error(described_class::MoneyFormatError)
     end
   end
 

data/spec/parser/locale_aware_spec.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Money::Parser::LocaleAware do
+  context "parsing amounts with period decimal separator" do
+    around(:example) do |example|
+      with_decimal_separator(".") { example.run }
+    end
+
+    it "parses an empty string to nil" do
+      expect(described_class.parse("", "CAD")).to be_nil
+    end
+
+    it "parses an invalid string when not strict" do
+      expect(described_class.parse("no money", "CAD")).to be_nil
+      expect(described_class.parse("1..", "CAD")).to be_nil
+    end
+
+    it "raises with an invalid string and strict option" do
+      expect { described_class.parse("no money", "CAD", strict: true) }.to raise_error(ArgumentError)
+      expect { described_class.parse("1..1", "CAD", strict: true) }.to raise_error(ArgumentError)
+    end
+
+    it "parses an integer string amount" do
+      expect(described_class.parse("1", "CAD")).to eq(Money.new(1.00, "CAD"))
+      expect(described_class.parse("-1", "CAD")).to eq(Money.new(-1.00, "CAD"))
+    end
+
+    it "parses a float string amount" do
+      expect(described_class.parse("1.37", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("-1.37", "CAD")).to eq(Money.new(-1.37, "CAD"))
+    end
+
+    it "parses a float string with 3 decimals" do
+      expect(described_class.parse("1.378", "JOD")).to eq(Money.new(1.378, "JOD"))
+      expect(described_class.parse("-1.378", "JOD")).to eq(Money.new(-1.378, "JOD"))
+      expect(described_class.parse("123.456", "USD")).to eq(Money.new(123.46, "USD"))
+    end
+
+    it "parses a float string amount with a leading random character" do
+      expect(described_class.parse("$1.37", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse(",1.37", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("€1.37", "CAD")).to eq(Money.new(1.37, "CAD"))
+    end
+
+    it "parses a float string amount with a trailing random character" do
+      expect(described_class.parse("1.37$", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("1.37,", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("1.37€", "CAD")).to eq(Money.new(1.37, "CAD"))
+    end
+
+    it "parses an amount with one or more thousands separators" do
+      expect(described_class.parse("100,000", "CAD")).to eq(Money.new(100_000.00, "CAD"))
+      expect(described_class.parse("-100,000", "CAD")).to eq(Money.new(-100_000.00, "CAD"))
+      expect(described_class.parse("100,000.01", "CAD")).to eq(Money.new(100_000.01, "CAD"))
+      expect(described_class.parse("1,00,000.01", "CAD")).to eq(Money.new(100_000.01, "CAD"))
+      expect(described_class.parse("1,00,000.001", "JOD")).to eq(Money.new(100_000.001, "JOD"))
+    end
+  end
+
+  context "parsing amounts with comma decimal separator" do
+    around(:example) do |example|
+      with_decimal_separator(",") { example.run }
+    end
+
+    it "parses an empty string to nil" do
+      expect(described_class.parse("", "CAD")).to be_nil
+    end
+
+    it "parses an invalid string when not strict" do
+      expect(described_class.parse("no money", "CAD")).to be_nil
+      expect(described_class.parse("1,,", "CAD")).to be_nil
+    end
+
+    it "raises with an invalid string and strict option" do
+      expect { described_class.parse("no money", "CAD", strict: true) }.to raise_error(ArgumentError)
+      expect { described_class.parse("1,,1", "CAD", strict: true) }.to raise_error(ArgumentError)
+    end
+
+    it "parses an integer string amount" do
+      expect(described_class.parse("1", "CAD")).to eq(Money.new(1.00, "CAD"))
+      expect(described_class.parse("-1", "CAD")).to eq(Money.new(-1.00, "CAD"))
+    end
+
+    it "parses a float string amount" do
+      expect(described_class.parse("1,37", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("-1,37", "CAD")).to eq(Money.new(-1.37, "CAD"))
+    end
+
+    it "parses a float string with 3 decimals" do
+      expect(described_class.parse("1,378", "JOD")).to eq(Money.new(1.378, "JOD"))
+      expect(described_class.parse("-1,378", "JOD")).to eq(Money.new(-1.378, "JOD"))
+    end
+
+    it "parses a float string amount with a leading random character" do
+      expect(described_class.parse("$1,37", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse(".1,37", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("€1,37", "CAD")).to eq(Money.new(1.37, "CAD"))
+    end
+
+    it "parses a float string amount with a trailing random character" do
+      expect(described_class.parse("1,37$", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("1,37.", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("1,37€", "CAD")).to eq(Money.new(1.37, "CAD"))
+    end
+
+    it "parses an amount with one or more thousands separators" do
+      expect(described_class.parse("100.000", "CAD")).to eq(Money.new(100_000.00, "CAD"))
+      expect(described_class.parse("-100.000", "CAD")).to eq(Money.new(-100_000.00, "CAD"))
+      expect(described_class.parse("100.000,01", "CAD")).to eq(Money.new(100_000.01, "CAD"))
+      expect(described_class.parse("1.00.000,01", "CAD")).to eq(Money.new(100_000.01, "CAD"))
+      expect(described_class.parse("1.00.000,001", "JOD")).to eq(Money.new(100_000.001, "JOD"))
+    end
+  end
+
+  context "parsing amounts with fullwidth characters" do
+    around(:example) do |example|
+      with_decimal_separator(".") { example.run }
+    end
+
+    it "parses an empty string to nil" do
+      expect(described_class.parse("", "CAD")).to be_nil
+    end
+
+    it "parses an invalid string when not strict" do
+      expect(described_class.parse("ｎｏ ｍｏｎｅｙ", "CAD")).to be_nil
+      expect(described_class.parse("１．．", "CAD")).to be_nil
+    end
+
+    it "raises with an invalid string and strict option" do
+      expect { described_class.parse("ｎｏ ｍｏｎｅｙ", "CAD", strict: true) }.to raise_error(ArgumentError)
+      expect { described_class.parse("１．．１", "CAD", strict: true) }.to raise_error(ArgumentError)
+    end
+
+    it "parses an integer string amount" do
+      expect(described_class.parse("１", "CAD")).to eq(Money.new(1.00, "CAD"))
+      expect(described_class.parse("-１", "CAD")).to eq(Money.new(-1.00, "CAD"))
+    end
+
+    it "parses a float string amount" do
+      expect(described_class.parse("１．３７", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("－１．３７", "CAD")).to eq(Money.new(-1.37, "CAD"))
+    end
+
+    it "parses a float string with 3 decimals" do
+      expect(described_class.parse("１．３７８", "JOD")).to eq(Money.new(1.378, "JOD"))
+      expect(described_class.parse("－１．３７８", "JOD")).to eq(Money.new(-1.378, "JOD"))
+    end
+
+    it "parses a float string amount with a leading random character" do
+      expect(described_class.parse("$１．３７", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("，１．３７", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("€１．３７", "CAD")).to eq(Money.new(1.37, "CAD"))
+    end
+
+    it "parses a float string amount with a trailing random character" do
+      expect(described_class.parse("１．３７$", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("１．３７，", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("１．３７€", "CAD")).to eq(Money.new(1.37, "CAD"))
+    end
+
+    it "parses an amount with one or more thousands separators" do
+      expect(described_class.parse("１００，０００", "CAD")).to eq(Money.new(100_000.00, "CAD"))
+      expect(described_class.parse("－１００，０００", "CAD")).to eq(Money.new(-100_000.00, "CAD"))
+      expect(described_class.parse("１００，０００．０１", "CAD")).to eq(Money.new(100_000.01, "CAD"))
+      expect(described_class.parse("１，００，０００．０１", "CAD")).to eq(Money.new(100_000.01, "CAD"))
+      expect(described_class.parse("１，００，０００．００１", "JOD")).to eq(Money.new(100_000.001, "JOD"))
+      expect(described_class.parse("１００,０００、０００", "JPY")).to eq(Money.new(100_000_000, "JPY"))
+    end
+  end
+
+  context "bad decimal_separator_proc" do
+    context "raises when called" do
+      around(:example) do |example|
+        with_decimal_separator_proc(->() { raise NoMethodError }) { example.run }
+      end
+
+      it "raises the original error" do
+        expect { described_class.parse("1", "CAD") }.to raise_error(NoMethodError)
+      end
+    end
+
+    context "returning nil" do
+      around(:example) do |example|
+        with_decimal_separator(nil) { example.run }
+      end
+
+      it "raises the original error" do
+        expect { described_class.parse("1", "CAD") }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  private
+
+  def with_decimal_separator(character)
+    with_decimal_separator_proc(->() { character }) do
+      yield
+    end
+  end
+
+  def with_decimal_separator_proc(proc)
+    old = described_class.decimal_separator_resolver
+    described_class.decimal_separator_resolver = proc
+    yield
+    described_class.decimal_separator_resolver = old
+  end
+end

data/spec/parser/simple_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Money::Parser::Simple do
+  context "parsing amounts with period decimal separator" do
+    it "parses an empty string to nil" do
+      expect(described_class.parse("", "CAD")).to be_nil
+    end
+
+    it "parses an invalid string when not strict" do
+      expect(described_class.parse("no money", "CAD")).to be_nil
+      expect(described_class.parse("1..", "CAD")).to be_nil
+      expect(described_class.parse("10.", "CAD")).to be_nil
+      expect(described_class.parse("10.1E2", "CAD")).to be_nil
+    end
+
+    it "raises with an invalid string and strict option" do
+      expect { described_class.parse("no money", "CAD", strict: true) }.to raise_error(ArgumentError)
+      expect { described_class.parse("1..1", "CAD", strict: true) }.to raise_error(ArgumentError)
+      expect { described_class.parse("10.", "CAD", strict: true) }.to raise_error(ArgumentError)
+      expect { described_class.parse("10.1E2", "CAD", strict: true) }.to raise_error(ArgumentError)
+    end
+
+    it "parses an integer string amount" do
+      expect(described_class.parse("1", "CAD")).to eq(Money.new(1.00, "CAD"))
+      expect(described_class.parse("-1", "CAD")).to eq(Money.new(-1.00, "CAD"))
+    end
+
+    it "parses a float string amount" do
+      expect(described_class.parse("1.37", "CAD")).to eq(Money.new(1.37, "CAD"))
+      expect(described_class.parse("-1.37", "CAD")).to eq(Money.new(-1.37, "CAD"))
+    end
+
+    it "parses a float string with 3 decimals" do
+      expect(described_class.parse("1.378", "JOD")).to eq(Money.new(1.378, "JOD"))
+      expect(described_class.parse("-1.378", "JOD")).to eq(Money.new(-1.378, "JOD"))
+      expect(described_class.parse("123.456", "USD")).to eq(Money.new(123.46, "USD"))
+    end
+
+    it "does not parse a float string amount with a leading random character" do
+      expect(described_class.parse("$1.37", "CAD")).to be_nil
+      expect(described_class.parse(",1.37", "CAD")).to be_nil
+      expect(described_class.parse("€1.37", "CAD")).to be_nil
+      expect(described_class.parse(" 1.37", "CAD")).to be_nil
+    end
+
+    it "does not parse a float string amount with a trailing random character" do
+      expect(described_class.parse("1.37$", "CAD")).to be_nil
+      expect(described_class.parse("1.37,", "CAD")).to be_nil
+      expect(described_class.parse("1.37€", "CAD")).to be_nil
+      expect(described_class.parse("1.37 ", "CAD")).to be_nil
+    end
+
+    it "does not parse an amount with one or more thousands separators" do
+      expect(described_class.parse("100,000", "CAD")).to be_nil
+      expect(described_class.parse("-100,000", "CAD")).to be_nil
+      expect(described_class.parse("100,000.01", "CAD")).to be_nil
+      expect(described_class.parse("1,00,000.01", "CAD")).to be_nil
+      expect(described_class.parse("1,00,000.001", "JOD")).to be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ require 'simplecov'
 SimpleCov.minimum_coverage 100
 SimpleCov.start do
   add_filter "/spec/"
+  add_filter "/lib/money/railtie"
 end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -70,11 +71,10 @@ RSpec::Matchers.define :quack_like do
 end
 
 
-def configure(default_currency: nil, legacy_json_format: nil, legacy_deprecations: nil, legacy_default_currency: nil, parser: nil)
+def configure(default_currency: nil, legacy_json_format: nil, legacy_deprecations: nil, legacy_default_currency: nil)
   old_config = Money.config
   Money.config = Money::Config.new.tap do |config|
     config.default_currency = default_currency if default_currency
-    config.parser = parser if parser
     config.legacy_json_format! if legacy_json_format
     config.legacy_deprecations! if legacy_deprecations
     config.legacy_default_currency! if legacy_default_currency

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shopify-money
 version: !ruby/object:Gem::Version
-  version: 1.0.1.pre
+  version: 1.0.2.pre
 platform: ruby
 authors:
 - Shopify Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-15 00:00:00.000000000 Z
+date: 2022-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -117,7 +117,6 @@ files:
 - config/currency_non_iso.yml
 - dev.yml
 - lib/money.rb
-- lib/money/accounting_money_parser.rb
 - lib/money/allocator.rb
 - lib/money/config.rb
 - lib/money/core_extensions.rb
@@ -127,8 +126,11 @@ files:
 - lib/money/errors.rb
 - lib/money/helpers.rb
 - lib/money/money.rb
-- lib/money/money_parser.rb
 - lib/money/null_currency.rb
+- lib/money/parser/accounting.rb
+- lib/money/parser/fuzzy.rb
+- lib/money/parser/locale_aware.rb
+- lib/money/parser/simple.rb
 - lib/money/rails/job_argument_serializer.rb
 - lib/money/railtie.rb
 - lib/money/version.rb
@@ -141,7 +143,6 @@ files:
 - lib/rubocop/cop/money/zero_money.rb
 - lib/shopify-money.rb
 - money.gemspec
-- spec/accounting_money_parser_spec.rb
 - spec/allocator_spec.rb
 - spec/config_spec.rb
 - spec/core_extensions_spec.rb
@@ -149,9 +150,12 @@ files:
 - spec/currency_spec.rb
 - spec/helpers_spec.rb
 - spec/money_column_spec.rb
-- spec/money_parser_spec.rb
 - spec/money_spec.rb
 - spec/null_currency_spec.rb
+- spec/parser/accounting_spec.rb
+- spec/parser/fuzzy_spec.rb
+- spec/parser/locale_aware_spec.rb
+- spec/parser/simple_spec.rb
 - spec/rails/job_argument_serializer_spec.rb
 - spec/rails_spec_helper.rb
 - spec/rubocop/cop/money/missing_currency_spec.rb
@@ -184,7 +188,6 @@ signing_key:
 specification_version: 4
 summary: Shopify's money gem
 test_files:
-- spec/accounting_money_parser_spec.rb
 - spec/allocator_spec.rb
 - spec/config_spec.rb
 - spec/core_extensions_spec.rb
@@ -192,9 +195,12 @@ test_files:
 - spec/currency_spec.rb
 - spec/helpers_spec.rb
 - spec/money_column_spec.rb
-- spec/money_parser_spec.rb
 - spec/money_spec.rb
 - spec/null_currency_spec.rb
+- spec/parser/accounting_spec.rb
+- spec/parser/fuzzy_spec.rb
+- spec/parser/locale_aware_spec.rb
+- spec/parser/simple_spec.rb
 - spec/rails/job_argument_serializer_spec.rb
 - spec/rails_spec_helper.rb
 - spec/rubocop/cop/money/missing_currency_spec.rb

data/lib/money/accounting_money_parser.rb

@@ -1,8 +0,0 @@
-# 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/money_parser.rb

@@ -1,162 +0,0 @@
-# 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_amount_from_string(input, currency, strict)
-    Money.new(amount, currency)
-  end
-
-  private
-
-  def extract_amount_from_string(input, currency, strict)
-    unless input.is_a?(String)
-      return input
-    end
-
-    if input.strip.empty?
-      return '0'
-    end
-
-    number = input.scan(NUMERIC_REGEX).flatten.first
-    number = number.to_s.strip
-
-    if number.empty?
-      if Money.config.legacy_deprecations && !strict
-        Money.deprecate("invalid money strings will raise in the next major release \"#{input}\"")
-        return '0'
-      else
-        raise MoneyFormatError, "invalid money string: #{input}"
-      end
-    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
-
-    if Money.config.legacy_deprecations && !strict
-      Money.deprecate("invalid money strings will raise in the next major release \"#{input}\"")
-    else
-      raise MoneyFormatError, "invalid money string: #{input}"
-    end
-
-    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