spree_core 3.0.9 → 3.2.0

data/app/models/spree/shipment.rb

@@ -2,26 +2,26 @@ require 'ostruct'
 
 module Spree
   class Shipment < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'H', length: 11)
+
     extend FriendlyId
     friendly_id :number, slug_column: :number, use: :slugged
 
-    include Spree::NumberGenerator
-
-    def generate_number(options = {})
-      options[:prefix] ||= 'H'
-      options[:length] ||= 11
-      super(options)
+    with_options inverse_of: :shipments do
+      belongs_to :address, class_name: 'Spree::Address'
+      belongs_to :order, class_name: 'Spree::Order', touch: true
     end
-
-    belongs_to :address, class_name: 'Spree::Address', inverse_of: :shipments
-    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
 
-    has_many :adjustments, as: :adjustable, dependent: :delete_all
-    has_many :inventory_units, dependent: :delete_all, inverse_of: :shipment
-    has_many :shipping_rates, -> { order('cost ASC') }, dependent: :delete_all
+    with_options dependent: :delete_all do
+      has_many :adjustments, as: :adjustable
+      has_many :inventory_units, inverse_of: :shipment
+      has_many :shipping_rates, -> { order(:cost) }
+      has_many :state_changes, as: :stateful
+    end
     has_many :shipping_methods, through: :shipping_rates
-    has_many :state_changes, as: :stateful
+    has_one :selected_shipping_rate, -> { where(selected: true).order(:cost) }, class_name: Spree::ShippingRate
+
 
     after_save :update_adjustments
 
@@ -67,10 +67,7 @@ module Spree
 
       event :resume do
         transition from: :canceled, to: :ready, if: lambda { |shipment|
-          shipment.determine_state(shipment.order) == :ready
-        }
-        transition from: :canceled, to: :pending, if: lambda { |shipment|
-          shipment.determine_state(shipment.order) == :ready
+          shipment.determine_state(shipment.order) == 'ready'
         }
         transition from: :canceled, to: :pending
       end
@@ -120,7 +117,7 @@ module Spree
       return 'canceled' if order.canceled?
       return 'pending' unless order.can_ship?
       return 'pending' if inventory_units.any? &:backordered?
-      return 'shipped' if state == 'shipped'
+      return 'shipped' if shipped?
       order.paid? || Spree::Config[:auto_capture_on_dispatch] ? 'ready' : 'pending'
     end
 
@@ -142,8 +139,8 @@ module Spree
     end
 
     def finalize!
-      InventoryUnit.finalize_units!(inventory_units)
-      manifest.each { |item| manifest_unstock(item) }
+      inventory_units.finalize_units!
+      after_resume
     end
 
     def include?(variant)
@@ -155,7 +152,7 @@ module Spree
     end
 
     def inventory_units_for_item(line_item, variant = nil)
-      inventory_units.where(line_item_id: line_item.id, variant_id: line_item.variant.id || variant.id)
+      inventory_units.where(line_item_id: line_item.id, variant_id: line_item.variant_id || variant.id)
     end
 
     def item_cost
@@ -175,7 +172,7 @@ module Spree
         units.group_by(&:line_item_id).map do |line_item_id, units|
 
           states = {}
-          units.group_by(&:state).each { |state, iu| states[state] = iu.count }
+          units.group_by(&:state).each { |state, iu| states[state] = iu.size }
 
           line_item = units.first.line_item
           variant = units.first.variant
@@ -234,10 +231,6 @@ module Spree
       shipping_rates
     end
 
-    def selected_shipping_rate
-      shipping_rates.where(selected: true).first
-    end
-
     def selected_shipping_rate_id
       selected_shipping_rate.try(:id)
     end
@@ -259,7 +252,7 @@ module Spree
 
     def shipped=(value)
       return unless value == '1' && shipped_at.nil?
-      self.shipped_at = Time.now
+      self.shipped_at = Time.current
     end
 
     def shipping_method
@@ -294,7 +287,7 @@ module Spree
         self.update_columns(
           cost: selected_shipping_rate.cost,
           adjustment_total: adjustments.additional.map(&:update!).compact.sum,
-          updated_at: Time.now,
+          updated_at: Time.current,
         )
       end
     end
