monetize 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24efb7c5a6f63618a6cd3988dfbb28513b89ca7d
-  data.tar.gz: 76318b62fc23e62f3ab4ad605b4e5cc5d0679fd0
+  metadata.gz: 2a6b1289754e6b83edb823b89e503d483cef3702
+  data.tar.gz: 7a8101c6719d5fb91f79ec85be449520ada30225
 SHA512:
-  metadata.gz: 962f9763ab9f0ba52a3c3b1903be90c08a1d2111e382ece0db00f3fe08a01e8cb36761fb0dca828139e88fb1c01f40c8eda1be21d09ef91d876674095534f0f9
-  data.tar.gz: a409f99aede0565c349075817200296ab79e2765f78f63baa0ad98a39dbd0160df6efe2ec846aa1120d16a7c340341ff7145ca8dc04c8e26956cb7532a2c7bb7
+  metadata.gz: bd40b6b99cc913a0e8f65bad08f7d1ab0ad06a0117f5b1038e4fb43a559b04a0812bdd28e0826005f979f565ba9e6a404fa73e617457c7d5ea0c0d43b8480f93
+  data.tar.gz: e356b03bf3a1c5ad46ab0725e1c99e1bd52723e451f28e1c68f3b6dbfe3529d21a5750046a595f0c7c2b7f6de10c71f1abfa02d10caa3ef71d056ec04a4e0085

data/.travis.yml

@@ -3,10 +3,10 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.9
-  - 2.2.5
-  - 2.3.1
-  - 2.4.0
+  - 2.1.10
+  - 2.2.7
+  - 2.3.4
+  - 2.4.1
   - jruby-9.0.5.0
 script: bundle exec rspec spec
 notifications:

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Changelog
 
+## 1.8.0
+- Money version updated to 6.11.2
+- Fix rounding problem in `.from_bigdecimal`
+
 ## 1.7.0
+- Add South Korean Won currency
 - Money version updated to 6.9
 - Coveralls version update to 0.8.20
 - Add South Korean Won currency
@@ -11,47 +16,63 @@
 - Money version updated to 6.8
 
 ## 1.5.0
+- Fix issue where parsing a Money object resulted in a Money object with its currency set to `Money.default_currency`,
+  rather than the currency that it was sent in as.
 - Add extra currencies:
   - Azerbaijani manat
   - Chinese yuan
   - Czech koruna
   - Hungarian forint
-  - Indinan rupee
+  - Indian rupee
   - Russian ruble
   - Turkish Lira
   - Ukrainian Hryvnia
   - Swiss Frank
   - Polish Zloty
   - Kazakhstani Tenge
-- Parsing a Money object returns it unchanged
-- Fix issue with loosing precision on BigDecimal input
+- Fix issue with losing precision on BigDecimal input
 - Add Swedish krona
-- Exclud ambiguous kr symbol from parsing
+- Exclude ambiguous kr symbol from parsing
 - Fix JPY parsing
-- Sublcass all errors to Monetize::Error
+- Subclass all errors to Monetize::Error
 - Fix ruby 1.9.3 compatibility
 - Suppress errors when using parse. Use `parse!` instead
 - Strip currency symbol prefix when parsing input
 
 ## 1.4.0
