solidus_core 1.2.3 → 1.3.0.beta1

data/app/models/spree/image.rb

@@ -10,14 +10,14 @@ module Spree
                       path: ':rails_root/public/spree/products/:id/:style/:basename.:extension',
                       convert_options: { all: '-strip -auto-orient -colorspace sRGB' }
     validates_attachment :attachment,
-      :presence => true,
-      :content_type => { :content_type => %w(image/jpeg image/jpg image/png image/gif) }
+      presence: true,
+      content_type: { content_type: %w(image/jpeg image/jpg image/png image/gif) }
 
     # save the w,h of the original image (from which others can be calculated)
     # we need to look at the write-queue for images which have not been saved yet
     after_post_process :find_dimensions
 
-    #used by admin products autocomplete
+    # used by admin products autocomplete
     def mini_url
       attachment.url(:mini, false)
     end

data/app/models/spree/inventory_unit.rb

@@ -75,7 +75,7 @@ module Spree
       inventory_units.map do |iu|
         iu.update_columns(
           pending: false,
-          updated_at: Time.current,
+          updated_at: Time.current
         )
       end
     end
@@ -113,35 +113,35 @@ module Spree
       return_items.not_expired.any?(&:exchange_requested?)
     end
 
+    def allow_ship?
+      on_hand?
+    end
+
     private
 
-      def allow_ship?
-        self.on_hand?
-      end
+    def fulfill_order
+      reload
+      order.fulfill!
+    end
 
-      def fulfill_order
-        self.reload
-        order.fulfill!
-      end
+    def percentage_of_line_item
+      1 / BigDecimal.new(line_item.quantity)
+    end
 
-      def percentage_of_line_item
-        1 / BigDecimal.new(line_item.quantity)
-      end
+    def current_return_item
+      return_items.not_cancelled.first
+    end
 
-      def current_return_item
-        return_items.not_cancelled.first
+    def ensure_can_destroy
+      if !backordered? && !on_hand?
+        errors.add(:state, :cannot_destroy, state: state)
+        return false
       end
 
-      def ensure_can_destroy
-        if !backordered? && !on_hand?
-          errors.add(:state, :cannot_destroy, state: self.state)
-          return false
-        end
-
-        unless shipment.pending?
-          errors.add(:base, :cannot_destroy_shipment_state, state: shipment.state)
-          return false
-        end
+      unless shipment.pending?
+        errors.add(:base, :cannot_destroy_shipment_state, state: shipment.state)
+        return false
       end
+    end
   end
 end

data/app/models/spree/item_adjustments.rb

@@ -49,7 +49,7 @@ module Spree
       #
       # We want to select the best promotion for the order, but the remainder
       # of the calculations here are done in the OrderUpdater instead.
-      return if Spree::Order === item
+      return if item.is_a?(Spree::Order)
 
       @item.promo_total = promo_total
 
@@ -67,13 +67,14 @@ module Spree
         included_tax_total: @item.included_tax_total,
         additional_tax_total: @item.additional_tax_total,
         adjustment_total: @item.adjustment_total,
-        updated_at: Time.current,
+        updated_at: Time.current
       ) if @item.changed?
 
       @item
     end
 
     private
+
     def adjustments
       # This is done intentionally to avoid loading the association. If the
       # association is loaded, the records may become stale due to code

data/app/models/spree/legacy_user.rb

@@ -8,11 +8,6 @@ module Spree
 
     self.table_name = 'spree_users'
 
-    # for url generation
-    def self.model_name
-      ActiveModel::Name.new(self, nil, "User")
-    end
-
     before_destroy :check_completed_orders
 
     def self.model_name
@@ -23,6 +18,7 @@ module Spree
     attr_accessor :password_confirmation
 
     private
+
     def check_completed_orders
       raise Spree::Core::DestroyWithOrdersError if orders.complete.present?
     end

data/app/models/spree/line_item.rb

@@ -1,6 +1,5 @@
 module Spree
   class LineItem < Spree::Base
-    before_validation :invalid_quantity_check
     belongs_to :order, class_name: "Spree::Order", inverse_of: :line_items, touch: true
     belongs_to :variant, -> { with_deleted }, class_name: "Spree::Variant", inverse_of: :line_items
     belongs_to :tax_category, class_name: "Spree::TaxCategory"
@@ -13,25 +12,24 @@ module Spree
     has_many :line_item_actions, dependent: :destroy
     has_many :actions, through: :line_item_actions
 
