monetize 1.12.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fec107ece48dc97d0e602c4176dc4bee8e9dd7be4172c0a507df4efa941ddc12
-  data.tar.gz: d15c4dd9bfc270948d69e6ffb9483baa9cde97743111d0fb68b3f6f1db8d6c9d
+  metadata.gz: 07adb2e223118b56f5944a6b90b8c51901df761f6b5ecebea8fd8ee8dea3343e
+  data.tar.gz: a61b3fda9d0c22fefb028043db74625c91083787068b31ecf639a05286f92cff
 SHA512:
-  metadata.gz: 2bae292db1e6349b333248bab902017130ee85741e0321e8429216c83ca17c79003f36355eaced3e21fa8e9969df5a29f8fe538fe79ecef7f951b882f8cafe10
-  data.tar.gz: f5cc392537c1d8487c3117c680f9e49d0d38ec0db67fcda73594a4a7ce0dfddd8224338eaf5e97da880a86a5e31b4181fb287b9dd8b079f47ec104fd0edbfd49
+  metadata.gz: 6d4774d81cc075b5c68849cd07c69f2311683f16adfbb00075d85e7530f4a1cb052a82a1b772b812b9b029fbe47b8b4400aabb0588ce27a35ef6e9d6340122cb
+  data.tar.gz: c5e7266b20bf556a2619974f8d97a690e6817eec1a56e9cd0497c6569bc36c681fc417c19900fa95c1ae7fcf7c10569867bec072d4a25e8c99d6f49c0b9901e1

data/.github/workflows/ruby.yml

@@ -19,10 +19,10 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.6', '2.7', '3.0']
+        ruby-version: ['2.6', '2.7', '3.0', '3.1', '3.2']
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Set up Ruby
     # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
     # change this to (see https://github.com/ruby/setup-ruby#versioning):

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Shane Emmons
+Copyright (c) 2024 Shane Emmons
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -10,13 +10,9 @@ A library for converting various objects into `Money` objects.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Run:
 
-    gem 'monetize'
-
-And then execute:
-
-    $ bundle
+    bundle add monetize
 
 Or install it yourself as:
 
@@ -53,6 +49,22 @@ Monetize.parse("£100") == Money.new(100_00, "GBP")
 "€100".to_money == Money.new(100_00, "EUR")
 ```
 
+Parsing can be improved where the input is not expected to contain fractonal subunits.
+To do this, set `Monetize.expect_whole_subunits = true`
+
+```ruby
+Monetize.parse('EUR 10,000') == Money.new(100_00, "EUR")
+
+Monetize.expect_whole_subunits = true
+Monetize.parse('EUR 10,000') == Money.new(10_000_00, "EUR")
+```
+
+Why does this work?  If we expect fractional subunits then the parser will treat a single
+delimiter as a decimal marker if it matches the currency's decimal marker.  But often 
+this is not the case - a European site will show $10.000 because that's the local format.
+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)):
 
 ```ruby

data/lib/monetize/parser.rb

@@ -8,6 +8,8 @@ module Monetize
       '£'  => 'GBP',
       '₤'  => 'GBP',
       'R$' => 'BRL',
+      'RM' => 'MYR',
+      'Rp' => 'IDR',
       'R'  => 'ZAR',
       '¥'  => 'JPY',
       'C$' => 'CAD',
@@ -23,6 +25,10 @@ module Monetize
       'zł' => 'PLN',
       '₸'  => 'KZT',
       "₩"  => 'KRW',
+      'S$' => 'SGD',
+      'HK$'=> 'HKD',
+      'NT$'=> 'TWD',
+      '₱'  => 'PHP',
     }
 
     MULTIPLIER_SUFFIXES = { 'K' => 3, 'M' => 6, 'B' => 9, 'T' => 12 }
@@ -70,6 +76,7 @@ module Monetize
     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 ||= compute_currency if assume_from_symbol?
 
 
@@ -80,6 +87,10 @@ module Monetize
       options.fetch(:assume_from_symbol) { Monetize.assume_from_symbol }
     end
 
+    def expect_whole_subunits?
+      options.fetch(:expect_whole_subunits) { Monetize.expect_whole_subunits }
+    end
+
     def apply_multiplier(multiplier_exp, amount)
       amount * 10**multiplier_exp
     end
@@ -109,13 +120,26 @@ module Monetize
       end
     end
 
