money 6.11.3 → 6.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1676f3c1841250eb391b20a12e2ae1701455c87b
-  data.tar.gz: c0ed79f93a51427b43c6af3bd3094219dbd69fe8
+  metadata.gz: 833d36d87efd793fa9e73986df700da145b59578
+  data.tar.gz: 5fae93b474a739c79e45c18e45b3d652c4f1d4d6
 SHA512:
-  metadata.gz: cb4a7fa2426f81cfc97fa07e983f12a4427ed891f2f6e2403865e58011c61ecd2244d12c2294d858f731707ae96b41a31e9bfbeb61b49006532bfb881fc6a190
-  data.tar.gz: ffaf8bc1eb9cb35d5c5d2017c5f4483d4b8b6ab1decc01ea0803fbb101ef053c3df4f37c8c4706ab7b6c5606aa5e3b8531fcfb9eeef4a626d29d715400b1ff40
+  metadata.gz: 77560afc19c7447c654daa551924ee3a0cd84e17a880d64b9d012aefda8fabc23ea100ad229278937817025f986839d9c6112c04cd8b1ee862ca0faf02fe9b4c
+  data.tar.gz: 8c126aadb1cd5beedff854a8353a46a423296ceccdc8e1f72b7c65016937df8cb643c78c735fa87327bb41838ff12a76919a561e35ad5d3cb3eeca2573b5f526

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 6.12.0
+- Remove caching of `.empty`/`.zero`
+- Preserve assigned bank when rounding
+- Always round the fractional part when calling `#round`
+- Wrap all amount parts when `:html_wrap` option is used
+- Deprecate `#currency_as_string` and `#currency_as_string=` (in favour of `#with_currency`)
+- Add `#with_currency` for swapping the currency
+- Rewrite allocate/split (fixing some penny loosing issues)
+
 ## 6.11.3
 - Fix regression: if enabled use i18n locales in Money#to_s
 

data/README.md

@@ -88,6 +88,9 @@ Money.from_amount(5, "TND") == Money.new(5000, "TND") # 5 TND
 some_code_to_setup_exchange_rates
 Money.new(1000, "USD").exchange_to("EUR") == Money.new(some_value, "EUR")
 
+# Swap currency
+Money.new(1000, "USD").with_currency("EUR") == Money.new(1000, "EUR")
+
 # Formatting (see Formatting section for more options)
 Money.new(100, "USD").format #=> "$1.00"
 Money.new(100, "GBP").format #=> "£1.00"

data/lib/money/money.rb

@@ -4,6 +4,7 @@ require "money/bank/single_currency"
 require "money/money/arithmetic"
 require "money/money/constructors"
 require "money/money/formatter"
+require "money/money/allocation"
 
 # "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
@@ -227,7 +228,8 @@ class Money
   #
   # @see #initialize
   def self.from_amount(amount, currency = default_currency, bank = default_bank)
-    Numeric === amount or raise ArgumentError, "'amount' must be numeric"
+    raise ArgumentError, "'amount' must be numeric" unless Numeric === amount
+
     currency = Currency.wrap(currency) || Money.default_currency
     value = amount.to_d * currency.subunit_to_unit
     value = value.round(0, rounding_mode) unless infinite_precision
@@ -301,6 +303,7 @@ class Money
   # @example
   #   Money.new(100, :USD).currency_as_string #=> "USD"
   def currency_as_string
+    warn "[DEPRECATION] `currency_as_string` is deprecated. Please use `.currency.to_s` instead."
     currency.to_s
   end
 
@@ -313,6 +316,8 @@ class Money
   # @example
   #   Money.new(100).currency_as_string("CAD") #=> #<Money::Currency id: cad>
   def currency_as_string=(val)
+    warn "[DEPRECATION] `currency_as_string=` is deprecated - Money instances are immutable." \
+      " Please use `with_currency` instead."
     @currency = Currency.wrap(val)
   end
 
@@ -390,7 +395,22 @@ class Money
     to_d.to_f
   end
 
