spree_core 5.5.3 → 5.6.0.rc1

data/app/models/concerns/spree/store_scoped_resource.rb

@@ -1,8 +1,18 @@
 module Spree
+  # @deprecated Use a single-store +belongs_to :store+ FK instead. This concern
+  #   modelled the historic many-to-many store relationship (Promotion,
+  #   PaymentMethod) and is removed in Spree 6.0 once those models finish
+  #   migrating to single-store ownership. See
+  #   docs/plans/5.6-6.0-single-store-promotions-payment-methods.md.
   module StoreScopedResource
     extend ActiveSupport::Concern
 
     included do
+      Spree::Deprecation.warn(
+        "Spree::StoreScopedResource is deprecated and will be removed in Spree 6.0. " \
+        "Use a single-store `belongs_to :store` FK instead (see Spree::Promotion / Spree::PaymentMethod)."
+      )
+
       scope :for_store, ->(store) { joins(:stores).where(Store.table_name => { id: store.id }) }
 
       before_validation :set_default_store, if: :new_record?

data/app/models/concerns/spree/stores/markets.rb

@@ -91,7 +91,8 @@ module Spree
                                        end
       end
 
-      # Returns supported locales derived from markets, falling back to store attributes
+      # Supported locale codes derived from markets, falling back to store
+      # attributes.
       # @return [Array<String>]
       def supported_locales_list
         @supported_locales_list ||= if has_markets?
@@ -101,6 +102,13 @@ module Spree
                                     end
       end
 
+      # Supported locales as rich Spree::Locale objects (name, default?, rtl?).
+      # The string-code form is +supported_locales_list+.
+      # @return [Array<Spree::Locale>]
+      def supported_locales
+        @supported_locales ||= supported_locales_list.map { |code| Spree::Locale.new(code: code) }
+      end
+
       # Returns true if the store has markets, false otherwise
       # @return [Boolean]
       def has_markets?

data/app/models/concerns/spree/stores/setup.rb

@@ -3,50 +3,64 @@ module Spree
     module Setup
       extend ActiveSupport::Concern
 
-      def setup_task_done?(task)
-        case task
-        when :setup_payment_method
-          payment_method_setup?
-        when :setup_taxes_collection
-          Spree::TaxRate.any?
-        when :add_products
-          products.any?
-        when :set_customer_support_email
-          customer_support_email.present?
+      # The evaluated Getting Started checklist for this store, in display
+      # order — what the Admin API serializes and every other setup method
+      # derives from. Memoized per instance: the dashboard evaluates the
+      # checklist several times per render (sidebar badge, progress bar, task
+      # list) and each done-check costs a query.
+      #
+      # @return [Array<Spree::SetupTask>]
+      def setup_tasks
+        return [] if deleted?
+
+        @setup_tasks ||= Spree.store_setup_tasks.for(self).map do |definition|
+          Spree::SetupTask.new(name: definition.key.to_s, done: definition.done?(self))
         end
       end
 
-      def setup_tasks_total
-        @setup_tasks_total = setup_tasks_list.count
+      # Drop the memoized checklist with the rest of the instance's state, so
+      # a mutate-then-rerender flow (e.g. a Turbo Stream update) can re-read
+      # completion within one request.
+      def reload(options = nil)
+        @setup_tasks = nil
+        super
       end
 
-      def setup_tasks_list
-        return [] if deleted?
+      def setup_task_done?(task)
+        setup_tasks.find { |t| t.name == task.to_s }&.done
+      end
 
-        @setup_tasks_list = []
-        @setup_tasks_list << :setup_payment_method
-        @setup_tasks_list << :add_products
-        @setup_tasks_list << :set_customer_support_email
-        @setup_tasks_list << :setup_taxes_collection
+      def setup_tasks_list
+        setup_tasks.map { |task| task.name.to_sym }
+      end
 
-        @setup_tasks_list
+      def setup_tasks_total
+        setup_tasks.size
       end
 
       def setup_tasks_done
-        @setup_tasks_done = setup_tasks_list.select { |task| setup_task_done?(task) }.count
+        setup_tasks.count(&:done)
       end
 
       def setup_completed?
-        @setup_completed ||= setup_tasks_done == setup_tasks_total
+        setup_tasks_done == setup_tasks_total
       end
 
       def setup_percentage
