shopify-money 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e95441c6aa9e01d7ac17c8e76f8008cf94dba8d4af2bd75f101d743a333311e
-  data.tar.gz: 07d99a0656016292183ef0a782879f018d4a8fdb814ab6e97470675003280805
+  metadata.gz: ca42130a743b47dba4be201df379a894d92e9e6101338fd41c6ad84b94805997
+  data.tar.gz: 4b4749500c63bdb88d8f63f36628a845f355aad3f572e428dd60804ad107b591
 SHA512:
-  metadata.gz: e18f193d30427adb99f4ebb28e1125a5819ec489801c25698069f1c48448edb492ea3effbd9117bac45d77a613f59688a5ff5ed3327d4b20d03b6dd0a51231d7
-  data.tar.gz: b5cc2766b02db02ebf0df626cc531d0996444f78e7939c7fee7e3caa050cb2fb06c767e88e7256ad12131f225436c68b7ebf776c6e8ea1995e18525004f34896
+  metadata.gz: 9bffc191b4fea246018814cd3961b5bd298212d076c6f6eb6b82d8c19bd377387f360b1a982dc1978ae8a29f531dd57e7127d47f5f4192b0fe5246a8015bc7f2
+  data.tar.gz: d99c2ca80783732eda61cb4e064140131b0aee8da9f56b541e9e5fad7cd1fa4c9ec7362c9fb343ae0c2716888135a38f76799435727f91f025ccddeede94aba4

data/lib/money.rb

@@ -2,6 +2,7 @@ require_relative 'money/money_parser'
 require_relative 'money/helpers'
 require_relative 'money/currency'
 require_relative 'money/null_currency'
+require_relative 'money/allocator'
 require_relative 'money/money'
 require_relative 'money/errors'
 require_relative 'money/deprecations'

data/lib/money/allocator.rb

