solidus_support 0.12.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88870615f95d8fe0794ee093b13f2875de6c84390a137352c196c7a6aa97d469
-  data.tar.gz: 2aa7188af2b42c60e90201d4b366673ed4f1b8333cc31d11ce9da7fde534e659
+  metadata.gz: 2cdd9849818af1dc56048136d30a8198d6d79c7245250824283659a47c396932
+  data.tar.gz: e82afa4bcca816ad08c7b0afb4ff09279104c99c111818d96ba26cf0f7dab2f7
 SHA512:
-  metadata.gz: 2f090251b1f4511057d6ec13781d63af4e951d3875818c157b7382e55c1d654a05ff464569af85fdafaa021a0ac3c998af29d29b3a70acb776c976e1becbb943
-  data.tar.gz: dfa6ba3b3ac590ac623f1c707edfb1d09ce369435bb8508feba37feed3908dcacc59c35b9b01ecf3774c3378d42d68c038472c318596e689d30190b43d002b92
+  metadata.gz: f619198e4c09da849dbab523854002358b35183d9c1cf13c5a24ae4001a986b6d5c38c5edc8d4ea06412581f4f14080a0abc1628d948409dbf47dc7be5364ee0
+  data.tar.gz: bb3060ebe160c24dca44376cab8d5c1cdb3bf377cc47312a1a70d15eaeabee3df045d566d464433f86b0943a24dbd5e2cbfd907a89c21374808defc0a054de72

data/README.md

