spree_core 3.1.14 → 3.2.0.rc1

data/app/models/spree/promotion_handler/coupon.rb

@@ -11,16 +11,13 @@ module Spree
       def apply
         if order.coupon_code.present?
           if promotion.present? && promotion.actions.exists?
-            handle_present_promotion(promotion)
+            handle_present_promotion
+          elsif Promotion.with_coupon_code(order.coupon_code).try(:expired?)
+            set_error_code :coupon_code_expired
           else
-            if Promotion.with_coupon_code(order.coupon_code).try(:expired?)
-              set_error_code :coupon_code_expired
-            else
-              set_error_code :coupon_code_not_found
-            end
+            set_error_code :coupon_code_not_found
           end
         end
-
         self
       end
 
@@ -35,7 +32,9 @@ module Spree
       end
 
       def promotion
-        @promotion ||= Promotion.active.includes(:promotion_rules, :promotion_actions).with_coupon_code(order.coupon_code)
+        @promotion ||= Promotion.active.includes(
+          :promotion_rules, :promotion_actions
+        ).with_coupon_code(order.coupon_code)
       end
 
       def successful?
@@ -44,18 +43,17 @@ module Spree
 
       private
 
-      def handle_present_promotion(promotion)
+      def handle_present_promotion
         return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded?(order)
-        return promotion_applied if promotion_exists_on_order?(order, promotion)
+        return promotion_applied if promotion_exists_on_order?
         unless promotion.eligible?(order)
           self.error = promotion.eligibility_errors.full_messages.first unless promotion.eligibility_errors.blank?
-          return (self.error || ineligible_for_this_order)
+          return (error || ineligible_for_this_order)
         end
 
         # If any of the actions for the promotion return `true`,
         # then result here will also be `true`.
-        result = promotion.activate(:order => order)
-        if result
+        if promotion.activate(order: order)
           determine_promotion_application_result
         else
           set_error_code :coupon_code_unknown_error
@@ -74,7 +72,7 @@ module Spree
         set_error_code :coupon_code_already_applied
       end
 
-      def promotion_exists_on_order?(order, promotion)
+      def promotion_exists_on_order?
         order.promotions.include? promotion
       end
 
@@ -85,21 +83,23 @@ module Spree
         end
 
         # Check for applied line items.
-        created_line_items = promotion.actions.detect { |a| a.type == 'Spree::Promotion::Actions::CreateLineItems' }
+        created_line_items = promotion.actions.detect do |a|
+          Object.const_get(a.type).ancestors.include?(
+            Spree::Promotion::Actions::CreateLineItems
+          )
+        end
 
         if discount || created_line_items
           order.update_totals
           order.persist_totals
           set_success_code :coupon_code_applied
-        else
+        elsif order.promotions.with_coupon_code(order.coupon_code)
           # if the promotion exists on an order, but wasn't found above,
           # we've already selected a better promotion
-          if order.promotions.with_coupon_code(order.coupon_code)
-            set_error_code :coupon_code_better_exists
-          else
-            # if the promotion was created after the order
-            set_error_code :coupon_code_not_found
-          end
+          set_error_code :coupon_code_better_exists
+        else
+          # if the promotion was created after the order
+          set_error_code :coupon_code_not_found
         end
       end
     end

data/app/models/spree/promotion_handler/page.rb

@@ -10,14 +10,14 @@ module Spree
 
       def activate
         if promotion && promotion.eligible?(order)
-          promotion.activate(:order => order)
+          promotion.activate(order: order)
         end
       end
 
       private
 
         def promotion
-          @promotion ||= Promotion.active.find_by(:path => path)
+          @promotion ||= Promotion.active.find_by(path: path)
         end
     end
   end

data/app/models/spree/refund.rb

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

data/app/models/spree/refund_reason.rb

@@ -7,7 +7,7 @@ module Spree
     has_many :refunds, dependent: :restrict_with_error
 
     def self.return_processing_reason