@@ -0,0 +1,145 @@
+class Money
+  class Allocator < SimpleDelegator
+    def initialize(money)
+      super
+    end
+
+    # Allocates money between different parties without losing pennies.
+    # After the mathematically split has been performed, 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 splits [Array<Numeric>]
+    # @param strategy Symbol
+    # @return [Array<Money>]
+    #
+    # Strategies:
+    # - `:roundrobin` (default): leftover pennies will be accumulated starting from the first allocation left to right
+    # - `:roundrobin_reverse`: leftover pennies will be accumulated starting from the last allocation right to left
+    #
+    # @example
+    #   Money.new(5, "USD").allocate([0.50, 0.25, 0.25])
+    #     #=> [#<Money value:2.50 currency:USD>, #<Money value:1.25 currency:USD>, #<Money value:1.25 currency:USD>]
+    #   Money.new(5, "USD").allocate([0.3, 0.7])
+    #     #=> [#<Money value:1.50 currency:USD>, #<Money value:3.50 currency:USD>]
+    #   Money.new(100, "USD").allocate([0.33, 0.33, 0.33])
+    #     #=> [#<Money value:33.34 currency:USD>, #<Money value:33.33 currency:USD>, #<Money value:33.33 currency:USD>]
+
+    # @example left over cents distributed to first party due to rounding, and two solutions for a more natural distribution
+    #   Money.new(30, "USD").allocate([0.667, 0.333])
+    #     #=> [#<Money value:20.01 currency:USD>, #<Money value:9.99 currency:USD>]
+    #   Money.new(30, "USD").allocate([0.333, 0.667])
+    #     #=> [#<Money value:20.00 currency:USD>, #<Money value:10.00 currency:USD>]
+    #   Money.new(30, "USD").allocate([Rational(2, 3), Rational(1, 3)])
+    #     #=> [#<Money value:20.00 currency:USD>, #<Money value:10.00 currency:USD>]
+
+    # @example left over pennies distributed reverse order when using roundrobin_reverse strategy
+    #   Money.new(10.01, "USD").allocate([0.5, 0.5], :roundrobin_reverse)
+    #     #=> [#<Money value:5.00 currency:USD>, #<Money value:5.01 currency:USD>]
+    def allocate(splits, strategy = :roundrobin)
+      if all_rational?(splits)
+        allocations = splits.inject(0) { |sum, n| sum + n }
+      else
+        allocations = splits.inject(0) { |sum, n| sum + Helpers.value_to_decimal(n) }
+      end
+
+      if (allocations - BigDecimal("1")) > Float::EPSILON
+        raise ArgumentError, "splits add to more than 100%"
+      end
+
+      amounts, left_over = amounts_from_splits(allocations, splits)
+
+      left_over.to_i.times do |i|
+        amounts[allocation_index_for(strategy, amounts.length, i)] += 1
+      end
+
+      amounts.collect { |subunits| Money.from_subunits(subunits, currency) }
+    end
+
+    # Allocates money between different parties up to the maximum amounts specified.
+    # Left over pennies will be assigned round-robin up to the maximum specified.
+    # Pennies are dropped when the maximums are attained.
+    #
+    # @example
+    #   Money.new(30.75).allocate_max_amounts([Money.new(26), Money.new(4.75)])
+    #     #=> [Money.new(26), Money.new(4.75)]
+    #
+    #   Money.new(30.75).allocate_max_amounts([Money.new(26), Money.new(4.74)]
+    #     #=> [Money.new(26), Money.new(4.74)]
+    #
+    #   Money.new(30).allocate_max_amounts([Money.new(15), Money.new(15)]
+    #     #=> [Money.new(15), Money.new(15)]
+    #
+    #   Money.new(1).allocate_max_amounts([Money.new(33), Money.new(33), Money.new(33)])
+    #     #=> [Money.new(0.34), Money.new(0.33), Money.new(0.33)]
+    #
+    #   Money.new(100).allocate_max_amounts([Money.new(5), Money.new(2)])
+    #     #=> [Money.new(5), Money.new(2)]
+    def allocate_max_amounts(maximums)
+      allocation_currency = extract_currency(maximums + [self.__getobj__])
+      maximums = maximums.map { |max| max.to_money(allocation_currency) }
+      maximums_total = maximums.reduce(Money.new(0, allocation_currency), :+)
+
+      splits = maximums.map do |max_amount|
+        next(0) if maximums_total.zero?
+        Money.rational(max_amount, maximums_total)
+      end
+
+      total_allocatable = [
+        value * allocation_currency.subunit_to_unit,
+        maximums_total.value * allocation_currency.subunit_to_unit
+      ].min
+
+      subunits_amounts, left_over = amounts_from_splits(1, splits, total_allocatable)
+
+      subunits_amounts.each_with_index do |amount, index|
+        break unless left_over > 0
+
+        max_amount = maximums[index].value * allocation_currency.subunit_to_unit
+        next unless amount < max_amount
+
+        left_over -= 1
+        subunits_amounts[index] += 1
+      end
+
+      subunits_amounts.map { |cents| Money.from_subunits(cents, allocation_currency) }
+    end
+
+    private
+
+    def extract_currency(money_array)
+      currencies = money_array.lazy.select { |money| money.is_a?(Money) }.reject(&:no_currency?).map(&:currency).to_a.uniq
+      if currencies.size > 1
+        raise ArgumentError, "operation not permitted for Money objects with different currencies #{currencies.join(', ')}"
+      end
+      currencies.first || NULL_CURRENCY
+    end
+
+    def amounts_from_splits(allocations, splits, subunits_to_split = subunits)
+      left_over = subunits_to_split
+
+      amounts = splits.collect do |ratio|
+        frac = (Helpers.value_to_decimal(subunits_to_split * ratio) / allocations).floor
+        left_over -= frac
+        frac
+      end
+
+      [amounts, left_over]
+    end
+
+    def all_rational?(splits)
+      splits.all? { |split| split.is_a?(Rational) }
+    end
+
+    def allocation_index_for(strategy, length, idx)
+      case strategy
+      when :roundrobin
+        idx % length
+      when :roundrobin_reverse
+        length - (idx % length) - 1
+      else
+        raise ArgumentError, "Invalid strategy. Valid options: :roundrobin, :roundrobin_reverse"
+      end
+    end
+  end
+end

data/lib/money/money.rb

@@ -245,94 +245,14 @@ class Money
     Money.new(result, currency)
   end
 
