solidus_core 1.2.3 → 1.3.0.beta1

data/app/models/spree/calculator/flexi_rate.rb

@@ -11,19 +11,19 @@ module Spree
       Spree.t(:flexible_rate)
     end
 
-    def self.available?(object)
+    def self.available?(_object)
       true
     end
 
     def compute(object)
       sum = 0
-      max = self.preferred_max_items.to_i
+      max = preferred_max_items.to_i
       items_count = object.quantity
       items_count.times do |i|
         if i == 0
-          sum += self.preferred_first_item.to_f
+          sum += preferred_first_item.to_f
         elsif ((max > 0) && (i <= (max - 1))) || (max == 0)
-          sum += self.preferred_additional_item.to_f
+          sum += preferred_additional_item.to_f
         end
       end
 

data/app/models/spree/calculator/percent_per_item.rb

@@ -1,5 +1,4 @@
 module Spree
-
   # A calculator for promotions that calculates a percent-off discount
   # for all matching products in an order. This should not be used as a
   # shipping calculator since it would be the same thing as a flat percent
@@ -15,21 +14,21 @@ module Spree
       Spree.t(:percent_per_item)
     end
 
-    def compute(object=nil)
+    def compute(object = nil)
       return 0 if object.nil?
-      object.line_items.reduce(0) do |sum, line_item|
-        sum += value_for_line_item(line_item)
-      end
+      object.line_items.map { |line_item|
+        value_for_line_item(line_item)
+      }.sum
     end
 
-  private
+    private
 
     # Returns all products that match this calculator, but only if the calculator
     # is attached to a promotion. If attached to a ShippingMethod, nil is returned.
     # Copied from per_item.rb
     def matching_products
       if compute_on_promotion?
-        self.calculable.promotion.rules.map do |rule|
+        calculable.promotion.rules.map do |rule|
           rule.respond_to?(:products) ? rule.products : []
         end.flatten
       end
@@ -37,14 +36,14 @@ module Spree
 
     def value_for_line_item(line_item)
       if compute_on_promotion?
-        return 0 unless matching_products.blank? or matching_products.include?(line_item.product)
+        return 0 unless matching_products.blank? || matching_products.include?(line_item.product)
       end
       ((line_item.price * line_item.quantity) * preferred_percent) / 100
     end
 
     # Determines wether or not the calculable object is a promotion
     def compute_on_promotion?
-      @compute_on_promotion ||= self.calculable.respond_to?(:promotion)
+      @compute_on_promotion ||= calculable.respond_to?(:promotion)
     end
   end
 end

data/app/models/spree/calculator/price_sack.rb

@@ -19,10 +19,10 @@ module Spree
         base = object.respond_to?(:amount) ? object.amount : BigDecimal(object.to_s)
       end
 
-      if base < self.preferred_minimal_amount
-        self.preferred_normal_amount
+      if base < preferred_minimal_amount
+        preferred_normal_amount
       else
-        self.preferred_discount_amount
+        preferred_discount_amount
       end
     end
   end

data/app/models/spree/calculator/returns/default_refund_amount.rb

@@ -3,14 +3,13 @@ require_dependency 'spree/returns_calculator'
 module Spree
   module Calculator::Returns
     class DefaultRefundAmount < ReturnsCalculator
-
       def self.description
         Spree.t(:default_refund_amount)
       end
 
       def compute(return_item)
         return 0.0.to_d if return_item.part_of_exchange?
-        weighted_order_adjustment_amount(return_item.inventory_unit) + weighted_line_item_pre_tax_amount(return_item.inventory_unit)
+        weighted_order_adjustment_amount(return_item.inventory_unit) + weighted_line_item_amount(return_item.inventory_unit)
       end
 
       private
@@ -19,18 +18,18 @@ module Spree
         inventory_unit.order.adjustments.eligible.non_tax.sum(:amount) * percentage_of_order_total(inventory_unit)
       end
 
-      def weighted_line_item_pre_tax_amount(inventory_unit)
-        inventory_unit.line_item.pre_tax_amount * percentage_of_line_item(inventory_unit)
+      def weighted_line_item_amount(inventory_unit)
+        inventory_unit.line_item.discounted_amount * percentage_of_line_item(inventory_unit)
       end
 
       def percentage_of_order_total(inventory_unit)