-    before_validation :copy_price
-    before_validation :copy_tax_category
+    before_validation :normalize_quantity
+    before_validation :set_required_attributes
 
     validates :variant, presence: true
     validates :quantity, numericality: {
       only_integer: true,
-      greater_than: -1,
-      message: Spree.t('validation.must_be_int')
+      greater_than: -1
     }
     validates :price, numericality: true
-
     validate :ensure_proper_currency
-    before_destroy :update_inventory
-    before_destroy :destroy_inventory_units
+
+    after_create :update_tax_charge
 
     after_save :update_inventory
     after_save :update_adjustments
 
-    after_create :update_tax_charge
+    before_destroy :update_inventory
+    before_destroy :destroy_inventory_units
 
     delegate :name, :description, :sku, :should_track_inventory?, to: :variant
     # @note This will return the product even if it has been deleted.
@@ -39,30 +37,11 @@ module Spree
     #   item, if there is one
     delegate :product, to: :variant
 
-
     attr_accessor :target_shipment
 
     self.whitelisted_ransackable_associations = ['variant']
     self.whitelisted_ransackable_attributes = ['variant_id']
 
-    # Sets this line item's price, cost price, and currency from this line
-    # item's variant if they are nil and a variant is present.
-    def copy_price
-      if variant
-        self.price = variant.price if price.nil?
-        self.cost_price = variant.cost_price if cost_price.nil?
-        self.currency = variant.currency if currency.nil?
-      end
-    end
-
-    # Sets this line item's tax category from this line item's variant if a
-    # variant is present.
-    def copy_tax_category
-      if variant
-        self.tax_category = variant.tax_category
-      end
-    end
-
     # @return [BigDecimal] the amount of this line item, which is the line
     #   item's price multiplied by its quantity.
     def amount
@@ -76,12 +55,6 @@ module Spree
       amount + promo_total
     end
 
-    # @return [Spree::Money] the amount of this line item, taking into
-    #   consideration line item promotions.
-    def discounted_money
-      Spree::Money.new(discounted_amount, { currency: currency })
-    end
-
     # @return [BigDecimal] the amount of this line item, taking into
     #   consideration all its adjustments.
     def final_amount
@@ -89,22 +62,32 @@ module Spree
     end
     alias total final_amount
 
-    # @return [Spree::Money] the price of this line item
-    def single_money
-      Spree::Money.new(price, { currency: currency })
+    # @return [BigDecimal] the amount of this line item before included tax
+    # @note just like `amount`, this does not include any additional tax
+    def pre_tax_amount
+      discounted_amount - included_tax_total
     end
-    alias single_display_amount single_money
 
-    # @return [Spree::Moeny] the amount of this line item
-    def money
-      Spree::Money.new(amount, { currency: currency })
-    end
-    alias display_total money
-    alias display_amount money
+    extend Spree::DisplayMoney
+    money_methods :amount, :discounted_amount, :final_amount, :pre_tax_amount, :price,
+                  :included_tax_total, :additional_tax_total
+    alias discounted_money display_discounted_amount
 
-    # Sets the quantity to zero if it is nil or less than zero.
-    def invalid_quantity_check
-      self.quantity = 0 if quantity.nil? || quantity < 0
+    # @return [Spree::Money] the price of this line item
+    alias money_price display_price
+    alias single_display_amount display_price
+    alias single_money display_price
+
+    # @return [Spree::Money] the amount of this line item
+    alias money display_amount
+    alias display_total display_amount
+
+    # Sets price and currency from a `Spree::Money` object
+    #
+    # @param [Spree::Money] money - the money object to obtain price and currency from
+    def money_price=(money)
+      self.price = money.to_d
+      self.currency = money.currency.iso_code
     end
 
     # @return [Boolean] true when it is possible to supply the required
@@ -119,59 +102,87 @@ module Spree
       !sufficient_stock?
     end
 
-    # Sets the options on the line item according to the order's currency or
-    # one passed in.
+    # Sets options on the line item.
+    #
+    # The options can be arbitrary attributes on the LineItem.
     #
     # @param options [Hash] options for this line item
-    def options=(options={})
+    def options=(options = {})
       return unless options.present?
+      assign_attributes options
+    end
 
-      opts = options.dup # we will be deleting from the hash, so leave the caller's copy intact
+    def pricing_options
+      Spree::Config.pricing_options_class.from_line_item(self)
+    end
 
