solidus_core 2.10.0.beta1 → 2.10.0

data/lib/spree/core.rb

@@ -53,6 +53,17 @@ module Spree
   end
 end
 
+if Gem::Version.new(Rails.version) < Gem::Version.new('5.2')
+  warn <<~HEREDOC
+    Rails 5.1 (EOL) is deprecated and will not be supported anymore from the next Solidus version.
+    Please, upgrade to a more recent Rails version.
+
+    Read more on upgrading from Rails 5.1 to Rails 5.2 here:
+    https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-5-1-to-rails-5-2
+
+  HEREDOC
+end
+
 require 'spree/core/version'
 
 require 'spree/core/active_merchant_dependencies'
@@ -85,6 +96,7 @@ require 'spree/core/controller_helpers/search'
 require 'spree/core/controller_helpers/store'
 require 'spree/core/controller_helpers/strong_parameters'
 require 'spree/core/role_configuration'
+require 'spree/core/state_machines'
 require 'spree/core/stock_configuration'
 require 'spree/core/validators/email'
 require 'spree/permission_sets'

data/lib/spree/core/controller_helpers/auth.rb

@@ -50,19 +50,7 @@ module Spree
         end
 
         def store_location
-          # disallow return to login, logout, signup pages
-          authentication_routes = [:spree_signup_path, :spree_login_path, :spree_logout_path]
-          disallowed_urls = []
-          authentication_routes.each do |route|
-            if respond_to?(route)
-              disallowed_urls << send(route)
-            end
-          end
-
-          disallowed_urls.map!{ |url| url[/\/\w+$/] }
-          unless disallowed_urls.include?(request.fullpath)
-            session['spree_user_return_to'] = request.fullpath.gsub('//', '/')
-          end
+          Spree::UserLastUrlStorer.new(self).store_location
         end
 
         # proxy method to *possible* spree_current_user method

data/lib/spree/core/engine.rb

@@ -11,8 +11,8 @@ module Spree
       isolate_namespace Spree
       engine_name 'spree'
 
-      config.generators do |g|
-        g.test_framework :rspec
+      config.generators do |generator|
+        generator.test_framework :rspec
       end
 
       initializer "spree.environment", before: :load_config_initializers do |app|

data/lib/spree/core/environment_extension.rb

@@ -22,6 +22,15 @@ module Spree
           end
         end
       end
+
+      def add_class(name)
+        Spree::Deprecation.warn(
+          'This method is deprecated. ' \
+          "Please use `#{self.class}.add_class_set(#{name.inspect})` instead.",
+          caller,
+        )
+        singleton_class.send(:add_class_set, name)
+      end
     end
   end
 end

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

@@ -53,17 +53,17 @@ module Spree
         def self.create_shipments_from_params(shipments_hash, order)
           return [] unless shipments_hash
 
-          shipments_hash.each do |s|
+          shipments_hash.each do |target|
             shipment = Shipment.new
-            shipment.tracking       = s[:tracking]
-            shipment.stock_location = Spree::StockLocation.find_by(admin_name: s[:stock_location]) || Spree::StockLocation.find_by!(name: s[:stock_location])
+            shipment.tracking       = target[:tracking]
+            shipment.stock_location = Spree::StockLocation.find_by(admin_name: target[:stock_location]) || Spree::StockLocation.find_by!(name: target[:stock_location])
 
-            inventory_units = s[:inventory_units] || []
-            inventory_units.each do |iu|
-              ensure_variant_id_from_params(iu)
+            inventory_units = target[:inventory_units] || []
+            inventory_units.each do |inventory_unit|
+              ensure_variant_id_from_params(inventory_unit)
 
-              unless line_item = order.line_items.find_by(variant_id: iu[:variant_id])
-                line_item = order.contents.add(Spree::Variant.find(iu[:variant_id]), 1)
+              unless line_item = order.line_items.find_by(variant_id: inventory_unit[:variant_id])
+                line_item = order.contents.add(Spree::Variant.find(inventory_unit[:variant_id]), 1)
               end
 
               # Spree expects a Inventory Unit to always reference a line
@@ -71,14 +71,14 @@ module Spree
               # trying to view these units. Note the Importer might not be
               # able to find the line item if line_item.variant_id |= iu.variant_id
               shipment.inventory_units.new(
-                variant_id: iu[:variant_id],
+                variant_id: inventory_unit[:variant_id],
                 line_item: line_item
               )
             end
 
             # Mark shipped if it should be.
-            if s[:shipped_at].present?
-              shipment.shipped_at = s[:shipped_at]
+            if target[:shipped_at].present?
+              shipment.shipped_at = target[:shipped_at]
               shipment.state      = 'shipped'
               shipment.inventory_units.each do |unit|
                 unit.state = 'shipped'
@@ -88,9 +88,9 @@ module Spree
             order.shipments << shipment
             shipment.save!
 
-            shipping_method = Spree::ShippingMethod.find_by(name: s[:shipping_method]) || Spree::ShippingMethod.find_by!(admin_name: s[:shipping_method])
+            shipping_method = Spree::ShippingMethod.find_by(name: target[:shipping_method]) || Spree::ShippingMethod.find_by!(admin_name: target[:shipping_method])
             rate = shipment.shipping_rates.create!(shipping_method: shipping_method,
-                                                   cost: s[:cost])
+                                                   cost: target[:cost])
             shipment.selected_shipping_rate_id = rate.id
             shipment.update_amounts
           end
@@ -98,9 +98,9 @@ module Spree
 
         def self.create_line_items_from_params(line_items_hash, order)
           return {} unless line_items_hash
-          line_items_hash.each_key do |k|
-            extra_params = line_items_hash[k].except(:variant_id, :quantity, :sku)
-            line_item = ensure_variant_id_from_params(line_items_hash[k])
+          line_items_hash.each_key do |key|
+            extra_params = line_items_hash[key].except(:variant_id, :quantity, :sku)
+            line_item = ensure_variant_id_from_params(line_items_hash[key])
             line_item = order.contents.add(Spree::Variant.find(line_item[:variant_id]), line_item[:quantity])
             # Raise any errors with saving to prevent import succeeding with line items failing silently.
             if extra_params.present?
@@ -113,11 +113,11 @@ module Spree
 
         def self.create_adjustments_from_params(adjustments, order)
           return [] unless adjustments
-          adjustments.each do |a|
+          adjustments.each do |target|
             adjustment = order.adjustments.build(
               order:  order,
-              amount: a[:amount].to_d,
-              label:  a[:label]
+              amount: target[:amount].to_d,
+              label:  target[:label]
             )
             adjustment.save!
             adjustment.finalize!
@@ -126,14 +126,14 @@ module Spree
 
         def self.create_payments_from_params(payments_hash, order)
           return [] unless payments_hash
-          payments_hash.each do |p|
+          payments_hash.each do |target|
             payment = order.payments.build order: order
-            payment.amount = p[:amount].to_f
+            payment.amount = target[:amount].to_f
             # Order API should be using state as that's the normal payment field.
             # spree_wombat serializes payment state as status so imported orders should fall back to status field.
-            payment.state = p[:state] || p[:status] || 'completed'
-            payment.payment_method = Spree::PaymentMethod.find_by!(name: p[:payment_method])
-            payment.source = create_source_payment_from_params(p[:source], payment) if p[:source]
+            payment.state = target[:state] || target[:status] || 'completed'
+            payment.payment_method = Spree::PaymentMethod.find_by!(name: target[:payment_method])
+            payment.source = create_source_payment_from_params(target[:source], payment) if target[:source]
             payment.save!
           end
         end
@@ -170,8 +170,8 @@ module Spree
             search[:iso_name] = iso_name.upcase
           elsif iso = address[:country]['iso']
             search[:iso] = iso.upcase
-          elsif iso3 = address[:country]['iso3']
-            search[:iso3] = iso3.upcase
+          elsif iso_three = address[:country]['iso3']
+            search[:iso3] = iso_three.upcase
           end
 
           address.delete(:country)

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