-      find_by!(name: RETURN_PROCESSING_REASON, mutable: false)
+      find_by(name: RETURN_PROCESSING_REASON, mutable: false)
     end
   end
 end

data/app/models/spree/reimbursement_type.rb

@@ -2,7 +2,11 @@ module Spree
   class ReimbursementType < Spree::Base
     include Spree::NamedType
 
-    ORIGINAL = 'original'
+    KINDS = %w(Spree::ReimbursementType::Credit
+               Spree::ReimbursementType::Exchange
+               Spree::ReimbursementType::OriginalPayment
+               Spree::ReimbursementType::StoreCredit).freeze
+    ORIGINAL = 'original'.freeze
 
     has_many :return_items
 

data/app/models/spree/return_item.rb

@@ -102,7 +102,7 @@ module Spree
         transition to: :manual_intervention_required, from: [:accepted, :pending, :manual_intervention_required]
       end
 
-      after_transition any => any, :do => :persist_acceptance_status_errors
+      after_transition any => any, do: :persist_acceptance_status_errors
     end
 
     def self.from_inventory_unit(inventory_unit)

data/app/models/spree/shipment.rb

@@ -20,6 +20,8 @@ module Spree
       has_many :state_changes, as: :stateful
     end
     has_many :shipping_methods, through: :shipping_rates
+    has_one :selected_shipping_rate, -> { where(selected: true).order(:cost) }, class_name: Spree::ShippingRate
+
 
     after_save :update_adjustments
 
@@ -137,7 +139,7 @@ module Spree
     end
 
     def finalize!
-      InventoryUnit.finalize_units!(inventory_units)
+      inventory_units.finalize_units!
       after_resume
     end
 
@@ -150,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
@@ -229,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

data/app/models/spree/shipment_handler.rb

@@ -20,9 +20,9 @@ module Spree
     def perform
       @shipment.inventory_units.each &:ship!
       @shipment.process_order_payments if Spree::Config[:auto_capture_on_dispatch]
+      send_shipped_email
       @shipment.touch :shipped_at
       update_order_shipment_state
-      send_shipped_email
     end
 
     private

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/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
@@ -22,7 +23,9 @@ module Spree
 
       def build_packages(packages = Array.new)
         stock_locations_with_requested_variants.each do |stock_location|
-          packages += build_packer(stock_location, inventory_units).packages
+          packer = build_packer(stock_location, unallocated_inventory_units)
+          packages += packer.packages
+          @allocated_inventory_units += packer.allocated_inventory_units
         end
 
         packages
@@ -30,9 +33,13 @@ module Spree
 
       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 })
+          where(spree_stock_items: { variant_id: requested_variant_ids }).distinct
       end
 
       def requested_variant_ids
@@ -40,7 +47,7 @@ module Spree
       end
 
       def prioritize_packages(packages)
-        prioritizer = Prioritizer.new(inventory_units, packages)
+        prioritizer = Prioritizer.new(packages)
         prioritizer.prioritized_packages
       end
 

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

@@ -10,7 +10,7 @@ module Spree
           line_item.quantity.times.map do |i|
             @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.size)
-            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_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|

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

@@ -1,12 +1,12 @@
 module Spree
   module Stock
     class Prioritizer
-      attr_reader :packages, :inventory_units
+      attr_reader :packages
 
-      def initialize(inventory_units, packages, adjuster_class=Adjuster)
-        @inventory_units = inventory_units
+      def initialize(packages, adjuster_class=Adjuster)
         @packages = packages
         @adjuster_class = adjuster_class
+        @adjusters = Hash.new
       end
 
       def prioritized_packages
@@ -17,22 +17,32 @@ module Spree
       end
 
       private
-      def adjust_packages
-        inventory_units.each do |inventory_unit|
-          adjuster = @adjuster_class.new(inventory_unit, :on_hand)
-
-          visit_packages(adjuster)
 