-       return 0.0 if inventory_unit.order.pre_tax_item_amount.zero?
-       weighted_line_item_pre_tax_amount(inventory_unit) / inventory_unit.order.pre_tax_item_amount
-     end
+        return 0.0 if inventory_unit.order.discounted_item_amount.zero?
+        weighted_line_item_amount(inventory_unit) / inventory_unit.order.discounted_item_amount
+      end
 
-     def percentage_of_line_item(inventory_unit)
-       1 / BigDecimal.new(inventory_unit.line_item.quantity)
-     end
-   end
- end
+      def percentage_of_line_item(inventory_unit)
+        1 / BigDecimal.new(inventory_unit.line_item.quantity)
+      end
+    end
+  end
 end

data/app/models/spree/calculator/shipping/flat_percent_item_total.rb

@@ -14,7 +14,7 @@ module Spree
       end
 
       def compute_from_price(price)
-        value = price * BigDecimal(self.preferred_flat_percent.to_s) / 100.0
+        value = price * BigDecimal(preferred_flat_percent.to_s) / 100.0
         (value * 100).round.to_f / 100
       end
     end

data/app/models/spree/calculator/shipping/flat_rate.rb

@@ -10,8 +10,8 @@ module Spree
         Spree.t(:shipping_flat_rate_per_order)
       end
 
-      def compute_package(package)
-        self.preferred_amount
+      def compute_package(_package)
+        preferred_amount
       end
     end
   end

data/app/models/spree/calculator/shipping/flexi_rate.rb

@@ -18,13 +18,13 @@ module Spree
 
       def compute_from_quantity(quantity)
         sum = 0
-        max = self.preferred_max_items.to_i
+        max = preferred_max_items.to_i
         quantity.times do |i|
           # check max value to avoid divide by 0 errors
           if (max == 0 && i == 0) || (max > 0) && (i % max == 0)
-            sum += self.preferred_first_item.to_f
+            sum += preferred_first_item.to_f
           else
-            sum += self.preferred_additional_item.to_f
+            sum += preferred_additional_item.to_f
           end
         end
 

data/app/models/spree/calculator/shipping/per_item.rb

@@ -15,7 +15,7 @@ module Spree
       end
 
       def compute_from_quantity(quantity)
-        self.preferred_amount * quantity
+        preferred_amount * quantity
       end
     end
   end

data/app/models/spree/calculator/shipping/price_sack.rb

@@ -17,10 +17,10 @@ module Spree
       end
 
       def compute_from_price(price)
-        if price < self.preferred_minimal_amount
-          self.preferred_normal_amount
+        if price < preferred_minimal_amount
+          preferred_normal_amount
         else
-          self.preferred_discount_amount
+          preferred_discount_amount
         end
       end
     end

data/app/models/spree/calculator/tiered_flat_rate.rb

@@ -19,11 +19,12 @@ module Spree
     end
 
     def compute(object)
-      base, amount = preferred_tiers.sort.reverse.detect{ |b,_| object.amount >= b }
+      _base, amount = preferred_tiers.sort.reverse.detect{ |b, _| object.amount >= b }
       amount || preferred_base_amount
     end
 
     private
+
     def preferred_tiers_content
       if preferred_tiers.is_a? Hash
         unless preferred_tiers.keys.all?{ |k| k.is_a?(Numeric) && k > 0 }

data/app/models/spree/calculator/tiered_percent.rb

@@ -24,11 +24,12 @@ module Spree
 
     def compute(object)
       order = object.is_a?(Order) ? object : object.order
-      base, percent = preferred_tiers.sort.reverse.detect{ |b,_| order.item_total >= b }
+      _base, percent = preferred_tiers.sort.reverse.detect{ |b, _| order.item_total >= b }
       (object.amount * (percent || preferred_base_percent) / 100).round(2)
     end
 
     private
+
     def preferred_tiers_content
       if preferred_tiers.is_a? Hash
         unless preferred_tiers.keys.all?{ |k| k.is_a?(Numeric) && k > 0 }

data/app/models/spree/calculator.rb

@@ -11,7 +11,7 @@ module Spree
       method = "compute_#{computable_name}".to_sym
       calculator_class = self.class
       if respond_to?(method)
-        self.send(method, computable)
+        send(method, computable)
       else
         raise NotImplementedError, "Please implement '#{method}(#{computable_name})' in your calculator: #{calculator_class.name}"
       end
@@ -24,7 +24,7 @@ module Spree
 
     ###################################################################
 
