solidus_core 2.10.0.beta1 → 2.10.0

data/app/models/spree/payment_method.rb

@@ -93,8 +93,8 @@ module Spree
           else
             active.available_to_users.available_to_admin
           end
-        available_payment_methods.select do |p|
-          store.nil? || store.payment_methods.empty? || store.payment_methods.include?(p)
+        available_payment_methods.select do |payment|
+          store.nil? || store.payment_methods.empty? || store.payment_methods.include?(payment)
         end
       end
 

data/app/models/spree/product.rb

@@ -25,7 +25,7 @@ module Spree
       variants_including_master.discard_all
       self.product_option_types = []
       self.product_properties = []
-      self.classifications = []
+      self.classifications.destroy_all
       self.product_promotion_rules = []
     end
 
@@ -190,7 +190,7 @@ module Spree
     # @return [Hash] option_type as keys, array of variants as values.
     def categorise_variants_from_option(opt_type, pricing_options = Spree::Config.default_pricing_options)
       return {} unless option_types.include?(opt_type)
-      variants.with_prices(pricing_options).group_by { |v| v.option_values.detect { |o| o.option_type == opt_type } }
+      variants.with_prices(pricing_options).group_by { |variant| variant.option_values.detect { |option| option.option_type == opt_type } }
     end
     deprecate :categorise_variants_from_option, deprecator: Spree::Deprecation
 
@@ -323,7 +323,7 @@ module Spree
 
     def any_variants_not_track_inventory?
       if variants_including_master.loaded?
-        variants_including_master.any? { |v| !v.should_track_inventory? }
+        variants_including_master.any? { |variant| !variant.should_track_inventory? }
       else
         !Spree::Config.track_inventory_levels || variants_including_master.where(track_inventory: false).exists?
       end

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

@@ -241,19 +241,20 @@ module Spree
             # Always return array with at least an empty string to avoid SQL errors
             def prepare_words(words)
               return [''] if words.blank?
-              a = words.split(/[,\s]/).map(&:strip)
-              a.any? ? a : ['']
+
+              splitted = words.split(/[,\s]/).map(&:strip)
+              splitted.any? ? splitted : ['']
             end
 
             def get_taxons(*ids_or_records_or_names)
               taxons = Spree::Taxon.table_name
