solidus_core 2.1.0.beta1 → 2.1.0.rc1

data/app/models/spree/payment.rb

@@ -36,9 +36,6 @@ module Spree
     # invalidate previously entered payments
     after_create :invalidate_old_payments
 
-    attr_accessor :source_attributes
-    after_initialize :apply_source_attributes
-
     attr_accessor :request_env
 
     validates :amount, numericality: true
@@ -149,25 +146,6 @@ module Spree
       credit_allowed > 0
     end
 
-    # When this is a new record without a source, builds a new source based on
-    # this payment's payment method and associates it correctly.
-    #
-    # @see https://github.com/spree/spree/issues/981
-    #
-    # TODO: Move this into upcoming CartUpdate class
-    def apply_source_attributes
-      return unless new_record?
-      return if source_attributes.blank?
-
-      Spree::Deprecation.warn(<<WARN.squish)
-Building payment sources by assigning source_attributes on payments is
-deprecated. Instead use either the PaymentCreate class or the
-OrderUpdateAttributes class.
-WARN
-
-      PaymentCreate.new(order, { source_attributes: source_attributes }, payment: self, request_env: request_env).build
-    end
-
     # @return [Array<String>] the actions available on this payment
     def actions
       sa = source_actions

data/app/models/spree/payment/processing.rb

@@ -56,7 +56,7 @@ module Spree
             gateway_options
           )
           money = ::Money.new(amount, currency)
-          capture_events.create!(amount: money.to_f)
+          capture_events.create!(amount: money.to_d)
           update_attributes!(amount: captured_amount)
           handle_response(response, :complete, :failure)
         end

data/app/models/spree/product/scopes.rb

@@ -172,18 +172,11 @@ module Spree
     end
 
     # Can't use add_search_scope for this as it needs a default argument
-    def self.available(available_on = nil, currency = nil)
-      Spree::Deprecation.warn("The second currency argument on Product.available has no effect, and is deprecated", caller) if currency
+    def self.available(available_on = nil)
       joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on || Time.current)
     end
     search_scopes << :available
 
-    def self.active(currency = nil)
-      Spree::Deprecation.warn("This scope is deprecated, please use .available instead", caller)
-      not_deleted.available(nil, currency)
-    end
-    search_scopes << :active
-
     add_search_scope :taxons_name_eq do |name|
       group("spree_products.id").joins(:taxons).where(Taxon.arel_table[:name].eq(name))
     end

data/app/models/spree/promotion/actions/create_adjustment.rb

@@ -35,7 +35,12 @@ module Spree
         # Ensure a negative amount which does not exceed the sum of the order's
         # item_total and ship_total
         def compute_amount(calculable)
-          amount = calculator.compute(calculable).to_f.abs
+          amount = calculator.compute(calculable)
+          if !amount.is_a?(BigDecimal)
+            Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{amount.inspect}, it should return a BigDecimal"
+          end
+          amount ||= BigDecimal.new(0)
+          amount = amount.abs
           [(calculable.item_total + calculable.ship_total), amount].min * -1
         end
 

data/app/models/spree/promotion/actions/create_item_adjustments.rb

@@ -31,7 +31,12 @@ module Spree
         def compute_amount(adjustable)
           order = adjustable.is_a?(Order) ? adjustable : adjustable.order
           return 0 unless promotion.line_item_actionable?(order, adjustable)
-          promotion_amount = calculator.compute(adjustable).to_f.abs
+          promotion_amount = calculator.compute(adjustable)
+          if !promotion_amount.is_a?(BigDecimal)
+            Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{promotion_amount.inspect}, it should return a BigDecimal"
+          end
+          promotion_amount ||= BigDecimal.new(0)
+          promotion_amount = promotion_amount.abs
           [adjustable.amount, promotion_amount].min * -1
         end
 

data/app/models/spree/promotion/actions/create_quantity_adjustments.rb

@@ -52,7 +52,12 @@ module Spree::Promotion::Actions
     # adjustment. +adjustment_amount * 3+ or $15.
     #
     def compute_amount(line_item)
-      adjustment_amount = calculator.compute(PartialLineItem.new(line_item)).to_f.abs
+      adjustment_amount = calculator.compute(PartialLineItem.new(line_item))
+      if !adjustment_amount.is_a?(BigDecimal)
+        Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{adjustment_amount.inspect}, it should return a BigDecimal"
+      end
+      adjustment_amount ||= BigDecimal.new(0)
+      adjustment_amount = adjustment_amount.abs
 
       order = line_item.order
       line_items = actionable_line_items(order)

