monetize 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bdb994a311b7519b56c417e4496a36bd6e41c377
-  data.tar.gz: f788b003d6412c6c3263b58736602f38be014c65
+  metadata.gz: 7f96f9f99c2fc04ab625a2977f370eff77d33696
+  data.tar.gz: 75817ce67a91ae35019f6ef3a3b290b937b64749
 SHA512:
-  metadata.gz: 6c7435ede20d6b291da530a7c67876d347a2b484b46781ff5a7d040b4de6de6ce9c7f0378ef2179473e541c6b70223d6a793eb4c11911da0e38cc1e92a32e61a
-  data.tar.gz: 12d53e41df08426527aceb44dd598bcf4dcdd926e6cf8d279ad8ce81e16f00b68a9b0503079df141dec6aa62de58e1f0ad7d3b4dee292a1b366f43df9c489571
+  metadata.gz: 657c4f4be74370f9a8b2b1f4fcb91e60a013e9d2e01f39f95258a48c47710c5418767770af32ca61c19d52b0a94ccaa875fd3a4b7d8f21023ff7f4b036700c90
+  data.tar.gz: 4cb6265937f209b0797cc4c0d2e78b4fa27a9f27f9f045cfac8d00812dcb2ccb86072672897b7fb36f7337dab52cbb62c3e58739b9cdcdc9ec32b73393bedd9a

data/.rubocop.yml

@@ -0,0 +1,32 @@
+Documentation:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/ModuleLength:
+  Enabled: false
+Style/AndOr:
+  Enabled: false
+Style/ClassAndModuleChildren:
+  Enabled: false
+Style/PerlBackrefs:
+  Enabled: false
+
+Style/CollectionMethods:
+  Enabled: yes
+Lint/LiteralInInterpolation:
+  Enabled: yes
+
+Metrics/LineLength:
+  Max: 120
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+Style/DotPosition:
+  EnforcedStyle: trailing
+Style/EmptyElse:
+  EnforcedStyle: empty
+Style/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space

data/CHANGELOG.md

@@ -1,14 +1,21 @@
 # Changelog
 
-## Master
+## 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.3.0
 - Add NilClass extension
 - Added correct parsing of Brazilian Real $R symbol
-- Add testing task for  Brazilian Real parsing 
+- 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
+
+## 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

data/Gemfile

@@ -1,5 +1,5 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
-gem "coveralls", :require => false
+gem 'coveralls', require: false
 
 gemspec

data/Rakefile

@@ -1,6 +1,18 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
 task default: :spec
 
 RSpec::Core::RakeTask.new
+
+task :environment do
+  require_relative 'lib/monetize'
+end
+
+desc 'Start a console with library loaded'
+task console: :environment do
+  require 'irb'
+  require 'irb/completion'
+  ARGV.clear
+  IRB.start
+end

data/lib/collection.rb

@@ -19,7 +19,7 @@ module Monetize
       if input.respond_to? :strip
         @input = input.clone.strip
       else
-        raise ArgumentError 'Input must be a string'
+        fail ArgumentError, 'Input must be a string'
       end
 
       @currency = currency
@@ -47,13 +47,11 @@ module Monetize
     RANGE_SPLIT = /-/
 
     def split_list
-      Array @input.split(LIST_SPLIT)
-        .map(&:strip)
+      @input.split(LIST_SPLIT).map(&:strip)
     end
 
     def split_range
-      Array @input.split(RANGE_SPLIT)
-        .map(&:strip)
+      @input.split(RANGE_SPLIT).map(&:strip)
     end
   end
 end

data/lib/monetize.rb

@@ -1,37 +1,42 @@
 # encoding: utf-8
 
-require "money"
-require "monetize/core_extensions"
-require "monetize/version"
-require "collection"
+require 'money'
+require 'monetize/core_extensions'
+require 'monetize/version'
+require 'collection'
 
 module Monetize
-
   CURRENCY_SYMBOLS = {
-    "$"    => "USD",
-    "€"    => "EUR",
-    "£"    => "GBP",
-    "₤"    => "GBP",
-    "R$"   => "BRL",
-    "R"    => "ZAR",
-    "¥"    => "JPY",
-    "C$"   => "CAD"
+    '$'    => 'USD',
+    '€'    => 'EUR',
+    '£'    => 'GBP',
+    '₤'    => 'GBP',
+    'R$'   => 'BRL',
+    'R'    => 'ZAR',
+    '¥'    => 'JPY',
+    'C$'   => 'CAD'
   }
 
   MULTIPLIER_SUFFIXES = {
-    "K"    => 3,
-    "M"    => 6,
-    "B"    => 9,
-    "T"    => 12
+    'K'    => 3,
+    'M'    => 6,
+    'B'    => 9,
+    'T'    => 12
   }
   MULTIPLIER_SUFFIXES.default = 0
-  MULTIPLIER_REGEXP = Regexp.new('\d(%s)\b[^\d]*$' % MULTIPLIER_SUFFIXES.keys.join('|'), 'i')
+  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
     #   ability to assume the currency from a passed symbol
     attr_accessor :assume_from_symbol
+
+    # Monetize uses the delimiters set in the currency to separate integers from
+    # decimals, and to ignore thousands separators. In some corner cases,
+    # 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 = {})
@@ -61,7 +66,7 @@ module Monetize
 
   def self.from_fixnum(value, currency = Money.default_currency)
     currency = Money::Currency.wrap(currency)
-    value = value * currency.subunit_to_unit
+    value *= currency.subunit_to_unit
     Money.new(value, currency)
   end
 
