solidus_core 2.10.5 → 3.0.8

data/lib/spree/core/controller_helpers/payment_parameters.rb

@@ -64,60 +64,6 @@ module Spree
       params
     end
 
-    # This method handles the awkwardness of how the html forms are currently
-    # set up for frontend.
-    #
-    # This method expects a params hash in the format of:
-    #
-    #  {
-    #    order: {
-    #      existing_card: '123',
-    #      ...other params...
-    #    },
-    #    cvc_confirm: '456', # optional
-    #    ...other params...
-    #  }
-    #
-    # And this method modifies the params into the format of:
-    #
-    #  {
-    #    order: {
-    #      payments_attributes: [
-    #        {
-    #          source_attributes: {
-    #            existing_card_id: '123',
-    #            verification_value: '456',
-    #          },
-    #        },
-    #      ]
-    #      ...other params...
-    #    },
-    #    ...other params...
-    #  }
-    #
-    def move_existing_card_into_payments_attributes(params)
-      return params if params[:order].blank?
-
-      card_id = params[:order][:existing_card].presence
-      cvc_confirm = params[:cvc_confirm].presence
-
-      return params if card_id.nil?
-
-      params[:order][:payments_attributes] = [
-        {
-          source_attributes: {
-            existing_card_id: card_id,
-            verification_value: cvc_confirm
-          }
-        }
-      ]
-
-      params[:order].delete(:existing_card)
-      params.delete(:cvc_confirm)
-
-      params
-    end
-
     # This method handles the awkwardness of how the html forms are currently
     # set up for frontend.
     #

data/lib/spree/core/controller_helpers/pricing.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spree/deprecation'
-
 module Spree
   module Core
     module ControllerHelpers
@@ -9,18 +7,12 @@ module Spree
         extend ActiveSupport::Concern
 
         included do
-          helper_method :current_currency
           helper_method :current_pricing_options
         end
 
         def current_pricing_options
           Spree::Config.pricing_options_class.from_context(self)
         end
-
-        def current_currency
-          current_pricing_options.currency
-        end
-        deprecate current_currency: :current_pricing_options, deprecator: Spree::Deprecation
       end
     end
   end

data/lib/spree/core/controller_helpers/strong_parameters.rb

@@ -30,10 +30,6 @@ module Spree
           ]
         end
 
-        def permitted_checkout_attributes
-          permitted_attributes.checkout_attributes
-        end
-
         def permitted_checkout_address_attributes
           permitted_attributes.checkout_address_attributes
         end

data/lib/spree/core/engine.rb

@@ -15,6 +15,12 @@ module Spree
         generator.test_framework :rspec
       end
 
+      if ActiveRecord.respond_to?(:yaml_column_permitted_classes) || ActiveRecord::Base.respond_to?(:yaml_column_permitted_classes)
+        config.active_record.yaml_column_permitted_classes ||= []
+        config.active_record.yaml_column_permitted_classes |=
+          [Symbol, BigDecimal, ActiveSupport::HashWithIndifferentAccess]
+      end
+
       initializer "spree.environment", before: :load_config_initializers do |app|
         app.config.spree = Spree::Config.environment
       end
@@ -47,26 +53,35 @@ module Spree
       # Setup Event Subscribers
       initializer 'spree.core.initialize_subscribers' do |app|
         app.reloader.to_prepare do
-          Spree::Event.subscribers.each(&:subscribe!)
+          Spree::Event.activate_autoloadable_subscribers
         end
 
         app.reloader.before_class_unload do
-          Spree::Event.subscribers.each(&:unsubscribe!)
+          Spree::Event.deactivate_all_subscribers
         end
       end
 
-      # Load in mailer previews for apps to use in development.
-      # We need to make sure we call `Preview.all` before requiring our
-      # previews, otherwise any previews the app attempts to add need to be
-      # manually required.
-      if Rails.env.development?
-        initializer "spree.mailer_previews" do
+      config.after_initialize do
+        # Load in mailer previews for apps to use in development.
+        # We need to make sure we call `Preview.all` before requiring our
+        # previews, otherwise any previews the app attempts to add need to be
+        # manually required.
+        if Rails.env.development? || Rails.env.test?
           ActionMailer::Preview.all
+
           Dir[root.join("lib/spree/mailer_previews/**/*_preview.rb")].each do |file|
             require_dependency file
           end
         end
       end
