solidus_core 2.11.10 → 3.3.1

data/lib/spree/event/subscriber_registry.rb

@@ -35,7 +35,9 @@ module Spree
             subscription = Spree::Event.subscribe(event_name) { |event| subscriber.send(event_action, event) }
 
             # deprecated mappings, to be removed when Solidus 2.10 is not supported anymore:
-            subscriber.send("#{event_action}_handler=", subscription)
+            if subscriber.respond_to?("#{event_action}_handler=")
+              subscriber.send("#{event_action}_handler=", subscription)
+            end
 
             registry[subscriber.name][event_action] = subscription
           end
@@ -62,13 +64,11 @@ module Spree
       # Loading the files has the side effect of adding their module to the
       # list in Spree::Event.subscribers.
       def require_subscriber_files
-        pattern = "app/subscribers/**/*_subscriber.rb"
+        require_dependency(
+          Spree::Core::Engine.root.join('app', 'subscribers', 'spree', 'mailer_subscriber.rb')
+        )
 
-        # Load Solidus subscribers
-        # rubocop:disable Rails/DynamicFindBy
-        solidus_core_dir = Gem::Specification.find_by_name('solidus_core').gem_dir
-        # rubocop:enable Rails/DynamicFindBy
-        Dir.glob(File.join(solidus_core_dir, pattern)) { |c| require_dependency(c.to_s) }
+        pattern = "app/subscribers/**/*_subscriber.rb"
 
         # Load application subscribers, only when the flag is set to true:
         if Spree::Config.events.autoload_subscribers

data/lib/spree/event.rb

@@ -21,7 +21,7 @@ module Spree
     #
     # @example Trigger an event named 'order_finalized'
     #   Spree::Event.fire 'order_finalized', order: @order do
-    #     @order.finalize!
+    #     @order.complete!
     #   end
     def fire(event_name, opts = {})
       adapter.fire normalize_name(event_name), opts do
@@ -29,20 +29,6 @@ module Spree
       end
     end
 
-    # @deprecated Loads all Solidus' core and application's event subscribers files.
-    # The latter are loaded automatically only when the preference
-    # Spree::Config.events.autoload_subscribers is set to a truthy value.
-    #
-    # Files must be placed under the directory `app/subscribers` and their
-    # name must end with `_subscriber.rb`.
-    #
-    # Loading the files has the side effect of adding their module to the
-    # list in Spree::Event.subscribers.
-    def require_subscriber_files
-      Spree::Deprecation.warn("#{self}.require_subscriber_files is deprecated and will be removed in Solidus 3.0.", caller)
-      subscriber_registry.send(:require_subscriber_files)
-    end
-
     # Subscribe to an event with the given name. The provided block is executed
     # every time the subscribed event is fired.
     #
@@ -114,23 +100,6 @@ module Spree
       Spree::Config.events.adapter
     end
 
-    # The suffix used for namespacing Solidus events, defaults to
-    # `.spree`
-    #
-    # @see Spree::Event::Configuration#suffix
-    def suffix
-      Spree::Deprecation.warn "This method is deprecated and will be removed. Please use Event::Adapters::ActiveSupportNotifications#suffix"
-      Spree::Config.events.suffix
-    end
-
-    # @deprecated
-    # @!attribute [r] subscribers
-    #   @return [Array<Spree::Event::Subscriber>] A list of subscribers used to support class reloading for Spree::Event::Subscriber instances
-    def subscribers
-      Spree::Deprecation.warn("`#{self}.subscribers` is deprecated. Please use `#{self}.subscriber_registry` instead.", caller)
-      Spree::Config.events.subscribers
-    end
-
     # @!attribute [r] subscribers
     #   @return <Spree::Event::SubscriberRegistry> The registry for supporting class reloading for Spree::Event::Subscriber instances
     def subscriber_registry

data/lib/spree/i18n.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require 'i18n'
-require 'active_support/core_ext/array/extract_options'
-require 'action_view'
 
 module Spree
   def self.i18n_available_locales
@@ -11,29 +9,9 @@ module Spree
     end
   end
 
-  class TranslationHelperWrapper # :nodoc:
-    include ActionView::Helpers::TranslationHelper
-  end
-
   # This value is used as a count for the pluralization helpers related to I18n
   # ex: Spree::Order.model_name.human(count: Spree::I18N_GENERIC_PLURAL)
   # Related to Solidus issue #1164, this is needed to avoid problems with
   # some pluralization calculators
   I18N_GENERIC_PLURAL = 2.1
