spree_core 5.6.0 → 6.0.0.beta1

data/app/models/spree/taxon.rb

@@ -1,518 +1,17 @@
 # frozen_string_literal: true
 
-require 'stringex'
-
 module Spree
-  class Taxon < Spree.base_class
-    include Spree::SingleStoreResource
-
-    has_prefix_id :ctg
-
-    RULES_MATCH_POLICIES = %w[all any].freeze
-    SORT_ORDERS = [
-      'manual',
-      'best_selling',
-      'price asc',
-      'price desc',
-      'available_on desc',
-      'available_on asc',
-      'name asc',
-      'name desc'
-    ].freeze
-
-    include Spree::TranslatableResource
-    include Spree::TranslatableResourceSlug
-    include Spree::Metafields
-    include Spree::Metadata
-    include Spree::MemoizedData
-
-    MEMOIZED_METHODS = %w[cached_self_and_descendants_ids].freeze
-
-    #
-    # Magic methods
-    #
-    extend FriendlyId
-    friendly_id :permalink, slug_column: :permalink, use: :history
-    acts_as_nested_set dependent: :destroy, counter_cache: :children_count
-
-    #
-    # Associations
-    #
-    belongs_to :taxonomy, class_name: 'Spree::Taxonomy', inverse_of: :taxons
-    belongs_to :store, class_name: 'Spree::Store', optional: true
-    has_many :classifications, -> { order(:position) }, dependent: :destroy_async, inverse_of: :taxon
-    has_many :products, through: :classifications
-
-    has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon', dependent: :destroy
-    has_many :prototypes, through: :prototype_taxons, class_name: 'Spree::Prototype'
-
-    has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', dependent: :destroy
-    has_many :promotion_rules, through: :promotion_rule_taxons, class_name: 'Spree::PromotionRule'
-
-    #
-    # Attachments
-    #
-    has_one_attached :image, service: Spree.public_storage_service_name
-    has_one_attached :square_image, service: Spree.public_storage_service_name
-
-    #
-    # Validations
-    #
-    validates :name, presence: true
-    validates :taxonomy, presence: true, if: :requires_taxonomy?
-    validates :store, presence: true
-    # Taxonomy-backed taxons are unique within their taxonomy; taxonomy-less
-    # categories (store-owned) are unique within their store, so two stores can
-    # each have a top-level "Shoes".
-    validates :name, uniqueness: { scope: %i[parent_id taxonomy_id], case_sensitive: false }, if: :requires_taxonomy?
-    validates :permalink, uniqueness: { scope: %i[parent_id taxonomy_id], case_sensitive: false }, if: :requires_taxonomy?
-    validates :name, uniqueness: { scope: %i[parent_id store_id], case_sensitive: false }, unless: :requires_taxonomy?
-    validates :permalink, uniqueness: { scope: %i[parent_id store_id], case_sensitive: false }, unless: :requires_taxonomy?
-    validates :hide_from_nav, inclusion: { in: [true, false] }
-    validate :check_for_root, on: :create
-    validate :parent_belongs_to_same_taxonomy
-    with_options length: { maximum: 255 }, allow_blank: true do
-      validates :meta_keywords
-      validates :meta_description
-      validates :meta_title
-    end
-    validates :image, :square_image, content_type: Rails.application.config.active_storage.web_image_content_types
-
-    #
-    # Callbacks
-    #
-    before_validation :set_permalink, if: :name
-    before_validation :copy_taxonomy_from_parent
-    before_save :set_pretty_name
-    after_save :touch_ancestors_and_taxonomy
-    after_update :sync_taxonomy_name
-    after_touch :touch_ancestors_and_taxonomy
-    after_commit :regenerate_pretty_name_and_permalink, on: :update, if: :should_regenerate_pretty_name_and_permalink?
-    after_move :regenerate_pretty_name_and_permalink
-    after_move :regenerate_translations_pretty_name_and_permalink
-    # Moving a subtree shifts its products under a new ancestor chain (and away
-    # from the old one), so recompute both branches' inclusive products_count.
-    # Capture the old parent before the move; recompute both chains after.
-    before_move :capture_parent_before_move
-    after_move :recalculate_products_count_after_move
-    # Destroying a taxon drops its subtree's products from every ancestor's
-    # inclusive count. Recompute the ancestors here (while the doomed subtree's
-    # rows still exist) excluding that subtree, since the Classification destroy
-    # callbacks can't help: classifications are removed via destroy_async, so
-    # they outlive this callback and their taxon may already be gone.
-    before_destroy :recalculate_ancestors_before_destroy, prepend: true
-
-    #
-    # Scopes
-    #
-    # Prefer the direct store_id column; fall back to the taxonomy join for rows
-    # not yet backfilled (store_id IS NULL) so legacy behaviour is preserved.
-    scope :for_store, ->(store) { for_stores([store]) }
-    scope :for_stores, lambda { |stores|
-      store_ids = Array(stores).map(&:id)
-      taxonomy_ids = Spree::Taxonomy.where(store_id: store_ids).select(:id)
-      where(store_id: store_ids).or(where(store_id: nil, taxonomy_id: taxonomy_ids))
-    }
-    scope :for_taxonomy, lambda { |taxonomy_name|
-      Spree::Deprecation.warn('Spree::Taxon.for_taxonomy is deprecated and will be removed in Spree 6. Please use for_store instead.')
-
-      if Spree.use_translations?
-        joins(:taxonomy)
-          .join_translation_table(Taxonomy)
-          .where(
-            Taxonomy.arel_table_alias[:name].lower.matches(taxonomy_name.downcase.strip)
-          )
-      else
-        joins(:taxonomy).where(Spree::Taxonomy.arel_table[:name].lower.matches(taxonomy_name.downcase.strip))
-      end
-    }
-
-    #
-    # Search
-    #
-    def self.search_by_name(query)
-      i18n { name.lower.matches("%#{query.downcase}%") }
-    end
-
-    scope :with_matching_name, lambda { |name_to_match|
-      value = name_to_match.to_s.strip.downcase
-
-      if Spree.use_translations?
-        i18n { name.lower.eq(value) }
-      else
-        where(arel_table[:name].lower.eq(value))
-      end
-    }
-
-    #
-    #  Ransack
-    #
-    self.whitelisted_ransackable_associations = %w[taxonomy parent]
-    self.whitelisted_ransackable_attributes = %w[name permalink automatic depth is_root children_count
-                                                 classification_count products_count pretty_name hide_from_nav parent_id]
-
-    #
-    # Translations
-    #
-    TRANSLATABLE_FIELDS = %i[name pretty_name description permalink].freeze
-    RICH_TEXT_TRANSLATABLE_FIELDS = %i[description].freeze
-    translates(*TRANSLATABLE_FIELDS, column_fallback: Spree.mobility_column_fallback)
-
-    #
-    # Action Text
-    #
-    translates :description, backend: :action_text
-
-    # Automatic taxons
-    validates :rules_match_policy, inclusion: { in: RULES_MATCH_POLICIES }, presence: true
-    validates :sort_order, inclusion: { in: SORT_ORDERS }, presence: true
-
-    has_many :taxon_rules, class_name: 'Spree::TaxonRule', dependent: :destroy
-    accepts_nested_attributes_for :taxon_rules, allow_destroy: true, reject_if: proc { |attributes|
-      attributes['value'].blank?
-    }
-    alias rules taxon_rules
-
-    scope :manual, -> { where.not(automatic: true) }
-    scope :automatic, -> { where(automatic: true) }
-
-    after_commit :regenerate_taxon_products, on: [:update], if: -> { automatic? && saved_change_to_rules_match_policy? }
-    attribute :marked_for_regenerate_taxon_products, :boolean, default: true
-
-    def manual?
-      !automatic?
-    end
-
-    # The owning store. Prefers the direct +store_id+; falls back to the
-    # taxonomy's store for legacy rows not yet backfilled.
-    def store
-      super || taxonomy&.store
-    end
-
-    # Whether a taxonomy is mandatory. Legacy +Spree::Taxon+ requires one;
-    # +Spree::Category+ overrides this to false (it is owned via +store_id+).
-    def requires_taxonomy?
-      true
-    end
-
-    def manual_sort_order?
-      sort_order == 'manual'
-    end
-
-    def active_products_with_descendants
-      @active_products_with_descendants ||= store.products
-                                                 .joins(:classifications)
-                                                 .active
-                                                 .where(
-                                                   Spree::Classification.table_name => {
-                                                     taxon_id: descendants.ids + [id]
-                                                   }
-                                                 )
-    end
-
-    # Recomputes the stored, descendant-inclusive +products_count+ for the given
-    # taxons AND all of their ancestors — the nodes whose inclusive count can
-    # shift when a classification changes. Counts unique products classified
-    # under each node or its descendants (a product reachable through several
-    # nodes is counted once per ancestor). Call after any classification change.
-    #
-    # @param taxon_ids [Array<Integer>] taxons whose branch counts changed
-    def self.recalculate_products_count(taxon_ids)
-      changed = unscoped.where(id: Array(taxon_ids).compact.uniq)
-
-      # The affected nodes are each changed taxon plus its ancestors.
-      affected = changed.flat_map { |taxon| taxon.self_and_ancestors.to_a }.uniq(&:id)
-
-      affected.each do |taxon|
-        count = Spree::Classification.where(taxon_id: taxon.self_and_descendants.select(:id))
-                                     .distinct.count(:product_id)
-        taxon.update_column(:products_count, count) if taxon.products_count != count
-      end
-    end
-
-    def products_matching_rules(opts = {})
-      return Spree::Product.none if manual? || rules.empty?
-
-      storefront = opts[:storefront] || false
-      currency = opts[:currency] || store.default_currency
-
-      all_products = store.products.not_archived
-
-      products_matcher_cache_key = [
-        'products_matching_rules',
-        cache_key_with_version,
-        storefront,
-        currency,
-        all_products.cache_key_with_version
-      ]
-
-      all_products = all_products.active(currency: currency) if storefront
-
-      any_rules_match_policy = rules_match_policy == 'any'
-      products = any_rules_match_policy ? Spree::Product.none : all_products
-
-      rules.each do |rule|
-        if any_rules_match_policy
-          product_ids = rule.apply(all_products).ids
-          # it's safer to use this approach with ids as it will not break if the rule is not a simple where clause
-          # and we will avoid `ArgumentError (Relation passed to #or must be structurally compatible. Incompatible values: [:group, :order, :joins, :readonly])` error
-          products = products.or(all_products.where(id: product_ids)) if product_ids.any?
-        else
-          products = rule.apply(products)
-        end
-      end
-
-      products
-    end
-
-    # we need to create a new taxon product (classification) record for each product that matches the rules
-    # so we can later use them for product filtering and so on
-    # if we want to fire the service once during object lifecycle - pass only_once: true
-    def regenerate_taxon_products(only_once: false)
-      return unless marked_for_regenerate_taxon_products?
-
-      Spree::Taxons::RegenerateProducts.call(taxon: self)
-      self.marked_for_regenerate_taxon_products = false if !frozen? && only_once
-    end
-
-    def slug
-      permalink
-    end
-
-    def slug=(value)
-      self.permalink = value
-    end
-
-    self::Translation.class_eval do
-      before_save :set_permalink
-      before_save :set_pretty_name
-      after_save :regenerate_pretty_name_and_permalink, if: :should_regenerate_pretty_name_and_permalink?
-
-      def slug
-        permalink
-      end
-
-      def slug=(value)
-        self.permalink = value
-      end
-
-      def set_permalink
-        self.permalink = generate_slug
-      end
-
-      def set_pretty_name
-        self.pretty_name = generate_pretty_name
-      end
-
-      def name_with_fallback
-        name.blank? ? translated_model[:name] : name
-      end
-
-      def pretty_name_with_fallback
-        pretty_name.blank? ? translated_model[:pretty_name] : pretty_name
-      end
-
-      def regenerate_pretty_name_and_permalink
-        Spree::Taxon::Translation.where(spree_taxon_id: translated_model.cached_self_and_descendants_ids).each(&:update_pretty_name_and_permalink)
-      end
-
-      def update_pretty_name_and_permalink
-        update_columns(pretty_name: generate_pretty_name, permalink: generate_slug, updated_at: Time.current)
-      end
-
-      private
-
-      def generate_slug
-        if parent.present?
-          generate_permalink_including_parent
-        elsif permalink.blank?
-          name_with_fallback.to_url
-        else
-          permalink.to_url
-        end
-      end
-
-      def generate_pretty_name
-        if parent.present?
-          generate_pretty_name_including_parent
-        elsif pretty_name.blank?
-          name_with_fallback
-        else
-          pretty_name
-        end
-      end
-
-      def generate_permalink_including_parent
-        [parent_permalink_with_fallback,
-         (permalink.blank? ? name_with_fallback.to_url : permalink.split('/').last.to_url)].join('/')
-      end
-
-      def generate_pretty_name_including_parent
-        [parent_pretty_name_with_fallback, (name.blank? ? name_with_fallback : name)].compact.join(' -> ')
-      end
-
-      def parent
-        translated_model.parent
-      end
-
-      def parent_permalink_with_fallback
-        localized_parent = parent.translations.find_by(locale: locale)
-        localized_parent.present? ? localized_parent.permalink : parent[:permalink]
-      end
-
-      def parent_pretty_name_with_fallback
-        localized_parent = parent.translations.find_by(locale: locale)
-        localized_parent.present? ? localized_parent.pretty_name : parent[:pretty_name]
-      end
-
-      def should_regenerate_pretty_name_and_permalink?
-        saved_changes.key?(:name) || saved_changes.key?(:permalink)
-      end
-    end
-
-    # Return meta_title if set otherwise generates from taxon name
-    def seo_title
-      meta_title.blank? ? name : meta_title
-    end
-
-    def set_pretty_name
-      self.pretty_name = generate_pretty_name
-    end
-
-    def generate_pretty_name
-      [parent&.pretty_name, name].compact.join(' -> ')
-    end
-
-    def generate_slug
-      if parent.present?
-        [parent.permalink, (permalink.blank? ? name.to_url : permalink.split('/').last.to_url)].join('/')
-      elsif permalink.blank?
-        name.to_url
-      else
-        permalink.to_url
-      end
-    end
-
-    def set_permalink
-      if Spree.use_translations?
-        translations.each(&:set_permalink)
-      else
-        self.permalink = generate_slug
-      end
-    end
-
-    def regenerate_pretty_name_and_permalink
-      Mobility.with_locale(nil) do
-        update_columns(pretty_name: generate_pretty_name, permalink: generate_slug, updated_at: Time.current)
-      end
-
-      children.reload.each(&:regenerate_pretty_name_and_permalink_as_child)
-    end
-
-    def regenerate_pretty_name_and_permalink_as_child
-      Mobility.with_locale(nil) do
-        update_columns(pretty_name: generate_pretty_name, permalink: generate_slug, updated_at: Time.current)
-      end
-
-      children.reload.each(&:regenerate_pretty_name_and_permalink_as_child)
-    end
-
-    def cached_self_and_descendants_ids
-      @cached_self_and_descendants_ids ||= Rails.cache.fetch("#{cache_key_with_version}/descendant-ids") do
-        self_and_descendants.ids
-      end
-    end
-
-    # awesome_nested_set sorts by :lft and :rgt. This call re-inserts the child
-    # node so that its resulting position matches the observable 0-indexed position.
-    # ** Note ** no :position column needed - a_n_s doesn't handle the reordering if
-    #  you bring your own :order_column.
-    #
-    #  See #3390 for background.
-    def child_index=(idx)
-      move_to_child_with_index(parent, idx.to_i) unless new_record?
-    end
-
-    private
-
-    def should_regenerate_pretty_name_and_permalink?
-      saved_changes.key?(:name) || saved_changes.key?(:permalink)
-    end
-
-    def sync_taxonomy_name
-      return unless taxonomy.present?
-      return unless saved_changes.key?(:name) && root?
-      return if taxonomy.name.to_s == name.to_s
-
-      taxonomy.update(name: name)
-    end
-
-    def touch_ancestors_and_taxonomy
-      # Touches all ancestors at once to avoid recursive taxonomy touch, and reduce queries.
-      ancestors.update_all(updated_at: Time.current)
-      # Have taxonomy touch happen in #touch_ancestors_and_taxonomy rather than association option in order for imports to override.
-      taxonomy.touch if taxonomy.present?
-    end
-
-    def capture_parent_before_move
-      @parent_id_before_move = parent_id_in_database
-    end
-
-    # Recompute the inclusive products_count for the moved node's new ancestor
-    # chain and the previous parent's chain too (whose subtree just lost this
-    # node's products).
-    def recalculate_products_count_after_move
-      affected = [id, @parent_id_before_move].compact
-      @parent_id_before_move = nil
-      self.class.recalculate_products_count(affected)
-    end
-
-    # Recomputes each ancestor's inclusive products_count as if this subtree were
-    # already gone (its classifications are destroyed asynchronously, so they're
-    # still present here). Excludes self_and_descendants from the count.
-    def recalculate_ancestors_before_destroy
-      doomed_ids = self_and_descendants.ids
-      ancestors.each do |ancestor|
-        remaining = Spree::Classification.
-                    where(taxon_id: ancestor.self_and_descendants.where.not(id: doomed_ids).select(:id)).
-                    distinct.count(:product_id)
-        ancestor.update_column(:products_count, remaining) if ancestor.products_count != remaining
-      end
-    end
-
-    def check_for_root
-      return unless taxonomy.try(:root).present? && parent_id.nil?
-
-      errors.add(:root_conflict, 'this taxonomy already has a root taxon')
-    end
-
-    def parent_belongs_to_same_taxonomy
-      return unless parent.present? && parent.taxonomy_id != taxonomy_id
-
-      errors.add(:parent, 'must belong to the same taxonomy')
-    end
-
-    def copy_taxonomy_from_parent
-      self.taxonomy = parent.taxonomy if parent.present? && taxonomy.blank?
-    end
-
-    def set_store
-      Spree::Deprecation.warn('Spree::Taxon#set_store is deprecated and will be removed in Spree 6.0. ensure_store instead.')
-      ensure_store
-    end
-
-    # Every taxon is store-owned. Resolve the store from the taxonomy, then the
-    # parent, finally the current store — so the direct column is always
-    # populated for new records. Guards on the raw +store_id+ column rather than
-    # +#store+, whose reader masks an unset column with the taxonomy fallback.
-    def ensure_store
-      return if store_id.present?
-
-      self.store = taxonomy&.store || parent&.store || Spree::Store.current
-    end
-
-    def regenerate_translations_pretty_name_and_permalink
-      translations.each(&:regenerate_pretty_name_and_permalink)
-    end
-  end
+  # Deprecation alias for Spree::Category, renamed from Spree::Taxon in 6.0.
+  # Retained for one release so existing code and extensions that reference
+  # Spree::Taxon keep working; the canonical class is Spree::Category. Removed
+  # in 6.1 (along with the spree_taxonomies table and the automatic-taxon columns).
+  #
+  # This is a true constant alias — the underlying class, table (spree_categories),
+  # prefix (ctg), and model_name are all Spree::Category. Only the constant differs,
+  # so is_a?, STI, polymorphic *_type strings, and class_name: references keep
+  # resolving to Spree::Category. The warning below fires through Spree's deprecator
+  # when this file loads (at boot under eager load, on first reference otherwise).
+  Taxon = Category
+
+  Spree::Deprecation.warn('Spree::Taxon is deprecated and will be removed in Spree 6.1. Use Spree::Category instead.')
 end

