solidus_core 2.8.6 → 2.9.0.rc.1

data/lib/spree/deprecation.rb

@@ -4,4 +4,54 @@ require 'active_support/deprecation'
 
 module Spree
   Deprecation = ActiveSupport::Deprecation.new('3.0', 'Solidus')
+
+  # 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
 end

data/lib/spree/event.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative 'event/adapters/active_support_notifications'
+require_relative 'event/configuration'
+require_relative 'event/subscriber'
+
+module Spree
+  module Event
+    extend self
+
+    # Allows to trigger events that can be subscribed using #subscribe. An
+    # optional block can be passed that will be executed immediately. The
+    # actual code implementation is delegated to the adapter.
+    #
+    # @param [String] event_name the name of the event. The suffix ".spree"
+    #  will be added automatically if not present
+    # @param [Hash] opts a list of options to be passed to the triggered event
+    #
+    # @example Trigger an event named 'order_finalized'
+    #   Spree::Event.fire 'order_finalized', order: @order do
+    #     @order.finalize!
+    #   end
+    def fire(event_name, opts = {})
+      adapter.fire name_with_suffix(event_name), opts do
+        yield opts if block_given?
+      end
+    end
+
+    # Subscribe to an event with the given name. The provided block is executed
+    # every time the subscribed event is fired.
+    #
+    # @param [String] event_name the name of the event. The suffix ".spree"
+    #  will be added automatically if not present
+    #
+    # @return a subscription object that can be used as reference in order
+    #  to remove the subscription
+    #
+    # @example Subscribe to the `order_finalized` event
+    #   Spree::Event.subscribe 'order_finalized' do |event|
+    #     order = event.payload[:order]
+    #     Spree::Mailer.order_finalized(order).deliver_later
+    #   end
+    #
+    # @see Spree::Event#unsubscribe
+    def subscribe(event_name, &block)
+      name = name_with_suffix(event_name)
+      listener_names << name
+      adapter.subscribe(name, &block)
+    end
+
+    # Unsubscribes a whole event or a specific subscription object
+    #
+    # @param [String, Object] subscriber the event name as a string (with
+    #  or without the ".spree" suffix) or the subscription object
+    #
+    # @example Unsubscribe a single subscription
+    #   subscription = Spree::Event.fire 'order_finalized'
+    #   Spree::Event.unsubscribe(subscription)
+    # @example Unsubscribe all `order_finalized` event subscriptions
+    #   Spree::Event.unsubscribe('order_finalized')
+    # @example Unsubscribe an event by name with explicit prefix
+    #   Spree::Event.unsubscribe('order_finalized.spree')
+    def unsubscribe(subscriber)
+      name_or_subscriber = subscriber.is_a?(String) ? name_with_suffix(subscriber) : subscriber
+      adapter.unsubscribe(name_or_subscriber)
+    end
+
+    # Lists all subscriptions currently registered under the ".spree"
+    # namespace. Actual implementation is delegated to the adapter
+    #
+    # @return [Hash] an hash with event names as keys and arrays of subscriptions
+    #  as values
+    #
+    # @example Current subscriptions
+    #  Spree::Event.listeners
+    #    # => {"order_finalized.spree"=> [#<ActiveSupport...>],
+    #      "reimbursement_reimbursed.spree"=> [#<ActiveSupport...>]}
+    def listeners
+      adapter.listeners_for(listener_names)
+    end
+
+    # The adapter used by Spree::Event, defaults to
+    # Spree::Event::Adapters::ActiveSupportNotifications
+    #
+    # @example Change the adapter
+    #   Spree::Config.events.adapter = "Spree::EventBus.new"
+    #
+    # @see Spree::AppConfiguration
+    def adapter
+      Spree::Config.events.adapter
+    end
+
+    # The suffix used for namespacing Solidus events, defaults to
+    # `.spree`
+    #
+    # @see Spree::Event::Configuration#suffix
+    def suffix
+      Spree::Config.events.suffix
+    end
+
+    private
+
+    def name_with_suffix(name)
+      name.end_with?(suffix) ? name : [name, suffix].join
+    end
+
+    def listener_names
+      @listeners_names ||= Set.new
+    end
+  end
+end

data/lib/spree/event/adapters/active_support_notifications.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Spree
+  module Event
+    module Adapters
+      module ActiveSupportNotifications
+        extend self
+
+        def fire(event_name, opts)
+          ActiveSupport::Notifications.instrument event_name, opts do
+            yield opts if block_given?
+          end
+        end
+
+        def subscribe(event_name)
+          ActiveSupport::Notifications.subscribe event_name do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            yield event
+          end
+        end
+
+        def unsubscribe(subscriber_or_name)
+          ActiveSupport::Notifications.unsubscribe(subscriber_or_name)
+        end
+
+        def listeners_for(names)
+          names.each_with_object({}) do |name, memo|
+            listeners = ActiveSupport::Notifications.notifier.listeners_for(name)
+            memo[name] = listeners if listeners.present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spree/event/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Spree
+  module Event
+    class Configuration
+      attr_writer :adapter, :suffix
+
+      def adapter
+        @adapter ||= Spree::Event::Adapters::ActiveSupportNotifications
+      end
+
+      def suffix
+        @suffix ||= '.spree'
+      end
+    end
+  end
+end

