solidus_core 3.0.0 → 4.5.1

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

@@ -1,51 +1,7 @@
 # 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
+Spree.deprecator.warn(
+  <<~MSG
+    The file "#{__FILE__}" does not need to be `require`d any longer, it is now autoloaded.
+  MSG
+)

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

@@ -1,42 +1,7 @@
 # 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, 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 }
-
-              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
+Spree.deprecator.warn(
+  <<~MSG
+    The file "#{__FILE__}" does not need to be `require`d any longer, it is now autoloaded.
+  MSG
+)

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

@@ -1,58 +1,7 @@
 # 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
+Spree.deprecator.warn(
+  <<~MSG
+    The file "#{__FILE__}" does not need to be `require`d any longer, it is now autoloaded.
+  MSG
+)

data/lib/spree/core/state_machines.rb

@@ -2,87 +2,54 @@
 
 module Spree
   module Core
-    class StateMachines
-      attr_writer :reimbursement,
-                  :return_authorization,
-                  :return_item_acceptance,
-                  :return_item_reception,
-                  :payment,
-                  :inventory_unit,
-                  :shipment,
-                  :order
-
-      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 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'
-          'Spree::Core::StateMachines::Reimbursement'
-        end
-
-        @reimbursement.constantize
-      end
+    class StateMachines < Spree::Preferences::Configuration
+      # State Machine module for Reimbursements
+      #
+      # @!attribute [rw] reimbursement
+      # @return [Module] a module that implements the state machine for the `Spree::Reimbursement` model.
+      class_name_attribute :reimbursement, default: "Spree::Core::StateMachines::Reimbursement"
+
+      # State Machine module for Return Authorizations
+      #
+      # @!attribute [rw] return_authorization
+      # @return [Module] a module that implements the state machine for the `Spree::ReturnAuthorization` model.
+      class_name_attribute :return_authorization, default: "Spree::Core::StateMachines::ReturnAuthorization"
+
+      # State Machine module for Return Item Acceptances
+      #
+      # @!attribute [rw] return_item_acceptance
+      # @return [Module] a module that implements the acceptance part of the state machine for the `Spree::ReturnItem` model.
+      class_name_attribute :return_item_acceptance, default: "Spree::Core::StateMachines::ReturnItem::AcceptanceStatus"
+
+      # State Machine module for Return Item Receptions
+      #
+      # @!attribute [rw] return_item_reception
+      # @return [Module] a module that implements the reception part of the state machine for the `Spree::ReturnItem` model.
+      class_name_attribute :return_item_reception, default: "Spree::Core::StateMachines::ReturnItem::ReceptionStatus"
+
+      # State Machine module for Payments
+      #
+      # @!attribute [rw] payment
+      # @return [Module] a module that implements the state machine for the `Spree::Payment` model.
+      class_name_attribute :payment, default: "Spree::Core::StateMachines::Payment"
+
+      # State Machine module for Inventory Units
+      #
+      # @!attribute [rw] inventory_unit
+      # @return [Module] a module that implements the state machine for the `Spree::InventoryUnit` model.
+      class_name_attribute :inventory_unit, default: "Spree::Core::StateMachines::InventoryUnit"
+
+      # State Machine module for Shipments
+      #
+      # @!attribute [rw] shipment
+      # @return [Module] a module that implements the state machine for the `Spree::Shipment` model.
+      class_name_attribute :shipment, default: "Spree::Core::StateMachines::Shipment"
+
+      # State Machine module for Orders
+      #
+      # @!attribute [rw] order
+      # @return [Module] a module that implements the state machine for the `Spree::Order` model.
+      class_name_attribute :order, default: "Spree::Core::StateMachines::Order"
     end
   end
 end

data/lib/spree/core/stock_configuration.rb

@@ -8,6 +8,9 @@ module Spree
       attr_writer :location_filter_class
       attr_writer :location_sorter_class
       attr_writer :allocator_class
