monetize 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77ba1cf94643805ce15012361fda9aaadf3d029483b7c5e557dae4a0cd220c2f
-  data.tar.gz: 8b9d5c77362a24cb9483d2cd02a0f35e5382a289c0eaacc8e44716408ef2a228
+  metadata.gz: 027fe3fe8fd8bf031ee1eeca954ccd33d64b09f7c1d611beef48758640f79ece
+  data.tar.gz: 252c3d7a5f4f922d0385ca6b7b10dffdbcf358a896afc5ba4a621298c966ae39
 SHA512:
-  metadata.gz: 528b67577977e7fb1300cac86a086cc16d9a1941bb93270ed913b83c898b35b3c853583113ece518aeee68f099c0d5ee03bf559a68dffbabc4ed52aa3aaefdce
-  data.tar.gz: d64891590b9c964dc7324f57e45262471922be81248914f8c4430649a9ee17a23e019ae99171762d27b07c1888db51d23f0be580cc0977fd0fa069e3aa7a6563
+  metadata.gz: 29bc1cef3e339731a0aa98f8d5198c81207f063c925650c5f42b8e23830f22dd1c35268b53d6f5296bfb0a15d59bbb08bc1b914967abc0eeda3282f7e0dcd8d4
+  data.tar.gz: af197d3990bc1a5488140912c7e5b39a9140a0bdf0247540ea3c9ef697044f20b8b9eab8691469bacf313a36e5ee3793c6c332e9353bf3cb676f98ba88bc1d8d