@@ -316,7 +309,7 @@ module Spree
           # (via Order#paid?) affects the shipment state (YAY)
           self.update_columns(
             state: determine_state(order),
-            updated_at: Time.now
+            updated_at: Time.current
           )
 
           # And then it's time to update shipment states and finally persist
@@ -337,7 +330,7 @@ module Spree
       new_state = determine_state(order)
       update_columns(
         state: new_state,
-        updated_at: Time.now,
+        updated_at: Time.current,
       )
       after_ship if new_state == 'shipped' and old_state != 'shipped'
     end

data/app/models/spree/shipment_handler.rb

@@ -5,7 +5,7 @@ module Spree
         # Do we have a specialized shipping-method-specific handler? e.g:
         # Given shipment.shipping_method = Spree::ShippingMethod::DigitalDownload
         # do we have Spree::ShipmentHandler::DigitalDownload?
-        if sm_handler = "Spree::ShipmentHandler::#{shipment.shipping_method.name.split('::').last}".constantize rescue false
+        if sm_handler = "Spree::ShipmentHandler::#{shipment.shipping_method.name.split('::').last}".safe_constantize
           sm_handler.new(shipment)
         else
           new(shipment)
@@ -36,7 +36,7 @@ module Spree
         new_state = OrderUpdater.new(order).update_shipment_state
         order.update_columns(
                              shipment_state: new_state,
-                             updated_at: Time.now,
+                             updated_at: Time.current,
                              )
       end
   end

data/app/models/spree/shipping_category.rb

@@ -1,8 +1,11 @@
 module Spree
   class ShippingCategory < Spree::Base
-    validates :name, presence: true
-    has_many :products, inverse_of: :shipping_category
-    has_many :shipping_method_categories, inverse_of: :shipping_category
+    validates :name, presence: true, uniqueness: { allow_blank: true }
+
+    with_options inverse_of: :shipping_category do
+      has_many :products
+      has_many :shipping_method_categories
+    end
     has_many :shipping_methods, through: :shipping_method_categories
   end
 end

data/app/models/spree/shipping_method.rb

@@ -11,16 +11,16 @@ module Spree
 
     default_scope { where(deleted_at: nil) }
 
-    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_and_belongs_to_many :zones, :join_table => 'spree_shipping_methods_zones',
-                                    :class_name => 'Spree::Zone',
-                                    :foreign_key => 'shipping_method_id'
+    has_many :shipping_method_zones, class_name: 'Spree::ShippingMethodZone',
+                                     foreign_key: 'shipping_method_id'
+    has_many :zones, through: :shipping_method_zones, class_name: 'Spree::Zone'
 
-    belongs_to :tax_category, :class_name => 'Spree::TaxCategory'
+    belongs_to :tax_category, class_name: 'Spree::TaxCategory'
 
     validates :name, presence: true
 
@@ -28,7 +28,7 @@ module Spree
 
     def include?(address)
       return false unless address
-      zones.any? do |zone|
+      zones.includes(:zone_members).any? do |zone|
         zone.include?(address)
       end
     end
@@ -59,10 +59,11 @@ module Spree
     end
 
     private
-      def at_least_one_shipping_category
-        if self.shipping_categories.empty?
-          self.errors[:base] << "You need to select at least one shipping category"
-        end
+
+    def at_least_one_shipping_category
+      if shipping_categories.empty?
+        errors.add(:base, :required_shipping_category)
       end
+    end
   end
 end

data/app/models/spree/shipping_method_zone.rb

@@ -0,0 +1,6 @@
+module Spree
+  class ShippingMethodZone < Spree::Base
+    belongs_to :shipping_method
+    belongs_to :zone
+  end
+end

data/app/models/spree/shipping_rate.rb

@@ -6,50 +6,37 @@ module Spree
 
     delegate :order, :currency, to: :shipment
     delegate :name, to: :shipping_method
+    delegate :code, to: :shipping_method, prefix: true
 
