spree_core 3.3.6 → 3.4.0.rc1

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

@@ -6,7 +6,7 @@ module Spree
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           if order.user.present?
             if promotion.used_by?(order.user, [order])
               eligibility_errors.add(:base, eligibility_error_message(:limit_once_per_user))
@@ -21,4 +21,3 @@ module Spree
     end
   end
 end
-

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

@@ -6,7 +6,7 @@ module Spree
           values = super || {}
           Hash[values.keys.map(&:to_i).zip(
             values.values.map do |v|
-              (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
+              (v.is_a?(Array) ? v : v.split(',')).map(&:to_i)
             end
           )]
         end
@@ -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

@@ -21,19 +21,19 @@ module Spree
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           return true if eligible_products.empty?
 
           if preferred_match_policy == 'all'
-            unless eligible_products.all? {|p| order.products.include?(p) }
+            unless eligible_products.all? { |p| order.products.include?(p) }
               eligibility_errors.add(:base, eligibility_error_message(:missing_product))
             end
           elsif preferred_match_policy == 'any'
-            unless order.products.any? {|p| eligible_products.include?(p) }
+            unless order.products.any? { |p| eligible_products.include?(p) }
               eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products))
             end
           else
-            unless order.products.none? {|p| eligible_products.include?(p) }
+            unless order.products.none? { |p| eligible_products.include?(p) }
               eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product))
             end
           end

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

@@ -12,14 +12,14 @@ module Spree
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           if preferred_match_policy == 'all'
             unless (taxons.to_a - taxons_in_order_including_parents(order)).empty?
               eligibility_errors.add(:base, eligibility_error_message(:missing_taxon))
             end
           else
             order_taxons = taxons_in_order_including_parents(order)
-            unless taxons.any?{ |taxon| order_taxons.include? taxon }
+            unless taxons.any? { |taxon| order_taxons.include? taxon }
               eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons))
             end
           end
@@ -44,12 +44,12 @@ module Spree
 
         # All taxons in an order
         def order_taxons(order)
-          Spree::Taxon.joins(products: {variants_including_master: :line_items}).where(spree_line_items: {order_id: order.id}).distinct
+          Spree::Taxon.joins(products: { variants_including_master: :line_items }).where(spree_line_items: { order_id: order.id }).distinct
         end
 
         # ids of taxons rules and taxons rules children
         def taxons_including_children_ids
-          taxons.inject([]){ |ids,taxon| ids += taxon.self_and_descendants.ids }
+          taxons.inject([]) { |ids, taxon| ids += taxon.self_and_descendants.ids }
         end
 
         # taxons order vs taxons rules and taxons rules children
@@ -58,11 +58,11 @@ module Spree
         end
 
         def taxons_in_order_including_parents(order)
-          order_taxons_in_taxons_and_children(order).inject([]){ |taxons, taxon| taxons << taxon.self_and_ancestors }.flatten.uniq
+          order_taxons_in_taxons_and_children(order).inject([]) { |taxons, taxon| taxons << taxon.self_and_ancestors }.flatten.uniq
         end
 
         def taxon_product_ids
-          Spree::Product.joins(:taxons).where(spree_taxons: {id: taxons.pluck(:id)}).pluck(:id).uniq
+          Spree::Product.joins(:taxons).where(spree_taxons: { id: taxons.pluck(:id) }).pluck(:id).uniq
         end
       end
     end

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

@@ -2,18 +2,18 @@ module Spree
   class Promotion
     module Rules
       class User < PromotionRule
-        belongs_to :user, class_name: "::#{Spree.user_class.to_s}"
+        belongs_to :user, class_name: "::#{Spree.user_class}"
 
         has_many :promotion_rule_users, class_name: 'Spree::PromotionRuleUser',
                                         foreign_key: :promotion_rule_id,
                                         dependent: :destroy
-        has_many :users, through: :promotion_rule_users, class_name: "::#{Spree.user_class.to_s}"
+        has_many :users, through: :promotion_rule_users, class_name: "::#{Spree.user_class}"
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           users.include?(order.user)
         end
 

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

@@ -6,7 +6,7 @@ module Spree
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           unless order.user.present?
             eligibility_errors.add(:base, eligibility_error_message(:no_user_specified))
           end