@@ -1,3 +1,5 @@
+[![CircleCI](https://dl.circleci.com/status-badge/img/gh/solidusio/solidus_support/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/solidusio/solidus_support/tree/main)
+
 # SolidusSupport
 
 This gem contains common runtime functionality for Solidus extensions.

data/lib/solidus_support/engine_extensions.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/deprecation"
+require "flickwerk"
 
 module SolidusSupport
   module EngineExtensions
@@ -9,6 +10,7 @@ module SolidusSupport
 
     def self.included(engine)
       engine.extend ClassMethods
+      engine.include Flickwerk
 
       engine.class_eval do
         solidus_decorators_root.glob('*') do |decorators_folder|
@@ -27,6 +29,25 @@ module SolidusSupport
     module ClassMethods
       def activate
         load_solidus_decorators_from(solidus_decorators_root)
+        load_solidus_subscribers_from(solidus_subscribers_root)
+      end
+
+      # Loads Solidus event subscriber files.
+      #
+      # This allows to add event subscribers to extensions without explicitly subscribing them,
+      # similarly to what happens in Solidus core.
+      def load_solidus_subscribers_from(path)
+        if SolidusSupport::LegacyEventCompat.using_legacy?
+          path.glob("**/*_subscriber.rb") do |subscriber_path|
+            require_dependency(subscriber_path)
+          end
+
+          if Spree::Event.respond_to?(:activate_all_subscribers)
+            Spree::Event.activate_all_subscribers
+          else
+            Spree::Event.subscribers.each(&:subscribe!)
+          end
+        end
       end
 
       # Loads decorator files.
@@ -83,7 +104,7 @@ module SolidusSupport
         # by those gems, we work around those gems by adding our paths before
         # `initialize_cache`, which is the Rails initializer called before
         # `set_load_path`.
-        initializer "#{name}_#{engine}_paths", before: :initialize_cache do
+        initializer "#{engine_name}_#{engine}_paths", before: :initialize_cache do
           if SolidusSupport.send(:"#{engine}_available?")
             paths['app/controllers'] << "lib/controllers/#{engine}"
             paths['app/views'] << "lib/views/#{engine}"
@@ -92,9 +113,11 @@ module SolidusSupport
 
         if SolidusSupport.send(:"#{engine}_available?")
           decorators_path = root.join("lib/decorators/#{engine}")
+          patches_path = root.join("lib/patches/#{engine}")
           controllers_path = root.join("lib/controllers/#{engine}")
           components_path = root.join("lib/components/#{engine}")
           config.autoload_paths += decorators_path.glob('*')
+          config.autoload_paths += patches_path.glob("*")
           config.autoload_paths << controllers_path if controllers_path.exist?
           config.autoload_paths << components_path if components_path.exist?
 
@@ -105,6 +128,30 @@ module SolidusSupport
             end
           end
         end
+
+        initializer "#{engine_name}_#{engine}_patch_paths" do
+          patch_paths = root.join("lib/patches/#{engine}").glob("*")
+          Flickwerk.patch_paths += patch_paths
+        end
+
+        initializer "#{engine_name}_#{engine}_user_patches" do |app|
+          app.reloader.to_prepare do
+            Flickwerk.aliases["Spree.user_class"] = Spree.user_class_name
+          end
+        end
+
+        initializer "eager_load_#{engine_name}_#{engine}_patches" do |app|
+          # Solidus versions < 4.5 `require` some of their application code.
+          # This leads to hard-to-debug problems with Flickwerk patches.
+          # What this does is eager-load all the patches in a `to_prepare`
+          # hook by constantizing them.
+          # You can override this behavior by setting the environment variable `SOLIDUS_LAZY_LOAD_PATCHES`.
+          if Spree.solidus_gem_version < Gem::Version.new("4.5.0.a") && !ENV["SOLIDUS_LAZY_LOAD_PATCHES"]
+            app.reloader.to_prepare do
+              Flickwerk.patches.each_value { _1.each(&:constantize) }
+            end
+          end
+        end
       end
     end
   end

data/lib/solidus_support/legacy_event_compat/bus.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SolidusSupport
+  module LegacyEventCompat
+    # Compatibility for some event-driven operations
+    module Bus
+      # Publication of an event
+      #
+      # If extensions want to support the legacy sytem, they need to use a
+      # compatible API. That means it's not possible to publish an instance as
+      # event, which is something supported by Omnes but not the legacy adapter.
+      # Instead, a payload can be given. E.g.:
+      #
+      # ```
+      # SolidusSupport::LegacyEventCompat::Bus.publish(:foo, bar: :baz)
+      # ```
+      #
+      # Legacy subscribers will receive an
+      # `ActiveSupport::Notifications::Fanout`, while omnes subscribers will get
+      # an `Omnes::UnstructuredEvent`. Both instances are compatible as they
+      # implement a `#payload` method.
+      #
+      # @param event_name [Symbol]
+      # @param payload [Hash<Symbol, Any>]
+      def self.publish(event_name, **payload)
+        SolidusSupport.deprecator.warn(
+          "SolidusSupport::LegacyEventCompat::Bus is deprecated and will be removed in solidus_support 1.0." \
+          " Please use Spree::Bus.publish instead."
+        )
+        if SolidusSupport::LegacyEventCompat.using_legacy?
+          Spree::Event.fire(event_name, payload)
+        else
+          Spree::Bus.publish(event_name, **payload, caller_location: caller_locations(1)[0])
+        end
+      end
+    end
+  end
+end

data/lib/solidus_support/legacy_event_compat/subscriber.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+begin
+  require "omnes"
+rescue LoadError
+end
+
+module SolidusSupport
+  module LegacyEventCompat
+    # Compatibility for subscriber modules
+    #
+    # Thanks to this module, extensions can create legacy subscriber modules
+    # (see {Spree::Event::Subscriber}) and translate them automatically to an
+    # {Omnes::Subscriber}). E.g.:
+    #
+    # ```
+    # module MyExtension
+    #   module MySubscriber
+    #     include Spree::Event::Subscriber
+    #     include SolidusSupport::LegacyEventCompat::Subscriber
+    #
+    #     event_action :order_finalized
+    #
+    #     def order_finalized(event)
+    #       event.payload[:order].do_something
+    #     end
+    #   end
+    # end
+    #
+    # MyExtension::MySubscriber.omnes_subscriber.subscribe_to(Spree::Bus)
+    # ```
+    #
+    # The generated omnes subscriptions will call the corresponding legacy
+    # subscriber method with the omnes event. It'll compatible as long as the
+    # omnes event responds to the `#payload` method (see
+    # {Omnes::UnstructuredEvent}).
+    module Subscriber
+      # @api private
+      ADAPTER = lambda do |legacy_subscriber, legacy_subscriber_method, _omnes_subscriber, omnes_event|
+        legacy_subscriber.send(legacy_subscriber_method, omnes_event)
+      end
+
+      def self.included(legacy_subscriber)
+        SolidusSupport.deprecator.warn(
+          "SolidusSupport::LegacyEventCompat::Subscriber is deprecated and will be removed in solidus_support 1.0." \
+          " Please `include Omnes::Subscriber` in `#{legacy_subscriber.name}` instead."
+        )
+        legacy_subscriber.define_singleton_method(:omnes_subscriber) do
+          @omnes_subscriber ||= Class.new.include(::Omnes::Subscriber).tap do |subscriber|
+            legacy_subscriber.event_actions.each do |(legacy_subscriber_method, event_name)|
+              subscriber.handle(event_name.to_sym, with: ADAPTER.curry[legacy_subscriber, legacy_subscriber_method])
+            end
+          end.new
+        end
+      end
+    end
+  end
+end

data/lib/solidus_support/legacy_event_compat.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'solidus_support/legacy_event_compat/bus'
+require 'solidus_support/legacy_event_compat/subscriber'
+
+module SolidusSupport
+  # Compatibility middleman for {Spree::Event} and {Spree::Bus}
+  #
+  # Solidus v3.2 changed to use [Omnes](https://github.com/nebulab/omnes) as the
+  # backbone for event-driven behavior (see {Spree::Bus}) by default. Before
+  # that, a custom adapter based on {ActiveSupport::Notifications} was used (see
+  # {Spree::Event}. Both systems are still supported on v3.2.
+  #
+  # This module provides compatibility support so that extensions can easily
+  # target both systems regardless of the underlying circumstances:
+  #
+  # - Solidus v3.2 with the new system.
+  # - Solidus v3.2 with the legacy system.
+  # - Solidus v2.9 to v3.1, when only {Spree::Event} existed.
+  # - Possible future versions of Solidus, whether the legacy system is
+  # eventually removed or not.
+  module LegacyEventCompat
+    # Returns whether the application is using the legacy event system
+    #
+    # @return [Boolean]
+    def self.using_legacy?
+      legacy_present? &&
+        (legacy_alone? ||
+         legacy_chosen?)
+    end
+
+    def self.legacy_present?
+      defined?(Spree::Event)
+    end
+    private_class_method :legacy_present?
+
+    def self.legacy_alone?
+      !Spree::Config.respond_to?(:use_legacy_events)
+    end
+    private_class_method :legacy_alone?
+
+    def self.legacy_chosen?
+      Spree::Config.use_legacy_events
+    end
+    private_class_method :legacy_chosen?
+  end
+end

data/lib/solidus_support/migration.rb

@@ -3,15 +3,10 @@
 module SolidusSupport
   module Migration
     def self.[](version)
-      if Rails.gem_version >= Gem::Version.new('5.x')
-        ActiveRecord::Migration[version]
-      else
-        # Rails < 5 doesn't support specifying rails version of migrations, but
-        # it _is_ rails 4.2, so we can use that when requested.
-        return ActiveRecord::Migration if version.to_s == '4.2'
-
-        raise ArgumentError, "Unknown migration version '#{version}'; expected one of '4.2'"
-      end
+      SolidusSupport.deprecator.warn(
+        "SolidusSupport::Migration[#{version}] is deprecated. Please use ActiveRecord::Migration[#{version}] instead."
+      )
+      ActiveRecord::Migration[version]
     end
   end
 end

data/lib/solidus_support/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidusSupport
-  VERSION = '0.12.0'
+  VERSION = '0.14.0'
 end

data/lib/solidus_support.rb

@@ -3,6 +3,7 @@
 require 'solidus_support/version'
 require 'solidus_support/deprecator'
 require 'solidus_support/migration'
+require 'solidus_support/legacy_event_compat'
 require 'solidus_support/engine_extensions'
 require 'solidus_core'
 

data/solidus_support.gemspec

@@ -28,6 +28,9 @@ Gem::Specification.new do |spec|
   spec.executables = files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency 'flickwerk', '~> 0.3.4'
+  spec.add_dependency 'solidus_core', '~> 4.1'
+
   spec.add_development_dependency 'rails'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

data/spec/solidus_support/legacy_event_compat/bus_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+RSpec.describe SolidusSupport::LegacyEventCompat::Bus do
+  describe '#publish' do
+    if SolidusSupport::LegacyEventCompat.using_legacy?
+      it 'forwards to Spree::Event' do
+        box = nil
+        subscription = Spree::Event.subscribe(:foo) { |event| box = event.payload[:bar] }
+
+        described_class.publish(:foo, bar: :baz)
+
+        expect(box).to be(:baz)
+      ensure
+        Spree::Event.unsubscribe(subscription)
+      end
+    else
+      it 'forwards to Spree::Bus' do
+        box = nil
+        Spree::Bus.register(:foo)
+        subscription = Spree::Bus.subscribe(:foo) { |event| box = event.payload[:bar] }
+
+        described_class.publish(:foo, bar: :baz)
+
+        expect(box).to be(:baz)
+      ensure
+        Spree::Bus.unsubscribe(subscription)
+        Spree::Bus.registry.unregister(:foo)
+      end
+    end
+  end
+end

data/spec/solidus_support/legacy_event_compat/legacy_event_compat_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'omnes'
+
+RSpec.describe SolidusSupport::LegacyEventCompat::Subscriber, if: Spree.solidus_version < Gem::Version.new("4.0.0.dev") do
+  subject { Module.new.include(Spree::Event::Subscriber).include(described_class) }
+
+  describe '#omnes_subscriber' do
+    it 'returns an Omnes::Subscriber' do
+      subject.module_eval do
+        event_action :foo
+
+        def foo(_event); end
+      end
+
+      expect(subject.omnes_subscriber.is_a?(Omnes::Subscriber)).to be(true)
+    end
+
+    it 'adds single-event definitions matching legacy event actions' do
+      subject.module_eval do
+        event_action :foo
+
+        def foo(_event); end
+      end
+      bus = Omnes::Bus.new
+      bus.register(:foo)
+
+      subscriptions = subject.omnes_subscriber.subscribe_to(bus)
+
+      event = Struct.new(:omnes_event_name).new(:foo)
+      expect(subscriptions.first.matches?(event)).to be(true)
+    end
+
+    it 'coerces event names given as Strings' do
+      subject.module_eval do
+        event_action 'foo'
+
+        def foo(_event); end
+      end
+      bus = Omnes::Bus.new
+      bus.register(:foo)
+
+      subscriptions = subject.omnes_subscriber.subscribe_to(bus)
+
+      event = Struct.new(:omnes_event_name).new(:foo)
+      expect(subscriptions.first.matches?(event)).to be(true)
+    end
+
+    it 'executes legacy event action methods as handlers with the omnes event' do
+      subject.module_eval do
+        event_action :foo
+
+        def foo(event)
+          event[:bar]
+        end
+      end
+      bus = Omnes::Bus.new
+      bus.register(:foo)
+
+      subscriptions = subject.omnes_subscriber.subscribe_to(bus)
+
+      expect(
+        bus.publish(:foo, bar: :baz).executions.first.result
+      ).to be(:baz)
+    end
+
+    it 'distingish when event name is given explicitly' do
+      subject.module_eval do
+        event_action :foo, event_name: :bar
+
+        def foo(_event)
+          :bar
+        end
+      end
+      bus = Omnes::Bus.new
+      bus.register(:bar)
+
+      subscriptions = subject.omnes_subscriber.subscribe_to(bus)
+
+      expect(
+        bus.publish(:bar).executions.first.result
+      ).to be(:bar)
+    end
+
+    it "returns the same omnes subscriber instance if called again" do
+      expect(subject.omnes_subscriber).to be(subject.omnes_subscriber)
+    end
+
+    it "doesn't fail when no event action has been defined" do
+      expect { subject.omnes_subscriber }.not_to raise_error
+    end
+  end
+end

data/spec/support/dummy_app.rb

@@ -14,9 +14,6 @@ module DummyApp
   class Application < ::Rails::Application
     config.eager_load               = false
     config.paths['config/database'] = File.expand_path('dummy_app/database.yml', __dir__)
-    if ActiveRecord::VERSION::MAJOR >= 7 && ActiveRecord::VERSION::MINOR < 1
-      config.active_record.legacy_connection_handling = false
-    end
   end
 end
 

metadata

@@ -1,16 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: solidus_support
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.14.0
 platform: ruby
 authors:
 - John Hawthorn
 - Solidus Team
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-17 00:00:00.000000000 Z
+date: 2025-02-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: flickwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+- !ruby/object:Gem::Dependency
+  name: solidus_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -123,7 +150,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.2
-description:
 email: contact@solidus.io
 executables: []
 extensions: []
@@ -146,9 +172,14 @@ files:
 - lib/solidus_support.rb
 - lib/solidus_support/deprecator.rb
 - lib/solidus_support/engine_extensions.rb
+- lib/solidus_support/legacy_event_compat.rb
+- lib/solidus_support/legacy_event_compat/bus.rb
+- lib/solidus_support/legacy_event_compat/subscriber.rb
 - lib/solidus_support/migration.rb
 - lib/solidus_support/version.rb
 - solidus_support.gemspec
+- spec/solidus_support/legacy_event_compat/bus_spec.rb
+- spec/solidus_support/legacy_event_compat/legacy_event_compat_spec.rb
 - spec/solidus_support_spec.rb
 - spec/spec_helper.rb
 - spec/support/dummy_app.rb
@@ -160,7 +191,6 @@ metadata:
   homepage_uri: https://github.com/solidusio/solidus_support
   source_code_uri: https://github.com/solidusio/solidus_support
   changelog_uri: https://github.com/solidusio/solidus_support/releases
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -175,11 +205,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Common runtime helpers for Solidus extensions.
 test_files:
+- spec/solidus_support/legacy_event_compat/bus_spec.rb
+- spec/solidus_support/legacy_event_compat/legacy_event_compat_spec.rb
 - spec/solidus_support_spec.rb
 - spec/spec_helper.rb
 - spec/support/dummy_app.rb