-  # Conversation to +self+.
+  # Returns a new Money instance in a given currency leaving the amount intact
+  # and not performing currency conversion.
+  #
+  # @param [Currency, String, Symbol] new_currency Currency of the new object.
+  #
+  # @return [self]
+  def with_currency(new_currency)
+    new_currency = Currency.wrap(new_currency)
+    if !new_currency || currency == new_currency
+      self
+    else
+      self.class.new(fractional, new_currency, bank)
+    end
+  end
+
+  # Conversion to +self+.
   #
   # @return [self]
   def to_money(given_currency = nil)
@@ -463,49 +483,27 @@ class Money
     exchange_to("EUR")
   end
 
-  # Allocates money between different parties without losing pennies.
-  # After the mathematical split has been performed, leftover pennies will
-  # be distributed round-robin amongst the parties. This means that parties
-  # listed first will likely receive more pennies than ones that are listed later
+  # Splits a given amount in parts without loosing pennies. The left-over pennies will 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 [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.
+  # @param [Array<Numeric>, Numeric] pass [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. Passing a
+  # number instead of an array will split the amount evenly (without loosing pennies when rounding).
   #
   # @return [Array<Money>]
   #
   # @example
-  #   Money.new(5,   "USD").allocate([0.3, 0.7])         #=> [Money.new(2), Money.new(3)]
+  #   Money.new(5,   "USD").allocate([3, 7]) #=> [Money.new(2), Money.new(3)]
   #   Money.new(100, "USD").allocate([1, 1, 1]) #=> [Money.new(34), Money.new(33), Money.new(33)]
+  #   Money.new(100, "USD").allocate(2) #=> [Money.new(50), Money.new(50)]
+  #   Money.new(100, "USD").allocate(3) #=> [Money.new(34), Money.new(33), Money.new(33)]
   #
-  def allocate(splits)
-    amounts, left_over = amounts_from_splits(splits)
-
-    unless self.class.infinite_precision
-      delta = left_over > 0 ? 1 : -1
-      # Distribute left over pennies amongst allocations
-      left_over.to_i.abs.times { |i| amounts[i % amounts.length] += delta }
-    end
-
-    amounts.collect { |fractional| self.class.new(fractional, currency) }
-  end
-
-  # Split money amongst parties evenly without losing pennies.
-  #
-  # @param [Numeric] num number of parties.
-  #
-  # @return [Array<Money>]
-  #
-  # @example
-  #   Money.new(100, "USD").split(3) #=> [Money.new(34), Money.new(33), Money.new(33)]
-  def split(num)
-    raise ArgumentError, "need at least one party" if num < 1
-
-    if self.class.infinite_precision
-      split_infinite(num)
-    else
-      split_flat(num)
-    end
+  def allocate(parts)
+    amounts = Money::Allocation.generate(fractional, parts, !Money.infinite_precision)
+    amounts.map { |amount| self.class.new(amount, currency) }
   end
+  alias_method :split, :allocate
 
   # Round the monetary amount to smallest unit of coinage.
   #
@@ -523,11 +521,8 @@ class Money
   #   Money.infinite_precision
   #
   def round(rounding_mode = self.class.rounding_mode, rounding_precision = 0)
-    if self.class.infinite_precision
-      self.class.new(fractional.round(rounding_precision, rounding_mode), self.currency)
-    else
-      self
-    end
+    rounded_amount = as_d(@fractional).round(rounding_precision, rounding_mode)
+    self.class.new(rounded_amount, currency, bank)
   end
 
   # Creates a formatted price string according to several rules.
@@ -566,39 +561,6 @@ class Money
     end
   end
 
-  def amounts_from_splits(splits)
-    allocations = splits.inject(0, :+)
-    left_over = fractional
-
-    amounts = splits.map do |ratio|
-      if self.class.infinite_precision
-        fractional * ratio
-      else
-        (fractional * ratio / allocations).truncate.tap do |frac|
-          left_over -= frac
-        end
-      end
-    end
-
-    [amounts, left_over]
-  end
-
-  def split_infinite(num)
-    amt = div(as_d(num))
-    1.upto(num).map{amt}
-  end
-
-  def split_flat(num)
-    low = self.class.new(fractional / num, currency)
-    high = self.class.new(low.fractional + 1, currency)
-
-    remainder = fractional % num
-
-    Array.new(num).each_with_index.map do |_, index|
-      index < remainder ? high : low
-    end
-  end
-
   def return_value(value)
     if self.class.infinite_precision
       value