data/app/models/spree/promotion.rb

@@ -1,17 +1,17 @@
 module Spree
   class Promotion < Spree::Base
     MATCH_POLICIES = %w(all any)
-    UNACTIVATABLE_ORDER_STATES = ["complete", "awaiting_return", "returned"]
+    UNACTIVATABLE_ORDER_STATES = ['complete', 'awaiting_return', 'returned']
 
     attr_reader :eligibility_errors
 
     belongs_to :promotion_category, optional: true
 
     has_many :promotion_rules, autosave: true, dependent: :destroy
-    alias_method :rules, :promotion_rules
+    alias rules promotion_rules
 
     has_many :promotion_actions, autosave: true, dependent: :destroy
-    alias_method :actions, :promotion_actions
+    alias actions promotion_actions
 
     has_many :order_promotions, class_name: 'Spree::OrderPromotion'
     has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
@@ -40,9 +40,9 @@ module Spree
     self.whitelisted_ransackable_attributes = ['path', 'promotion_category_id', 'code']
 
     def self.with_coupon_code(coupon_code)
-      where("lower(#{table_name}.code) = ?", coupon_code.strip.downcase)
-        .includes(:promotion_actions).where.not(spree_promotion_actions: { id: nil })
-        .first
+      where("lower(#{table_name}.code) = ?", coupon_code.strip.downcase).
+        includes(:promotion_actions).where.not(spree_promotion_actions: { id: nil }).
+        first
     end
 
     def self.active
@@ -74,10 +74,10 @@ module Spree
       action_taken = results.include?(true)
 
       if action_taken
-      # connect to the order
-      # create the join_table entry.
-        self.orders << order
-        self.save
+        # connect to the order
+        # create the join_table entry.
+        orders << order
+        save
       end
 
       action_taken
@@ -122,7 +122,7 @@ 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 = ->(r) { r.eligible?(promotable, options) }
       specific_rules = rules.select { |rule| rule.applicable?(promotable) }
       return [] if specific_rules.none?
 
@@ -149,7 +149,7 @@ module Spree
     end
 
     def products
-      rules.where(type: "Spree::Promotion::Rules::Product").map(&:products).flatten.uniq
+      rules.where(type: 'Spree::Promotion::Rules::Product').map(&:products).flatten.uniq
     end
 
     def usage_limit_exceeded?(promotable)
@@ -203,13 +203,14 @@ module Spree
     end
 
     private
+
     def blacklisted?(promotable)
       case promotable
       when Spree::LineItem
         !promotable.product.promotionable?
       when Spree::Order
         promotable.line_items.any? &&
-          !promotable.line_items.joins(:product).where(spree_products: {promotionable: true}).any?
+          promotable.line_items.joins(:product).where(spree_products: { promotionable: true }).none?
       end
     end
 
@@ -224,9 +225,7 @@ module Spree
     end
 
     def expires_at_must_be_later_than_starts_at
-      if expires_at < starts_at
-        errors.add(:expires_at, :invalid_date_range)
-      end
+      errors.add(:expires_at, :invalid_date_range) if expires_at < starts_at
     end
   end
 end

data/app/models/spree/promotion_action.rb

@@ -12,7 +12,7 @@ module Spree
     # Updates the state of the order or performs some other action depending on the subclass
     # options will contain the payload from the event that activated the promotion. This will include
     # the key :user which allows user based actions to be performed in addition to actions on the order
-    def perform(options = {})
+    def perform(_options = {})
       raise 'perform should be implemented in a sub-class of PromotionAction'
     end
 

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

@@ -16,8 +16,9 @@ module Spree
       attr_reader :line_item, :order
       attr_accessor :error, :success
 
-      def initialize(order, line_item=nil)
-        @order, @line_item = order, line_item
+      def initialize(order, line_item = nil)
+        @order = order
+        @line_item = line_item
       end
 
       def activate

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

@@ -14,9 +14,7 @@ module Spree
         promotions.each do |promotion|
           next if promotion.code.present? && !order_promo_ids.include?(promotion.id)
 