-    def display_base_price
-      Spree::Money.new(cost, currency: currency)
-    end
+    extend Spree::DisplayMoney
+
+    money_methods :base_price, :tax_amount
 
-    def calculate_tax_amount
-      tax_rate.calculator.compute_shipping_rate(self)
+    def base_price
+      cost
     end
 
     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
+
+      return price if tax_rate.nil? || tax_amount == 0
+
+      Spree.t tax_rate.included_in_price? ? :including_tax : :excluding_tax,
+              scope: "shipping_rates.display_price",
+              price: price,
+              tax_amount: display_tax_amount,
+              tax_rate_name: tax_rate.name
     end
     alias_method :display_cost, :display_price
 
-    def display_tax_amount(tax_amount)
-      Spree::Money.new(tax_amount, currency: currency)
+    def tax_amount
+      @_tax_amount ||= tax_rate.calculator.compute_shipping_rate(self)
     end
 
     def shipping_method
       Spree::ShippingMethod.unscoped { super }
     end
 
-    def shipping_method_code
-      shipping_method.code
-    end
-
     def tax_rate
       Spree::TaxRate.unscoped { super }
     end

data/app/models/spree/state.rb

@@ -1,7 +1,7 @@
 module Spree
   class State < Spree::Base
     belongs_to :country, class_name: 'Spree::Country'
-    has_many :addresses, dependent: :nullify
+    has_many :addresses, dependent: :restrict_with_error
 
     has_many :zone_members,
              -> { where(zoneable_type: 'Spree::State') },
@@ -12,6 +12,7 @@ module Spree
     has_many :zones, through: :zone_members, class_name: 'Spree::Zone'
 
     validates :country, :name, presence: true
+    validates :name, :abbr, uniqueness: { case_sensitive: false, scope: :country_id }, allow_blank: true
 
     self.whitelisted_ransackable_attributes = %w(abbr)
 
@@ -23,7 +24,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 ASC').each { |state|
+      self.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

@@ -1,6 +1,6 @@
 module Spree
   class StateChange < Spree::Base
-    belongs_to :user, class_name: Spree.user_class.to_s
+    belongs_to :user, class_name: Spree.user_class
     belongs_to :stateful, polymorphic: true
 
     def <=>(other)

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

@@ -3,11 +3,12 @@
 module Spree
   module Stock
     class Adjuster
-      attr_accessor :inventory_unit, :status, :fulfilled
+      attr_accessor :inventory_unit, :status, :fulfilled, :package
 
-      def initialize(inventory_unit, status)
+      def initialize(inventory_unit, status, package=nil)
         @inventory_unit = inventory_unit
         @status = status
+        @package = package
         @fulfilled = false
       end
 
@@ -19,6 +20,12 @@ module Spree
         end
       end
 
+      def reassign(status, package)
+        @fulfilled = false
+        @status = status
+        @package = package
+      end
+
       def fulfilled?
         fulfilled
       end

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

@@ -8,16 +8,17 @@ module Spree
         @state = state
       end
 
-      def variant
-        inventory_unit.variant
+      with_options allow_nil: true do
+        delegate :line_item,
+                 :variant, to: :inventory_unit
+        delegate :price, to: :variant
+        delegate :dimension,
+                 :volume,
+                 :weight, to: :variant, prefix: true
       end
 
       def weight
-        variant.weight * quantity
-      end
-
-      def line_item
-        inventory_unit.line_item
+        variant_weight * quantity
       end
 
       def on_hand?
@@ -28,9 +29,6 @@ module Spree
         state.to_s == "backordered"
       end
 
-      def price
-        variant.price
-      end
 
       def amount
         price * quantity
@@ -45,11 +43,11 @@ module Spree
       end
 
       def volume
-        variant.volume * quantity
+        variant_volume * quantity
       end
 
       def dimension
-        variant.dimension * quantity
+        variant_dimension * quantity
       end
     end
   end

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

@@ -1,11 +1,12 @@
 module Spree
   module Stock
     class Coordinator
-      attr_reader :order, :inventory_units
+      attr_reader :order, :inventory_units, :allocated_inventory_units
 
       def initialize(order, inventory_units = nil)
         @order = order
         @inventory_units = inventory_units || InventoryUnitBuilder.new(order).units
