spree_core 3.4.6 → 3.5.0.rc1

data/app/models/spree/promotion/rules/option_value.rb

@@ -31,12 +31,20 @@ module Spree
         end
 
         def actionable?(line_item)
-          product_id = line_item.product.id
-          option_values_ids = line_item.variant.option_value_ids
-          eligible_product_ids = preferred_eligible_values.keys
-          eligible_value_ids = preferred_eligible_values[product_id]
+          pid = line_item.product.id
+          ovids = line_item.variant.option_values.pluck(:id)
 
-          eligible_product_ids.include?(product_id) && (eligible_value_ids & option_values_ids).present?
+          product_ids.include?(pid) && (value_ids(pid) - ovids).empty?
+        end
+
+        private
+
+        def product_ids
+          preferred_eligible_values.keys
+        end
+
+        def value_ids(product_id)
+          preferred_eligible_values[product_id]
         end
       end
     end

data/app/models/spree/promotion/rules/product.rb

@@ -6,7 +6,8 @@ module Spree
     module Rules
       class Product < PromotionRule
         has_many :product_promotion_rules, class_name: 'Spree::ProductPromotionRule',
-                                           foreign_key: :promotion_rule_id
+                                           foreign_key: :promotion_rule_id,
+                                           dependent: :destroy
         has_many :products, through: :product_promotion_rules, class_name: 'Spree::Product'
 
         MATCH_POLICIES = %w(any all none)

data/app/models/spree/promotion/rules/taxon.rb

@@ -2,7 +2,9 @@ module Spree
   class Promotion
     module Rules
       class Taxon < PromotionRule
-        has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', foreign_key: 'promotion_rule_id'
+        has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon',
+                                         foreign_key: 'promotion_rule_id',
+                                         dependent: :destroy
         has_many :taxons, through: :promotion_rule_taxons, class_name: 'Spree::Taxon'
 
         MATCH_POLICIES = %w(any all)

data/app/models/spree/promotion_action_line_item.rb

@@ -2,5 +2,8 @@ module Spree
   class PromotionActionLineItem < Spree::Base
     belongs_to :promotion_action, class_name: 'Spree::Promotion::Actions::CreateLineItems'
     belongs_to :variant, class_name: 'Spree::Variant'
+
+    validates :promotion_action, :variant, :quantity, presence: true
+    validates :quantity, numericality: { only_integer: true, message: Spree.t('validation.must_be_int') }
   end
 end

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

@@ -0,0 +1,52 @@
+module Spree
+  module PromotionHandler
+    class PromotionDuplicator
+      def initialize(promotion)
+        @promotion = promotion
+      end
+
+      def duplicate
+        @new_promotion = @promotion.dup
+        @new_promotion.path = "#{@promotion.path}_new"
+        @new_promotion.name = "New #{@promotion.name}"
+        @new_promotion.code = "#{@promotion.code}_new"
+
+        ActiveRecord::Base.transaction do
+          @new_promotion.save
+          copy_rules
+          copy_actions
+        end
+
+        @new_promotion
+      end
+
+      private
+
+      def copy_rules
+        @promotion.promotion_rules.each do |rule|
+          new_rule = rule.dup
+          @new_promotion.promotion_rules << new_rule
+
+          new_rule.users = rule.users if rule.try(:users)
+          new_rule.taxons = rule.taxons if rule.try(:taxons)
+          new_rule.products = rule.products if rule.try(:products)
+        end
+      end
+
+      def copy_actions
+        @promotion.promotion_actions.each do |action|
+          new_action = action.dup
+          new_action.calculator = action.calculator.dup if action.try(:calculator)
+
+          @new_promotion.promotion_actions << new_action
+
+          if action.try(:promotion_action_line_items)
+            action.promotion_action_line_items.each do |item|
+              new_action.promotion_action_line_items << item.dup
+            end
+          end
+        end
+      end
+    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/reimbursement.rb

@@ -42,7 +42,7 @@ module Spree
     #   Refund.total_amount_reimbursed_for(reimbursement)
     # See the `reimbursement_generator` property regarding the generation of custom reimbursements.
     class_attribute :reimbursement_models
-    self.reimbursement_models = [Refund]
+    self.reimbursement_models = [Refund, Credit]
 
     # The reimbursement_performer property should be set to an object that responds to the following methods:
     # - #perform

