shopify-money 1.3.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 968f61cd2788112e0310dad876e0100eef9bdc375b39d10b7a34e98cb23650fc
-  data.tar.gz: 279e00665cf1561add517a797afc0d732410813233da3dfe6c09225de9108445
+  metadata.gz: 75ba2eb41fa1e50dac837fab61774cdb4a05407b030cb7ba2989b60de27bbfe4
+  data.tar.gz: e612602f0f07fe052e6a2e53046e7b6b9a05c56775a75c6a3e4d1f7984671a49
 SHA512:
-  metadata.gz: 5abf64ebc32b62bbb31906b977a05e66362dc68453c454efedfe0c83ae5743454c526882fbec437f4874d36ae5d384947c64175a8d50fba0fb339c58d77500c5
-  data.tar.gz: 76a439a0dca761dc12b3fd44e90737aee88fe26f11ed20af1ab9eba45ce20d6fa55265c9130ee034548d5b799621eef4d328808ca12fcfdcca6b02e258a496b4
+  metadata.gz: ffa8231621bc6d26f446425cab725e4a3fdcef5a5ec1c7bc240f6397c6fd07514863b56a44c89b413c4750f4a20eb8b218500ea2ab5c0120b7c158f5a24b9a46
+  data.tar.gz: 6b9582714d55a4e1150b01fcb3eada86751f6408b943811570470c88fda04a7e9db8fdc8a1da65ff46bdf465eb641be521ac474fe1ec6dcc952598d6c32594c0

data/.github/workflows/tests.yml

@@ -1,7 +1,7 @@
 name: tests
 
 on: [push, pull_request]
-  
+
 jobs:
   build:
 
@@ -9,7 +9,7 @@ jobs:
 
     strategy:
       matrix:
-        ruby: ['2.6', '2.7', '3.0', '3.1', '3.2']
+        ruby: ['3.0', '3.1', '3.2', '3.3']
 
     name: Ruby ${{ matrix.ruby }}
     steps:

data/.gitignore

@@ -46,6 +46,5 @@ pkg
 
 # For rubinius:
 #*.rbc
-Gemfile.lock
 
-.rspec_status
+.rspec_status

data/.ruby-version

@@ -0,0 +1 @@
+3.3.0

data/Gemfile.lock

