solidus_core 2.9.6 → 2.11.0

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    module ControllerHelpers
+      module CurrentHost
+        extend ActiveSupport::Concern
+
+        included do
+          before_action do
+            ActiveStorage::Current.host = request.base_url
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -30,18 +30,19 @@ module Spree
 
         # The current incomplete order from the guest_token for use in cart and during checkout
         def current_order(options = {})
-          options[:create_order_if_necessary] ||= false
+          should_create = options[:create_order_if_necessary] || false
+          should_build = options[:build_order_if_necessary] || should_create
 
           return @current_order if @current_order
 
-          @current_order = find_order_by_token_or_user(options)
+          @current_order = find_order_by_token_or_user(lock: options[:lock])
 
-          if options[:create_order_if_necessary] && (@current_order.nil? || @current_order.completed?)
+          if should_build && (@current_order.nil? || @current_order.completed?)
             @current_order = Spree::Order.new(new_order_params)
             @current_order.user ||= try_spree_current_user
             # See issue https://github.com/spree/spree/issues/3346 for reasons why this line is here
             @current_order.created_by ||= try_spree_current_user
-            @current_order.save!
+            @current_order.save! if should_create
           end
 
           if @current_order
@@ -84,14 +85,14 @@ module Spree
         end
 
         def find_order_by_token_or_user(options = {}, with_adjustments = false)
-          options[:lock] ||= false
+          should_lock = options[:lock] || false
 
           # Find any incomplete orders for the guest_token
           if with_adjustments
             Spree::Deprecation.warn "The second argument to find_order_by_token_or_user is deprecated, and will be removed in a future version."
-            order = Spree::Order.incomplete.includes(:adjustments).lock(options[:lock]).find_by(current_order_params)
+            order = Spree::Order.incomplete.includes(:adjustments).lock(should_lock).find_by(current_order_params)
           else
-            order = Spree::Order.incomplete.lock(options[:lock]).find_by(current_order_params)
+            order = Spree::Order.incomplete.lock(should_lock).find_by(current_order_params)
           end
 
           # Find any incomplete orders for the current user

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|
@@ -47,11 +47,48 @@ module Spree
       # Setup Event Subscribers
       initializer 'spree.core.initialize_subscribers' do |app|
         app.reloader.to_prepare do
-          Spree::Event.subscribers.each(&:subscribe!)
+          Spree::Event.activate_autoloadable_subscribers
         end
 
         app.reloader.before_class_unload do
-          Spree::Event.subscribers.each(&:unsubscribe!)
+          Spree::Event.deactivate_all_subscribers
+        end
+      end
+
+      config.after_initialize do
+        if Spree::Config.raise_with_invalid_currency == true
+          Spree::Deprecation.warn(
+            'Spree::Config.raise_with_invalid_currency set to true is ' \
+            'deprecated. Please note that by switching this value, ' \
+            'Spree::LineItem::CurrencyMismatch will not be raised anymore.',
+            caller
+          )
+        end
+        if Spree::Config.consider_actionless_promotion_active == true
+          Spree::Deprecation.warn(
+            'Spree::Config.consider_actionless_promotion_active set to true is ' \
+            'deprecated. Please note that by switching this value, ' \
+            'promotions with no actions will be considered active.',
+            caller
+          )
+        end
+        if Spree::Config.run_order_validations_on_order_updater != true
+          Spree::Deprecation.warn(
+            'Spree::Config.run_order_validations_on_order_updater set to false is ' \
+            'deprecated and will not be possibile in Solidus 3.0. Please switch this ' \
+            'value to true and check that everything works as expected.',
+            caller
+          )
+        end
+
+        if Spree::Config.use_legacy_address_state_validator != false
+          Spree::Deprecation.warn(<<~DEPRECATION.squish, caller)
+            Spree::Config.use_legacy_address_state_validator set to true has been
+            deprecated and will be removed in Solidus 3.0. The Spree::Address state
+            validation has been extracted into a configurable external class.
+            Switch Spree::Config.use_legacy_address_state_validator to true to start
+            using the external validation class.
+          DEPRECATION
         end
       end
 

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