-              ids_or_records_or_names.flatten.map { |t|
-                case t
-                when Integer then Spree::Taxon.find_by(id: t)
+              ids_or_records_or_names.flatten.map { |taxon|
+                case taxon
+                when Integer then Spree::Taxon.find_by(id: taxon)
                 when ActiveRecord::Base then t
                 when String
-                  Spree::Taxon.find_by(name: t) ||
-                    Spree::Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first
+                  Spree::Taxon.find_by(name: taxon) ||
+                    Spree::Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{taxon}/", "#{taxon}/").first
                 end
               }.compact.flatten.uniq
             end

data/app/models/spree/promotion.rb

@@ -126,9 +126,12 @@ module Spree
     # called anytime order.recalculate happens
     def eligible?(promotable, promotion_code: nil)
       return false if inactive?
-      return false if usage_limit_exceeded?
-      return false if promotion_code && promotion_code.usage_limit_exceeded?
       return false if blacklisted?(promotable)
+
+      excluded_orders = eligibility_excluded_orders(promotable)
+      return false if usage_limit_exceeded?(excluded_orders: excluded_orders)
+      return false if promotion_code&.usage_limit_exceeded?(excluded_orders: excluded_orders)
+
       !!eligible_rules(promotable, {})
     end
 
@@ -138,7 +141,8 @@ module Spree
     def eligible_rules(promotable, options = {})
       # Promotions without rules are eligible by default.
       return [] if rules.none?
-      eligible = lambda { |r| r.eligible?(promotable, options) }
+
+      eligible = lambda { |rule| rule.eligible?(promotable, options) }
       specific_rules = rules.for(promotable)
       return [] if specific_rules.none?
 
@@ -165,23 +169,23 @@ module Spree
 
     # Whether the promotion has exceeded it's usage restrictions.
     #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
     # @return true or false
-    def usage_limit_exceeded?
+    def usage_limit_exceeded?(excluded_orders: [])
       if usage_limit
-        usage_count >= usage_limit
+        usage_count(excluded_orders: excluded_orders) >= usage_limit
       end
     end
 
     # Number of times the code has been used overall
     #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
     # @return [Integer] usage count
-    def usage_count
-      Spree::Adjustment.eligible.
-        promotion.
-        where(source_id: actions.map(&:id)).
-        joins(:order).
-        merge(Spree::Order.complete).
-        distinct.
+    def usage_count(excluded_orders: [])
+      Spree::Adjustment.promotion.
+        eligible.
+        in_completed_orders(excluded_orders: excluded_orders).
+        where(source_id: actions).
         count(:order_id)
     end
 
@@ -255,8 +259,19 @@ module Spree
 
     def apply_automatically_disallowed_with_codes_or_paths
       return unless apply_automatically
+
       errors.add(:apply_automatically, :disallowed_with_code) if codes.any?
       errors.add(:apply_automatically, :disallowed_with_path) if path.present?
     end
+
+    def eligibility_excluded_orders(promotable)
+      if promotable.is_a?(Spree::Order)
+        [promotable]
+      elsif promotable.respond_to?(:order)
+        [promotable.order]
+      else
+        []
+      end
+    end
   end
 end

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

@@ -67,7 +67,7 @@ module Spree
           line_items = actionable_line_items(order)
 
           actioned_line_items = order.line_item_adjustments.reload.
-            select { |a| a.source == self && a.amount < 0 }.
+            select { |adjustment| adjustment.source == self && adjustment.amount < 0 }.
             map(&:adjustable)
           other_line_items = actioned_line_items - [line_item]
 

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

@@ -21,7 +21,7 @@ module Spree
           end
           # Did we actually end up applying any adjustments?
           # If so, then this action should be classed as 'successful'
-          results.any? { |r| r == true }
+          results.any? { |result| result == true }
         end
 
         def label

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

@@ -29,8 +29,8 @@ module Spree
         def preferred_eligible_values
           values = preferences[:eligible_values] || {}
           Hash[values.keys.map(&:to_i).zip(
-            values.values.map do |v|
-              (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
+            values.values.map do |value|
+              (value.is_a?(Array) ? value : value.split(",")).map(&:to_i)
             end
           )]
         end

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

@@ -32,15 +32,15 @@ module Spree
 
           case preferred_match_policy
           when 'all'
-            unless eligible_products.all? { |p| order.products.include?(p) }
+            unless eligible_products.all? { |product| order.products.include?(product) }
               eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
             end
           when 'any'
-            unless order.products.any? { |p| eligible_products.include?(p) }
+            unless order.products.any? { |product| eligible_products.include?(product) }
               eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products), error_code: :no_applicable_products)
             end
           when 'none'
-            unless order.products.none? { |p| eligible_products.include?(p) }
+            unless order.products.none? { |product| eligible_products.include?(product) }
               eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product), error_code: :has_excluded_product)
             end
           else

data/app/models/spree/promotion_action.rb

@@ -16,7 +16,7 @@ module Spree
 
     belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions, optional: true
 
-    scope :of_type, ->(t) { where(type: Array.wrap(t).map(&:to_s)) }
+    scope :of_type, ->(type) { where(type: Array.wrap(type).map(&:to_s)) }
     scope :shipping, -> { of_type(Spree::Config.environment.promotions.shipping_actions.to_a) }
 
     # Updates the state of the order or performs some other action depending on

data/app/models/spree/promotion_chooser.rb

@@ -26,8 +26,8 @@ module Spree
 
     # @return The best promotion from this set of adjustments.
     def best_promotion_adjustment