data/app/models/spree/taxon_rule.rb

@@ -9,19 +9,18 @@ module Spree
       does_not_contain
     ].freeze
 
-    belongs_to :taxon, class_name: 'Spree::Taxon', inverse_of: :taxon_rules, touch: true
+    # Category no longer declares the has_many :taxon_rules inverse (categories are
+    # manual in 6.0), so this is a plain belongs_to. Data-only until 6.1.
+    belongs_to :taxon, class_name: 'Spree::Category', touch: true
 
-    validates :taxon, :type, :value, presence: true
+    validates :type, :value, presence: true
     validates :match_policy, inclusion: { in: MATCH_POLICIES }, presence: true
 
-    after_commit :regenerate_taxon_products, if: -> { saved_change_to_value? || destroyed? || saved_change_to_match_policy? }
-
     delegate :store, to: :taxon
 
-    private
-
-    def regenerate_taxon_products
-      taxon.regenerate_taxon_products(only_once: true)
-    end
+    # Retained as a data-only model in 6.0 so the taxons -> collections data
+    # migration can read existing automatic-taxon rules; dropped in 6.1 along
+    # with the spree_taxon_rules table. Automatic membership now lives on
+    # Spree::Collection (rule matching + regeneration moved there).
   end
 end

data/app/models/spree/taxonomy.rb

