solidus_core 2.9.0 → 2.10.0

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      # Payments' state machine
+      #
+      # for each event the following instance methods are dynamically implemented:
+      #   #<event_name>
+      #   #<event_name>!
+      #   #can_<event_name>?
+      #
+      # for each state the following instance methods are implemented:
+      #   #<state_name>?
+      #
+      module Payment
+        extend ActiveSupport::Concern
+
+        included do
+          state_machine initial: :checkout do
+            # With card payments, happens before purchase or authorization happens
+            #
+            # Setting it after creating a profile and authorizing a full amount will
+            # prevent the payment from being authorized again once Order transitions
+            # to complete
+            event :started_processing do
+              transition from: [:checkout, :pending, :completed, :processing], to: :processing
+            end
+            # When processing during checkout fails
+            event :failure do
+              transition from: [:pending, :processing], to: :failed
+            end
+            # With card payments this represents authorizing the payment
+            event :pend do
+              transition from: [:checkout, :processing], to: :pending
+            end
+            # With card payments this represents completing a purchase or capture transaction
+            event :complete do
+              transition from: [:processing, :pending, :checkout], to: :completed
+            end
+            event :void do
+              transition from: [:pending, :processing, :completed, :checkout], to: :void
+            end
+            # when the card brand isnt supported
+            event :invalidate do
+              transition from: [:checkout], to: :invalid
+            end
+
+            after_transition do |payment, transition|
+              payment.state_changes.create!(
+                previous_state: transition.from,
+                next_state:     transition.to,
+                name:           'payment'
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      # Reimbursement' state machine
+      #
+      # for each event the following instance methods are dynamically implemented:
+      #   #<event_name>
+      #   #<event_name>!
+      #   #can_<event_name>?
+      #
+      # for each state the following instance methods are implemented:
+      #   #<state_name>?
+      #
+      module Reimbursement
+        extend ActiveSupport::Concern
+
+        included do
+          state_machine :reimbursement_status, initial: :pending do
+            event :errored do
+              transition to: :errored, from: [:pending, :errored]
+            end
+
+            event :reimbursed do
+              transition to: :reimbursed, from: [:pending, :errored]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      # Return Authorizations' state machine
+      #
+      # for each event the following instance methods are dynamically implemented:
+      #   #<event_name>
+      #   #<event_name>!
+      #   #can_<event_name>?
+      #
+      # for each state the following instance methods are implemented:
+      #   #<state_name>?
+      #
+      module ReturnAuthorization
+        extend ActiveSupport::Concern
+
+        included do
+          state_machine initial: :authorized do
+            before_transition to: :canceled, do: :cancel_return_items
+
+            event :cancel do
+              transition to: :canceled, from: :authorized,
+                if: lambda { |return_authorization| return_authorization.can_cancel_return_items? }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      module ReturnItem
+        # Return Items' acceptance status state machine
+        #
+        # for each event the following instance methods are dynamically implemented:
+        #   #<event_name>
+        #   #<event_name>!
+        #   #can_<event_name>?
+        #
+        # for each state the following instance methods are implemented:
+        #   #<state_name>?
+        #
+        module AcceptanceStatus
+          extend ActiveSupport::Concern
+
+          included do
+            state_machine :acceptance_status, initial: :pending do
+              event :attempt_accept do
+                transition to: :accepted, from: :accepted
+                transition to: :accepted, from: :pending, if: ->(return_item) { return_item.eligible_for_return? }
+                transition to: :manual_intervention_required, from: :pending, if: ->(return_item) { return_item.requires_manual_intervention? }
+                transition to: :rejected, from: :pending
+              end
+
+              # bypasses eligibility checks
+              event :accept do
+                transition to: :accepted, from: [:accepted, :pending, :manual_intervention_required]
+              end
+
+              # bypasses eligibility checks
+              event :reject do
+                transition to: :rejected, from: [:accepted, :pending, :manual_intervention_required]
+              end
+
+              # bypasses eligibility checks
+              event :require_manual_intervention do
+                transition to: :manual_intervention_required, from: [:accepted, :pending, :manual_intervention_required]
+              end
+
+              after_transition any => any, do: :persist_acceptance_status_errors
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      module ReturnItem
+        # Return Items' reception status state machine
+        #
+        # for each event the following instance methods are dynamically implemented:
+        #   #<event_name>
+        #   #<event_name>!
+        #   #can_<event_name>?
+        #
+        # for each state the following instance methods are implemented:
+        #   #<state_name>?
+        #
+        module ReceptionStatus
+          extend ActiveSupport::Concern
+
+          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: :received, do: :process_inventory_unit!
+
+              event(:cancel) { transition to: :cancelled, from: :awaiting }
+
+              event(:receive) { transition to: :received, from: ::Spree::ReturnItem::INTERMEDIATE_RECEPTION_STATUSES + [:awaiting] }
+              event(:unexchange) { transition to: :unexchanged, from: [:awaiting] }
+              event(:give) { transition to: :given_to_customer, from: :awaiting }
+              event(:lost) { transition to: :lost_in_transit, from: :awaiting }
+              event(:wrong_item_shipped) { transition to: :shipped_wrong_item, from: :awaiting }
+              event(:short_shipped) { transition to: :short_shipped, from: :awaiting }
+              event(:in_transit) { transition to: :in_transit, from: :awaiting }
+              event(:expired) { transition to: :expired, from: :awaiting }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      # Shipments' state machine
+      #
+      # for each event the following instance methods are dynamically implemented:
+      #   #<event_name>
+      #   #<event_name>!
+      #   #can_<event_name>?
+      #
+      # for each state the following instance methods are implemented:
+      #   #<state_name>?
+      #
+      module Shipment
+        extend ActiveSupport::Concern
+
+        included do
+          state_machine initial: :pending, use_transactions: false do
+            event :ready do
+              transition from: :pending, to: :shipped, if: :can_transition_from_pending_to_shipped?
+              transition from: :pending, to: :ready, if: :can_transition_from_pending_to_ready?
+            end
+
+            event :pend do
+              transition from: :ready, to: :pending
+            end
+
+            event :ship do
+              transition from: [:ready, :canceled], to: :shipped
+            end
+            after_transition to: :shipped, do: :after_ship
+
+            event :cancel do
+              transition to: :canceled, from: [:pending, :ready]
+            end
+            after_transition to: :canceled, do: :after_cancel
+
+            event :resume do
+              transition from: :canceled, to: :ready, if: :can_transition_from_canceled_to_ready?
+              transition from: :canceled, to: :pending
+            end
+            after_transition from: :canceled, to: [:pending, :ready, :shipped], do: :after_resume
+
+            after_transition do |shipment, transition|
+              shipment.state_changes.create!(
+                previous_state: transition.from,
+                next_state:     transition.to,
+                name:           'shipment'
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/state_machines.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      attr_writer :reimbursement,
+                  :return_authorization,
+                  :return_item_acceptance,
+                  :return_item_reception,
+                  :payment,
+                  :inventory_unit,
+                  :shipment
+
+      def return_authorization
+        @return_authorization ||= begin
+          require 'spree/core/state_machines/return_authorization'
+          'Spree::Core::StateMachines::ReturnAuthorization'
+        end
+
+        @return_authorization.constantize
+      end
+
+      def return_item_reception
+        @return_item_reception_status ||= begin
+          require 'spree/core/state_machines/return_item/reception_status'
+          'Spree::Core::StateMachines::ReturnItem::ReceptionStatus'
+        end
+
+        @return_item_reception_status.constantize
+      end
+
+      def return_item_acceptance
+        @return_item_acceptance_status ||= begin
+          require 'spree/core/state_machines/return_item/acceptance_status'
+          'Spree::Core::StateMachines::ReturnItem::AcceptanceStatus'
+        end
+
+        @return_item_acceptance_status.constantize
+      end
+
+      def payment
+        @payment ||= begin
+          require 'spree/core/state_machines/payment'
+          'Spree::Core::StateMachines::Payment'
+        end
+
+        @payment.constantize
+      end
+
+      def inventory_unit
+        @inventory_unit ||= begin
+          require 'spree/core/state_machines/inventory_unit'
+          'Spree::Core::StateMachines::InventoryUnit'
+        end
+
+        @inventory_unit.constantize
+      end
+
+      def shipment
+        @shipment ||= begin
+          require 'spree/core/state_machines/shipment'
+          'Spree::Core::StateMachines::Shipment'
+        end
+
+        @shipment.constantize
+      end
+
+      def reimbursement
+        @reimbursement ||= begin
+          require 'spree/core/state_machines/reimbursement'
+          'Spree::Core::StateMachines::Reimbursement'
+        end
+
+        @reimbursement.constantize
+      end
+    end
+  end
+end

data/lib/spree/core/stock_configuration.rb

@@ -5,6 +5,7 @@ module Spree
     class StockConfiguration
       attr_writer :coordinator_class
       attr_writer :estimator_class
+      attr_writer :location_filter_class
       attr_writer :location_sorter_class
       attr_writer :allocator_class
 

data/lib/spree/core/validators/email.rb

@@ -15,16 +15,9 @@ module Spree
     EMAIL_REGEXP = /\A([^@\.]|[^@\.]([^@\s]*)[^@\.])@([^@\s]+\.)+[^@\s]+\z/
 
     def validate_each(record, attribute, value)
-      unless value =~ EMAIL_REGEXP
+      unless EMAIL_REGEXP.match? value
         record.errors.add(attribute, :invalid, { value: value }.merge!(options))
       end
     end
   end
 end
-
-# @private
-EmailValidator = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
-  'EmailValidator',
-  'Spree::EmailValidator',
-  message: "EmailValidator is deprecated! Use Spree::EmailValidator instead.\nChange `validates :email, email: true` to `validates :email, 'spree/email' => true`\n"
-)

data/lib/spree/core/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Spree
-  VERSION = "2.9.0"
+  VERSION = "2.10.0"
 
   def self.solidus_version
     VERSION

data/lib/spree/core.rb

@@ -53,6 +53,17 @@ module Spree
   end
 end
 
+if Gem::Version.new(Rails.version) < Gem::Version.new('5.2')
+  warn <<~HEREDOC
+    Rails 5.1 (EOL) is deprecated and will not be supported anymore from the next Solidus version.
+    Please, upgrade to a more recent Rails version.
+
+    Read more on upgrading from Rails 5.1 to Rails 5.2 here:
+    https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-5-1-to-rails-5-2
+
+  HEREDOC
+end
+
 require 'spree/core/version'
 
 require 'spree/core/active_merchant_dependencies'
@@ -85,6 +96,7 @@ require 'spree/core/controller_helpers/search'
 require 'spree/core/controller_helpers/store'
 require 'spree/core/controller_helpers/strong_parameters'
 require 'spree/core/role_configuration'
+require 'spree/core/state_machines'
 require 'spree/core/stock_configuration'
 require 'spree/core/validators/email'
 require 'spree/permission_sets'

data/lib/spree/money.rb

@@ -82,9 +82,9 @@ module Spree
       # Maintain compatibility by checking html option renamed to html_wrap.
       if options[:html] || options[:html] == false
         Spree::Deprecation.warn <<-WARN.squish, caller
-          Spree::Money#to_html called with Spree::Money#to_html(html: #{options[:html]}),
+          Spree::Money#to_html called with Spree::Money#to_html(html: #{options[:html].inspect}),
           which will not be supported in the future.
-          Instead use :html_wrap e.g. Spree::Money#to_html(html_wrap: #{options[:html]})
+          Instead use :html_wrap e.g. Spree::Money#to_html(html_wrap: #{options[:html].inspect})
         WARN
       end
       if options[:html_wrap] || options[:html]

data/lib/spree/permission_sets/default_customer.rb

@@ -8,7 +8,7 @@ module Spree
         can :display, OptionType
         can :display, OptionValue
         can :create, Order
-        can [:read, :update], Order do |order, token|
+        can [:read, :update], Order, Order.where(user: user) do |order, token|
           order.user == user || (order.guest_token.present? && token == order.guest_token)
         end
         cannot :update, Order do |order|

data/lib/spree/permission_sets/user_management.rb

@@ -11,6 +11,9 @@ module Spree
         can :update_email, Spree.user_class do |user|
           user.spree_roles.none?
         end
+        can :update_password, Spree.user_class do |user|
+          user.spree_roles.none?
+        end
 
         cannot [:delete, :destroy], Spree.user_class
         can :manage, Spree::StoreCredit

data/lib/spree/permitted_attributes.rb

@@ -117,10 +117,10 @@ module Spree
       :meta_description, :meta_keywords, :meta_title, :child_index
     ]
 