data/lib/money/money/allocation.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+class Money
+  class Allocation
+    # Splits a given amount in parts without loosing pennies.
+    # The left-over pennies will be distributed round-robin amongst the parties. This means that
+    # parties listed first will likely receive more pennies than ones that are listed later.
+    #
+    # The results should always add up to the original amount.
+    #
+    # The parts can be specified as:
+    #   Numeric — performs the split between a given number of parties evenely
+    #   Array<Numeric> — allocates the amounts proportionally to the given array
+    #
+    def self.generate(amount, parts, whole_amounts = true)
+      parts = parts.is_a?(Numeric) ? Array.new(parts, 1) : parts.dup
+
+      raise ArgumentError, 'need at least one party' if parts.empty?
+
+      result = []
+      remaining_amount = amount
+
+      until parts.empty? do
+        parts_sum = parts.inject(0, :+)
+        part = parts.pop
+
+        current_split = remaining_amount * part / parts_sum
+        current_split = current_split.truncate if whole_amounts
+
+        result.unshift current_split
+        remaining_amount -= current_split
+      end
+
+      result
+    end
+  end
+end

data/lib/money/money/constructors.rb

@@ -10,9 +10,7 @@ class Money
     # @example
     #   Money.empty #=> #<Money @fractional=0>
     def empty(currency = default_currency)
-      @empty ||= {}
-      currency = Currency.new(currency)
-      @empty[currency] ||= new(0, currency).freeze
+      new(0, currency)
     end
     alias_method :zero, :empty
 

data/lib/money/money/formatter.rb

@@ -138,6 +138,12 @@ class Money
     #   Money.ca_dollar(570).format(html: true, with_currency: true)
     #   #=> "$5.70 <span class=\"currency\">CAD</span>"
     #
+    # @option rules [Boolean] :html_wrap (false) Whether all currency parts should be HTML-formatted.
+    #
+    # @example
+    #   Money.ca_dollar(570).format(html_wrap: true, with_currency: true)
+    #   #=> "<span class=\"money-currency-symbol\">$</span><span class=\"money-whole\">5</span><span class=\"money-decimal-mark\">.</span><span class=\"money-decimal\">70</span> <span class=\"money-currency\">CAD</span>"
+    #
     # @option rules [Boolean] :sign_before_symbol (false) Whether the sign should be
     #  before the currency symbol.
     #
@@ -209,6 +215,14 @@ class Money
     def to_s
       return free_text if show_free_text?
 
+      if rules[:html]
+        warn "[DEPRECATION] `html` is deprecated - use `html_wrap` instead. Please note that `html_wrap` will wrap all parts of currency and if you use `with_currency` option, currency element class changes from `currency` to `money-currency`."
+      end
+
+      if rules[:html_wrap_symbol]
+        warn "[DEPRECATION] `html_wrap_symbol` is deprecated - use `html_wrap` instead. Please note that `html_wrap` will wrap all parts of currency."
+      end
+
       whole_part, decimal_part = extract_whole_and_decimal_parts
 
       # Format whole and decimal parts separately
@@ -216,7 +230,15 @@ class Money
       whole_part = format_whole_part(whole_part)
 
       # Assemble the final formatted amount
-      formatted = [whole_part, decimal_part].compact.join(decimal_mark)
+      formatted = if rules[:html_wrap]
+        if decimal_part.nil?
+          html_wrap(whole_part, "whole")
+        else
+          [html_wrap(whole_part, "whole"), html_wrap(decimal_mark, "decimal-mark"), html_wrap(decimal_part, "decimal")].join
+        end
+      else
+        [whole_part, decimal_part].compact.join(decimal_mark)
+      end
 
       sign = money.negative? ? '-' : ''
 
@@ -232,7 +254,11 @@ class Money
       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]
