solidus_core 3.0.0 → 4.5.1

data/lib/spree/permitted_attributes.rb

@@ -14,6 +14,7 @@ module Spree
       :checkout_confirm_attributes,
       :credit_card_update_attributes,
       :customer_return_attributes,
+      :customer_metadata_attributes,
       :image_attributes,
       :inventory_unit_attributes,
       :line_item_attributes,
@@ -51,37 +52,53 @@ 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, customer_metadata: {}
+      ]
+    ]
+
+    @@customer_metadata_attributes = [customer_metadata: {}]
 
     @@image_attributes = [:alt, :attachment, :position, :viewable_type, :viewable_id]
 
     @@inventory_unit_attributes = [:shipment, :variant_id]
 
-    @@line_item_attributes = [:id, :variant_id, :quantity]
-
-    @@option_type_attributes = [:name, :presentation, :option_values_attributes]
+    @@line_item_attributes = [:id, :variant_id, :quantity, customer_metadata: {}]
 
     @@option_value_attributes = [:name, :presentation]
 
-    @@payment_attributes = [:amount, :payment_method_id, :payment_method]
+    @@option_type_attributes = [:name, :presentation, option_values_attributes: option_value_attributes]
+
+    @@payment_attributes = [:amount, :payment_method_id, :payment_method, customer_metadata: {}]
 
     @@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,
-      :taxon_ids, :option_type_ids, :cost_currency, :cost_price
+      :taxon_ids, :option_type_ids, :cost_currency, :cost_price, :primary_taxon_id,
+      :gtin, :condition
     ]
 
     @@property_attributes = [:name, :presentation]
 
-    @@return_authorization_attributes = [:memo, :stock_location_id, :return_reason_id, return_items_attributes: [:inventory_unit_id, :exchange_variant_id, :return_reason_id, :preferred_reimbursement_type_id]]
+    @@return_authorization_attributes = [:memo, :stock_location_id, :return_reason_id,
+                                         customer_metadata: {},
+                                         return_items_attributes: [
+                                           :inventory_unit_id,
+                                           :exchange_variant_id,
+                                           :return_reason_id,
+                                           :preferred_reimbursement_type_id
+                                         ]]
 
     @@shipment_attributes = [
       :special_instructions, :stock_location_id, :id, :tracking,
-      :selected_shipping_rate_id
+      :selected_shipping_rate_id, customer_metadata: {}
     ]
 
     # month / year may be provided by some sources, or others may elect to use one field
@@ -89,7 +106,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,
-      :wallet_payment_source_id, address_attributes: address_attributes
+      :wallet_payment_source_id, address_attributes:
     ]
 
     @@stock_item_attributes = [:variant, :stock_location, :backorderable, :variant_id]
@@ -120,17 +137,21 @@ module Spree
     # 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.
-    @@user_attributes = [:password, :password_confirmation]
+    @@user_attributes = [:password, :password_confirmation, customer_metadata: {}]
 
     @@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 = [
       :use_billing,
+      :use_shipping,
       :email,
       bill_address_attributes: address_attributes,
       ship_address_attributes: address_attributes
@@ -143,7 +164,7 @@ module Spree
 
     @@checkout_payment_attributes = [
       payments_attributes: payment_attributes + [
-        source_attributes: source_attributes
+        source_attributes:
       ]
     ]
 

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.deprecator.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}"
@@ -102,6 +173,23 @@ module Spree::Preferences
         class_name = class_name.constantize if class_name.is_a?(String)
         class_name
       end
+
+      define_method("#{name}_name") do
+        instance_variable_get(ivar) || default
+      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/persistable.rb

@@ -7,7 +7,13 @@ module Spree
 
       included do
         include Spree::Preferences::Preferable
-        serialize :preferences, Hash
+
+        if Rails.gem_version >= Gem::Version.new('7.1')
+          serialize :preferences, type: Hash, coder: YAML
+        else
+          serialize :preferences, Hash, coder: YAML
+        end
+
         after_initialize :initialize_preference_defaults
       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

@@ -26,8 +26,14 @@ 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 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 +50,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 +66,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

data/lib/spree/preferences/store.rb

@@ -19,7 +19,7 @@ module Spree::Preferences
 
     def exist?(key)
       @cache.exist?(key) ||
-        should_persist? && Spree::Preference.where(key: key).exists?
+        should_persist? && Spree::Preference.where(key:).exists?
     end
 
     def get(key)
