shopify-money 2.0.0 → 2.2.0

data/lib/money/splitter.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+class Money
+  class Splitter
+    include Enumerable
+
+    def initialize(money, num)
+      @num = Integer(num)
+      raise ArgumentError, "need at least one party" if num < 1
+      @money = money
+      @split = nil
+    end
+
+    protected attr_writer :split
+
+    def split
+      @split ||= begin
+        subunits = @money.subunits
+        low = Money.from_subunits(subunits / @num, @money.currency)
+        high = Money.from_subunits(low.subunits + 1, @money.currency)
+
+        num_high = subunits % @num
+
+        split = {}
+        split[high] = num_high if num_high > 0
+        split[low] = @num - num_high
+        split.freeze
+      end
+    end
+
+    alias_method :to_ary, :to_a
+
+    def first(count = (count_undefined = true))
+      if count_undefined
+        each do |money|
+          return money
+        end
+      else
+        if count >= size
+          to_a
+        else
+          result = Array.new(count)
+          index = 0
+          each do |money|
+            result[index] = money
+            index += 1
+            break if index == count
+          end
+          result
+        end
+      end
+    end
+
+    def last(count = (count_undefined = true))
+      if count_undefined
+        reverse_each do |money|
+          return money
+        end
+      else
+        if count >= size
+          to_a
+        else
+          result = Array.new(count)
+          index = 0
+          reverse_each do |money|
+            result[index] = money
+            index += 1
+            break if index == count
+          end
+          result.reverse!
+          result
+        end
+      end
+    end
+
+    def [](index)
+      offset = 0
+      split.each do |money, count|
+        offset += count
+        if index < offset
+          return money
+        end
+      end
+      nil
+    end
+
+    def reverse_each(&block)
+      split.reverse_each do |money, count|
+        count.times do
+          yield money
+        end
+      end
+    end
+
+    def each(&block)
+      split.each do |money, count|
+        count.times do
+          yield money
+        end
+      end
+    end
+
+    def reverse
+      copy = dup
+      copy.split = split.reverse_each.to_h.freeze
+      copy
+    end
+
+    def size
+      count = 0
+      split.each_value { |c| count += c }
+      count
+    end
+  end
+end

data/lib/money/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 class Money
-  VERSION = "2.0.0"
+  VERSION = "2.2.0"
 end

data/lib/money.rb

@@ -5,6 +5,7 @@ require_relative 'money/helpers'
 require_relative 'money/currency'
 require_relative 'money/null_currency'
 require_relative 'money/allocator'
+require_relative 'money/splitter'
 require_relative 'money/config'
 require_relative 'money/money'
 require_relative 'money/errors'

data/money.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency("rails", "~> 6.0")
   s.add_development_dependency("rspec", "~> 3.2")
   s.add_development_dependency("database_cleaner", "~> 1.6")
-  s.add_development_dependency("sqlite3", "~> 1.4.2")
+  s.add_development_dependency("sqlite3")
 
   s.required_ruby_version = '>= 3.0'
 

data/spec/allocator_spec.rb

@@ -8,34 +8,38 @@ RSpec.describe "Allocator" do
     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))