+- Fixed support for <code>Money.infinite_precision = true</code> in .to_money
+- Add Rubocop config to project
+- Reformat code to adapt to Rubocop guidelines
+- Add config setting to always enforce currency delimiters
+- Add rake console task
 - Required Forwardable on Collection to resolve NameError [\#44](https://github.com/RubyMoney/monetize/issues/44)
 - Add capability to parse currency amounts given with suffixes (K, M, B, and T)
 
+## 1.3.1
+- Updated Money version dependency to 6.6
+
 ## 1.3.0
-- Add NilClass extension
-- Added correct parsing of Brazilian Real $R symbol
-- Add testing task for  Brazilian Real parsing
 - Add Lira Sign (₤) as a symbol for GBP
 
-## 1.3.1
-- Updated Money version dependency to 6.6
+## 1.2.0
+- Add support for parsing Yen symbol
+- Add `Monetize.parse_collection` and `Monetize::Collection` class for parsing multiple values
+- Add parsing of C$ for Canadian Dollar
+- Add NilClass extension
+- Add Hash extension
 
-## master
-- Fixed support for <code>Money.infinite_precision = true</code> in .to_money
-- Add Rubocop config to project
-- Reformat code to adapt to Rubocop guidelines
-- Add config setting to always enforce currency delimiters
-- Add rake console task
-- Fix issue where parsing a Money object resulted in a Money object with its currency set to `Money.default_currency`,
-  rather than the currency that it was sent in as.
-- Add South Korean Won currency
+## 1.1.0
+- Add :assume_from_symbol option to #parse
+- Enable #parse to detect currency with signed amounts
+- Updated Money version dependency to 6.5.0
+
+## 1.0.0
+- Updated Money version dependency to 6.4.0
+
+## 0.4.1
+- Updated Money version dependency to 6.2.1
+
+## 0.4.0
+- Added correct parsing of Brazilian Real $R symbol
+- Add testing task for  Brazilian Real parsing
+- Updated Money version dependency to 6.2.0

data/lib/monetize.rb

@@ -4,41 +4,10 @@ require 'money'
 require 'monetize/core_extensions'
 require 'monetize/errors'
 require 'monetize/version'
-require 'collection'
+require 'monetize/parser'
+require 'monetize/collection'
 
 module Monetize
-  CURRENCY_SYMBOLS = {
-    '$'    => 'USD',
-    '€'    => 'EUR',
-    '£'    => 'GBP',
-    '₤'    => 'GBP',
-    'R$'   => 'BRL',
-    'R'    => 'ZAR',
-    '¥'    => 'JPY',
-    'C$'   => 'CAD',
-    '₼'    => 'AZN',
-    '元'   => 'CNY',
-    'Kč'   => 'CZK',
-    'Ft'   => 'HUF',
-    '₹'    => 'INR',
-    '₽'    => 'RUB',
-    '₺'    => 'TRY',
-    '₴'    => 'UAH',
-    'Fr'   => 'CHF',
-    'zł'   => 'PLN',
-    '₸'    => 'KZT',
-    "₩"    => 'KRW',
-  }
-
-  MULTIPLIER_SUFFIXES = {
-    'K'    => 3,
-    'M'    => 6,
-    'B'    => 9,
-    'T'    => 12
-  }
-  MULTIPLIER_SUFFIXES.default = 0
-  MULTIPLIER_REGEXP = Regexp.new(format('^(.*?\d)(%s)\b([^\d]*)$', MULTIPLIER_SUFFIXES.keys.join('|')), 'i')
-
   # Class methods
   class << self
     # @attr_accessor [true, false] assume_from_symbol Use this to enable the
@@ -62,19 +31,10 @@ module Monetize
     return input if input.is_a?(Money)
     return from_numeric(input, currency) if input.is_a?(Numeric)
 
-    input = input.to_s.strip
-
-    computed_currency = if options.fetch(:assume_from_symbol) { assume_from_symbol }
-                          compute_currency(input)
-                        else
-                          input[/[A-Z]{2,3}/]
-                        end
-
-    currency = computed_currency || currency || Money.default_currency
-    currency = Money::Currency.wrap(currency)
+    parser = Monetize::Parser.new(input, currency, options)
+    currency_from_input = Money::Currency.wrap(parser.parse_currency)
 
-    fractional = extract_cents(input, currency)
-    Money.new(fractional, currency)
+    Money.new(parser.parse_cents(currency_from_input), currency_from_input)
   rescue Money::Currency::UnknownCurrency => e
     fail ParseError, e.message
   end
@@ -101,10 +61,7 @@ module Monetize
   end
 
   def self.from_bigdecimal(value, currency = Money.default_currency)
-    currency = Money::Currency.wrap(currency)
-    value *= currency.subunit_to_unit
-    value = value.round unless Money.infinite_precision
-    Money.new(value, currency)
+    Money.from_amount(value, currency)
   end
 
   def self.from_numeric(value, currency = Money.default_currency)
@@ -120,137 +77,6 @@ module Monetize
   end
 
   def self.extract_cents(input, currency = Money.default_currency)
-    multiplier_exp, input = extract_multiplier(input)
-
-    num = input.gsub(/(?:^#{currency.symbol}|[^\d.,'-]+)/, '')
-
-    negative, num = extract_sign(num)
-
-    num.chop! if num.match(/[\.|,]$/)
-
-    major, minor = extract_major_minor(num, currency)
-
-    major, minor = apply_multiplier(multiplier_exp, major.to_i, minor)
-
-    cents = major.to_i * currency.subunit_to_unit
-
-    cents += set_minor_precision(minor, currency)
-
-    apply_sign(negative, cents)
-  end
-
-  private
-
-  def self.apply_multiplier(multiplier_exp, major, minor)
-    major *= 10**multiplier_exp
-    minor = minor.to_s + ('0' * multiplier_exp)
-    shift = minor[0...multiplier_exp].to_i
-    major += shift
-    minor = (minor[multiplier_exp..-1] || '')
-    [major, minor]
-  end
-
-  def self.apply_sign(negative, cents)
-    negative ? cents * -1 : cents
-  end
-
-  def self.contains_currency_symbol?(amount)
-    amount =~ currency_symbol_regex
-  end
-
-  def self.compute_currency(amount)
-    if contains_currency_symbol?(amount)
-      matches = amount.match(currency_symbol_regex)
-      CURRENCY_SYMBOLS[matches[:symbol]]
-    else
-      amount[/[A-Z]{2,3}/]
-    end
-  end
-
-  def self.extract_major_minor(num, currency)
-    used_delimiters = num.scan(/[^\d]/).uniq
-
-    case used_delimiters.length
-    when 0
-      [num, 0]
-    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)
-    else
-      fail ParseError, 'Invalid amount'
-    end
-  end
-
-  def self.extract_major_minor_with_single_delimiter(num, currency, delimiter)
-    if delimiter == currency.decimal_mark
-      split_major_minor(num, delimiter)
-    elsif enforce_currency_delimiters and delimiter == currency.thousands_separator
-      [num.gsub(delimiter, ''), 0]
-    else
-      extract_major_minor_with_tentative_delimiter(num, delimiter)
-    end
-  end
-
-  def self.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)
-
-      if possible_minor.length != 3 or possible_major.length > 3 or delimiter == '.'
-        # Doesn't look like thousands separator
-        [possible_major, possible_minor]
-      else
-        ["#{possible_major}#{possible_minor}", '00']
-      end
-    end
-  end
-
-  def self.extract_multiplier(input)
-    if (matches = MULTIPLIER_REGEXP.match(input))
-      multiplier_suffix = matches[2].upcase
-      [MULTIPLIER_SUFFIXES[multiplier_suffix], "#{$1}#{$3}"]
-    else
-      [0, input]
-    end
-  end
-
-  def self.extract_sign(input)
-    result = (input =~ /^-+(.*)$/ or input =~ /^(.*)-+$/) ? [true, $1] : [false, input]
-    fail ParseError, 'Invalid amount (hyphen)' if result[1].include?('-')
-    result
-  end
-
-  def self.regex_safe_symbols
-    CURRENCY_SYMBOLS.keys.map { |key| Regexp.escape(key) }.join('|')
-  end
-
-  def self.set_minor_precision(minor, currency)
-    if Money.infinite_precision
-      (BigDecimal.new(minor) / (10**minor.size)) * currency.subunit_to_unit
-    elsif minor.size < currency.decimal_places
-      (minor + ('0' * currency.decimal_places))[0, currency.decimal_places].to_i
-    elsif minor.size > currency.decimal_places
-      if minor[currency.decimal_places, 1].to_i >= 5
-        minor[0, currency.decimal_places].to_i + 1
-      else
-        minor[0, currency.decimal_places].to_i
-      end
-    else
-      minor.to_i
-    end
-  end
-
-  def self.split_major_minor(num, delimiter)
-    major, minor = num.split(delimiter)
-    minor = '00' unless minor
-    [major, minor]
-  end
-
-  def self.currency_symbol_regex
-    /\A[\+|\-]?(?<symbol>#{regex_safe_symbols})/
+    Monetize::Parser.new(input).parse_cents(currency)
   end
 end

data/lib/{collection.rb → monetize/collection.rb}

@@ -1,6 +1,5 @@
 # encoding: utf-8
 
-require 'monetize'
 require 'forwardable'
 
 module Monetize

data/lib/monetize/parser.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+
+module Monetize
+  class Parser
+    CURRENCY_SYMBOLS = {
+      '$'  => 'USD',
+      '€'  => 'EUR',
+      '£'  => 'GBP',
+      '₤'  => 'GBP',
+      'R$' => 'BRL',
+      'R'  => 'ZAR',
+      '¥'  => 'JPY',
+      'C$' => 'CAD',
+      '₼'  => 'AZN',
+      '元' => 'CNY',
+      'Kč' => 'CZK',
+      'Ft' => 'HUF',
+      '₹'  => 'INR',
+      '₽'  => 'RUB',
+      '₺'  => 'TRY',
+      '₴'  => 'UAH',
+      'Fr' => 'CHF',
+      'zł' => 'PLN',
+      '₸'  => 'KZT',
+      "₩"  => 'KRW',
+    }
+
+    MULTIPLIER_SUFFIXES = { 'K' => 3, 'M' => 6, 'B' => 9, 'T' => 12 }
+    MULTIPLIER_SUFFIXES.default = 0
+    MULTIPLIER_REGEXP = Regexp.new(format('^(.*?\d)(%s)\b([^\d]*)$', MULTIPLIER_SUFFIXES.keys.join('|')), 'i')
+
+    def initialize(input, fallback_currency = Money.default_currency, options = {})
+      @input = input.to_s.strip
+      @fallback_currency = fallback_currency
+      @options = options
+    end
+
+    def parse_cents(currency)
+      multiplier_exp, input = extract_multiplier
+
+      num = input.gsub(/(?:^#{currency.symbol}|[^\d.,'-]+)/, '')
+
+      negative, num = extract_sign(num)
+
+      num.chop! if num.match(/[\.|,]$/)
+
+      major, minor = extract_major_minor(num, currency)
+
+      major, minor = apply_multiplier(multiplier_exp, major.to_i, minor)
+
+      cents = major.to_i * currency.subunit_to_unit
+
+      cents += set_minor_precision(minor, currency)
+
+      apply_sign(negative, cents)
+    end
+
+    def parse_currency
+      computed_currency = if options.fetch(:assume_from_symbol) { Monetize.assume_from_symbol }
+                            compute_currency
+                          else
+                            input[/[A-Z]{2,3}/]
+                          end
+
+      computed_currency || fallback_currency || Money.default_currency
+    end
+
+    private
+
+    attr_reader :input, :fallback_currency, :options
+
+    def apply_multiplier(multiplier_exp, major, minor)
+      major *= 10**multiplier_exp
+      minor = minor.to_s + ('0' * multiplier_exp)
+      shift = minor[0...multiplier_exp].to_i
+      major += shift
+      minor = (minor[multiplier_exp..-1] || '')
+      [major, minor]
+    end
+
+    def apply_sign(negative, cents)
+      negative ? cents * -1 : cents
+    end
+
+    def contains_currency_symbol?
+      input =~ currency_symbol_regex
+    end
+
+    def compute_currency
+      if contains_currency_symbol?
+        matches = input.match(currency_symbol_regex)
+        CURRENCY_SYMBOLS[matches[:symbol]]
+      else
+        input[/[A-Z]{2,3}/]
+      end
+    end
+
+    def extract_major_minor(num, currency)
+      used_delimiters = num.scan(/[^\d]/).uniq
+
+      case used_delimiters.length
+      when 0
+        [num, 0]
+      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)
+      else
+        fail ParseError, 'Invalid amount'
+      end
+    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 and delimiter == currency.thousands_separator
+        [num.gsub(delimiter, ''), 0]
+      else
+        extract_major_minor_with_tentative_delimiter(num, delimiter)
+      end
+    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)
+
+        if possible_minor.length != 3 or possible_major.length > 3 or delimiter == '.'
+          # Doesn't look like thousands separator
+          [possible_major, possible_minor]
+        else
+          ["#{possible_major}#{possible_minor}", '00']
+        end
+      end
+    end
+
+    def extract_multiplier
+      if (matches = MULTIPLIER_REGEXP.match(input))
+        multiplier_suffix = matches[2].upcase
+        [MULTIPLIER_SUFFIXES[multiplier_suffix], "#{$1}#{$3}"]
+      else
+        [0, input]
+      end
+    end
+
+    def extract_sign(input)
+      result = (input =~ /^-+(.*)$/ or input =~ /^(.*)-+$/) ? [true, $1] : [false, input]
+      fail ParseError, 'Invalid amount (hyphen)' if result[1].include?('-')
+      result
+    end
+
+    def regex_safe_symbols
+      CURRENCY_SYMBOLS.keys.map { |key| Regexp.escape(key) }.join('|')
+    end
+
+    def set_minor_precision(minor, currency)
+      if Money.infinite_precision
+        (BigDecimal.new(minor) / (10**minor.size)) * currency.subunit_to_unit
+      elsif minor.size < currency.decimal_places
+        (minor + ('0' * currency.decimal_places))[0, currency.decimal_places].to_i
+      elsif minor.size > currency.decimal_places
+        if minor[currency.decimal_places, 1].to_i >= 5
+          minor[0, currency.decimal_places].to_i + 1
+        else
+          minor[0, currency.decimal_places].to_i
+        end
+      else
+        minor.to_i
+      end
+    end
+
+    def split_major_minor(num, delimiter)
+      major, minor = num.split(delimiter)
+      minor = '00' unless minor
+      [major, minor]
+    end
+
+    def currency_symbol_regex
+      /\A[\+|\-]?(?<symbol>#{regex_safe_symbols})/
+    end
+  end
+end

data/lib/monetize/version.rb

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

data/monetize.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'money', '~> 6.9'
+  spec.add_dependency 'money', '~> 6.11.2'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'

data/spec/monetize_spec.rb

@@ -56,7 +56,7 @@ describe Monetize do
           Monetize.assume_from_symbol = false
         end
 
-        Monetize::CURRENCY_SYMBOLS.each_pair do |symbol, iso_code|
+        Monetize::Parser::CURRENCY_SYMBOLS.each_pair do |symbol, iso_code|
           context iso_code do
             let(:currency) { Money::Currency.find(iso_code) }
             let(:amount) { 5_95 }
@@ -430,6 +430,12 @@ describe Monetize do
       expect(Monetize.from_bigdecimal(BigDecimal.new('1'), 'JPY')).to eq Money.new(1, 'JPY')
     end
 
+    it 'respects rounding mode when rounding amount to the nearest cent' do
+      amount = BigDecimal.new('1.005')
+
+      expect(Monetize.from_bigdecimal(amount, 'USD')).to eq Money.from_amount(amount, 'USD')
+    end
+
     it 'accepts a currency options' do
       m = Monetize.from_bigdecimal(BigDecimal.new('1'))
       expect(m.currency).to eq Money.default_currency

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monetize
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Shane Emmons
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-24 00:00:00.000000000 Z
+date: 2018-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: money
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.9'
+        version: 6.11.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.9'
+        version: 6.11.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -83,8 +83,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- lib/collection.rb
 - lib/monetize.rb
+- lib/monetize/collection.rb
 - lib/monetize/core_extensions.rb
 - lib/monetize/core_extensions/hash.rb
 - lib/monetize/core_extensions/nil_class.rb
@@ -92,6 +92,7 @@ files:
 - lib/monetize/core_extensions/string.rb
 - lib/monetize/core_extensions/symbol.rb
 - lib/monetize/errors.rb
+- lib/monetize/parser.rb
 - lib/monetize/version.rb
 - monetize.gemspec
 - spec/core_extensions_spec.rb