@@ -0,0 +1,234 @@
+PATH
+  remote: .
+  specs:
+    shopify-money (2.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (6.1.7.7)
+      actionpack (= 6.1.7.7)
+      activesupport (= 6.1.7.7)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailbox (6.1.7.7)
+      actionpack (= 6.1.7.7)
+      activejob (= 6.1.7.7)
+      activerecord (= 6.1.7.7)
+      activestorage (= 6.1.7.7)
+      activesupport (= 6.1.7.7)
+      mail (>= 2.7.1)
+    actionmailer (6.1.7.7)
+      actionpack (= 6.1.7.7)
+      actionview (= 6.1.7.7)
+      activejob (= 6.1.7.7)
+      activesupport (= 6.1.7.7)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 2.0)
+    actionpack (6.1.7.7)
+      actionview (= 6.1.7.7)
+      activesupport (= 6.1.7.7)
+      rack (~> 2.0, >= 2.0.9)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actiontext (6.1.7.7)
+      actionpack (= 6.1.7.7)
+      activerecord (= 6.1.7.7)
+      activestorage (= 6.1.7.7)
+      activesupport (= 6.1.7.7)
+      nokogiri (>= 1.8.5)
+    actionview (6.1.7.7)
+      activesupport (= 6.1.7.7)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (6.1.7.7)
+      activesupport (= 6.1.7.7)
+      globalid (>= 0.3.6)
+    activemodel (6.1.7.7)
+      activesupport (= 6.1.7.7)
+    activerecord (6.1.7.7)
+      activemodel (= 6.1.7.7)
+      activesupport (= 6.1.7.7)
+    activestorage (6.1.7.7)
+      actionpack (= 6.1.7.7)
+      activejob (= 6.1.7.7)
+      activerecord (= 6.1.7.7)
+      activesupport (= 6.1.7.7)
+      marcel (~> 1.0)
+      mini_mime (>= 1.1.0)
+    activesupport (6.1.7.7)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    ast (2.4.2)
+    builder (3.2.4)
+    byebug (11.1.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.2.3)
+    crass (1.0.6)
+    database_cleaner (1.99.0)
+    date (3.3.4)
+    diff-lcs (1.5.1)
+    docile (1.4.0)
+    erubi (1.12.0)
+    globalid (1.2.1)
+      activesupport (>= 6.1)
+    i18n (1.14.4)
+      concurrent-ruby (~> 1.0)
+    jaro_winkler (1.5.6)
+    loofah (2.22.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    mail (2.8.1)
+      mini_mime (>= 0.1.1)
+      net-imap
+      net-pop
+      net-smtp
+    marcel (1.0.4)
+    method_source (1.0.0)
+    mini_mime (1.1.5)
+    minitest (5.22.3)
+    net-imap (0.4.10)
+      date
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.2.2)
+      timeout
+    net-smtp (0.5.0)
+      net-protocol
+    nio4r (2.7.1)
+    nokogiri (1.16.3-aarch64-linux)
+      racc (~> 1.4)
+    nokogiri (1.16.3-arm-linux)
+      racc (~> 1.4)
+    nokogiri (1.16.3-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.16.3-x86-linux)
+      racc (~> 1.4)
+    nokogiri (1.16.3-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.16.3-x86_64-linux)
+      racc (~> 1.4)
+    parallel (1.24.0)
+    parser (3.3.0.5)
+      ast (~> 2.4.1)
+      racc
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.10.1)
+      byebug (~> 11.0)
+      pry (>= 0.13, < 0.15)
+    racc (1.7.3)
+    rack (2.2.9)
+    rack-test (2.1.0)
+      rack (>= 1.3)
+    rails (6.1.7.7)
+      actioncable (= 6.1.7.7)
+      actionmailbox (= 6.1.7.7)
+      actionmailer (= 6.1.7.7)
+      actionpack (= 6.1.7.7)
+      actiontext (= 6.1.7.7)
+      actionview (= 6.1.7.7)
+      activejob (= 6.1.7.7)
+      activemodel (= 6.1.7.7)
+      activerecord (= 6.1.7.7)
+      activestorage (= 6.1.7.7)
+      activesupport (= 6.1.7.7)
+      bundler (>= 1.15.0)
+      railties (= 6.1.7.7)
+      sprockets-rails (>= 2.0.0)
+    rails-dom-testing (2.2.0)
+      activesupport (>= 5.0.0)
+      minitest
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.6.0)
+      loofah (~> 2.21)
+      nokogiri (~> 1.14)
+    railties (6.1.7.7)
+      actionpack (= 6.1.7.7)
+      activesupport (= 6.1.7.7)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+    rainbow (3.1.1)
+    rake (13.2.0)
+    rexml (3.2.6)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+    rubocop (0.81.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.7.0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      rexml
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    ruby-progressbar (1.13.0)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    sprockets (4.2.1)
+      concurrent-ruby (~> 1.0)
+      rack (>= 2.2.4, < 4)
+    sprockets-rails (3.4.2)
+      actionpack (>= 5.2)
+      activesupport (>= 5.2)
+      sprockets (>= 3.0.0)
+    sqlite3 (1.7.3-aarch64-linux)
+    sqlite3 (1.7.3-arm-linux)
+    sqlite3 (1.7.3-arm64-darwin)
+    sqlite3 (1.7.3-x86-linux)
+    sqlite3 (1.7.3-x86_64-darwin)
+    sqlite3 (1.7.3-x86_64-linux)
+    thor (1.3.1)
+    timeout (0.4.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (1.8.0)
+    websocket-driver (0.7.6)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.6.13)
+
+PLATFORMS
+  aarch64-linux
+  arm-linux
+  arm64-darwin
+  x86-linux
+  x86_64-darwin
+  x86_64-linux
+
+DEPENDENCIES
+  bundler
+  database_cleaner (~> 1.6)
+  pry-byebug
+  rails (~> 6.0)
+  rspec (~> 3.2)
+  rubocop (~> 0.81.0)
+  shopify-money!
+  simplecov
+  sqlite3
+
+BUNDLED WITH
+   2.5.3

data/README.md

@@ -11,7 +11,8 @@ money_column expects a DECIMAL(21,3) database field.
 - Provides a `Money::Currency` class which encapsulates all information about a monetary unit.
 - Represents monetary values as decimals. No need to convert your amounts every time you use them. Easily understand the data in your DB.
 - Does NOT provide APIs for exchanging money from one currency to another.
-- Will not lose pennies during divisions
+- Will not lose pennies during divisions. For instance, given $1 / 3 the resulting chunks will be .34, .33, and .33. Notice that one chunk is larger than the others, so the result still adds to $1.
+- Allows callers to select a rounding strategy when dividing, to determine the order in which leftover pennies are given out.
 
 ## Installation
 
@@ -29,7 +30,7 @@ require 'money'
 # 10.00 USD
 money = Money.new(10.00, "USD")
 money.subunits     #=> 1000
-money.currency  #=> Currency.new("USD")
+money.currency     #=> Money::Currency.new("USD")
 
 # Comparisons
 Money.new(1000, "USD") == Money.new(1000, "USD")   #=> true
@@ -40,13 +41,54 @@ Money.new(1000, "USD") != Money.new(1000, "EUR")   #=> true
 # Arithmetic
 Money.new(1000, "USD") + Money.new(500, "USD") == Money.new(1500, "USD")
 Money.new(1000, "USD") - Money.new(200, "USD") == Money.new(800, "USD")
-Money.new(1000, "USD") / 5                     == Money.new(200, "USD")
 Money.new(1000, "USD") * 5                     == Money.new(5000, "USD")
 
+m = Money.new(1000, "USD")
+# Splitting money evenly
+m.split(2)              == [Money.new(500, "USD"), Money.new(500, "USD")]
+m.split(3).map(&:value) == [333.34, 333.33, 333.33]
+m.calculate_splits(2)   == { Money.new(500, "USD") => 2 }
+m.calculate_splits(3)   == { Money.new(333.34, "USD") => 1, Money.new(333.33, "USD") =>2 }
+
+# Allocating money proportionally
+m.allocate([0.50, 0.25, 0.25]).map(&:value)               == [500, 250, 250]
+m.allocate([Rational(2, 3), Rational(1, 3)]).map(&:value) == [666.67, 333.33]
+
+## Allocating up to a cutoff
+m.allocate_max_amounts([500, 300, 200]).map(&:value) == [500, 300, 200]
+m.allocate_max_amounts([500, 300, 300]).map(&:value) == [454.55, 272.73, 272.72]
+
+## Selectable rounding strategies during division
+
+# Assigns leftover subunits left to right
+m = Money::Allocator.new(Money.new(10.55, "USD"))
+monies = m.allocate([0.25, 0.5, 0.25], :roundrobin)
+#monies[0] == 2.64  <-- gets 1 penny
+#monies[1] == 5.28  <-- gets 1 penny
+#monies[2] == 2.63  <-- gets no penny
+
+# Assigns leftover subunits right to left
+m = Money::Allocator.new(Money.new(10.55, "USD"))
+monies = m.allocate([0.25, 0.5, 0.25], :roundrobin_reverse)
+#monies[0] == 2.63  <-- gets no penny
+#monies[1] == 5.28  <-- gets 1 penny
+#monies[2] == 2.64  <-- gets 1 penny
+
+# Assigns leftover subunits to the nearest whole subunit
+m = Money::Allocator.new(Money.new(10.55, "USD"))
+monies = m.allocate([0.25, 0.5, 0.25], :nearest)
+#monies[0] == 2.64  <-- gets 1 penny
+#monies[1] == 5.27  <-- gets no penny
+#monies[2] == 2.64  <-- gets 1 penny
+# $2.6375 is closer to the next whole penny than $5.275
+
+# Clamp
+Money.new(50, "USD").clamp(1, 100) == Money.new(50, "USD")
+
 # Unit to subunit conversions
-Money.from_subunits(500, "USD") == Money.new(5, "USD")  # 5 USD
-Money.from_subunits(5, "JPY") == Money.new(5, "JPY")    # 5 JPY
-Money.from_subunits(5000, "TND") == Money.new(5, "TND") # 5 TND
+Money.from_subunits(500, "USD")  == Money.new(5, "USD")   # 5 USD
+Money.from_subunits(5, "JPY")    == Money.new(5, "JPY")   # 5 JPY
+Money.from_subunits(5000, "TND") == Money.new(5, "TND")   # 5 TND
 ```
 
 ## Currency

data/dev.yml

@@ -3,7 +3,7 @@
 ---
 name: money
 up:
-- ruby: 3.2.0
+- ruby
 - bundler
 commands:
   test: bundle exec rspec

data/lib/money/allocator.rb

@@ -9,18 +9,27 @@ class Money
 
     ONE = BigDecimal("1")
 
-    # 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
+    # Allocates money between different parties without losing subunits. A "subunit"
+    # in this context is the smallest unit of a currency that can be divided no
+    # further. In USD the unit is dollars and the subunit is cents. In JPY the unit
+    # is yen and the subunit is also yen. So given $1 divided by 3, the resulting subunits
+    # should be [34¢, 33¢, 33¢]. Notice that one of these chunks is larger than the other
+    # two, because we cannot transact in amounts less than 1 subunit.
+    #
+    # After the mathematically split has been performed, left over subunits will
+    # be distributed round-robin or nearest-subunit strategy amongst the parties.
+    # Round-robin strategy has the virtue of being easier to understand, while
+    # nearest-subunit is a more complex alogirthm that results in the most fair
+    # distribution.
     #
     # @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
+    # - `:roundrobin` (default): leftover subunits will be accumulated starting from the first allocation left to right
+    # - `:roundrobin_reverse`: leftover subunits will be accumulated starting from the last allocation right to left
+    # - `:nearest`: leftover subunits will by given first to the party closest to the next whole subunit
     #
     # @example
     #   Money.new(5, "USD").allocate([0.50, 0.25, 0.25])
@@ -38,29 +47,49 @@ class Money
     #   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
+    # @example left over subunits 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>]
+
+    # @examples left over subunits distributed by nearest strategy
+    #   Money.new(10.55, "USD").allocate([0.25, 0.5, 0.25], :nearest)
+    #     #=> [#<Money value:2.64 currency:USD>, #<Money value:5.27 currency:USD>, #<Money value:2.64 currency:USD>]
+
     def allocate(splits, strategy = :roundrobin)
+      if splits.empty?
+        raise ArgumentError, 'at least one split must be provided'
+      end
+
       splits.map!(&:to_r)
       allocations = splits.inject(0, :+)
 
       if (allocations - ONE) > Float::EPSILON
-        raise ArgumentError, "splits add to more than 100%"
+        raise ArgumentError, "allocations add to more than 100%"
       end
 
       amounts, left_over = amounts_from_splits(allocations, splits)
 
+      order = case strategy
+      when :roundrobin
+        (0...left_over).to_a
+      when :roundrobin_reverse
+        (0...amounts.length).to_a.reverse
+      when :nearest
+        rank_by_nearest(amounts)
+      else
+        raise ArgumentError, "Invalid strategy. Valid options: :roundrobin, :roundrobin_reverse, :nearest"
+      end
+
       left_over.to_i.times do |i|
-        amounts[allocation_index_for(strategy, amounts.length, i)] += 1
+        amounts[order[i]][:whole_subunits] += 1
       end
 
-      amounts.collect { |subunits| Money.from_subunits(subunits, currency) }
+      amounts.map { |amount| Money.from_subunits(amount[:whole_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.
+    # Left over subunits will be assigned round-robin up to the maximum specified.
+    # Subunits are dropped when the maximums are attained.
     #
     # @example
     #   Money.new(30.75).allocate_max_amounts([Money.new(26), Money.new(4.75)])
@@ -90,6 +119,7 @@ class Money
       total_allocatable = [maximums_total.subunits, self.subunits].min
 
       subunits_amounts, left_over = amounts_from_splits(1, splits, total_allocatable)
+      subunits_amounts.map! { |amount| amount[:whole_subunits] }
 
       subunits_amounts.each_with_index do |amount, index|
         break unless left_over > 0
@@ -119,10 +149,14 @@ class Money
 
       left_over = subunits_to_split
 
-      amounts = splits.collect do |ratio|
-        frac = (subunits_to_split * ratio / allocations.to_r).floor
-        left_over -= frac
-        frac
+      amounts = splits.map do |ratio|
+        whole_subunits = (subunits_to_split * ratio / allocations.to_r).floor
+        fractional_subunits = (subunits_to_split * ratio / allocations.to_r).to_f - whole_subunits
+        left_over -= whole_subunits
+        {
+          :whole_subunits => whole_subunits,
+          :fractional_subunits => fractional_subunits
+        }
       end
 
       [amounts, left_over]
@@ -132,15 +166,13 @@ class Money
       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
+    # Given a list of decimal numbers, return a list ordered by which is nearest to the next whole number.
+    # For instance, given inputs [1.1, 1.5, 1.9] the correct ranking is 2, 1, 0. This is because 1.9 is nearly 2.
+    # Note that we are not ranking by absolute size, we only care about the distance between our input number and
+    # the next whole number. Similarly, given the input [9.1, 5.5, 3.9] the correct ranking is *still* 2, 1, 0. This
+    # is because 3.9 is nearer to 4 than 9.1 is to 10.
+    def rank_by_nearest(amounts)
+      amounts.each_with_index.sort_by{ |amount, i| 1 - amount[:fractional_subunits] }.map(&:last)
     end
   end
 end

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,20 @@ class Money
         Money.current_currency = old_currency
       end
     end
+
+    private
+
+    def new_from_money(amount, currency)
+      return amount if amount.currency.compatible?(Helpers.value_to_currency(currency))
+
+      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
 
@@ -137,13 +177,8 @@ class Money
   end
 
   def *(numeric)
-    unless numeric.is_a?(Numeric)
-      if Money.config.legacy_deprecations
-        Money.deprecate("Multiplying Money with #{numeric.class.name} is deprecated and will be removed in the next major release.")
-      else
-        raise ArgumentError, "Money objects can only be multiplied by a Numeric"
-      end
-    end
+    raise ArgumentError, "Money objects can only be multiplied by a Numeric" unless numeric.is_a?(Numeric)
+
     return self if numeric == 1
     Money.new(value.to_r * numeric, currency)
   end
@@ -167,43 +202,22 @@ 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 no_currency?
+      return Money.new(value, new_currency)
+    end
+
+    unless currency.compatible?(Helpers.value_to_currency(new_currency))
+      msg = "to_money is attempting to change currency of an existing money object from #{currency} to #{new_currency}"
       if Money.config.legacy_deprecations
         Money.deprecate("#{msg}. A Money::IncompatibleCurrencyError will raise in the next major release")
       else
@@ -298,12 +312,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.
@@ -318,17 +332,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
@@ -355,10 +359,24 @@ 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)
+    case money_or_numeric
+    when Money
+      unless currency.compatible?(money_or_numeric.currency)
+        msg = "mathematical operation not permitted for Money objects with different currencies #{money_or_numeric.currency} 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
+      end
+      yield(money_or_numeric)
+
+    when Numeric
+      yield(Money.new(money_or_numeric, currency))
 
-    yield(other)
+    else
+      raise TypeError, "#{money_or_numeric.class.name} can't be coerced into Money"
+    end
   end
 
   def calculated_currency(other)