+      monies = new_allocator(0.05).allocate([0.3,0.7])
+      expect(monies[0]).to eq(Money.new(0.02))
+      expect(monies[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'))
+      monies = new_allocator(5, 'JPY').allocate([0.3,0.7])
+      expect(monies[0]).to eq(Money.new(2, 'JPY'))
+      expect(monies[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'))
+      monies = new_allocator(0.005, 'JOD').allocate([0.3,0.7])
+      expect(monies[0]).to eq(Money.new(0.002, 'JOD'))
+      expect(monies[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)
+      monies = new_allocator(1).allocate([0.333,0.333, 0.333])
+      expect(monies[0].subunits).to eq(34)
+      expect(monies[1].subunits).to eq(33)
+      expect(monies[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 requires at least one split" do
+      expect { new_allocator(0.05).allocate([]) }.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)])
@@ -53,27 +57,173 @@ RSpec.describe "Allocator" do
       expect { new_allocator(1).allocate([rate, 1 - rate]) }.not_to raise_error
     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, :nearest")
+    end
+
+    specify "#allocate raises an error when splits exceed 100%" do
+      expect { new_allocator(0.03).allocate([0.5, 0.6]) }.to raise_error(ArgumentError, "allocations add to more than 100%")
+    end
+
+    specify "#allocate scales up allocations less than 100%, preserving the relative magnitude of each chunk" do
+      # Allocations sum to 0.3
+      # This is analogous to new_allocator(12).allocate([1/3, 2/3])
+      monies = new_allocator(12).allocate([0.1, 0.2])
+      expect(monies[0]).to eq(Money.new(4))
+      expect(monies[1]).to eq(Money.new(8))
+
+      # Allocations sum to .661
+      monies = new_allocator(488.51).allocate([0.111, 0.05, 0.5])
+      expect(monies[0]).to eq(Money.new(82.04)) # <-- leftover penny
+      expect(monies[1]).to eq(Money.new(36.95))
+      expect(monies[2]).to eq(Money.new(369.52))
+
+      monies = new_allocator(488.51).allocate([0.111, 0.05, 0.5], :roundrobin_reverse)
+      expect(monies[0]).to eq(Money.new(82.03))
+      expect(monies[1]).to eq(Money.new(36.95))
+      expect(monies[2]).to eq(Money.new(369.53)) # <-- leftover penny
+
+      monies = new_allocator(488.51).allocate([0.05, 0.111, 0.5], :nearest)
+      expect(monies[0]).to eq(Money.new(36.95))
+      expect(monies[1]).to eq(Money.new(82.04)) # <-- leftover penny
+      expect(monies[2]).to eq(Money.new(369.52))
+    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))
+      #round robin for 1 penny
+      monies = new_allocator(0.03).allocate([0.5, 0.5], :roundrobin)
+      expect(monies[0]).to eq(Money.new(0.02)) # <-- gets 1 penny
+      expect(monies[1]).to eq(Money.new(0.01)) # <-- gets no penny
+
+      #round robin for 2 pennies
+      monies = new_allocator(10.55).allocate([0.25, 0.5, 0.25], :roundrobin)
+      expect(monies[0]).to eq(Money.new(2.64)) # <-- gets 1 penny
+      expect(monies[1]).to eq(Money.new(5.28)) # <-- gets 1 penny
+      expect(monies[2]).to eq(Money.new(2.63)) # <-- gets no penny
+
+      #round robin for 3 pennies
+      monies = new_allocator(195.35).allocate([0.025, 0.025, 0.125, 0.125, 0.4, 0.3], :roundrobin)
+      expect(monies[0]).to eq(Money.new(4.89)) # <-- gets 1 penny
+      expect(monies[1]).to eq(Money.new(4.89)) # <-- gets 1 penny
+      expect(monies[2]).to eq(Money.new(24.42)) # <-- gets 1 penny
+      expect(monies[3]).to eq(Money.new(24.41)) # <-- gets no penny
+      expect(monies[4]).to eq(Money.new(78.14)) # <-- gets no penny
+      expect(monies[5]).to eq(Money.new(58.60)) # <-- gets no penny
+
+      #round robin for 0 pennies
+      monies = new_allocator(101).allocate([0.25, 0.25, 0.25, 0.25], :roundrobin)
+      expect(monies[0]).to eq(Money.new(25.25)) # <-- gets no penny
+      expect(monies[1]).to eq(Money.new(25.25)) # <-- gets no penny
+      expect(monies[2]).to eq(Money.new(25.25)) # <-- gets no penny
+      expect(monies[3]).to eq(Money.new(25.25)) # <-- gets no penny
     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))