+
+      config.after_initialize do
+        if defined?(Spree::Auth::Engine) &&
+            Gem::Version.new(Spree::Auth::VERSION) < Gem::Version.new('2.5.4') &&
+            defined?(Spree::UsersController)
+          Spree::UsersController.protect_from_forgery with: :exception
+        end
+      end
     end
   end
 end

data/lib/spree/core/environment_extension.rb

@@ -22,15 +22,6 @@ module Spree
           end
         end
       end
-
-      def add_class(name)
-        Spree::Deprecation.warn(
-          'This method is deprecated. ' \
-          "Please use `#{self.class}.add_class_set(#{name.inspect})` instead.",
-          caller,
-        )
-        singleton_class.send(:add_class_set, name)
-      end
     end
   end
 end

data/lib/spree/core/importer/order.rb

@@ -56,7 +56,9 @@ module Spree
           shipments_hash.each do |target|
             shipment = Shipment.new
             shipment.tracking       = target[:tracking]
-            shipment.stock_location = Spree::StockLocation.find_by(admin_name: target[:stock_location]) || Spree::StockLocation.find_by!(name: target[:stock_location])
+            shipment.stock_location = Spree::StockLocation.find_by(id: target[:stock_location_id]) ||
+              Spree::StockLocation.find_by(admin_name: target[:stock_location]) ||
+              Spree::StockLocation.find_by!(name: target[:stock_location])
 
             inventory_units = target[:inventory_units] || []
             inventory_units.each do |inventory_unit|
@@ -98,19 +100,31 @@ module Spree
 
         def self.create_line_items_from_params(line_items_hash, order)
           return {} unless line_items_hash
-          line_items_hash.each_key do |key|
-            extra_params = line_items_hash[key].except(:variant_id, :quantity, :sku)
-            line_item = ensure_variant_id_from_params(line_items_hash[key])
-            line_item = order.contents.add(Spree::Variant.find(line_item[:variant_id]), line_item[:quantity])
-            # Raise any errors with saving to prevent import succeeding with line items failing silently.
-            if extra_params.present?
-              line_item.update!(extra_params)
-            else
-              line_item.save!
+
+          case line_items_hash
+          when Hash
+            line_items_hash.each_key do |key|
+              create_line_item(line_items_hash[key], order)
+            end
+          when Array
+            line_items_hash.each do |line_item_hash|
+              create_line_item(line_item_hash, order)
             end
           end
         end
 
+        def self.create_line_item(line_item_hash, order)
+          extra_params = line_item_hash.except(:variant_id, :quantity, :sku)
+          line_item = ensure_variant_id_from_params(line_item_hash)
+          line_item = order.contents.add(Spree::Variant.find(line_item[:variant_id]), line_item[:quantity])
+          # Raise any errors with saving to prevent import succeeding with line items failing silently.
+          if extra_params.present?
+            line_item.update!(extra_params)
+          else
+            line_item.save!
+          end
+        end
+
         def self.create_adjustments_from_params(adjustments, order)
           return [] unless adjustments
           adjustments.each do |target|

data/lib/spree/core/permalinks.rb

@@ -9,7 +9,7 @@ module Spree
         class_attribute :permalink_options
       end
 
-      module ClassMethods
+      class_methods do
         def make_permalink(options = {})
           options[:field] ||= :permalink
           self.permalink_options = options
@@ -63,5 +63,3 @@ module Spree
     end
   end
 end
-
-ActiveRecord::Base.send :include, Spree::Core::Permalinks

data/lib/spree/core/product_filters.rb

@@ -60,6 +60,7 @@ module Spree
         conds.each do |new_scope|
           scope = scope.or(new_scope)
         end
+
         Spree::Product.joins(master: :default_price).where(scope)
       end
 