-          if promotion.eligible?(order)
-            promotion.activate(order: order)
-          end
+          promotion.activate(order: order) if promotion.eligible?(order)
         end
       end
 

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

@@ -16,9 +16,9 @@ module Spree
 
       private
 
-        def promotion
-          @promotion ||= Promotion.active.find_by(path: path)
-        end
+      def promotion
+        @promotion ||= Promotion.active.find_by(path: path)
+      end
     end
   end
 end

data/app/models/spree/promotion_rule.rb

@@ -11,17 +11,17 @@ module Spree
       all.select { |rule| rule.applicable?(promotable) }
     end
 
-    def applicable?(promotable)
+    def applicable?(_promotable)
       raise 'applicable? should be implemented in a sub-class of Spree::PromotionRule'
     end
 
-    def eligible?(promotable, options = {})
+    def eligible?(_promotable, _options = {})
       raise 'eligible? should be implemented in a sub-class of Spree::PromotionRule'
     end
 
     # This states if a promotion can be applied to the specified line item
     # It is true by default, but can be overridden by promotion rules to provide conditions
-    def actionable?(line_item)
+    def actionable?(_line_item)
       true
     end
 
@@ -30,9 +30,10 @@ module Spree
     end
 
     private
+
     def unique_per_promotion
       if Spree::PromotionRule.exists?(promotion_id: promotion_id, type: self.class.name)
-        errors[:base] << "Promotion already contains this rule type"
+        errors[:base] << 'Promotion already contains this rule type'
       end
     end
 

data/app/models/spree/refund.rb

@@ -22,7 +22,7 @@ module Spree
     scope :non_reimbursement, -> { where(reimbursement_id: nil) }
 
     def money
-      Spree::Money.new(amount, { currency: payment.currency })
+      Spree::Money.new(amount, currency: payment.currency)
     end
     alias display_amount money
 
@@ -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)
 
@@ -55,21 +55,21 @@ module Spree
     # return an activemerchant response object if successful or else raise an error
     def process!(credit_cents)
       response = if payment.payment_method.payment_profiles_supported?
-        payment.payment_method.credit(credit_cents, payment.source, payment.transaction_id, {originator: self})
-      else
-        payment.payment_method.credit(credit_cents, payment.transaction_id, {originator: self})
+                   payment.payment_method.credit(credit_cents, payment.source, payment.transaction_id, originator: self)
+                 else
+                   payment.payment_method.credit(credit_cents, payment.transaction_id, originator: self)
       end
 
-      if !response.success?
+      unless response.success?
         logger.error(Spree.t(:gateway_error) + "  #{response.to_yaml}")
         text = response.params['message'] || response.params['response_reason_text'] || response.message
-        raise Core::GatewayError.new(text)
+        raise Core::GatewayError, text
       end
 
       response
     rescue ActiveMerchant::ConnectionError => e
       logger.error(Spree.t(:gateway_error) + "  #{e.inspect}")
-      raise Core::GatewayError.new(Spree.t(:unable_to_connect_to_gateway))
+      raise Core::GatewayError, Spree.t(:unable_to_connect_to_gateway)
     end
 
     def create_log_entry

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

@@ -19,7 +19,7 @@ module Spree
     end
 
     def display_amount
-      Spree::Money.new(amount, { currency: creditable.try(:currency) || "USD" })
+      Spree::Money.new(amount, currency: creditable.try(:currency) || 'USD')
     end
   end
 end

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

@@ -16,7 +16,7 @@ module Spree
 
     def initialize(return_items)
       @return_items = return_items
-      @reimbursement_type_hash = Hash.new {|h,k| h[k] = Array.new }
+      @reimbursement_type_hash = Hash.new { |h, k| h[k] = [] }
     end
 
     def calculate_reimbursement_types
@@ -38,8 +38,6 @@ module Spree
       elsif return_item.preferred_reimbursement_type.present?
         if valid_preferred_reimbursement_type?(return_item)
           return_item.preferred_reimbursement_type.class
-        else
-          nil
         end
       elsif past_reimbursable_time_period?(return_item)
         expired_reimbursement_type

data/app/models/spree/reimbursement.rb