+        if rules[:html_wrap_symbol]
+          symbol_value = "<span class=\"currency_symbol\">#{symbol_value}</span>"
+        elsif rules[:html_wrap]
+          symbol_value = html_wrap(symbol_value, "currency-symbol")
+        end
         symbol_position = symbol_position_from(rules)
 
         formatted = if symbol_position == :before
@@ -248,9 +274,14 @@ class Money
 
       if rules[:with_currency]
         formatted << " "
-        formatted << '<span class="currency">' if rules[:html]
-        formatted << currency.to_s
-        formatted << '</span>' if rules[:html]
+
+        if rules[:html]
+          formatted << "<span class=\"currency\">#{currency.to_s}</span>"
+        elsif rules[:html_wrap]
+          formatted << html_wrap(currency.to_s, "currency")
+        else
+          formatted << currency.to_s
+        end
       end
       formatted
     end
@@ -282,6 +313,10 @@ class Money
       money.zero? && rules[:display_free]
     end
 
+    def html_wrap(string, class_name)
+      "<span class=\"money-#{class_name}\">#{string}</span>"
+    end
+
     def free_text
       rules[:display_free].respond_to?(:to_str) ? rules[:display_free] : 'free'
     end
@@ -359,7 +394,7 @@ class Money
         else
           ""
         end
-      elsif rules[:html]
+      elsif rules[:html] || rules[:html_wrap]
         currency.html_entity == '' ? currency.symbol : currency.html_entity
       elsif rules[:disambiguate] && currency.disambiguate_symbol
         currency.disambiguate_symbol

data/lib/money/version.rb

@@ -1,3 +1,3 @@
 class Money
-  VERSION = '6.11.3'
+  VERSION = '6.12.0'
 end