-    def self.register(*klasses)
+    def self.register(*_klasses)
     end
 
     # Returns all calculators applicable for kind of work
@@ -40,7 +40,7 @@ module Spree
       self.class.description
     end
 
-    def available?(object)
+    def available?(_object)
       true
     end
   end

data/app/models/spree/carton.rb

@@ -4,8 +4,8 @@ class Spree::Carton < Spree::Base
   belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', inverse_of: :cartons
 
   has_many :inventory_units, class_name: "Spree::InventoryUnit", inverse_of: :carton, dependent: :nullify
-  has_many :orders, -> { uniq }, through: :inventory_units
-  has_many :shipments, -> { uniq }, through: :inventory_units
+  has_many :orders, -> { distinct }, through: :inventory_units
+  has_many :shipments, -> { distinct }, through: :inventory_units
 
   validates :address, presence: true
   validates :stock_location, presence: true

data/app/models/spree/country.rb

@@ -8,14 +8,17 @@ module Spree
     def self.states_required_by_country_id
       ActiveSupport::Deprecation.warn "Spree::Country.states_required_by_country_id is deprecated and will be removed from future releases, Implement it yourself.", caller
       states_required = Hash.new(true)
-      all.each { |country| states_required[country.id.to_s]= country.states_required }
+      all.each { |country| states_required[country.id.to_s] = country.states_required }
       states_required
     end
 
     def self.default
-      if default_country_id = Spree::Config[:default_country_id]
-        find_by_id(default_country_id)
-      end || first
+      if Spree::Config.default_country_id
+        ActiveSupport::Deprecation.warn("Setting your default country via its ID is deprecated. Please set your default country via the `default_country_iso` setting.", caller)
+        find_by(id: Spree::Config.default_country_id) || find_by!(iso: Spree::Config.default_country_iso)
+      else
+        find_by!(iso: Spree::Config.default_country_iso)
+      end
     end
 
     def <=>(other)

data/app/models/spree/credit_card.rb

@@ -48,11 +48,11 @@ module Spree
       return unless expiry.present?
 
       self[:month], self[:year] =
-      if expiry.match(/\d{2}\s?\/\s?\d{2,4}/) # will match mm/yy and mm / yyyy
-        expiry.delete(' ').split('/')
-      elsif match = expiry.match(/(\d{2})(\d{2,4})/) # will match mmyy and mmyyyy
-        [match[1], match[2]]
-      end
+        if expiry =~ /\d{2}\s?\/\s?\d{2,4}/ # will match mm/yy and mm / yyyy
+          expiry.delete(' ').split('/')
+        elsif match = expiry.match(/(\d{2})(\d{2,4})/) # will match mmyy and mmyyyy
+          [match[1], match[2]]
+        end
       if self[:year]
         self[:year] = "20" + self[:year] if self[:year].length == 2
         self[:year] = self[:year].to_i
@@ -64,7 +64,11 @@ module Spree
     #
     # @param num [String] the desired credit card number
     def number=(num)
-      @number = num.gsub(/[^0-9]/, '') rescue nil
+      @number = begin
+                  num.gsub(/[^0-9]/, '')
+                rescue
+                  nil
+                end
     end
 
     # Sets the credit card type, converting it to the preferred internal
@@ -75,18 +79,18 @@ module Spree
       # cc_type is set by jquery.payment, which helpfully provides different
       # types from Active Merchant. Converting them is necessary.
       self[:cc_type] = case type
-      when 'mastercard', 'maestro' then 'master'
-      when 'amex' then 'american_express'
-      when 'dinersclub' then 'diners_club'
-      when '' then try_type_from_number
+                       when 'mastercard', 'maestro' then 'master'
+                       when 'amex' then 'american_express'
+                       when 'dinersclub' then 'diners_club'
+                       when '' then try_type_from_number
       else type
       end
     end
 
     # Sets the last digits field based on the assigned credit card number.
     def set_last_digits
-      number.to_s.gsub!(/\s/,'')
-      verification_value.to_s.gsub!(/\s/,'')
+      number.to_s.gsub!(/\s/, '')
+      verification_value.to_s.gsub!(/\s/, '')
       self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
     end
 
@@ -94,7 +98,7 @@ module Spree
     #   number, otherwise the empty string
     def try_type_from_number
       numbers = number.delete(' ') if number