-          adjuster.status = :backordered
-          visit_packages(adjuster)
+      def adjust_packages
+        packages.each do |package|
+          package.contents.each do |item|
+            adjuster = find_adjuster(item)
+
+            if adjuster.nil?
+              adjuster = build_adjuster(item, package)
+            elsif item.state == :on_hand && adjuster.status == :backordered
+              # Remove item from backordered package
+              adjuster.package.remove(item.inventory_unit)
+              # Reassign adjuster's status package
+              adjuster.reassign(:on_hand, package)
+            end
+
+            adjuster.adjust(package)
+          end
         end
       end
 
-      def visit_packages(adjuster)
-        packages.each do |package|
-          item = package.find_item adjuster.inventory_unit, adjuster.status
-          adjuster.adjust(package) if item
-        end
+      def build_adjuster(item, package)
+        @adjusters[item.inventory_unit] = @adjuster_class.new(item.inventory_unit, item.state, package)
+      end
+
+      def find_adjuster(item)
+        @adjusters[item.inventory_unit]
       end
 
       def sort_packages

data/app/models/spree/stock/splitter/shipping_category.rb

@@ -14,7 +14,7 @@ module Spree
         def split_by_category(package)
           categories = Hash.new { |hash, key| hash[key] = [] }
           package.contents.each do |item|
-            categories[item.variant.shipping_category_id] << item
+            categories[shipping_category_for(item)] << item
           end
           hash_to_packages(categories)
         end
@@ -26,6 +26,11 @@ module Spree
           end
           packages
         end
+
+        def shipping_category_for(item)
+          @item_shipping_category ||= {}
+          @item_shipping_category[item.inventory_unit.variant_id] ||= item.variant.shipping_category_id
+        end
       end
     end
   end

data/app/models/spree/stock_item.rb

@@ -4,7 +4,7 @@ module Spree
 
     with_options inverse_of: :stock_items do
       belongs_to :stock_location, class_name: 'Spree::StockLocation'
-      belongs_to :variant, class_name: 'Spree::Variant', counter_cache: true
+      belongs_to :variant, class_name: 'Spree::Variant'
     end
     has_many :stock_movements, inverse_of: :stock_item
 
@@ -18,6 +18,7 @@ module Spree
 
     delegate :weight, :should_track_inventory?, to: :variant
     delegate :name, to: :variant, prefix: true
+    delegate :product, to: :variant
 
     after_save :conditional_variant_touch, if: :changed?
     after_touch { variant.touch }

data/app/models/spree/stock_movement.rb

@@ -1,5 +1,10 @@
 module Spree
   class StockMovement < Spree::Base
+    QUANTITY_LIMITS = {
+      max: 2**31 - 1,
+      min: -2**31
+    }.freeze
+
     belongs_to :stock_item, class_name: 'Spree::StockItem', inverse_of: :stock_movements
     belongs_to :originator, polymorphic: true
 
@@ -8,11 +13,11 @@ module Spree
     with_options presence: true do
       validates :stock_item
       validates :quantity, numericality: {
-                                            greater_than_or_equal_to: -2**31,
-                                            less_than_or_equal_to: 2**31 - 1,
-                                            only_integer: true,
-                                            allow_nil: true
-                                          }
+        greater_than_or_equal_to: QUANTITY_LIMITS[:min],
+        less_than_or_equal_to: QUANTITY_LIMITS[:max],
+        only_integer: true,
+        allow_nil: true
+      }
     end
 
     scope :recent, -> { order(created_at: :desc) }
@@ -20,7 +25,7 @@ module Spree
     self.whitelisted_ransackable_attributes = ['quantity']
 
     def readonly?
-      !new_record?
+      persisted?
     end
 
     private

data/app/models/spree/store.rb

@@ -38,6 +38,7 @@ module Spree
     def validate_not_default
       if default
         errors.add(:base, :cannot_destroy_default_store)
+        throw(:abort)
       end
     end
 

data/app/models/spree/store_credit.rb

@@ -238,7 +238,7 @@ module Spree
     def validate_no_amount_used
       if amount_used > 0
         errors.add(:amount_used, :greater_than_zero_restrict_delete)
-        false
+        throw(:abort)
       end
     end
 