+      #round robin reverse for 1 penny
+      monies = new_allocator(0.05).allocate([0.3,0.7], :roundrobin_reverse)
+      expect(monies[0]).to eq(Money.new(0.01)) # <-- gets no penny
+      expect(monies[1]).to eq(Money.new(0.04)) # <-- gets 1 penny
+
+      #round robin reverse for 2 pennies
+      monies = new_allocator(10.55).allocate([0.25, 0.5, 0.25], :roundrobin_reverse)
+      expect(monies[0]).to eq(Money.new(2.63)) # <-- gets no penny
+      expect(monies[1]).to eq(Money.new(5.28)) # <-- gets 1 penny
+      expect(monies[2]).to eq(Money.new(2.64)) # <-- gets 1 penny
+
+      #round robin reverse for 3 pennies
+      monies = new_allocator(195.35).allocate([0.025, 0.025, 0.125, 0.125, 0.4, 0.3], :roundrobin_reverse)
+      expect(monies[0]).to eq(Money.new(4.88)) #  <-- gets no penny
+      expect(monies[1]).to eq(Money.new(4.88)) #  <-- gets no penny
+      expect(monies[2]).to eq(Money.new(24.41)) # <-- gets no penny
+      expect(monies[3]).to eq(Money.new(24.42)) # <-- gets 1 penny
+      expect(monies[4]).to eq(Money.new(78.15)) # <-- gets 1 penny
+      expect(monies[5]).to eq(Money.new(58.61)) # <-- gets 1 penny
+
+      #round robin reverse for 0 pennies
+      monies = new_allocator(101).allocate([0.25, 0.25, 0.25, 0.25], :roundrobin_reverse)
+      expect(monies[0]).to eq(Money.new(25.25)) # <-- gets no penny
+      expect(monies[1]).to eq(Money.new(25.25)) # <-- gets no penny
+      expect(monies[2]).to eq(Money.new(25.25)) # <-- gets no penny
+      expect(monies[3]).to eq(Money.new(25.25)) # <-- gets no penny
     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")
+    specify "#allocate :nearest strategy distributes pennies first to the number which is nearest to the next whole cent" do
+      #nearest for 1 penny
+      monies = new_allocator(0.03).allocate([0.5, 0.5], :nearest)
+      expect(monies[0]).to eq(Money.new(0.02)) # <-- gets 1 penny
+      expect(monies[1]).to eq(Money.new(0.01)) # <-- gets no penny
+
+      #Nearest for 2 pennies
+      monies = new_allocator(10.55).allocate([0.25, 0.5, 0.25], :nearest)
+      expect(monies[0]).to eq(Money.new(2.64)) # <-- gets 1 penny
+      expect(monies[1]).to eq(Money.new(5.27)) # <-- gets no penny
+      expect(monies[2]).to eq(Money.new(2.64)) # <-- gets 1 penny
+
+      #Nearest for 3 pennies
+      monies = new_allocator(195.35).allocate([0.025, 0.025, 0.125, 0.125, 0.4, 0.3], :nearest)
+      expect(monies[0]).to eq(Money.new(4.88)) #  <-- gets no penny
+      expect(monies[1]).to eq(Money.new(4.88)) #  <-- gets no penny
+      expect(monies[2]).to eq(Money.new(24.42)) # <-- gets 1 penny
+      expect(monies[3]).to eq(Money.new(24.42)) # <-- gets 1 penny
+      expect(monies[4]).to eq(Money.new(78.14)) # <-- gets no penny
+      expect(monies[5]).to eq(Money.new(58.61)) # <-- gets 1 penny
+
+      #Nearest for 0 pennies
+      monies = new_allocator(101).allocate([0.25, 0.25, 0.25, 0.25], :nearest)
+      expect(monies[0]).to eq(Money.new(25.25)) # <-- gets no penny
+      expect(monies[1]).to eq(Money.new(25.25)) # <-- gets no penny
+      expect(monies[2]).to eq(Money.new(25.25)) # <-- gets no penny
+      expect(monies[3]).to eq(Money.new(25.25)) # <-- gets no penny
     end
 