@@ -70,9 +71,9 @@ module Spree
       def self.price_filter
         value = Spree::Price.arel_table
         conds = [[I18n.t('spree.under_price', price: format_price(10)), value[:amount].lteq(10)],
-                 ["#{format_price(10)} - #{format_price(15)}", value[:amount].in(10..15)],
-                 ["#{format_price(15)} - #{format_price(18)}", value[:amount].in(15..18)],
-                 ["#{format_price(18)} - #{format_price(20)}", value[:amount].in(18..20)],
+                 ["#{format_price(10)} - #{format_price(15)}", value[:amount].between(10..15)],
+                 ["#{format_price(15)} - #{format_price(18)}", value[:amount].between(15..18)],
+                 ["#{format_price(18)} - #{format_price(20)}", value[:amount].between(18..20)],
                  [I18n.t('spree.or_over_price', price: format_price(20)), value[:amount].gteq(20)]]
         {
           name:   I18n.t('spree.price_range'),
@@ -107,7 +108,7 @@ module Spree
         brand_property = Spree::Property.find_by(name: 'brand')
         brands = brand_property ? Spree::ProductProperty.where(property_id: brand_property.id).pluck(:value).uniq.map(&:to_s) : []
         pp = Spree::ProductProperty.arel_table
-        conds = Hash[*brands.map { |brand| [brand, pp[:value].eq(brand)] }.flatten]
+        conds = Hash[*brands.flat_map { |brand| [brand, pp[:value].eq(brand)] }]
         {
           name:   'Brands',
           scope:  :brand_any,
@@ -152,46 +153,6 @@ module Spree
           labels: brands.sort.map { |key| [key, key] }
         }
       end
-
-      # Provide filtering on the immediate children of a taxon
-      #
-      # This doesn't fit the pattern of the examples above, so there's a few changes.
-      # Firstly, it uses an existing scope which was not built for filtering - and so
-      # has no need of a conditions mapping, and secondly, it has a mapping of name
-      # to the argument type expected by the other scope.
-      #
-      # This technique is useful for filtering on objects (by passing ids) or with a
-      # scope that can be used directly (eg. testing only ever on a single property).
-      #
-      # This scope selects products in any of the active taxons or their children.
-      #
-      def self.taxons_below(taxon)
-        Spree::Deprecation.warn "taxons_below is deprecated in solidus_core. Please add it to your own application to continue using it."
-        return Spree::Core::ProductFilters.all_taxons if taxon.nil?
-        {
-          name:   'Taxons under ' + taxon.name,
-          scope:  :taxons_id_in_tree_any,
-          labels: taxon.children.sort_by(&:position).map { |element| [element.name, element.id] },
-          conds:  nil
-        }
-      end
-
-      # Filtering by the list of all taxons
-      #
-      # Similar idea as above, but we don't want the descendants' products, hence
-      # it uses one of the auto-generated scopes from Ransack.
-      #
-      # idea: expand the format to allow nesting of labels?
-      def self.all_taxons
-        Spree::Deprecation.warn "all_taxons is deprecated in solidus_core. Please add it to your own application to continue using it."
-        taxons = Spree::Taxonomy.all.map { |element| [element.root] + element.root.descendants }.flatten
-        {
-          name:   'All taxons',
-          scope:  :taxons_id_equals_any,
-          labels: taxons.sort_by(&:name).map { |element| [element.name, element.id] },
-          conds:  nil # not needed
-        }
-      end
     end
   end
 end

data/lib/spree/core/role_configuration.rb

@@ -31,20 +31,6 @@ module Spree
 
     attr_accessor :roles
 
-    class << self
-      def instance
-        Spree::Deprecation.warn "Spree::RoleConfiguration.instance is DEPRECATED use Spree::Config.roles instead"
-        Spree::Config.roles
-      end
-
-      # Yields the instance of the singleton, used for configuration
-      # @yieldparam instance [Spree::RoleConfiguration]
-      def configure
-        Spree::Deprecation.warn "Spree::RoleConfiguration.configure is deprecated. Call Spree::Config.roles.assign_permissions instead"
-        yield(Spree::Config.roles)
-      end
-    end
-
     # Given a CanCan::Ability, and a user, determine what permissions sets can
     # be activated on the ability, then activate them.
     #

data/lib/spree/core/search/base.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spree/deprecation'
-
 module Spree
   module Core
     module Search
@@ -16,17 +14,6 @@ module Spree
           prepare(params)
         end
 
-        def current_currency=(currency)
-          self.pricing_options = Spree::Config.pricing_options_class.new(
-            pricing_options.desired_attributes.merge(currency: currency)
-          )
-        end
-
-        def current_currency
-          pricing_options.currency
-        end
-        deprecate :current_currency, :current_currency=, deprecator: Spree::Deprecation
-
         def retrieve_products
           @products = get_base_scope
           curr_page = @properties[:page] || 1
@@ -37,19 +24,6 @@ module Spree
           @products = @products.page(curr_page).per(@properties[:per_page])
         end
 
-        def method_missing(name)
-          if @properties.key?(name)
-            Spree::Deprecation.warn "Accessing Searcher's #{name} property using #{self.class.name}##{name} is deprecated without replacement"
-            @properties[name]
-          else
-            super
-          end
-        end
-
-        def respond_to_missing?(name)
-          @properties.key?(name) || super(name)
-        end
-
         protected
 
         def get_base_scope

data/lib/spree/core/state_machines/order.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      module Order
+        def self.included(klass)
+          klass.extend ClassMethods
+        end
+
+        module ClassMethods
+          attr_accessor :previous_states
+          attr_writer :next_event_transitions
+          attr_writer :checkout_steps
+          attr_writer :removed_transitions
+
+          def checkout_flow(&block)
+            if block_given?
+              @checkout_flow = block
+              define_state_machine!
+            else
+              @checkout_flow
+            end
+          end
+
+          def define_state_machine!
+            self.checkout_steps = {}
+            self.next_event_transitions = []
+            self.previous_states = [:cart]
+            self.removed_transitions = []
+
+            # Build the checkout flow using the checkout_flow defined either
+            # within the Order class, or a decorator for that class.
+            #
+            # This method may be called multiple times depending on if the
+            # checkout_flow is re-defined in a decorator or not.
+            instance_eval(&checkout_flow)
+
+            klass = self
+
+            # To avoid multiple occurrences of the same transition being defined
+            # On first definition, state_machines will not be defined
+            state_machines.clear if respond_to?(:state_machines)
+            state_machine :state, initial: :cart, use_transactions: false do
+              klass.next_event_transitions.each { |state| transition(state.merge(on: :next)) }
+
+              # Persist the state on the order
+              after_transition do |order, transition|
+                order.state = order.state
+                order.state_changes.create(
+                  previous_state: transition.from,
+                  next_state:     transition.to,
+                  name:           'order',
+                  user_id:        order.user_id
+                )
+                order.save
+              end
+
+              event :cancel do
+                transition to: :canceled, if: :allow_cancel?, from: :complete
+              end
+
+              event :return do
+                transition to: :returned, from: [:complete, :awaiting_return], if: :all_inventory_units_returned?
+              end
+
+              event :resume do
+                transition to: :resumed, from: :canceled, if: :canceled?
+              end
+
+              event :authorize_return do
+                transition to: :awaiting_return, from: :complete
+              end
+
+              event :complete do
+                transition to: :complete, from: :confirm
+              end
+
+              if states[:payment]
+                event :payment_failed do
+                  transition to: :payment, from: :confirm
+                end
+
+                after_transition to: :complete, do: :add_payment_sources_to_wallet
+                before_transition to: :payment, do: :add_default_payment_from_wallet
+                before_transition to: :payment, do: :ensure_billing_address
+
+                before_transition to: :confirm, do: :add_store_credit_payments
+
+                # see also process_payments_before_complete below which needs to
+                # be added in the correct sequence.
+              end
+
+              before_transition from: :cart, do: :ensure_line_items_present
+
+              if states[:address]
+                before_transition to: :address, do: :assign_default_user_addresses
+                before_transition from: :address, do: :persist_user_address!
+              end
+
+              if states[:delivery]
+                before_transition to: :delivery, do: :ensure_shipping_address
+                before_transition to: :delivery, do: :create_proposed_shipments
+                before_transition to: :delivery, do: :ensure_available_shipping_rates
+                before_transition from: :delivery, do: :apply_shipping_promotions
+              end
+
+              before_transition to: :resumed, do: :ensure_line_item_variants_are_not_deleted
+              before_transition to: :resumed, do: :validate_line_item_availability
+
+              # Sequence of before_transition to: :complete
+              # calls matter so that we do not process payments
+              # until validations have passed
+              before_transition to: :complete, do: :validate_line_item_availability
+              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
+              if states[:payment]
+                before_transition to: :complete, do: :process_payments_before_complete
+              end
+
+              after_transition to: :complete, do: :finalize!
+              after_transition to: :resumed,  do: :after_resume
+              after_transition to: :canceled, do: :after_cancel
+
+              after_transition from: any - :cart, to: any - [:confirm, :complete] do |order|
+                order.recalculate
+              end
+
+              after_transition do |order, transition|
+                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
+            end
+          end
+
+          def go_to_state(name, options = {})
+            checkout_steps[name] = options
+            previous_states.each do |state|
+              add_transition({ from: state, to: name }.merge(options))
+            end
+            if options[:if]
+              previous_states << name
+            else
+              self.previous_states = [name]
+            end
+          end
+
+          def insert_checkout_step(name, options = {})
+            before = options.delete(:before)
+            after = options.delete(:after) unless before
+            after = checkout_steps.keys.last unless before || after
+
+            cloned_steps = checkout_steps.clone
+            cloned_removed_transitions = removed_transitions.clone
+            checkout_flow do
+              cloned_steps.each_pair do |key, value|
+                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|
+                remove_transition(transition)
+              end
+            end
+          end
+
+          def remove_checkout_step(name)
+            cloned_steps = checkout_steps.clone
+            cloned_removed_transitions = removed_transitions.clone
+            checkout_flow do
+              cloned_steps.each_pair do |key, value|
+                go_to_state(key, value) unless key == name
+              end
+              cloned_removed_transitions.each do |transition|
+                remove_transition(transition)
+              end
+            end
+          end
+
+          def remove_transition(options = {})
+            removed_transitions << options
+            next_event_transitions.delete(find_transition(options))
+          end
+
+          def find_transition(options = {})
+            return nil if options.nil? || !options.include?(:from) || !options.include?(:to)
+
+            next_event_transitions.detect do |transition|
+              transition[options[:from].to_sym] == options[:to].to_sym
+            end
+          end
+
+          def next_event_transitions
+            @next_event_transitions ||= []
+          end
+
+          def checkout_steps
+            @checkout_steps ||= {}
+          end
+
+          def checkout_step_names
+            checkout_steps.keys
+          end
+
+          def add_transition(options)
+            next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
+          end
+
+          def removed_transitions
+            @removed_transitions ||= []
+          end
+        end
+
+        def checkout_steps
+          steps = self.class.checkout_steps.each_with_object([]) { |(step, options), checkout_steps|
+            next if options.include?(:if) && !options[:if].call(self)
+
+            checkout_steps << step
+          }.map(&:to_s)
+          # Ensure there is always a complete step
+          steps << "complete" unless steps.include?("complete")
+          steps
+        end
+
+        def has_checkout_step?(step)
+          step.present? && checkout_steps.include?(step)
+        end
+
+        def passed_checkout_step?(step)
+          has_checkout_step?(step) && checkout_step_index(step) < checkout_step_index(state)
+        end
+
+        def checkout_step_index(step)
+          checkout_steps.index(step).to_i
+        end
+
+        def can_go_to_state?(state)
+          return false unless has_checkout_step?(self.state) && has_checkout_step?(state)
+
+          checkout_step_index(state) > checkout_step_index(self.state)
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/state_machines/return_item/reception_status.rb

@@ -19,8 +19,8 @@ module Spree
 
           included do
             state_machine :reception_status, initial: :awaiting do
-              after_transition to: ::Spree::ReturnItem::COMPLETED_RECEPTION_STATUSES,  do: :attempt_accept
-              after_transition to: ::Spree::ReturnItem::COMPLETED_RECEPTION_STATUSES,  do: :check_unexchange
+              after_transition to: ::Spree::ReturnItem::COMPLETED_RECEPTION_STATUSES, do: :attempt_accept, if: :can_attempt_accept?
+              after_transition to: ::Spree::ReturnItem::COMPLETED_RECEPTION_STATUSES, do: :check_unexchange
               after_transition to: :received, do: :process_inventory_unit!
 
               event(:cancel) { transition to: :cancelled, from: :awaiting }

data/lib/spree/core/state_machines.rb

@@ -9,7 +9,8 @@ module Spree
                   :return_item_reception,
                   :payment,
                   :inventory_unit,
-                  :shipment
+                  :shipment,
+                  :order
 
       def return_authorization
         @return_authorization ||= begin
@@ -65,6 +66,15 @@ module Spree
         @shipment.constantize
       end
 
+      def order
+        @order ||= begin
+          require 'spree/core/state_machines/order'
+          'Spree::Core::StateMachines::Order'
+        end
+
+        @order.constantize
+      end
+
       def reimbursement
         @reimbursement ||= begin
           require 'spree/core/state_machines/reimbursement'