@@ -29,7 +29,7 @@ module Spree
 
             completed_at = params.delete(:completed_at)
 
-            order.update_attributes!(params)
+            order.update!(params)
 
             order.create_proposed_shipments unless shipments_attrs.present?
 
@@ -53,17 +53,19 @@ 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(id: target[:stock_location_id]) ||
+              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 +73,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 +90,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,26 +100,38 @@ 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_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?
-              line_item.update_attributes!(extra_params)
-            else
-              line_item.save!
+
+          case line_items_hash
+          when Hash
+            line_items_hash.each_key do |key|
+              create_line_item(line_items_hash[key], order)
+            end
+          when Array
+            line_items_hash.each do |line_item_hash|
+              create_line_item(line_item_hash, order)
             end
           end
         end
 
+        def self.create_line_item(line_item_hash, order)
+          extra_params = line_item_hash.except(:variant_id, :quantity, :sku)
+          line_item = ensure_variant_id_from_params(line_item_hash)
+          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?
+            line_item.update!(extra_params)
+          else
+            line_item.save!
+          end
+        end
+
         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 +140,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])
-            source_attributes = p[:source] || p[:source_attributes]
+            payment.state = target[:state] || target[:status] || 'completed'
+            payment.payment_method = Spree::PaymentMethod.find_by!(name: target[:payment_method])
+            source_attributes = target[:source] || target[:source_attributes]
             payment.source = create_source_payment_from_params(source_attributes, payment) if source_attributes
             payment.save!
           end
@@ -171,8 +185,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/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/permalinks.rb

@@ -9,7 +9,7 @@ module Spree
         class_attribute :permalink_options
       end
 
-      module ClassMethods
+      class_methods do
         def make_permalink(options = {})
           options[:field] ||= :permalink
           self.permalink_options = options
@@ -63,5 +63,3 @@ module Spree
     end
   end
 end
-
-ActiveRecord::Base.send :include, Spree::Core::Permalinks

data/lib/spree/core/product_filters.rb

@@ -55,11 +55,12 @@ 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)
         end
+
         Spree::Product.joins(master: :default_price).where(scope)
       end
 
@@ -68,17 +69,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].between(10..15)],
+                 ["#{format_price(15)} - #{format_price(18)}", value[:amount].between(15..18)],
+                 ["#{format_price(18)} - #{format_price(20)}", value[:amount].between(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 +96,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 +108,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.flat_map { |brand| [brand, pp[:value].eq(brand)] }]
         {
           name:   'Brands',
           scope:  :brand_any,
           conds:  conds,
-          labels: brands.sort.map { |k| [k, k] }
+          labels: brands.sort.map { |key| [key, key] }
         }
       end
 
@@ -149,7 +150,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 +172,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 +185,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.flat_map { |element| [element.root] + element.root.descendants }
         {
           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,97 @@
+# 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,
+                  :order
+
+      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 order
+        @order ||= begin
+          if Spree::Config.use_legacy_order_state_machine
+            Spree::Deprecation.warn(
+              "Spree::Order state machine defined in Spree::Order::Checkout is deprecated. " \
+              "Future versions of Solidus will use Spree::Core::StateMachines::Order}",
+              caller
+            )
+            'Spree::Order::Checkout'
+          else
+            require 'spree/core/state_machines/order'
+            'Spree::Core::StateMachines::Order'
+          end
+        end
+
+        @order.constantize
+      end
+
+      def reimbursement
+        @reimbursement ||= begin
+          require 'spree/core/state_machines/reimbursement'
+          'Spree::Core::StateMachines::Reimbursement'
+        end
+
+        @reimbursement.constantize
+      end
+    end
+  end
+end