+        @allocated_inventory_units = []
       end
 
       def shipments
@@ -20,28 +21,33 @@ module Spree
         packages = estimate_packages(packages)
       end
 
-      # Build packages as per stock location
-      #
-      # It needs to check whether each stock location holds at least one stock
-      # item for the order. In case none is found it wouldn't make any sense
-      # to build a package because it would be empty. Plus we avoid errors down
-      # the stack because it would assume the stock location has stock items
-      # for the given order
-      # 
-      # Returns an array of Package instances
       def build_packages(packages = Array.new)
-        StockLocation.active.each do |stock_location|
-          next unless stock_location.stock_items.where(:variant_id => inventory_units.map(&:variant_id).uniq).exists?
-
-          packer = build_packer(stock_location, inventory_units)
+        stock_locations_with_requested_variants.each do |stock_location|
+          packer = build_packer(stock_location, unallocated_inventory_units)
           packages += packer.packages
+          @allocated_inventory_units += packer.allocated_inventory_units
         end
+
         packages
       end
 
       private
+
+      def unallocated_inventory_units
+        inventory_units - allocated_inventory_units
+      end
+
+      def stock_locations_with_requested_variants
+        Spree::StockLocation.active.joins(:stock_items).
+          where(spree_stock_items: { variant_id: requested_variant_ids }).distinct
+      end
+
+      def requested_variant_ids
+        inventory_units.map(&:variant_id).uniq
+      end
+
       def prioritize_packages(packages)
-        prioritizer = Prioritizer.new(inventory_units, packages)
+        prioritizer = Prioritizer.new(packages)
         prioritizer.prioritized_packages
       end
 

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

@@ -1,6 +1,8 @@
 module Spree
   module Stock
     class Estimator
+      include VatPriceCalculation
+
       attr_reader :order, :currency
 
       def initialize(order)
@@ -28,44 +30,40 @@ module Spree
       def calculate_shipping_rates(package, ui_filter)
         shipping_methods(package, ui_filter).map do |shipping_method|
           cost = shipping_method.calculator.compute(package)
-          tax_category = shipping_method.tax_category
-          if tax_category
-            tax_rate = tax_category.tax_rates.detect do |rate|
-              # If the rate's zone matches the order's zone, a positive adjustment will be applied.
-              # If the rate is from the default tax zone, then a negative adjustment will be applied.
-              # See the tests in shipping_rate_spec.rb for an example of this.d
-              rate.zone == order.tax_zone || rate.zone.default_tax?
-            end
-          end
-
-          if cost
-            rate = shipping_method.shipping_rates.new(cost: cost)
-            rate.tax_rate = tax_rate if tax_rate
-          end
 
-          rate
+          shipping_method.shipping_rates.new(
+            cost: gross_amount(cost, taxation_options_for(shipping_method)),
+            tax_rate: first_tax_rate_for(shipping_method.tax_category)
+          ) if cost
         end.compact
       end
 
+      # Override this if you need the prices for shipping methods to be handled just like the
+      # prices for products in terms of included tax manipulation.
+      #
+      def taxation_options_for(shipping_method)
+        {
+          tax_category: shipping_method.tax_category,
+          tax_zone: @order.tax_zone
+        }
+      end
+
+      def first_tax_rate_for(tax_category)
+        return unless @order.tax_zone && tax_category
+        Spree::TaxRate.for_tax_category(tax_category).
+          potential_rates_for_zone(@order.tax_zone).first
+      end
+
       def shipping_methods(package, display_filter)
         package.shipping_methods.select do |ship_method|
           calculator = ship_method.calculator
-          begin
-            ship_method.available_to_display(display_filter) &&
-            ship_method.include?(order.ship_address) &&
-            calculator.available?(package) &&
-            (calculator.preferences[:currency].blank? ||
-             calculator.preferences[:currency] == currency)
-          rescue Exception => exception
-            log_calculator_exception(ship_method, exception)
-          end
-        end
-      end
 
