spree_core 3.3.6 → 3.4.0.rc1

data/app/models/spree/order/currency_updater.rb

@@ -4,12 +4,10 @@ module Spree
       extend ActiveSupport::Concern
 
       included do
-
         def homogenize_line_item_currencies
           update_line_item_currencies!
           update_with_updater!
         end
-
       end
 
       # Updates prices of order's line items
@@ -31,10 +29,9 @@ module Spree
         if price
           line_item.update_attributes!(currency: price.currency, price: price.amount)
         else
-          raise RuntimeError, "no #{currency} price found for #{line_item.product.name} (#{line_item.variant.sku})"
+          raise "no #{currency} price found for #{line_item.product.name} (#{line_item.variant.sku})"
         end
       end
-
     end
   end
 end

data/app/models/spree/order/payments.rb

@@ -32,11 +32,11 @@ module Spree
         end
 
         def pending_payments
-          payments.select { |payment| payment.pending? }
+          payments.select(&:pending?)
         end
 
         def unprocessed_payments
-          payments.select { |payment| payment.checkout? }
+          payments.select(&:checkout?)
         end
 
         private
@@ -45,7 +45,7 @@ module Spree
           # Don't run if there is nothing to pay.
           return if payment_total >= total
           # Prevent orders from transitioning to complete without a successfully processed payment.
-          raise Core::GatewayError.new(Spree.t(:no_payment_found)) if unprocessed_payments.empty?
+          raise Core::GatewayError, Spree.t(:no_payment_found) if unprocessed_payments.empty?
 
           unprocessed_payments.each do |payment|
             break if payment_total >= total
@@ -58,7 +58,7 @@ module Spree
           end
         rescue Core::GatewayError => e
           result = !!Spree::Config[:allow_checkout_on_gateway_error]
-          errors.add(:base, e.message) and return result
+          errors.add(:base, e.message) && (return result)
         end
       end
     end

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

@@ -8,7 +8,7 @@ module Spree
 
         if user && user.store_credits.any?
           payment_method = Spree::PaymentMethod::StoreCredit.available.first
-          raise "Store credit payment method could not be found" unless payment_method
+          raise 'Store credit payment method could not be found' unless payment_method
 
           user.store_credits.order_by_priority.each do |credit|
             break if remaining_total.zero?
@@ -30,7 +30,7 @@ module Spree
         return false unless user
         user.total_available_store_credit >= total
       end
-      alias_method :covered_by_store_credit, :covered_by_store_credit?
+      alias covered_by_store_credit covered_by_store_credit?
 
       def total_available_store_credit
         return 0.0 unless user

data/app/models/spree/order.rb

@@ -20,7 +20,7 @@ module Spree
                   :included_tax_total,  :additional_tax_total, :tax_total,
                   :shipment_total,      :promo_total,          :total
 
-    alias :display_ship_total :display_shipment_total
+    alias display_ship_total display_shipment_total
     alias_attribute :ship_total, :shipment_total
 
     MONEY_THRESHOLD  = 100_000_000
@@ -196,7 +196,7 @@ module Spree
     # least one LineItem in the Order.  Feel free to override this logic in your
     # own application if you require additional steps before allowing a checkout.
     def checkout_allowed?
-      line_items.count > 0
+      line_items.exists?
     end
 
     # Is this a free order in which case the payment step should be skipped
@@ -268,8 +268,8 @@ module Spree
       self.user           = user
       self.email          = user.email if override_email
       self.created_by   ||= user
-      self.bill_address ||= user.bill_address.try(:clone)
-      self.ship_address ||= user.ship_address.try(:clone)
+      self.bill_address ||= user.bill_address
+      self.ship_address ||= user.ship_address
 
       changes = slice(:user_id, :email, :created_by_id, :bill_address_id, :ship_address_id)
 
@@ -486,7 +486,7 @@ module Spree
       all_adjustments.shipping.delete_all
 
       shipment_ids = shipments.map(&:id)
-      StateChange.where(stateful_type: "Spree::Shipment", stateful_id: shipment_ids).delete_all
+      StateChange.where(stateful_type: 'Spree::Shipment', stateful_id: shipment_ids).delete_all
       ShippingRate.where(shipment_id: shipment_ids).delete_all
 
       shipments.delete_all
@@ -521,9 +521,9 @@ module Spree
     def restart_checkout_flow
       update_columns(
         state: 'cart',
-        updated_at: Time.current,
+        updated_at: Time.current
       )
-      next! if !line_items.empty?
+      next! unless line_items.empty?
     end
 
     def refresh_shipment_rates(shipping_method_filter = ShippingMethod::DISPLAY_ON_FRONT_END)
