spree_core 6.0.0.rc7 → 6.0.1

data/app/models/spree/stock/coordinator.rb

@@ -22,13 +22,45 @@ module Spree
       end
 
       def packages
-        packages = build_packages
-        packages = prioritize_packages(packages)
-        packages = estimate_packages(packages)
+        estimate_packages(allocated_packages)
       end
 
-      def build_packages(packages = [])
-        stock_locations = stock_locations_with_requested_variants.to_a
+      # Where each unit comes from, without quoting a rate, so a caller that
+      # only needs the origins — a checkout hold — never costs a carrier request.
+      #
+      # @param stock_locations [Array<Spree::StockLocation>] candidate origins, preferred first
+      # @return [Array<Spree::Stock::Package>]
+      def allocated_packages(stock_locations = candidate_stock_locations)
+        prioritize_packages(build_packages(stock_locations: stock_locations))
+      end
+
+      # Whether any delivery method can carry the package to the order's
+      # address, by the rule allocation ranked origins with, so no rate is requested.
+      #
+      # @param package [Spree::Stock::Package]
+      # @return [Boolean]
+      def deliverable?(package)
+        estimator.deliverable?(package)
+      end
+
+      # @param packages [Array<Spree::Stock::Package>]
+      # @return [Array<Spree::Stock::Package>] the same packages, with their delivery rates
+      def estimate_packages(packages)
+        packages.each do |package|
+          package.delivery_rates = estimator.delivery_rates(package)
+        end
+        packages
+      end
+
+      # Active locations stocking any requested variant, in database order.
+      #
+      # @return [Array<Spree::StockLocation>]
+      def candidate_stock_locations
+        order.store.stock_locations.active.joins(:stock_levels)
+             .where(Spree::StockLevel.table_name => { variant_id: requested_variant_ids }).distinct.to_a
+      end
+
+      def build_packages(packages = [], stock_locations: candidate_stock_locations)
         stock_levels = Packer.stock_levels_by_location(stock_locations, requested_variant_ids)
 
         stock_locations.each do |stock_location|
@@ -44,11 +76,6 @@ module Spree
 
       private
 
-      def stock_locations_with_requested_variants
-        order.store.stock_locations.active.joins(:stock_levels).
-          where(Spree::StockLevel.table_name => { variant_id: requested_variant_ids }).distinct
-      end
-
       # An item may only be allocated from locations its delivery profile
       # covers — a profile narrowed to the cold-storage warehouse never packs
       # from anywhere else — intersected with the channel's served set when
@@ -104,13 +131,6 @@ module Spree
         prioritizer.prioritized_packages
       end
 
-      def estimate_packages(packages)
-        packages.each do |package|
-          package.delivery_rates = estimator.delivery_rates(package)
-        end
-        packages
-      end
-
       # Shared between prioritization (which origins can deliver at all) and
       # the rate refresh, so both answer with the same eligibility rules.
       def estimator

data/app/models/spree/stock/packer.rb

@@ -44,25 +44,35 @@ module Spree
         package = build_package
 
         # Group by variant_id as grouping by variant fires cached query.
-        units_by_variant_id = inventory_units.index_by(&:variant_id)
+        units_by_variant_id = inventory_units.group_by(&:variant_id)
         # The package's variants and their levels here, each in one query
         # rather than one per variant. Lowest id first, as StockLocation#stock_level reads.
         variants = variants_for(units_by_variant_id)
         stock_levels = @stock_levels || stock_location.stock_levels.where(variant_id: units_by_variant_id.keys).order(:id).
                        group_by(&:variant_id).transform_values(&:first)
 
-        units_by_variant_id.each do |variant_id, inventory_unit|
+        units_by_variant_id.each do |variant_id, units|
           variant = variants[variant_id] || Spree::Variant.find(variant_id)
-          unit = inventory_unit.dup # Can be used by others, do not use directly
+          # Can be used by others, do not use directly
+          units = units.map(&:dup)
           if variant.should_track_inventory?
             stock_level = stock_levels[variant_id]
             next if stock_level.nil?
 