@@ -1,53 +1,19 @@
 module Spree
+  # @deprecated Data-only in 6.0. Categories are store-owned via +store_id+ and
+  #   nothing creates or reads a taxonomy at runtime any more. The model and the
+  #   spree_taxonomies table are retained solely so the 5.6 -> 6.0 upgrade task
+  #   (spree:migrate_categories_and_collections) can read existing rows to
+  #   backfill category store_id, and so an interrupted upgrade can be rolled
+  #   back. Both drop in 6.1.
   class Taxonomy < Spree.base_class
     has_prefix_id :txnmy  # Spree-specific: taxonomy
 
-    include Spree::TranslatableResource
-    include Spree::Metafields
-    include Spree::Metadata
     include Spree::SingleStoreResource
 
-    TRANSLATABLE_FIELDS = %i[name].freeze
-    translates(*TRANSLATABLE_FIELDS, column_fallback: Spree.mobility_column_fallback)
-
-    acts_as_list
-
-    validates :name, presence: true, uniqueness: { case_sensitive: false, scope: :store_id }
-    validates :store, presence: true
-
-    has_many :taxons, inverse_of: :taxonomy
-    has_one :root, -> { where parent_id: nil }, class_name: 'Spree::Taxon', dependent: :destroy
+    has_many :taxons, class_name: 'Spree::Category', inverse_of: :taxonomy
+    has_one :root, -> { where parent_id: nil }, class_name: 'Spree::Category', dependent: :destroy
     belongs_to :store, class_name: 'Spree::Store'
 