@@ -549,7 +549,7 @@ module Spree
         cancel!
         update_columns(
           canceler_id: user.id,
-          canceled_at: Time.current,
+          canceled_at: Time.current
         )
       end
     end
@@ -559,7 +559,7 @@ module Spree
         approve!
         update_columns(
           approver_id: user.id,
-          approved_at: Time.current,
+          approved_at: Time.current
         )
       end
     end
@@ -573,9 +573,7 @@ module Spree
     end
 
     def consider_risk
-      if is_risky? && !approved?
-        considered_risky!
-      end
+      considered_risky! if is_risky? && !approved?
     end
 
     def considered_risky!
@@ -616,28 +614,12 @@ module Spree
     def fully_discounted?
       adjustment_total + line_items.map(&:final_amount).sum == 0.0
     end
-    alias_method :fully_discounted, :fully_discounted?
+    alias fully_discounted fully_discounted?
 
     def promo_code
       promotions.pluck(:code).compact.first
     end
 
-    def payments_attributes=(attributes)
-      validate_payments_attributes(attributes)
-      super(attributes)
-    end
-
-    def validate_payments_attributes(attributes)
-      # Ensure the payment methods specified are allowed for this user
-      payment_methods = Spree::PaymentMethod.where(id: available_payment_methods.map(&:id))
-      attributes.each do |payment_attributes|
-        payment_method_id = payment_attributes[:payment_method_id]
-
-        # raise RecordNotFound unless it is an allowed payment method
-        payment_methods.find(payment_method_id) if payment_method_id
-      end
-    end
-
     private
 
     def link_by_email

data/app/models/spree/order_contents.rb

@@ -81,6 +81,7 @@ module Spree
     end
 
     def persist_totals
+      order_updater.update_item_count
       order_updater.update
     end
 
@@ -94,13 +95,13 @@ module Spree
         options_params = options.is_a?(ActionController::Parameters) ? options : ActionController::Parameters.new(options.to_h)
         opts = options_params.
                permit(PermittedAttributes.line_item_attributes).to_h.
-               merge( { currency: order.currency } )
+               merge(currency: order.currency)
 
         line_item = order.line_items.new(quantity: quantity,
-                                          variant: variant,
-                                          options: opts)
+                                         variant: variant,
+                                         options: opts)
       end
-      line_item.target_shipment = options[:shipment] if options.has_key? :shipment
+      line_item.target_shipment = options[:shipment] if options.key? :shipment
       line_item.save!
       line_item
     end
@@ -108,7 +109,7 @@ module Spree
     def remove_from_line_item(variant, quantity, options = {})
       line_item = grab_line_item_by_variant(variant, true, options)
       line_item.quantity -= quantity
-      line_item.target_shipment= options[:shipment]
+      line_item.target_shipment = options[:shipment]
 
       if line_item.quantity.zero?
         order.line_items.destroy(line_item)

data/app/models/spree/order_inventory.rb

@@ -72,10 +72,10 @@ module Spree
       if variant.should_track_inventory?
         on_hand, back_order = shipment.stock_location.fill_status(variant, quantity)
 
-        shipment.set_up_inventory('on_hand', variant, order, line_item, on_hand)
-        shipment.set_up_inventory('backordered', variant, order, line_item, back_order)
+        on_hand.times { shipment.set_up_inventory('on_hand', variant, order, line_item) }
+        back_order.times { shipment.set_up_inventory('backordered', variant, order, line_item) }
       else
-        shipment.set_up_inventory('on_hand', variant, order, line_item, quantity)
+        quantity.times { shipment.set_up_inventory('on_hand', variant, order, line_item) }
       end
 
       # adding to this shipment, and removing from stock_location
@@ -103,7 +103,6 @@ module Spree
           end
           removed_quantity += 1
         end
-        inventory_unit.save! if inventory_unit.persisted?
       end
 
       shipment.destroy if shipment.inventory_units.sum(:quantity).zero?

data/app/models/spree/order_updater.rb

@@ -51,7 +51,6 @@ module Spree
       update_adjustment_total
     end
 
-
     # give each of the shipments a chance to update themselves
     def update_shipments
       shipments.each do |shipment|
@@ -78,14 +77,14 @@ module Spree
     def update_adjustment_total
       recalculate_adjustments
       order.adjustment_total = line_items.sum(:adjustment_total) +
-                               shipments.sum(:adjustment_total)  +
-                               adjustments.eligible.sum(:amount)
+        shipments.sum(:adjustment_total) +
+        adjustments.eligible.sum(:amount)
       order.included_tax_total = line_items.sum(:included_tax_total) + shipments.sum(:included_tax_total)
       order.additional_tax_total = line_items.sum(:additional_tax_total) + shipments.sum(:additional_tax_total)
 
       order.promo_total = line_items.sum(:promo_total) +
