monetize 1.4.0 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7f96f9f99c2fc04ab625a2977f370eff77d33696
-  data.tar.gz: 75817ce67a91ae35019f6ef3a3b290b937b64749
+  metadata.gz: 7c921047a6f291ae61ceb19db130de7b0288d8e2
+  data.tar.gz: f48eb20c8582b1453ef6114df30793f9367d934e
 SHA512:
-  metadata.gz: 657c4f4be74370f9a8b2b1f4fcb91e60a013e9d2e01f39f95258a48c47710c5418767770af32ca61c19d52b0a94ccaa875fd3a4b7d8f21023ff7f4b036700c90
-  data.tar.gz: 4cb6265937f209b0797cc4c0d2e78b4fa27a9f27f9f045cfac8d00812dcb2ccb86072672897b7fb36f7337dab52cbb62c3e58739b9cdcdc9ec32b73393bedd9a
+  metadata.gz: 9b4a49126c30cfd92968d6fed6cd43a806e5cda807f8dfd0c8956d434e0e3a3331191d9e228e5648c4d11157f01d3c3fcdb72f72f21e52f96002ab803b70265a
+  data.tar.gz: 571ec0ec170014d408f4ba0208a1b40f04cdf3436b2939e7d43b922cfe2ce3e981fb5a51a6dc79eab8d07ccad4ecfbc270548e15b4293428df87dbc0c912d277

data/.travis.yml

@@ -1,8 +1,17 @@
+sudo: false
 language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.2
+  - 2.1.10
+  - 2.2.10
+  - 2.3.7
+  - 2.4.4
+  - 2.5.1
+  - 2.6.0
+  - jruby-9.0.5.0
+before_install:
+  - gem install bundler --version '~> 1.17'
 script: bundle exec rspec spec
 notifications:
   recipients:

data/CHANGELOG.md

@@ -1,21 +1,86 @@
 # Changelog
 
-## 1.4.0
-- 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.9.1
+- Ruby 2.6 support
 
-## 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.9.0
+- Relax Money gem dependency to ~> 6.12
+- Refactor `Monetize::Parser`
+- Ruby 2.5 support
 
-## 1.3.1
-- Updated Money version dependency to 6.6
+## 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
+- Improve conversion to Money from Hash
+
+## 1.6.0
+- Ruby 2.4.0 support
+- Money version updated to 6.8
 
-## master
+## 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
+  - Indian rupee
+  - Russian ruble
+  - Turkish Lira
+  - Ukrainian Hryvnia
+  - Swiss Frank
+  - Polish Zloty
+  - Kazakhstani Tenge
+- Fix issue with losing precision on BigDecimal input
+- Add Swedish krona
+- Exclude ambiguous kr symbol from parsing
+- Fix JPY parsing
+- 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 Lira Sign (₤) as a symbol for GBP
+
+## 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
+
+## 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/Gemfile

@@ -1,5 +1,15 @@
 source 'https://rubygems.org'
 
-gem 'coveralls', require: false
+gem 'coveralls', '>= 0.8.20', require: false
+
+# JSON and I18n gem no longer supports ruby < 2.0.0
+if defined?(JRUBY_VERSION)
+  gem 'json'
+elsif RUBY_VERSION =~ /^1/
+  gem 'json', '~> 1.8.3'
+  gem 'tins', '~> 1.6.0'
+  gem 'term-ansicolor', '~> 1.3.0'
+  gem 'i18n', '~> 0.9'
+end
 
 gemspec

data/README.md

@@ -1,11 +1,11 @@
 # Monetize
 