-      currency = opts.delete(:currency) || order.try(:currency)
+    private
 
-      if currency
-        self.currency = currency
-        self.price    = variant.price_in(currency).amount +
-                        variant.price_modifier_amount_in(currency, opts)
-      else
-        self.price    = variant.price +
-                        variant.price_modifier_amount(opts)
-      end
+    # Sets the quantity to zero if it is nil or less than zero.
+    def normalize_quantity
+      self.quantity = 0 if quantity.nil? || quantity < 0
+    end
 
-      self.assign_attributes opts
+    # Sets tax category, price-related attributes from
+    # its variant if they are nil and a variant is present.
+    def set_required_attributes
+      return unless variant
+      self.tax_category ||= variant.tax_category
+      set_pricing_attributes
     end
 
-    private
-      def update_inventory
-        if (changed? || target_shipment.present?) && self.order.has_checkout_step?("delivery")
-          Spree::OrderInventory.new(self.order, self).verify(target_shipment)
-        end
-      end
+    # Set price, cost_price and currency. This method used to be called #copy_price, but actually
+    # did more than just setting the price, hence renamed to #set_pricing_attributes
+    def set_pricing_attributes
+      # If the legacy method #copy_price has been overridden, handle that gracefully
+      return handle_copy_price_override if respond_to?(:copy_price)
 
-      def destroy_inventory_units
-        inventory_units.destroy_all
-      end
+      self.currency ||= order.currency
+      self.cost_price ||= variant.cost_price
+      self.money_price = variant.price_for(pricing_options) if price.nil?
+      true
+    end
 
-      def update_adjustments
-        if quantity_changed?
-          update_tax_charge # Called to ensure pre_tax_amount is updated.
-          recalculate_adjustments
-        end
-      end
+    def handle_copy_price_override
+      copy_price
+      ActiveSupport::Deprecation.warn 'You have overridden Spree::LineItem#copy_price. ' \
+        'This method is now called Spree::LineItem#set_pricing_attributes. ' \
+        'Please adjust your override.',
+        caller
+    end
 
-      def recalculate_adjustments
-        Spree::ItemAdjustments.new(self).update
+    def update_inventory
+      if (changed? || target_shipment.present?) && order.has_checkout_step?("delivery")
+        Spree::OrderInventory.new(order, self).verify(target_shipment)
       end
+    end
+
+    def destroy_inventory_units
+      inventory_units.destroy_all
+    end
 
-      def update_tax_charge
-        Spree::TaxRate.adjust(order.tax_zone, [self])
+    def update_adjustments
+      if quantity_changed?
+        update_tax_charge # Called to ensure pre_tax_amount is updated.
+        recalculate_adjustments
       end
+    end
+
+    def recalculate_adjustments
+      Spree::ItemAdjustments.new(self).update
+    end
 
-      def ensure_proper_currency
-        unless currency == order.currency
-          errors.add(:currency, :must_match_order_currency)
-        end
+    def update_tax_charge
+      Spree::Tax::ItemAdjuster.new(self).adjust!
+    end
+
+    def ensure_proper_currency
+      if currency != order.currency
+        Spree::Deprecation.warn "The line items currency is different from it's order currency. " \
+                                "This behavior is not supported anymore and will be deleted soon.",
+                                caller
+        errors.add(:currency, :must_match_order_currency)
       end
+    end
   end
 end

data/app/models/spree/option_type.rb

@@ -21,7 +21,7 @@ module Spree
 
     default_scope -> { order(:position) }
 
-    accepts_nested_attributes_for :option_values, reject_if: lambda { |ov| ov[:name].blank? || ov[:presentation].blank? }, allow_destroy: true
+    accepts_nested_attributes_for :option_values, reject_if: lambda { |ov| ov[:name].blank? && ov[:presentation].blank? }, allow_destroy: true
 
     after_touch :touch_all_products
     after_save :touch_all_products

data/app/models/spree/option_value.rb

@@ -12,6 +12,8 @@ module Spree
     after_save :touch, if: :changed?
     after_touch :touch_all_variants
 
+    delegate :name, :presentation, to: :option_type, prefix: :option_type
+
     self.whitelisted_ransackable_attributes = ['presentation']
 
     # Updates the updated_at column on all the variants associated with this