-      CARD_TYPES.find{|type, pattern| return type.to_s if numbers =~ pattern}.to_s
+      CARD_TYPES.find{ |type, pattern| return type.to_s if numbers =~ pattern }.to_s
     end
 
     # @return [Boolean] true when a verification value is present
@@ -163,24 +167,24 @@ module Spree
     #   card that represents this credit card
     def to_active_merchant
       ActiveMerchant::Billing::CreditCard.new(
-        :number => number,
-        :month => month,
-        :year => year,
-        :verification_value => verification_value,
-        :first_name => first_name,
-        :last_name => last_name,
+        number: number,
+        month: month,
+        year: year,
+        verification_value: verification_value,
+        first_name: first_name,
+        last_name: last_name
       )
     end
 
     private
 
     def require_card_numbers?
-      !self.encrypted_data.present? && !self.has_payment_profile?
+      !encrypted_data.present? && !has_payment_profile?
     end
 
     def ensure_one_default
-      if self.user_id && self.default
-        CreditCard.where(default: true).where.not(id: self.id).where(user_id: self.user_id).each do |ucc|
+      if user_id && default
+        CreditCard.where(default: true).where.not(id: id).where(user_id: user_id).each do |ucc|
           ucc.update_columns(default: false, updated_at: Time.current)
         end
       end

data/app/models/spree/customer_return.rb

@@ -16,10 +16,9 @@ module Spree
     accepts_nested_attributes_for :return_items
 
     extend DisplayMoney
-    money_methods pre_tax_total: { currency: Spree::Config[:currency] },
-                  total: { currency: Spree::Config[:currency] }
-
+    money_methods :pre_tax_total, :total, :amount
 
+    delegate :currency, to: :order
     delegate :id, to: :order, prefix: true, allow_nil: true
 
     def total
@@ -27,7 +26,11 @@ module Spree
     end
 
     def pre_tax_total
-      return_items.sum(:pre_tax_amount)
+      return_items.map(&:pre_tax_amount).sum
+    end
+
+    def amount
+      return_items.sum(:amount)
     end
 
     # Temporarily tie a customer_return to one order
@@ -52,7 +55,7 @@ module Spree
 
     def generate_number
       self.number ||= loop do
-        random = "CR#{Array.new(9){rand(9)}.join}"
+        random = "CR#{Array.new(9){ rand(9) }.join}"
         break random unless self.class.exists?(number: random)
       end
     end
@@ -66,7 +69,5 @@ module Spree
     def inventory_units
       return_items.flat_map(&:inventory_unit)
     end
-
   end
 end
-

data/app/models/spree/exchange.rb

@@ -1,6 +1,7 @@
 module Spree
   class Exchange
     class UnableToCreateShipments < StandardError; end
+    extend ActiveModel::Naming
 
     def initialize(order, reimbursement_objects)
       @order = order
@@ -38,14 +39,5 @@ module Spree
     def self.param_key
       "spree_exchange"
     end
-
-    def self.model_name
-      Spree::Exchange
-    end
-
-    def model_name
-      self.class.model_name
-    end
-
   end
 end

data/app/models/spree/gateway/bogus.rb

@@ -1,9 +1,9 @@
 module Spree
   class Gateway::Bogus < Gateway
-    TEST_VISA = ['4111111111111111','4012888888881881','4222222222222']
-    TEST_MC   = ['5500000000000004','5555555555554444','5105105105105100']
-    TEST_AMEX = ['378282246310005','371449635398431','378734493671000','340000000000009']
-    TEST_DISC = ['6011000000000004','6011111111111117','6011000990139424']
+    TEST_VISA = ['4111111111111111', '4012888888881881', '4222222222222']
+    TEST_MC   = ['5500000000000004', '5555555555554444', '5105105105105100']
+    TEST_AMEX = ['378282246310005', '371449635398431', '378734493671000', '340000000000009']
+    TEST_DISC = ['6011000000000004', '6011111111111117', '6011000990139424']
 
     VALID_CCS = ['1', TEST_VISA, TEST_MC, TEST_AMEX, TEST_DISC].flatten
 
@@ -17,47 +17,46 @@ module Spree
       return if payment.source.has_payment_profile?
       # simulate the storage of credit card profile using remote service
       if success = VALID_CCS.include?(payment.source.number)
-        payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
+        payment.source.update_attributes(gateway_customer_profile_id: generate_profile_id(success))
       end
     end
 
-    def authorize(money, credit_card, options = {})
+    def authorize(_money, credit_card, _options = {})
       profile_id = credit_card.gateway_customer_profile_id