-
-  class << self
-    # Add spree namespace and delegate to Rails TranslationHelper for some nice
-    # extra functionality. e.g return reasonable strings for missing translations
-
-    def translate(key, options = {})
-      Spree::Deprecation.warn <<-WARN.squish
-        Spree.t & Spree.translate have been deprecated.
-        Instead use I18n.t('spree.your_translation_key')
-      WARN
-      options[:scope] = [:spree, *options[:scope]]
-      TranslationHelperWrapper.new.translate(key, **options)
-    end
-
-    alias_method :t, :translate
-  end
 end

data/lib/spree/migrations.rb

@@ -23,16 +23,18 @@ module Spree
     # Shouldn't run on test mode because migrations inside engine don't have
     # engine name on the file name
     def check
-      if File.directory?(app_dir)
-        unless missing_migrations.empty?
-          puts "[#{engine_name.capitalize} WARNING] Missing migrations."
-          missing_migrations.each do |migration|
-            puts "[#{engine_name.capitalize} WARNING] #{migration} from #{engine_name} is missing."
-          end
-          puts "[#{engine_name.capitalize} WARNING] Run `bundle exec rake railties:install:migrations` to get them.\n\n"
-          true
-        end
-      end
+      return unless File.directory?(app_dir)
+      return if missing_migrations.empty?
+      return if ENV['SOLIDUS_SKIP_MIGRATIONS_CHECK']
+
+      prefix = "[WARNING #{engine_name.capitalize}]"
+      warn <<~WARN
+        #{prefix} Missing migrations.
+        #{missing_migrations.map {|m| "#{prefix} - #{m}"}.join("\n")}
+        #{prefix}
+        #{prefix} Run `bin/rails railties:install:migrations` to get them.
+        #{prefix} You can silence this warning by setting the `SOLIDUS_SKIP_MIGRATIONS_CHECK` environment variable.
+      WARN
     end
 
     def missing_migrations
@@ -66,7 +68,7 @@ module Spree
     end
 
     def app_dir
-      "#{Rails.root}/db/migrate"
+      Spree::Config.migration_path
     end
 
     def engine_dir

data/lib/spree/money.rb

@@ -6,7 +6,6 @@ module Spree
   class Money
     include Comparable
     DifferentCurrencyError = Class.new(StandardError)
-    RUBY_NUMERIC_STRING = /\A-?\d+(\.\d+)?\z/
 
     class <<self
       attr_accessor :default_formatting_rules
@@ -37,15 +36,8 @@ module Spree
         @money = amount
       else
         currency = (options[:currency] || Spree::Config[:currency])