-        @setup_percentage ||= (setup_tasks_done / setup_tasks_total.to_f * 100).to_i
+        return 0 if setup_tasks_total.zero?
+
+        (setup_tasks_done / setup_tasks_total.to_f * 100).to_i
       end
 
       def payment_method_setup?
         payment_methods.active.where.not(type: Spree::PaymentMethod::StoreCredit.to_s).any?
       end
+
+      # A storefront counts as set up once the merchant has saved the storefront
+      # URL (entered manually or backfilled by the Vercel callback).
+      def storefront_setup?
+        preferred_storefront_url.present?
+      end
     end
   end
 end

data/app/models/concerns/spree/translatable_resource.rb

@@ -5,11 +5,6 @@ module Spree
     included do
       extend Mobility
       default_scope { i18n }
-
-      def get_field_with_locale(locale, field_name, fallback: false)
-        # method will return nil if no translation is present due to fallback: false setting
-        public_send(field_name, locale: locale, fallback: fallback)
-      end
     end
 
     class_methods do
@@ -17,6 +12,39 @@ module Spree
         const_get(:TRANSLATABLE_FIELDS)
       end
 
+      # Maps a public API field name to the internal Mobility field, for models
+      # whose translatable column has a legacy name (e.g. OptionType exposes
+      # +label+ but stores +presentation+). The public name is what the API
+      # serializer and translation matrix use; the writer alias (+label=+)
+      # already routes to the internal field through Mobility. Override per
+      # model; default is identity.
+      #
+      # @return [Hash{Symbol=>Symbol}] public_name => internal_field
+      def translatable_field_aliases
+        {}
+      end
+
+      # The translatable fields by their PUBLIC API name (read/write symmetry),
+      # substituting any aliased public name for the internal field.
+      #
+      # @return [Array<Symbol>]
+      def public_translatable_fields
+        inverse = translatable_field_aliases.invert
+        translatable_fields.map { |field| inverse[field] || field }
+      end
+
+      # Translatable fields that hold rich text (HTML). Drives generic editor
+      # rendering — the translation matrix tags these as +html+ so the SPA shows
+      # a rich-text editor instead of a plain input. A +text+ column is
+      # type-indistinguishable from a plain string, so the model must declare
+      # which of its fields are rich text (via a +RICH_TEXT_TRANSLATABLE_FIELDS+
+      # constant). Default is none.
+      #
+      # @return [Array<Symbol>] public field names
+      def translatable_rich_text_fields
+        const_defined?(:RICH_TEXT_TRANSLATABLE_FIELDS) ? const_get(:RICH_TEXT_TRANSLATABLE_FIELDS) : []
+      end
+
       def translation_table_alias
         "#{self::Translation.table_name}_#{Mobility.normalize_locale(Mobility.locale)}"
       end
@@ -25,5 +53,67 @@ module Spree
         Arel::Table.new(translation_table_alias)
       end
     end
+
+    def get_field_with_locale(locale, field_name, fallback: false)
+      # method will return nil if no translation is present due to fallback: false setting
+      public_send(field_name, locale: locale, fallback: fallback)
+    end
+
+    # Upserts per-locale, per-field translations.
+    #
+    # Semantics (omit-to-leave-alone, never implicit-delete):
+    # - a locale absent from +values+ is untouched
+    # - a field absent within a present locale is untouched
+    # - a field set to +""+ writes an empty string (read falls back to source
+    #   via Mobility +column_fallback+); +nil+ deletes that cell
+    #
+    # Value normalization (HTML sanitization, slug parameterization) is owned by
+    # the model's own writers — this only routes each value to its setter under
+    # the right locale.
+    #
+    # @param values [Hash{String=>Hash{String=>String,nil}}] locale => { field => value }
+    # @raise [ActiveRecord::RecordInvalid] on an unsupported locale or invalid save
+    # @return [self]
+    def upsert_translations(values)
+      return self if values.blank?
+
+      validate_translation_locales!(values.keys)
+      # Accept (and write) the PUBLIC field names so read/write are symmetric
+      # with the serializer. `label=` etc. delegate to the internal Mobility
+      # field under the active locale.
+      allowed = self.class.public_translatable_fields.map(&:to_s)
+
+      transaction do
+        values.each do |locale, fields|
+          Mobility.with_locale(locale) do
+            fields.to_h.slice(*allowed).each { |field, value| public_send("#{field}=", value) }
+          end
+        end
+        save!
+      end
+
+      self
+    end
+
+    # The store whose supported locales gate which translations are allowed and
+    # which locales the matrix exposes. The record's own store when it has one,
+    # else the current store.
+    def translatable_store
+      return self if is_a?(Spree::Store)
+
+      try(:store) || Spree::Current.store
+    end
+
+    private
+
+    # @raise [ActiveRecord::RecordInvalid] if any locale isn't supported by the store
+    def validate_translation_locales!(locales)
+      supported = translatable_store&.supported_locales_list || []
+      unsupported = locales.map(&:to_s) - supported.map(&:to_s)
+      return if unsupported.empty?
+
+      errors.add(:base, :unsupported_locale, message: "Unsupported locale(s): #{unsupported.join(', ')}")
+      raise ActiveRecord::RecordInvalid, self
+    end
   end
 end