@@ -61,7 +61,6 @@ module Spree
     self.reimbursement_failure_hooks = []
 
     state_machine :reimbursement_status, initial: :pending do
-
       event :errored do
         transition to: :errored, from: :pending
       end
@@ -69,21 +68,18 @@ module Spree
       event :reimbursed do
         transition to: :reimbursed, from: [:pending, :errored]
       end
-
     end
 
     class << self
       def build_from_customer_return(customer_return)
         order = customer_return.order
-        order.reimbursements.build({
-          customer_return: customer_return,
-          return_items: customer_return.return_items.accepted.not_reimbursed,
-        })
+        order.reimbursements.build(customer_return: customer_return,
+                                   return_items: customer_return.return_items.accepted.not_reimbursed)
       end
     end
 
     def display_total
-      Spree::Money.new(total, { currency: order.currency })
+      Spree::Money.new(total, currency: order.currency)
     end
 
     def calculated_total
@@ -116,7 +112,7 @@ module Spree
       else
         errored!
         reimbursement_failure_hooks.each { |h| h.call self }
-        raise IncompleteReimbursementError, Spree.t("validation.unpaid_amount_not_zero", amount: unpaid_amount)
+        raise IncompleteReimbursementError, Spree.t('validation.unpaid_amount_not_zero', amount: unpaid_amount)
       end
     end
 

data/app/models/spree/reimbursement_performer.rb

@@ -1,7 +1,5 @@
 module Spree
-
   class ReimbursementPerformer
-
     class << self
       class_attribute :reimbursement_type_engine
       self.reimbursement_type_engine = Spree::Reimbursement::ReimbursementTypeEngine
@@ -35,9 +33,6 @@ module Spree
         # {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_tax_calculator.rb

@@ -1,5 +1,4 @@
 module Spree
-
   # Tax calculation is broken out at this level to allow easy integration with 3rd party
   # taxation systems.  Those systems are usually geared toward calculating all items at once
   # rather than one at a time.
@@ -9,9 +8,7 @@ module Spree
   # where `calculator_object` is an object that responds to "call" and accepts a reimbursement object
 
   class ReimbursementTaxCalculator
-
     class << self
-
       def call(reimbursement)
         reimbursement.return_items.includes(:inventory_unit).each do |return_item|
           set_tax!(return_item)
@@ -24,21 +21,17 @@ module Spree
         calculated_refund = Spree::ReturnItem.refund_amount_calculator.new.compute(return_item)
 
         percent_of_tax = if return_item.pre_tax_amount <= 0 || calculated_refund <= 0
-          0
-        else
-          return_item.pre_tax_amount / calculated_refund
+                           0
+                         else
+                           return_item.pre_tax_amount / calculated_refund
         end
 
         additional_tax_total = percent_of_tax * return_item.inventory_unit.additional_tax_total
         included_tax_total   = percent_of_tax * return_item.inventory_unit.included_tax_total
 
-        return_item.update_attributes!({
-          additional_tax_total: additional_tax_total,
-          included_tax_total:   included_tax_total,
-        })
+        return_item.update_attributes!(additional_tax_total: additional_tax_total,
+                                       included_tax_total:   included_tax_total)
       end
     end
-
   end
-
 end

data/app/models/spree/reimbursement_type.rb

@@ -13,8 +13,8 @@ module Spree
     # This method will reimburse the return items based on however its child implements it
     # By default it takes a reimbursement, the return items it needs to reimburse, and if
     # it is a simulation or a real reimbursement. This should return an array
-    def self.reimburse(reimbursement, return_items, simulate)
-      raise "Implement me"
+    def self.reimburse(_reimbursement, _return_items, _simulate)
+      raise 'Implement me'
     end
   end
 end

data/app/models/spree/return_authorization.rb

@@ -21,7 +21,6 @@ module Spree
     validates :order, :reason, :stock_location, presence: true
     validate :must_have_shipped_units, on: :create
 
-
     # These are called prior to generating expedited exchanges shipments.
     # Should respond to a "call" method that takes the list of return items
     class_attribute :pre_expedited_exchange_hooks
@@ -31,9 +30,8 @@ module Spree
       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? }
