solidus_core 1.2.3 → 1.3.0.beta1

data/app/models/spree/returns_calculator.rb

@@ -1,7 +1,6 @@
 module Spree
   class ReturnsCalculator < Calculator
-
-    def compute(return_item)
+    def compute(_return_item)
       raise NotImplementedError, "Please implement 'compute(return_item)' in your calculator: #{self.class.name}"
     end
   end

data/app/models/spree/shipment.rb

@@ -17,7 +17,7 @@ module Spree
 
     before_destroy :ensure_can_destroy
 
-    # TODO remove the suppress_mailer temporary variable once we are calling 'ship'
+    # TODO: remove the suppress_mailer temporary variable once we are calling 'ship'
     # from outside of the state machine and can actually pass variables through.
     attr_accessor :special_instructions, :suppress_mailer
 
@@ -66,7 +66,7 @@ module Spree
         shipment.state_changes.create!(
           previous_state: transition.from,
           next_state:     transition.to,
-          name:           'shipment',
+          name:           'shipment'
         )
       end
     end
@@ -74,12 +74,15 @@ module Spree
     self.whitelisted_ransackable_associations = ['order']
     self.whitelisted_ransackable_attributes = ['number']
 
+    delegate :tax_category, to: :selected_shipping_rate, allow_nil: true
+
     def can_transition_from_pending_to_shipped?
       !requires_shipment?
     end
 
     def can_transition_from_pending_to_ready?
-      order.can_ship? && !inventory_units.any?(&:backordered?) &&
+      order.can_ship? &&
+        inventory_units.all? { |iu| iu.allow_ship? || iu.canceled? } &&
         (order.paid? || !Spree::Config[:require_payment_to_ship])
     end
 
@@ -88,8 +91,8 @@ module Spree
     end
 
     extend DisplayMoney
-    money_methods :cost, :discounted_cost, :final_price, :item_cost
-    alias display_amount display_cost
+    money_methods :cost, :amount, :discounted_cost, :final_price, :item_cost
+    alias_attribute :amount, :cost
 
     def add_shipping_method(shipping_method, selected = false)
       shipping_rates.create(shipping_method: shipping_method, selected: selected, cost: cost)
@@ -104,7 +107,7 @@ module Spree
     end
 
     def backordered?
-      inventory_units.any? { |inventory_unit| inventory_unit.backordered? }
+      inventory_units.any?(&:backordered?)
     end
 
     def currency
@@ -116,8 +119,7 @@ module Spree
     end
     alias discounted_amount discounted_cost
 
-
-    def editable_by?(user)
+    def editable_by?(_user)
       !shipped?
     end
 
@@ -162,8 +164,12 @@ module Spree
       inventory_units.includes(:line_item).map(&:line_item).uniq
     end
 
+    def pre_tax_amount
+      discounted_amount - included_tax_total
+    end
+
     def ready_or_pending?
-      self.ready? || self.pending?
+      ready? || pending?
     end
 
     def refresh_rates
@@ -173,7 +179,7 @@ module Spree
       # StockEstimator.new assigment below will replace the current shipping_method
       original_shipping_method_id = shipping_method.try!(:id)
 
-      new_rates = Spree::Config.stock.estimator_class.new(order).shipping_rates(to_package)
+      new_rates = Spree::Config.stock.estimator_class.new.shipping_rates(to_package)
 
       # If one of the new rates matches the previously selected shipping
       # method, select that instead of the default provided by the estimator.
@@ -186,7 +192,7 @@ module Spree
       end
 
       self.shipping_rates = new_rates
-      self.save!
+      save!
 
       shipping_rates
     end
@@ -206,7 +212,7 @@ module Spree
     def selected_shipping_rate_id=(id)
       shipping_rates.update_all(selected: false)
       shipping_rates.update(id, selected: true)
-      self.save!
+      save!
     end
 
     # Determines the appropriate +state+ according to the following logic:
@@ -217,10 +223,9 @@ module Spree
     # ready      all other cases
     def determine_state(order)
       return 'canceled' if order.canceled?
+      return 'shipped' if shipped?
       return 'pending' unless order.can_ship?
-      return 'pending' if inventory_units.any? &:backordered?
-      return 'shipped' if state == 'shipped'
-      if order.paid? || !Spree::Config[:require_payment_to_ship]
+      if can_transition_from_pending_to_ready?
         'ready'
       else
         'pending'
@@ -228,7 +233,7 @@ module Spree
     end
 
     def set_up_inventory(state, variant, order, line_item)