-            on_hand, backordered = stock_location.fill_status(variant, unit.quantity, stock_level: stock_level)
-            package.add(FulfillmentItem.split(unit, backordered), :backordered) if backordered.positive?
-            package.add(FulfillmentItem.split(unit, on_hand), :on_hand) if on_hand.positive?
+            on_hand, backordered = stock_location.fill_status(variant, units.sum(&:quantity), stock_level: stock_level)
+            # Two lines of one variant draw on one shelf, so it is split
+            # between them in order rather than offered to each in full.
+            units.each do |unit|
+              unit_on_hand = [on_hand, unit.quantity].min
+              unit_backordered = [backordered, unit.quantity - unit_on_hand].min
+              on_hand -= unit_on_hand
+              backordered -= unit_backordered
+
+              package.add(FulfillmentItem.split(unit, unit_backordered), :backordered) if unit_backordered.positive?
+              package.add(FulfillmentItem.split(unit, unit_on_hand), :on_hand) if unit_on_hand.positive?
+            end
           else
-            package.add unit
+            units.each { |unit| package.add unit }
           end
         end
 
@@ -84,8 +94,8 @@ module Spree
       # The units' own variants when they carry them, so a cart's variants are
       # read once however many locations are packed.
       def variants_for(units_by_variant_id)
-        variants = units_by_variant_id.each_with_object({}) do |(variant_id, unit), loaded|
-          loaded[variant_id] = unit.variant if unit.association(:variant).loaded?
+        variants = units_by_variant_id.each_with_object({}) do |(variant_id, units), loaded|
+          loaded[variant_id] = units.first.variant if units.first.association(:variant).loaded?
         end
         missing_ids = units_by_variant_id.keys - variants.keys
         missing_ids.empty? ? variants : variants.merge(Spree::Variant.where(id: missing_ids).index_by(&:id))

data/app/models/spree/stock/prioritizer.rb

@@ -18,6 +18,7 @@ module Spree
 
       def prioritized_packages
         sort_packages
+        withdraw_covered_items
         adjust_packages
         prune_packages
         packages
@@ -44,11 +45,10 @@ module Spree
       end
 
       # Origins that can deliver go first, so the Adjuster fills each unit from
-      # one of them and the origins that cannot are left empty and pruned. A
-      # profile with per-region origin groups would otherwise allocate to
-      # whichever warehouse came first, and when that warehouse's group has no
-      # method for the destination the item is dropped as undeliverable even
-      # though another warehouse could have shipped it.
+      # one of them. A profile with per-region origin groups would otherwise
+      # allocate to whichever warehouse came first, and when that warehouse's
+      # group has no method for the destination the item is dropped as
+      # undeliverable even though another warehouse could have shipped it.
       #
       # The caller's order survives within each group, so routing rank and the
       # store's location order still decide between origins that can both
@@ -56,25 +56,40 @@ module Spree
       def sort_packages
         return if estimator.nil?
 
-        ranked = packages.each_with_index.sort_by do |package, index|
-          [estimator.deliverable?(package) ? 0 : 1, index]
+        deliverable, @undeliverable_packages = packages.partition { |package| estimator.deliverable?(package) }
+        packages.replace(deliverable + @undeliverable_packages)
+      end
+
+      # Ordering alone loses to the Adjuster, which takes stock on hand anywhere
+      # over a backorder; a unit the capable origins cannot cover stays, so it is
+      # still reported as undeliverable rather than lost.
+      def withdraw_covered_items
+        return if @undeliverable_packages.blank? || @undeliverable_packages.size == packages.size
+
+        supplied = supplied_quantities(packages - @undeliverable_packages)
+
+        @undeliverable_packages.each do |package|
+          package.contents.each do |item|
+            package.remove_item(item) if supplied[hash_item(item)] >= item.inventory_unit.required_quantity
+          end
         end
+      end
 
-        packages.replace(ranked.map(&:first))
+      def supplied_quantities(packages)
+        packages.flat_map(&:contents).each_with_object(Hash.new(0)) do |item, supplied|
+          supplied[hash_item(item)] += item.quantity
+        end
       end
 
       def prune_packages
         packages.reject!(&:empty?)
       end
 