data/app/models/spree/tag.rb

@@ -0,0 +1,4 @@
+module Spree
+  class Tag < ActsAsTaggableOn::Tag
+  end
+end

data/app/models/spree/tax_rate.rb

@@ -72,6 +72,12 @@ module Spree
           rate.adjust(order, item)
         end
       end
+
+      # updates pre_tax for items without any tax rates
+      remaining_items = items - relevant_items
+      remaining_items.each do |item|
+        store_pre_tax_amount(item, [])
+      end
     end
 
     def self.included_tax_amount_for(options)

data/app/models/spree/taxon.rb

@@ -4,7 +4,7 @@ require 'stringex'
 module Spree
   class Taxon < Spree::Base
     extend FriendlyId
-    friendly_id :permalink, slug_column: :permalink, use: :slugged
+    friendly_id :permalink, slug_column: :permalink, use: :history
     before_create :set_permalink
 
     acts_as_nested_set dependent: :destroy
@@ -13,10 +13,10 @@ module Spree
     has_many :classifications, -> { order(:position) }, dependent: :delete_all, inverse_of: :taxon
     has_many :products, through: :classifications
 
-    has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon'
+    has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon', dependent: :destroy
     has_many :prototypes, through: :prototype_taxons, class_name: 'Spree::Prototype'
 
-    has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon'
+    has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', dependent: :destroy
     has_many :promotion_rules, through: :promotion_rule_taxons, class_name: 'Spree::PromotionRule'
 
     validates :name, presence: true

data/app/models/spree/variant.rb

@@ -58,15 +58,18 @@ module Spree
     scope :in_stock, -> { joins(:stock_items).where('count_on_hand > ? OR track_inventory = ?', 0, false) }
 
     scope :not_discontinued, -> do
-      variant_table_name = Variant.quoted_table_name
-      where("#{variant_table_name}.discontinue_on IS NULL OR #{variant_table_name}.discontinue_on >= ?", Time.current)
+      where(
+        arel_table[:discontinue_on].eq(nil).or(
+          arel_table[:discontinue_on].gteq(Time.current)
+        )
+      )
     end
 
     scope :not_deleted, -> { where("#{Variant.quoted_table_name}.deleted_at IS NULL") }
 
     scope :for_currency_and_available_price_amount, -> (currency) do
       currency ||= Spree::Config[:currency]
-      joins(:prices).where("spree_prices.currency = ?", currency).where("spree_prices.amount IS NOT NULL").uniq
+      joins(:prices).where("spree_prices.currency = ?", currency).where("spree_prices.amount IS NOT NULL").distinct
     end
 
     scope :active, -> (currency = nil) do

data/app/models/spree/zone.rb

@@ -33,7 +33,7 @@ module Spree
         # Match zones of the same kind with similar countries
         joins(countries: :zones).
           where("zone_members_spree_countries_join.zone_id = ?", zone.id).
-          uniq
+          distinct
       else
         # Match zones of the same kind with similar states in AND match zones
         # that have the states countries in
@@ -44,7 +44,7 @@ module Spree
             spree_zone_members.zoneable_id IN (?))",
           zone.state_ids,
           zone.states.pluck(:country_id)
-        ).uniq
+        ).distinct
       end
     end
 

data/app/views/spree/shared/_paths.html.erb

@@ -0,0 +1,8 @@
+<script>
+  SpreePaths = <%==
+  {
+    mounted_at: Rails.application.routes.url_helpers.spree_path(trailing_slash: true),
+    admin: Spree.admin_path.gsub(/\A(\/)?(.*[^\/])(\/)?\z/, '\\2/')
+  }.to_json
+  %>
+</script>

data/config/initializers/acts_as_taggable_on.rb

@@ -0,0 +1,9 @@
+require "acts-as-taggable-on"
+
+ActsAsTaggableOn::Tag.class_eval do
+  self.table_name_prefix = "spree_"
+end
+
+ActsAsTaggableOn::Tagging.class_eval do
+  self.table_name_prefix = "spree_"
+end