+      attr_writer :inventory_unit_builder_class
+      attr_writer :availability_validator_class
+      attr_writer :inventory_validator_class
 
       def coordinator_class
         @coordinator_class ||= '::Spree::Stock::SimpleCoordinator'
@@ -33,6 +36,21 @@ module Spree
         @allocator_class ||= '::Spree::Stock::Allocator::OnHandFirst'
         @allocator_class.constantize
       end
+
+      def inventory_unit_builder_class
+        @inventory_unit_builder_class ||= '::Spree::Stock::InventoryUnitBuilder'
+        @inventory_unit_builder_class.constantize
+      end
+
+      def availability_validator_class
+        @availability_validator_class ||= '::Spree::Stock::AvailabilityValidator'
+        @availability_validator_class.constantize
+      end
+ 
+      def inventory_validator_class
+        @inventory_validator_class ||= '::Spree::Stock::InventoryValidator'
+        @inventory_validator_class.constantize
+      end
     end
   end
 end

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

@@ -12,11 +12,9 @@ module Spree
   #     end
   #
   class EmailValidator < ActiveModel::EachValidator
-    EMAIL_REGEXP = /\A([^@\.]|[^@\.]([^@\s]*)[^@\.])@([^@\s]+\.)+[^@\s]+\z/
-
     def validate_each(record, attribute, value)
-      unless EMAIL_REGEXP.match? value
-        record.errors.add(attribute, :invalid, { value: value }.merge!(options))
+      unless Spree::Config.default_email_regexp.match? value
+        record.errors.add(attribute, :invalid, **{ value: }.merge!(options))
       end
     end
   end

data/lib/spree/core/version.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 module Spree
-  VERSION = "3.0.0"
+  VERSION = "4.5.1"
 
   def self.solidus_version
     VERSION
   end
 
+  def self.previous_solidus_minor_version
+    '4.4'
+  end
+
   def self.solidus_gem_version
     Gem::Version.new(solidus_version)
   end

data/lib/spree/core/versioned_value.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    # Wrapper for a value that can be different depending on the Solidus version
+    #
+    # Some configuration defaults can be added or changed when a new Solidus
+    # version is released. This class encapsulates getting the correct value for a
+    # given Solidus version.
+    #
+    # The way it works is you provide an initial value in time, plus the version
+    # boundary where it got changed. Then you can fetch the value providing the
+    # desired Solidus version:
+    #
+    # @example
+    #   value = VersionedValue.new(true, "3.0.0" => false)
+    #   value.call("2.7.0") # => true
+    #   value.call("3.0.0") # => false
+    #   value.call("3.1.0") # => false
+    #
+    # Remember that you must provide the exact boundary when a value got changed,
+    # which could easily be during a pre-release:
+    #
+    # @example
+    #   value = VersionedValue.new(true, "3.0.0" => false)
+    #   value.call("3.0.0.alpha") # => true
+    #
+    #   value = VersionedValue.new(true, "3.0.0.alpha" => false)
+    #   value.call("3.0.0.alpha") # => false
+    #
+    # Multiple boundaries can also be provided:
+    #
+    # @example
+    #   value = VersionedValue.new(0, "2.0.0" => 1, "3.0.0" => 2)
+    #   value.call("1.0.0") # => 0
+    #   value.call("2.1.0") # => 1
+    #   value.call("3.0.0") # => 2
+    class VersionedValue
+      attr_reader :boundaries
+
+      # @param initial_value [Any]
+      # @param boundary [Hash<String, Any>] Map from version number to new value
+      def initialize(initial_value, boundaries = {})
+        @boundaries = Hash[
+                        { '0' => initial_value }
+                        .merge(boundaries)
+                        .transform_keys { |version| to_gem_version(version) }
+                        .sort
+                      ]
+      end
+
+      # @param solidus_version [String]
+      def call(solidus_version = Spree.solidus_version)
+        solidus_version = to_gem_version(solidus_version)
+        boundaries.fetch(
+          boundaries
+            .keys
+            .reduce do |target, following|
+              if target <= solidus_version && solidus_version < following
+                target
+              else
+                following
+              end
+            end
+        )
+      end
+
+      private
+
+      def to_gem_version(string)
+        Gem::Version.new(string)
+      end
+    end
+  end
+end