data/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+## 2.0.1
+- Fix parsing of ISO codes not in `Monetize::Parser::CURRENCY_SYMBOLS`. `Monetize.parse('20.00 DKK')` returned 20.00 in the default currency instead of 20.00 DKK.
+
 ## 2.0.0
 - **Breaking change**: Remove deprecated `Monetize.extract_cents`.
 - **Breaking change**: Update Money gem dependency to ~> 7.0. See the [Money 7.0 upgrading guide](https://github.com/RubyMoney/money/blob/main/UPGRADING-7.0.md)

data/README.md

@@ -1,8 +1,8 @@
 # Monetize
 
-[![Gem Version](https://badge.fury.io/rb/monetize.svg)](http://badge.fury.io/rb/monetize)
+[![Gem Version](https://badge.fury.io/rb/monetize.svg)](https://rubygems.org/gems/monetize)
 [![Ruby](https://github.com/RubyMoney/monetize/actions/workflows/ruby.yml/badge.svg)](https://github.com/RubyMoney/monetize/actions/workflows/ruby.yml)
-[![License](https://img.shields.io/badge/license-MIT-green.svg)](http://opensource.org/licenses/MIT)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://opensource.org/license/MIT)
 
 A library for converting various objects into `Money` objects.
 
@@ -53,7 +53,7 @@ this is not the case - a European site will show $10.000 because that's the loca
 As a human, if this was a stock ticker we might expect fractional cents.  If it's a retail price we know it's actually an incorrect thousands separator.
 
 
-Monetize can also parse a list of values, returning an array-like object ([Monetize::Collection](lib/collection.rb)):
+Monetize can also parse a list of values, returning an array-like object ([Monetize::Collection](lib/monetize/collection.rb)):
 
 ```ruby
 Monetize.parse_collection("€80/$100") == [Money.new(80_00, "EUR"), Money.new(100_00, "USD")]

data/lib/monetize/parser.rb

@@ -35,6 +35,8 @@ module Monetize
     MULTIPLIER_REGEXP = Regexp.new(format('^(.*?\d)(%s)\b([^\d]*)$', MULTIPLIER_SUFFIXES.keys.join('|')), 'i')
 
     DEFAULT_DECIMAL_MARK = '.'.freeze
+    DEFAULT_MINOR = "00".freeze
+    private_constant :DEFAULT_MINOR
 
     def initialize(input, fallback_currency = Money.default_currency, options = {})
       @input = input.to_s.strip
@@ -43,19 +45,13 @@ module Monetize
     end
 
     def parse
-      currency = Money::Currency.wrap(parse_currency)
-
       multiplier_exp, input = extract_multiplier
 
       num = input.gsub(/(?:^#{currency.symbol}|[^\d.,'-]+)/, '')
 
       negative, num = extract_sign(num)
 
-      num.chop! if num =~ /[\.|,]$/
-
-      major, minor = extract_major_minor(num, currency)
-
-      amount = to_big_decimal([major, minor].join(DEFAULT_DECIMAL_MARK))
+      amount = to_big_decimal(normalize_number(num))
       amount = apply_multiplier(multiplier_exp, amount)
       amount = apply_sign(negative, amount)
 
@@ -64,6 +60,12 @@ module Monetize
 
     private
 
+    def normalize_number(num)
+      clean_num = num.sub(/[\.|,]$/, "")
+
+      extract_major_minor(clean_num).join(DEFAULT_DECIMAL_MARK)
+    end
+
     def to_big_decimal(value)
       BigDecimal(value)
     rescue ::ArgumentError => err
@@ -72,10 +74,14 @@ module Monetize
 
     attr_reader :input, :fallback_currency, :options
 
+    def currency
+      @currency ||= Money::Currency.wrap(parse_currency)
+    end
+
     def parse_currency
       computed_currency = nil
       computed_currency = input[/[A-Z]{2,3}/]
-      computed_currency = nil unless Monetize::Parser::CURRENCY_SYMBOLS.value?(computed_currency)
+      computed_currency = nil unless Money::Currency.find(computed_currency)
       computed_currency ||= compute_currency if assume_from_symbol?
 
       found = computed_currency || fallback_currency || Money.default_currency
@@ -104,64 +110,65 @@ module Monetize
       CURRENCY_SYMBOLS[match.to_s] if match
     end
 
-    def extract_major_minor(num, currency)
+    def remove_separator(num, separator)
+      num.gsub(separator, "")
+    end
+
+    def extract_major_minor(num)
       used_delimiters = num.scan(/[^\d]/).uniq
 
       case used_delimiters.length
       when 0
-        [num, 0]
+        [num, DEFAULT_MINOR]
+      when 1
+        extract_major_minor_with_single_delimiter(num, used_delimiters.first)
       when 2
         thousands_separator, decimal_mark = used_delimiters
-        split_major_minor(num.gsub(thousands_separator, ''), decimal_mark)
-      when 1
-        extract_major_minor_with_single_delimiter(num, currency, used_delimiters.first)
+        num = remove_separator(num, thousands_separator)
+
+        split_major_minor(num, decimal_mark)
       else
         fail ParseError, 'Invalid amount'
       end
     end
 
-    def minor_has_correct_dp_for_currency_subunit?(minor, currency)
-      minor.length == currency.subunit_to_unit.to_s.length - 1
+    def minor_has_correct_decimal_places_for_currency?(minor)
+      minor.length == currency.decimal_places
     end
 
-    def extract_major_minor_with_single_delimiter(num, currency, delimiter)
+    def extract_major_minor_with_single_delimiter(num, delimiter)
       if expect_whole_subunits?
-        _possible_major, possible_minor = split_major_minor(num, delimiter)
-        if minor_has_correct_dp_for_currency_subunit?(possible_minor, currency)
-          split_major_minor(num, delimiter)
-        else
-          extract_major_minor_with_tentative_delimiter(num, delimiter)
-        end
-      else
-        if delimiter == currency.decimal_mark
-          split_major_minor(num, delimiter)
-        elsif Monetize.enforce_currency_delimiters && delimiter == currency.thousands_separator
-          [num.gsub(delimiter, ''), 0]
-        else
-          extract_major_minor_with_tentative_delimiter(num, delimiter)
+        possible_major, possible_minor = split_major_minor(num, delimiter)
+
+        if minor_has_correct_decimal_places_for_currency?(possible_minor)
+          return [possible_major, possible_minor]
         end
+      elsif delimiter == currency.decimal_mark
+        return split_major_minor(num, delimiter)
+      elsif Monetize.enforce_currency_delimiters && delimiter == currency.thousands_separator
+        return [remove_separator(num, delimiter), DEFAULT_MINOR]
       end
+
+      extract_major_minor_with_tentative_delimiter(num, delimiter)
     end
 
     def extract_major_minor_with_tentative_delimiter(num, delimiter)
       if num.scan(delimiter).length > 1
         # Multiple matches; treat as thousands separator
-        [num.gsub(delimiter, ''), '00']
-      else
-        possible_major, possible_minor = split_major_minor(num, delimiter)
+        return [remove_separator(num, delimiter), DEFAULT_MINOR]
+      end
 
-        # Doesn't look like thousands separator
-        is_decimal_mark = possible_minor.length != 3 ||
-                          possible_major.length > 3 ||
-                          possible_major.to_i == 0 ||
-                          (!expect_whole_subunits? && delimiter == '.')
+      possible_major, possible_minor = split_major_minor(num, delimiter)
 
-        if is_decimal_mark
-          [possible_major, possible_minor]
-        else
-          ["#{possible_major}#{possible_minor}", '00']
-        end
-      end
+      # Doesn't look like thousands separator
+      is_decimal_mark = possible_minor.length != 3 ||
+                        possible_major.length > 3 ||
+                        possible_major.to_i == 0 ||
+                        (!expect_whole_subunits? && delimiter == ".")
+
+      return [possible_major, possible_minor] if is_decimal_mark
+
+      ["#{possible_major}#{possible_minor}", DEFAULT_MINOR]
     end
 
     def extract_multiplier
@@ -183,7 +190,9 @@ module Monetize
       splits = num.split(delimiter)
       fail ParseError, 'Invalid amount (multiple delimiters)' if splits.length > 2
 
-      [splits[0], splits[1] || '00']
+      splits[1] ||= DEFAULT_MINOR
+
+      splits
     end
   end
 end

data/lib/monetize/version.rb

@@ -1,3 +1,3 @@
 module Monetize
-  VERSION = '2.0.0'
+  VERSION = '2.0.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: monetize
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Shane Emmons
@@ -69,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.0
+rubygems_version: 4.0.17
 specification_version: 4
 summary: A library for converting various objects into `Money` objects.
 test_files: []