-                          shipments.sum(:promo_total) +
-                          adjustments.promotion.eligible.sum(:amount)
+        shipments.sum(:promo_total) +
+        adjustments.promotion.eligible.sum(:amount)
 
       update_order_total
     end
@@ -112,7 +111,7 @@ module Spree
         shipment_total: order.shipment_total,
         promo_total: order.promo_total,
         total: order.total,
-        updated_at: Time.current,
+        updated_at: Time.current
       )
     end
 
@@ -132,18 +131,18 @@ module Spree
       else
         # get all the shipment states for this order
         shipment_states = shipments.states
-        if shipment_states.size > 1
+        order.shipment_state = if shipment_states.size > 1
           # multiple shiment states means it's most likely partially shipped
-          order.shipment_state = 'partial'
-        else
+                                 'partial'
+                               else
           # will return nil if no shipments are found
-          order.shipment_state = shipment_states.first
-          # TODO inventory unit states?
+                                 shipment_states.first
+          # TODO: inventory unit states?
           # if order.shipment_state && order.inventory_units.where(shipment_id: nil).exists?
           #   shipments exist but there are unassigned inventory units
           #   order.shipment_state = 'partial'
           # end
-        end
+                               end
       end
 
       order.state_changed('shipment')
@@ -161,14 +160,14 @@ module Spree
     # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
     def update_payment_state
       last_state = order.payment_state
-      if payments.present? && payments.valid.size == 0
+      if payments.present? && payments.valid.empty?
         order.payment_state = 'failed'
       elsif order.canceled? && order.payment_total == 0
         order.payment_state = 'void'
       else
         order.payment_state = 'balance_due' if order.outstanding_balance > 0
         order.payment_state = 'credit_owed' if order.outstanding_balance < 0
-        order.payment_state = 'paid' if !order.outstanding_balance?
+        order.payment_state = 'paid' unless order.outstanding_balance?
       end
       order.state_changed('payment') if last_state != order.payment_state
       order.payment_state

data/app/models/spree/payment/processing.rb

@@ -29,7 +29,7 @@ module Spree
       # a new pending payment record for the remaining amount to capture later.
       def capture!(amount = nil)
         return true if completed?
-        amount ||= money.amount_in_cents
+        amount ||= money.money.cents
         started_processing!
         protect_from_connection_error do
           # Standard ActiveMerchant capture usage
@@ -48,20 +48,19 @@ module Spree
       def void_transaction!
         return true if void?
         protect_from_connection_error do
-
           if payment_method.payment_profiles_supported?
             # Gateways supporting payment profiles will need access to credit card object because this stores the payment profile information
             # so supply the authorization itself as well as the credit card, rather than just the authorization code
-            response = payment_method.void(self.response_code, source, gateway_options)
+            response = payment_method.void(response_code, source, gateway_options)
           else
             # Standard ActiveMerchant void usage
-            response = payment_method.void(self.response_code, gateway_options)
+            response = payment_method.void(response_code, gateway_options)
           end
           record_response(response)
 
           if response.success?
             self.response_code = response.authorization
-            self.void
+            void
           else
             gateway_error(response)
           end
@@ -92,30 +91,30 @@ module Spree
         capture_events.create!(amount: amount)
       end
 
-      def handle_payment_preconditions(&block)
+      def handle_payment_preconditions
         unless block_given?
-          raise ArgumentError.new("handle_payment_preconditions must be called with a block")
+          raise ArgumentError, 'handle_payment_preconditions must be called with a block'
         end
 
         if payment_method && payment_method.source_required?
           if source
-            if !processing?
+            unless processing?
               if payment_method.supports?(source) || token_based?
                 yield
               else
                 invalidate!
-                raise Core::GatewayError.new(Spree.t(:payment_method_not_supported))
+                raise Core::GatewayError, Spree.t(:payment_method_not_supported)
               end
             end
           else
-            raise Core::GatewayError.new(Spree.t(:payment_processing_failed))
+            raise Core::GatewayError, Spree.t(:payment_processing_failed)
           end
         end
       end
 
       def gateway_action(source, action, success_state)
         protect_from_connection_error do