data/lib/spree/core.rb

@@ -9,25 +9,27 @@ require "active_record/railtie"
 require "active_storage/engine"
 require "sprockets/railtie"
 
+require 'active_support/deprecation'
+require 'spree/deprecated_instance_variable_proxy'
+require 'spree/deprecator'
 require 'acts_as_list'
 require 'awesome_nested_set'
 require 'cancan'
 require 'friendly_id'
 require 'kaminari/activerecord'
-require 'mail'
 require 'monetize'
 require 'paperclip'
 require 'ransack'
 require 'state_machines-activerecord'
 
-require 'spree/deprecation'
-
 # This is required because ActiveModel::Validations#invalid? conflicts with the
 # invalid state of a Payment. In the future this should be removed.
 StateMachines::Machine.ignore_method_conflicts = true
 
 module Spree
-  mattr_accessor :user_class
+  autoload :Deprecation, 'spree/deprecation'
+
+  mattr_accessor :user_class, default: 'Spree::LegacyUser'
 
   def self.user_class
     if @@user_class.is_a?(Class)
@@ -37,6 +39,20 @@ module Spree
     end
   end
 
+  def self.user_class_name
+    @@user_class
+  end
+
+  # Load the same version defaults for all available Solidus components
+  #
+  # @see Spree::Preferences::Configuration#load_defaults
+  def self.load_defaults(version)
+    Spree::Config.load_defaults(version)
+    Spree::Frontend::Config.load_defaults(version) if defined?(Spree::Frontend::Config)
+    Spree::Backend::Config.load_defaults(version) if defined?(Spree::Backend::Config)
+    Spree::Api::Config.load_defaults(version) if defined?(Spree::Api::Config)
+  end
+
   # Used to configure Spree.
   #
   # Example:
@@ -52,6 +68,24 @@ module Spree
   end
 
   module Core
+    # @api private
+    def self.has_install_generator_been_run?(rails_paths: Rails.application.paths, initializer_name: 'spree.rb', dummy_app_name: 'DummyApp::Application')
+      does_spree_initializer_exist?(rails_paths, initializer_name) ||
+        running_solidus_test_suite_with_dummy_app?(dummy_app_name)
+    end
+
+    def self.running_solidus_test_suite_with_dummy_app?(dummy_app_name)
+      Rails.env.test? && Rails.application.class.name == dummy_app_name
+    end
+    private_class_method :running_solidus_test_suite_with_dummy_app?
+
+    def self.does_spree_initializer_exist?(rails_paths, initializer_name)
+      rails_paths['config/initializers'].any? do |path|
+        File.exist?(Pathname.new(path).join(initializer_name))
+      end
+    end
+    private_class_method :does_spree_initializer_exist?
+
     class GatewayError < RuntimeError; end
   end
 end
@@ -66,31 +100,21 @@ require 'spree/core/environment/promotions'
 require 'spree/core/environment'
 require 'spree/migrations'
 require 'spree/migration_helpers'
-require 'spree/event'
+require 'spree/bus'
 require 'spree/core/engine'
 
 require 'spree/i18n'
 require 'spree/localized_number'
-require 'spree/money'
 require 'spree/permitted_attributes'
 
 require 'spree/core/importer'
 require 'spree/core/permalinks'
 require 'spree/core/product_duplicator'
-require 'spree/core/controller_helpers/auth'
-require 'spree/core/controller_helpers/common'
-require 'spree/core/controller_helpers/current_host'
-require 'spree/core/controller_helpers/order'
-require 'spree/core/controller_helpers/payment_parameters'
-require 'spree/core/controller_helpers/pricing'
-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/null_promotion_configuration'
 require 'spree/core/validators/email'
-require 'spree/permission_sets'
 require 'spree/user_class_handle'
 
 require 'spree/preferences/store'