data/app/models/concerns/spree/user_methods.rb

@@ -48,7 +48,10 @@ module Spree
       # Token auto-invalidates when password changes (salt changes)
       # Expiration is configurable via Spree::Config.customer_password_reset_expires_in (in minutes)
       generates_token_for :password_reset, expires_in: Spree::Config.customer_password_reset_expires_in.minutes do
-        password_salt&.last(10) || encrypted_password&.last(10)
+        # `try` rather than `&.`: models without a password_salt method or
+        # column at all (modern Devise) must fall through to encrypted_password
+        # — a bare call would raise NameError before the fallback.
+        try(:password_salt)&.last(10) || encrypted_password&.last(10)
       end
 
       # we need to have this callback before any dependent: :destroy associations
@@ -85,6 +88,17 @@ module Spree
       belongs_to :ship_address, class_name: 'Spree::Address', optional: true
       belongs_to :bill_address, class_name: 'Spree::Address', optional: true
 
+      # Replaces the customer's group membership. Accepts both prefixed IDs and
+      # raw integer IDs. Only groups belonging to the current store are
+      # assigned — ids from another store are dropped, preventing cross-store
+      # membership. Mirrors +Spree::Product#category_ids=+.
+      def customer_group_ids=(ids)
+        decoded_ids = Array(ids).filter_map do |id|
+          id.to_s.include?('_') ? Spree::CustomerGroup.decode_prefixed_id(id) : id
+        end
+        super(Spree::CustomerGroup.for_store(Spree::Current.store).where(id: decoded_ids).ids)
+      end
+
       #
       # Attachments
       #
@@ -200,7 +214,18 @@ module Spree
     def total_available_store_credit(currency = nil, store = nil)
       store ||= Store.default
       currency ||= store.default_currency
-      store_credits.without_gift_card.for_store(store).where(currency: currency).reload.to_a.sum(&:amount_remaining)
+
+      # When the association is already loaded (e.g. preloaded via the admin
+      # API's scope_includes), filter in memory to avoid an N+1 — but mirror
+      # the query branch exactly: non-gift-card credits, scoped to the store
+      # and currency. A gift card is identified by its originator_type.
+      if store_credits.loaded?
+        store_credits.
+          select { |sc| sc.originator_type != 'Spree::GiftCard' && sc.store_id.to_s == store.id.to_s && sc.currency == currency }.
+          sum(&:amount_remaining)
+      else
+        store_credits.without_gift_card.for_store(store).where(currency: currency).to_a.sum(&:amount_remaining)
+      end
     end
 
     # Returns the available store credits for the current store per currency

data/app/models/spree/ability.rb

@@ -45,17 +45,18 @@ module Spree
     end
 
     # Determines the role names for the current user, scoped to the current
-    # store. A +Spree::RoleUser+ binds a role to a store via +resource+, so a
-    # role held on one store does not apply on another.
+    # store. A +Spree::RoleUser+ is bound to a store via its +store_id+ (set from
+    # the role's resource), so a role held on one store does not apply on another,
+    # independent of the polymorphic +resource+ the role is attached to.
     #
     # @return [Array<Symbol>] the role names
     def determine_role_names
       return [:default] unless @user.persisted?
 
       if @user.respond_to?(:role_users)
-        role_names = @user.role_users.where(resource: @store).
+        role_names = @user.role_users.where(store: @store).
                      joins(:role).
-                     pluck("#{Spree::Role.table_name}.name").map(&:to_sym)
+                     pluck("#{Spree::Role.table_name}.name").map(&:to_sym).uniq
         return role_names if role_names.any?
       end
 