+        transition to: :canceled, from: :authorized, if: ->(return_authorization) { return_authorization.can_cancel_return_items? }
       end
-
     end
 
     extend DisplayMoney
@@ -63,37 +61,35 @@ module Spree
 
     private
 
-      def must_have_shipped_units
-        if order.nil? || order.inventory_units.shipped.none?
-          errors.add(:order, Spree.t(:has_no_shipped_units))
-        end
-      end
-
-
-      def cancel_return_items
-        return_items.each { |item| item.cancel! if item.can_cancel? }
+    def must_have_shipped_units
+      if order.nil? || order.inventory_units.shipped.none?
+        errors.add(:order, Spree.t(:has_no_shipped_units))
       end
+    end
 
-      def generate_expedited_exchange_reimbursements
-        return unless Spree::Config[:expedited_exchanges]
+    def cancel_return_items
+      return_items.each { |item| item.cancel! if item.can_cancel? }
+    end
 
-        items_to_exchange = return_items.select(&:exchange_required?)
-        items_to_exchange.each(&:attempt_accept)
-        items_to_exchange.select!(&:accepted?)
+    def generate_expedited_exchange_reimbursements
+      return unless Spree::Config[:expedited_exchanges]
 
-        return if items_to_exchange.blank?
+      items_to_exchange = return_items.select(&:exchange_required?)
+      items_to_exchange.each(&:attempt_accept)
+      items_to_exchange.select!(&:accepted?)
 
-        pre_expedited_exchange_hooks.each { |h| h.call items_to_exchange }
+      return if items_to_exchange.blank?
 
-        reimbursement = Reimbursement.new(return_items: items_to_exchange, order: order)
+      pre_expedited_exchange_hooks.each { |h| h.call items_to_exchange }
 
-        if reimbursement.save
-          reimbursement.perform!
-        else
-          errors.add(:base, reimbursement.errors.full_messages)
-          raise ActiveRecord::RecordInvalid.new(self)
-        end
+      reimbursement = Reimbursement.new(return_items: items_to_exchange, order: order)
 
+      if reimbursement.save
+        reimbursement.perform!
+      else
+        errors.add(:base, reimbursement.errors.full_messages)
+        raise ActiveRecord::RecordInvalid, self
       end
+    end
   end
 end

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

@@ -10,11 +10,11 @@ module Spree
                                             ]
 
     def eligible_for_return?
-      validators.all? {|v| v.eligible_for_return? }
+      validators.all?(&:eligible_for_return?)
     end
 
     def requires_manual_intervention?
-      validators.any? {|v| v.requires_manual_intervention? }
+      validators.any?(&:requires_manual_intervention?)
     end
 
     def errors
@@ -24,7 +24,7 @@ module Spree
     private
 
     def validators
-      @validators ||= permitted_eligibility_validators.map{|v| v.new(@return_item) }
+      @validators ||= permitted_eligibility_validators.map { |v| v.new(@return_item) }
     end
   end
 end

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

@@ -2,10 +2,10 @@ module Spree
   class ReturnItem::EligibilityValidator::InventoryShipped < Spree::ReturnItem::EligibilityValidator::BaseValidator
     def eligible_for_return?
       if @return_item.inventory_unit.shipped?
-        return true
+        true
       else
         add_error(:inventory_unit_shipped, Spree.t('return_item_inventory_unit_ineligible'))
-        return false
+        false
       end
     end
 

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

@@ -3,9 +3,9 @@ module Spree
     def eligible_for_return?
       if Spree::ReturnItem.where(inventory_unit: @return_item.inventory_unit).where.not(reimbursement_id: nil).any?
         add_error(:inventory_unit_reimbursed, Spree.t('return_item_inventory_unit_reimbursed'))
-        return false
+        false
       else
-        return true
+        true
       end
     end
 

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

@@ -2,10 +2,10 @@ module Spree
   class ReturnItem::EligibilityValidator::OrderCompleted < Spree::ReturnItem::EligibilityValidator::BaseValidator
     def eligible_for_return?
       if @return_item.inventory_unit.order.completed?
-        return true
+        true
       else
         add_error(:order_not_completed, Spree.t('return_item_order_not_completed'))
-        return false
+        false
       end
     end