money 6.10.1 → 6.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2e4b452eb189b014f2807754a5be04f71419c60
-  data.tar.gz: f94facfe0d9f541b0f3e1cae4cb94c1be7b9775d
+  metadata.gz: 8de2a6b8bf58ff5719f33d9db889ae722fa39b41
+  data.tar.gz: 713995a09dfac0042e598c153f3d7dffa54e06d7
 SHA512:
-  metadata.gz: '008425091a080a8b13e96cb593863bb12bc7041de755686b27065de0d2b36830b2cbd5abd8c7e38424995511856a501d483557a3e4a20708669806917395fcfb'
-  data.tar.gz: 6db8674c8037f772efc5ebfbdbaf680db6a9778d2a0f6fa9abe95b6d7802bb570efc4ae22b2b1d7f0c4385d9a35b38b6acf33f6b4d8e87d34cbbceeb5a4d8751
+  metadata.gz: 86cd80fd6278138aa30cdf281e92bfc369035fe7122d98f78ebdd3662810fe7ead3a252e7dea8f40f6600df6c23134f2038e8f8a685fd3065306ef06b81a8f6b
+  data.tar.gz: e8ed3c0961bbb92ab3cb5523620f08fab61c1c9741819bf2f892c039fd8d5b550843113a71b984dc249ebdb5aa9cbf2f0291b813085c940648f647cb6764f404

data/.travis.yml

@@ -1,22 +1,24 @@
+---
 language: ruby
 sudo: false
 rvm:
   - 1.9.3
-  - 2.0.0
+  - 2.0
   - 2.1.10
-  - 2.2.7
-  - 2.3.4
-  - 2.4.1
-  - rbx-2
+  - 2.2.10
+  - 2.3.7
+  - 2.4.4
+  - 2.5.1
+  - rbx-3
   - jruby-9.0.5.0
-  - jruby-9.1.2.0
+  - jruby-9.1.16.0
   - ruby-head
   - jruby-head
 matrix:
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
-    - rvm: rbx-2
+    - rvm: rbx-3
   fast_finish: true
 before_install:
   - gem update bundler

data/AUTHORS

@@ -43,6 +43,7 @@ George Millo
 Hakan Ensari
 Hongli Lai
 Ilia Lobsanov
+Ivan Shamatov
 Ingo Wichmann
 Jacob Atzen
 James Cotterill
@@ -112,6 +113,7 @@ Thomas Weymuth
 Ticean Bennett
 Tien Nguyen
 Tim Hart
+Tim Krins
 Tobias Luetke
 Tobias Schmidt
 Tom Lianza
@@ -125,3 +127,4 @@ Yuri Sidorov
 Yuusuke Takizawa
 Zubin Henner
 Бродяной Александр
+Nicolay Hvidsten

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 6.11.0
+- Support i18n 1.0
+- Update yard dependency to 0.9.11
+- Support for ruby 2.5.0
+- Add inheritance for currency definitions
+- Added new symbol for bitcoin denomination
+- Specify custom rounding precision when using `infinite_precision`
+- Allow splits with sums greater than 1
+- Prevent arithmetic methods from loosing reference to the bank
+- Fix coerced zero numeric subtraction
+- Fix south asian formatting to support whole numbers
+- Refactor formatting logic
+
 ## 6.10.1
 - Fix an issue with Money.empty memoization
 

data/README.md