@@ -35,7 +35,7 @@ module Spree::Preferences
         # has been cleared from the cache
 
         # does it exist in the database?
-        if preference = Spree::Preference.find_by(key: key)
+        if preference = Spree::Preference.find_by(key:)
           # it does exist
           val = preference.value
         else

data/lib/spree/testing_support/blacklist_urls.rb

@@ -5,7 +5,7 @@ module Spree
     module BlacklistUrls
       def setup_url_blacklist(browser)
         if browser.respond_to?(:url_blacklist)
-          browser.url_blacklist = ['http://fonts.googleapis.com']
+          browser.url_blacklist = ['https://fonts.googleapis.com']
         end
       end
     end

data/lib/spree/testing_support/bus_helpers.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spree/bus'
+
+module Spree
+  module TestingSupport
+    # RSpec test helpers for the event bus
+    #
+    # If you want to use the methods defined in this module, include it in your
+    # specs:
+    #
+    # @example
+    #   require 'rails_helper'
+    #   require 'spree/testing_support/bus_helpers'
+    #
+    #   RSpec.describe MyClass do
+    #     include Spree::TestingSupport::BusHelpers
+    #   end
+    #
+    # or, globally, in your `spec_helper.rb`:
+    #
+    # @example
+    #   require 'spree/testing_support/bus_helpers'
+    #
+    #   RSpec.configure do |config|
+    #     config.include Spree::TestingSupport::BusHelpers
+    #   end
+    module BusHelpers
+      extend RSpec::Matchers::DSL
+
+      # Stubs {Spree::Bus}
+      #
+      # After you have called this method in an example, {Spree::Bus} will no
+      # longer publish any event for the duration of that example. All the
+      # method invocations on it will be stubbed.
+      #
+      # Internally, it stubs {Spree::Bus#publish}.
+      #
+      # After you call this method, probably you'll want to call some of the
+      # matchers defined in this module.
+      def stub_spree_bus
+        allow(Spree::Bus).to receive(:publish)
+      end
+
+      # @!method have_been_published(event_name)
+      #   Matcher to test that an event has been published via {Spree::Bus#publish}
+      #
+      #   Before using this matcher, you need to call {#stub_spree_bus}.
+      #
+      #   Remember that the event listeners won't be performed.
+      #
+      #   @example
+      #     it 'publishes foo event' do
+      #       stub_spree_bus
+      #
+      #       Spree::Bus.publish 'foo'
+      #
+      #       expect('foo').to have_been_published
+      #     end
+      #
+      #   It can be chain through `with` to match with the published payload:
+      #
+      #   @example
+      #     it 'publishes foo event with the expected payload' do
+      #       stub_spree_bus
+      #
+      #       Spree::Bus.publish 'foo', bar: :baz, qux: :quux
+      #
+      #       expect('foo').to have_been_published.with(a_hash_including(bar: :baz))
+      #     end
+      #
+      #   @param [Symbol] event_name
+      matcher :have_been_published do
+        chain :with, :payload
+
+        match do |expected_event|
+          expected_event = normalize_name(expected_event)
+          arguments = payload ? [expected_event, payload] : [expected_event, any_args]
+          expect(Spree::Bus).to have_received(:publish).with(*arguments)
+        end
+
+        failure_message do |expected_event|
+          <<~MSG
+            expected #{expected_event.inspect} to have been published.
+            Make sure that provided payload, if any, also matches.
+          MSG
+        end
+
+        def normalize_name(event_name)
+          if event_name.is_a?(Symbol)
+            eq(event_name)
+          else
+            raise ArgumentError, <<~MSG
+              "#{event_name.inspect} is not a valid event name. It must be a Symbol."
+            MSG
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spree/testing_support/capybara_ext.rb

@@ -23,7 +23,7 @@ module Spree
             field.dispatchEvent(event);
           JS
         else
-          fill_in locator, with: with
+          fill_in locator, with:
         end
       end
 
