solidus_core 1.2.3 → 1.3.0.beta1

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

@@ -16,7 +16,7 @@ module Spree
       attr_reader :line_item, :order
       attr_accessor :error, :success
 
-      def initialize(order, line_item=nil)
+      def initialize(order, line_item = nil)
         @order, @line_item = order, line_item
       end
 
@@ -29,24 +29,25 @@ module Spree
       end
 
       private
-        def promotions
-          connected_order_promotions | sale_promotions
-        end
 
-        def connected_order_promotions
-          Promotion.active.includes(:promotion_rules).
-            joins(:order_promotions).
-            where(spree_orders_promotions: { order_id: order.id }).readonly(false).to_a
-        end
+      def promotions
+        connected_order_promotions | sale_promotions
+      end
 
-        def sale_promotions
-          Promotion.where(apply_automatically: true).active.includes(:promotion_rules)
-        end
+      def connected_order_promotions
+        Promotion.active.includes(:promotion_rules).
+          joins(:order_promotions).
+          where(spree_orders_promotions: { order_id: order.id }).readonly(false).to_a
+      end
 
-        def promotion_code(promotion)
-          order_promotion = Spree::OrderPromotion.where(order: order, promotion: promotion).first
-          order_promotion.present? ? order_promotion.promotion_code : nil
-        end
+      def sale_promotions
+        Promotion.where(apply_automatically: true).active.includes(:promotion_rules)
+      end
+
+      def promotion_code(promotion)
+        order_promotion = Spree::OrderPromotion.where(order: order, promotion: promotion).first
+        order_promotion.present? ? order_promotion.promotion_code : nil
+      end
     end
   end
 end

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

@@ -12,12 +12,10 @@ module Spree
         if order.coupon_code.present?
           if promotion.present? && promotion.actions.exists?
             handle_present_promotion(promotion)
+          elsif promotion_code && promotion_code.promotion.expired?
+            set_error_code :coupon_code_expired
           else
-            if promotion_code && promotion_code.promotion.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
 