-  # Allocates money between different parties without losing pennies.
-  # After the mathematically split has been performed, 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 splits [Array<Numeric>]
-  # @return [Array<Money>]
-  #
-  # @example
-  #   Money.new(5, "USD").allocate([0.50, 0.25, 0.25])
-  #     #=> [#<Money value:2.50 currency:USD>, #<Money value:1.25 currency:USD>, #<Money value:1.25 currency:USD>]
-  #   Money.new(5, "USD").allocate([0.3, 0.7])
-  #     #=> [#<Money value:1.50 currency:USD>, #<Money value:3.50 currency:USD>]
-  #   Money.new(100, "USD").allocate([0.33, 0.33, 0.33])
-  #     #=> [#<Money value:33.34 currency:USD>, #<Money value:33.33 currency:USD>, #<Money value:33.33 currency:USD>]
-
-  # @example left over cents distributed to first party due to rounding, and two solutions for a more natural distribution
-  #   Money.new(30, "USD").allocate([0.667, 0.333])
-  #     #=> [#<Money value:20.01 currency:USD>, #<Money value:9.99 currency:USD>]
-  #   Money.new(30, "USD").allocate([0.333, 0.667])
-  #     #=> [#<Money value:20.00 currency:USD>, #<Money value:10.00 currency:USD>]
-  #   Money.new(30, "USD").allocate([Rational(2, 3), Rational(1, 3)])
-  #     #=> [#<Money value:20.00 currency:USD>, #<Money value:10.00 currency:USD>]
-  def allocate(splits)
-    if all_rational?(splits)
-      allocations = splits.inject(0) { |sum, n| sum + n }
-    else
-      allocations = splits.inject(0) { |sum, n| sum + Helpers.value_to_decimal(n) }
-    end
-
-    if (allocations - BigDecimal("1")) > Float::EPSILON
-      raise ArgumentError, "splits add to more than 100%"
-    end
-
-    amounts, left_over = amounts_from_splits(allocations, splits)
-
-    left_over.to_i.times { |i| amounts[i % amounts.length] += 1 }
-
-    amounts.collect { |subunits| Money.from_subunits(subunits, currency) }
+  # @see Money::Allocator#allocate
+  def allocate(splits, strategy = :roundrobin)
+    Money::Allocator.new(self).allocate(splits, strategy)
   end
 
-  # Allocates money between different parties up to the maximum amounts specified.
-  # Left over pennies will be assigned round-robin up to the maximum specified.
-  # Pennies are dropped when the maximums are attained.
-  #
-  # @example
-  #   Money.new(30.75).allocate_max_amounts([Money.new(26), Money.new(4.75)])
-  #     #=> [Money.new(26), Money.new(4.75)]
-  #
-  #   Money.new(30.75).allocate_max_amounts([Money.new(26), Money.new(4.74)]
-  #     #=> [Money.new(26), Money.new(4.74)]
-  #
-  #   Money.new(30).allocate_max_amounts([Money.new(15), Money.new(15)]
-  #     #=> [Money.new(15), Money.new(15)]
-  #
-  #   Money.new(1).allocate_max_amounts([Money.new(33), Money.new(33), Money.new(33)])
-  #     #=> [Money.new(0.34), Money.new(0.33), Money.new(0.33)]
-  #
-  #   Money.new(100).allocate_max_amounts([Money.new(5), Money.new(2)])
-  #     #=> [Money.new(5), Money.new(2)]
+  # @see Money::Allocator#allocate_max_amounts
   def allocate_max_amounts(maximums)
-    allocation_currency = extract_currency(maximums + [self])
-    maximums = maximums.map { |max| max.to_money(allocation_currency) }
-    maximums_total = maximums.reduce(Money.new(0, allocation_currency), :+)
-
-    splits = maximums.map do |max_amount|
-      next(0) if maximums_total.zero?
-      Money.rational(max_amount, maximums_total)
-    end
-
-    total_allocatable = [
-      value * allocation_currency.subunit_to_unit,
-      maximums_total.value * allocation_currency.subunit_to_unit
-    ].min
-
-    subunits_amounts, left_over = amounts_from_splits(1, splits, total_allocatable)
-
-    subunits_amounts.each_with_index do |amount, index|
-      break unless left_over > 0
-
-      max_amount = maximums[index].value * allocation_currency.subunit_to_unit
-      next unless amount < max_amount
-
-      left_over -= 1
-      subunits_amounts[index] += 1
-    end
-
-    subunits_amounts.map { |cents| Money.from_subunits(cents, allocation_currency) }
+    Money::Allocator.new(self).allocate_max_amounts(maximums)
   end
 
   # Split money amongst parties evenly without losing pennies.