@@ -72,7 +77,7 @@ module Monetize
 
   def self.from_bigdecimal(value, currency = Money.default_currency)
     currency = Money::Currency.wrap(currency)
-    value = value * currency.subunit_to_unit
+    value *= currency.subunit_to_unit
     value = value.round unless Money.infinite_precision
     Money.new(value, currency)
   end
@@ -85,99 +90,47 @@ module Monetize
       value = BigDecimal.new(value.to_s)
       from_bigdecimal(value, currency)
     else
-      raise ArgumentError, "'value' should be a type of Numeric"
+      fail ArgumentError, "'value' should be a type of Numeric"
     end
   end
 
   def self.extract_cents(input, currency = Money.default_currency)
-    multiplier_suffix = (matches = MULTIPLIER_REGEXP.match(input)) ? matches[1].upcase : nil
-    multiplier_exp = MULTIPLIER_SUFFIXES[multiplier_suffix]
+    multiplier_exp, input = extract_multiplier(input)
 
     num = input.gsub(/[^\d.,'-]/, '')
 
-    negative = num =~ /^-|-$/ ? true : false
-
-    decimal_char = currency.decimal_mark
-
-    num = num.sub(/^-|-$/, '') if negative
-
-    if num.include?('-')
-      raise ArgumentError, "Invalid currency amount (hyphen)"
-    end
+    negative, num = extract_sign(num)
 
     num.chop! if num.match(/[\.|,]$/)
 
-    used_delimiters = num.scan(/[^\d]/)
+    major, minor = extract_major_minor(num, currency)
 
-    case used_delimiters.uniq.length
-    when 0
-      major, minor = num, 0
-    when 2
-      thousands_separator, decimal_mark = used_delimiters.uniq
+    cents = major.to_i * currency.subunit_to_unit
 
-      major, minor = num.gsub(thousands_separator, '').split(decimal_mark)
-      min = 0 unless min
-    when 1
-      decimal_mark = used_delimiters.first
+    cents, minor = apply_multiplier(multiplier_exp, cents, minor)
 
-      if decimal_char == decimal_mark
-        major, minor = num.split(decimal_char)
-      else
-        if num.scan(decimal_mark).length > 1 # multiple matches; treat as decimal_mark
-          major, minor = num.gsub(decimal_mark, ''), 0
-        else
-          possible_major, possible_minor = num.split(decimal_mark)
-          possible_major ||= "0"
-          possible_minor ||= "00"
-
-          if possible_minor.length != 3 # thousands_separator
-            major, minor = possible_major, possible_minor
-          else
-            if possible_major.length > 3
-              major, minor = possible_major, possible_minor
-            else
-              if decimal_mark == '.'
-                major, minor = possible_major, possible_minor
-              else
-                major, minor = "#{possible_major}#{possible_minor}", 0
-              end
-            end
-          end
-        end
-      end
-    else
-      raise ArgumentError, "Invalid currency amount"
-    end
+    cents += set_minor_precision(minor, currency)
 
-    cents = major.to_i * currency.subunit_to_unit
+    apply_sign(negative, cents)
+  end
+
+  private
 
-    cents *= (10 ** multiplier_exp)
+  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
+    shift = minor[0...multiplier_exp].to_i * 100
     cents += shift
-    minor = (minor[multiplier_exp .. -1] || '')
-
-    minor = if 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
-
-    cents += minor
+    minor = (minor[multiplier_exp..-1] || '')
+    [cents, minor]
+  end
 
+  def self.apply_sign(negative, cents)
     negative ? cents * -1 : cents
   end
 
-  private
-
   def self.contains_currency_symbol?(amount)
-    currency_symbol_regex === amount
+    amount =~ currency_symbol_regex
   end
 
   def self.compute_currency(amount)
@@ -189,10 +142,87 @@ module Monetize
     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'
+    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 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('|')
+    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

data/lib/monetize/core_extensions.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
-require "monetize/core_extensions/nil_class"
-require "monetize/core_extensions/numeric"
-require "monetize/core_extensions/string"
-require "monetize/core_extensions/symbol"
-require "monetize/core_extensions/hash"
+require 'monetize/core_extensions/nil_class'
+require 'monetize/core_extensions/numeric'
+require 'monetize/core_extensions/string'
+require 'monetize/core_extensions/symbol'
+require 'monetize/core_extensions/hash'

data/lib/monetize/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Monetize
-  VERSION = "1.3.1"
+  VERSION = '1.4.0'
 end

data/monetize.gemspec

@@ -1,26 +1,27 @@
 # coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "monetize/version"
+require 'monetize/version'
+require 'English'
 
 Gem::Specification.new do |spec|
-  spec.name          = "monetize"
+  spec.name          = 'monetize'
   spec.version       = Monetize::VERSION
-  spec.authors       = ["Shane Emmons"]
-  spec.email         = ["shane@emmons.io"]
-  spec.description   = "A library for converting various objects into `Money` objects."
-  spec.summary       = "A library for converting various objects into `Money` objects."
-  spec.homepage      = "https://github.com/RubyMoney/monetize"
-  spec.license       = "MIT"
+  spec.authors       = ['Shane Emmons']
+  spec.email         = ['shane@emmons.io']
+  spec.description   = 'A library for converting various objects into `Money` objects.'
+  spec.summary       = 'A library for converting various objects into `Money` objects.'
+  spec.homepage      = 'https://github.com/RubyMoney/monetize'
+  spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_dependency "money", "~> 6.6"
+  spec.add_dependency 'money', '~> 6.7'
 
-  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', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0.0.beta1'
 end