-[![Gem Version](https://badge.fury.io/rb/monetize.png)](http://badge.fury.io/rb/monetize)
-[![Build Status](https://travis-ci.org/RubyMoney/monetize.png?branch=master)](https://travis-ci.org/RubyMoney/monetize)
-[![Code Climate](https://codeclimate.com/github/RubyMoney/monetize.png)](https://codeclimate.com/github/RubyMoney/monetize)
-[![Coverage Status](https://coveralls.io/repos/RubyMoney/monetize/badge.png)](https://coveralls.io/r/RubyMoney/monetize)
-[![Dependency Status](https://gemnasium.com/RubyMoney/monetize.png)](https://gemnasium.com/RubyMoney/monetize)
-[![License](http://img.shields.io/license/MIT.png?color=green)](http://opensource.org/licenses/MIT)
+[![Gem Version](https://badge.fury.io/rb/monetize.svg)](http://badge.fury.io/rb/monetize)
+[![Build Status](https://travis-ci.org/RubyMoney/monetize.svg?branch=master)](https://travis-ci.org/RubyMoney/monetize)
+[![Code Climate](https://codeclimate.com/github/RubyMoney/monetize.svg)](https://codeclimate.com/github/RubyMoney/monetize)
+[![Coverage Status](https://coveralls.io/repos/RubyMoney/monetize/badge.svg)](https://coveralls.io/r/RubyMoney/monetize)
+[![Dependency Status](https://gemnasium.com/RubyMoney/monetize.svg)](https://gemnasium.com/RubyMoney/monetize)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](http://opensource.org/licenses/MIT)
 
 A library for converting various objects into `Money` objects.
 
@@ -33,6 +33,16 @@ Monetize.parse("GBP 100") == Money.new(100_00, "GBP")
 "100".to_money == Money.new(100_00, "USD")
 ```
 
+`parse` will return `nil` if it is unable to parse the input. Use `parse!` instead if you want a `Monetize::Error` (or one of the subclasses) to be raised instead:
+
+```ruby
+>> Monetize.parse('OMG 100')
+=> nil
+
+>> Monetize.parse!('OMG 100')
+Monetize::ParseError: Unknown currency 'omg'
+```
+
 Optionally, enable the ability to assume the currency from a passed symbol. Otherwise, currency symbols will be ignored, and USD used as the default currency:
 
 ```ruby

data/lib/monetize.rb

@@ -2,30 +2,12 @@
 
 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'
-  }
-
-  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
@@ -37,195 +19,54 @@ module Monetize
     # though, it will try to determine the correct separator by itself. Set this
     # to true to enforce the delimiters set in the currency all the time.
     attr_accessor :enforce_currency_delimiters
-  end
-
-  def self.parse(input, currency = Money.default_currency, options = {})
-    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)
-
-    fractional = extract_cents(input, currency)
-    Money.new(fractional, currency)
-  end
-
-  def self.parse_collection(input, currency = Money.default_currency, options = {})
-    Collection.parse(input, currency, options)
-  end
-
-  def self.from_string(value, currency = Money.default_currency)
-    value = BigDecimal.new(value.to_s)
-    from_bigdecimal(value, currency)
-  end
-
-  def self.from_fixnum(value, currency = Money.default_currency)
-    currency = Money::Currency.wrap(currency)
-    value *= currency.subunit_to_unit
-    Money.new(value, currency)
-  end
-
-  def self.from_float(value, currency = Money.default_currency)
-    value = BigDecimal.new(value.to_s)
-    from_bigdecimal(value, currency)
-  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)
-  end
-
-  def self.from_numeric(value, currency = Money.default_currency)
-    case value
-    when Fixnum
-      from_fixnum(value, currency)
-    when Numeric
-      value = BigDecimal.new(value.to_s)
-      from_bigdecimal(value, currency)
-    else
-      fail ArgumentError, "'value' should be a type of Numeric"
+    def parse(input, currency = Money.default_currency, options = {})
+      parse! input, currency, options
+    rescue Error
+      nil
     end
-  end
-
-  def self.extract_cents(input, currency = Money.default_currency)
-    multiplier_exp, input = extract_multiplier(input)
-
-    num = input.gsub(/[^\d.,'-]/, '')
-
-    negative, num = extract_sign(num)
-
-    num.chop! if num.match(/[\.|,]$/)
-
-    major, minor = extract_major_minor(num, currency)
-
-    cents = major.to_i * currency.subunit_to_unit
 
-    cents, minor = apply_multiplier(multiplier_exp, cents, minor)
+    def parse!(input, currency = Money.default_currency, options = {})
+      return input if input.is_a?(Money)
+      return from_numeric(input, currency) if input.is_a?(Numeric)
 
-    cents += set_minor_precision(minor, currency)
+      parser = Monetize::Parser.new(input, currency, options)
+      currency_from_input = Money::Currency.wrap(parser.parse_currency)
 
-    apply_sign(negative, cents)
-  end
-
-  private
-
-  def self.apply_multiplier(multiplier_exp, cents, minor)
-    cents *= (10**multiplier_exp)
-    minor = minor.to_s + ('0' * multiplier_exp)
-    shift = minor[0...multiplier_exp].to_i * 100
-    cents += shift
-    minor = (minor[multiplier_exp..-1] || '')
-    [cents, 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}/]
+      Money.new(parser.parse_cents(currency_from_input), currency_from_input)
+    rescue Money::Currency::UnknownCurrency => e
+      fail ParseError, e.message
     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 ArgumentError, 'Invalid currency amount'
+    def parse_collection(input, currency = Money.default_currency, options = {})
+      Collection.parse(input, currency, options)
     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)
+    def from_string(value, currency = Money.default_currency)
+      value = BigDecimal(value.to_s)
+      Money.from_amount(value, currency)
     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
+    def from_fixnum(value, currency = Money.default_currency)
+      Money.from_amount(value, currency)
     end
-  end
+    alias_method :from_integer, :from_fixnum
 
-  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]
+    def from_float(value, currency = Money.default_currency)
+      Money.from_amount(value, currency)
     end
-  end
-
-  def self.extract_sign(input)
-    result = (input =~ /^-+(.*)$/ or input =~ /^(.*)-+$/) ? [true, $1] : [false, input]
-    fail ArgumentError, 'Invalid currency 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
+    def from_bigdecimal(value, currency = Money.default_currency)
+      Money.from_amount(value, currency)
     end
-  end
 
-  def self.split_major_minor(num, delimiter)
-    major, minor = num.split(delimiter)
-    minor = '00' unless minor
-    [major, minor]
-  end
+    def from_numeric(value, currency = Money.default_currency)
+      fail ArgumentError, "'value' should be a type of Numeric" unless value.is_a?(Numeric)
+      Money.from_amount(value, currency)
+    end
 
-  def self.currency_symbol_regex
-    /\A[\+|\-]?(?<symbol>#{regex_safe_symbols})/
+    def extract_cents(input, currency = Money.default_currency)
+      Monetize::Parser.new(input).parse_cents(currency)
+    end
   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/core_extensions/hash.rb

@@ -2,6 +2,7 @@
 
 class Hash
   def to_money(currency = nil)
-    Money.new(self[:cents], self[:currency] || currency || Money.default_currency)
+    hash_currency = self[:currency].is_a?(Hash) ? self[:currency][:iso_code] : self[:currency]
+    Money.new(self[:cents] || self[:fractional], hash_currency || currency || Money.default_currency)
   end
 end

data/lib/monetize/core_extensions/string.rb

@@ -2,7 +2,7 @@
 
 class String
   def to_money(currency = nil)
-    Monetize.parse(self, currency)
+    Monetize.parse!(self, currency)
   end
 
   def to_currency

data/lib/monetize/errors.rb

@@ -0,0 +1,6 @@
+module Monetize
+  class Error < StandardError; end
+
+  class ParseError < Error; end
+  class ArgumentError < Error; end
+end

data/lib/monetize/parser.rb

@@ -0,0 +1,178 @@
+# 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 =~ /[\.|,]$/
+
+      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 = nil
+      computed_currency = compute_currency if assume_from_symbol?
+      computed_currency ||= input[/[A-Z]{2,3}/]
+
+      computed_currency || fallback_currency || Money.default_currency
+    end
+
+    private
+
+    attr_reader :input, :fallback_currency, :options
+
+    def assume_from_symbol?
+      options.fetch(:assume_from_symbol) { Monetize.assume_from_symbol }
+    end
+
+    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 compute_currency
+      matches = input.match(currency_symbol_regex)
+      CURRENCY_SYMBOLS[matches[:symbol]] if matches
+    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 && 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 || possible_major.length > 3 || 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 =~ /^-+(.*)$/ || 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(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)
+      [major, minor || '00']
+    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.4.0'
+  VERSION = '1.9.1'
 end

data/monetize.gemspec

@@ -19,9 +19,15 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'money', '~> 6.7'
+  spec.add_dependency 'money', '~> 6.12'
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec', '~> 3.0.0.beta1'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake', '~> 10.2'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['changelog_uri'] = 'https://github.com/RubyMoney/monetize/blob/master/CHANGELOG.md'
+    spec.metadata['source_code_uri'] = 'https://github.com/RubyMoney/monetize/'
+    spec.metadata['bug_tracker_uri'] = 'https://github.com/RubyMoney/monetize/issues'
+  end
 end

data/spec/core_extensions_spec.rb

@@ -31,7 +31,7 @@ describe Monetize, 'core extensions' do
         expect(money.cents).to eq 100_37
         expect(money.currency).to eq Money.default_currency
 
-        money = BigDecimal.new('1234').to_money
+        money = BigDecimal('1234').to_money
         expect(money.cents).to eq 1_234_00
         expect(money.currency).to eq Money.default_currency
       end
@@ -182,6 +182,14 @@ describe Monetize, 'core extensions' do
         end
       end
 
+      context 'when currency argument is a hash' do
+        subject(:hash) { {cents: 100, currency: {iso_code: 'EUR'}} }
+
+        it 'converts Hash to Money using iso_code from currency hash' do
+          expect(hash.to_money).to eq(Money.new(100, 'EUR'))
+        end
+      end
+
       context 'when no currency is passed' do
         subject(:hash) { {cents: 123} }
 
@@ -191,6 +199,14 @@ describe Monetize, 'core extensions' do
           expect(hash.to_money('USD')).to eq(Money.new(123, 'USD'))
         end
       end
+
+      context "when key name is 'fractional'" do
+        subject(:hash) { {fractional: 100} }
+
+        it 'converts Hash to Money, interpreting fractional as cents' do
+          expect(hash.to_money).to eq(Money.new(100, 'USD'))
+        end
+      end
     end
   end
 

data/spec/monetize_spec.rb

@@ -56,76 +56,69 @@ describe Monetize do
           Monetize.assume_from_symbol = false
         end
 
-        it 'parses formatted inputs with Euros passed as a symbol' do
-          expect(Monetize.parse('€5.95')).to eq Money.new(595, 'EUR')
-        end
-
-        it 'parses formatted inputs with Euros passed as a symbol with surrounding space' do
-          expect(Monetize.parse(' €5.95 ')).to eq Money.new(595, 'EUR')
-        end
-
-        it 'parses formatted inputs with British Pounds Sterling passed as a symbol' do
-          expect(Monetize.parse('£9.99')).to eq Money.new(999, 'GBP')
-        end
-
-        it 'parses formatted inputs with British Pounds Sterling passed as a lira sign symbol' do
-          expect(Monetize.parse('₤9.99')).to eq Money.new(999, 'GBP')
-        end
-
-        it 'parses formatted inputs with South African Rand passed as a symbol' do
-          expect(Monetize.parse('R9.99')).to eq Money.new(999, 'ZAR')
-        end
-
-        it 'parses formatted inputs with Brazilian real passed as a symbol' do
-          expect(Monetize.parse('R$R9.99')).to eq Money.new(999, 'BRL')
-        end
-
-        it 'parses formatted inputs with Japanese Yen passed as a symbol' do
-          expect(Monetize.parse('¥999')).to eq Money.new(999, 'JPY')
-        end
-
-        it 'parses formatted inputs with Canadian Dollar passed as a symbol' do
-          expect(Monetize.parse('C$9.99')).to eq Money.new(999, 'CAD')
+        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 }
+            let(:amount_in_units) { amount.to_f / currency.subunit_to_unit }
+
+            it 'ensures correct amount calculations for test' do
+              expect(amount_in_units * currency.subunit_to_unit).to eq(amount)
+            end
+
+            it "parses formatted inputs with #{iso_code} passed as a symbol" do
+              expect(Monetize.parse("#{symbol}#{amount_in_units}")).to eq Money.new(amount, iso_code)
+            end
+
+            context 'prefix' do
+              it 'parses formatted inputs with plus sign and currency as a symbol' do
+                expect(Monetize.parse("+#{symbol}#{amount_in_units}")).to eq Money.new(amount, iso_code)
+              end
+
+              it 'parses formatted inputs with minus sign and currency as a symbol' do
+                expect(Monetize.parse("-#{symbol}#{amount_in_units}")).to eq Money.new(-amount, iso_code)
+              end
+            end
+
+            context 'postfix' do
+              it 'parses formatted inputs with currency symbol and postfix minus sign' do
+                expect(Monetize.parse("#{symbol}#{amount_in_units}-")).to eq Money.new(-amount, iso_code)
+              end
+
+              it 'parses formatted inputs with currency symbol and postfix plus sign' do
+                expect(Monetize.parse("#{symbol}#{amount_in_units}+")).to eq Money.new(amount, iso_code)
+              end
+            end
+
+            context 'amount suffixes' do
+              it 'parses formatted inputs with amounts given with suffixes' do
+                expect(Monetize.parse("#{symbol}1.26K")).to eq Money.new(1_260 * currency.subunit_to_unit, iso_code)
+                expect(Monetize.parse("#{symbol}126.36M")).to eq Money.new(126_360_000 * currency.subunit_to_unit, iso_code)
+                expect(Monetize.parse("#{symbol}.45B")).to eq Money.new(450_000_000 * currency.subunit_to_unit, iso_code)
+                expect(Monetize.parse("-#{symbol}2.45B")).to eq Money.new(-2_450_000_000 * currency.subunit_to_unit, iso_code)
+                expect(Monetize.parse("#{symbol}1.65T")).to eq Money.new(1_650_000_000_000 * currency.subunit_to_unit, iso_code)
+              end
+            end
+
+            it 'parses formatted inputs with symbol and surrounding spaces' do
+              expect(Monetize.parse(" #{symbol}#{amount_in_units} ")).to eq Money.new(amount, iso_code)
+            end
+
+            it 'parses formatted inputs without currency detection when overridden' do
+              expect(Monetize.parse("#{symbol}5.95", nil, assume_from_symbol: false)).to eq Money.new(amount, 'USD')
+            end
+          end
         end
 
         it 'should assume default currency if not a recognised symbol' do
           expect(Monetize.parse('L9.99')).to eq Money.new(999, 'USD')
         end
 
-        it 'parses formatted inputs without currency detection when overridden' do
-          expect(Monetize.parse('£9.99', nil, assume_from_symbol: false)).to eq Money.new(999, 'USD')
-        end
-
-        it 'parses formatted inputs with minus sign and currency symbol' do
-          expect(Monetize.parse('-€9.99')).to eq Money.new(-999, 'EUR')
-          expect(Monetize.parse('-£9.99')).to eq Money.new(-999, 'GBP')
-          expect(Monetize.parse('-R$R9.99')).to eq Money.new(-999, 'BRL')
-          expect(Monetize.parse('-¥999')).to eq Money.new(-999, 'JPY')
-          expect(Monetize.parse('-C$9.99')).to eq Money.new(-999, 'CAD')
-        end
-
-        it 'parses formatted inputs with plus and GBP passed as symbol' do
-          expect(Monetize.parse('+€9.99')).to eq Money.new(999, 'EUR')
-          expect(Monetize.parse('+£9.99')).to eq Money.new(999, 'GBP')
-          expect(Monetize.parse('+R$R9.99')).to eq Money.new(999, 'BRL')
-          expect(Monetize.parse('+¥999')).to eq Money.new(999, 'JPY')
-          expect(Monetize.parse('+C$9.99')).to eq Money.new(999, 'CAD')
-        end
-
-        it 'parses formatted inputs with currency symbol and postfix minus sign' do
-          expect(Monetize.parse('€9.99-')).to eq Money.new(-999, 'EUR')
-        end
-
-        it 'parses formatted inputs with currency symbol and postfix plus sign' do
-          expect(Monetize.parse('€9.99+')).to eq Money.new(999, 'EUR')
-        end
-
-        it 'parses formatted inputs with amounts given with suffixes' do
-          expect(Monetize.parse('$1.26K')).to eq Money.new(1_260_00, 'USD')
-          expect(Monetize.parse('$126.36M')).to eq Money.new(126_360_000_00, 'USD')
-          expect(Monetize.parse('€.45B')).to eq Money.new(450_000_000_00, 'EUR')
-          expect(Monetize.parse('-$2.45B')).to eq Money.new(-2_450_000_000_00, 'USD')
-          expect(Monetize.parse('€1.65T')).to eq Money.new(1_650_000_000_000_00, 'EUR')
+        context 'negatives' do
+          it 'ignores the ambiguous kr symbol' do
+            # Could mean either of DKK, EEK, ISK, NOK, SEK
+            expect(Monetize.parse('kr9.99')).to eq Money.new(999, 'USD')
+          end
         end
       end
 
@@ -158,6 +151,18 @@ describe Monetize do
       it 'should opt out by default' do
         expect(Monetize.assume_from_symbol).to be_falsy
       end
+
+      context 'ISO code' do
+        it 'parses currency given as ISO code' do
+          expect('20.00 USD'.to_money).to eq Money.new(20_00, 'USD')
+          expect('20.00 EUR'.to_money).to eq Money.new(20_00, 'EUR')
+          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
+        end
+      end
     end
 
     it 'parses USD-formatted inputs under $10' do
@@ -177,10 +182,16 @@ describe Monetize do
       expect(Monetize.parse('1,111,234,567.89')).to eq Money.new(1_111_234_567_89, 'USD')
     end
 
-    it 'does not return a price if there is a price range' do
-      expect { Monetize.parse('$5.95-10.95') }.to raise_error ArgumentError
-      expect { Monetize.parse('$5.95 - 10.95') }.to raise_error ArgumentError
-      expect { Monetize.parse('$5.95 - $10.95') }.to raise_error ArgumentError
+    it 'parses DKK-formatted inputs' do
+      expect(Monetize.parse('kr.123,45', 'DKK')).to eq Money.new(123_45, 'DKK')
+      expect(Monetize.parse('kr.123.45', 'DKK')).to eq Money.new(123_45, 'DKK')
+      expect(Monetize.parse('kr.45k', 'DKK')).to eq Money.new(45_000_00, 'DKK')
+    end
+
+    it 'returns nil if input is a price range' do
+      expect(Monetize.parse('$5.95-10.95')).to be_nil
+      expect(Monetize.parse('$5.95 - 10.95')).to be_nil
+      expect(Monetize.parse('$5.95 - $10.95')).to be_nil
     end
 
     it 'does not return a price for completely invalid input' do
@@ -197,8 +208,16 @@ describe Monetize do
       expect(Monetize.parse('$5.95-')).to eq five_ninety_five
     end
 
-    it 'raises ArgumentError when unable to detect polarity' do
-      expect { Monetize.parse('-$5.95-') }.to raise_error ArgumentError
+    it 'returns nil when unable to detect polarity' do
+      expect(Monetize.parse('-$5.95-')).to be_nil
+    end
+
+    it 'returns nil when more than 2 digit separators are used' do
+      expect(Monetize.parse("123.34,56'89 EUR")).to be_nil
+    end
+
+    it 'parses correctly strings with repeated digit separator' do
+      expect(Monetize.parse('19.12.89', 'EUR')).to eq Money.new(191_289_00, 'EUR')
     end
 
     it 'parses correctly strings with exactly 3 decimal digits' do
@@ -210,6 +229,32 @@ describe Monetize do
       Monetize.enforce_currency_delimiters = false
     end
 
+    context 'Money object attempting to be parsed' do
+      let(:money) { Money.new(595, 'GBP') }
+
+      it 'returns the original Money object' do
+        expect(Monetize.parse(money)).to eq money
+        expect(Monetize.parse(money).currency).to eq 'GBP'
+        expect(Monetize.parse(money).cents).to eq 595
+      end
+    end
+
+    context 'parsing an instance of Numeric class' do
+      let(:integer)     { 10 }
+      let(:float)       { 10.0 }
+      let(:big_decimal) { BigDecimal('10') }
+
+      [:integer, :float, :big_decimal].each do |type|
+        it "returns a new Money object based on the #{type} input" do
+          money = Monetize.parse(send(type), 'USD')
+
+          expect(money).to be_instance_of(Money)
+          expect(money.currency).to eq('USD')
+          expect(money.cents).to eq(10_00)
+        end
+      end
+    end
+
     context 'custom currencies with 4 decimal places' do
       before :each do
         Money::Currency.register(JSON.parse(bar, symbolize_names: true))
@@ -265,6 +310,18 @@ describe Monetize do
     end
   end
 
+  describe '.parse!' do
+    it 'does not return a price if there is a price range' do
+      expect { Monetize.parse!('$5.95-10.95') }.to raise_error Monetize::ParseError
+      expect { Monetize.parse!('$5.95 - 10.95') }.to raise_error Monetize::ParseError
+      expect { Monetize.parse!('$5.95 - $10.95') }.to raise_error Monetize::ParseError
+    end
+
+    it 'raises ArgumentError when unable to detect polarity' do
+      expect { Monetize.parse!('-$5.95-') }.to raise_error Monetize::ParseError
+    end
+  end
+
   describe '.parse_collection' do
     it 'parses into a Money::Collection' do
       expect(Monetize.parse_collection('$7')).to be_a Monetize::Collection
@@ -287,6 +344,10 @@ describe Monetize do
       expect(collection.first).to eq Monetize.parse('$4')
       expect(collection.last).to eq Monetize.parse('$10')
     end
+
+    it 'raises an error if argument is invalid' do
+      expect { Monetize.parse_collection(nil) }.to raise_error Monetize::ArgumentError
+    end
   end
 
   describe '.from_string' do
@@ -337,6 +398,10 @@ describe Monetize do
       m = Monetize.from_fixnum(1, 'EUR')
       expect(m.currency).to eq Money::Currency.wrap('EUR')
     end
+
+    it 'is aliased as from_integer' do
+      expect(Monetize.from_integer(1)).to eq(Monetize.from_fixnum(1))
+    end
   end
 
   describe '.from_float' do
@@ -366,25 +431,31 @@ describe Monetize do
 
   describe '.from_bigdecimal' do
     it 'converts given amount to cents' do
-      expect(Monetize.from_bigdecimal(BigDecimal.new('1'))).to eq Money.new(1_00)
-      expect(Monetize.from_bigdecimal(BigDecimal.new('1'))).to eq Money.new(1_00, 'USD')
-      expect(Monetize.from_bigdecimal(BigDecimal.new('1'), 'EUR')).to eq Money.new(1_00, 'EUR')
+      expect(Monetize.from_bigdecimal(BigDecimal('1'))).to eq Money.new(1_00)
+      expect(Monetize.from_bigdecimal(BigDecimal('1'))).to eq Money.new(1_00, 'USD')
+      expect(Monetize.from_bigdecimal(BigDecimal('1'), 'EUR')).to eq Money.new(1_00, 'EUR')
     end
 
     it 'respects :subunit_to_unit currency property' do
-      expect(Monetize.from_bigdecimal(BigDecimal.new('1'), 'USD')).to eq Money.new(1_00, 'USD')
-      expect(Monetize.from_bigdecimal(BigDecimal.new('1'), 'TND')).to eq Money.new(1_000, 'TND')
-      expect(Monetize.from_bigdecimal(BigDecimal.new('1'), 'JPY')).to eq Money.new(1, 'JPY')
+      expect(Monetize.from_bigdecimal(BigDecimal('1'), 'USD')).to eq Money.new(1_00, 'USD')
+      expect(Monetize.from_bigdecimal(BigDecimal('1'), 'TND')).to eq Money.new(1_000, 'TND')
+      expect(Monetize.from_bigdecimal(BigDecimal('1'), 'JPY')).to eq Money.new(1, 'JPY')
+    end
+
+    it 'respects rounding mode when rounding amount to the nearest cent' do
+      amount = BigDecimal('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'))
+      m = Monetize.from_bigdecimal(BigDecimal('1'))
       expect(m.currency).to eq Money.default_currency
 
-      m = Monetize.from_bigdecimal(BigDecimal.new('1'), Money::Currency.wrap('EUR'))
+      m = Monetize.from_bigdecimal(BigDecimal('1'), Money::Currency.wrap('EUR'))
       expect(m.currency).to eq Money::Currency.wrap('EUR')
 
-      m = Monetize.from_bigdecimal(BigDecimal.new('1'), 'EUR')
+      m = Monetize.from_bigdecimal(BigDecimal('1'), 'EUR')
       expect(m.currency).to eq Money::Currency.wrap('EUR')
     end
 
@@ -398,11 +469,11 @@ describe Monetize do
       end
 
       it 'keeps precision' do
-        expect(Monetize.from_bigdecimal(BigDecimal.new('1'))).to eq Money.new(100)
-        expect(Monetize.from_bigdecimal(BigDecimal.new('1.23456'))).to eq Money.new(123.456)
-        expect(Monetize.from_bigdecimal(BigDecimal.new('-1.23456'))).to eq Money.new(-123.456)
-        expect(Monetize.from_bigdecimal(BigDecimal.new('1.23456'))).to eq Money.new(123.456, 'USD')
-        expect(Monetize.from_bigdecimal(BigDecimal.new('1.23456'), 'EUR')).to eq Money.new(123.456, 'EUR')
+        expect(Monetize.from_bigdecimal(BigDecimal('1'))).to eq Money.new(100)
+        expect(Monetize.from_bigdecimal(BigDecimal('1.23456'))).to eq Money.new(123.456)
+        expect(Monetize.from_bigdecimal(BigDecimal('-1.23456'))).to eq Money.new(-123.456)
+        expect(Monetize.from_bigdecimal(BigDecimal('1.23456'))).to eq Money.new(123.456, 'USD')
+        expect(Monetize.from_bigdecimal(BigDecimal('1.23456'), 'EUR')).to eq Money.new(123.456, 'EUR')
 
         expect('1'.to_money).to eq Money.new(100)
         expect('1.23456'.to_money).to eq Money.new(123.456)
@@ -417,19 +488,11 @@ describe Monetize do
     it 'converts given amount to cents' do
       expect(Monetize.from_numeric(1)).to eq Money.new(1_00)
       expect(Monetize.from_numeric(1.0)).to eq Money.new(1_00)
-      expect(Monetize.from_numeric(BigDecimal.new('1'))).to eq Money.new(1_00)
+      expect(Monetize.from_numeric(BigDecimal('1'))).to eq Money.new(1_00)
     end
 
     it 'raises ArgumentError with unsupported argument' do
-      expect { Monetize.from_numeric('100') }.to raise_error(ArgumentError)
-    end
-
-    it 'optimizes workload' do
-      expect(Monetize).to receive(:from_fixnum).with(1, 'USD').and_return(Money.new(1_00, 'USD'))
-      expect(Monetize.from_numeric(1, 'USD')).to eq Money.new(1_00, 'USD')
-      expect(Monetize).to receive(:from_bigdecimal).with(BigDecimal.new('1.0'), 'USD').
-        and_return(Money.new(1_00, 'USD'))
-      expect(Monetize.from_numeric(1.0, 'USD')).to eq Money.new(1_00, 'USD')
+      expect { Monetize.from_numeric('100') }.to raise_error(Monetize::ArgumentError)
     end
 
     it 'respects :subunit_to_unit currency property' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monetize
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.9.1
 platform: ruby
 authors:
 - Shane Emmons
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-15 00:00:00.000000000 Z
+date: 2019-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: money
@@ -16,56 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.7'
+        version: '6.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.7'
+        version: '6.12'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0.beta1
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0.beta1
+        version: '3.0'
 description: A library for converting various objects into `Money` objects.
 email:
 - shane@emmons.io
@@ -83,14 +83,16 @@ 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
 - lib/monetize/core_extensions/numeric.rb
 - 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
@@ -99,7 +101,10 @@ files:
 homepage: https://github.com/RubyMoney/monetize
 licenses:
 - MIT
-metadata: {}
+metadata:
+  changelog_uri: https://github.com/RubyMoney/monetize/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/RubyMoney/monetize/
+  bug_tracker_uri: https://github.com/RubyMoney/monetize/issues
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -116,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: A library for converting various objects into `Money` objects.
@@ -124,4 +129,3 @@ test_files:
 - spec/core_extensions_spec.rb
 - spec/monetize_spec.rb
 - spec/spec_helper.rb
-has_rdoc: