solidus_core 2.9.5 → 2.10.2

data/lib/spree/core/importer/product.rb

@@ -28,11 +28,11 @@ module Spree
         end
 
         def update
-          if product.update_attributes(product_attrs)
+          if product.update(product_attrs)
             variants_attrs.each do |variant_attribute|
               # update the variant if the id is present in the payload
               if variant_attribute['id'].present?
-                product.variants.find(variant_attribute['id'].to_i).update_attributes(variant_attribute)
+                product.variants.find(variant_attribute['id'].to_i).update(variant_attribute)
               else
                 # make sure the product is assigned before the options=
                 product.variants.create({ product: product }.merge(variant_attribute))

data/lib/spree/core/product_filters.rb

@@ -55,7 +55,7 @@ module Spree
       # below scope would be something like ["$10 - $15", "$15 - $18", "$18 - $20"]
       #
       Spree::Product.add_search_scope :price_range_any do |*opts|
-        conds = opts.map { |o| Spree::Core::ProductFilters.price_filter[:conds][o] }.reject(&:nil?)
+        conds = opts.map { |element| Spree::Core::ProductFilters.price_filter[:conds][element] }.reject(&:nil?)
         scope = conds.shift
         conds.each do |new_scope|
           scope = scope.or(new_scope)
@@ -68,17 +68,17 @@ module Spree
       end
 
       def self.price_filter
-        v = Spree::Price.arel_table
-        conds = [[I18n.t('spree.under_price', price: format_price(10)), v[:amount].lteq(10)],
-                 ["#{format_price(10)} - #{format_price(15)}", v[:amount].in(10..15)],
-                 ["#{format_price(15)} - #{format_price(18)}", v[:amount].in(15..18)],
-                 ["#{format_price(18)} - #{format_price(20)}", v[:amount].in(18..20)],
-                 [I18n.t('spree.or_over_price', price: format_price(20)), v[:amount].gteq(20)]]
+        value = Spree::Price.arel_table
+        conds = [[I18n.t('spree.under_price', price: format_price(10)), value[:amount].lteq(10)],
+                 ["#{format_price(10)} - #{format_price(15)}", value[:amount].in(10..15)],
+                 ["#{format_price(15)} - #{format_price(18)}", value[:amount].in(15..18)],
+                 ["#{format_price(18)} - #{format_price(20)}", value[:amount].in(18..20)],
+                 [I18n.t('spree.or_over_price', price: format_price(20)), value[:amount].gteq(20)]]
         {
           name:   I18n.t('spree.price_range'),
           scope:  :price_range_any,
           conds:  Hash[*conds.flatten],
-          labels: conds.map { |k, _v| [k, k] }
+          labels: conds.map { |key, _value| [key, key] }
         }
       end
 
@@ -95,7 +95,7 @@ module Spree
       #   being blank: note that this relies on with_property doing a left outer join
       #   rather than an inner join.
       Spree::Product.add_search_scope :brand_any do |*opts|
-        conds = opts.map { |o| ProductFilters.brand_filter[:conds][o] }.reject(&:nil?)
+        conds = opts.map { |value| ProductFilters.brand_filter[:conds][value] }.reject(&:nil?)
         scope = conds.shift
         conds.each do |new_scope|
           scope = scope.or(new_scope)
@@ -107,12 +107,12 @@ module Spree
         brand_property = Spree::Property.find_by(name: 'brand')
         brands = brand_property ? Spree::ProductProperty.where(property_id: brand_property.id).pluck(:value).uniq.map(&:to_s) : []
         pp = Spree::ProductProperty.arel_table
-        conds = Hash[*brands.map { |b| [b, pp[:value].eq(b)] }.flatten]
+        conds = Hash[*brands.map { |brand| [brand, pp[:value].eq(brand)] }.flatten]
         {
           name:   'Brands',
           scope:  :brand_any,
           conds:  conds,
-          labels: brands.sort.map { |k| [k, k] }
+          labels: brands.sort.map { |key| [key, key] }
         }
       end
 
@@ -149,7 +149,7 @@ module Spree
         {
           name:   'Applicable Brands',
           scope:  :selective_brand_any,
-          labels: brands.sort.map { |k| [k, k] }
+          labels: brands.sort.map { |key| [key, key] }
         }
       end
 
@@ -171,7 +171,7 @@ module Spree
         {
           name:   'Taxons under ' + taxon.name,
           scope:  :taxons_id_in_tree_any,
-          labels: taxon.children.sort_by(&:position).map { |t| [t.name, t.id] },
+          labels: taxon.children.sort_by(&:position).map { |element| [element.name, element.id] },
           conds:  nil
         }
       end
@@ -184,11 +184,11 @@ module Spree
       # idea: expand the format to allow nesting of labels?
       def self.all_taxons
         Spree::Deprecation.warn "all_taxons is deprecated in solidus_core. Please add it to your own application to continue using it."
-        taxons = Spree::Taxonomy.all.map { |t| [t.root] + t.root.descendants }.flatten
+        taxons = Spree::Taxonomy.all.map { |element| [element.root] + element.root.descendants }.flatten
         {
           name:   'All taxons',
           scope:  :taxons_id_equals_any,
-          labels: taxons.sort_by(&:name).map { |t| [t.name, t.id] },
+          labels: taxons.sort_by(&:name).map { |element| [element.name, element.id] },
           conds:  nil # not needed
         }
       end

data/lib/spree/core/role_configuration.rb

@@ -69,8 +69,8 @@ module Spree
     # Not public due to the fact this class is a Singleton
     # @!visibility private
     def initialize
-      @roles = Hash.new do |h, name|
-        h[name] = Role.new(name, Set.new)
+      @roles = Hash.new do |hash, name|
+        hash[name] = Role.new(name, Set.new)
       end
     end
 

data/lib/spree/core/search/variant.rb

@@ -57,7 +57,7 @@ module Spree
         end
 
         def search_term_params(word)
-          terms = Hash[search_terms(word).map { |t| [t, word] }]
+          terms = Hash[search_terms(word).map { |term| [term, word] }]
           terms.merge(m: 'or')
         end
       end

data/lib/spree/core/state_machines.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      attr_writer :reimbursement,
+                  :return_authorization,
+                  :return_item_acceptance,
+                  :return_item_reception,
+                  :payment,
+                  :inventory_unit,
+                  :shipment
+
+      def return_authorization
+        @return_authorization ||= begin
+          require 'spree/core/state_machines/return_authorization'
+          'Spree::Core::StateMachines::ReturnAuthorization'
+        end
+
+        @return_authorization.constantize
+      end
+
+      def return_item_reception
+        @return_item_reception_status ||= begin
+          require 'spree/core/state_machines/return_item/reception_status'
+          'Spree::Core::StateMachines::ReturnItem::ReceptionStatus'
+        end
+
+        @return_item_reception_status.constantize
+      end
+
+      def return_item_acceptance
+        @return_item_acceptance_status ||= begin
+          require 'spree/core/state_machines/return_item/acceptance_status'
+          'Spree::Core::StateMachines::ReturnItem::AcceptanceStatus'
+        end
+
+        @return_item_acceptance_status.constantize
+      end
+
+      def payment
+        @payment ||= begin
+          require 'spree/core/state_machines/payment'
+          'Spree::Core::StateMachines::Payment'
+        end
+
+        @payment.constantize
+      end
+
+      def inventory_unit
+        @inventory_unit ||= begin
+          require 'spree/core/state_machines/inventory_unit'
+          'Spree::Core::StateMachines::InventoryUnit'
+        end
+
+        @inventory_unit.constantize
+      end
+
+      def shipment
+        @shipment ||= begin
+          require 'spree/core/state_machines/shipment'
+          'Spree::Core::StateMachines::Shipment'
+        end
+
+        @shipment.constantize
+      end
+
+      def reimbursement
+        @reimbursement ||= begin
+          require 'spree/core/state_machines/reimbursement'
+          'Spree::Core::StateMachines::Reimbursement'
+        end
+
+        @reimbursement.constantize
+      end
+    end
+  end
+end

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