data/spec/money/allocation_spec.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+describe Money::Allocation do
+  describe 'given number as argument' do
+    it 'raises an error when invalid argument is given' do
+      expect { described_class.generate(100, 0) }.to raise_error(ArgumentError)
+      expect { described_class.generate(100, -1) }.to raise_error(ArgumentError)
+    end
+
+    context 'whole amounts' do
+      it 'returns the amount when 1 is given' do
+        expect(described_class.generate(100, 1)).to eq([100])
+      end
+
+      it 'splits the amount into equal parts' do
+        expect(described_class.generate(100, 2)).to eq([50, 50])
+        expect(described_class.generate(100, 4)).to eq([25, 25, 25, 25])
+        expect(described_class.generate(100, 5)).to eq([20, 20, 20, 20, 20])
+      end
+
+      it 'does not loose pennies' do
+        expect(described_class.generate(5, 2)).to eq([3, 2])
+        expect(described_class.generate(2, 3)).to eq([1, 1, 0])
+        expect(described_class.generate(100, 3)).to eq([34, 33, 33])
+        expect(described_class.generate(100, 6)).to eq([17, 17, 17, 17, 16, 16])
+      end
+    end
+
+    context 'fractional amounts' do
+      it 'returns the amount when 1 is given' do
+        expect(described_class.generate(BigDecimal(100), 1, false)).to eq([BigDecimal(100)])
+      end
+
+      it 'splits the amount into equal parts' do
+        expect(described_class.generate(BigDecimal(100), 2, false)).to eq([50, 50])
+        expect(described_class.generate(BigDecimal(100), 4, false)).to eq([25, 25, 25, 25])
+        expect(described_class.generate(BigDecimal(100), 5, false)).to eq([20, 20, 20, 20, 20])
+      end
+
+      it 'splits the amount into equal fractions' do
+        expect(described_class.generate(BigDecimal(5), 2, false)).to eq([2.5, 2.5])
+        expect(described_class.generate(BigDecimal(5), 4, false)).to eq([1.25, 1.25, 1.25, 1.25])
+      end
+
+      it 'handles splits into repeating decimals' do
+        amount = BigDecimal(100)
+        parts = described_class.generate(amount, 3, false)
+
+        # Rounding due to inconsistent BigDecimal size in ruby compared to jruby. In reality the
+        # first 2 elements will look like the last one with a '5' at the end, compensating for a
+        # missing fraction
+        expect(parts.map { |x| x.round(10) }).to eq([
+          BigDecimal('33.3333333333'),
+          BigDecimal('33.3333333333'),
+          BigDecimal('33.3333333333')
+        ])
+        expect(parts.inject(0, :+)).to eq(amount)
+      end
+    end
+  end
+
+  describe 'given array as argument' do
+    it 'raises an error when invalid argument is given' do
+      expect { described_class.generate(100, []) }.to raise_error(ArgumentError)
+    end
+
+    context 'whole amounts' do
+      it 'returns the amount when array contains only one element' do
+        expect(described_class.generate(100, [1])).to eq([100])
+        expect(described_class.generate(100, [5])).to eq([100])
+      end
+
+      it 'splits the amount into whole parts respecting the order' do
+        expect(described_class.generate(100, [1, 1])).to eq([50, 50])
+        expect(described_class.generate(100, [1, 1, 2])).to eq([25, 25, 50])
+        expect(described_class.generate(100, [7, 3])).to eq([70, 30])
+      end
+
+      it 'accepts floats as arguments' do
+        expect(described_class.generate(100, [1.0, 1.0])).to eq([50, 50])
+        expect(described_class.generate(100, [0.1, 0.1, 0.2])).to eq([25, 25, 50])
+        expect(described_class.generate(100, [0.07, 0.03])).to eq([70, 30])
+        expect(described_class.generate(10, [0.1, 0.2, 0.1])).to eq([3, 5, 2])
+      end
+
+      it 'does not loose pennies' do
+        expect(described_class.generate(10, [1, 1, 2])).to eq([3, 2, 5])
+        expect(described_class.generate(100, [1, 1, 1])).to eq([34, 33, 33])
+      end
+    end
+
+    context 'fractional amounts' do
+      it 'returns the amount when array contains only one element' do
+        expect(described_class.generate(BigDecimal(100), [1], false)).to eq([100])
+        expect(described_class.generate(BigDecimal(100), [5], false)).to eq([100])
+      end
+
+      it 'splits the amount into whole parts respecting the order' do
+        expect(described_class.generate(BigDecimal(100), [1, 1], false)).to eq([50, 50])
+        expect(described_class.generate(BigDecimal(100), [1, 1, 2], false)).to eq([25, 25, 50])
+        expect(described_class.generate(BigDecimal(100), [7, 3], false)).to eq([70, 30])
+      end
+
+      it 'splits the amount proportionally to the given parts' do
+        expect(described_class.generate(BigDecimal(10), [1, 1, 2], false)).to eq([2.5, 2.5, 5])
+        expect(described_class.generate(BigDecimal(7), [1, 1], false)).to eq([3.5, 3.5])
+      end
+
+      it 'keeps the class of the splits the same as given amount' do
+        # Note that whole_amount is false but result is whole values
+        expect(described_class.generate(10, [1, 1, 2], false)).to eq([3, 2, 5])
+      end
+
+      it 'handles splits into repeating decimals' do
+        amount = BigDecimal(100)
+        parts = described_class.generate(amount, [1, 1, 1], false)
+
+        # Rounding due to inconsistent BigDecimal size in ruby compared to jruby. In reality the
+        # first 2 elements will look like the last one with a '5' at the end, compensating for a
+        # missing fraction
+        expect(parts.map { |x| x.round(10) }).to eq([
+          BigDecimal('33.3333333333'),
+          BigDecimal('33.3333333333'),
+          BigDecimal('33.3333333333')
+        ])
+        expect(parts.inject(0, :+)).to eq(amount)
+      end
+    end
+  end
+end

data/spec/money/constructors_spec.rb

@@ -7,26 +7,6 @@ describe Money::Constructors do
       expect(Money.empty).to eq Money.new(0)
     end
 