data/app/models/spree/refund.rb

@@ -40,7 +40,7 @@ module Spree
     def perform!
       return true if transaction_id.present?
 
-      credit_cents = Spree::Money.new(amount.to_f, currency: payment.currency).money.cents
+      credit_cents = money.cents
 
       @response = process!(credit_cents)
 

data/app/models/spree/store.rb

@@ -21,8 +21,7 @@ module Spree
 
     scope :by_url, lambda { |url| where("url like ?", "%#{url}%") }
 
-    def self.current(store_key = nil)
-      Spree::Deprecation.warn "Spree::Store.current needs a code or URL as an argument. If you want the default store use Spree::Store.default", caller if !store_key
+    def self.current(store_key)
       current_store = Store.find_by(code: store_key) || Store.by_url(store_key).first if store_key
       current_store || Store.default
     end

data/app/models/spree/zone.rb

@@ -16,16 +16,18 @@ module Spree
     after_save :remove_previous_default
 
     scope :with_member_ids, ->(state_ids, country_ids) do
-      return none if !state_ids.present? && !country_ids.present?
-
-      spree_zone_members_table = Spree::ZoneMember.arel_table
-      matching_state =
-        spree_zone_members_table[:zoneable_type].eq("Spree::State").
-        and(spree_zone_members_table[:zoneable_id].in(state_ids))
-      matching_country =
-        spree_zone_members_table[:zoneable_type].eq("Spree::Country").
-        and(spree_zone_members_table[:zoneable_id].in(country_ids))
-      joins(:zone_members).where(matching_state.or(matching_country)).distinct
+      if !state_ids.present? && !country_ids.present?
+        none
+      else
+        spree_zone_members_table = Spree::ZoneMember.arel_table
+        matching_state =
+          spree_zone_members_table[:zoneable_type].eq("Spree::State").
+          and(spree_zone_members_table[:zoneable_id].in(state_ids))
+        matching_country =
+          spree_zone_members_table[:zoneable_type].eq("Spree::Country").
+          and(spree_zone_members_table[:zoneable_id].in(country_ids))
+        joins(:zone_members).where(matching_state.or(matching_country)).distinct
+      end
     end
 
     scope :for_address, ->(address) do

data/lib/spree/core.rb

@@ -46,16 +46,6 @@ module Spree
   module Core
     autoload :ProductFilters, "spree/core/product_filters"
 
-    def self.const_missing(name)
-      case name
-      when :AdjustmentSource, :CalculatedAdjustments, :UserAddress, :UserPaymentSource
-        Spree::Deprecation.warn("Spree::Core::#{name} is deprecated! Use Spree::#{name} instead.", caller)
-        Spree.const_get(name)
-      else
-        super
-      end
-    end
-
     class GatewayError < RuntimeError; end
     class DestroyWithOrdersError < StandardError; end
   end

data/lib/spree/core/engine.rb

@@ -136,5 +136,3 @@ module Spree
     end
   end
 end
-
-require 'spree/core/routes'

data/lib/spree/core/version.rb

@@ -1,11 +1,6 @@
 module Spree
-  def self.version
-    Spree::Deprecation.warn("Spree.version does not work and will be removed from solidus. Use Spree.solidus_version instead to determine the solidus version")
-    "2.4.6.beta"
-  end
-
   def self.solidus_version
-    "2.1.0.beta1"
+    "2.1.0.rc1"
   end
 
   def self.solidus_gem_version

data/spec/mailers/carton_mailer_spec.rb

@@ -16,15 +16,6 @@ describe Spree::CartonMailer do
     expect(shipment_email.subject).to eq "#{order.store.name} Shipment Notification ##{order.number}"
   end
 
-  context "deprecated signature" do
-    it do
-      Spree::Deprecation.silence do
-        mail = Spree::CartonMailer.shipped_email(carton.id)
-        expect(mail.subject).to include "Shipment Notification"
-      end
-    end
-  end
-
   context "with resend option" do
     subject do
       Spree::CartonMailer.shipped_email(order: order, carton: carton, resend: true).subject

data/spec/mailers/order_mailer_spec.rb