-      def log_calculator_exception(ship_method, exception)
-        Rails.logger.info("Something went wrong calculating rates with the #{ship_method.name} (ID=#{ship_method.id}) shipping method.")
-        Rails.logger.info("*" * 50)
-        Rails.logger.info(exception.backtrace.join("\n"))
+          ship_method.available_to_display(display_filter) &&
+          ship_method.include?(order.ship_address) &&
+          calculator.available?(package) &&
+          (calculator.preferences[:currency].blank? ||
+           calculator.preferences[:currency] == currency)
+        end
       end
     end
   end

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

@@ -8,17 +8,9 @@ module Spree
       def units
         @order.line_items.flat_map do |line_item|
           line_item.quantity.times.map do |i|
-            @order.inventory_units.includes(
-              variant: {
-                product: {
-                  shipping_category: {
-                    shipping_methods: [:calculator, { zones: :zone_members }]
-                  }
-                }
-              }
-            ).build(
+            @order.inventory_units.build(
               pending: true,
-              variant: line_item.variant,
+              variant_id: line_item.variant_id,
               line_item: line_item,
               order: @order
             )

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

@@ -11,7 +11,8 @@ module Spree
       end
 
       def add(inventory_unit, state = :on_hand)
-        contents << ContentItem.new(inventory_unit, state) unless find_item(inventory_unit)
+         # Remove find_item check as already taken care by prioritizer
+        contents << ContentItem.new(inventory_unit, state)
       end
 
       def add_multiple(inventory_units, state = :on_hand)
@@ -62,11 +63,12 @@ module Spree
       end
 
       def shipping_categories
-        contents.map { |item| item.variant.shipping_category }.compact.uniq
+        Spree::ShippingCategory.joins(products: :variants_including_master).
+          where(spree_variants: { id: variant_ids }).distinct
       end
 
       def shipping_methods
-        shipping_categories.map(&:shipping_methods).reduce(:&).to_a
+        shipping_categories.includes(:shipping_methods).map(&:shipping_methods).reduce(:&).to_a
       end
 
       def inspect
@@ -99,6 +101,12 @@ module Spree
       def dimension
         contents.sum(&:dimension)
       end
+
+      private
+
+      def variant_ids
+        contents.map { |item| item.inventory_unit.variant_id }.compact.uniq
+      end
     end
   end
 end

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

@@ -1,12 +1,13 @@
 module Spree
   module Stock
     class Packer
-      attr_reader :stock_location, :inventory_units, :splitters
+      attr_reader :stock_location, :inventory_units, :splitters, :allocated_inventory_units
 
       def initialize(stock_location, inventory_units, splitters=[Splitter::Base])
         @stock_location = stock_location
         @inventory_units = inventory_units
         @splitters = splitters
+        @allocated_inventory_units = []
       end
 
       def packages
@@ -19,23 +20,32 @@ module Spree
 
       def default_package
         package = Package.new(stock_location)
-        inventory_units.group_by(&:variant).each do |variant, variant_inventory_units|
+
+        # Group by variant_id as grouping by variant fires cached query.
+        inventory_units.group_by(&:variant_id).each do |variant_id, variant_inventory_units|
+          variant = Spree::Variant.find(variant_id)
           units = variant_inventory_units.clone
           if variant.should_track_inventory?
             next unless stock_location.stock_item(variant)
 
-            on_hand, backordered = stock_location.fill_status(variant, units.count)
-            package.add_multiple units.slice!(0, on_hand), :on_hand if on_hand > 0
-            package.add_multiple units.slice!(0, backordered), :backordered if backordered > 0
+            on_hand, backordered = stock_location.fill_status(variant, units.size)
+            on_hand_units, backordered_units = units.slice!(0, on_hand), units.slice!(0, backordered)
+
+            package.add_multiple on_hand_units, :on_hand if on_hand > 0
+            package.add_multiple backordered_units, :backordered if backordered > 0
+
+            @allocated_inventory_units += (on_hand_units + backordered_units)
           else
             package.add_multiple units
+            @allocated_inventory_units += units
           end
-
         end
+
         package
       end
 
       private
+
       def build_splitter
         splitter = nil
         splitters.reverse.each do |klass|