-    it "memoizes the result" do
-      expect(Money.empty.object_id).to eq Money.empty.object_id
-    end
-
-    it "memoizes a result for each currency" do
-      expect(Money.empty(:cad).object_id).to eq Money.empty(:cad).object_id
-    end
-
-    it "doesn't allow money to be modified for a currency" do
-      expect(Money.empty).to be_frozen
-    end
-
-    it "always use Currency object to memoize Money objects" do
-      Money.instance_variable_set(:@empty, {})
-      expect {
-        Money.zero(:usd)
-        Money.zero
-      }.to_not raise_error
-    end
-
     it "instantiates a subclass when inheritance is used" do
       special_money_class = Class.new(Money)
       expect(special_money_class.empty).to be_a special_money_class

data/spec/money/formatting_spec.rb

@@ -268,6 +268,12 @@ describe Money, "formatting" do
         output = money.format(html: true, no_cents: true)
         expect(output).to eq "19 ₽"
       end
+
+      it "doesn't incorrectly format HTML (html_wrap)" do
+        money = ::Money.new(1999, "RUB")
+        output = money.format(html_wrap: true, no_cents: true)
+        expect(output).to eq "<span class=\"money-whole\">19</span> <span class=\"money-currency-symbol\">&#x20BD;</span>"
+      end
     end
 
     describe ":no_cents_if_whole option" do
@@ -488,6 +494,23 @@ describe Money, "formatting" do
       end
     end
 
+    describe ":html_wrap option" do
+      specify "(html_wrap: true) works as documented" do
+        string = Money.ca_dollar(570).format(html_wrap: true)
+        expect(string).to eq "<span class=\"money-currency-symbol\">$</span><span class=\"money-whole\">5</span><span class=\"money-decimal-mark\">.</span><span class=\"money-decimal\">70</span>"
+      end
+
+      specify "(html_wrap: true, with_currency: true)" do
+        string = Money.ca_dollar(570).format(html_wrap: true, with_currency: true)
+        expect(string).to eq "<span class=\"money-currency-symbol\">$</span><span class=\"money-whole\">5</span><span class=\"money-decimal-mark\">.</span><span class=\"money-decimal\">70</span> <span class=\"money-currency\">CAD</span>"
+      end
+
+      specify "should fallback to symbol if entity is not available" do
+        string = Money.new(570, 'DKK').format(html_wrap: true)
+        expect(string).to eq "<span class=\"money-whole\">5</span><span class=\"money-decimal-mark\">,</span><span class=\"money-decimal\">70</span> <span class=\"money-currency-symbol\">kr.</span>"
+      end
+    end
+
     describe ":symbol_position option" do
       it "inserts currency symbol before the amount when set to :before" do
         expect(Money.euro(1_234_567_12).format(symbol_position: :before)).to eq "€1.234.567,12"

data/spec/money_spec.rb

@@ -568,6 +568,25 @@ YAML
     end
   end
 
+  describe "#with_currency" do
+    it 'returns self if currency is the same' do
+      money = Money.new(10_00, 'USD')
+
+      expect(money.with_currency('USD')).to eq(money)
+      expect(money.with_currency('USD').object_id).to eq(money.object_id)
+    end
+
+    it 'returns a new instance in a given currency' do
+      money = Money.new(10_00, 'USD')
+      new_money = money.with_currency('EUR')
+
+      expect(new_money).to eq(Money.new(10_00, 'EUR'))
+      expect(money.fractional).to eq(new_money.fractional)
+      expect(money.bank).to eq(new_money.bank)
+      expect(money.object_id).not_to eq(new_money.object_id)
+    end
+  end
+
   describe "#exchange_to" do
     it "exchanges the amount via its exchange bank" do
       money = Money.new(100_00, "USD")
@@ -668,12 +687,8 @@ YAML
 
     context "with infinite_precision", :infinite_precision do
       it "allows for fractional cents allocation" do
-        one_third = BigDecimal("1") / BigDecimal("3")
-
-        moneys = Money.new(100).allocate([one_third, one_third, one_third])
-        expect(moneys[0].cents).to eq one_third * BigDecimal("100")
-        expect(moneys[1].cents).to eq one_third * BigDecimal("100")
-        expect(moneys[2].cents).to eq one_third * BigDecimal("100")
+        moneys = Money.new(100).allocate([1, 1, 1])
+        expect(moneys.inject(0, :+)).to eq(Money.new(100))
       end
     end
   end