@@ -395,22 +315,6 @@ class Money
 
   private
 
-  def all_rational?(splits)
-    splits.all? { |split| split.is_a?(Rational) }
-  end
-
-  def amounts_from_splits(allocations, splits, subunits_to_split = subunits)
-    left_over = subunits_to_split
-
-    amounts = splits.collect do |ratio|
-      frac = (Helpers.value_to_decimal(subunits_to_split * ratio) / allocations).floor
-      left_over -= frac
-      frac
-    end
-
-    [amounts, left_over]
-  end
-
   def arithmetic(money_or_numeric)
     raise TypeError, "#{money_or_numeric.class.name} can't be coerced into Money" unless money_or_numeric.respond_to?(:to_money)
     other = money_or_numeric.to_money(currency)
@@ -421,12 +325,4 @@ class Money
   def calculated_currency(other)
     no_currency? ? other : currency
   end
-
-  def extract_currency(money_array)
-    currencies = money_array.lazy.select { |money| money.is_a?(Money) }.reject(&:no_currency?).map(&:currency).to_a.uniq
-    if currencies.size > 1
-      raise ArgumentError, "operation not permitted for Money objects with different currencies #{currencies.join(', ')}"
-    end
-    currencies.first || NULL_CURRENCY
-  end
 end

data/lib/money/version.rb

@@ -1,3 +1,3 @@
 class Money
-  VERSION = "0.12.0"
+  VERSION = "0.13.0"
 end

