shopify-money 0.12.0 → 0.14.2

data/lib/money/null_currency.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class Money
   class NullCurrency
 

data/lib/money/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class Money
-  VERSION = "0.12.0"
+  VERSION = "0.14.2"
 end

data/lib/money_accessor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module MoneyAccessor
   def self.included(base)
     base.extend(ClassMethods)

data/lib/money_column.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'money_column/active_record_hooks'
 require_relative 'money_column/active_record_type'
 require_relative 'money_column/railtie'

data/lib/money_column/active_record_hooks.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module MoneyColumn
   module ActiveRecordHooks
     def self.included(base)
@@ -57,7 +58,7 @@ module MoneyColumn
       if options[:currency_read_only]
         currency_source = Money::Helpers.value_to_currency(currency_raw_source)
         if currency_raw_source && !money.currency.compatible?(currency_source)
-          Money.deprecate("[money_column] currency mismatch between #{currency_source} and #{money.currency}.")
+          Money.deprecate("[money_column] currency mismatch between #{currency_source} and #{money.currency} in column #{column}.")
         end
       else
         self[options[:currency_column]] = money.currency.to_s unless money.no_currency?

data/lib/money_column/active_record_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class MoneyColumn::ActiveRecordType < ActiveRecord::Type::Decimal
   def serialize(money)
     return nil unless money

data/lib/money_column/railtie.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module MoneyColumn
   class Railtie < Rails::Railtie
     ActiveSupport.on_load :active_record do

data/lib/rubocop/cop/money.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'rubocop/cop/money/missing_currency'

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Money
+      class MissingCurrency < Cop
+        # `Money.new()` without a currency argument cannot guarantee correctness:
+        # - no error raised for cross-currency computation (e.g. 5 CAD + 5 USD)
+        # - #subunits returns wrong values for 0 and 3 decimals currencies
+        #
+        # @example
+        #   # bad
+        #   Money.new(123.45)
+        #   Money.new
+        #   "1,234.50".to_money
+        #
+        #   # good
+        #   Money.new(123.45, 'CAD')
+        #   "1,234.50".to_money('CAD')
+        #
+
+        def_node_matcher :money_new, <<~PATTERN
+          (send (const nil? :Money) {:new :from_amount :from_cents} $...)
+        PATTERN
+
+        def_node_matcher :to_money_without_currency?, <<~PATTERN
+          (send _ :to_money)
+        PATTERN
+
+        def_node_matcher :to_money_block?, <<~PATTERN
+          (send _ _ (block_pass (sym :to_money)))
+        PATTERN
+
+        def on_send(node)
+          money_new(node) do |_amount, currency_arg|
+            return if currency_arg
+
+            add_offense(node, message: 'Money is missing currency argument')
+          end
+
+          if to_money_block?(node) || to_money_without_currency?(node)
+            add_offense(node, message: 'to_money is missing currency argument')
+          end
+        end
+
+        def autocorrect(node)
+          currency = cop_config['ReplacementCurrency']
+          return unless currency
+
+          receiver, method, _ = *node
+
+          lambda do |corrector|
+            money_new(node) do |amount, currency_arg|
+              return if currency_arg
+
+              corrector.replace(
+                node.loc.expression,
+                "#{receiver.source}.#{method}(#{amount&.source || 0}, '#{currency}')"
+              )
+            end
+
+            if to_money_without_currency?(node)
+              corrector.insert_after(node.loc.expression, "('#{currency}')")
+            elsif to_money_block?(node)
+              corrector.replace(
+                node.loc.expression,
+                "#{receiver.source}.#{method} { |x| x.to_money('#{currency}') }"
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify-money.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+require_relative 'money'

data/money.gemspec

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 require_relative "lib/money/version"
 
 Gem::Specification.new do |s|
@@ -12,13 +13,16 @@ Gem::Specification.new do |s|
   s.licenses = "MIT"
   s.summary = "Shopify's money gem"
 
+  s.metadata['allowed_push_host'] = "https://rubygems.org"
+
   s.add_development_dependency("bundler", ">= 1.5")
   s.add_development_dependency("simplecov", ">= 0")
-  s.add_development_dependency("rails", "~> 5.0")
+  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.3.6")
-  s.add_development_dependency("bigdecimal", "~> 1.3.2")
+  s.add_development_dependency("sqlite3", "~> 1.4.2")
+
+  s.required_ruby_version = '>= 2.6'
 
   s.files = `git ls-files`.split($/)
   s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }

data/spec/accounting_money_parser_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe AccountingMoneyParser do

data/spec/allocator_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+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
+
+    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))
+    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
+
+    specify "#allocate_max_amounts allocates the right amount without rounding error" do
+      expect(
+        new_allocator(24.2).allocate_max_amounts([Money.new(46), Money.new(46), Money.new(50), Money.new(50),Money.new(50)]),
+        ).to eq([Money.new(4.6), Money.new(4.6), Money.new(5), Money.new(5), Money.new(5)])
+    end
+  end
+
+  def new_allocator(amount, currency = nil)
+    Money::Allocator.new(Money.new(amount, currency))
+  end
+end

data/spec/core_extensions_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.shared_examples_for "an object supporting to_money" do
@@ -56,6 +57,6 @@ RSpec.describe BigDecimal do
   it_should_behave_like "an object supporting to_money"
 
   it "parses a zero BigDecimal to Money.zero" do
-    expect(BigDecimal.new("-0.000").to_money).to eq(Money.zero)
+    expect(BigDecimal("-0.000").to_money).to eq(Money.zero)
   end
 end

data/spec/currency/loader_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe Money::Currency::Loader do

data/spec/currency_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe "Currency" do

data/spec/helpers_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe Money::Helpers do
@@ -49,12 +50,6 @@ RSpec.describe Money::Helpers do
       expect(subject.value_to_decimal('invalid')).to eq(0)
     end
 
-    it 'returns the bigdecimal representation of numbers while they are deprecated' do
-      expect(Money).to receive(:deprecate).exactly(2).times
-      expect(subject.value_to_decimal('1.23abc')).to eq(amount)
-      expect(subject.value_to_decimal("1.23\n23")).to eq(amount)
-    end
-
     it 'raises on invalid object' do
       expect { subject.value_to_decimal(OpenStruct.new(amount: 1)) }.to raise_error(ArgumentError)
     end

data/spec/money_accessor_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 class NormalObject

data/spec/money_column_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 class MoneyRecord < ActiveRecord::Base

data/spec/money_parser_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe MoneyParser do

data/spec/money_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 require 'yaml'
 
@@ -583,113 +584,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
@@ -828,8 +745,8 @@ RSpec.describe "Money" do
     end
 
     it "accepts Rational number" do
-      expect(Money.from_amount(Rational("999999999999999999.999")).value).to eql(BigDecimal.new("1000000000000000000", Money::Helpers::MAX_DECIMAL))
-      expect(Money.from_amount(Rational("999999999999999999.99")).value).to eql(BigDecimal.new("999999999999999999.99", Money::Helpers::MAX_DECIMAL))
+      expect(Money.from_amount(Rational("999999999999999999.999")).value).to eql(BigDecimal("1000000000000000000", Money::Helpers::MAX_DECIMAL))
+      expect(Money.from_amount(Rational("999999999999999999.99")).value).to eql(BigDecimal("999999999999999999.99", Money::Helpers::MAX_DECIMAL))
     end
 
     it "raises ArgumentError with unsupported argument" do