@@ -710,27 +725,40 @@ YAML
 
     context "with infinite_precision", :infinite_precision do
       it "allows for splitting by fractional cents" do
-        thirty_three_and_one_third = BigDecimal("100") / BigDecimal("3")
-
         moneys = Money.new(100).split(3)
-        expect(moneys[0].cents).to eq thirty_three_and_one_third
-        expect(moneys[1].cents).to eq thirty_three_and_one_third
-        expect(moneys[2].cents).to eq thirty_three_and_one_third
+        expect(moneys.inject(0, :+)).to eq(Money.new(100))
       end
     end
   end
 
   describe "#round" do
-
     let(:money) { Money.new(15.75, 'NZD') }
     subject(:rounded) { money.round }
 
     context "without infinite_precision" do
-      it "returns self (as it is already rounded)" do
-        rounded = money.round
-        expect(rounded).to be money
+      it "returns a different money" do
+        expect(rounded).not_to be money
+      end
+
+      it "rounds the cents" do
         expect(rounded.cents).to eq 16
       end
+
+      it "maintains the currency" do
+        expect(rounded.currency).to eq Money::Currency.new('NZD')
+      end
+
+      it "uses a provided rounding strategy" do
+        rounded = money.round(BigDecimal::ROUND_DOWN)
+        expect(rounded.cents).to eq 15
+      end
+
+      it "does not accumulate rounding error" do
+        money_1 = Money.new(10.9).round(BigDecimal::ROUND_DOWN)
+        money_2 = Money.new(10.9).round(BigDecimal::ROUND_DOWN)
+
+        expect(money_1 + money_2).to eq(Money.new(20))
+      end
     end
 
     context "with infinite_precision", :infinite_precision do
@@ -751,15 +779,6 @@ YAML
         expect(rounded.cents).to eq 15
       end
 
-      context "when using a subclass of Money" do
-        let(:special_money_class) { Class.new(Money) }
-        let(:money) { special_money_class.new(15.75, 'NZD') }
-
-        it "preserves the class in the result" do
-          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') }
 
@@ -769,6 +788,22 @@ YAML
         end
       end
     end
+
+    it 'preserves assigned bank' do
+      bank = Money::Bank::VariableExchange.new
+      rounded = Money.new(1_00, 'USD', bank).round
+
+      expect(rounded.bank).to eq(bank)
+    end
+
+    context "when using a subclass of Money" do
+      let(:special_money_class) { Class.new(Money) }
+      let(:money) { special_money_class.new(15.75, 'NZD') }
+
+      it "preserves the class in the result" do
+        expect(rounded).to be_a special_money_class
+      end
+    end
   end
 
   describe "#inspect" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: money
 version: !ruby/object:Gem::Version
-  version: 6.11.3
+  version: 6.12.0
 platform: ruby
 authors:
 - Shane Emmons
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-09 00:00:00.000000000 Z
+date: 2018-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -129,6 +129,7 @@ files:
 - lib/money/currency/heuristics.rb
 - lib/money/currency/loader.rb
 - lib/money/money.rb
+- lib/money/money/allocation.rb
 - lib/money/money/arithmetic.rb
 - lib/money/money/constructors.rb
 - lib/money/money/formatter.rb
@@ -142,6 +143,7 @@ files:
 - spec/currency/heuristics_spec.rb
 - spec/currency/loader_spec.rb
 - spec/currency_spec.rb
+- spec/money/allocation_spec.rb
 - spec/money/arithmetic_spec.rb
 - spec/money/constructors_spec.rb
 - spec/money/formatting_spec.rb
@@ -180,6 +182,7 @@ test_files:
 - spec/currency/heuristics_spec.rb
 - spec/currency/loader_spec.rb
 - spec/currency_spec.rb
+- spec/money/allocation_spec.rb
 - spec/money/arithmetic_spec.rb
 - spec/money/constructors_spec.rb
 - spec/money/formatting_spec.rb