data/spec/allocator_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+RSpec.describe "Allocator" do
+  describe "allocate"do
+    specify "#allocate takes no action when one gets all" do
+      expect(new_allocator(5).allocate([1])).to eq([Money.new(5)])
+    end
+
+    specify "#allocate does not lose pennies" do
+      moneys = new_allocator(0.05).allocate([0.3,0.7])
+      expect(moneys[0]).to eq(Money.new(0.02))
+      expect(moneys[1]).to eq(Money.new(0.03))
+    end
+
+    specify "#allocate does not lose dollars with non-decimal currency" do
+      moneys = new_allocator(5, 'JPY').allocate([0.3,0.7])
+      expect(moneys[0]).to eq(Money.new(2, 'JPY'))
+      expect(moneys[1]).to eq(Money.new(3, 'JPY'))
+    end
+
+    specify "#allocate does not lose dollars with three decimal currency" do
+      moneys = new_allocator(0.005, 'JOD').allocate([0.3,0.7])
+      expect(moneys[0]).to eq(Money.new(0.002, 'JOD'))
+      expect(moneys[1]).to eq(Money.new(0.003, 'JOD'))
+    end
+
+    specify "#allocate does not lose pennies even when given a lossy split" do
+      moneys = new_allocator(1).allocate([0.333,0.333, 0.333])
+      expect(moneys[0].subunits).to eq(34)
+      expect(moneys[1].subunits).to eq(33)
+      expect(moneys[2].subunits).to eq(33)
+    end
+
+    specify "#allocate requires total to be less than 1" do
+      expect { new_allocator(0.05).allocate([0.5,0.6]) }.to raise_error(ArgumentError)
+    end
+
+    specify "#allocate will use rationals if provided" do
+      splits = [128400,20439,14589,14589,25936].map{ |num| Rational(num, 203953) } # sums to > 1 if converted to float
+      expect(new_allocator(2.25).allocate(splits)).to eq([Money.new(1.42), Money.new(0.23), Money.new(0.16), Money.new(0.16), Money.new(0.28)])
+    end
+
+    specify "#allocate will convert rationals with high precision" do
+      ratios = [Rational(1, 1), Rational(0)]
+      expect(new_allocator("858993456.12").allocate(ratios)).to eq([Money.new("858993456.12"), Money.empty])
+      ratios = [Rational(1, 6), Rational(5, 6)]
+      expect(new_allocator("3.00").allocate(ratios)).to eq([Money.new("0.50"), Money.new("2.50")])
+    end
+
+    specify "#allocate doesn't raise with weird negative rational ratios" do
+      rate = Rational(-5, 1201)
+      expect { new_allocator(1).allocate([rate, 1 - rate]) }.not_to raise_error
+    end
+
+    specify "#allocate fills pennies from beginning to end with roundrobin strategy" do
+      moneys = new_allocator(0.05).allocate([0.3,0.7], :roundrobin)
+      expect(moneys[0]).to eq(Money.new(0.02))
+      expect(moneys[1]).to eq(Money.new(0.03))
+    end
+
+    specify "#allocate fills pennies from end to beginning with roundrobin_reverse strategy" do
+      moneys = new_allocator(0.05).allocate([0.3,0.7], :roundrobin_reverse)
+      expect(moneys[0]).to eq(Money.new(0.01))
+      expect(moneys[1]).to eq(Money.new(0.04))
+    end
+
+    specify "#allocate raise ArgumentError when invalid strategy is provided" do
+      expect { new_allocator(0.03).allocate([0.5, 0.5], :bad_strategy_name) }.to raise_error(ArgumentError, "Invalid strategy. Valid options: :roundrobin, :roundrobin_reverse")
+    end
+  end
+
+  describe 'allocate_max_amounts' do
+    specify "#allocate_max_amounts returns the weighted allocation without exceeding the maxima when there is room for the remainder" do
+      expect(
+        new_allocator(30.75).allocate_max_amounts([Money.new(26), Money.new(4.75)]),
+      ).to eq([Money.new(26), Money.new(4.75)])
+    end
+
+    specify "#allocate_max_amounts returns the weighted allocation without exceeding the maxima when there is room for the remainder with currency" do
+      expect(
+        new_allocator(3075, 'JPY').allocate_max_amounts([Money.new(2600, 'JPY'), Money.new(475, 'JPY')]),
+      ).to eq([Money.new(2600, 'JPY'), Money.new(475, 'JPY')])
+    end
+
+    specify "#allocate_max_amounts legal computation with no currency objects" do
+      expect(
+        new_allocator(3075, 'JPY').allocate_max_amounts([2600, 475]),
+      ).to eq([Money.new(2600, 'JPY'), Money.new(475, 'JPY')])
+
+      expect(
+        new_allocator(3075, Money::NULL_CURRENCY).allocate_max_amounts([Money.new(2600, 'JPY'), Money.new(475, 'JPY')]),
+      ).to eq([Money.new(2600, 'JPY'), Money.new(475, 'JPY')])
+    end
+
+    specify "#allocate_max_amounts illegal computation across currencies" do
+      expect {
+        new_allocator(3075, 'USD').allocate_max_amounts([Money.new(2600, 'JPY'), Money.new(475, 'JPY')])
+      }.to raise_error(ArgumentError)
+    end
+
+    specify "#allocate_max_amounts drops the remainder when returning the weighted allocation without exceeding the maxima when there is no room for the remainder" do
+      expect(
+        new_allocator(30.75).allocate_max_amounts([Money.new(26), Money.new(4.74)]),
+      ).to eq([Money.new(26), Money.new(4.74)])
+    end
+
+    specify "#allocate_max_amounts returns the weighted allocation when there is no remainder" do
+      expect(
+        new_allocator(30).allocate_max_amounts([Money.new(15), Money.new(15)]),
+      ).to eq([Money.new(15), Money.new(15)])
+    end
+
+    specify "#allocate_max_amounts allocates the remainder round-robin when the maxima are not reached" do
+      expect(
+        new_allocator(1).allocate_max_amounts([Money.new(33), Money.new(33), Money.new(33)]),
+      ).to eq([Money.new(0.34), Money.new(0.33), Money.new(0.33)])
+    end
+
+    specify "#allocate_max_amounts allocates up to the maxima specified" do
+      expect(
+        new_allocator(100).allocate_max_amounts([Money.new(5), Money.new(2)]),
+      ).to eq([Money.new(5), Money.new(2)])
+    end
+
+    specify "#allocate_max_amounts supports all-zero maxima" do
+      expect(
+        new_allocator(3).allocate_max_amounts([Money.empty, Money.empty, Money.empty]),
+      ).to eq([Money.empty, Money.empty, Money.empty])
+    end
+  end
+
+  def new_allocator(amount, currency = nil)
+    Money::Allocator.new(Money.new(amount, currency))
+  end
+end