-      @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |a|
-        [a.amount, -a.id]
+      @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |adjustment|
+        [adjustment.amount, -adjustment.id]
       end
     end
   end

data/app/models/spree/promotion_code.rb

@@ -14,22 +14,23 @@ class Spree::PromotionCode < Spree::Base
 
   # Whether the promotion code has exceeded its usage restrictions
   #
+  # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
   # @return true or false
-  def usage_limit_exceeded?
+  def usage_limit_exceeded?(excluded_orders: [])
     if usage_limit
-      usage_count >= usage_limit
+      usage_count(excluded_orders: excluded_orders) >= usage_limit
     end
   end
 
   # Number of times the code has been used overall
   #
+  # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
   # @return [Integer] usage count
-  def usage_count
-    adjustments.eligible.
-      joins(:order).
-      merge(Spree::Order.complete).
-      distinct.
-      count(:order_id)
+  def usage_count(excluded_orders: [])
+    adjustments.
+    eligible.
+    in_completed_orders(excluded_orders: excluded_orders).
+    count(:order_id)
   end
 
   def usage_limit

data/app/models/spree/promotion_code/batch_builder.rb

@@ -33,12 +33,12 @@ class ::Spree::PromotionCode::BatchBuilder
   def build_promotion_codes
     generate_random_codes
     promotion_code_batch.update!(state: "completed")
-  rescue StandardError => e
+  rescue StandardError => error
     promotion_code_batch.update!(
-      error: e.inspect,
+      error: error.inspect,
       state: "failed"
     )
-    raise e
+    raise error
   end
 
   private

data/app/models/spree/promotion_rule.rb

@@ -5,7 +5,7 @@ module Spree
   class PromotionRule < Spree::Base
     belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules, optional: true
 
-    scope :of_type, ->(t) { where(type: t) }
+    scope :of_type, ->(type) { where(type: type) }
 
     validates :promotion, presence: true
     validate :unique_per_promotion, on: :create

data/app/models/spree/refund.rb

@@ -68,8 +68,8 @@ module Spree
       end
 
       response
-    rescue ActiveMerchant::ConnectionError => e
-      logger.error(I18n.t('spree.gateway_error') + "  #{e.inspect}")
+    rescue ActiveMerchant::ConnectionError => error
+      logger.error(I18n.t('spree.gateway_error') + "  #{error.inspect}")
       raise Core::GatewayError.new(I18n.t('spree.unable_to_connect_to_gateway'))
     end
 

data/app/models/spree/reimbursement.rb

@@ -59,15 +59,7 @@ module Spree
     class_attribute :reimbursement_failure_hooks
     self.reimbursement_failure_hooks = []
 
-    state_machine :reimbursement_status, initial: :pending do
-      event :errored do
-        transition to: :errored, from: [:pending, :errored]
-      end
-
-      event :reimbursed do
-        transition to: :reimbursed, from: [:pending, :errored]
-      end
-    end
+    include ::Spree::Config.state_machines.reimbursement
 
     class << self
       def build_from_customer_return(customer_return)
@@ -112,11 +104,11 @@ module Spree
       if unpaid_amount_within_tolerance?
         reimbursed!
         Spree::Event.fire 'reimbursement_reimbursed', reimbursement: self
-        reimbursement_success_hooks.each { |h| h.call self }
+        reimbursement_success_hooks.each { |hook| hook.call self }
       else
         errored!
         Spree::Event.fire 'reimbursement_errored', reimbursement: self
-        reimbursement_failure_hooks.each { |h| h.call self }
+        reimbursement_failure_hooks.each { |hook| hook.call self }
       end
 
       if errored?

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

@@ -18,7 +18,7 @@ module Spree
 
     def initialize(return_items)
       @return_items = return_items