+      # A proposed unit has no fulfillment, so its line item keeps two lines of
+      # one variant apart; a pair, as XORed ids collide whenever they match.
       def hash_item(item)
-        shipment = item.inventory_unit.fulfillment
-        variant  = item.inventory_unit.variant
-        if shipment.present?
-          variant.hash ^ shipment.hash
-        else
-          variant.hash
-        end
+        unit = item.inventory_unit
+        [unit.variant, unit.fulfillment || unit.line_item_id]
       end
     end
   end

data/app/models/spree/store.rb

@@ -42,6 +42,11 @@ module Spree
       acts_as_paranoid
       # deleted translation values still need to be accessible - remove deleted_at scope
       default_scope { unscope(where: :deleted_at) }
+
+      # Mobility deletes a row once its last value is cleared. The soft delete
+      # stamps only `deleted_at`, and the row stays readable, so the cleared
+      # values have to be written too or the old translation keeps showing.
+      before_destroy { update_columns(changes_to_save.transform_values(&:last)) if has_changes_to_save? }
     end
 
     #
@@ -50,8 +55,9 @@ module Spree
     UNIT_SYSTEMS = %w[metric imperial].freeze
 
     # general preferences
-    preference :admin_locale, :string, format: :locale
-    preference :timezone, :string, format: :timezone, default: Time.zone.name
+    preference :admin_locale, :string, format: :locale, parse_on_set: ->(value) { Spree::Locales.listed(value) || value.presence }
+    preference :timezone, :string, format: :timezone, default: Spree::TimeZones.normalize(Time.zone.name),
+                                   parse_on_set: ->(value) { Spree::TimeZones.normalize(value) }
     preference :weight_unit, :string, default: 'lb', choices: -> { Spree::Variant::WEIGHT_UNITS }
     preference :unit_system, :string, default: 'imperial', choices: -> { UNIT_SYSTEMS }
     # Anonymous identifier of this installation, kept on the default store
@@ -403,6 +409,8 @@ module Spree
                         message: :invalid_document_number_affix }
     validates :preferred_capture_method, inclusion: { in: Spree::CaptureMethod::CAPTURE_METHODS }
     validate :preferred_storefront_url_is_an_origin
+    validate :preferred_admin_locale_is_listed
+    validate :preferred_timezone_is_a_time_zone
     validate :order_number_sequence_start_unchanged_after_first_number, on: :update
     validates :mail_from_address, email: { allow_blank: false }
     validates :customer_support_email, email: { allow_blank: true }
@@ -836,6 +844,31 @@ module Spree
       errors.add(:preferred_storefront_url, :invalid)
     end
 
+    def preferred_admin_locale_is_listed
+      locale = preferred_admin_locale
+      return if locale.blank? || Spree::Locales::ALL.include?(locale)
+      return if awaiting_upgrade?(:admin_locale) { Spree::Locales.listed(locale) }
+
+      errors.add(:preferred_admin_locale, :inclusion)
+    end
+
+    def preferred_timezone_is_a_time_zone
+      return if Spree::TimeZones.valid?(preferred_timezone)
+      return if awaiting_upgrade?(:timezone) { Spree::TimeZones.valid?(Spree::TimeZones.normalize(preferred_timezone)) }
+
+      errors.add(:preferred_timezone, :invalid)
+    end
+
+    # A value saved before 6.0 that the store settings upgrade step converts
+    # must not block saving the store's other settings until the step runs.
+    # The block says whether the step can convert it.
+    def awaiting_upgrade?(name)
+      return false unless persisted?
+      return false unless public_send(:"preferred_#{name}") == (attribute_was('preferences') || {})[name]
+
+      yield.present?
+    end
+
     # The starting value only shapes a counter that does not exist yet — once
     # the first number is issued the counter owns the value, so accepting a
     # change here would persist a setting that can never apply again. The

data/app/models/spree/upgrade_record.rb