-    specify "#allocate does not raise ArgumentError when invalid splits types are provided" do
-      moneys = new_allocator(0.03).allocate([0.5, 0.5], :roundrobin)
-      expect(moneys[0]).to eq(Money.new(0.02))
-      expect(moneys[1]).to eq(Money.new(0.01))
+    specify "#allocate :roundrobin strategy distributes leftovers from left to right when the currency does not use two decimal places (e.g. `JPY`)" do
+      #Roundrobin for 1 yen
+      monies = new_allocator(31, 'JPY').allocate([0.5,0.5], :roundrobin)
+      expect(monies[0]).to eq(Money.new(16, 'JPY'))
+      expect(monies[1]).to eq(Money.new(15, 'JPY'))
+
+      #Roundrobin for 3 yen
+      monies = new_allocator(19535, "JPY").allocate([0.025, 0.025, 0.125, 0.125, 0.4, 0.3], :roundrobin)
+      expect(monies[0]).to eq(Money.new(489, "JPY")) #  <-- gets 1 yen
+      expect(monies[1]).to eq(Money.new(489, "JPY")) #  <-- gets 1 yen
+      expect(monies[2]).to eq(Money.new(2442, "JPY")) # <-- gets 1 yen
+      expect(monies[3]).to eq(Money.new(2441, "JPY")) # <-- gets no yen
+      expect(monies[4]).to eq(Money.new(7814, "JPY")) # <-- gets no yen
+      expect(monies[5]).to eq(Money.new(5860, "JPY")) # <-- gets no yen
     end
+
+    specify "#allocate :roundrobin_reverse strategy distributes leftovers from right to left when the currency does not use two decimal places (e.g. `JPY`)" do
+      #Roundrobin for 1 yen
+      monies = new_allocator(31, 'JPY').allocate([0.5,0.5], :roundrobin_reverse)
+      expect(monies[0]).to eq(Money.new(15, 'JPY'))
+      expect(monies[1]).to eq(Money.new(16, 'JPY'))
+
+      #Roundrobin for 3 yen
+      monies = new_allocator(19535, "JPY").allocate([0.025, 0.025, 0.125, 0.125, 0.4, 0.3], :roundrobin_reverse)
+      expect(monies[0]).to eq(Money.new(488, "JPY")) #  <-- gets no yen
+      expect(monies[1]).to eq(Money.new(488, "JPY")) #  <-- gets no yen
+      expect(monies[2]).to eq(Money.new(2441, "JPY")) # <-- gets no yen
+      expect(monies[3]).to eq(Money.new(2442, "JPY")) # <-- gets 1 yen
+      expect(monies[4]).to eq(Money.new(7815, "JPY")) # <-- gets 1 yen
+      expect(monies[5]).to eq(Money.new(5861, "JPY")) # <-- gets 1 yen
+    end
+
+    specify "#allocate :nearest strategy distributes leftovers to the nearest whole subunity when the currency does not use two decimal places (e.g. `JPY`)" do
+      #Nearest for 1 yen
+      monies = new_allocator(31, 'JPY').allocate([0.5,0.5], :nearest)
+      expect(monies[0]).to eq(Money.new(16, 'JPY'))
+      expect(monies[1]).to eq(Money.new(15, 'JPY'))
+
+      #Nearest for 3 yen
+      monies = new_allocator(19535, "JPY").allocate([0.025, 0.025, 0.125, 0.125, 0.4, 0.3], :nearest)
+      expect(monies[0]).to eq(Money.new(488, "JPY")) #  <-- gets no yen
+      expect(monies[1]).to eq(Money.new(488, "JPY")) #  <-- gets no yen
+      expect(monies[2]).to eq(Money.new(2442, "JPY")) # <-- gets 1 yen
+      expect(monies[3]).to eq(Money.new(2442, "JPY")) # <-- gets 1 yen
+      expect(monies[4]).to eq(Money.new(7814, "JPY")) # <-- gets no yen
+      expect(monies[5]).to eq(Money.new(5861, "JPY")) # <-- gets 1 yen
+    end
+
   end
 
   describe 'allocate_max_amounts' do

data/spec/deprecations_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 RSpec.describe "deprecations" do
   it "has the deprecation_horizon as the next major release" do