data/app/models/spree/reimbursement/reimbursement_type_engine.rb

@@ -22,7 +22,7 @@ module Spree
     def calculate_reimbursement_types
       @return_items.each do |return_item|
         reimbursement_type = calculate_reimbursement_type(return_item)
-        add_reimbursement_type(return_item, reimbursement_type)
+        @reimbursement_type_hash[reimbursement_type] << return_item if reimbursement_type
       end
 
       @reimbursement_type_hash
@@ -31,24 +31,13 @@ module Spree
     private
 
     def calculate_reimbursement_type(return_item)
-      if return_item.exchange_required?
-        exchange_reimbursement_type
-      elsif return_item.override_reimbursement_type.present?
-        return_item.override_reimbursement_type.class
-      elsif return_item.preferred_reimbursement_type.present?
-        if valid_preferred_reimbursement_type?(return_item)
-          return_item.preferred_reimbursement_type.class
-        end
-      elsif past_reimbursable_time_period?(return_item)
-        expired_reimbursement_type
-      else
-        default_reimbursement_type
+      return exchange_reimbursement_type if return_item.exchange_required?
+      return return_item.override_reimbursement_type.class if return_item.override_reimbursement_type.present?
+      if return_item.preferred_reimbursement_type.present?
+        return valid_preferred_reimbursement_type?(return_item) ? return_item.preferred_reimbursement_type.class : nil
       end
-    end
-
-    def add_reimbursement_type(return_item, reimbursement_type)
-      return unless reimbursement_type
-      @reimbursement_type_hash[reimbursement_type] << return_item
+      return expired_reimbursement_type if past_reimbursable_time_period?(return_item)
+      default_reimbursement_type
     end
   end
 end

data/app/models/spree/reimbursement_performer.rb

@@ -21,18 +21,14 @@ module Spree
       private
 
       def execute(reimbursement, simulate)
-        reimbursement_type_hash = calculate_reimbursement_types(reimbursement)
+        # Engine reimbursement_type_engine returns hash of preferred reimbursement types pointing at return items
+        # {Spree::ReimbursementType::OriginalPayment => [ReturnItem, ...], Spree::ReimbursementType::Exchange => [ReturnItem, ...]}
+        reimbursement_type_hash = reimbursement_type_engine.new(reimbursement.return_items).calculate_reimbursement_types
 
         reimbursement_type_hash.flat_map do |reimbursement_type, return_items|
           reimbursement_type.reimburse(reimbursement, return_items, simulate)
         end
       end
-
-      def calculate_reimbursement_types(reimbursement)
-        # Engine returns hash of preferred reimbursement types pointing at return items
-        # {Spree::ReimbursementType::OriginalPayment => [ReturnItem, ...], Spree::ReimbursementType::Exchange => [ReturnItem, ...]}
-        reimbursement_type_engine.new(reimbursement.return_items).calculate_reimbursement_types
-      end
     end
   end
 end

data/app/models/spree/reimbursement_type/original_payment.rb

@@ -6,8 +6,8 @@ class Spree::ReimbursementType::OriginalPayment < Spree::ReimbursementType
       unpaid_amount = return_items.map { |ri| ri.total.to_d.round(2) }.sum
       payments = reimbursement.order.payments.completed
 
-      refund_list, unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount, simulate)
-      refund_list
+      reimbursement_list, unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount, simulate)
+      reimbursement_list
     end
   end
 end

data/app/models/spree/reimbursement_type/reimbursement_helpers.rb

@@ -1,7 +1,7 @@
 module Spree
   module ReimbursementType::ReimbursementHelpers
     def create_refunds(reimbursement, payments, unpaid_amount, simulate, reimbursement_list = [])
-      payments.map do |payment|
+      payments.each do |payment|
         break if unpaid_amount <= 0
         next unless payment.can_credit?
 
@@ -37,17 +37,13 @@ module Spree
     # If you have multiple methods of crediting a customer, overwrite this method
     # Must return an array of objects the respond to #description, #display_amount
     def create_credit(reimbursement, unpaid_amount, simulate)