@@ -110,6 +110,16 @@ module Spree
         # find the original.
         find('label:not(.select2-offscreen)', text: /#{Regexp.escape(text)}/i, match: :one)
       end
+
+      def dialog(parent: 'body', **options)
+        within(parent) do
+          find('dialog', visible: :all, **options)
+        end
+      end
+
+      def turbo_frame_modal
+        dialog(parent: find('turbo-frame', visible: :all))
+      end
     end
   end
 end

data/lib/spree/testing_support/common_rake.rb

@@ -1,38 +1,91 @@
 # frozen_string_literal: true
 
-unless defined?(Solidus::InstallGenerator)
-  require 'generators/solidus/install/install_generator'
-end
-
 require 'generators/spree/dummy/dummy_generator'
 
-namespace :common do
-  task :test_app, :user_class do |_t, args|
-    args.with_defaults(user_class: "Spree::LegacyUser")
-    require ENV['LIB_NAME']
+class CommonRakeTasks
+  include Rake::DSL
 
-    ENV["RAILS_ENV"] = 'test'
+  def initialize
+    namespace :common do
+      task :test_app, :user_class do |_t, args|
+        args.with_defaults(user_class: "Spree::LegacyUser")
+        lib_name = ENV['LIB_NAME'] or
+          raise "Please provide a library name via the LIB_NAME environment variable."
+
+        require lib_name
+
+        force_rails_environment_to_test
+
+        Spree::DummyGenerator.start [
+          "--lib-name=#{lib_name}",
+          "--quiet",
+        ]
+
+        # While the dummy app is generated the current directory
+        # within ruby is changed to that of the dummy app.
+        sh({
+          'FRONTEND' => ENV['FRONTEND'] || 'none',
+        }, [
+          'bin/rails',
+          'generate',
+          'solidus:install',
+          Dir.pwd, # use the current dir as Rails.root
+          "--auto-accept",
+          "--admin-preview=#{ENV.fetch('ADMIN_PREVIEW', 'false')}",
+          "--authentication=none",
+          "--payment-method=none",
+          "--migrate=false",
+          "--seed=false",
+          "--sample=false",
+          "--user-class=#{args[:user_class]}",
+          "--quiet",
+        ].shelljoin)
+
+        if Bundler.locked_gems.dependencies['solidus_frontend']
+          sh "bin/rails g solidus_frontend:install --auto-accept"
+        end
+
+        puts "Setting up dummy database..."
 
-    Spree::DummyGenerator.start ["--lib_name=#{ENV['LIB_NAME']}", "--quiet"]
-    Solidus::InstallGenerator.start ["--lib_name=#{ENV['LIB_NAME']}", "--auto-accept", "--with-authentication=false", "--payment-method=none", "--migrate=false", "--seed=false", "--sample=false", "--quiet", "--user_class=#{args[:user_class]}"]
+        sh "bin/rails db:environment:set RAILS_ENV=test"
+        sh "bin/rails db:drop db:create db:migrate VERBOSE=false RAILS_ENV=test"
 
-    puts "Setting up dummy database..."
+        if extension_installation_generator_exists?
+          puts 'Running extension installation generator...'
+          sh "bin/rails generate #{rake_generator_namespace}:install --auto-run-migrations"
+        end
+      end
 
-    sh "bin/rails db:environment:set RAILS_ENV=test"
-    sh "bin/rails db:drop db:create db:migrate VERBOSE=false RAILS_ENV=test"
+      task :seed do |_t, _args|
+        puts "Seeding ..."
 
-    begin
-      require "generators/#{ENV['LIB_NAME']}/install/install_generator"
-      puts 'Running extension installation generator...'
-      "#{ENV['LIB_NAMESPACE'] || ENV['LIB_NAME'].camelize}::Generators::InstallGenerator".constantize.start(["--auto-run-migrations"])
-    rescue LoadError
-      # No extension generator to run
+        sh "bundle exec rake db:seed RAILS_ENV=test"
+      end
     end
   end
 
-  task :seed do |_t, _args|
-    puts "Seeding ..."
+  private
 
-    sh "bundle exec rake db:seed RAILS_ENV=test"
+  def force_rails_environment_to_test
+    ENV["RAILS_ENV"] = 'test'
+    Rails.env = 'test'
+  end
+
+  def extension_installation_generator_exists?
+    require "generators/#{generator_namespace}/install/install_generator"
+
+    true
+  rescue LoadError
+    false
+  end
+
+  def generator_namespace
+    "#{ENV['LIB_NAMESPACE']&.underscore || ENV['LIB_NAME']}"
+  end
+
+  def rake_generator_namespace
+    generator_namespace.gsub("/", ":")
   end
 end
+
+CommonRakeTasks.new

data/lib/spree/testing_support/dummy_ability.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'cancan'
+
+class DummyAbility
+  include CanCan::Ability
+end