data/lib/spree/deprecated_instance_variable_proxy.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'active_support/deprecation'
+
+module Spree
+  # This DeprecatedInstanceVariableProxy transforms instance variable to
+  # deprecated instance variable.
+  #
+  # It differs from ActiveSupport::DeprecatedInstanceVariableProxy since
+  # it allows to define a custom message.
+  #
+  #   class Example
+  #     def initialize(deprecator)
+  #       @request = Spree::DeprecatedInstanceVariableProxy.new(self, :request, :@request, deprecator, "Please, do not use this thing.")
+  #       @_request = :a_request
+  #     end
+  #
+  #     def request
+  #       @_request
+  #     end
+  #
+  #     def old_request
+  #       @request
+  #     end
+  #   end
+  #
+  # When someone execute any method on @request variable this will trigger
+  # +warn+ method on +deprecator_instance+ and will fetch <tt>@_request</tt>
+  # variable via +request+ method and execute the same method on non-proxy
+  # instance variable.
+  #
+  # Default deprecator is <tt>Spree.deprecator</tt>.
+  class DeprecatedInstanceVariableProxy < ActiveSupport::Deprecation::DeprecationProxy
+    def initialize(instance, method_or_var, var = "@#{method}", deprecator = Spree.deprecator, message = nil)
+      @instance = instance
+      @method_or_var = method_or_var
+      @var = var
+      @deprecator = deprecator
+      @message = message
+    end
+
+    private
+
+    def target
+      return @instance.instance_variable_get(@method_or_var) if @instance.instance_variable_defined?(@method_or_var)
+
+      @instance.__send__(@method_or_var)
+    end
+
+    def warn(callstack, called, args)
+      message = @message || "#{@var} is deprecated! Call #{@method_or_var}.#{called} instead of #{@var}.#{called}."
+      message = [message, "Args: #{args.inspect}"].join(" ") unless args.empty?
+
+      @deprecator.warn(message, callstack)
+    end
+  end
+end

data/lib/spree/deprecation.rb

@@ -1,57 +1,9 @@
 # frozen_string_literal: true
 
-require 'active_support/deprecation'
+require 'spree/core'
 
 module Spree
-  Deprecation = ActiveSupport::Deprecation.new('4.0', 'Solidus')
+  Deprecation = Spree.deprecator
 
-  # This DeprecatedInstanceVariableProxy transforms instance variable to
-  # deprecated instance variable.
-  #
-  # It differs from ActiveSupport::DeprecatedInstanceVariableProxy since
-  # it allows to define a custom message.
-  #
-  #   class Example
-  #     def initialize(deprecator)
-  #       @request = Spree::DeprecatedInstanceVariableProxy.new(self, :request, :@request, deprecator, "Please, do not use this thing.")
-  #       @_request = :a_request
-  #     end
-  #
-  #     def request
-  #       @_request
-  #     end
-  #
-  #     def old_request
-  #       @request
-  #     end
-  #   end
-  #
-  # When someone execute any method on @request variable this will trigger
-  # +warn+ method on +deprecator_instance+ and will fetch <tt>@_request</tt>
-  # variable via +request+ method and execute the same method on non-proxy
-  # instance variable.
-  #
-  # Default deprecator is <tt>Spree::Deprecation</tt>.
-  class DeprecatedInstanceVariableProxy < ActiveSupport::Deprecation::DeprecationProxy
-    def initialize(instance, method, var = "@#{method}", deprecator = Spree::Deprecation, message = nil)
-      @instance = instance
-      @method = method
-      @var = var
-      @deprecator = deprecator
-      @message = message
-    end
-
-    private
-
-    def target
-      @instance.__send__(@method)
-    end
-
-    def warn(callstack, called, args)
-      message = @message || "#{@var} is deprecated! Call #{@method}.#{called} instead of #{@var}.#{called}."
-      message = [message, "Args: #{args.inspect}"].join(" ")
-
-      @deprecator.warn(message, callstack)
-    end
-  end
+  Spree.deprecator.warn "Spree::Deprecation is deprecated. Please use Spree.deprecator instead.", caller(2)
 end