-      creditable = create_creditable(reimbursement, unpaid_amount)
+      category = Spree::StoreCreditCategory.default_reimbursement_category(category_options(reimbursement))
+      creditable = Spree::StoreCredit.new(store_credit_params(category, reimbursement, unpaid_amount))
       credit = reimbursement.credits.build(creditable: creditable, amount: unpaid_amount)
       simulate ? credit.readonly! : credit.save!
       credit
     end
 
-    def create_creditable(reimbursement, unpaid_amount)
-      category = Spree::StoreCreditCategory.default_reimbursement_category(category_options(reimbursement))
-      Spree::StoreCredit.new(store_credit_params(category, reimbursement, unpaid_amount))
-    end
-
     def store_credit_params(category, reimbursement, unpaid_amount)
       {
         user: reimbursement.order.user,

data/app/models/spree/reimbursement_type/store_credit.rb

@@ -4,12 +4,10 @@ class Spree::ReimbursementType::StoreCredit < Spree::ReimbursementType
   class << self
     def reimburse(reimbursement, return_items, simulate)
       unpaid_amount = return_items.sum(&:total).to_d.round(2, :down)
-      payments = store_credit_payments(reimbursement)
-      reimbursement_list = []
+      payments = reimbursement.order.payments.completed.store_credits
 
       # Credit each store credit that was used on the order
-      reimbursement_list, unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount,
-                                                         simulate, reimbursement_list)
+      reimbursement_list, unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount, simulate)
 
       # If there is any amount left to pay out to the customer, then create credit with that amount
       if unpaid_amount > 0.0
@@ -18,11 +16,5 @@ class Spree::ReimbursementType::StoreCredit < Spree::ReimbursementType
 
       reimbursement_list
     end
-
-    private
-
-    def store_credit_payments(reimbursement)
-      reimbursement.order.payments.completed.store_credits
-    end
   end
 end

data/app/models/spree/shipment.rb

@@ -39,7 +39,7 @@ module Spree
     scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
     scope :with_state, ->(*s) { where(state: s) }
     # sort by most recent shipped_at, falling back to created_at. add "id desc" to make specs that involve this scope more deterministic.
-    scope :reverse_chronological, -> { order('coalesce(spree_shipments.shipped_at, spree_shipments.created_at) desc', id: :desc) }
+    scope :reverse_chronological, -> { order(Arel.sql('coalesce(spree_shipments.shipped_at, spree_shipments.created_at) desc'), id: :desc) }
 
     # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
     state_machine initial: :pending, use_transactions: false do
@@ -217,10 +217,15 @@ module Spree
 
       if shipping_method
         selected_rate = shipping_rates.detect do |rate|
-          rate.shipping_method_id == original_shipping_method_id
+          if original_shipping_method_id
+            rate.shipping_method_id == original_shipping_method_id
+          else
+            rate.selected
+          end
         end
         save!
         self.selected_shipping_rate_id = selected_rate.id if selected_rate
+        reload
       end
 
       shipping_rates
@@ -340,10 +345,11 @@ module Spree
 
         order.contents.remove(variant, quantity, shipment: self)
         order.contents.add(variant, quantity, shipment: new_shipment)
+        order.create_tax_charge!
         order.update_with_updater!
 
         refresh_rates
-        save!
+        save! if persisted?
         new_shipment.save!
       end
     end
@@ -362,7 +368,7 @@ module Spree
         order.update_with_updater!
 
         refresh_rates
-        save!
+        save! if persisted?
         shipment_to_transfer_to.refresh_rates
         shipment_to_transfer_to.save!
       end

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

@@ -2,7 +2,7 @@ module Spree
   module Stock
     class AvailabilityValidator < ActiveModel::Validator
       def validate(line_item)
-        unit_count = line_item.inventory_units.sum(&:quantity)
+        unit_count = line_item.inventory_units.reject(&:pending?).sum(&:quantity)
         return if unit_count >= line_item.quantity
 
         quantity = line_item.quantity - unit_count

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

@@ -41,7 +41,7 @@ module Spree
 
       def build_splitter
         splitter = nil
-        splitters.reverse.each do |klass|
+        splitters.reverse_each do |klass|
           splitter = klass.new(self, splitter)
         end
         splitter

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

@@ -4,16 +4,14 @@ module Spree
       class Backordered < Spree::Stock::Splitter::Base
         def split(packages)
           split_packages = []
+
           packages.each do |package|