-      if VALID_CCS.include? credit_card.number or (profile_id and profile_id.starts_with? 'BGS-')
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'D' })
+      if VALID_CCS.include?(credit_card.number) || (profile_id && profile_id.starts_with?('BGS-'))
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'D' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
       end
     end
 
-    def purchase(money, credit_card, options = {})
+    def purchase(_money, credit_card, _options = {})
       profile_id = credit_card.gateway_customer_profile_id
-      if VALID_CCS.include? credit_card.number  or (profile_id and profile_id.starts_with? 'BGS-')
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'M' })
+      if VALID_CCS.include?(credit_card.number) || (profile_id && profile_id.starts_with?('BGS-'))
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'M' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
       end
     end
 
-    def credit(money, credit_card, response_code, options = {})
-      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+    def credit(_money, _credit_card, _response_code, _options = {})
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
     end
 
-    def capture(money, authorization, gateway_options)
+    def capture(_money, authorization, _gateway_options)
       if authorization == '12345'
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true)
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true)
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :error => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', error: 'Bogus Gateway: Forced failure', test: true)
       end
-
     end
 
-    def void(response_code, credit_card, options = {})
-      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+    def void(_response_code, _credit_card, _options = {})
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
     end
 
-    def cancel(response_code)
-      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+    def cancel(_response_code)
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
     end
 
     def test?
@@ -74,14 +73,15 @@ module Spree
     end
 
     private
-      def generate_profile_id(success)
-        record = true
-        prefix = success ? 'BGS' : 'FAIL'
-        while record
-          random = "#{prefix}-#{Array.new(6){rand(6)}.join}"
-          record = CreditCard.where(:gateway_customer_profile_id => random).first
-        end
-        random
+
+    def generate_profile_id(success)
+      record = true
+      prefix = success ? 'BGS' : 'FAIL'
+      while record
+        random = "#{prefix}-#{Array.new(6){ rand(6) }.join}"
+        record = CreditCard.where(gateway_customer_profile_id: random).first
       end
+      random
+    end
   end
 end

data/app/models/spree/gateway/bogus_simple.rb

@@ -1,26 +1,24 @@
 module Spree
   # Bogus Gateway that doesn't support payment profiles.
   class Gateway::BogusSimple < Gateway::Bogus
-
     def payment_profiles_supported?
       false
     end
 
-    def authorize(money, credit_card, options = {})
+    def authorize(_money, credit_card, _options = {})
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
       end
     end
 
-    def purchase(money, credit_card, options = {})
+    def purchase(_money, credit_card, _options = {})
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
       end
     end
-
   end
 end

data/app/models/spree/gateway.rb

@@ -11,14 +11,9 @@ module Spree
       CreditCard
     end
 
-    # instantiates the selected gateway and configures with the options stored in the database
-    def self.current
-      super
-    end
-
     def provider
       gateway_options = options
-      gateway_options.delete :login if gateway_options.has_key?(:login) and gateway_options[:login].nil?
+      gateway_options.delete :login if gateway_options.key?(:login) && gateway_options[:login].nil?
       if gateway_options[:server]
         ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
       end
@@ -39,11 +34,12 @@ module Spree
 
     def supports?(source)
       return true unless provider_class.respond_to? :supports?
-      return false unless source.brand
-      provider_class.supports?(source.brand)
+      return true if source.brand && provider_class.supports?(source.brand)
+      source.has_payment_profile?
     end
 
     def disable_customer_profile(source)
+      ActiveSupport::Deprecation.warn("Gateway#disable_customer_profile is deprecated")
       if source.is_a? CreditCard
         source.update_column :gateway_customer_profile_id, nil
       else
@@ -52,19 +48,17 @@ module Spree
     end
 
     def sources_by_order(order)
-      source_ids = order.payments.where(payment_method_id: self.id).pluck(:source_id).uniq
+      source_ids = order.payments.where(payment_method_id: id).pluck(:source_id).uniq
       payment_source_class.where(id: source_ids).with_payment_profile
     end
 
     def reusable_sources(order)
       if order.completed?
-        sources_by_order order
+        sources_by_order(order)
+      elsif order.user_id
+        credit_cards.where(user_id: order.user_id).with_payment_profile
       else
-        if order.user_id
-          self.credit_cards.where(user_id: order.user_id).with_payment_profile
-        else
-          []
-        end
+        []
       end
     end
   end