@@ -312,8 +312,9 @@ def marshal_dump; end
 The following example implements an `ActiveRecord` store to save exchange rates to a database.
 
 ```ruby
-# DB columns :from[String], :to[String], :rate[Float]
+# rails g model exchange_rate from:string to:string rate:float
 
+# for Rails 5 replace ActiveRecord::Base with ApplicationRecord
 class ExchangeRate < ActiveRecord::Base
   def self.get_rate(from_iso_code, to_iso_code)
     rate = find_by(:from => from_iso_code, :to => to_iso_code)

data/config/currency_non_iso.json

@@ -3,12 +3,12 @@
     "priority": 100,
     "iso_code": "BTC",
     "name": "Bitcoin",
-    "symbol": "B⃦",
+    "symbol": "₿",
     "alternate_symbols": [],
     "subunit": "Satoshi",
     "subunit_to_unit": 100000000,
     "symbol_first": true,
-    "html_entity": "",
+    "html_entity": "₿",
     "decimal_mark": ".",
     "thousands_separator": ",",
     "iso_numeric": "",

data/lib/money/bank/variable_exchange.rb

@@ -119,14 +119,14 @@ class Money
       end
 
       def calculate_fractional(from, to_currency)
-        BigDecimal.new(from.fractional.to_s) / (
-          BigDecimal.new(from.currency.subunit_to_unit.to_s) /
-          BigDecimal.new(to_currency.subunit_to_unit.to_s)
+        BigDecimal(from.fractional.to_s) / (
+          BigDecimal(from.currency.subunit_to_unit.to_s) /
+          BigDecimal(to_currency.subunit_to_unit.to_s)
         )
       end
 
       def exchange(fractional, rate, &block)
-        ex = fractional * BigDecimal.new(rate.to_s)
+        ex = fractional * BigDecimal(rate.to_s)
         if block_given?
           yield ex
         elsif @rounding_method

data/lib/money/currency.rb

@@ -173,6 +173,15 @@ class Money
         @stringified_keys = stringify_keys
       end
 
+      # Inherit a new currency from existing one
+      #
+      # @param parent_iso_code [String] the international 3-letter code as defined
+      # @param curr [Hash] See {register} method for hash structure 
+      def inherit(parent_iso_code, curr)
+        parent_iso_code = parent_iso_code.downcase.to_sym
+        curr = @table.fetch(parent_iso_code, {}).merge(curr)
+        register(curr)
+      end
 
       # Unregister a currency.
       #
@@ -399,38 +408,12 @@ class Money
     #
     # @return [Integer]
     def exponent
-      Math.log10(@subunit_to_unit).round
-    end
-
-    # Cache decimal places for subunit_to_unit values. Common ones pre-cached.
-    def self.decimal_places_cache
-      @decimal_places_cache ||= {1 => 0, 10 => 1, 100 => 2, 1000 => 3}
-    end
-
-    # The number of decimal places needed.
-    #
-    # @return [Integer]
-    def decimal_places
-      cache[subunit_to_unit] ||= calculate_decimal_places(subunit_to_unit)
+      Math.log10(subunit_to_unit).round
     end
+    alias decimal_places exponent
 
     private
 
-    def cache
-      self.class.decimal_places_cache
-    end
-
-    # If we need to figure out how many decimal places we need we
-    # use repeated integer division.
-    def calculate_decimal_places(num)
-      i = 1
-      while num >= 10
-        num /= 10
-        i += 1 if num >= 10
-      end
-      i
-    end
-
     def initialize_data!
       data = self.class.table[@id]
       @alternate_symbols     = data[:alternate_symbols]

data/lib/money/money/arithmetic.rb

@@ -16,7 +16,7 @@ class Money
     # @example
     #    - Money.new(100) #=> #<Money @fractional=-100>
     def -@
-      self.class.new(-fractional, currency)
+      self.class.new(-fractional, currency, bank)
     end
 
     # Checks whether two Money objects have the same currency and the same
@@ -125,11 +125,13 @@ class Money
     [:+, :-].each do |op|
       define_method(op) do |other|
         unless other.is_a?(Money)
-          return self if other.zero?
+          if other.zero?
+            return other.is_a?(CoercedNumeric) ? Money.empty.public_send(op, self) : self
+          end
           raise TypeError
         end
         other = other.exchange_to(currency)
-        self.class.new(fractional.public_send(op, other.fractional), currency)
+        self.class.new(fractional.public_send(op, other.fractional), currency, bank)
       end
     end
 
@@ -150,7 +152,7 @@ class Money
     def *(value)
       value = value.value if value.is_a?(CoercedNumeric)
       if value.is_a? Numeric
-        self.class.new(fractional * value, currency)
+        self.class.new(fractional * value, currency, bank)
       else
         raise TypeError, "Can't multiply a #{self.class.name} by a #{value.class.name}'s value"
       end
@@ -176,7 +178,7 @@ class Money
         fractional / as_d(value.exchange_to(currency).fractional).to_f
       else
         raise TypeError, 'Can not divide by Money' if value.is_a?(CoercedNumeric)
-        self.class.new(fractional / as_d(value), currency)
+        self.class.new(fractional / as_d(value), currency, bank)
       end
     end
 
@@ -214,13 +216,13 @@ class Money
     def divmod_money(val)
       cents = val.exchange_to(currency).cents
       quotient, remainder = fractional.divmod(cents)
-      [quotient, self.class.new(remainder, currency)]
+      [quotient, self.class.new(remainder, currency, bank)]
     end
     private :divmod_money
 
     def divmod_other(val)
       quotient, remainder = fractional.divmod(as_d(val))
-      [self.class.new(quotient, currency), self.class.new(remainder, currency)]
+      [self.class.new(quotient, currency, bank), self.class.new(remainder, currency, bank)]
     end
     private :divmod_other
 
@@ -264,7 +266,7 @@ class Money
       if (fractional < 0 && val < 0) || (fractional > 0 && val > 0)
         self.modulo(val)
       else
-        self.modulo(val) - (val.is_a?(Money) ? val : self.class.new(val, currency))
+        self.modulo(val) - (val.is_a?(Money) ? val : self.class.new(val, currency, bank))
       end
     end
 
@@ -275,7 +277,7 @@ class Money
     # @example
     #   Money.new(-100).abs #=> #<Money @fractional=100>
     def abs
-      self.class.new(fractional.abs, currency)
+      self.class.new(fractional.abs, currency, bank)
     end
 
     # Test if the money amount is zero.

data/lib/money/money/{formatting.rb → formatter.rb}

@@ -1,6 +1,8 @@
 # encoding: UTF-8
+require 'money/money/formatting_rules'
+
 class Money
-  module Formatting
+  class Formatter
     # Creates a formatted price string according to several rules.
     #
     # @param [Hash] rules The options used to format the string.
@@ -198,66 +200,27 @@ class Money
     # Note that the default rules can be defined through {Money.default_formatting_rules} hash.
     #
     # @see Money.default_formatting_rules Money.default_formatting_rules for more information.
-    def format(*rules)
-      # support for old format parameters
-      rules = normalize_formatting_rules(rules)
-
-      rules = default_formatting_rules.merge(rules)
-      rules = localize_formatting_rules(rules)
-      rules = translate_formatting_rules(rules) if rules[:translate]
-
-      thousands_separator = self.thousands_separator
-      decimal_mark = self.decimal_mark
-
-      escaped_decimal_mark = Regexp.escape(decimal_mark)
-
-      if fractional == 0
-        if rules[:display_free].respond_to?(:to_str)
-          return rules[:display_free]
-        elsif rules[:display_free]
-          return "free"
-        end
-      end
-
-      symbol_value = symbol_value_from(rules)
-
-      formatted = self.abs.to_s
+    def initialize(money, *rules)
+      @money = money
+      @currency = money.currency
+      @rules = FormattingRules.new(@currency, *rules)
+    end
 
-      if rules[:rounded_infinite_precision]
-        formatted.gsub!(/#{decimal_mark}/, '.') unless '.' == decimal_mark
-        formatted = ((BigDecimal(formatted) * currency.subunit_to_unit).round / BigDecimal(currency.subunit_to_unit.to_s)).to_s("F")
-        formatted.gsub!(/\..*/) do |decimal_part|
-          decimal_part << '0' while decimal_part.length < (currency.decimal_places + 1)
-          decimal_part
-        end
-        formatted.gsub!(/\./, decimal_mark) unless '.' == decimal_mark
-      end
+    def to_s
+      return free_text if show_free_text?
 
-      sign = self.negative? ? '-' : ''
+      whole_part, decimal_part = extract_whole_and_decimal_parts
 
-      if rules[:no_cents] || (rules[:no_cents_if_whole] && cents % currency.subunit_to_unit == 0)
-        formatted = "#{formatted.to_i}"
-      end
+      # Format whole and decimal parts separately
+      decimal_part = format_decimal_part(decimal_part)
+      whole_part = format_whole_part(whole_part)
 
-      # Inspiration: https://github.com/rails/rails/blob/16214d1108c31174c94503caced3855b0f6bad95/activesupport/lib/active_support/number_helper/number_to_rounded_converter.rb#L72-L79
-      if rules[:drop_trailing_zeros]
-        formatted = formatted.sub(/(#{escaped_decimal_mark})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_decimal_mark}\z/, '')
-      end
-      has_decimal_value = !!(formatted =~ /#{escaped_decimal_mark}/)
+      # Assemble the final formatted amount
+      formatted = [whole_part, decimal_part].compact.join(decimal_mark)
 
-      thousands_separator_value = thousands_separator
-      # Determine thousands_separator
-      if rules.has_key?(:thousands_separator)
-        thousands_separator_value = rules[:thousands_separator] || ''
-      end
+      sign = money.negative? ? '-' : ''
 
-      # Apply thousands_separator
-      formatted.gsub!(regexp_format(formatted, rules, decimal_mark, symbol_value),
-                      "\\1#{thousands_separator_value}")
-
-      symbol_position = symbol_position_from(rules)
-
-      if rules[:sign_positive] == true && self.positive?
+      if rules[:sign_positive] == true && money.positive?
         sign = '+'
       end
 
@@ -266,8 +229,11 @@ class Money
         sign = ''
       end
 
+      symbol_value = symbol_value_from(rules)
+
       if symbol_value && !symbol_value.empty?
         symbol_value = "<span class=\"currency_symbol\">#{symbol_value}</span>" if rules[:html_wrap_symbol]
+        symbol_position = symbol_position_from(rules)
 
         formatted = if symbol_position == :before
           symbol_space = rules[:symbol_before_without_space] === false ? " " : ""
@@ -280,8 +246,6 @@ class Money
         formatted="#{sign_before}#{sign}#{formatted}"
       end
 
-      apply_decimal_mark_from_rules(formatted, rules) if has_decimal_value
-
       if rules[:with_currency]
         formatted << " "
         formatted << '<span class="currency">' if rules[:html]
@@ -292,11 +256,19 @@ class Money
     end
 
     def thousands_separator
-      i18n_format_for(:thousands_separator, :delimiter, ",")
+      if rules.has_key?(:thousands_separator)
+        rules[:thousands_separator] || ''
+      else
+        i18n_format_for(:thousands_separator, :delimiter, ',')
+      end
     end
 
     def decimal_mark
-      i18n_format_for(:decimal_mark, :separator, ".")
+      if rules.has_key?(:decimal_mark)
+        rules[:decimal_mark] || '.'
+      else
+        i18n_format_for(:decimal_mark, :separator, '.')
+      end
     end
 
     alias_method :delimiter, :thousands_separator
@@ -304,8 +276,57 @@ class Money
 
     private
 
+    attr_reader :money, :currency, :rules
+
+    def show_free_text?
+      money.zero? && rules[:display_free]
+    end
+
+    def free_text
+      rules[:display_free].respond_to?(:to_str) ? rules[:display_free] : 'free'
+    end
+
+    def format_whole_part(value)
+      # Determine thousands_separator
+      thousands_separator_value = if rules.has_key?(:thousands_separator)
+                                    rules[:thousands_separator] || ''
+                                  else
+                                    thousands_separator
+                                  end
+
+      # Apply thousands_separator
+      value.gsub regexp_format, "\\1#{thousands_separator_value}"
+    end
+
+    def extract_whole_and_decimal_parts
+      fractional = money.fractional.abs
+
+      # Round the infinite precision part if needed
+      fractional = fractional.round if rules[:rounded_infinite_precision]
+
+      # Translate subunits into units
+      fractional_units = BigDecimal(fractional) / currency.subunit_to_unit
+
+      # Split the result and return whole and decimal parts separately
+      fractional_units.to_s('F').split('.')
+    end
+
+    def format_decimal_part(value)
+      return nil if currency.decimal_places == 0
+      return nil if rules[:no_cents]
+      return nil if rules[:no_cents_if_whole] && value.to_i == 0
+
+      # Pad value, making up for missing zeroes at the end
+      value = value.ljust(currency.decimal_places, '0')
+
+      # Drop trailing zeros if needed
+      value.gsub!(/0*$/, '') if rules[:drop_trailing_zeros]
+
+      value.empty? ? nil : value
+    end
+
     def i18n_format_for(method, name, character)
-      if self.class.use_i18n
+      if Money.use_i18n
         begin
           I18n.t name, :scope => "number.currency.format", :raise => true
         rescue I18n::MissingTranslationData
@@ -316,111 +337,49 @@ class Money
       end
     end
 
-    # Cleans up formatting rules.
-    #
-    # @param [Hash] rules
-    #
-    # @return [Hash]
-    def normalize_formatting_rules(rules)
-      if rules.size == 0
-        rules = {}
-      elsif rules.size == 1
-        rules = rules.pop
-        rules = { rules => true } if rules.is_a?(Symbol)
-      end
-      if !rules.include?(:decimal_mark) && rules.include?(:separator)
-        rules[:decimal_mark] = rules[:separator]
-      end
-      if !rules.include?(:thousands_separator) && rules.include?(:delimiter)
-        rules[:thousands_separator] = rules[:delimiter]
-      end
-      rules
-    end
-
-    # Applies decimal mark from rules to formatted
-    #
-    # @param [String] formatted
-    # @param [Hash]   rules
-    def apply_decimal_mark_from_rules(formatted, rules)
-      if rules.has_key?(:decimal_mark) && rules[:decimal_mark] &&
-        rules[:decimal_mark] != decimal_mark
-
-        regexp_decimal = Regexp.escape(decimal_mark)
-        formatted.sub!(/(.*)(#{regexp_decimal})(.*)\Z/,
-                       "\\1#{rules[:decimal_mark]}\\3")
-      end
-    end
-  end
-
-  def default_formatting_rules
-    self.class.default_formatting_rules || {}
-  end
-
-  def regexp_format(formatted, rules, decimal_mark, symbol_value)
-    regexp_decimal = Regexp.escape(decimal_mark)
-    if rules[:south_asian_number_formatting]
-      /(\d+?)(?=(\d\d)+(\d)(?:\.))/
-    else
-      # Symbols may contain decimal marks (E.g "դր.")
-      if formatted.sub(symbol_value.to_s, "") =~ /#{regexp_decimal}/
-        /(\d)(?=(?:\d{3})+(?:#{regexp_decimal}))/
+    def regexp_format
+      if rules[:south_asian_number_formatting]
+        # from http://blog.revathskumar.com/2014/11/regex-comma-seperated-indian-currency-format.html
+        /(\d+?)(?=(\d\d)+(\d)(?!\d))(\.\d+)?/
       else
         /(\d)(?=(?:\d{3})+(?:[^\d]{1}|$))/
       end
     end
-  end
-
-  def translate_formatting_rules(rules)
-    begin
-      rules[:symbol] = I18n.t currency.iso_code, :scope => "number.currency.symbol", :raise => true
-    rescue I18n::MissingTranslationData
-      # Do nothing
-    end
-    rules
-  end
 
-  def localize_formatting_rules(rules)
-    if currency.iso_code == "JPY" && I18n.locale == :ja
-      rules[:symbol] = "円" unless rules[:symbol] == false
-      rules[:symbol_position] = :after
-      rules[:symbol_after_without_space] = true
-    end
-    rules
-  end
-
-  def symbol_value_from(rules)
-    if rules.has_key?(:symbol)
-      if rules[:symbol] === true
-        if rules[:disambiguate] && currency.disambiguate_symbol
-          currency.disambiguate_symbol
+    def symbol_value_from(rules)
+      if rules.has_key?(:symbol)
+        if rules[:symbol] === true
+          if rules[:disambiguate] && currency.disambiguate_symbol
+            currency.disambiguate_symbol
+          else
+            money.symbol
+          end
+        elsif rules[:symbol]
+          rules[:symbol]
         else
-          symbol
+          ""
         end
-      elsif rules[:symbol]
-        rules[:symbol]
+      elsif rules[:html]
+        currency.html_entity == '' ? currency.symbol : currency.html_entity
+      elsif rules[:disambiguate] && currency.disambiguate_symbol
+        currency.disambiguate_symbol
       else
-        ""
+        money.symbol
       end
-    elsif rules[:html]
-      currency.html_entity == '' ? currency.symbol : currency.html_entity
-    elsif rules[:disambiguate] && currency.disambiguate_symbol
-      currency.disambiguate_symbol
-    else
-      symbol
     end
-  end
 
-  def symbol_position_from(rules)
-    if rules.has_key?(:symbol_position)
-      if [:before, :after].include?(rules[:symbol_position])
-        return rules[:symbol_position]
+    def symbol_position_from(rules)
+      if rules.has_key?(:symbol_position)
+        if [:before, :after].include?(rules[:symbol_position])
+          return rules[:symbol_position]
+        else
+          raise ArgumentError, ":symbol_position must be ':before' or ':after'"
+        end
+      elsif currency.symbol_first?
+        :before
       else
-        raise ArgumentError, ":symbol_position must be ':before' or ':after'"
+        :after
       end
-    elsif currency.symbol_first?
-      :before
-    else
-      :after
     end
   end
 end

data/lib/money/money/formatting_rules.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+
+class Money
+  class FormattingRules
+    def initialize(currency, *raw_rules)
+      @currency = currency
+
+      # support for old format parameters
+      @rules = normalize_formatting_rules(raw_rules)
+
+      @rules = default_formatting_rules.merge(@rules)
+      @rules = localize_formatting_rules(@rules)
+      @rules = translate_formatting_rules(@rules) if @rules[:translate]
+    end
+
+    def [](key)
+      @rules[key]
+    end
+
+    def has_key?(key)
+      @rules.has_key? key
+    end
+
+    private
+
+    attr_reader :currency
+
+    # Cleans up formatting rules.
+    #
+    # @param [Hash] rules
+    #
+    # @return [Hash]
+    def normalize_formatting_rules(rules)
+      if rules.size == 0
+        rules = {}
+      elsif rules.size == 1
+        rules = rules.pop
+        rules = { rules => true } if rules.is_a?(Symbol)
+      end
+      if !rules.include?(:decimal_mark) && rules.include?(:separator)
+        rules[:decimal_mark] = rules[:separator]
+      end
+      if !rules.include?(:thousands_separator) && rules.include?(:delimiter)
+        rules[:thousands_separator] = rules[:delimiter]
+      end
+      rules
+    end
+
+    def default_formatting_rules
+      Money.default_formatting_rules || {}
+    end
+
+    def translate_formatting_rules(rules)
+      begin
+        rules[:symbol] = I18n.t currency.iso_code, :scope => "number.currency.symbol", :raise => true
+      rescue I18n::MissingTranslationData
+        # Do nothing
+      end
+      rules
+    end
+
+    def localize_formatting_rules(rules)
+      if currency.iso_code == "JPY" && I18n.locale == :ja
+        rules[:symbol] = "円" unless rules[:symbol] == false
+        rules[:symbol_position] = :after
+        rules[:symbol_after_without_space] = true
+      end
+      rules
+    end
+  end
+end

data/lib/money/money.rb

@@ -3,7 +3,7 @@ require "money/bank/variable_exchange"
 require "money/bank/single_currency"
 require "money/money/arithmetic"
 require "money/money/constructors"
-require "money/money/formatting"
+require "money/money/formatter"
 
 # "Money is any object or record that is generally accepted as payment for
 # goods and services and repayment of debts in a given socio-economic context
@@ -17,7 +17,6 @@ require "money/money/formatting"
 class Money
   include Comparable
   include Money::Arithmetic
-  include Money::Formatting
   extend Constructors
 
   # Raised when smallest denomination of a currency is not defined
@@ -177,7 +176,7 @@ class Money
   #
   # @example
   #   fee = Money.rounding_mode(BigDecimal::ROUND_HALF_UP) do
-  #     Money.new(1200) * BigDecimal.new('0.029')
+  #     Money.new(1200) * BigDecimal('0.029')
   #   end
   def self.rounding_mode(mode=nil)
     if mode.nil?
@@ -271,7 +270,7 @@ class Money
   # @return [BigDecimal]
   #
   # @example
-  #   Money.new(1_00, "USD").dollars   # => BigDecimal.new("1.00")
+  #   Money.new(1_00, "USD").dollars   # => BigDecimal("1.00")
   #
   # @see #amount
   # @see #to_d
@@ -286,7 +285,7 @@ class Money
   # @return [BigDecimal]
   #
   # @example
-  #   Money.new(1_00, "USD").amount    # => BigDecimal.new("1.00")
+  #   Money.new(1_00, "USD").amount    # => BigDecimal("1.00")
   #
   # @see #to_d
   # @see #fractional
@@ -358,10 +357,10 @@ class Money
             if fraction == ""
               unit
             else
-              "#{unit}#{decimal_mark}#{fraction}"
+              "#{unit}#{currency.decimal_mark}#{fraction}"
             end
           else
-            "#{unit}#{decimal_mark}#{pad_subunit(subunit)}#{fraction}"
+            "#{unit}#{currency.decimal_mark}#{pad_subunit(subunit)}#{fraction}"
           end
 
     fractional < 0 ? "-#{str}" : str
@@ -372,7 +371,7 @@ class Money
   # @return [BigDecimal]
   #
   # @example
-  #   Money.us_dollar(1_00).to_d #=> BigDecimal.new("1.00")
+  #   Money.us_dollar(1_00).to_d #=> BigDecimal("1.00")
   def to_d
     as_d(fractional) / as_d(currency.subunit_to_unit)
   end
@@ -478,22 +477,17 @@ class Money
   # be distributed round-robin amongst the parties. This means that parties
   # listed first will likely receive more pennies than ones that are listed later
   #
-  # @param [Array<Numeric>] splits [0.50, 0.25, 0.25] to give 50% of the cash to party1, 25% to party2, and 25% to party3.
+  # @param [Array<Numeric>] splits [2, 1, 1] to give twice as much to party1 as party2 or party3
+  #   which results in 50% of the cash to party1, 25% to party2, and 25% to party3.
   #
   # @return [Array<Money>]
   #
   # @example
   #   Money.new(5,   "USD").allocate([0.3, 0.7])         #=> [Money.new(2), Money.new(3)]
-  #   Money.new(100, "USD").allocate([0.33, 0.33, 0.33]) #=> [Money.new(34), Money.new(33), Money.new(33)]
+  #   Money.new(100, "USD").allocate([1, 1, 1]) #=> [Money.new(34), Money.new(33), Money.new(33)]
   #
   def allocate(splits)
-    allocations = allocations_from_splits(splits)
-
-    if (allocations - BigDecimal("1")) > Float::EPSILON
-      raise ArgumentError, "splits add to more then 100%"
-    end
-
-    amounts, left_over = amounts_from_splits(allocations, splits)
+    amounts, left_over = amounts_from_splits(splits)
 
     unless self.class.infinite_precision
       delta = left_over > 0 ? 1 : -1
@@ -537,21 +531,47 @@ class Money
   # @see
   #   Money.infinite_precision
   #
-  def round(rounding_mode = self.class.rounding_mode)
+  def round(rounding_mode = self.class.rounding_mode, rounding_precision = 0)
     if self.class.infinite_precision
-      self.class.new(fractional.round(0, rounding_mode), self.currency)
+      self.class.new(fractional.round(rounding_precision, rounding_mode), self.currency)
     else
       self
     end
   end
 
+  # Creates a formatted price string according to several rules.
+  #
+  # @param [Hash] See Money::Formatter for the list of formatting options
+  #
+  # @return [String]
+  #
+  def format(*rules)
+    Money::Formatter.new(self, *rules).to_s
+  end
+
+  # Returns a thousands separator according to the locale
+  #
+  # @return [String]
+  #
+  def thousands_separator
+    Money::Formatter.new(self, {}).thousands_separator
+  end
+
+  # Returns a decimal mark according to the locale
+  #
+  # @return [String]
+  #
+  def decimal_mark
+    Money::Formatter.new(self, {}).decimal_mark
+  end
+
   private
 
   def as_d(num)
     if num.respond_to?(:to_d)
       num.is_a?(Rational) ? num.to_d(self.class.conversion_precision) : num.to_d
     else
-      BigDecimal.new(num.to_s.empty? ? 0 : num.to_s)
+      BigDecimal(num.to_s.empty? ? 0 : num.to_s)
     end
   end
 
@@ -578,16 +598,11 @@ class Money
   end
 
   def pad_subunit(subunit)
-    cnt = currency.decimal_places
-    padding = "0" * cnt
-    "#{padding}#{subunit}"[-1 * cnt, cnt]
-  end
-
-  def allocations_from_splits(splits)
-    splits.inject(0) { |sum, n| sum + n }
+    subunit.rjust(currency.decimal_places, '0')
   end
 
-  def amounts_from_splits(allocations, splits)
+  def amounts_from_splits(splits)
+    allocations = splits.inject(0, :+)
     left_over = fractional
 
     amounts = splits.map do |ratio|

data/lib/money/version.rb

@@ -1,3 +1,3 @@
 class Money
-  VERSION = '6.10.1'
+  VERSION = '6.11.0'
 end

data/money.gemspec

@@ -14,12 +14,12 @@ Gem::Specification.new do |s|
   s.description = "A Ruby Library for dealing with money and currency conversion."
   s.license     = "MIT"
 
-  s.add_dependency 'i18n', [">= 0.6.4", '< 1.0']
+  s.add_dependency 'i18n', [">= 0.6.4", '< 1.1']
 
   s.add_development_dependency "bundler", "~> 1.3"
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec", "~> 3.4.0"
-  s.add_development_dependency "yard", "~> 0.8"
+  s.add_development_dependency "yard", "~> 0.9.11"
   s.add_development_dependency "kramdown", "~> 1.1"
 
   s.files         = `git ls-files`.split($/)

data/spec/currency_spec.rb

@@ -115,6 +115,32 @@ class Money
     end
 
 
+    describe ".inherit" do
+      after do
+        Currency.unregister(iso_code: "XXX") if Currency.find("XXX")
+        Currency.unregister(iso_code: "YYY") if Currency.find("YYY")
+      end
+
+      it "inherit a new currency" do
+        Currency.register(
+          iso_code: "XXX",
+          name: "Golden Doubloon",
+          symbol: "%",
+          subunit_to_unit: 100
+        )
+        Currency.inherit("XXX",
+          iso_code: "YYY",
+          symbol: "@"
+        )
+        new_currency = Currency.find("YYY")
+        expect(new_currency).not_to be_nil
+        expect(new_currency.name).to eq "Golden Doubloon"
+        expect(new_currency.symbol).to eq "@"
+        expect(new_currency.subunit_to_unit).to eq 100
+      end
+    end
+
+
     describe ".unregister" do
       it "unregisters a currency" do
         Currency.register(iso_code: "XXX")

data/spec/money/arithmetic_spec.rb

@@ -12,6 +12,8 @@ describe Money do
       special_money_class = Class.new(Money)
       expect(- special_money_class.new(10_00)).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :-@
   end
 
   describe "#==" do
@@ -49,7 +51,7 @@ describe Money do
     it 'allows comparison with zero' do
       expect(Money.new(0, :usd)).to eq 0
       expect(Money.new(0, :usd)).to eq 0.0
-      expect(Money.new(0, :usd)).to eq BigDecimal.new(0)
+      expect(Money.new(0, :usd)).to eq BigDecimal(0)
       expect(Money.new(1, :usd)).to_not eq 0
     end
 
@@ -215,6 +217,8 @@ describe Money do
       special_money_class = Class.new(Money)
       expect(special_money_class.new(10_00, "USD") + Money.new(90, "USD")).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :+, Money.new(1)
   end
 
   describe "#-" do
@@ -236,6 +240,8 @@ describe Money do
       special_money_class = Class.new(Money)
       expect(special_money_class.new(10_00, "USD") - Money.new(90, "USD")).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :-, Money.new(1)
   end
 
   describe "#*" do
@@ -267,6 +273,8 @@ describe Money do
       special_money_class = Class.new(Money)
       expect(special_money_class.new(10_00, "USD") * 2).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :*, 1
   end
 
   describe "#/" do
@@ -363,6 +371,8 @@ describe Money do
         end
       end
     end
+
+    it_behaves_like 'instance with custom bank', :/, 1
   end
 
   describe "#div" do
@@ -479,6 +489,9 @@ describe Money do
       special_money_class = Class.new(Money)
       expect(special_money_class.new(10_00, "USD").divmod(special_money_class.new(4_00)).last).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :divmod, Money.new(1)
+    it_behaves_like 'instance with custom bank', :divmod, 1
   end
 
   describe "#modulo" do
@@ -571,6 +584,8 @@ describe Money do
         expect(t[:a].remainder(t[:b])).to eq t[:c]
       end
     end
+
+    it_behaves_like 'instance with custom bank', :remainder, -1
   end
 
   describe "#abs" do
@@ -584,6 +599,8 @@ describe Money do
       special_money_class = Class.new(Money)
       expect(special_money_class.new(-1).abs).to be_a special_money_class
     end
+
+    it_behaves_like 'instance with custom bank', :abs
   end
 
   describe "#zero?" do
@@ -637,6 +654,16 @@ describe Money do
       }.to raise_exception(TypeError)
     end
 
+    it "allows subtraction from numeric zero" do
+      result = 0 - Money.new(4, 'USD')
+      expect(result).to eq Money.new(-4, 'USD')
+    end
+
+    it "allows addition from numeric zero" do
+      result = 0 + Money.new(4, 'USD')
+      expect(result).to eq Money.new(4, 'USD')
+    end
+
     it "treats multiplication as commutative" do
       expect {
         2 * Money.new(2, 'USD')

data/spec/money/formatting_spec.rb

@@ -265,7 +265,7 @@ describe Money, "formatting" do
         expect(Money.new(10000, "VUV").format(:no_cents_if_whole => true, :symbol => false)).to eq "10,000"
         expect(Money.new(10034, "VUV").format(:no_cents_if_whole => true, :symbol => false)).to eq "10,034"
         expect(Money.new(10000, "MGA").format(:no_cents_if_whole => true, :symbol => false)).to eq "2,000"
-        expect(Money.new(10034, "MGA").format(:no_cents_if_whole => true, :symbol => false)).to eq "2,006.4"
+        expect(Money.new(10034, "MGA").format(:no_cents_if_whole => true, :symbol => false)).to eq "2,006.8"
         expect(Money.new(10000, "VND").format(:no_cents_if_whole => true, :symbol => false)).to eq "10.000"
         expect(Money.new(10034, "VND").format(:no_cents_if_whole => true, :symbol => false)).to eq "10.034"
         expect(Money.new(10000, "USD").format(:no_cents_if_whole => true, :symbol => false)).to eq "100"
@@ -278,7 +278,7 @@ describe Money, "formatting" do
         expect(Money.new(10000, "VUV").format(:no_cents_if_whole => false, :symbol => false)).to eq "10,000"
         expect(Money.new(10034, "VUV").format(:no_cents_if_whole => false, :symbol => false)).to eq "10,034"
         expect(Money.new(10000, "MGA").format(:no_cents_if_whole => false, :symbol => false)).to eq "2,000.0"
-        expect(Money.new(10034, "MGA").format(:no_cents_if_whole => false, :symbol => false)).to eq "2,006.4"
+        expect(Money.new(10034, "MGA").format(:no_cents_if_whole => false, :symbol => false)).to eq "2,006.8"
         expect(Money.new(10000, "VND").format(:no_cents_if_whole => false, :symbol => false)).to eq "10.000"
         expect(Money.new(10034, "VND").format(:no_cents_if_whole => false, :symbol => false)).to eq "10.034"
         expect(Money.new(10000, "USD").format(:no_cents_if_whole => false, :symbol => false)).to eq "100.00"
@@ -405,6 +405,11 @@ describe Money, "formatting" do
         expect(Money.new(1000000000, 'INDIAN_BAR').format(:south_asian_number_formatting => true, :symbol => false)).to eq "1,00,000.0000"
         expect(Money.new(10000000).format(:south_asian_number_formatting => true)).to eq "$1,00,000.00"
       end
+
+      specify "(:south_asian_number_formatting => true and no_cents_if_whole => true) works as documented" do
+        expect(Money.new(10000000, 'INR').format(:south_asian_number_formatting => true, :symbol => false, :no_cents_if_whole => true)).to eq "1,00,000"
+        expect(Money.new(1000000000, 'INDIAN_BAR').format(:south_asian_number_formatting => true, :symbol => false, :no_cents_if_whole => true)).to eq "1,00,000"
+      end
     end
 
     describe ":thousands_separator option" do
@@ -556,23 +561,23 @@ describe Money, "formatting" do
 
     describe ":rounded_infinite_precision option", :infinite_precision do
       it "does round fractional when set to true" do
-        expect(Money.new(BigDecimal.new('12.1'), "USD").format(:rounded_infinite_precision => true)).to eq "$0.12"
-        expect(Money.new(BigDecimal.new('12.5'), "USD").format(:rounded_infinite_precision => true)).to eq "$0.13"
-        expect(Money.new(BigDecimal.new('123.1'), "BHD").format(:rounded_infinite_precision => true)).to eq "ب.د0.123"
-        expect(Money.new(BigDecimal.new('123.5'), "BHD").format(:rounded_infinite_precision => true)).to eq "ب.د0.124"
-        expect(Money.new(BigDecimal.new('100.1'), "USD").format(:rounded_infinite_precision => true)).to eq "$1.00"
-        expect(Money.new(BigDecimal.new('109.5'), "USD").format(:rounded_infinite_precision => true)).to eq "$1.10"
-        expect(Money.new(BigDecimal.new('1'), "MGA").format(:rounded_infinite_precision => true)).to eq "Ar0.2"
+        expect(Money.new(BigDecimal('12.1'), "USD").format(:rounded_infinite_precision => true)).to eq "$0.12"
+        expect(Money.new(BigDecimal('12.5'), "USD").format(:rounded_infinite_precision => true)).to eq "$0.13"
+        expect(Money.new(BigDecimal('123.1'), "BHD").format(:rounded_infinite_precision => true)).to eq "ب.د0.123"
+        expect(Money.new(BigDecimal('123.5'), "BHD").format(:rounded_infinite_precision => true)).to eq "ب.د0.124"
+        expect(Money.new(BigDecimal('100.1'), "USD").format(:rounded_infinite_precision => true)).to eq "$1.00"
+        expect(Money.new(BigDecimal('109.5'), "USD").format(:rounded_infinite_precision => true)).to eq "$1.10"
+        expect(Money.new(BigDecimal('1.7'), "MGA").format(:rounded_infinite_precision => true)).to eq "Ar0.4"
       end
 
       it "does not round fractional when set to false" do
-        expect(Money.new(BigDecimal.new('12.1'), "USD").format(:rounded_infinite_precision => false)).to eq "$0.121"
-        expect(Money.new(BigDecimal.new('12.5'), "USD").format(:rounded_infinite_precision => false)).to eq "$0.125"
-        expect(Money.new(BigDecimal.new('123.1'), "BHD").format(:rounded_infinite_precision => false)).to eq "ب.د0.1231"
-        expect(Money.new(BigDecimal.new('123.5'), "BHD").format(:rounded_infinite_precision => false)).to eq "ب.د0.1235"
-        expect(Money.new(BigDecimal.new('100.1'), "USD").format(:rounded_infinite_precision => false)).to eq "$1.001"
-        expect(Money.new(BigDecimal.new('109.5'), "USD").format(:rounded_infinite_precision => false)).to eq "$1.095"
-        expect(Money.new(BigDecimal.new('1'), "MGA").format(:rounded_infinite_precision => false)).to eq "Ar0.1"
+        expect(Money.new(BigDecimal('12.1'), "USD").format(:rounded_infinite_precision => false)).to eq "$0.121"
+        expect(Money.new(BigDecimal('12.5'), "USD").format(:rounded_infinite_precision => false)).to eq "$0.125"
+        expect(Money.new(BigDecimal('123.1'), "BHD").format(:rounded_infinite_precision => false)).to eq "ب.د0.1231"
+        expect(Money.new(BigDecimal('123.5'), "BHD").format(:rounded_infinite_precision => false)).to eq "ب.د0.1235"
+        expect(Money.new(BigDecimal('100.1'), "USD").format(:rounded_infinite_precision => false)).to eq "$1.001"
+        expect(Money.new(BigDecimal('109.5'), "USD").format(:rounded_infinite_precision => false)).to eq "$1.095"
+        expect(Money.new(BigDecimal('1.7'), "MGA").format(:rounded_infinite_precision => false)).to eq "Ar0.34"
       end
 
       describe "with i18n = false" do
@@ -585,13 +590,13 @@ describe Money, "formatting" do
         end
 
         it 'does round fractional when set to true' do
-          expect(Money.new(BigDecimal.new('12.1'), "EUR").format(:rounded_infinite_precision => true)).to eq "€0,12"
-          expect(Money.new(BigDecimal.new('12.5'), "EUR").format(:rounded_infinite_precision => true)).to eq "€0,13"
-          expect(Money.new(BigDecimal.new('100.1'), "EUR").format(:rounded_infinite_precision => true)).to eq "€1,00"
-          expect(Money.new(BigDecimal.new('109.5'), "EUR").format(:rounded_infinite_precision => true)).to eq "€1,10"
+          expect(Money.new(BigDecimal('12.1'), "EUR").format(:rounded_infinite_precision => true)).to eq "€0,12"
+          expect(Money.new(BigDecimal('12.5'), "EUR").format(:rounded_infinite_precision => true)).to eq "€0,13"
+          expect(Money.new(BigDecimal('100.1'), "EUR").format(:rounded_infinite_precision => true)).to eq "€1,00"
+          expect(Money.new(BigDecimal('109.5'), "EUR").format(:rounded_infinite_precision => true)).to eq "€1,10"
 
-          expect(Money.new(BigDecimal.new('100012.1'), "EUR").format(:rounded_infinite_precision => true)).to eq "€1.000,12"
-          expect(Money.new(BigDecimal.new('100012.5'), "EUR").format(:rounded_infinite_precision => true)).to eq "€1.000,13"
+          expect(Money.new(BigDecimal('100012.1'), "EUR").format(:rounded_infinite_precision => true)).to eq "€1.000,12"
+          expect(Money.new(BigDecimal('100012.5'), "EUR").format(:rounded_infinite_precision => true)).to eq "€1.000,13"
         end
       end
 
@@ -612,13 +617,13 @@ describe Money, "formatting" do
         end
 
         it 'does round fractional when set to true' do
-          expect(Money.new(BigDecimal.new('12.1'), "USD").format(:rounded_infinite_precision => true)).to eq "$0,12"
-          expect(Money.new(BigDecimal.new('12.5'), "USD").format(:rounded_infinite_precision => true)).to eq "$0,13"
-          expect(Money.new(BigDecimal.new('123.1'), "BHD").format(:rounded_infinite_precision => true)).to eq "ب.د0,123"
-          expect(Money.new(BigDecimal.new('123.5'), "BHD").format(:rounded_infinite_precision => true)).to eq "ب.د0,124"
-          expect(Money.new(BigDecimal.new('100.1'), "USD").format(:rounded_infinite_precision => true)).to eq "$1,00"
-          expect(Money.new(BigDecimal.new('109.5'), "USD").format(:rounded_infinite_precision => true)).to eq "$1,10"
-          expect(Money.new(BigDecimal.new('1'), "MGA").format(:rounded_infinite_precision => true)).to eq "Ar0,2"
+          expect(Money.new(BigDecimal('12.1'), "USD").format(:rounded_infinite_precision => true)).to eq "$0,12"
+          expect(Money.new(BigDecimal('12.5'), "USD").format(:rounded_infinite_precision => true)).to eq "$0,13"
+          expect(Money.new(BigDecimal('123.1'), "BHD").format(:rounded_infinite_precision => true)).to eq "ب.د0,123"
+          expect(Money.new(BigDecimal('123.5'), "BHD").format(:rounded_infinite_precision => true)).to eq "ب.د0,124"
+          expect(Money.new(BigDecimal('100.1'), "USD").format(:rounded_infinite_precision => true)).to eq "$1,00"
+          expect(Money.new(BigDecimal('109.5'), "USD").format(:rounded_infinite_precision => true)).to eq "$1,10"
+          expect(Money.new(BigDecimal('1'), "MGA").format(:rounded_infinite_precision => true)).to eq "Ar0,2"
         end
       end
     end

data/spec/money_spec.rb

@@ -591,6 +591,18 @@ YAML
       expect(moneys[1]).to eq Money.us_dollar(3)
     end
 
+    it "handles small splits" do
+      moneys = Money.us_dollar(5).allocate([0.03, 0.07])
+      expect(moneys[0]).to eq Money.us_dollar(2)
+      expect(moneys[1]).to eq Money.us_dollar(3)
+    end
+
+    it "handles large splits" do
+      moneys = Money.us_dollar(5).allocate([3, 7])
+      expect(moneys[0]).to eq Money.us_dollar(2)
+      expect(moneys[1]).to eq Money.us_dollar(3)
+    end
+
     it "does not lose pennies" do
       moneys = Money.us_dollar(100).allocate([0.333, 0.333, 0.333])
       expect(moneys[0].cents).to eq 34
@@ -607,7 +619,7 @@ YAML
     end
 
     it "handles mixed split types" do
-      splits = [Rational(1, 4), 0.25, 0.25, BigDecimal.new('0.25')]
+      splits = [Rational(1, 4), 0.25, 0.25, BigDecimal('0.25')]
       moneys = Money.us_dollar(100).allocate(splits)
       moneys.each do |money|
         expect(money.cents).to eq 25
@@ -618,9 +630,9 @@ YAML
       it "does not lose pennies" do
         moneys = Money.us_dollar(-100).allocate([0.333, 0.333, 0.333])
 
-        expect(moneys[0].cents).to eq -34
-        expect(moneys[1].cents).to eq -33
-        expect(moneys[2].cents).to eq -33
+        expect(moneys[0].cents).to eq(-34)
+        expect(moneys[1].cents).to eq(-33)
+        expect(moneys[2].cents).to eq(-33)
       end
 
       it "allocates the same way as positive amounts" do
@@ -631,10 +643,6 @@ YAML
       end
     end
 
-    it "requires total to be less then 1" do
-      expect { Money.us_dollar(0.05).allocate([0.5, 0.6]) }.to raise_error(ArgumentError)
-    end
-
     it "keeps subclasses intact" do
       special_money_class = Class.new(Money)
       expect(special_money_class.new(005).allocate([1]).first).to be_a special_money_class
@@ -733,6 +741,15 @@ YAML
           expect(rounded).to be_a special_money_class
         end
       end
+
+      context "when using a specific rounding precision" do
+        let(:money) { Money.new(15.7526, 'NZD') }
+
+        it "uses the provided rounding precision" do
+          rounded = money.round(BigDecimal::ROUND_DOWN, 3)
+          expect(rounded.fractional).to eq 15.752
+        end
+      end
     end
   end
 

data/spec/spec_helper.rb

@@ -5,6 +5,8 @@ $LOAD_PATH.unshift File.dirname(__FILE__)
 require "rspec"
 require "money"
 
+Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
+
 I18n.enforce_available_locales = false
 
 RSpec.configure do |c|

data/spec/support/shared_examples/money_examples.rb

@@ -0,0 +1,14 @@
+RSpec.shared_examples 'instance with custom bank' do |operation, value|
+  let(:custom_bank) { Money::Bank::VariableExchange.new }
+  let(:instance) { Money.new(1, :usd, custom_bank) }
+
+  subject { value ? instance.send(operation, value) : instance.send(operation) }
+
+  it "returns custom bank from new instance" do
+    new_money_instances = Array(subject).select { |el| el.is_a?(Money) }
+
+    new_money_instances.each do |money_instance|
+      expect(money_instance.bank).to eq(custom_bank)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: money
 version: !ruby/object:Gem::Version
-  version: 6.10.1
+  version: 6.11.0
 platform: ruby
 authors:
 - Shane Emmons
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-15 00:00:00.000000000 Z
+date: 2018-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -19,7 +19,7 @@ dependencies:
         version: 0.6.4
     - - "<"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: 0.6.4
     - - "<"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -78,14 +78,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.9.11
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.9.11
 - !ruby/object:Gem::Dependency
   name: kramdown
   requirement: !ruby/object:Gem::Requirement
@@ -131,7 +131,8 @@ files:
 - lib/money/money.rb
 - lib/money/money/arithmetic.rb
 - lib/money/money/constructors.rb
-- lib/money/money/formatting.rb
+- lib/money/money/formatter.rb
+- lib/money/money/formatting_rules.rb
 - lib/money/rates_store/memory.rb
 - lib/money/version.rb
 - money.gemspec
@@ -147,6 +148,7 @@ files:
 - spec/money_spec.rb
 - spec/rates_store/memory_spec.rb
 - spec/spec_helper.rb
+- spec/support/shared_examples/money_examples.rb
 homepage: https://rubymoney.github.io/money
 licenses:
 - MIT
@@ -184,3 +186,4 @@ test_files:
 - spec/money_spec.rb
 - spec/rates_store/memory_spec.rb
 - spec/spec_helper.rb
+- spec/support/shared_examples/money_examples.rb