-    allow(Money).to receive(:const_get).with('VERSION').and_return("2.0.0")
+    allow(Money).to receive(:const_get).with('VERSION').and_return("2.1.0")
     expect(Money.active_support_deprecator.deprecation_horizon).to eq("3.0.0")
   end
 end

data/spec/helpers_spec.rb

@@ -7,8 +7,8 @@ RSpec.describe Money::Helpers do
     let (:amount) { BigDecimal('1.23') }
     let (:money) { Money.new(amount) }
 
-    it 'raises when provided with a money object' do
-      expect { subject.value_to_decimal(money) }.to raise_error(ArgumentError)
+    it 'returns the value of a money object' do
+      expect(subject.value_to_decimal(money)).to eq(amount)
     end
 
     it 'returns itself if it is already a big decimal' do

data/spec/money_spec.rb

@@ -30,15 +30,20 @@ RSpec.describe "Money" do
 
   it "returns itself with to_money" do
     expect(money.to_money).to eq(money)
+    expect(amount_money.to_money).to eq(amount_money)
   end
 
   it "#to_money uses the provided currency when it doesn't already have one" do
     expect(Money.new(1).to_money('CAD')).to eq(Money.new(1, 'CAD'))
   end
 
+  it "#to_money works with money objects of the same currency" do
+    expect(Money.new(1, 'CAD').to_money('CAD')).to eq(Money.new(1, 'CAD'))
+  end
+
   it "legacy_deprecations #to_money doesn't overwrite the money object's currency" do
     configure(legacy_deprecations: true) do
-      expect(Money).to receive(:deprecate).once
+      expect(Money).to receive(:deprecate).with(match(/to_money is attempting to change currency of an existing money object/)).once
       expect(Money.new(1, 'USD').to_money('CAD')).to eq(Money.new(1, 'USD'))
     end
   end
@@ -55,6 +60,29 @@ RSpec.describe "Money" do
     expect(Money.new('')).to eq(Money.new(0))
   end
 
+  it "can be constructed with a string" do
+    expect(Money.new('1')).to eq(Money.new(1))
+  end
+
+  it "can be constructed with a numeric" do
+    expect(Money.new(1.00)).to eq(Money.new(1))
+  end
+
+  it "can be constructed with a money object" do
+    expect(Money.new(Money.new(1))).to eq(Money.new(1))
+  end
+
+  it "constructor raises when changing currency" do
+    expect { Money.new(Money.new(1, 'USD'), 'CAD') }.to raise_error(Money::IncompatibleCurrencyError)
+  end
+
+  it "legacy_deprecations constructor with money used the constructor currency" do
+    configure(legacy_deprecations: true) do
+     expect(Money).to receive(:deprecate).with(match(/Money.new is attempting to change currency of an existing money object/)).once
+      expect(Money.new(Money.new(1, 'USD'), 'CAD')).to eq(Money.new(1, 'CAD'))
+    end
+  end
+
   it "legacy_deprecations defaults to 0 when constructed with an invalid string" do
     configure(legacy_deprecations: true) do
       expect(Money).to receive(:deprecate).once
@@ -192,7 +220,7 @@ RSpec.describe "Money" do
 
   it "logs a deprecation warning when adding across currencies" do
     configure(legacy_deprecations: true) do
-      expect(Money).to receive(:deprecate)
+      expect(Money).to receive(:deprecate).with(match(/mathematical operation not permitted for Money objects with different currencies/))
       expect(Money.new(10, 'USD') - Money.new(1, 'JPY')).to eq(Money.new(9, 'USD'))
     end
   end
@@ -723,22 +751,32 @@ RSpec.describe "Money" do
     specify "#split needs at least one party" do
       expect {Money.new(1).split(0)}.to raise_error(ArgumentError)
       expect {Money.new(1).split(-1)}.to raise_error(ArgumentError)