-            unless package.on_hand.empty?
-              split_packages << build_package(package.on_hand)
-            end
+            split_packages << build_package(package.on_hand) unless package.on_hand.empty?
 
-            unless package.backordered.empty?
-              split_packages << build_package(package.backordered)
-            end
+            split_packages << build_package(package.backordered) unless package.backordered.empty?
           end
-          return_next split_packages
+
+          return_next(split_packages)
         end
       end
     end

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

@@ -8,6 +8,7 @@ module Spree
           @packer = packer
           @next_splitter = next_splitter
         end
+
         delegate :stock_location, to: :packer
 
         def split(packages)

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

@@ -3,31 +3,24 @@ module Spree
     module Splitter
       class ShippingCategory < Spree::Stock::Splitter::Base
         def split(packages)
-          split_packages = []
-          packages.each do |package|
-            split_packages += split_by_category(package)
-          end
-          return_next split_packages
+          split_packages = packages.flat_map(&method(:split_by_category))
+          return_next(split_packages)
         end
 
         private
 
         def split_by_category(package)
-          categories = Hash.new { |hash, key| hash[key] = [] }
-          package.contents.each do |item|
-            categories[shipping_category_for(item)] << item
-          end
-          hash_to_packages(categories)
+          # group package items by shipping category
+          grouped_packages = package.contents.group_by(&method(:shipping_category_for))
+          hash_to_packages(grouped_packages)
         end
 
-        def hash_to_packages(categories)
-          packages = []
-          categories.each do |_id, contents|
-            packages << build_package(contents)
-          end
-          packages
+        def hash_to_packages(grouped_packages)
+          # select values from packages grouped by shipping categories and build new packages
+          grouped_packages.values.map(&method(:build_package))
         end
 
+        # optimization: save variant -> shipping_category correspondence
         def shipping_category_for(item)
           @item_shipping_category ||= {}
           @item_shipping_category[item.inventory_unit.variant_id] ||= item.variant.shipping_category_id

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

@@ -4,17 +4,12 @@ module Spree
       class Weight < Spree::Stock::Splitter::Base
         attr_reader :packer, :next_splitter
 
-        cattr_accessor :threshold do
-          150
-        end
+        cattr_accessor(:threshold) { 150 }
 
         def split(packages)
-          generated_packages = []
-          packages.each do |package|
-            generated_packages.push *reduce(package)
-          end
-          packages.push *generated_packages
-          return_next packages
+          generated_packages = packages.flat_map(&method(:reduce))
+          packages.push(*generated_packages)
+          return_next(packages)
         end
 
         private
@@ -25,20 +20,20 @@ module Spree
           # This also prevents an additional package if no fit is possible
           package.contents.clear
           package.contents << contents.shift
-          _split_packages = [package]
-          while contents.present?
+          split_packages = [package]
 
-            package_to_use = choose_package _split_packages, contents.first
+          while contents.present?
+            package_to_use = choose_package(split_packages, contents.first)
 
             if package_to_use.nil?
               package_to_use = build_package
-              _split_packages << package_to_use
+              split_packages << package_to_use
             end
 
             package_to_use.contents << contents.shift
           end
 
-          _split_packages.drop 1 # Drop the original package to ensure only generated packages are returned
+          split_packages.drop(1)
         end
 
         def choose_package(generated_packages, content_to_add)
@@ -50,11 +45,14 @@ module Spree
 
           generated_packages.each do |generated_package|
             generated_package_weight = generated_package.weight
-            if (generated_package_weight + content_to_add.weight <= threshold) &&
-                (available_space < threshold - generated_package_weight)
-              package_to_use = generated_package
-              available_space = threshold - generated_package_weight
-            end
+
+            weight_exceed = (generated_package_weight + content_to_add.weight) > threshold
+            space_left = available_space >= (threshold - generated_package_weight)
+
+            next if weight_exceed || space_left
+
+            package_to_use = generated_package
+            available_space = threshold - generated_package_weight
           end
 
           package_to_use
@@ -63,7 +61,7 @@ module Spree
         def split_package_contents_over_threshold(package)
           package.contents.flat_map do |content|
             if content.weight > threshold && content.splittable_by_weight?
-              split_content_item_over_threshold content
+              split_content_item_over_threshold(content)
             else
               content
             end