data/spec/money_spec.rb

@@ -583,113 +583,29 @@ RSpec.describe "Money" do
   end
 
   describe "allocation"do
-    specify "#allocate takes no action when one gets all" do
-      expect(Money.new(5).allocate([1])).to eq([Money.new(5)])
+    specify "#allocate is calculated by Money::Allocator#allocate" do
+      expected = [Money.new(1), [Money.new(1)]]
+      expect_any_instance_of(Money::Allocator).to receive(:allocate).with([0.5, 0.5], :roundrobin).and_return(expected)
+      expect(Money.new(2).allocate([0.5, 0.5])).to eq(expected)
     end
 
-    specify "#allocate does not lose pennies" do
+    specify "#allocate does not lose pennies (integration test)" do
       moneys = Money.new(0.05).allocate([0.3,0.7])
       expect(moneys[0]).to eq(Money.new(0.02))
       expect(moneys[1]).to eq(Money.new(0.03))
     end
 
-    specify "#allocate does not lose dollars with non-decimal currency" do
-      moneys = Money.new(5, 'JPY').allocate([0.3,0.7])
-      expect(moneys[0]).to eq(Money.new(2, 'JPY'))
-      expect(moneys[1]).to eq(Money.new(3, 'JPY'))
+    specify "#allocate_max_amounts is calculated by Money::Allocator#allocate_max_amounts" do
+      expected = [Money.new(1), [Money.new(1)]]
+      expect_any_instance_of(Money::Allocator).to receive(:allocate_max_amounts).and_return(expected)
+      expect(Money.new(2).allocate_max_amounts([0.5, 0.5])).to eq(expected)
     end
 
-    specify "#allocate does not lose dollars with three decimal currency" do
-      moneys = Money.new(0.005, 'JOD').allocate([0.3,0.7])
-      expect(moneys[0]).to eq(Money.new(0.002, 'JOD'))
-      expect(moneys[1]).to eq(Money.new(0.003, 'JOD'))
-    end
-
-    specify "#allocate does not lose pennies even when given a lossy split" do
-      moneys = Money.new(1).allocate([0.333,0.333, 0.333])
-      expect(moneys[0].subunits).to eq(34)
-      expect(moneys[1].subunits).to eq(33)
-      expect(moneys[2].subunits).to eq(33)
-    end
-
-    specify "#allocate requires total to be less than 1" do
-      expect { Money.new(0.05).allocate([0.5,0.6]) }.to raise_error(ArgumentError)
-    end
-
-    specify "#allocate will use rationals if provided" do
-      splits = [128400,20439,14589,14589,25936].map{ |num| Rational(num, 203953) } # sums to > 1 if converted to float
-      expect(Money.new(2.25).allocate(splits)).to eq([Money.new(1.42), Money.new(0.23), Money.new(0.16), Money.new(0.16), Money.new(0.28)])
-    end
-
-    specify "#allocate will convert rationals with high precision" do
-      ratios = [Rational(1, 1), Rational(0)]
-      expect(Money.new("858993456.12").allocate(ratios)).to eq([Money.new("858993456.12"), Money.empty])
-      ratios = [Rational(1, 6), Rational(5, 6)]
-      expect(Money.new("3.00").allocate(ratios)).to eq([Money.new("0.50"), Money.new("2.50")])
-    end
-
-    specify "#allocate doesn't raise with weird negative rational ratios" do
-      rate = Rational(-5, 1201)
-      expect { Money.new(1).allocate([rate, 1 - rate]) }.not_to raise_error
-    end
-
-    specify "#allocate_max_amounts returns the weighted allocation without exceeding the maxima when there is room for the remainder" do
+    specify "#allocate_max_amounts returns the weighted allocation without exceeding the maxima when there is room for the remainder (integration test)" do
       expect(
         Money.new(30.75).allocate_max_amounts([Money.new(26), Money.new(4.75)]),
       ).to eq([Money.new(26), Money.new(4.75)])
     end