+      expect {Money.new(1).split(0.1)}.to raise_error(ArgumentError)
+      expect(Money.new(1).split(BigDecimal("0.1e1")).to_a).to eq([Money.new(1)])
+    end
+
+    specify "#split can be zipped" do
+      expect(Money.new(100).split(3).zip(Money.new(50).split(3)).to_a).to eq([
+        [Money.new(33.34), Money.new(16.67)],
+        [Money.new(33.33), Money.new(16.67)],
+        [Money.new(33.33), Money.new(16.66)],
+      ])
     end
 
     specify "#gives 1 cent to both people if we start with 2" do
-      expect(Money.new(0.02).split(2)).to eq([Money.new(0.01), Money.new(0.01)])
+      expect(Money.new(0.02).split(2).to_a).to eq([Money.new(0.01), Money.new(0.01)])
     end
 
     specify "#split may distribute no money to some parties if there isnt enough to go around" do
-      expect(Money.new(0.02).split(3)).to eq([Money.new(0.01), Money.new(0.01), Money.new(0)])
+      expect(Money.new(0.02).split(3).to_a).to eq([Money.new(0.01), Money.new(0.01), Money.new(0)])
     end
 
     specify "#split does not lose pennies" do
-      expect(Money.new(0.05).split(2)).to eq([Money.new(0.03), Money.new(0.02)])
+      expect(Money.new(0.05).split(2).to_a).to eq([Money.new(0.03), Money.new(0.02)])
     end
 
     specify "#split does not lose dollars with non-decimal currencies" do
-      expect(Money.new(5, 'JPY').split(2)).to eq([Money.new(3, 'JPY'), Money.new(2, 'JPY')])
+      expect(Money.new(5, 'JPY').split(2).to_a).to eq([Money.new(3, 'JPY'), Money.new(2, 'JPY')])
     end
 
     specify "#split a dollar" do
@@ -754,6 +792,41 @@ RSpec.describe "Money" do
       expect(moneys[1].value).to eq(33)
       expect(moneys[2].value).to eq(33)
     end
+
+    specify "#split return respond to #first" do
+      expect(Money.new(100).split(3).first).to eq(Money.new(33.34))
+      expect(Money.new(100).split(3).first(2)).to eq([Money.new(33.34), Money.new(33.33)])
+
+      expect(Money.new(100).split(10).first).to eq(Money.new(10))
+      expect(Money.new(100).split(10).first(2)).to eq([Money.new(10), Money.new(10)])
+      expect(Money.new(20).split(2).first(4)).to eq([Money.new(10), Money.new(10)])
+    end
+
+    specify "#split return respond to #last" do
+      expect(Money.new(100).split(3).last).to eq(Money.new(33.33))
+      expect(Money.new(100).split(3).last(2)).to eq([Money.new(33.33), Money.new(33.33)])
+      expect(Money.new(20).split(2).last(4)).to eq([Money.new(10), Money.new(10)])
+    end
+
+    specify "#split return supports destructuring" do
+      first, second = Money.new(100).split(3)
+      expect(first).to eq(Money.new(33.34))
+      expect(second).to eq(Money.new(33.33))
+
+      first, *rest = Money.new(100).split(3)
+      expect(first).to eq(Money.new(33.34))
+      expect(rest).to eq([Money.new(33.33), Money.new(33.33)])
+    end
+
+    specify "#split return can be reversed" do
+      list = Money.new(100).split(3)
+      expect(list.first).to eq(Money.new(33.34))
+      expect(list.last).to eq(Money.new(33.33))
+
+      list = list.reverse
+      expect(list.first).to eq(Money.new(33.33))
+      expect(list.last).to eq(Money.new(33.34))
+    end
   end
 
   describe "calculate_splits" do