-      self.inventory_units.create(
+      inventory_units.create(
         state: state,
         variant_id: variant.id,
         order_id: order.id,
@@ -245,10 +250,6 @@ module Spree
       selected_shipping_rate.try(:shipping_method) || shipping_rates.first.try(:shipping_method)
     end
 
-    def tax_category
-      selected_shipping_rate.try(:tax_rate).try(:tax_category)
-    end
-
     # Only one of either included_tax_total or additional_tax_total is set
     # This method returns the total of the two. Saves having to check if
     # tax is included or additional.
@@ -258,6 +259,7 @@ module Spree
 
     def to_package
       package = Stock::Package.new(stock_location)
+      package.shipment = self
       inventory_units.includes(:variant).joins(:variant).group_by(&:state).each do |state, state_inventory_units|
         package.add_multiple state_inventory_units, state.to_sym
       end
@@ -269,35 +271,41 @@ module Spree
     end
 
     def tracking_url
+      return nil unless tracking && shipping_method
+
       @tracking_url ||= shipping_method.build_tracking_url(tracking)
     end
 
     def update_amounts
       if selected_shipping_rate
-        self.update_columns(
-          cost: selected_shipping_rate.cost,
-          adjustment_total: adjustments.additional.map(&:update!).compact.sum,
-          updated_at: Time.current,
-        )
+        self.cost = selected_shipping_rate.cost
+        self.adjustment_total = adjustments.additional.map(&:update!).compact.sum
+        if changed?
+          update_columns(
+            cost: cost,
+            adjustment_total: adjustment_total,
+            updated_at: Time.current
+          )
+        end
       end
     end
 
     # Update Shipment and make sure Order states follow the shipment changes
     def update_attributes_and_order(params = {})
-      if self.update_attributes params
-        if params.has_key? :selected_shipping_rate_id
+      if update_attributes params
+        if params.key? :selected_shipping_rate_id
           # Changing the selected Shipping Rate won't update the cost (for now)
           # so we persist the Shipment#cost before calculating order shipment
           # total and updating payment state (given a change in shipment cost
           # might change the Order#payment_state)
-          self.update_amounts
+          update_amounts
 
           order.updater.update_shipment_total
           order.updater.update_payment_state
 
           # Update shipment state only after order total is updated because it
           # (via Order#paid?) affects the shipment state (YAY)
-          self.update_columns(
+          update_columns(
             state: determine_state(order),
             updated_at: Time.current
           )
@@ -318,11 +326,13 @@ module Spree
     def update!(order)
       old_state = state
       new_state = determine_state(order)
-      update_columns(
-        state: new_state,
-        updated_at: Time.current,
-      )
-      after_ship if new_state == 'shipped' and old_state != 'shipped'
+      if new_state != old_state
+        update_columns(
+          state: new_state,
+          updated_at: Time.current
+        )
+        after_ship if new_state == 'shipped'
+      end
     end
 
     def transfer_to_location(variant, quantity, stock_location)
@@ -333,8 +343,8 @@ module Spree
       transaction do
         new_shipment = order.shipments.create!(stock_location: stock_location)
 
-        order.contents.remove(variant, quantity, {shipment: self})
-        order.contents.add(variant, quantity, {shipment: new_shipment})
+        order.contents.remove(variant, quantity, { shipment: self })
+        order.contents.add(variant, quantity, { shipment: new_shipment })
 
         refresh_rates
         save!
@@ -343,16 +353,13 @@ module Spree
     end
 
     def transfer_to_shipment(variant, quantity, shipment_to_transfer_to)
-      quantity_already_shipment_to_transfer_to = shipment_to_transfer_to.manifest.find{|mi| mi.line_item.variant == variant}.try(:quantity) || 0
-      final_quantity = quantity + quantity_already_shipment_to_transfer_to
-
-      if (quantity <= 0 || self == shipment_to_transfer_to)
+      if quantity <= 0 || self == shipment_to_transfer_to
         raise ArgumentError
       end
 
       transaction do
-        order.contents.remove(variant, quantity, {shipment: self})
-        order.contents.add(variant, quantity, {shipment: shipment_to_transfer_to})
+        order.contents.remove(variant, quantity, { shipment: self })
+        order.contents.add(variant, quantity, { shipment: shipment_to_transfer_to })
 
         refresh_rates
         save!
@@ -367,48 +374,47 @@ module Spree
 
     private
 
-      def after_ship
-        order.shipping.ship_shipment(self, suppress_mailer: suppress_mailer)
-      end
-
-      def can_get_rates?
-        order.ship_address && order.ship_address.valid?
-      end
+    def after_ship
+      order.shipping.ship_shipment(self, suppress_mailer: suppress_mailer)
+    end
 
-      def manifest_restock(item)
-        if item.states["on_hand"].to_i > 0
-         stock_location.restock item.variant, item.states["on_hand"], self
-        end
+    def can_get_rates?
+      order.ship_address && order.ship_address.valid?
+    end
 
-        if item.states["backordered"].to_i > 0
-          stock_location.restock_backordered item.variant, item.states["backordered"]
-        end
+    def manifest_restock(item)
+      if item.states["on_hand"].to_i > 0
+       stock_location.restock item.variant, item.states["on_hand"], self
       end
 
-      def manifest_unstock(item)
-        stock_location.unstock item.variant, item.quantity, self
+      if item.states["backordered"].to_i > 0
+        stock_location.restock_backordered item.variant, item.states["backordered"]
       end
+    end
 
-      def recalculate_adjustments
-        Spree::ItemAdjustments.new(self).update
-      end
+    def manifest_unstock(item)
+      stock_location.unstock item.variant, item.quantity, self
+    end
 
-      def set_cost_zero_when_nil
-        self.cost = 0 unless self.cost
-      end
+    def recalculate_adjustments
+      Spree::ItemAdjustments.new(self).update
+    end
 
-      def update_adjustments
-        if cost_changed? && state != 'shipped'
-          recalculate_adjustments
-        end
-      end
+    def set_cost_zero_when_nil
+      self.cost = 0 unless cost
+    end
 
+    def update_adjustments
+      if cost_changed? && state != 'shipped'
+        recalculate_adjustments
+      end
+    end
 
-      def ensure_can_destroy
-        unless pending?
-          errors.add(:state, :cannot_destroy, state: self.state)
-          return false
-        end
+    def ensure_can_destroy
+      unless pending?
+        errors.add(:state, :cannot_destroy, state: state)
+        return false
       end
+    end
   end
 end

data/app/models/spree/shipping_calculator.rb

@@ -1,22 +1,21 @@
 module Spree
   class ShippingCalculator < Calculator
-
-    def compute_shipment(shipment)
+    def compute_shipment(_shipment)
       raise NotImplementedError, "Please implement 'compute_shipment(shipment)' in your calculator: #{self.class.name}"
     end
 
-    def compute_package(package)
+    def compute_package(_package)
       raise NotImplementedError, "Please implement 'compute_package(package)' in your calculator: #{self.class.name}"
     end
 
-    def available?(package)
+    def available?(_package)
       true
     end
 
     private
+
     def total(content_items)
       content_items.map(&:amount).sum
     end
   end
 end
-

data/app/models/spree/shipping_manifest.rb

@@ -7,16 +7,15 @@ class Spree::ShippingManifest
 
   def for_order(order)
     Spree::ShippingManifest.new(
-      inventory_units: @inventory_units.select {|iu| iu.order_id == order.id }
+      inventory_units: @inventory_units.select { |iu| iu.order_id == order.id }
     )
   end
 
   def items
     # Grouping by the ID means that we don't have to call out to the association accessor
     # This makes the grouping by faster because it results in less SQL cache hits.
-    @inventory_units.group_by(&:variant_id).map do |variant_id, variant_units|
-      variant_units.group_by(&:line_item_id).map do |line_item_id, units|
-
+    @inventory_units.group_by(&:variant_id).map do |_variant_id, variant_units|
+      variant_units.group_by(&:line_item_id).map do |_line_item_id, units|
         states = {}
         units.group_by(&:state).each { |state, iu| states[state] = iu.count }
 

data/app/models/spree/shipping_method.rb

@@ -4,21 +4,67 @@ module Spree
     include Spree::CalculatedAdjustments
     DISPLAY = [:both, :front_end, :back_end]
 
-    has_many :shipping_method_categories, :dependent => :destroy
+    has_many :shipping_method_categories, dependent: :destroy
     has_many :shipping_categories, through: :shipping_method_categories
     has_many :shipping_rates, inverse_of: :shipping_method
-    has_many :shipments, :through => :shipping_rates
+    has_many :shipments, through: :shipping_rates
     has_many :cartons, inverse_of: :shipping_method
 
     has_many :shipping_method_zones
     has_many :zones, through: :shipping_method_zones
 
-    belongs_to :tax_category, -> { with_deleted }, :class_name => 'Spree::TaxCategory'
+    belongs_to :tax_category, -> { with_deleted }, class_name: 'Spree::TaxCategory'
+    has_many :shipping_method_stock_locations, dependent: :destroy, class_name: "Spree::ShippingMethodStockLocation"
+    has_many :stock_locations, through: :shipping_method_stock_locations
 
     validates :name, presence: true
 
     validate :at_least_one_shipping_category
 
+    # @param shipping_category_ids [Array<Integer>] ids of desired shipping categories
+    # @return [ActiveRecord::Relation] shipping methods which are associated
+    #   with all of the provided shipping categories
+    def self.with_all_shipping_category_ids(shipping_category_ids)
+      # Some extra care is needed with the having clause to ensure we are
+      # counting distinct records of the join table. Otherwise a join could
+      # cause this to return incorrect results.
+      join_table = ShippingMethodCategory.arel_table
+      having = join_table[:id].count(true).eq(shipping_category_ids.count)
+      joins(:shipping_method_categories).
+        where(spree_shipping_method_categories: { shipping_category_id: shipping_category_ids }).
+        group('spree_shipping_methods.id').
+        having(having)
+    end
+
+    # @param stock_location [Spree::StockLocation] stock location
+    # @return [ActiveRecord::Relation] shipping methods which are available
+    #   with the stock location or are marked available_to_all
+    def self.available_in_stock_location(stock_location)
+      smsl_table = ShippingMethodStockLocation.arel_table
+
+      # We are searching for either a matching entry in the stock location join
+      # table or available_to_all being true.
+      # We need to use an outer join otherwise a shipping method with no
+      # associated stock locations will be filtered out of the results. In
+      # rails 5 this will be easy using .left_join and .or, but for now we must
+      # use arel to achieve this.
+      arel_join =
+        arel_table.join(smsl_table, Arel::Nodes::OuterJoin).
+        on(arel_table[:id].eq(smsl_table[:shipping_method_id])).
+        join_sources
+      arel_condition =
+        arel_table[:available_to_all].eq(true).or(smsl_table[:stock_location_id].eq(stock_location.id))
+
+      joins(arel_join).where(arel_condition).distinct
+    end
+
+    # @param address [Spree::Address] address to match against zones
+    # @return [ActiveRecord::Relation] shipping methods which are associated
+    #   with zones matching the provided address
+    def self.available_for_address(address)
+      joins(:zones).merge(Zone.for_address(address))
+    end
+
     def include?(address)
       return false unless address
       zones.any? do |zone|
@@ -31,32 +77,17 @@ module Spree
       tracking_url.gsub(/:tracking/, ERB::Util.url_encode(tracking)) # :url_encode exists in 1.8.7 through 2.1.0
     end
 
-    def self.calculators
-      spree_calculators.send(model_name_without_spree_namespace).select{ |c| c < Spree::ShippingCalculator }
-    end
-
     # Some shipping methods are only meant to be set via backend
     def frontend?
-      self.display_on != "back_end"
+      display_on != "back_end"
     end
 
     private
-      def compute_amount(calculable)
-        self.calculator.compute(calculable)
-      end
-
-      def at_least_one_shipping_category
-        if self.shipping_categories.empty?
-          self.errors[:base] << "You need to select at least one shipping category"
-        end
-      end
-
-      def self.on_backend_query
-        "#{table_name}.display_on != 'front_end' OR #{table_name}.display_on IS NULL"
-      end
 
-      def self.on_frontend_query
-        "#{table_name}.display_on != 'back_end' OR #{table_name}.display_on IS NULL"
+    def at_least_one_shipping_category
+      if shipping_categories.empty?
+        errors[:base] << "You need to select at least one shipping category"
       end
+    end
   end
 end

data/app/models/spree/shipping_method_stock_location.rb

@@ -0,0 +1,4 @@
+class Spree::ShippingMethodStockLocation < Spree::Base
+  belongs_to :shipping_method
+  belongs_to :stock_location
+end

data/app/models/spree/shipping_rate.rb

@@ -2,45 +2,40 @@ module Spree
   class ShippingRate < Spree::Base
     belongs_to :shipment, class_name: 'Spree::Shipment'
     belongs_to :shipping_method, -> { with_deleted }, class_name: 'Spree::ShippingMethod', inverse_of: :shipping_rates
-    belongs_to :tax_rate, -> { with_deleted }, class_name: 'Spree::TaxRate'
+
+    has_many :taxes,
+             class_name: "Spree::ShippingRateTax",
+             foreign_key: "shipping_rate_id",
+             dependent: :destroy
 
     delegate :order, :currency, to: :shipment
-    delegate :name, to: :shipping_method
+    delegate :name, :tax_category, to: :shipping_method
     delegate :code, to: :shipping_method, prefix: true
+    alias_attribute :amount, :cost
 
-    def display_base_price
-      Spree::Money.new(cost, currency: currency)
-    end
+    alias_method :discounted_amount, :amount
 
-    def calculate_tax_amount
-      tax_rate.calculator.compute_shipping_rate(self)
-    end
+    extend DisplayMoney
+    money_methods :amount
 
     def display_price
-      price = display_base_price.to_s
-      if tax_rate
-        tax_amount = calculate_tax_amount
-        if tax_amount != 0
-          if tax_rate.included_in_price?
-            if tax_amount > 0
-              amount = "#{display_tax_amount(tax_amount)} #{tax_rate.name}"
-              price += " (#{Spree.t(:incl)} #{amount})"
-            else
-              amount = "#{display_tax_amount(tax_amount*-1)} #{tax_rate.name}"
-              price += " (#{Spree.t(:excl)} #{amount})"
-            end
-          else
-            amount = "#{display_tax_amount(tax_amount)} #{tax_rate.name}"
-            price += " (+ #{amount})"
-          end
-        end
-      end
-      price
+      price = display_amount.to_s
+
+      return price if taxes.empty? || amount == 0
+
+      tax_explanations = taxes.map(&:label).join(tax_label_separator)
+
+      Spree.t :display_price_with_explanations,
+               scope: 'shipping_rate.display_price',
+               price: price,
+               explanations: tax_explanations
     end
     alias_method :display_cost, :display_price
 
-    def display_tax_amount(tax_amount)
-      Spree::Money.new(tax_amount, currency: currency)
+    private
+
+    def tax_label_separator
+      Spree.t :tax_label_separator, scope: 'shipping_rate.display_price'
     end
   end
 end

data/app/models/spree/shipping_rate_tax.rb

@@ -0,0 +1,41 @@
+module Spree
+  # Used to persist shipping rate tax estimations.
+  # @attr [Spree::ShippingRate] shipping_rate The shipping rate to be taxed
+  # @attr [Spree::TaxRate] tax_rate The tax rate used to calculate the tax amount
+  # @since 1.3.0
+  # @see Spree::Tax::ShippingRateTaxer
+  class ShippingRateTax < ActiveRecord::Base
+    belongs_to :shipping_rate, class_name: "Spree::ShippingRate"
+    belongs_to :tax_rate, class_name: "Spree::TaxRate"
+
+    extend DisplayMoney
+    money_methods :absolute_amount
+
+    delegate :currency, to: :shipping_rate, allow_nil: true
+
+    def label
+      Spree.t translation_key,
+        scope: 'shipping_rate_tax.label',
+        amount: display_absolute_amount,
+        tax_rate_name: tax_rate.name
+    end
+
+    def absolute_amount
+      amount.abs
+    end
+
+    private
+
+    def translation_key
+      if tax_rate.included_in_price?
+        if amount > 0
+           :vat
+         else
+           :vat_refund
+         end
+       else
+         :sales_tax
+      end
+    end
+  end
+end

data/app/models/spree/state.rb

@@ -13,7 +13,7 @@ module Spree
     # blank is added elsewhere, if needed
     def self.states_group_by_country_id
       state_info = Hash.new { |h, k| h[k] = [] }
-      self.order(:name).each { |state|
+      order(:name).each { |state|
         state_info[state.country_id.to_s].push [state.id, state.name]
       }
       state_info

data/app/models/spree/state_change.rb

@@ -9,7 +9,7 @@ module Spree
     end
 
     def assign_user
-      true   # don't stop the filters
+      true # don't stop the filters
     end
   end
 end

data/app/models/spree/stock/availability_validator.rb

@@ -21,8 +21,8 @@ module Spree
         quantifier = Stock::Quantifier.new(line_item.variant, stock_location)
         unless quantifier.can_supply?(quantity)
           variant = line_item.variant
-          display_name = %Q{#{variant.name}}
-          display_name += %Q{ (#{variant.options_text})} unless variant.options_text.blank?
+          display_name = variant.name.to_s
+          display_name += %{ (#{variant.options_text})} unless variant.options_text.blank?
 
           line_item.errors[:quantity] << Spree.t(
             :selected_quantity_not_available,