data/lib/spree/event/processors/mailer_processor.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Spree
+  module Event
+    module Processors
+      module MailerProcessor
+        include Spree::Event::Subscriber
+
+        event_action :order_finalized
+        event_action :send_reimbursement_email, event_name: :reimbursement_reimbursed
+
+        def order_finalized(event)
+          order = event.payload[:order]
+          unless order.confirmation_delivered?
+            Spree::Config.order_mailer_class.confirm_email(order).deliver_later
+            order.update_column(:confirmation_delivered, true)
+          end
+        end
+
+        def send_reimbursement_email(event)
+          reimbursement = event.payload[:reimbursement]
+          Spree::Config.reimbursement_mailer_class.reimbursement_email(reimbursement.id).deliver_later
+        end
+      end
+    end
+  end
+end

data/lib/spree/event/subscriber.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Spree
+  module Event
+    # This module simplifies adding and removing subscriptions to {Spree::Event} events.
+    # Here's a complete example:
+    #   module EmailSender
+    #     include Spree::Event::Subscriber
+    #
+    #     event_action :order_finalized
+    #     event_action :confirm_reimbursement, event_name: :reimbursement_reimbursed
+    #
+    #     def order_finalized(event)
+    #       Mailer.send_email(event.payload[:order])
+    #     end
+    #
+    #     def confirm_reimbursement(event)
+    #       Mailer.send_email(event.payload[:reimbursement])
+    #     end
+    #   end
+    #
+    #  EmailSender.subscribe!
+    module Subscriber
+      def self.included(base)
+        base.extend base
+
+        base.mattr_accessor :event_actions
+        base.event_actions = {}
+      end
+
+      # Declares a method name in the including module that can be subscribed/unsubscribed
+      # to an event.
+      #
+      # @param method_name [String, Symbol] the method that will be called when the subscribed event is fired
+      # @param event_name [String, Symbol] the name of the event to be subscribed
+      #
+      # @example Declares 'send_email' as an event action that can subscribe the event 'order_finalized'
+      #   module EmailSender
+      #     event_action :send_email, event_name: :order_finalized
+      #
+      #     def send_email(event)
+      #       Mailer.send_email(event.payload[:order])
+      #     end
+      #   end
+      #
+      # @example Same as above, but the method name is same as the event name:
+      #   module EmailSender
+      #     event_action :order_completed
+      #
+      #     def order_completed(event)
+      #       Mailer.send_email(event.payload[:order])
+      #     end
+      #   end
+      def event_action(method_name, event_name: nil)
+        mattr_accessor "#{method_name}_handler"
+        event_actions[method_name] = (event_name || method_name).to_s
+      end
+
+      # Subscribes all declared event actions to their events. Only actions that are subscribed
+      # will be called when their event fires.
+      #
+      # @example subscribe all event actions for module 'EmailSender'
+      #    EmailSender.subscribe!
+      def subscribe!
+        unsubscribe!
+        event_actions.each do |event_action, event_name|
+          send "#{event_action}_handler=", Spree::Event.subscribe(event_name) { |event|
+            send event_action, event
+          }
+        end
+      end
+
+      # Unsubscribes all declared event actions from their events. This means that when an event
+      # fires then none of its unsubscribed event actions will be called.
+      # @example unsubscribe all event actions for module 'EmailSender'
+      #    EmailSender.unsubscribe!
+      def unsubscribe!
+        event_actions.keys.each do |event_action|
+          Spree::Event.unsubscribe send("#{event_action}_handler")
+        end
+      end
+    end
+  end
+end

data/lib/spree/permitted_attributes.rb

@@ -8,10 +8,7 @@ module Spree
     ATTRIBUTES = [
       :address_attributes,
       :address_book_attributes,
-      :checkout_address_attributes,
-      :checkout_delivery_attributes,
-      :checkout_payment_attributes,
-      :checkout_confirm_attributes,
+      :checkout_attributes,
       :credit_card_update_attributes,
       :customer_return_attributes,
       :image_attributes,
@@ -48,6 +45,10 @@ module Spree
 
     @@address_book_attributes = address_attributes + [:default]
 
+    @@checkout_attributes = [
+      :coupon_code, :email, :special_instructions, :use_billing
+    ]
+
     @@credit_card_update_attributes = [
       :month, :year, :expiry, :first_name, :last_name, :name
     ]
@@ -78,7 +79,7 @@ module Spree
 
     @@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]]
+    @@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]]
 
     @@shipment_attributes = [
       :special_instructions, :stock_location_id, :id, :tracking,
@@ -90,7 +91,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
+      :existing_card_id, :wallet_payment_source_id
     ]
 
     @@stock_item_attributes = [:variant, :stock_location, :backorderable, :variant_id]
@@ -128,75 +129,5 @@ module Spree
       :product_id, :product, :option_values_attributes, :price,
       :weight, :height, :width, :depth, :sku, :cost_currency, option_value_ids: [], options: [:name, :value]
     ]
-
-    @@checkout_address_attributes = [
-      :use_billing,
-      :email,
-      bill_address_attributes: address_attributes,
-      ship_address_attributes: address_attributes
-    ]
-
-    @@checkout_delivery_attributes = [
-      :special_instructions,
-      shipments_attributes: shipment_attributes
-    ]
-
-    @@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)
-      attributes.each do |attribute|
-        PermittedAttributes.checkout_address_attributes.send(method, attribute)
-        PermittedAttributes.checkout_delivery_attributes.send(method, attribute)
-        PermittedAttributes.checkout_payment_attributes.send(method, attribute)
-        PermittedAttributes.checkout_confirm_attributes.send(method, attribute)
-      end
-    end
   end
 end