@@ -23,7 +25,7 @@ module Spree
     # @return [String] a string representation of all option value and its
     #   option type
     def presentation_with_option_type
-      "#{self.option_type.presentation} - #{self.presentation}"
+      "#{option_type.presentation} - #{presentation}"
     end
   end
 end

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

@@ -110,7 +110,9 @@ module Spree
               # calls matter so that we do not process payments
               # until validations have passed
               before_transition to: :complete, do: :validate_line_item_availability, unless: :unreturned_exchange?
-              before_transition to: :complete, do: :ensure_available_shipping_rates
+              if states[:delivery]
+                before_transition to: :complete, do: :ensure_available_shipping_rates
+              end
               before_transition to: :complete, do: :ensure_promotions_eligible
               before_transition to: :complete, do: :ensure_line_item_variants_are_not_deleted
               before_transition to: :complete, do: :ensure_inventory_units, unless: :unreturned_exchange?
@@ -131,7 +133,6 @@ module Spree
                 order.logger.debug "Order #{order.number} transitioned from #{transition.from} to #{transition.to} via #{transition.event}"
               end
 
-
               after_failure do |order, transition|
                 order.logger.debug "Order #{order.number} halted transition on event #{transition.event} state #{transition.from}: #{order.errors.full_messages.join}"
               end
@@ -140,13 +141,13 @@ module Spree
             alias_method :save_state, :save
           end
 
-          def self.go_to_state(name, options={})
-            self.checkout_steps[name] = options
+          def self.go_to_state(name, options = {})
+            checkout_steps[name] = options
             previous_states.each do |state|
-              add_transition({from: state, to: name}.merge(options))
+              add_transition({ from: state, to: name }.merge(options))
             end
             if options[:if]
-              self.previous_states << name
+              previous_states << name
             else
               self.previous_states = [name]
             end
@@ -155,43 +156,43 @@ module Spree
           def self.insert_checkout_step(name, options = {})
             before = options.delete(:before)
             after = options.delete(:after) unless before
-            after = self.checkout_steps.keys.last unless before || after
+            after = checkout_steps.keys.last unless before || after
 
-            cloned_steps = self.checkout_steps.clone
-            cloned_removed_transitions = self.removed_transitions.clone
-            self.checkout_flow do
+            cloned_steps = checkout_steps.clone
+            cloned_removed_transitions = removed_transitions.clone
+            checkout_flow do
               cloned_steps.each_pair do |key, value|
-                self.go_to_state(name, options) if key == before
-                self.go_to_state(key, value)
-                self.go_to_state(name, options) if key == after
+                go_to_state(name, options) if key == before
+                go_to_state(key, value)
+                go_to_state(name, options) if key == after
               end
               cloned_removed_transitions.each do |transition|
-                self.remove_transition(transition)
+                remove_transition(transition)
               end
             end
           end
 
           def self.remove_checkout_step(name)
-            cloned_steps = self.checkout_steps.clone
-            cloned_removed_transitions = self.removed_transitions.clone
-            self.checkout_flow do
+            cloned_steps = checkout_steps.clone
+            cloned_removed_transitions = removed_transitions.clone
+            checkout_flow do
               cloned_steps.each_pair do |key, value|
-                self.go_to_state(key, value) unless key == name
+                go_to_state(key, value) unless key == name
               end
               cloned_removed_transitions.each do |transition|
-                self.remove_transition(transition)
+                remove_transition(transition)
               end
             end
           end
 
-          def self.remove_transition(options={})
-            self.removed_transitions << options
-            self.next_event_transitions.delete(find_transition(options))
+          def self.remove_transition(options = {})
+            removed_transitions << options
+            next_event_transitions.delete(find_transition(options))
           end
 
-          def self.find_transition(options={})
+          def self.find_transition(options = {})
             return nil if options.nil? || !options.include?(:from) || !options.include?(:to)
-            self.next_event_transitions.detect do |transition|
+            next_event_transitions.detect do |transition|
               transition[options[:from].to_sym] == options[:to].to_sym
             end
           end
@@ -205,11 +206,11 @@ module Spree
           end
 
           def self.checkout_step_names
-            self.checkout_steps.keys
+            checkout_steps.keys
           end
 
           def self.add_transition(options)
-            self.next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
+            next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
           end
 
           def checkout_steps
@@ -223,15 +224,15 @@ module Spree
           end
 
           def has_checkout_step?(step)