-      @reimbursement_type_hash = Hash.new { |h, k| h[k] = [] }
+      @reimbursement_type_hash = Hash.new { |hash, key| hash[key] = [] }
     end
 
     def calculate_reimbursement_types

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

@@ -63,8 +63,8 @@ module Spree
 
     def sorted_eligible_refund_payments(payments)
       if eligible_refund_methods = self.eligible_refund_methods
-        payments = payments.select { |p| eligible_refund_methods.include? p.payment_method.class }
-        payments = payments.sort_by { |p| eligible_refund_methods.index(p.payment_method.class) }
+        payments = payments.select { |payment| eligible_refund_methods.include? payment.payment_method.class }
+        payments = payments.sort_by { |payment| eligible_refund_methods.index(payment.payment_method.class) }
       end
       payments
     end

data/app/models/spree/return_authorization.rb

@@ -22,13 +22,7 @@ module Spree
     validate :must_have_shipped_units, on: :create
     validate :no_previously_exchanged_inventory_units, on: :create
 
-    state_machine initial: :authorized do
-      before_transition to: :canceled, do: :cancel_return_items
-
-      event :cancel do
-        transition to: :canceled, from: :authorized, if: lambda { |return_authorization| return_authorization.can_cancel_return_items? }
-      end
-    end
+    include ::Spree::Config.state_machines.return_authorization
 
     extend DisplayMoney
     money_methods :pre_tax_total, :amount, :total_excluding_vat

data/app/models/spree/return_item.rb

@@ -77,22 +77,8 @@ module Spree
     before_create :set_default_amount, unless: :amount_changed?
     before_save :set_exchange_amount
 
-    state_machine :reception_status, initial: :awaiting do
-      after_transition to: COMPLETED_RECEPTION_STATUSES,  do: :attempt_accept
-      after_transition to: COMPLETED_RECEPTION_STATUSES,  do: :check_unexchange
-      after_transition to: :received, do: :process_inventory_unit!
-
-      event(:cancel) { transition to: :cancelled, from: :awaiting }
-
-      event(:receive) { transition to: :received, from: INTERMEDIATE_RECEPTION_STATUSES + [:awaiting] }
-      event(:unexchange) { transition to: :unexchanged, from: [:awaiting] }
-      event(:give) { transition to: :given_to_customer, from: :awaiting }
-      event(:lost) { transition to: :lost_in_transit, from: :awaiting }
-      event(:wrong_item_shipped) { transition to: :shipped_wrong_item, from: :awaiting }
-      event(:short_shipped) { transition to: :short_shipped, from: :awaiting }
-      event(:in_transit) { transition to: :in_transit, from: :awaiting }
-      event(:expired) { transition to: :expired, from: :awaiting }
-    end
+    include ::Spree::Config.state_machines.return_item_reception
+    include ::Spree::Config.state_machines.return_item_acceptance
 
     extend DisplayMoney
     money_methods :pre_tax_amount, :amount, :total, :total_excluding_vat
@@ -104,31 +90,6 @@ module Spree
       COMPLETED_RECEPTION_STATUSES.map(&:to_s).include?(reception_status.to_s)
     end
 
-    state_machine :acceptance_status, initial: :pending do
-      event :attempt_accept do
-        transition to: :accepted, from: :accepted
-        transition to: :accepted, from: :pending, if: ->(return_item) { return_item.eligible_for_return? }
-        transition to: :manual_intervention_required, from: :pending, if: ->(return_item) { return_item.requires_manual_intervention? }
-        transition to: :rejected, from: :pending
-      end
-
-      # bypasses eligibility checks
-      event :accept do
-        transition to: :accepted, from: [:accepted, :pending, :manual_intervention_required]
-      end
-
-      # bypasses eligibility checks
-      event :reject do
-        transition to: :rejected, from: [:accepted, :pending, :manual_intervention_required]
-      end
-
-      # bypasses eligibility checks
-      event :require_manual_intervention do
-        transition to: :manual_intervention_required, from: [:accepted, :pending, :manual_intervention_required]
-      end
-
-      after_transition any => any, do: :persist_acceptance_status_errors
-    end
 
     attr_accessor :skip_customer_return_processing
 