data/spec/splitter_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'yaml'
+
+RSpec.describe "Money::Splitter" do
+  specify "#split needs at least one party" do
+    expect {Money.new(1).split(0)}.to raise_error(ArgumentError)
+    expect {Money.new(1).split(-1)}.to raise_error(ArgumentError)
+    expect {Money.new(1).split(0.1)}.to raise_error(ArgumentError)
+    expect(Money.new(1).split(BigDecimal("0.1e1")).to_a).to eq([Money.new(1)])
+  end
+
+  specify "#split can be zipped" do
+    expect(Money.new(100).split(3).zip(Money.new(50).split(3)).to_a).to eq([
+      [Money.new(33.34), Money.new(16.67)],
+      [Money.new(33.33), Money.new(16.67)],
+      [Money.new(33.33), Money.new(16.66)],
+    ])
+  end
+
+  specify "#gives 1 cent to both people if we start with 2" do
+    expect(Money.new(0.02).split(2).to_a).to eq([Money.new(0.01), Money.new(0.01)])
+  end
+
+  specify "#split may distribute no money to some parties if there isnt enough to go around" do
+    expect(Money.new(0.02).split(3).to_a).to eq([Money.new(0.01), Money.new(0.01), Money.new(0)])
+  end
+
+  specify "#split does not lose pennies" do
+    expect(Money.new(0.05).split(2).to_a).to eq([Money.new(0.03), Money.new(0.02)])
+  end
+
+  specify "#split does not lose dollars with non-decimal currencies" do
+    expect(Money.new(5, 'JPY').split(2).to_a).to eq([Money.new(3, 'JPY'), Money.new(2, 'JPY')])
+  end
+
+  specify "#split a dollar" do
+    moneys = Money.new(1).split(3)
+    expect(moneys[0].subunits).to eq(34)
+    expect(moneys[1].subunits).to eq(33)
+    expect(moneys[2].subunits).to eq(33)
+  end
+
+  specify "#split a 100 yen" do
+    moneys = Money.new(100, 'JPY').split(3)
+    expect(moneys[0].value).to eq(34)
+    expect(moneys[1].value).to eq(33)
+    expect(moneys[2].value).to eq(33)
+  end
+
+  specify "#split return respond to #first" do
+    expect(Money.new(100).split(3).first).to eq(Money.new(33.34))
+    expect(Money.new(100).split(3).first(2)).to eq([Money.new(33.34), Money.new(33.33)])
+
+    expect(Money.new(100).split(10).first).to eq(Money.new(10))
+    expect(Money.new(100).split(10).first(2)).to eq([Money.new(10), Money.new(10)])
+    expect(Money.new(20).split(2).first(4)).to eq([Money.new(10), Money.new(10)])
+  end
+
+  specify "#split return respond to #last" do
+    expect(Money.new(100).split(3).last).to eq(Money.new(33.33))
+    expect(Money.new(100).split(3).last(2)).to eq([Money.new(33.33), Money.new(33.33)])
+    expect(Money.new(20).split(2).last(4)).to eq([Money.new(10), Money.new(10)])
+  end
+
+  specify "#split return supports destructuring" do
+    first, second = Money.new(100).split(3)
+    expect(first).to eq(Money.new(33.34))
+    expect(second).to eq(Money.new(33.33))
+
+    first, *rest = Money.new(100).split(3)
+    expect(first).to eq(Money.new(33.34))
+    expect(rest).to eq([Money.new(33.33), Money.new(33.33)])
+  end
+
+  specify "#split return can be reversed" do
+    list = Money.new(100).split(3)
+    expect(list.first).to eq(Money.new(33.34))
+    expect(list.last).to eq(Money.new(33.33))
+
+    list = list.reverse
+    expect(list.first).to eq(Money.new(33.33))
+    expect(list.last).to eq(Money.new(33.34))
+  end
+
+  describe "calculate_splits" do
+    specify "#calculate_splits gives 1 cent to both people if we start with 2" do
+      actual = Money.new(0.02, 'CAD').calculate_splits(2)
+
+      expect(actual).to eq({
+        Money.new(0.01, 'CAD') => 2,
+      })
+    end
+
+    specify "#calculate_splits gives an extra penny to one" do
+      actual = Money.new(0.04, 'CAD').calculate_splits(3)
+
+      expect(actual).to eq({
+        Money.new(0.02, 'CAD') => 1,
+        Money.new(0.01, 'CAD') => 2,
+      })
+    end
+  end
+end