shopify-money 2.0.0 → 2.2.1

data/spec/money_spec.rb

@@ -30,15 +30,30 @@ 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 "#to_money works with money objects that doesn't have a currency" do
+    money = Money.new(1, Money::NULL_CURRENCY).to_money('USD')
+    expect(money.value).to eq(1)
+    expect(money.currency.to_s).to eq('USD')
+
+    money = Money.new(1, 'USD').to_money(Money::NULL_CURRENCY)
+    expect(money.value).to eq(1)
+    expect(money.currency.to_s).to eq('USD')
+  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 +70,40 @@ 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))
+    expect(Money.new(Money.new(1, "USD"), "USD")).to eq(Money.new(1, "USD"))
+  end
+
+  it "can be constructed with a money object with a null currency" do
+    money = Money.new(Money.new(1, Money::NULL_CURRENCY), 'USD')
+    expect(money.value).to eq(1)
+    expect(money.currency.to_s).to eq('USD')
+
+    money = Money.new(Money.new(1, 'USD'), Money::NULL_CURRENCY)
+    expect(money.value).to eq(1)
+    expect(money.currency.to_s).to eq('USD')
+  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 +241,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
@@ -528,13 +577,49 @@ RSpec.describe "Money" do
         it { expect(cad_10 == usd_10).to(eq(false)) }
       end
 
-      describe('to_money types') do
+      describe('coerced types') do
         it { expect(cad_10 <=> 10.00).to(eq(0)) }
         it { expect(cad_10 >   10.00).to(eq(false)) }
         it { expect(cad_10 >=  10.00).to(eq(true)) }
         it { expect(cad_10 ==  10.00).to(eq(false)) }
         it { expect(cad_10 <=  10.00).to(eq(true)) }
         it { expect(cad_10 <   10.00).to(eq(false)) }
+        it { expect(cad_10 <=>'10.00').to(eq(0)) }
+        it { expect(cad_10 >  '10.00').to(eq(false)) }
+        it { expect(cad_10 >= '10.00').to(eq(true)) }
+        it { expect(cad_10 == '10.00').to(eq(false)) }
+        it { expect(cad_10 <= '10.00').to(eq(true)) }
+        it { expect(cad_10 <  '10.00').to(eq(false)) }
+      end
+
+      describe('to_money coerced types') do
+        let(:coercible_object) do
+          double("coercible_object").tap do |mock|
+            allow(mock).to receive(:to_money).with(any_args) { |currency| Money.new(10, currency) }
+          end
+        end
+
+        it { expect { cad_10 <=> coercible_object }.to(raise_error(TypeError)) }
+        it { expect { cad_10 >   coercible_object }.to(raise_error(TypeError)) }
+        it { expect { cad_10 >=  coercible_object }.to(raise_error(TypeError)) }
+        it { expect { cad_10 <=  coercible_object }.to(raise_error(TypeError)) }
+        it { expect { cad_10 <   coercible_object }.to(raise_error(TypeError)) }
+        it { expect { cad_10 +   coercible_object }.to(raise_error(TypeError)) }
+        it { expect { cad_10 -   coercible_object }.to(raise_error(TypeError)) }
+
+        describe('with legacy_deprecations') do
+          around(:each) do |test|
+            configure(legacy_deprecations: true) { test.run }
+          end
+
+          it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <=> coercible_object).to(eq(0)) }
+          it { expect(Money).to(receive(:deprecate).once); expect(cad_10 >   coercible_object).to(eq(false)) }
+          it { expect(Money).to(receive(:deprecate).once); expect(cad_10 >=  coercible_object).to(eq(true)) }
+          it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <=  coercible_object).to(eq(true)) }
+          it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <   coercible_object).to(eq(false)) }
+          it { expect(Money).to(receive(:deprecate).once); expect(cad_10 +   coercible_object).to(eq(Money.new(20, 'CAD'))) }
+          it { expect(Money).to(receive(:deprecate).once); expect(cad_10 -   coercible_object).to(eq(Money.new(0, 'CAD'))) }
+        end
       end
     end
 
@@ -723,22 +808,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 +849,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shopify-money
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Shopify Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-30 00:00:00.000000000 Z
+date: 2024-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,16 +84,16 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.2
+        version: '0'
 description: Manage money in Shopify with a class that wont lose pennies during division!
 email: gems@shopify.com
 executables:
@@ -106,7 +106,9 @@ files:
 - ".github/workflows/tests.yml"
 - ".gitignore"
 - ".rspec"
+- ".ruby-version"
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -133,6 +135,7 @@ files:
 - lib/money/parser/simple.rb
 - lib/money/rails/job_argument_serializer.rb
 - lib/money/railtie.rb
