shopify-money 2.0.0 → 2.2.1

data/lib/money/money.rb

@@ -10,6 +10,30 @@ class Money
   attr_reader :value, :currency
   def_delegators :@value, :zero?, :nonzero?, :positive?, :negative?, :to_i, :to_f, :hash
 
+  class ReverseOperationProxy
+    include Comparable
+
+    def initialize(value)
+      @value = value
+    end
+
+    def <=>(other)
+      -(other <=> @value)
+    end
+
+    def +(other)
+      other + @value
+    end
+
+    def -(other)
+      -(other - @value)
+    end
+
+    def *(other)
+      other * @value
+    end
+  end
+
   class << self
     extend Forwardable
     attr_accessor :config
@@ -21,6 +45,8 @@ class Money
     end
 
     def new(value = 0, currency = nil)
+      return new_from_money(value, currency) if value.is_a?(Money)
+
       value = Helpers.value_to_decimal(value)
       currency = Helpers.value_to_currency(currency)
 
@@ -76,6 +102,28 @@ class Money
         Money.current_currency = old_currency
       end
     end
+
+    private
+
+    def new_from_money(amount, currency)
+      currency = Helpers.value_to_currency(currency)
+
+      if amount.no_currency?
+        return Money.new(amount.value, currency)
+      end
+
+      if amount.currency.compatible?(currency)
+        return amount
+      end
+
+      msg = "Money.new is attempting to change currency of an existing money object"
+      if Money.config.legacy_deprecations
+        Money.deprecate("#{msg}. A Money::IncompatibleCurrencyError will raise in the next major release")
+        return Money.new(amount.value, currency)
+      else
+        raise Money::IncompatibleCurrencyError, msg
+      end
+    end
   end
   configure
 
@@ -162,50 +210,23 @@ class Money
     value == other.value
   end
 
-  class ReverseOperationProxy
-    include Comparable
-
-    def initialize(value)
-      @value = value
-    end
-
-    def <=>(other)
-      -(other <=> @value)
-    end
-
-    def +(other)
-      other + @value
-    end
-
-    def -(other)
-      -(other - @value)
-    end
-
-    def *(other)
-      other * @value
-    end
-  end
-
   def coerce(other)
     raise TypeError, "Money can't be coerced into #{other.class}" unless other.is_a?(Numeric)
     [ReverseOperationProxy.new(other), self]
   end
 
-  def to_money(curr = nil)
-    if !curr.nil? && no_currency?
-      return Money.new(value, curr)
+  def to_money(new_currency = nil)
+    if new_currency.nil?
+      return self
     end
 
-    curr = Helpers.value_to_currency(curr)
-    unless currency.compatible?(curr)
-      msg = "mathematical operation not permitted for Money objects with different currencies #{curr} and #{currency}"
-      if Money.config.legacy_deprecations
-        Money.deprecate("#{msg}. A Money::IncompatibleCurrencyError will raise in the next major release")
-      else
-        raise Money::IncompatibleCurrencyError, msg
-      end
+    if no_currency?
+      return Money.new(value, new_currency)
     end
 
+    ensure_compatible_currency(Helpers.value_to_currency(new_currency),
+      "to_money is attempting to change currency of an existing money object from #{currency} to #{new_currency}")
+
     self
   end
 
@@ -293,12 +314,12 @@ class Money
   #
   # @param [2] number of parties.
   #
-  # @return [Array<Money, Money, Money>]
+  # @return [Enumerable<Money, Money, Money>]
   #
   # @example
-  #   Money.new(100, "USD").split(3) #=> [Money.new(34), Money.new(33), Money.new(33)]
+  #   Money.new(100, "USD").split(3) #=> Enumerable[Money.new(34), Money.new(33), Money.new(33)]
   def split(num)
-    calculate_splits(num).sum([]) { |value, count| Array.new(count, value) }
+    Splitter.new(self, num)
   end
 
   # Calculate the splits evenly without losing pennies.
@@ -313,17 +334,7 @@ class Money
   # @example
   #   Money.new(100, "USD").calculate_splits(3) #=> {Money.new(34) => 1, Money.new(33) => 2}
   def calculate_splits(num)
-    raise ArgumentError, "need at least one party" if num < 1
-    subunits = self.subunits
-    low = Money.from_subunits(subunits / num, currency)
-    high = Money.from_subunits(low.subunits + 1, currency)
-
-    num_high = subunits % num
-
-    {}.tap do |result|
-      result[high] = num_high if num_high > 0
-      result[low] = num - num_high
-    end
+    Splitter.new(self, num).split.dup
   end
 
   # Clamps the value to be within the specified minimum and maximum. Returns
@@ -349,11 +360,34 @@ class Money
 
   private
 
-  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)
+  def arithmetic(other)
+    case other
+    when Money
+      ensure_compatible_currency(other.currency,
+        "mathematical operation not permitted for Money objects with different currencies #{other.currency} and #{currency}.")
+      yield(other)
 
-    yield(other)
+    when Numeric, String
+      yield(Money.new(other, currency))
+
+    else
+      if Money.config.legacy_deprecations && other.respond_to?(:to_money)
+        Money.deprecate("#{other.inspect} is being implicitly coerced into a Money object. Call `to_money` on this object to transform it into a money explicitly. An TypeError will raise in the next major release")
+        yield(other.to_money(currency))
+      else
+        raise TypeError, "#{other.class.name} can't be coerced into Money"
+      end
+    end
+  end
+
+  def ensure_compatible_currency(other_currency, msg)
+    return if currency.compatible?(other_currency)
+
+    if Money.config.legacy_deprecations
+      Money.deprecate("#{msg}. A Money::IncompatibleCurrencyError will raise in the next major release")
+    else
+      raise Money::IncompatibleCurrencyError, msg
+    end
   end
 
   def calculated_currency(other)

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.1"
 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/lib/rubocop/cop/money.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
 
 require 'rubocop/cop/money/missing_currency'
-require 'rubocop/cop/money/unsafe_to_money'
 require 'rubocop/cop/money/zero_money'

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