+    def minor_has_correct_dp_for_currency_subunit?(minor, currency)
+      minor.length == currency.subunit_to_unit.to_s.length - 1
+    end
+
     def extract_major_minor_with_single_delimiter(num, currency, delimiter)
-      if delimiter == currency.decimal_mark
-        split_major_minor(num, delimiter)
-      elsif Monetize.enforce_currency_delimiters && delimiter == currency.thousands_separator
-        [num.gsub(delimiter, ''), 0]
+      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
-        extract_major_minor_with_tentative_delimiter(num, delimiter)
+        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)
+        end
       end
     end
 
@@ -130,7 +154,7 @@ module Monetize
         is_decimal_mark = possible_minor.length != 3 ||
                           possible_major.length > 3 ||
                           possible_major.to_i == 0 ||
-                          delimiter == '.'
+                          (!expect_whole_subunits? && delimiter == '.')
 
         if is_decimal_mark
           [possible_major, possible_minor]

data/lib/monetize/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Monetize
-  VERSION = '1.12.0'
+  VERSION = '1.13.0'
 end

data/lib/monetize.rb

@@ -20,6 +20,12 @@ module Monetize
     # to true to enforce the delimiters set in the currency all the time.
     attr_accessor :enforce_currency_delimiters
 
+
+    # Where this set to true, the behavior for parsing thousands separators is changed to 
+    # expect that eg. €10.000 is EUR 10 000 and not EUR 10.000 - it's incredibly rare when parsing 
+    # human text that we're dealing with fractions of cents.
+    attr_accessor :expect_whole_subunits
+
     def parse(input, currency = Money.default_currency, options = {})
       parse! input, currency, options
     rescue Error

data/spec/monetize_spec.rb

@@ -172,8 +172,28 @@ describe Monetize do
           expect('20.00 GBP'.to_money).to eq Money.new(20_00, 'GBP')
         end
 
-        it 'raises an error if currency code is invalid' do
-          expect { '20.00 OMG'.to_money }.to raise_error Monetize::ParseError
+        context 'with default currency' do
+          before do
+            Money.default_currency = Money::Currency.new('USD')
+          end
+
+          it 'parses currency given using default currency' do
+            expect('20.00 OMG'.to_money).to eq Money.new(20_00, 'USD')
+          end
+        end
+
+        context 'without default currency' do
+          before do
+            Money.default_currency = nil
+          end
+
+          after do
+            Money.default_currency = Money::Currency.new('USD')
+          end
+
+          it 'raises an error if currency code is invalid' do
+            expect { '20.00 OMG'.to_money }.to raise_error
+          end
         end
       end
     end
@@ -344,6 +364,32 @@ describe Monetize do
         expect('€0.5324'.to_money('EU4')).to eq Money.new(5324, 'EU4')
       end
     end
+
+    describe "expecting whole subunits" do
+      before(:all) do
+        Monetize.expect_whole_subunits = true
+        Monetize.assume_from_symbol = true
+      end
+
+      after(:all) do
+        Monetize.expect_whole_subunits = false
+        Monetize.assume_from_symbol = false
+      end
+
+      it "handles euros" do
+        expect(Monetize.parse('€10,000')).to eq Money.new(10_000_00, 'EUR')
+        expect(Monetize.parse('€10,00')).to eq Money.new(10_00, 'EUR')
+        expect(Monetize.parse('€10.00')).to eq Money.new(10_00, 'EUR')
+        expect(Monetize.parse('EUR 10,000.00')).to eq Money.new(10_000_00, 'EUR')
+      end
+
+      it "handles GBP" do
+        expect(Monetize.parse('£10,000')).to eq Money.new(10_000_00, 'GBP')
+        expect(Monetize.parse('£10.000')).to eq Money.new(10_000_00, 'GBP')
+        expect(Monetize.parse('£10,00')).to eq Money.new(10_00, 'GBP')
+        expect(Monetize.parse('£10.00')).to eq Money.new(10_00, 'GBP')
+      end
+    end
   end
 
   describe '.parse!' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: monetize
 version: !ruby/object:Gem::Version
-  version: 1.12.0
+  version: 1.13.0
 platform: ruby
 authors:
 - Shane Emmons
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-07 00:00:00.000000000 Z
+date: 2024-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: money
@@ -121,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: A library for converting various objects into `Money` objects.