solidus_core 2.10.0.beta1 → 2.10.5

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      # Inventory Units' 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 InventoryUnit
+        extend ActiveSupport::Concern
+
+        included do
+          state_machine initial: :on_hand do
+            event :fill_backorder do
+              transition to: :on_hand, from: :backordered
+            end
+            after_transition on: :fill_backorder, do: :fulfill_order
+
+            event :ship do
+              transition to: :shipped, if: :allow_ship?
+            end
+
+            event :return do
+              transition to: :returned, from: :shipped
+            end
+
+            event :cancel do
+              transition to: :canceled, from: ::Spree::InventoryUnit::CANCELABLE_STATES.map(&:to_sym)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      # Payments' 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 Payment
+        extend ActiveSupport::Concern
+
+        included do
+          state_machine initial: :checkout do
+            # With card payments, happens before purchase or authorization happens
+            #
+            # Setting it after creating a profile and authorizing a full amount will
+            # prevent the payment from being authorized again once Order transitions
+            # to complete
+            event :started_processing do
+              transition from: [:checkout, :pending, :completed, :processing], to: :processing
+            end
+            # When processing during checkout fails
+            event :failure do
+              transition from: [:pending, :processing], to: :failed
+            end
+            # With card payments this represents authorizing the payment
+            event :pend do
+              transition from: [:checkout, :processing], to: :pending
+            end
+            # With card payments this represents completing a purchase or capture transaction
+            event :complete do
+              transition from: [:processing, :pending, :checkout], to: :completed
+            end
+            event :void do
+              transition from: [:pending, :processing, :completed, :checkout], to: :void
+            end
+            # when the card brand isnt supported
+            event :invalidate do
+              transition from: [:checkout], to: :invalid
+            end
+
+            after_transition do |payment, transition|
+              payment.state_changes.create!(
+                previous_state: transition.from,
+                next_state:     transition.to,
+                name:           'payment'
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      # Reimbursement' 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 Reimbursement
+        extend ActiveSupport::Concern
+
+        included do
+          state_machine :reimbursement_status, initial: :pending do
+            event :errored do
+              transition to: :errored, from: [:pending, :errored]
+            end
+
+            event :reimbursed do
+              transition to: :reimbursed, from: [:pending, :errored]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      # Return Authorizations' 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 ReturnAuthorization
+        extend ActiveSupport::Concern
+
+        included do
+          state_machine initial: :authorized do
+            before_transition to: :canceled, do: :cancel_return_items
+
+            event :cancel do
+              transition to: :canceled, from: :authorized,
+                if: lambda { |return_authorization| return_authorization.can_cancel_return_items? }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# 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

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

@@ -0,0 +1,42 @@
+# 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
+              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

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

@@ -0,0 +1,58 @@
+# 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

data/lib/spree/core/stock_configuration.rb

@@ -5,6 +5,7 @@ module Spree
     class StockConfiguration
       attr_writer :coordinator_class
       attr_writer :estimator_class
+      attr_writer :location_filter_class
       attr_writer :location_sorter_class
       attr_writer :allocator_class
 

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

@@ -15,16 +15,9 @@ module Spree
     EMAIL_REGEXP = /\A([^@\.]|[^@\.]([^@\s]*)[^@\.])@([^@\s]+\.)+[^@\s]+\z/
 
     def validate_each(record, attribute, value)
-      unless value =~ EMAIL_REGEXP
+      unless EMAIL_REGEXP.match? value
         record.errors.add(attribute, :invalid, { value: value }.merge!(options))
       end
     end
   end
 end
-
-# @private
-EmailValidator = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
-  'EmailValidator',
-  'Spree::EmailValidator',
-  message: "EmailValidator is deprecated! Use Spree::EmailValidator instead.\nChange `validates :email, email: true` to `validates :email, 'spree/email' => true`\n"
-)

data/lib/spree/core/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Spree
-  VERSION = "2.10.0.beta1"
+  VERSION = "2.10.5"
 
   def self.solidus_version
     VERSION

data/lib/spree/money.rb

@@ -82,9 +82,9 @@ module Spree
       # 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]}),
+          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]})
+          Instead use :html_wrap e.g. Spree::Money#to_html(html_wrap: #{options[:html].inspect})
         WARN
       end
       if options[:html_wrap] || options[:html]

data/lib/spree/permission_sets/user_management.rb

@@ -11,6 +11,9 @@ module Spree
         can :update_email, Spree.user_class do |user|
           user.spree_roles.none?
         end
+        can :update_password, Spree.user_class do |user|
+          user.spree_roles.none?
+        end
 
         cannot [:delete, :destroy], Spree.user_class
         can :manage, Spree::StoreCredit

data/lib/spree/permitted_attributes.rb

@@ -8,7 +8,10 @@ module Spree
     ATTRIBUTES = [
       :address_attributes,
       :address_book_attributes,
-      :checkout_attributes,
+      :checkout_address_attributes,
+      :checkout_delivery_attributes,
+      :checkout_payment_attributes,
+      :checkout_confirm_attributes,
       :credit_card_update_attributes,
       :customer_return_attributes,
       :image_attributes,
@@ -45,10 +48,6 @@ 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
     ]
@@ -91,7 +90,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
+      :existing_card_id, :wallet_payment_source_id, address_attributes: address_attributes
     ]
 
     @@stock_item_attributes = [:variant, :stock_location, :backorderable, :variant_id]
@@ -117,10 +116,10 @@ module Spree
       :meta_description, :meta_keywords, :meta_title, :child_index
     ]
 
-    # intentionally leaving off email here to prevent privilege escalation
+    # Intentionally leaving off email here to prevent privilege escalation
     # 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
+    # admin owns. Creating a user with an email is handled separate at the
+    # controller level.
     @@user_attributes = [:password, :password_confirmation]
 
     @@variant_attributes = [
@@ -129,5 +128,75 @@ 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