@@ -0,0 +1,62 @@
+module Spree
+  # A release boundary whose data steps this installation has completed
+  # (docs/plans/6.0-maintenance-tasks.md).
+  #
+  # This exists because nothing else in the schema records where an
+  # installation upgraded *from*. `Spree.version` is only ever the gem that is
+  # installed now, so without a stamp the dashboard cannot tell a store that
+  # has been on 5.6 for months from one jumping straight from 5.4 — and would
+  # have to show both every step of every manifest, which grows with each
+  # release.
+  #
+  # Written from three places, none of which guesses:
+  #
+  # - a successful `spree:upgrade` walk stamps the boundary it reached
+  # - a fresh install stamps the current version, because a database created
+  #   by today's schema has no historical data to convert
+  # - an operator can stamp one by hand, for a store upgraded before this
+  #   record existed
+  class UpgradeRecord < Spree.base_class
+    has_prefix_id :upg
+
+    SOURCES = %w[walk install manual].freeze
+
+    validates :version, presence: true, uniqueness: true
+    validates :source, presence: true, inclusion: { in: SOURCES }
+    validates :completed_at, presence: true
+
+    # Whether this installation has ever been upgraded, as opposed to having
+    # been installed at its current version.
+    #
+    # A store installed fresh at 6.0 has no historical data to convert and no
+    # upgrade to perform — showing it a manifest of steps, current or past,
+    # describes work that does not exist for it.
+    #
+    # @return [Boolean]
+    def self.upgraded?
+      where.not(source: 'install').exists?
+    end
+
+    # The highest boundary recorded, or nil when this installation has never
+    # stamped one.
+    #
+    # @return [String, nil]
+    def self.current_version
+      all.map(&:version).max_by { |version| Spree::Upgrade.version_parts(version) }
+    end
+
+    # Records a completed boundary. Idempotent — re-running a walk that has
+    # already been stamped updates when it happened rather than failing.
+    #
+    # @param version [String] two-segment release, e.g. "6.0"
+    # @param source [String] one of SOURCES
+    # @return [Spree::UpgradeRecord]
+    def self.stamp!(version, source: 'walk')
+      record = find_or_initialize_by(version: version.to_s)
+      record.source = source.to_s
+      record.completed_at = Time.current
+      record.save!
+      record
+    end
+  end
+end

data/app/services/spree/carts/update.rb

@@ -252,12 +252,13 @@ module Spree
 
       # Three-way dispatch on the cart→checkout transition:
       # entering checkout → Reserve, mid-checkout mutation → Extend, reverting to cart → Release.
+      # A new destination reserves again, because it can move the units to another origin.
       # A failed Reserve raises so the enclosing transaction rolls back and the
       # outer rescue surfaces the error to the API caller.
       def sync_stock_reservations(was_in_checkout:)
         if !cart.in_checkout?
           Spree::StockReservations::Release.call(cart: cart) if was_in_checkout
-        elsif was_in_checkout
+        elsif was_in_checkout && !@destination_changed && !@new_delivery_destination
           Spree::StockReservations::Extend.call(cart: cart)
         else
           result = Spree::StockReservations::Reserve.call(cart: cart)

data/app/services/spree/maintenance_tasks/argument_parser.rb