-            step.present? && self.checkout_steps.include?(step)
+            step.present? && checkout_steps.include?(step)
           end
 
           def passed_checkout_step?(step)
-            has_checkout_step?(step) && checkout_step_index(step) < checkout_step_index(self.state)
+            has_checkout_step?(step) && checkout_step_index(step) < checkout_step_index(state)
           end
 
           def checkout_step_index(step)
-            self.checkout_steps.index(step).to_i
+            checkout_steps.index(step).to_i
           end
 
           def self.removed_transitions
@@ -243,7 +244,7 @@ module Spree
             checkout_step_index(state) > checkout_step_index(self.state)
           end
 
-          define_callbacks :updating_from_params, terminator: ->(target, result) { result == false }
+          define_callbacks :updating_from_params, terminator: ->(_target, result) { result == false }
 
           set_callback :updating_from_params, :before, :update_params_payment_source
 
@@ -253,7 +254,7 @@ module Spree
             success = false
             @updating_params = params
             run_callbacks :updating_from_params do
-              attributes = @updating_params[:order] ? @updating_params[:order].permit(permitted_params).delete_if { |k,v| v.nil? } : {}
+              attributes = @updating_params[:order] ? @updating_params[:order].permit(permitted_params).delete_if { |_k, v| v.nil? } : {}
 
               # Set existing card after setting permitted parameters because
               # rails would slice parameters containg ruby objects, apparently
@@ -261,7 +262,7 @@ module Spree
 
               if existing_card_id.present?
                 credit_card = CreditCard.find existing_card_id
-                if credit_card.user_id != self.user_id || credit_card.user_id.blank?
+                if credit_card.user_id != user_id || credit_card.user_id.blank?
                   raise Core::GatewayError.new Spree.t(:invalid_credit_card)
                 end
 
@@ -293,35 +294,35 @@ module Spree
           end
 
           def assign_default_addresses!
-            if self.user
+            if user
               # this is one of 2 places still using User#bill_address
               self.bill_address ||= user.bill_address if user.bill_address.try!(:valid?)
               # Skip setting ship address if order doesn't have a delivery checkout step
               # to avoid triggering validations on shipping address
-              self.ship_address ||= user.ship_address if user.ship_address.try!(:valid?) && self.checkout_steps.include?("delivery")
+              self.ship_address ||= user.ship_address if user.ship_address.try!(:valid?) && checkout_steps.include?("delivery")
             end
           end
 
           def persist_user_address!
-            if !self.temporary_address && self.user && self.user.respond_to?(:persist_order_address) && self.bill_address_id
-              self.user.persist_order_address(self)
+            if !temporary_address && user && user.respond_to?(:persist_order_address) && bill_address_id
+              user.persist_order_address(self)
             end
           end
 
           def persist_user_credit_card
-            if !self.temporary_credit_card && self.user_id && self.valid_credit_cards.present?
-              default_cc = self.valid_credit_cards.first
-              # TODO target for refactoring -- why is order checkout responsible for the user -> credit_card relationship?
-              default_cc.user_id = self.user_id
+            if !temporary_credit_card && user_id && valid_credit_cards.present?
+              default_cc = valid_credit_cards.first
+              # TODO: target for refactoring -- why is order checkout responsible for the user -> credit_card relationship?
+              default_cc.user_id = user_id
               default_cc.default = true
               default_cc.save
             end
           end
 
           def assign_default_credit_card
-            if self.payments.from_credit_card.count == 0 && self.user && self.user.default_credit_card.try(:valid?)
-              cc = self.user.default_credit_card
-              self.payments.create!(payment_method_id: cc.payment_method_id, source: cc)
+            if payments.from_credit_card.count == 0 && user && user.default_credit_card.try(:valid?)
+              cc = user.default_credit_card
+              payments.create!(payment_method_id: cc.payment_method_id, source: cc)
               # this is one of 2 places still using User#bill_address
               self.bill_address ||= user.default_credit_card.address || user.bill_address
             end
@@ -359,7 +360,7 @@ module Spree
           def update_params_payment_source
             if @updating_params[:order] && (@updating_params[:order][:payments_attributes] || @updating_params[:order][:existing_card])
               @updating_params[:order][:payments_attributes] ||= [{}]
-              @updating_params[:order][:payments_attributes].first[:amount] = self.total
+              @updating_params[:order][:payments_attributes].first[:amount] = total
             end
           end
         end