-          response = payment_method.send(action, money.amount_in_cents,
+          response = payment_method.send(action, money.money.cents,
                                          source,
                                          gateway_options)
           handle_response(response, success_state, :failure)
@@ -135,9 +134,9 @@ module Spree
               self.cvv_response_message = response.cvv_result['message']
             end
           end
-          self.send("#{success_state}!")
+          send("#{success_state}!")
         else
-          self.send(failure_state)
+          send(failure_state)
           gateway_error(response)
         end
       end
@@ -147,24 +146,24 @@ module Spree
       end
 
       def protect_from_connection_error
-        begin
-          yield
-        rescue ActiveMerchant::ConnectionError => e
-          gateway_error(e)
-        end
+
+        yield
+      rescue ActiveMerchant::ConnectionError => e
+        gateway_error(e)
+
       end
 
       def gateway_error(error)
-        if error.is_a? ActiveMerchant::Billing::Response
-          text = error.params['message'] || error.params['response_reason_text'] || error.message
-        elsif error.is_a? ActiveMerchant::ConnectionError
-          text = Spree.t(:unable_to_connect_to_gateway)
-        else
-          text = error.to_s
-        end
+        text = if error.is_a? ActiveMerchant::Billing::Response
+                 error.params['message'] || error.params['response_reason_text'] || error.message
+               elsif error.is_a? ActiveMerchant::ConnectionError
+                 Spree.t(:unable_to_connect_to_gateway)
+               else
+                 error.to_s
+               end
         logger.error(Spree.t(:gateway_error))
         logger.error("  #{error.to_yaml}")
-        raise Core::GatewayError.new(text)
+        raise Core::GatewayError, text
       end
 
       def token_based?

data/app/models/spree/payment.rb

@@ -16,7 +16,7 @@ module Spree
     end
     belongs_to :source, polymorphic: true
 
-    has_many :offsets, -> { offset_payment }, class_name: "Spree::Payment", foreign_key: :source_id
+    has_many :offsets, -> { offset_payment }, class_name: 'Spree::Payment', foreign_key: :source_id
     has_many :log_entries, as: :source
     has_many :state_changes, as: :stateful
     has_many :capture_events, class_name: 'Spree::PaymentCaptureEvent'
@@ -103,13 +103,13 @@ module Spree
         payment.state_changes.create!(
           previous_state: transition.from,
           next_state:     transition.to,
-          name:           'payment',
+          name:           'payment'
         )
       end
     end
 
     def money
-      Spree::Money.new(amount, { currency: currency })
+      Spree::Money.new(amount, currency: currency)
     end
     alias display_amount money
 
@@ -124,7 +124,7 @@ module Spree
     end
 
     def offsets_total
-      offsets.pluck(:amount).sum
+      offsets.sum(:amount)
     end
 
     def credit_allowed
@@ -140,14 +140,14 @@ module Spree
       return unless new_record?
       if source_attributes.present? && source.blank? && payment_method.try(:payment_source_class)
         self.source = payment_method.payment_source_class.new(source_attributes)
-        self.source.payment_method_id = payment_method.id
-        self.source.user_id = self.order.user_id if self.order
+        source.payment_method_id = payment_method.id
+        source.user_id = order.user_id if order
       end
     end
 
     def actions
-      return [] unless payment_source and payment_source.respond_to? :actions
-      payment_source.actions.select { |action| !payment_source.respond_to?("can_#{action}?") or payment_source.send("can_#{action}?", self) }
+      return [] unless payment_source && payment_source.respond_to?(:actions)
+      payment_source.actions.select { |action| !payment_source.respond_to?("can_#{action}?") || payment_source.send("can_#{action}?", self) }
     end
 
     def payment_source
@@ -157,14 +157,14 @@ module Spree
 
     def is_avs_risky?
       return false if avs_response.blank? || NON_RISKY_AVS_CODES.include?(avs_response)
-      return true
+      true
     end
 
     def is_cvv_risky?
-      return false if cvv_response_code == "M"
+      return false if cvv_response_code == 'M'
       return false if cvv_response_code.nil?
       return false if cvv_response_message.present?
-      return true
+      true
     end
 
     def captured_amount
@@ -185,86 +185,79 @@ module Spree
       INVALID_STATES.include?(state)
     end
 
-      def validate_source
-        if source && !source.valid?
-          source.errors.each do |field, error|
-            field_name = I18n.t("activerecord.attributes.#{source.class.to_s.underscore}.#{field}")
-            self.errors.add(Spree.t(source.class.to_s.demodulize.underscore), "#{field_name} #{error}")
-          end
+    def validate_source
+      if source && !source.valid?
+        source.errors.each do |field, error|
+          field_name = I18n.t("activerecord.attributes.#{source.class.to_s.underscore}.#{field}")
+          errors.add(Spree.t(source.class.to_s.demodulize.underscore), "#{field_name} #{error}")
         end
-        return !errors.present?
       end
+      !errors.present?
+    end
 
-      def profiles_supported?
-        payment_method.respond_to?(:payment_profiles_supported?) && payment_method.payment_profiles_supported?
-      end
+    def profiles_supported?
+      payment_method.respond_to?(:payment_profiles_supported?) && payment_method.payment_profiles_supported?
+    end
 
-      def create_payment_profile
-        # Don't attempt to create on bad payments.
-        return if has_invalid_state?
-        # Payment profile cannot be created without source
-        return unless source
-        # Imported payments shouldn't create a payment profile.
-        return if source.imported
-
-        payment_method.create_profile(self)
-      rescue ActiveMerchant::ConnectionError => e
-        gateway_error e
-      end
+    def create_payment_profile
+      # Don't attempt to create on bad payments.
+      return if has_invalid_state?
+      # Payment profile cannot be created without source
+      return unless source
+      # Imported payments shouldn't create a payment profile.
+      return if source.imported
+
+      payment_method.create_profile(self)
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error e
+    end
 
-      def split_uncaptured_amount
-        if uncaptured_amount > 0
-          order.payments.create!(
-            amount: uncaptured_amount,
-            payment_method: payment_method,
-            source: source,
-            state: 'pending',
-            capture_on_dispatch: true
-          ).authorize!
-          update_attributes(amount: captured_amount)
-        end
+    def split_uncaptured_amount
+      if uncaptured_amount > 0
+        order.payments.create!(
+          amount: uncaptured_amount,
+          payment_method: payment_method,
+          source: source,
+          state: 'pending',
+          capture_on_dispatch: true
+        ).authorize!
+        update_attributes(amount: captured_amount)
       end
+    end
 
-      def update_order
-        if completed? || void?
-          order.updater.update_payment_total
-        end
-
-        if order.completed?
-          order.updater.update_payment_state
-          order.updater.update_shipments
-          order.updater.update_shipment_state
-        end
+    def update_order
+      order.updater.update_payment_total if completed? || void?
 
-        if self.completed? || order.completed?
-          order.persist_totals
-        end
+      if order.completed?
+        order.updater.update_payment_state
+        order.updater.update_shipments
+        order.updater.update_shipment_state
       end
 
-      def create_eligible_credit_event
-        # When cancelling an order, a payment with the negative amount
-        # of the payment total is created to refund the customer. That
-        # payment has a source of itself (Spree::Payment) no matter the
-        # type of payment getting refunded, hence the additional check
-        # if the source is a store credit.
-        return unless store_credit? && source.is_a?(Spree::StoreCredit)
-
-        # creates the store credit event
-        source.update_attributes!({
-          action: Spree::StoreCredit::ELIGIBLE_ACTION,
-          action_amount: amount,
-          action_authorization_code: response_code,
-        })
-      end
+      order.persist_totals if completed? || order.completed?
+    end
 
-      def invalidate_old_payments
-        # invalid payment or store_credit payment shouldn't invalidate other payment types
-        return if has_invalid_state? || store_credit?
+    def create_eligible_credit_event
+      # When cancelling an order, a payment with the negative amount
+      # of the payment total is created to refund the customer. That
+      # payment has a source of itself (Spree::Payment) no matter the
+      # type of payment getting refunded, hence the additional check
+      # if the source is a store credit.
+      return unless store_credit? && source.is_a?(Spree::StoreCredit)
+
+      # creates the store credit event
+      source.update_attributes!(action: Spree::StoreCredit::ELIGIBLE_ACTION,
+                                action_amount: amount,
+                                action_authorization_code: response_code)
+    end
 
-        order.payments.with_state('checkout').where.not(id: id).each do |payment|
-          payment.invalidate! unless payment.store_credit?
-        end
-      end
+    def invalidate_old_payments
+      # invalid payment or store_credit payment shouldn't invalidate other payment types
+      return if has_invalid_state? || store_credit?
 
+      order.payments.with_state('checkout').where.not(id: id).each do |payment|
+        payment.invalidate! unless payment.store_credit?
+      end
+    end
   end
 end

data/app/models/spree/payment_capture_event.rb

@@ -3,7 +3,7 @@ module Spree
     belongs_to :payment, class_name: 'Spree::Payment'
 
     def display_amount
-      Spree::Money.new(amount, { currency: payment.currency })
+      Spree::Money.new(amount, currency: payment.currency)
     end
   end
 end

data/app/models/spree/payment_method/check.rb

@@ -37,7 +37,7 @@ module Spree
     private
 
     def simulated_successful_billing_response
-      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+      ActiveMerchant::Billing::Response.new(true, '', {}, {})
     end
   end
 end