@@ -28,20 +28,6 @@ describe Spree::OrderMailer, type: :mailer do
     expect(confirmation_email.body).not_to include(""")
   end
 
-  it "confirm_email accepts an order id as an alternative to an Order object" do
-    expect(Spree::Order).to receive(:find).with(order.id).and_return(order)
-    Spree::Deprecation.silence do
-      Spree::OrderMailer.confirm_email(order.id).body
-    end
-  end
-
-  it "cancel_email accepts an order id as an alternative to an Order object" do
-    expect(Spree::Order).to receive(:find).with(order.id).and_return(order)
-    Spree::Deprecation.silence do
-      Spree::OrderMailer.cancel_email(order.id).body
-    end
-  end
-
   context "only shows eligible adjustments in emails" do
     before do
       create(

data/spec/models/spree/calculator/flexi_rate_spec.rb

@@ -2,43 +2,155 @@ require 'spec_helper'
 require 'shared_examples/calculator_shared_examples'
 
 describe Spree::Calculator::FlexiRate, type: :model do
-  let(:calculator) { Spree::Calculator::FlexiRate.new }
+  let(:calculator) do
+    Spree::Calculator::FlexiRate.new(
+      preferred_first_item: first_item,
+      preferred_additional_item: additional_item,
+      preferred_max_items: max_items
+    )
+  end
+  let(:first_item) { 0 }
+  let(:additional_item) { 0 }
+  let(:max_items) { 0 }
 
   it_behaves_like 'a calculator with a description'
 
   let(:order) do
     mock_model(
-      Spree::Order, quantity: 10
+      Spree::Order, quantity: quantity
     )
   end
 
   context "compute" do
-    it "should compute amount correctly when all fees are 0" do
-      expect(calculator.compute(order).round(2)).to eq(0.0)
-    end
+    subject { calculator.compute(order) }
+    context "with all amounts 0" do
+      context "with quantity 0" do
+        let(:quantity) { 0 }
+        it { should eq 0 }
+      end
 
-    it "should compute amount correctly when first_item has a value" do
-      allow(calculator).to receive_messages preferred_first_item: 1.0
-      expect(calculator.compute(order).round(2)).to eq(1.0)
-    end
+      context "with quantity 1" do
+        let(:quantity) { 1 }
+        it { should eq 0 }
+      end
 
-    it "should compute amount correctly when additional_items has a value" do
-      allow(calculator).to receive_messages preferred_additional_item: 1.0
-      expect(calculator.compute(order).round(2)).to eq(9.0)
+      context "with quantity 2" do
+        let(:quantity) { 2 }
+        it { should eq 0 }
+      end
+
+      context "with quantity 10" do
+        let(:quantity) { 10 }
+        it { should eq 0 }
+      end
     end
 
-    it "should compute amount correctly when additional_items and first_item have values" do
-      allow(calculator).to receive_messages preferred_first_item: 5.0, preferred_additional_item: 1.0
-      expect(calculator.compute(order).round(2)).to eq(14.0)
+    context "when first_item has a value" do
+      let(:first_item) { 1.23 }
+
+      context "with quantity 0" do
+        let(:quantity) { 0 }
+        it { should eq 0 }
+      end
+
+      context "with quantity 1" do
+        let(:quantity) { 1 }
+        it { should eq 1.23 }
+      end
+
+      context "with quantity 2" do
+        let(:quantity) { 2 }
+        it { should eq 1.23 }
+      end
+
+      context "with quantity 10" do
+        let(:quantity) { 10 }
+        it { should eq 1.23 }
+      end
     end
 
-    it "should compute amount correctly when additional_items and first_item have values AND max items has value" do
-      allow(calculator).to receive_messages preferred_first_item: 5.0, preferred_additional_item: 1.0, preferred_max_items: 3
-      expect(calculator.compute(order).round(2)).to eq(7.0)
+    context "when additional_items has a value" do
+      let(:additional_item) { 1.23 }
+
+      context "with quantity 0" do
+        let(:quantity) { 0 }
+        it { should eq 0 }
+      end
+
+      context "with quantity 1" do
+        let(:quantity) { 1 }
+        it { should eq 0 }
+      end
+
+      context "with quantity 2" do
+        let(:quantity) { 2 }
+        it { should eq 1.23 }
+      end
+
+      context "with quantity 10" do
+        let(:quantity) { 10 }
+        it { should eq 11.07 }
+      end
     end
 
-    it "should allow creation of new object with all the attributes" do
-      Spree::Calculator::FlexiRate.new(preferred_first_item: 1, preferred_additional_item: 1, preferred_max_items: 1)
+    context "when first_item and additional_items has a value" do
+      let(:first_item) { 1.13 }
+      let(:additional_item) { 2.11 }
+
+      context "with quantity 0" do
+        let(:quantity) { 0 }
+        it { should eq 0 }
+      end
+
+      context "with quantity 1" do
+        let(:quantity) { 1 }
+        it { should eq 1.13 }
+      end
+
+      context "with quantity 2" do
+        let(:quantity) { 2 }
+        it { should eq 3.24 }
+      end
+
+      context "with quantity 10" do
+        let(:quantity) { 10 }
+        it { should eq 20.12 }
+      end
+
+      context "with max_items 5" do
+        let(:max_items) { 5 }
+
+        context "with quantity 0" do
+          let(:quantity) { 0 }
+          it { should eq 0 }
+        end
+
+        context "with quantity 1" do
+          let(:quantity) { 1 }
+          it { should eq 1.13 }
+        end
+
+        context "with quantity 2" do
+          let(:quantity) { 2 }
+          it { should eq 3.24 }
+        end
+
+        context "with quantity 5" do
+          let(:quantity) { 5 }
+          it { should eq 9.57 }
+        end
+
+        context "with quantity 10" do
+          let(:quantity) { 10 }
+          it { should eq 9.57 }
+        end
+      end
     end
   end
+
+  it "should allow creation of new object with all the attributes" do
+    attributes = {preferred_first_item: 1, preferred_additional_item: 1, preferred_max_items: 1}
+    calculator = Spree::Calculator::FlexiRate.new(attributes)
+    expect(calculator).to have_attributes(attributes)
+  end
 end

data/spec/models/spree/calculator/shipping/flat_percent_item_total_spec.rb

@@ -21,6 +21,10 @@ module Spree
       it "should round result correctly" do
         expect(subject.compute(package)).to eq(4.04)
       end
+
+      it "should return a bigdecimal" do
+        expect(subject.compute(package)).to be_a(BigDecimal)
+      end
     end
   end
 end

data/spec/models/spree/calculator/tiered_flat_rate_spec.rb

@@ -9,10 +9,50 @@ describe Spree::Calculator::TieredFlatRate, type: :model do
   describe "#valid?" do
     subject { calculator.valid? }
     context "when tiers is a hash" do
-      context "and one of the keys is not a positive number" do
+      context "and the key is not a positive number" do
         before { calculator.preferred_tiers = { "nope" => 20 } }
         it { is_expected.to be false }
       end
+
+      context "and the key is an integer" do
+        before { calculator.preferred_tiers = { 20 => 20 } }
+        it "converts successfully" do
+          is_expected.to be true
+          expect(calculator.preferred_tiers).to eq({ BigDecimal.new('20') => BigDecimal.new('20') })
+        end
+      end
+
+      context "and the key is a float" do
+        before { calculator.preferred_tiers = { 20.5 => 20.5 } }
+        it "converts successfully" do
+          is_expected.to be true
+          expect(calculator.preferred_tiers).to eq({ BigDecimal.new('20.5') => BigDecimal.new('20.5') })
+        end
+      end
+
+      context "and the key is a string number" do
+        before { calculator.preferred_tiers = { "20" => 20 } }
+        it "converts successfully" do
+          is_expected.to be true
+          expect(calculator.preferred_tiers).to eq({ BigDecimal.new('20') => BigDecimal.new('20') })
+        end
+      end
+
+      context "and the key is a numeric string with spaces" do
+        before { calculator.preferred_tiers = { "  20 " => 20 } }
+        it "converts successfully" do
+          is_expected.to be true
+          expect(calculator.preferred_tiers).to eq({ BigDecimal.new('20') => BigDecimal.new('20') })
+        end
+      end
+
+      context "and the key is a string number with decimals" do
+        before { calculator.preferred_tiers = { "20.5" => "20.5" } }
+        it "converts successfully" do
+          is_expected.to be true
+          expect(calculator.preferred_tiers).to eq({ BigDecimal.new('20.5') => BigDecimal.new('20.5') })
+        end
+      end
     end
   end