-        if amount.to_s =~ RUBY_NUMERIC_STRING
-          @money = Monetize.from_string(amount, currency)
-        else
-          @money = Spree::Money.parse_to_money(amount, currency)
-          Spree::Deprecation.warn <<-WARN.squish, caller
-            Spree::Money was initialized with #{amount.inspect}, which will not be supported in the future.
-            Instead use Spree::Money.new(#{@money.to_s.inspect}, options) or Spree::Money.parse(#{amount.inspect})
-          WARN
-        end
+
+        @money = Monetize.from_string(amount, currency)
       end
       @options = Spree::Money.default_formatting_rules.merge(options)
     end
@@ -80,14 +72,7 @@ module Spree
     def to_html(options = { html_wrap: true })
       output = format(options)
       # 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].inspect}),
-          which will not be supported in the future.
-          Instead use :html_wrap e.g. Spree::Money#to_html(html_wrap: #{options[:html].inspect})
-        WARN
-      end
-      if options[:html_wrap] || options[:html]
+      if options[:html_wrap]
         output = output.html_safe
       end
       output

data/lib/spree/permission_sets/default_customer.rb

@@ -7,7 +7,14 @@ module Spree
         can :read, Country
         can :read, OptionType
         can :read, OptionValue
-        can :create, Order
+        can :create, Order do |order, token|
+          # same user, or both nil
+          order.user == user ||
+          # guest checkout order
+          order.email.present? ||
+          # via API, just like with show and update
+          (order.guest_token.present? && token == order.guest_token)
+        end
         can [:show, :update], Order, Order.where(user: user) do |order, token|
           order.user == user || (order.guest_token.present? && token == order.guest_token)
         end

data/lib/spree/permitted_attributes.rb

@@ -39,8 +39,7 @@ module Spree
     mattr_reader(*ATTRIBUTES)
 
     @@address_attributes = [
-      :id, :name, :firstname, :lastname, :first_name, :last_name,
-      :address1, :address2, :city, :country_id, :state_id,
+      :id, :name, :address1, :address2, :city, :country_id, :state_id,
       :zipcode, :phone, :state_name, :country_iso, :alternative_phone, :company,
       country: [:iso, :name, :iso3, :iso_name],
       state: [:name, :abbr]
@@ -52,7 +51,13 @@ module Spree
       :month, :year, :expiry, :first_name, :last_name, :name
     ]
 
-    @@customer_return_attributes = [:stock_location_id, return_items_attributes: [:id, :inventory_unit_id, :return_authorization_id, :returned, :amount, :reception_status_event, :acceptance_status, :exchange_variant_id, :resellable]]
+    @@customer_return_attributes = [
+      :stock_location_id, return_items_attributes: [
+        :id, :inventory_unit_id, :return_authorization_id, :returned, :amount,
+        :reception_status_event, :acceptance_status, :exchange_variant_id,
+        :resellable, :return_reason_id
+      ]
+    ]
 
     @@image_attributes = [:alt, :attachment, :position, :viewable_type, :viewable_id]
 
@@ -60,16 +65,16 @@ module Spree
 
     @@line_item_attributes = [:id, :variant_id, :quantity]
 
-    @@option_type_attributes = [:name, :presentation, :option_values_attributes]
-
     @@option_value_attributes = [:name, :presentation]
 
+    @@option_type_attributes = [:name, :presentation, option_values_attributes: option_value_attributes]
+
     @@payment_attributes = [:amount, :payment_method_id, :payment_method]
 
     @@product_properties_attributes = [:property_name, :value, :position]
 
     @@product_attributes = [
-      :name, :description, :available_on, :discontinue_on, :permalink, :meta_description,
+      :name, :description, :available_on, :discontinue_on, :meta_description,
       :meta_keywords, :price, :sku, :deleted_at,
       :option_values_hash, :weight, :height, :width, :depth,
       :shipping_category_id, :tax_category_id,
@@ -90,7 +95,7 @@ module Spree
       :number, :month, :year, :expiry, :verification_value,
       :first_name, :last_name, :cc_type, :gateway_customer_profile_id,
       :gateway_payment_profile_id, :last_digits, :name, :encrypted_data,
-      :existing_card_id, :wallet_payment_source_id, address_attributes: address_attributes
+      :wallet_payment_source_id, address_attributes: address_attributes
     ]
 
     @@stock_item_attributes = [:variant, :stock_location, :backorderable, :variant_id]
@@ -126,8 +131,11 @@ module Spree
     @@variant_attributes = [
       :name, :presentation, :cost_price, :lock_version,
       :position, :track_inventory,
-      :product_id, :product, :option_values_attributes, :price,
-      :weight, :height, :width, :depth, :sku, :cost_currency, option_value_ids: [], options: [:name, :value]
+      :product_id, :product, :price,
+      :weight, :height, :width, :depth, :sku, :cost_currency,
+      :tax_category_id, :shipping_category_id,
+      option_value_ids: [],
+      options: [:name, :value]
     ]
 
     @@checkout_address_attributes = [
@@ -143,61 +151,11 @@ module Spree
     ]
 
     @@checkout_payment_attributes = [
-      :coupon_code,
       payments_attributes: payment_attributes + [
         source_attributes: source_attributes
       ]
     ]
 
     @@checkout_confirm_attributes = []
-
-    def self.checkout_attributes
-      Spree::Deprecation.warn <<-WARN.squish, caller
-        checkout_attributes is deprecated, please use the permitted
-        attributes set for the specific step that needs to be updated.
-
-        E.g. permitted_checkout_address_attributes
-      WARN
-
-      CheckoutAdditionalAttributes.new(
-        checkout_address_attributes +
-        checkout_delivery_attributes +
-        checkout_payment_attributes +
-        checkout_confirm_attributes
-      )
-    end
-  end
-
-  class CheckoutAdditionalAttributes < Array
-    def <<(*attributes)
-      super
-
-      inject_attributes_to_all_steps(attributes, :<<)
-    end
-
-    def push(*attributes)
-      super
-
-      inject_attributes_to_all_steps(attributes, :push)
-    end
-    alias append push
-
-    def prepend(*attributes)
-      super
-
-      inject_attributes_to_all_steps(attributes, :prepend)
-    end
-    alias unshift prepend
-
-    private
-
-    def inject_attributes_to_all_steps(attributes, method_name)
-      attributes.each do |attribute|
-        PermittedAttributes.checkout_address_attributes.send(method_name, attribute)
-        PermittedAttributes.checkout_delivery_attributes.send(method_name, attribute)
-        PermittedAttributes.checkout_payment_attributes.send(method_name, attribute)
-        PermittedAttributes.checkout_confirm_attributes.send(method_name, attribute)
-      end
-    end
   end
 end

data/lib/spree/preferences/configuration.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'spree/core/versioned_value'
 require 'spree/preferences/preferable'
 
 module Spree::Preferences
@@ -29,6 +30,45 @@ module Spree::Preferences
   class Configuration
     include Spree::Preferences::Preferable
 
+    # @!attribute [r] loaded_defaults
+    #   @return [String]
+    #     Some configuration defaults can be added or changed when a new Solidus
+    #     version is released. Setting this to an older Solidus version allows keeping
+    #     backward compatibility until the application code is updated to the new
+    #     defaults. Set via {#load_defaults}
+    attr_reader :loaded_defaults
+
+    # @api private
+    attr_reader :load_defaults_called
+
+    def initialize
+      @loaded_defaults = Spree.solidus_version
+      @load_defaults_called = false
+    end
+
+    # @param [String] Solidus version from which take defaults when preferences
+    # are not overriden by the user.
+    # @see #loaded_defaults
+    def load_defaults(version)
+      @loaded_defaults = version
+      @load_defaults_called = true
+      reset
+    end
+
+    def check_load_defaults_called(instance_constant_name = nil)
+      return if load_defaults_called || !Spree::Core.has_install_generator_been_run?
+
+      target_name = instance_constant_name || "#{self.class.name}.new"
+      Spree::Deprecation.warn <<~MSG
+        It's recommended that you explicitly load the default configuration for
+        your current Solidus version. You can do it by adding the following call
+        to your Solidus initializer within the #{target_name} block:
+
+          config.load_defaults('#{Spree.solidus_version}')
+
+      MSG
+    end
+
     # @yield [config] Yields this configuration object to a block
     def configure
       yield(self)
@@ -79,6 +119,37 @@ module Spree::Preferences
       end
     end
 
+    def self.inherited(klass)
+      klass.instance_variable_set(:@versioned_preferences, [])
+      class << klass
+        attr_reader :versioned_preferences
+      end
+    end
+
+    # Adds a preference with different default depending on {#loaded_defaults}
+    #
+    # This method is a specialized version of {.preference} that generates a
+    # different default value for different Solidus versions. For instance, in
+    # the example, `foo`'s default was `true` until version 3.0.0.alpha, when it
+    # became `false`:
+    #
+    # @example
+    #   versioned_preference :foo, :boolean, initial_value: true, boundaries: { "3.0.0.alpha" => false }
+    #
+    # @see .preference
+    # @see #loaded_defaults
+    # @see Spree::Core::VersionedValue
+    def self.versioned_preference(name, type, initial_value:, boundaries:, **options)
+      @versioned_preferences << name
+      preference(
+        name,
+        type,
+        options.merge(
+          default: by_version(initial_value, boundaries)
+        )
+      )
+    end
+
     def self.preference(name, type, options = {})
       super
       alias_method name.to_s, "preferred_#{name}"
@@ -103,5 +174,18 @@ module Spree::Preferences
         class_name
       end
     end
+
+    def self.by_version(*args)
+      proc do |loaded_defaults|
+        Spree::Core::VersionedValue.new(*args).call(loaded_defaults)
+      end
+    end
+    private_class_method :by_version
+
+    private
+
+    def context_for_default
+      [loaded_defaults]
+    end
   end
 end

data/lib/spree/preferences/preferable.rb

@@ -10,6 +10,13 @@ module Spree
     #
     # A class including Preferable must implement #preferences which should return
     # an object responding to .fetch(key), []=(key, val), and .delete(key).
+    # If #preferences is initialized with `default_preferences` and one of the
+    # preferences is another preference, it will cause a stack level too deep error.
+    # To avoid it do not memoize #preferences.
+    #
+    # It may also define a `#context_for_default` method. It should return an
+    # array with the arguments to be provided to a proc used as the `default:`
+    # keyword for a preference.
     #
     # The generated writer method performs typecasting before assignment into the
     # preferences object.
@@ -107,6 +114,8 @@ module Spree
       end
 
       # @return [Hash{Symbol => Object}] Default for all preferences defined on this class
+      # This may raise an infinite loop error if any of the defaults are
+      # dependent on other preferences defaults.
       def default_preferences
         Hash[
           defined_preferences.map do |preference|
@@ -176,6 +185,10 @@ module Spree
           value
         end
       end
+
+      def context_for_default
+        [].freeze
+      end
     end
   end
 end

data/lib/spree/preferences/preferable_class_methods.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'spree/deprecation'
 require 'spree/encryptor'
 
 module Spree::Preferences
@@ -26,8 +27,38 @@ module Spree::Preferences
         options[:default] = preference_encryptor.encrypt(options[:default])
       end
 
-      default = options[:default]
-      default = ->{ options[:default] } unless default.is_a?(Proc)
+      default = begin
+                  given = options[:default]
+                  if ancestors.include?(Spree::Preferences::Configuration) &&
+                     given.is_a?(Proc) &&
+                     given.lambda? &&
+                     given.arity.zero?
+                    Spree::Deprecation.warn <<~MSG
+                      The arity of a proc given as the default for a preference
+                      has changed from 0 to 1 on Solidus 3.1. The Solidus
+                      version for the loaded preference defaults is given as the
+                      proc's argument from this point on.
+
+                      If you don't need to return a different default value
+                      depending on the loaded Solidus version, you can change
+                      the proc so that it doesn't have lambda semantics (lambdas
+                      raise when extra arguments are supplied, while raw procs
+                      don't). E.g.:
+
+                      preference :foo, :string, default: proc { true }
+
+                      If you want to branch on the provided Solidus version, you can do like the following:
+
+                      versioned_preference :foo, :string, initial_value: true, boundaries: { "3.2.0" => false }
+
+                    MSG
+                    ->(_default_context) { given.call }
+                  elsif given.is_a?(Proc)
+                    given
+                  else
+                    proc { given }
+                  end
+                end
 
       # The defined preferences on a class are all those defined directly on
       # that class as well as those defined on ancestors.
@@ -44,7 +75,7 @@ module Spree::Preferences
       # is a pending preference before going to default
       define_method preference_getter_method(name) do
         value = preferences.fetch(name) do
-          default.call
+          instance_exec(*context_for_default, &default)
         end
         value = preference_encryptor.decrypt(value) if preference_encryptor.present?
         value
@@ -60,7 +91,9 @@ module Spree::Preferences
         preferences_will_change! if respond_to?(:preferences_will_change!)
       end
 
-      define_method preference_default_getter_method(name), &default
+      define_method preference_default_getter_method(name) do
+        instance_exec(*context_for_default, &default)
+      end
 
       define_method preference_type_getter_method(name) do
         type

data/lib/spree/preferences/preference_differentiator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Spree
+  module Preferences
+    class PreferenceDifferentiator
+      attr_reader :config_class
+
+      def initialize(config_class)
+        @config_class = config_class
+      end
+
+      def call(from:, to:)
+        preferences_from = config_class.new.load_defaults(from)
+        preferences_to = config_class.new.load_defaults(to)
+        config_class.versioned_preferences.reduce({}) do |changes, pref_key|
+          value_from = preferences_from[pref_key]
+          value_to = preferences_to[pref_key]
+          if value_from == value_to
+            changes
+          else
+            changes.merge(
+              pref_key => { from: value_from, to: value_to }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spree/preferences/static_model_preferences.rb

@@ -7,13 +7,8 @@ module Spree
         attr_reader :preferences
 
         def initialize(klass, hash)
-          hash = hash.symbolize_keys
-          hash.keys.each do |key|
-            if !klass.defined_preferences.include?(key)
-              raise "Preference #{key.inspect} is not defined on #{klass}"
-            end
-          end
-          @preferences = hash
+          @klass = klass
+          @preferences = hash.symbolize_keys
         end
 
         def fetch(key, &block)
@@ -27,6 +22,8 @@ module Spree
         def to_hash
           @preferences.deep_dup
         end
+
+        delegate :keys, to: :@preferences
       end
 
       def initialize
@@ -36,14 +33,32 @@ module Spree
       end
 
       def add(klass, name, preferences)
-        # We use class name instead of class to allow reloading in dev
-        raise "Static model preference '#{name}' on #{klass} is already defined" if @store[klass.to_s][name]
-        @store[klass.to_s][name] = Definition.new(klass, preferences)
+        @store[klass.to_s][name] = Definition.new(klass.to_s, preferences)
       end
 
       def for_class(klass)
         @store[klass.to_s]
       end
+
+      def validate!
+        @store.keys.map(&:constantize).each do |klass|
+          validate_for_class!(klass)
+        end
+      end
+
+      private
+
+      def validate_for_class!(klass)
+        for_class(klass).each do |name, preferences|
+          klass_keys = klass.defined_preferences.map(&:to_s)
+          extra_keys = preferences.keys.map(&:to_s) - klass_keys
+          next if extra_keys.empty?
+
+          raise \
+            "Unexpected keys found for #{klass} under #{name}: #{extra_keys.sort.join(', ')} " \
+            "(expected keys: #{klass_keys.sort.join(', ')})"
+        end
+      end
     end
   end
 end