+- lib/money/splitter.rb
 - lib/money/version.rb
 - lib/money_column.rb
 - lib/money_column/active_record_hooks.rb
@@ -140,7 +143,6 @@ files:
 - lib/money_column/railtie.rb
 - lib/rubocop/cop/money.rb
 - lib/rubocop/cop/money/missing_currency.rb
-- lib/rubocop/cop/money/unsafe_to_money.rb
 - lib/rubocop/cop/money/zero_money.rb
 - lib/shopify-money.rb
 - money.gemspec
@@ -161,11 +163,11 @@ files:
 - spec/rails/job_argument_serializer_spec.rb
 - spec/rails_spec_helper.rb
 - spec/rubocop/cop/money/missing_currency_spec.rb
-- spec/rubocop/cop/money/unsafe_to_money_spec.rb
 - spec/rubocop/cop/money/zero_money_spec.rb
 - spec/rubocop_helper.rb
 - spec/schema.rb
 - spec/spec_helper.rb
+- spec/splitter_spec.rb
 homepage: https://github.com/Shopify/money
 licenses:
 - MIT
@@ -186,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.5
+rubygems_version: 3.5.9
 signing_key: 
 specification_version: 4
 summary: Shopify's money gem
@@ -208,8 +210,8 @@ test_files:
 - spec/rails/job_argument_serializer_spec.rb
 - spec/rails_spec_helper.rb
 - spec/rubocop/cop/money/missing_currency_spec.rb
-- spec/rubocop/cop/money/unsafe_to_money_spec.rb
 - spec/rubocop/cop/money/zero_money_spec.rb
 - spec/rubocop_helper.rb
 - spec/schema.rb
 - spec/spec_helper.rb
+- spec/splitter_spec.rb

data/lib/rubocop/cop/money/unsafe_to_money.rb

@@ -1,35 +0,0 @@
-
-module RuboCop
-  module Cop
-    module Money
-      # Prevents the use of `to_money` because it has inconsistent behaviour.
-      # Use `Money.new` instead.
-      #
-      # @example
-      #  # bad
-      #  "2.000".to_money("USD")     #<Money value:2000.00 currency:USD>
-      #
-      #  # good
-      #  Money.new("2.000", "USD")   #<Money value:2.00 currency:USD>
-      class UnsafeToMoney < Cop
-        MSG = '`to_money` has inconsistent behaviour. Use `Money.new` instead.'.freeze
-
-        def on_send(node)
-          return unless node.method?(:to_money)
-          return if node.receiver.nil? || node.receiver.is_a?(AST::NumericNode)
-
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            receiver = node.receiver.source
-            args = node.arguments.map(&:source)
-            args.prepend(receiver)
-            corrector.replace(node.loc.expression, "Money.new(#{args.join(', ')})")
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/cop/money/unsafe_to_money_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../rubocop_helper'
-require 'rubocop/cop/money/unsafe_to_money'
-
-RSpec.describe RuboCop::Cop::Money::UnsafeToMoney do
-  subject(:cop) { described_class.new(config) }
-
-  let(:config) { RuboCop::Config.new }
-
-  context 'with default configuration' do
-    it 'does not register an offense for literal integer' do
-      expect_no_offenses(<<~RUBY)
-        1.to_money
-      RUBY
-    end
-
-    it 'does not register an offense for literal float' do
-      expect_no_offenses(<<~RUBY)
-        1.000.to_money
-      RUBY
-    end
-
-    it 'registers an offense and corrects for Money.new without a currency argument' do
-      expect_offense(<<~RUBY)
-        '2.000'.to_money
-                ^^^^^^^^ #{described_class::MSG}
-      RUBY
-
-      expect_correction(<<~RUBY)
-        Money.new('2.000')
-      RUBY
-    end
-
-    it 'registers an offense and corrects for Money.new with a currency argument' do
-      expect_offense(<<~RUBY)
-        '2.000'.to_money('USD')
-                ^^^^^^^^ #{described_class::MSG}
-      RUBY
-
-      expect_correction(<<~RUBY)
-        Money.new('2.000', 'USD')
-      RUBY
-    end
-
-    it 'registers an offense and corrects for Money.new with a complex receiver' do
-      expect_offense(<<~RUBY)
-        obj.money.to_money('USD')
-                  ^^^^^^^^ #{described_class::MSG}
-      RUBY
-
-      expect_correction(<<~RUBY)
-        Money.new(obj.money, 'USD')
-      RUBY
-    end
-
-    it 'does not register an offense for receiver-less calls' do
-      expect_no_offenses(<<~RUBY)
-        a = to_money
-      RUBY
-    end
-  end
-end