-
-    specify "#allocate_max_amounts returns the weighted allocation without exceeding the maxima when there is room for the remainder with currency" do
-      expect(
-        Money.new(3075, 'JPY').allocate_max_amounts([Money.new(2600, 'JPY'), Money.new(475, 'JPY')]),
-      ).to eq([Money.new(2600, 'JPY'), Money.new(475, 'JPY')])
-    end
-
-    specify "#allocate_max_amounts legal computation with no currency objects" do
-      expect(
-        Money.new(3075, 'JPY').allocate_max_amounts([2600, 475]),
-      ).to eq([Money.new(2600, 'JPY'), Money.new(475, 'JPY')])
-
-      expect(
-        Money.new(3075, Money::NULL_CURRENCY).allocate_max_amounts([Money.new(2600, 'JPY'), Money.new(475, 'JPY')]),
-      ).to eq([Money.new(2600, 'JPY'), Money.new(475, 'JPY')])
-    end
-
-    specify "#allocate_max_amounts illegal computation across currencies" do
-      expect {
-        Money.new(3075, 'USD').allocate_max_amounts([Money.new(2600, 'JPY'), Money.new(475, 'JPY')])
-      }.to raise_error(ArgumentError)
-    end
-
-    specify "#allocate_max_amounts drops the remainder when returning the weighted allocation without exceeding the maxima when there is no room for the remainder" do
-      expect(
-        Money.new(30.75).allocate_max_amounts([Money.new(26), Money.new(4.74)]),
-      ).to eq([Money.new(26), Money.new(4.74)])
-    end
-
-    specify "#allocate_max_amounts returns the weighted allocation when there is no remainder" do
-      expect(
-        Money.new(30).allocate_max_amounts([Money.new(15), Money.new(15)]),
-      ).to eq([Money.new(15), Money.new(15)])
-    end
-
-    specify "#allocate_max_amounts allocates the remainder round-robin when the maxima are not reached" do
-      expect(
-        Money.new(1).allocate_max_amounts([Money.new(33), Money.new(33), Money.new(33)]),
-      ).to eq([Money.new(0.34), Money.new(0.33), Money.new(0.33)])
-    end
-
-    specify "#allocate_max_amounts allocates up to the maxima specified" do
-      expect(
-        Money.new(100).allocate_max_amounts([Money.new(5), Money.new(2)]),
-      ).to eq([Money.new(5), Money.new(2)])
-    end
-
-    specify "#allocate_max_amounts supports all-zero maxima" do
-      expect(
-        Money.new(3).allocate_max_amounts([Money.empty, Money.empty, Money.empty]),
-      ).to eq([Money.empty, Money.empty, Money.empty])
-    end
   end
 
   describe "split" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shopify-money
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Shopify Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-10 00:00:00.000000000 Z
+date: 2019-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -131,6 +131,7 @@ files:
 - dev.yml
 - lib/money.rb
 - lib/money/accounting_money_parser.rb
+- lib/money/allocator.rb
 - lib/money/core_extensions.rb
 - lib/money/currency.rb
 - lib/money/currency/loader.rb
@@ -148,6 +149,7 @@ files:
 - lib/money_column/railtie.rb
 - money.gemspec
 - spec/accounting_money_parser_spec.rb
+- spec/allocator_spec.rb
 - spec/core_extensions_spec.rb
 - spec/currency/loader_spec.rb
 - spec/currency_spec.rb
@@ -185,6 +187,7 @@ specification_version: 4
 summary: Shopify's money gem
 test_files:
 - spec/accounting_money_parser_spec.rb
+- spec/allocator_spec.rb
 - spec/core_extensions_spec.rb
 - spec/currency/loader_spec.rb
 - spec/currency_spec.rb