@@ -214,7 +175,7 @@ module Spree
       event_paths.delete(:expired)
       event_paths.delete(:unexchange)
 
-      status_paths.map{ |s| I18n.t("spree.reception_states.#{s}", default: s.to_s.humanize) }.zip(event_paths)
+      status_paths.map{ |status| I18n.t("spree.reception_states.#{status}", default: status.to_s.humanize) }.zip(event_paths)
     end
 
     def part_of_exchange?

data/app/models/spree/return_item/eligibility_validator/default.rb

@@ -28,7 +28,7 @@ module Spree
         private
 
         def validators
-          @validators ||= permitted_eligibility_validators.map{ |v| v.new(@return_item) }
+          @validators ||= permitted_eligibility_validators.map{ |validator| validator.new(@return_item) }
         end
       end
     end

data/app/models/spree/shipment.rb

@@ -31,7 +31,7 @@ module Spree
     scope :ready,   -> { with_state('ready') }
     scope :shipped, -> { with_state('shipped') }
     scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
-    scope :with_state, ->(*s) { where(state: s) }
+    scope :with_state, ->(*state) { where(state: state) }
     # 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(Arel.sql("coalesce(#{Spree::Shipment.table_name}.shipped_at, #{Spree::Shipment.table_name}.created_at) desc"), id: :desc)
@@ -39,41 +39,7 @@ module Spree
 
     scope :by_store, ->(store) { joins(:order).merge(Spree::Order.by_store(store)) }
 
-    # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-    state_machine initial: :pending, use_transactions: false do
-      event :ready do
-        transition from: :pending, to: :shipped, if: :can_transition_from_pending_to_shipped?
-        transition from: :pending, to: :ready, if: :can_transition_from_pending_to_ready?
-      end
-
-      event :pend do
-        transition from: :ready, to: :pending
-      end
-
-      event :ship do
-        transition from: [:ready, :canceled], to: :shipped
-      end
-      after_transition to: :shipped, do: :after_ship
-
-      event :cancel do
-        transition to: :canceled, from: [:pending, :ready]
-      end
-      after_transition to: :canceled, do: :after_cancel
-
-      event :resume do
-        transition from: :canceled, to: :ready, if: :can_transition_from_canceled_to_ready?
-        transition from: :canceled, to: :pending
-      end
-      after_transition from: :canceled, to: [:pending, :ready, :shipped], do: :after_resume
-
-      after_transition do |shipment, transition|
-        shipment.state_changes.create!(
-          previous_state: transition.from,
-          next_state:     transition.to,
-          name:           'shipment'
-        )
-      end
-    end
+    include ::Spree::Config.state_machines.shipment
 
     self.whitelisted_ransackable_associations = ['order']
     self.whitelisted_ransackable_attributes = ['number']
@@ -142,7 +108,7 @@ module Spree
     # @return [BigDecimal] the amount of this item, taking into consideration
     #   all non-tax adjustments.
     def total_before_tax
-      amount + adjustments.select { |a| !a.tax? && a.eligible? }.sum(&:amount)
+      amount + adjustments.select { |adjustment| !adjustment.tax? && adjustment.eligible? }.sum(&:amount)
     end
 
     # @return [BigDecimal] the amount of this shipment before VAT tax
@@ -219,7 +185,7 @@ module Spree
     def select_shipping_method(shipping_method)
       estimator = Spree::Config.stock.estimator_class.new
       rates = estimator.shipping_rates(to_package, false)
-      rate = rates.detect { |r| r.shipping_method_id == shipping_method.id }
+      rate = rates.detect { |detected| detected.shipping_method_id == shipping_method.id }
       rate.selected = true
       self.shipping_rates = [rate]
     end