data/app/models/spree/allowed_origin.rb

@@ -32,6 +32,37 @@ module Spree
       nil
     end
 
+    # Normalizes free-form input (possibly a bare host like `my-shop.vercel.app`)
+    # to a canonical origin string (`scheme://host[:port]`, the scheme's default
+    # port stripped), or nil when it's not a valid http(s) URL.
+    #
+    # @param raw [String, nil]
+    # @return [String, nil]
+    def self.normalize_origin(raw)
+      raw = raw.to_s.strip
+      return if raw.blank?
+
+      candidate = raw.match?(%r{\Ahttps?://}i) ? raw : "https://#{raw}"
+      parsed = parse_origin(candidate)
+      return if parsed.nil?
+
+      origin = "#{parsed[:scheme]}://#{parsed[:host]}"
+      # Strip only the scheme's own default — https://host:80 must keep its
+      # port, or the normalized origin would silently mean a different one.
+      default_port = parsed[:scheme] == 'https' ? 443 : 80
+      origin += ":#{parsed[:port]}" unless parsed[:port] == default_port
+      origin
+    end
+
+    # Whether this origin points at a loopback/development host ({LOOPBACK_HOSTS}),
+    # e.g. the `http://localhost` origin seeded on install. Loopback origins are
+    # ignored when deciding if a real storefront has been connected to the store.
+    #
+    # @return [Boolean]
+    def loopback?
+      LOOPBACK_HOSTS.include?(self.class.parse_origin(origin)&.dig(:host))
+    end
+
     # Returns true if the given URL's origin matches this stored origin.
     #
     # Scheme and host must match exactly (host comparison is case- and trailing-dot-

data/app/models/spree/category.rb

@@ -1,6 +1,16 @@
 module Spree
-  # Public API name for Taxon. Will become the base class in 6.0
-  # when spree_taxons table is renamed to spree_categories.
+  # Public API name for Taxon, used by the admin dashboard. Unlike a legacy
+  # +Spree::Taxon+, a Category does not require a +Spree::Taxonomy+ — it is
+  # owned directly via +store_id+, so a parentless category is a genuine
+  # top-level node. (Legacy taxonomy-backed taxons are unaffected.) Will become
+  # the base class in 6.0 when +Spree::Taxonomy+ is dropped and +spree_taxons+
+  # is renamed to +spree_categories+.
   class Category < Taxon
+    default_scope { manual }
+
+    # A category is owned directly via +store_id+ and never needs a taxonomy.
+    def requires_taxonomy?
+      false
+    end
   end
 end

data/app/models/spree/channel/gating.rb

@@ -0,0 +1,67 @@
+module Spree
+  class Channel
+    # Storefront access gating for a channel. Decides what an anonymous
+    # (not-logged-in) visitor may see and whether an order may be placed
+    # without an account. Both controls fall back to the owning Store when the
+    # channel preference is unset, mirroring +OrderRouting::HasStrategyPreference+.
+    module Gating
+      extend ActiveSupport::Concern
+
+      # Posture controlling catalog/price visibility for anonymous visitors:
+      # - +public+         products + prices visible to anyone
+      # - +prices_hidden+  products browsable, prices null for guests
+      # - +login_required+ catalog reads rejected for guests
+      STOREFRONT_ACCESS = %w[public prices_hidden login_required].freeze
+
+      included do
+        # Empty -> falls back to the Store-level preference. `guest_checkout` is
+        # `nullable` so a blank write stays nil (inherit) rather than coercing to
+        # false, while an explicit true/false remains a channel override.
+        preference :storefront_access, :string, default: nil
+        preference :guest_checkout, :boolean, default: nil, nullable: true
+
+        validate :storefront_access_must_be_valid
+      end
+
+      # @return [String] the effective access posture: the channel preference,
+      #   or the store fallback when unset, defaulting to +public+.
+      def resolved_storefront_access
+        preferred_storefront_access.presence ||
+          store&.preferred_storefront_access.presence ||
+          'public'
+      end
+
+      # @return [Boolean] whether guest checkout is allowed: the channel
+      #   preference, or the store fallback when the channel value is unset.
+      def resolved_guest_checkout
+        value = preferred_guest_checkout
+        return value unless value.nil?
+
+        store.nil? ? true : store.preferred_guest_checkout
+      end
+
+      # @return [Boolean] true when guests must not see prices on this channel.
+      def storefront_prices_hidden?
+        resolved_storefront_access == 'prices_hidden'
+      end
+
+      # @return [Boolean] true when guests must authenticate before browsing.
+      def storefront_login_required?
+        resolved_storefront_access == 'login_required'
+      end
+
+      private
+
+      def storefront_access_must_be_valid
+        value = preferred_storefront_access
+        return if value.blank?
+        return if STOREFRONT_ACCESS.include?(value.to_s)
+
+        errors.add(
+          :preferred_storefront_access,
+          Spree.t(:invalid_storefront_access, scope: [:errors, :messages], default: 'is not a valid storefront access level')
+        )
+      end
+    end
+  end
+end

data/app/models/spree/channel.rb

@@ -11,6 +11,7 @@ module Spree
     include Spree::Metafields
     include Spree::Metadata
     include Spree::OrderRouting::HasStrategyPreference
+    include Spree::Channel::Gating
 
     # Empty -> falls back to the Store-level preference.
     preference :order_routing_strategy, :string, default: nil

data/app/models/spree/classification.rb

@@ -13,6 +13,12 @@ module Spree
     # For #3494
     validates :taxon_id, uniqueness: { scope: :product_id, message: :already_linked, allow_blank: true }
 
+    # Keep the taxon's descendant-inclusive products_count (and its ancestors')
+    # in sync on direct create/destroy. Bulk Taxons::AddProducts/RemoveProducts
+    # skip these callbacks and recompute explicitly.
+    after_create :recalculate_taxon_products_count
+    after_destroy :recalculate_taxon_products_count
+
     self.whitelisted_ransackable_attributes = ['taxon_id', 'product_id']
 
     scope :by_best_selling, lambda { |order_direction = :desc|
@@ -36,5 +42,11 @@ module Spree
         end
       end
     }
+
+    private
+
+    def recalculate_taxon_products_count
+      Spree::Taxon.recalculate_products_count(taxon_id)
+    end
   end
 end

data/app/models/spree/country.rb

@@ -31,7 +31,7 @@ module Spree
       pluck(:name, :id, :iso).map do |name, id, iso|
         {
           id: id,
-          name: "#{iso_to_emoji_flag(iso)} #{name}"
+          name: new(iso: iso, name: name).option_label
         }
       end.as_json
     end
@@ -46,6 +46,27 @@ module Spree
       @current_market ||= Spree::Current.store&.market_for_country(self)
     end
 
+    # Display name localized to +locale+ via the countries gem (CLDR), falling
+    # back to the stored +name+ (or the ISO when there is no name) for an
+    # unknown ISO or missing translation.
+    # @param locale [Symbol, String]
+    # @return [String]
+    def localized_name(locale: I18n.locale)
+      fallback = name.presence || iso.to_s
+      data = ISO3166::Country[iso.to_s.upcase]
+      return fallback unless data
+
+      base_locale = locale.to_s.downcase.tr('_', '-').split('-').first
+      (data.translation(base_locale) || data.translation(:en)).presence || fallback
+    end
+
+    # Flag emoji + localized name, for select options.
+    # @param locale [Symbol, String]
+    # @return [String]
+    def option_label(locale: I18n.locale)
+      "#{self.class.iso_to_emoji_flag(iso)} #{localized_name(locale: locale)}"
+    end
+
     def <=>(other)
       name <=> other.name
     end

data/app/models/spree/credit_card.rb

@@ -37,6 +37,11 @@ module Spree
       validates :name, presence: true
     end
 
+    # Prevents saving the same physical card (same gateway fingerprint + expiry)
+    # twice for a user and payment method. Skipped when the gateway does not
+    # provide a fingerprint.
+    validate :fingerprint_not_duplicated, if: -> { fingerprint.present? }
+
     scope :with_payment_profile, -> { where.not(gateway_customer_profile_id: nil) }
     scope :capturable, -> { where.not(gateway_customer_profile_id: nil).or(where.not(gateway_payment_profile_id: nil)) }
     scope :default, -> { where(default: true) }
@@ -47,6 +52,19 @@ module Spree
     }
     scope :not_removed, -> { where(deleted_at: nil) }
 
+    # Matches saved cards by the gateway's stable card fingerprint plus expiry,
+    # used to reuse an existing card instead of saving a duplicate when a gateway
+    # issues a fresh payment method id for the same physical card.
+    #
+    # @param fingerprint [String] gateway card fingerprint
+    # @param month [Integer, String] expiry month
+    # @param year [Integer, String] expiry year
+    scope :by_fingerprint, ->(fingerprint, month, year) {
+      where(fingerprint: fingerprint).
+        where("CAST(#{table_name}.month AS DECIMAL) = ?", month).
+        where("CAST(#{table_name}.year AS DECIMAL) = ?", year)
+    }
+
     alias_attribute :brand, :cc_type
     alias_attribute :last4, :last_digits
 
@@ -165,6 +183,17 @@ module Spree
 
     private
 
+    # month/year are varchar columns exposed as integer attributes, so the
+    # match must go through #by_fingerprint's decimal cast rather than a plain
+    # equality (which Postgres rejects as `character varying = integer`).
+    def fingerprint_not_duplicated
+      duplicates = self.class.where(user_id: user_id, payment_method_id: payment_method_id).
+                   by_fingerprint(fingerprint, month, year)
+      duplicates = duplicates.where.not(id: id) if persisted?
+
+      errors.add(:fingerprint, :taken) if duplicates.exists?
+    end
+
     def require_card_numbers?
       !encrypted_data.present? && !has_payment_profile?
     end

data/app/models/spree/currency.rb

@@ -0,0 +1,47 @@
+module Spree
+  # Virtual model for a currency. Wraps a currency +code+ (ISO 4217) and exposes
+  # its display name and select label — the single home for that logic instead
+  # of being restated in helpers. Mirrors +Spree::Locale+.
+  class Currency
+    include ActiveModel::Model
+    include Comparable
+
+    # @!attribute code
+    #   @return [String] the currency code, e.g. "USD", "EUR"
+    attr_accessor :code
+
+    # Display name, e.g. "United States Dollar". Falls back to the code for an
+    # unknown currency.
+    # @return [String]
+    def name
+      # `find` returns nil (it does not raise) for unknown codes.
+      ::Money::Currency.find(code.to_s.upcase)&.name || code.to_s.upcase
+    end
+
+    # Select label, e.g. "USD — United States Dollar".
+    # @return [String]
+    def label
+      upper = code.to_s.upcase
+      return upper if name.blank? || name.casecmp?(code.to_s)
+
+      "#{upper} — #{name}"
+    end
+
+    def to_s
+      code.to_s.upcase
+    end
+
+    # Compare/equality by code so a Currency slots into string-keyed collections.
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+
+    def eql?(other)
+      other.is_a?(Spree::Currency) && to_s == other.to_s
+    end
+
+    def hash
+      to_s.hash
+    end
+  end
+end

data/app/models/spree/current.rb

@@ -4,7 +4,7 @@ module Spree
   # All attributes are automatically reset between requests by Rails.
   # Fallback chains ensure sensible defaults when attributes are not explicitly set.
   class Current < ::ActiveSupport::CurrentAttributes
-    attribute :store, :channel, :market, :currency, :locale, :zone, :default_tax_zone, :price_lists, :global_pricing_context
+    attribute :store, :channel, :market, :currency, :locale, :content_locale, :zone, :default_tax_zone, :price_lists, :global_pricing_context
 
     resets { @default_tax_zone_loaded = false }
 
@@ -38,6 +38,17 @@ module Spree
       super || market&.default_locale.presence || store&.default_locale.presence || I18n.default_locale.to_s
     end
 
+    # Returns the locale that base (untranslated) record columns are authored
+    # in for the current request — the current store's default locale. It is
+    # assigned per request alongside +I18n.locale+ and must never be written
+    # to the process-global +I18n.default_locale+, which every thread in the
+    # server process shares. Outside a request it falls back to the
+    # application default locale.
+    # @return [String] locale code, e.g. +"en"+, +"de"+
+    def content_locale
+      super.presence || I18n.default_locale.name
+    end
+
     # Returns the current tax zone.
     # Fallback: market's tax zone (from default country) -> global default tax zone.
     # @return [Spree::Zone, nil]

data/app/models/spree/customer_group.rb

@@ -30,6 +30,7 @@ module Spree
     #
     # Instance Methods
     #
+    # FIXME: convert this to counter cache
     def customers_count
       customer_group_users.size
     end