-    # intentionally leaving off email here to prevent privilege escalation
+    # Intentionally leaving off email here to prevent privilege escalation
     # by changing a user with higher priveleges' email to one a lower-priveleged
-    # admin owns. creating a user with an email is handled separate at the
-    # controller level
+    # admin owns. Creating a user with an email is handled separate at the
+    # controller level.
     @@user_attributes = [:password, :password_confirmation]
 
     @@variant_attributes = [

data/lib/spree/preferences/static_model_preferences.rb

@@ -30,8 +30,8 @@ module Spree
       end
 
       def initialize
-        @store = Hash.new do |h, klass|
-          h[klass] = {}
+        @store = Hash.new do |data, klass|
+          data[klass] = {}
         end
       end
 

data/lib/spree/testing_support/dummy_app/rake_tasks.rb

@@ -38,8 +38,12 @@ namespace :db do
     # railties:install:migrations and then db:migrate.
     # Migrations should be run one directory at a time
     ActiveRecord::Migrator.migrations_paths.each do |path|
-      if defined?(ActiveRecord::MigrationContext)
-        # Rails >= 5.2
+      if Rails.gem_version >= Gem::Version.new('6.0.0')
+        ActiveRecord::MigrationContext.new(
+          [path],
+          ActiveRecord::SchemaMigration
+        ).migrate
+      elsif Rails.gem_version >= Gem::Version.new('5.2.0')
         ActiveRecord::MigrationContext.new([path]).migrate
       else
         ActiveRecord::Migrator.migrate(path)

data/lib/spree/testing_support/dummy_app.rb

@@ -13,6 +13,7 @@ Rails.env = 'test'
 require 'solidus_core'
 
 RAILS_52_OR_ABOVE = Gem::Version.new(Rails.version) >= Gem::Version.new('5.2')
+RAILS_6_OR_ABOVE = Gem::Version.new(Rails.version) >= Gem::Version.new('6.0')
 
 # @private
 class ApplicationController < ActionController::Base
@@ -64,7 +65,9 @@ module DummyApp
 
     if RAILS_52_OR_ABOVE
       config.action_controller.default_protect_from_forgery = true
-      config.active_record.sqlite3.represent_boolean_as_integer = true
+      unless RAILS_6_OR_ABOVE
+        config.active_record.sqlite3.represent_boolean_as_integer = true
+      end
     end
 
     # Avoid issues if an old spec/dummy still exists

data/lib/spree/testing_support/factories/inventory_unit_factory.rb

@@ -9,6 +9,7 @@ FactoryBot.define do
   factory :inventory_unit, class: 'Spree::InventoryUnit' do
     transient do
       order { nil }
+      stock_location { nil }
     end
 
     variant
@@ -20,7 +21,13 @@ FactoryBot.define do
       end
     end
     state { 'on_hand' }
-    shipment { build(:shipment, state: 'pending', order: line_item.order) }
+    shipment do
+      if stock_location
+        build(:shipment, state: 'pending', order: line_item.order, stock_location: stock_location)
+      else
+        build(:shipment, state: 'pending', order: line_item.order)
+      end
+    end
     # return_authorization
   end
 end

data/lib/spree/testing_support/factories/promotion_factory.rb

@@ -27,8 +27,15 @@ FactoryBot.define do
         Spree::Promotion::Actions::CreateItemAdjustments.create!(calculator: calculator, promotion: promotion)
       end
     end
+
     factory :promotion_with_item_adjustment, traits: [:with_line_item_adjustment]
 
+    trait :with_free_shipping do
+      after(:create) do |promotion|
+        Spree::Promotion::Actions::FreeShipping.create!(promotion: promotion)
+      end
+    end
+
     trait :with_order_adjustment do
       transient do
         weighted_order_adjustment_amount { 10 }

data/lib/spree/testing_support/factories/stock_package_factory.rb

@@ -17,7 +17,7 @@ FactoryBot.define do
 
     after(:build) do |package, evaluator|
       evaluator.variants_contents.each do |variant, count|
-        package.add_multiple build_list(:inventory_unit, count, variant: variant)
+        package.add_multiple build_list(:inventory_unit, count, variant: variant, stock_location: evaluator.stock_location)
       end
     end
 

data/lib/spree/testing_support/preferences.rb

@@ -44,21 +44,36 @@ module Spree
       # This method  may be used for stubbing one or more different preferences
       # at the same time.
       #
-      # @param [Hash] preferences names and values to be stubbed
+      # @param prefs_or_conf_class [Class, Hash] the class we want to stub
+      #   preferences for or the preferences hash (see prefs param). If this
+      #   param is an Hash, preferences will be stubbed on Spree::Config.
+      # @param prefs [Hash, nil] names and values to be stubbed
       #
-      # @example Stubs `currency` and `track_inventory_levels` preferences
+      # @example Stubs `currency` and `track_inventory_levels` on `Spree::Config`:
       #   stub_spree_preferences(currency: 'EUR', track_inventory_levels: false)
       #   expect(Spree::Config.currency).to eql 'EUR'
       #
+      # @example Stubs `locale` preference on `Spree::Backend::Config`:
+      #   stub_spree_preferences(Spree::Backend::Config, locale: 'fr'),
+      #   expect(Spree::Backend::Config.locale).to eql 'fr'
+      #
       # @see https://github.com/solidusio/solidus/issues/3219
       #   Solidus #3219 for more details and motivations.
-      def stub_spree_preferences(preferences)
+      def stub_spree_preferences(prefs_or_conf_class, prefs = nil)
+        if prefs_or_conf_class.is_a?(Hash)
+          preference_store_class = Spree::Config
+          preferences = prefs_or_conf_class
+        else
+          preference_store_class = prefs_or_conf_class
+          preferences = prefs
+        end
+
         preferences.each do |name, value|
-          if Spree::Config.method(:[]).owner >= Spree::Config.class
-            allow(Spree::Config).to receive(:[]).and_call_original
+          if preference_store_class.method(:[]).owner >= preference_store_class.class
+            allow(preference_store_class).to receive(:[]).and_call_original
           end
-          allow(Spree::Config).to receive(:[]).with(name) { value }
-          allow(Spree::Config).to receive(name) { value }
+          allow(preference_store_class).to receive(:[]).with(name) { value }
+          allow(preference_store_class).to receive(name) { value }
         end
       end
 
@@ -75,12 +90,30 @@ module Spree
       #     expect(Spree::Config.currency).to eql 'EUR'
       #   end
       # @see Spree::TestingSupport::Preferences#stub_spree_preferences
-      def with_unfrozen_spree_preference_store
-        frozen_store = Spree::Config.preference_store
-        Spree::Config.preference_store = Spree::Config[:unfrozen_preference_store].dup
+      def with_unfrozen_spree_preference_store(preference_store_class: Spree::Config)
+        frozen_store = preference_store_class.preference_store
+        preference_store_class.preference_store = preference_store_class[:unfrozen_preference_store].dup
         yield
       ensure
-        Spree::Config.preference_store = frozen_store
+        preference_store_class.preference_store = frozen_store
+      end
+
+      # This class method allows to freeze preferences for a specific
+      # configuration store class. It also stores the current state into
+      # a new preference of that store, so it can be reused when needed
+      # (eg. with_unfrozen_spree_preference_store)
+      #
+      # It is meant to be used by extensions as well, for example if one
+      # extension has its own Spree::ExtensionName::Config class, we can
+      # freeze it and be sure we always stub values on it during tests.
+      #
+      # @param preference_store_class [Class] the configuration class we want
+      #   to freeze.
+      def self.freeze_preferences(preference_store_class)
+        config_class = preference_store_class.class
+        config_class.preference :unfrozen_preference_store, :hash
+        preference_store_class.unfrozen_preference_store = preference_store_class.preference_store.dup
+        preference_store_class.preference_store.freeze
       end
     end
   end
@@ -88,9 +121,15 @@ end
 
 RSpec.configure do |config|
   config.before :suite do
-    # keep a copy of the original unfrozen preference_store for later use:
-    Spree::AppConfiguration.preference :unfrozen_preference_store, :hash
-    Spree::Config.unfrozen_preference_store = Spree::Config.preference_store.dup
-    Spree::Config.preference_store.freeze
+    %w[
+      Spree::Config
+      Spree::Frontend::Config
+      Spree::Backend::Config
+      Spree::Api::Config
+    ].each do |configuration_class|
+      if Object.const_defined?(configuration_class)
+        Spree::TestingSupport::Preferences.freeze_preferences(configuration_class.constantize)
+      end
+    end
   end
 end