@@ -57,7 +55,7 @@ module Spree
         return promotion_applied if promotion_exists_on_order?(order, promotion)
         unless promotion.eligible?(order, promotion_code: promotion_code)
           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`,
@@ -88,7 +86,7 @@ module Spree
 
       def determine_promotion_application_result
         detector = lambda { |p|
-          p.source.promotion.codes.any? { |code| code.value == order.coupon_code.downcase }
+          p.source.promotion.codes.where(value: order.coupon_code.downcase).any?
         }
 
         # Check for applied adjustments.
@@ -103,15 +101,13 @@ module Spree
           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,15 +10,15 @@ 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)
-        end
+      def promotion
+        @promotion ||= Promotion.active.find_by(path: path)
+      end
     end
   end
 end

data/app/models/spree/promotion_rule.rb

@@ -12,17 +12,17 @@ module Spree
       all.select { |rule| rule.applicable?(promotable) }
     end
 
-    def applicable?(promotable)
+    def applicable?(_promotable)
       raise NotImplementedError, "applicable? should be implemented in a sub-class of Spree::PromotionRule"
     end
 
-    def eligible?(promotable, options = {})
+    def eligible?(_promotable, _options = {})
       raise NotImplementedError, "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
 
@@ -31,6 +31,7 @@ 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"

data/app/models/spree/prototype.rb

@@ -1,6 +1,5 @@
 module Spree
   class Prototype < Spree::Base
-
     has_many :property_prototypes
     has_many :properties, through: :property_prototypes
 

data/app/models/spree/refund.rb

@@ -9,7 +9,7 @@ module Spree
     validates :payment, presence: true
     validates :reason, presence: true
     validates :transaction_id, presence: true, on: :update # can't require this on create because the before_create needs to run first
-    validates :amount, presence: true, numericality: {greater_than: 0}
+    validates :amount, presence: true, numericality: { greater_than: 0 }
 
     validate :amount_is_less_than_or_equal_to_allowed_amount, on: :create
 
@@ -52,9 +52,9 @@ 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})
+        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.transaction_id, { originator: self })
       end
 
       if !response.success?

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

@@ -57,7 +57,6 @@ module Spree
     self.reimbursement_failure_hooks = []
 
     state_machine :reimbursement_status, initial: :pending do
-
       event :errored do
         transition to: :errored, from: [:pending, :errored]
       end
@@ -65,7 +64,6 @@ module Spree
       event :reimbursed do
         transition to: :reimbursed, from: [:pending, :errored]
       end
-
     end
 
     class << self
@@ -73,7 +71,7 @@ module Spree
         order = customer_return.order
         order.reimbursements.build({
           customer_return: customer_return,
-          return_items: customer_return.return_items.accepted.not_reimbursed,
+          return_items: customer_return.return_items.accepted.not_reimbursed
         })
       end
     end
@@ -150,7 +148,7 @@ module Spree
 
     def generate_number
       self.number ||= loop do
-        random = "RI#{Array.new(9){rand(9)}.join}"
+        random = "RI#{Array.new(9){ rand(9) }.join}"
         break random unless self.class.exists?(number: random)
       end
     end
@@ -162,7 +160,7 @@ module Spree
     end
 
     def send_reimbursement_email
-      Spree::ReimbursementMailer.reimbursement_email(self.id).deliver_later
+      Spree::ReimbursementMailer.reimbursement_email(id).deliver_later
     end
 
     # If there are multiple different reimbursement types for a single

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)
@@ -21,18 +18,16 @@ module Spree
       private
 
       def set_tax!(return_item)
-        percent_of_tax = (return_item.pre_tax_amount <= 0) ? 0 : return_item.pre_tax_amount / Spree::ReturnItem.refund_amount_calculator.new.compute(return_item)
+        percent_of_tax = (return_item.amount <= 0) ? 0 : return_item.amount / Spree::ReturnItem.refund_amount_calculator.new.compute(return_item)
 
         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,
+          included_tax_total:   included_tax_total
         })
       end
     end
-
   end
-
 end

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

@@ -5,7 +5,7 @@ module Spree
     class << self
       def reimburse(reimbursement, return_items, simulate)
         unpaid_amount = return_items.sum(&:total).round(2, :down)
-        reimbursement_list, unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate)
+        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate)
         reimbursement_list
       end
     end

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

@@ -6,7 +6,7 @@ class Spree::ReimbursementType::OriginalPayment < Spree::ReimbursementType
       unpaid_amount = return_items.sum(&:total).round(2, :down)
       payments = reimbursement.order.payments.completed
 
-      refund_list, unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount, simulate)
+      refund_list, _unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount, simulate)
       refund_list
     end
   end

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

@@ -15,7 +15,7 @@ module Spree
         unpaid_amount -= amount
       end
 
-      return reimbursement_list, unpaid_amount
+      [reimbursement_list, unpaid_amount]
     end
 
     def create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list = [])
@@ -23,7 +23,7 @@ module Spree
       unpaid_amount -= credits.sum(&:amount)
       reimbursement_list += credits
 
-      return reimbursement_list, unpaid_amount
+      [reimbursement_list, unpaid_amount]
     end
 
     private
@@ -32,7 +32,7 @@ module Spree
       refund = reimbursement.refunds.build({
         payment: payment,
         amount: amount,
-        reason: Spree::RefundReason.return_processing_reason,
+        reason: Spree::RefundReason.return_processing_reason
       })
 
       simulate ? refund.readonly! : refund.save!

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

@@ -12,7 +12,7 @@ class Spree::ReimbursementType::StoreCredit < Spree::ReimbursementType
 
       # If there is any amount left to pay out to the customer, then create credit with that amount
       if unpaid_amount > 0.0
-        reimbursement_list, unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list)
+        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list)
       end
 
       reimbursement_list

data/app/models/spree/reimbursement_type.rb

@@ -9,7 +9,7 @@ module Spree
     # This method will reimburse the return items based on however it 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)
+    def self.reimburse(_reimbursement, _return_items, _simulate)
       raise "Implement me"
     end
   end

data/app/models/spree/return_authorization.rb

@@ -20,7 +20,6 @@ module Spree
     validate :must_have_shipped_units, on: :create
     validate :no_previously_exchanged_inventory_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
@@ -32,24 +31,27 @@ module Spree
       event :cancel do
         transition to: :canceled, from: :authorized, if: lambda { |return_authorization| return_authorization.can_cancel_return_items? }
       end
-
     end
 
     extend DisplayMoney
-    money_methods :pre_tax_total
+    money_methods :pre_tax_total, :amount
 
     self.whitelisted_ransackable_attributes = ['memo']
 
     def pre_tax_total
-      return_items.sum(:pre_tax_amount)
+      return_items.map(&:pre_tax_amount).sum
+    end
+
+    def amount
+      return_item.sum(:amount)
     end
 
     def currency
-      order.nil? ? Spree::Config[:currency] : order.currency
+      order.currency
     end
 
     def refundable_amount
-      order.pre_tax_item_amount + order.promo_total
+      order.discounted_item_amount + order.promo_total
     end
 
     def customer_returned_items?
@@ -62,49 +64,48 @@ 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 generate_number
-        self.number ||= loop do
-          random = "RA#{Array.new(9){rand(9)}.join}"
-          break random unless self.class.exists?(number: random)
-        end
+    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 no_previously_exchanged_inventory_units
-        if return_items.map(&:inventory_unit).any?(&:exchange_requested?)
-          errors.add(:base, Spree.t(:return_items_cannot_be_created_for_inventory_units_that_are_already_awaiting_exchange))
-        end
+    def generate_number
+      self.number ||= loop do
+        random = "RA#{Array.new(9){ rand(9) }.join}"
+        break random unless self.class.exists?(number: random)
       end
+    end
 
-      def cancel_return_items
-        return_items.each { |item| item.cancel! if item.can_cancel? }
+    def no_previously_exchanged_inventory_units
+      if return_items.map(&:inventory_unit).any?(&:exchange_requested?)
+        errors.add(:base, Spree.t(:return_items_cannot_be_created_for_inventory_units_that_are_already_awaiting_exchange))
       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.new(self)
       end
+    end
   end
 end

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

@@ -6,15 +6,15 @@ module Spree
                                               ReturnItem::EligibilityValidator::TimeSincePurchase,
                                               ReturnItem::EligibilityValidator::RMARequired,
                                               ReturnItem::EligibilityValidator::InventoryShipped,
-                                              ReturnItem::EligibilityValidator::NoReimbursements,
+                                              ReturnItem::EligibilityValidator::NoReimbursements
                                             ]
 
     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/no_reimbursements.rb

@@ -14,4 +14,3 @@ module Spree
     end
   end
 end
-

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

@@ -14,4 +14,3 @@ module Spree
     end
   end
 end
-

data/app/models/spree/return_item.rb

@@ -1,6 +1,5 @@
 module Spree
   class ReturnItem < Spree::Base
-
     INTERMEDIATE_RECEPTION_STATUSES = %i(given_to_customer lost_in_transit shipped_wrong_item short_shipped in_transit)
     COMPLETED_RECEPTION_STATUSES = INTERMEDIATE_RECEPTION_STATUSES + [:received]
 
@@ -49,8 +48,8 @@ module Spree
     scope :awaiting_return, -> { where(reception_status: 'awaiting') }
     scope :expecting_return, -> { where.not(reception_status: COMPLETED_RECEPTION_STATUSES) }
     scope :not_cancelled, -> { where.not(reception_status: 'cancelled') }
-    scope :valid, -> { where.not(reception_status: %w(cancelled expired unexchanged))}
-    scope :not_expired, -> { where.not(reception_status: 'expired')}
+    scope :valid, -> { where.not(reception_status: %w(cancelled expired unexchanged)) }
+    scope :not_expired, -> { where.not(reception_status: 'expired') }
     scope :received, -> { where(reception_status: 'received') }
     INTERMEDIATE_RECEPTION_STATUSES.each do |reception_status|
       scope reception_status, -> { where(reception_status: reception_status) }
@@ -73,8 +72,8 @@ module Spree
     delegate :variant, to: :inventory_unit
     delegate :shipment, to: :inventory_unit
 
-    before_create :set_default_pre_tax_amount, unless: :pre_tax_amount_changed?
-    before_save :set_exchange_pre_tax_amount
+    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
@@ -94,7 +93,7 @@ module Spree
     end
 
     extend DisplayMoney
-    money_methods :pre_tax_amount, :total
+    money_methods :pre_tax_amount, :amount, :total
 
     # @return [Boolean] true when this retur item is in a complete reception
     #   state
@@ -134,7 +133,7 @@ module Spree
     #   unit if one exists, or a new one if one does not
     def self.from_inventory_unit(inventory_unit)
       valid.find_by(inventory_unit: inventory_unit) ||
-        new(inventory_unit: inventory_unit).tap(&:set_default_pre_tax_amount)
+        new(inventory_unit: inventory_unit).tap(&:set_default_amount)
     end
 
     # @return [Boolean] true when an exchange has been requested on this return
@@ -155,10 +154,14 @@ module Spree
       exchange_requested? && !exchange_processed?
     end
 
-    # @return [BigDecimal] the cost of the item before tax, plus the included
-    #   and additional taxes
+    # @return [BigDecimal] the cost of the item after tax
     def total
-      pre_tax_amount + included_tax_total + additional_tax_total
+      amount + additional_tax_total
+    end
+
+    # @return [BigDecimal] the cost of the item before tax
+    def pre_tax_amount
+      amount - included_tax_total
     end
 
     # @note This uses the exchange_variant_engine configured on the class.
@@ -186,12 +189,12 @@ module Spree
       exchange_inventory_unit.try(:shipment)
     end
 
-    # Calculates and sets the default pre-tax amount to be refunded.
+    # Calculates and sets the default amount to be refunded.
     #
     # @note This uses the configured refund_amount_calculator configured on the
     #   class.
-    def set_default_pre_tax_amount
-      self.pre_tax_amount = refund_amount_calculator.new.compute(self)
+    def set_default_amount
+      self.amount = refund_amount_calculator.new.compute(self)
     end
 
     def potential_reception_transitions
@@ -216,7 +219,7 @@ module Spree
     private
 
     def persist_acceptance_status_errors
-      self.update_attributes(acceptance_status_errors: validator.errors)
+      update_attributes(acceptance_status_errors: validator.errors)
     end
 
     def currency
@@ -241,7 +244,7 @@ module Spree
       original_ri = sibling_intended_for_exchange('awaiting')
       if original_ri
         original_ri.unexchange!
-        set_default_pre_tax_amount
+        set_default_amount
         save!
       end
     end
@@ -277,20 +280,20 @@ module Spree
       end
     end
 
-    def set_exchange_pre_tax_amount
-      self.pre_tax_amount = 0.0.to_d if exchange_requested?
+    def set_exchange_amount
+      self.amount = 0.0.to_d if exchange_requested?
     end
 
     def validate_no_other_completed_return_items
       other_return_item = Spree::ReturnItem.where({
         inventory_unit_id: inventory_unit_id,
-        reception_status: COMPLETED_RECEPTION_STATUSES,
-      }).where.not(id: self.id).first
+        reception_status: COMPLETED_RECEPTION_STATUSES
+      }).where.not(id: id).first
 
       if other_return_item && (new_record? || COMPLETED_RECEPTION_STATUSES.include?(reception_status.to_sym))
         errors.add(:inventory_unit, :other_completed_return_item_exists, {
           inventory_unit_id: inventory_unit_id,
-          return_item_id: other_return_item.id,
+          return_item_id: other_return_item.id
         })
       end
     end
@@ -299,9 +302,7 @@ module Spree
       Spree::ReturnItem.where(inventory_unit_id: inventory_unit_id)
                        .where.not(id: id)
                        .valid
-                       .each do |return_item|
-        return_item.cancel!
-      end
+                       .each(&:cancel!)
     end
 
     def should_restock?