-    after_create :set_root
-    after_update :set_root_taxon_name
-
     default_scope { order("#{table_name}.position, #{table_name}.created_at") }
-
-    scope :with_matching_name, ->(name_to_match) do
-      value = name_to_match.to_s.strip.downcase
-
-      if Spree.use_translations?
-        i18n { name.lower.eq(value) }
-      else
-        where(arel_table[:name].lower.eq(value))
-      end
-    end
-
-    self.whitelisted_ransackable_attributes = %w[name]
-    self.whitelisted_ransackable_associations = %w[root]
-
-    private
-
-    def set_root
-      self.root ||= Taxon.create!(taxonomy_id: id, name: name)
-    end
-
-    def set_root_taxon_name
-      return unless saved_changes.key?(:name)
-      return if name.to_s == root.name.to_s
-
-      root.update(name: name)
-    end
   end
 end

data/app/models/spree/user_identity.rb

@@ -21,7 +21,7 @@ module Spree
 
     # Find or create user from OAuth data
     def self.find_or_create_from_oauth(provider:, uid:, info:, tokens: {}, user_class: nil)
-      user_class ||= Spree.user_class
+      user_class ||= Spree.customer_class
       user_type = user_class.name
 
       identity = find_by(provider: provider, uid: uid, user_type: user_type)
@@ -57,7 +57,7 @@ module Spree
     end
 
     def self.create_user_from_oauth(provider:, uid:, info:, tokens: {}, user_class: nil)
-      user_class ||= Spree.user_class
+      user_class ||= Spree.customer_class
 
       transaction do
         user = user_class.create!(