@@ -0,0 +1,23 @@
+module Spree
+  module MaintenanceTasks
+    # Turns the CLI's `ARGS='market_id=mkt_1 batch_size=200'` into the hash the
+    # task's ActiveModel attributes expect.
+    #
+    # Values stay strings: attribute types cast them, so the parser never has
+    # to guess whether `200` is a number or a label.
+    module ArgumentParser
+      # Quoted values may contain spaces: ARGS='label="two words" limit=5'.
+      TOKEN = /(\w+)=("[^"]*"|'[^']*'|\S+)/
+
+      # @param raw [String, nil]
+      # @return [Hash{String => String}]
+      def self.parse(raw)
+        return {} if raw.blank?
+
+        raw.scan(TOKEN).to_h do |key, value|
+          [key, value.gsub(/\A["']|["']\z/, '')]
+        end
+      end
+    end
+  end
+end

data/app/services/spree/maintenance_tasks/cancel.rb

@@ -0,0 +1,51 @@
+module Spree
+  module MaintenanceTasks
+    # Stops a run for good. The service records the request and the runner
+    # records the outcome; a run that has not started yet is cancelled
+    # outright, since no execution will ever observe the request.
+    #
+    # Cancelling a run that is already `cancelling` also cancels it outright.
+    # That is the way out when the worker that should have observed the first
+    # request is gone: a run the runner never comes back to would otherwise
+    # stay active and block every new run of its task.
+    #
+    # Cancelling is not a rollback — work already committed stays committed.
+    # What a cancelled run keeps is its cursor, so an operator can see exactly
+    # how far it got.
+    class Cancel
+      prepend ::Spree::ServiceModule::Base
+
+      # @param run [Spree::MaintenanceTaskRun]
+      # @return [Spree::ServiceModule::Base::Result] the run
+      def call(run:)
+        # Locked so the status read here is still the status when it is
+        # written: the runner may finish the run in between, and a finished
+        # run overwritten with `cancelling` would stay active for good.
+        run.with_lock do
+          return failure(run, not_cancelable_error(run)) unless run.active?
+
+          # A running run has a worker mid-batch, so it, not this service,
+          # records that the run stopped.
+          if run.running?
+            run.update!(status: 'cancelling')
+          else
+            run.update!(status: 'cancelled', ended_at: Time.current)
+            run.publish_event('maintenance_task_run.cancelled')
+          end
+        end
+
+        success(run.reload)
+      end
+
+      private
+
+      def not_cancelable_error(run)
+        build_error("a run with status #{run.status} cannot be cancelled")
+      end
+
+      def build_error(message)
+        ActiveModel::Errors.new(Spree::MaintenanceTaskRun.new).tap { |errors| errors.add(:base, message) }
+      end
+    end
+  end
+end

data/app/services/spree/maintenance_tasks/start.rb

@@ -0,0 +1,127 @@
+module Spree
+  module MaintenanceTasks
+    # Creates a run for a registered task and hands it to the runner
+    # (docs/plans/6.0-maintenance-tasks.md).
+    #
+    # Everything that can be known before any work happens is checked here —
+    # the task exists, its parameters validate, and no run of the same task
+    # is already in flight — so an operator sees a 422
+    # rather than a run that dies on its first record.
+    class Start
+      prepend ::Spree::ServiceModule::Base
+
+      # @param task_name [String] a registered Spree::MaintenanceTask subclass name
+      # @param api_type [String] the task's short name, in place of `task_name`
+      #   — how an API caller names it, so a class name never has to cross
+      #   the API
+      # @param arguments [Hash] task parameters
+      # @param dry_run [Boolean] preview mode; only honored by tasks that declare
+      #   `supports_dry_run`
+      # @param initiated_via [String] dashboard / api / cli
+      # @param inline [Boolean] run synchronously (seeds, the CLI, the upgrade walk)
+      # @return [Spree::ServiceModule::Base::Result] the run
+      def call(task_name: nil, api_type: nil, arguments: {}, dry_run: false, admin_user: nil,
+               api_key: nil, initiated_via: 'api', inline: false)
+        task_class = if api_type.nil?
+                       Spree::MaintenanceTask.find_registered(task_name)
+                     else
+                       Spree::MaintenanceTask.find_by_api_type(api_type)
+                     end
+        return failure(nil, unknown_task_error(api_type || task_name)) if task_class.nil?
+
+        task_name = task_class.name
+
+        arguments = (arguments || {}).stringify_keys
+        unknown = arguments.keys - task_class.attribute_names
+        return failure(nil, unknown_arguments_error(unknown)) if unknown.any?
+
+        if initiated_via.to_s.in?(%w[api dashboard]) && superseded_step?(task_class, arguments)
+          return failure(nil, superseded_error(task_class))
+        end
+
+        task = task_class.new(arguments)
+        return failure(task, task.errors) unless task.valid?
+
+        active = active_run_for(task_name)
+        return failure(active, already_running_error(task_class)) if active
+
+        run = build_run(task_class, arguments, dry_run, admin_user, api_key, initiated_via)
+        return failure(run, run.errors) unless run.save
+
+        dispatch(run, inline)
+
+        success(run)
+      end
+
+      private
+
+      def build_run(task_class, arguments, dry_run, admin_user, api_key, initiated_via)
+        Spree::MaintenanceTaskRun.new(
+          task_name: task_class.name,
+          status: Spree::MaintenanceTaskRun.default_status,
+          arguments: arguments,
+          # A task that does not declare dry-run support would ignore the flag
+          # and write for real; recording it as a preview would be a lie.
+          dry_run: dry_run && task_class.dry_run_supported,
+          admin_user: admin_user,
+          api_key: api_key,
+          initiated_via: initiated_via.to_s
+        )
+      end
+
+      # The enqueue waits for the transaction so the worker cannot pick the
+      # job up before the row it names is visible.
+      def dispatch(run, inline)
+        if inline
+          ActiveRecord.after_all_transactions_commit { Spree::MaintenanceTasks::RunJob.perform_now(run.id, inline: true) }
+        else
+          Spree::MaintenanceTasks::RunJob.perform_later(run.id)
+        end
+      end
+
+      # Upgrade steps of a release this installation already completed. The
+      # dashboard never offers them; the command line still runs them, since
+      # that is where an operator deliberately repeats a step.
+      #
+      # Refused even when the completed release was assumed rather than
+      # recorded. The assumption is right for nearly every store, and for
+      # those a repeated conversion damages data; a store that really skipped
+      # a release is told to run its steps from the command line.
+      def superseded_step?(task_class, arguments)
+        Spree::Upgrade.superseded_steps.any? do |step|
+          step['task_class'] == task_class.name ||
+            (task_class <= Spree::MaintenanceTasks::UpgradeStep && step['id'] == arguments['step_id'])
+        end
+      end
+
+      # One run per task at a time. Checked rather than locked: two requests
+      # can both pass this check, and the runner then cancels the newer run
+      # before it does any work (RunJob#duplicate_run?).
+      def active_run_for(task_name)
+        Spree::MaintenanceTaskRun.active.find_by(task_name: task_name)
+      end
+
+      def unknown_task_error(task_name)
+        errors_for(:task_name, "#{task_name} is not a registered maintenance task")
+      end
+
+      def unknown_arguments_error(names)
+        errors_for(:arguments, "the task takes no parameter named #{names.to_sentence}")
+      end
+
+      def superseded_error(task_class)
+        errors_for(:base, "#{task_class.api_type} belongs to a release this store has already completed")
+      end
+
+      def already_running_error(task_class)
+        errors_for(:base, "#{task_class.api_type} is already running")
+      end
+
+      def errors_for(attribute, message)
+        ActiveModel::Errors.new(Spree::MaintenanceTaskRun.new).tap do |errors|
+          errors.add(attribute, message)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/seeds/all.rb

@@ -10,6 +10,8 @@ module Spree
             # countries gem, and zones are migration-only, so none of them
             # are seeded.
 
+            fresh_database = Spree::Store.none?
+
             Stores.call
             Spree::Store.find_each { |store| StoreResources.call(store: store) }
             # The warehouse, delivery zones and pickup are not seeded: their
@@ -18,6 +20,26 @@ module Spree
             # them from the merchant's answer — at first-run setup, or here
             # when ADMIN_EMAIL/ADMIN_PASSWORD name an install that skips it.
             AdminUser.call
+
+            # A database created by today's schema has no historical data to
+            # convert, so every upgrade boundary up to this release is already
+            # satisfied. Recording that is what keeps a fresh install from
+            # being shown a backlog of steps it must never run. Only a database
+            # seeded for the first time qualifies: seeding is also a deploy
+            # step, and an upgraded store seeded before its upgrade ran still
+            # has every step to do.
+            stamp_upgrade_boundaries if fresh_database
+          end
+        end
+      end
+
+      private
+
+      def stamp_upgrade_boundaries
+        Spree::Upgrade.manifests.each do |manifest|
+          Spree::UpgradeRecord.find_or_create_by!(version: manifest['to']) do |record|
+            record.source = 'install'
+            record.completed_at = Time.current
           end
         end
       end