usernames 0.1.3

data/lib/generators/usernames/existing_schema.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Usernames
+  module Generators
+    # What the database holds now for one table and column, as the install
+    # generator sees it: the column (nil when missing), the table's indexes,
+    # and whether any row already has a username.
+    #
+    # Every lookup is guarded: a generator must run without a database (a
+    # fresh checkout, CI, a laptop with the server off). Then nothing is known,
+    # and the column is assumed missing.
+    class ExistingSchema
+      attr_reader :column, :indexes
+
+      # `owner` is the model (or ActiveRecord::Base) whose database holds the
+      # table; `mode` is the case mode the index is for: the first index that
+      # enforces its comparison contract is the matching one. Every other
+      # index involving the column is kept with why it does not count.
+      def self.read(owner, table, column, mode)
+        owner.with_connection do |connection|
+          next new(reachable: true) unless connection.table_exists?(table)
+
+          existing = connection.columns(table).find { |each| each.name == column.to_s }
+          indexes = connection.indexes(table)
+          contract = Usernames::Comparison::IndexContract.new(connection, table: table, column: column, mode: mode)
+          new(reachable: true, column: existing, indexes: indexes,
+              verdicts: verdicts(indexes, contract),
+              populated: !existing.nil? && rows?(connection, table, column))
+        end
+      rescue StandardError
+        new(reachable: false)
+      end
+
+      # The migration line that drops `index` (one of `indexes`) and can be
+      # rolled back: it restates the columns or expression as the database
+      # reads them back, the uniqueness and the condition.
+      def self.remove_index_line(table, index)
+        columns = index.columns
+        options = [columns.is_a?(Array) ? "column: #{columns.map(&:to_sym).inspect}" : columns.inspect]
+        options << "unique: true" if index.unique
+        options << "where: #{index.where.inspect}" if index.where.present?
+        options << "name: #{index.name.inspect}"
+        "remove_index #{Usernames::Comparison.ruby_name(table)}, #{options.join(', ')}"
+      end
+
+      # [[index, reason], …] for every index involving the column; reason nil
+      # when it enforces the contract.
+      def self.verdicts(indexes, contract)
+        indexes.select { |index| contract.mentions?(index) }.map { |index| [index, contract.violation(index)] }
+      end
+
+      def self.rows?(connection, table, column)
+        sql = "SELECT 1 FROM #{connection.quote_table_name(table)} " \
+              "WHERE #{connection.quote_column_name(column)} IS NOT NULL LIMIT 1"
+        !connection.select_value(sql).nil?
+      end
+
+      def initialize(reachable:, column: nil, indexes: [], verdicts: [], populated: false)
+        @reachable = reachable
+        @column = column
+        @indexes = indexes
+        @verdicts = verdicts
+        @populated = populated
+      end
+
+      # The first index that enforces the contract, or nil.
+      def matching_index
+        @verdicts.find { |_index, reason| reason.nil? }&.first
+      end
+
+      # [[index, reason], …]: the indexes on the column that do not.
+      def rejected_indexes
+        @verdicts.select { |_index, reason| reason }
+      end
+
+      def reachable?
+        @reachable
+      end
+
+      def populated?
+        @populated
+      end
+    end
+  end
+end

data/lib/generators/usernames/install_generator.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require "rails/generators/active_record"
+require_relative "existing_schema"
+require_relative "install_messages"
+
+module Usernames
+  module Generators
+    # rails generate usernames:install [--model=User] [--column=username] [--case=preserve]
+    #
+    # Writes config/initializers/usernames.rb and one migration: the column
+    # (if the table has none), byte-compared ("C" on PostgreSQL, utf8mb4_bin
+    # on MySQL — except PostgreSQL in preserve mode, whose index expression
+    # carries the "C" itself), and the ONE unique index the gem needs, built
+    # from the same expression every query uses (Usernames::Comparison).
+    #
+    # It looks at the database first, when it can reach it, so a re-run
+    # writes nothing twice and an existing column is adopted rather than
+    # added. A column that already holds usernames gets the adoption workflow
+    # instead of a promise: the index cannot be trusted — or even added —
+    # until `rails usernames:audit` comes back clean.
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+      include InstallMessages
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Add usernames to a model: the initializer, the column if missing, and its unique index."
+
+      class_option :model, type: :string, default: "User", desc: "The model that gets has_username"
+      class_option :column, type: :string, default: "username", desc: "The column that holds the username"
+      # The index depends on the case mode, so the generator reads it from
+      # the model's has_username (or config.case), and --case overrides that
+      # for a model that does not declare it yet.
+      class_option :case, type: :string,
+                          desc: "lowercase or preserve (default: the model's has_username, else config.case)"
+
+      def self.next_migration_number(dir)
+        ActiveRecord::Generators::Base.next_migration_number(dir)
+      end
+
+      # The index and collation depend on the adapter: an unsupported one
+      # stops the generator here, before it writes a single file.
+      def check_the_database_adapter
+        adapter
+      end
+
+      def create_initializer
+        # Never over an initializer the app has already edited.
+        template "usernames.rb", "config/initializers/usernames.rb", skip: true
+      end
+
+      def create_migration_file
+        if nothing_to_migrate?
+          say_status :skip, "#{table}.#{column} and #{matching_index.name} are already in place", :yellow
+          return
+        end
+
+        # An index on the column that looks like the one but does not count
+        # gets said why, rather than a second unique index appearing unexplained.
+        database.rejected_indexes.each do |existing, reason|
+          say_status :ignore, "#{existing.name} doesn't make #{column} unique: it #{reason}", :yellow
+        end
+        migration_template "add_username.rb.erb", File.join(db_migrate_path, "#{migration_name}.rb")
+      end
+
+      def display_post_install_message
+        say "\n\tThe `usernames` gem has been successfully installed!", :green
+        warn_about_the_database unless database.reachable?
+        populated? ? adoption_message : setup_message
+        say "\nEnjoy your new usernames!", :green
+      end
+
+      private
+
+      # --- what the migration does -----------------------------------------------------------------
+
+      # A file name and a constant, whatever the table is called:
+      # `public.users` makes add_username_to_public_users, AddUsernameToPublicUsers.
+      def migration_name
+        table_part = table.gsub(/\W+/, "_")
+        column_part = column.gsub(/\W+/, "_")
+        add_column? ? "add_#{column_part}_to_#{table_part}" : "add_unique_#{column_part}_index_to_#{table_part}"
+      end
+
+      def migration_class_name = migration_name.camelize
+
+      # A table or column as the migration's argument (`:users`, `"public.users"`).
+      def ruby_name(name) = Usernames::Comparison.ruby_name(name)
+
+      def nothing_to_migrate?
+        !add_column? && !change_collation? && !add_index?
+      end
+
+      def add_column? = database.column.nil?
+
+      # Adopting a PostgreSQL column: set "C" when it is anything else, and
+      # make citext a plain string. In preserve mode the comparison
+      # carries its own COLLATE "C", so only citext changes: the column keeps
+      # the collation its ORDER BY sorts by. MySQL's change_column restates
+      # the whole column definition, so there the migration only shows the line.
+      def change_collation?
+        existing = database.column
+        return false if existing.nil? || adapter != :postgresql
+
+        existing.sql_type == "citext" || (!collation.nil? && existing.collation != collation)
+      end
+
+      def mysql_collation_note?
+        existing = database.column
+        !existing.nil? && adapter == :mysql && existing.collation != collation
+      end
+
+      def add_index? = matching_index.nil?
+
+      # An index of the same name that is not the one the mode needs (a plain
+      # non-unique index_users_on_username, say) has to go first.
+      def conflicting_index
+        database.indexes.find { |existing| existing.name == index[:name] && !existing.equal?(matching_index) }
+      end
+
+      def matching_index = database.matching_index
+
+      # Whether the migration touches the column before its indexes.
+      def column_step? = add_column? || change_collation? || mysql_collation_note?
+
+      def index
+        @index ||= Usernames::Comparison.index_definition(adapter: adapter, table: table, column: column, mode: mode)
+      end
+
+      def collation = Usernames::Comparison.column_collation(adapter, mode)
+
+      # Readable in the migration: 'lower(username COLLATE "C")', not an escaped string.
+      def index_column
+        wanted = index[:column]
+        return wanted.inspect unless wanted.is_a?(String) && wanted.include?('"') && !wanted.include?("'")
+
+        "'#{wanted}'"
+      end
+
+      def column_options = collation ? ", collation: #{collation.inspect}" : ""
+
+      # The audit runs before has_username is declared, so it is told a mode
+      # the configuration does not already say.
+      def audit_arguments = [model_name, column, (mode if mode != configured_mode)].compact.join(",")
+
+      def macro_line
+        options = []
+        options << ":#{column}" unless column == "username"
+        options << "case: :preserve" if mode == :preserve && configured_mode != :preserve
+        ["has_username", options.join(", ")].reject(&:empty?).join(" ")
+      end
+
+      # --- the app ---------------------------------------------------------------------------------
+
+      def model_name
+        options[:model].camelize
+      end
+
+      def model_class
+        model_name.safe_constantize
+      rescue StandardError, LoadError
+        nil
+      end
+
+      def table
+        @table ||= model_class.try(:table_name) || model_name.tableize.tr("/", "_")
+      end
+
+      def column
+        options[:column].to_s
+      end
+
+      def mode
+        @mode ||= begin
+          given = options[:case]&.to_sym || declared_mode || configured_mode
+          unless %i[lowercase preserve].include?(given)
+            raise Thor::Error, "--case must be lowercase or preserve (got #{options[:case].inspect})"
+          end
+
+          given
+        end
+      end
+
+      def declared_mode
+        model_class.try(:_usernames)&.[](column.to_sym)&.mode
+      end
+
+      def configured_mode
+        Usernames.configuration.case
+      end
+
+      # The model's own database when the model exists — an app with several
+      # databases keeps its users on any of them — else the primary one.
+      def connection_owner
+        model_class.is_a?(Class) && model_class < ActiveRecord::Base ? model_class : ActiveRecord::Base
+      end
+
+      # From the model's database configuration, which needs no connection.
+      # The index and the collation depend on it, so an adapter the gem has
+      # no comparison contract for — or none at all — stops the generator.
+      def adapter
+        @adapter ||= Usernames::Comparison.adapter(connection_owner.connection_db_config&.adapter.to_s)
+      rescue Usernames::ConfigurationError => e
+        raise Thor::Error, "#{e.message} (#{model_name}'s database in config/database.yml)"
+      rescue ActiveRecord::ActiveRecordError => e
+        raise Thor::Error, "couldn't read #{model_name}'s database adapter (#{e.message}): the migration depends on it"
+      end
+
+      def database
+        @database ||= ExistingSchema.read(connection_owner, table, column, mode)
+      end
+
+      # A model on the primary database migrates where Rails always does. A
+      # model on another one migrates where that database's migrations live
+      # (its migrations_paths); without them there is nowhere the migration
+      # would run against the right database, so the generator says so.
+      def db_migrate_path
+        own, primary = [connection_owner, ActiveRecord::Base].map(&:connection_db_config)
+        return super if own.equal?(primary) || own.configuration_hash == primary.configuration_hash
+
+        Array(own.migrations_paths).first || raise(Thor::Error, <<~MESSAGE.squish)
+          #{model_name} lives on the #{own.name.inspect} database, which sets no migrations_paths, so a migration
+          written here would run against the primary database. Add migrations_paths for it in config/database.yml
+          and run the generator again.
+        MESSAGE
+      rescue ActiveRecord::ActiveRecordError # no database configuration to read: Rails' default
+        super
+      end
+
+      def populated?
+        database.populated?
+      end
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::STRING.to_f}]"
+      end
+    end
+  end
+end

data/lib/generators/usernames/install_messages.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Usernames
+  module Generators
+    # What `rails generate usernames:install` tells the developer once it has
+    # written its files: the next steps on a fresh column, or the adoption
+    # workflow on one that already holds usernames. :nodoc:
+    module InstallMessages
+      private
+
+      def setup_message
+        say "\nTo complete the setup:"
+        say "  1. Run 'rails db:migrate'#{migration_summary}."
+        say "  2. Add `#{macro_line}` to your #{model_name} model."
+        say "  3. Optionally, run 'rails generate usernames:availability' for a live \"is this name free?\" " \
+            "check on your sign-up form."
+        say "\nUsernames are unique from the moment the index exists: the database decides, " \
+            "with the same comparison the gem uses everywhere."
+      end
+
+      # On a populated column no index is a promise — not even one already in
+      # place, which compares the values as they were stored (`JAVI`), while
+      # the gem stores and compares them normalised (`javi`). Only the audit
+      # can say the two agree.
+      def adoption_message
+        say "\n#{table}.#{column} already holds usernames, and `normalizes` never rewrites rows already stored, " \
+            "so #{index_doubt}:", :yellow
+        say "  1. Run 'rails usernames:audit[#{audit_arguments}]'. It's read-only: it lists values that differ " \
+            "from their normalised form, names that would collide, and the column's collation and indexes."
+        say "  2. If it finds anything, fix it in a migration you own, under a short freeze of the username form: " \
+            "rewrite noncanonical values with your own callbacks and policy, and resolve collisions by contacting " \
+            "the people or appending a suffix. The gem renames nobody."
+        say "  3. #{nothing_to_migrate? ? 'Re-run the audit until it comes back clean' : "Run 'rails db:migrate'#{migration_summary}, re-run the audit"}, " \
+            "and reopen the form."
+        say "  4. Add `#{macro_line}` to your #{model_name} model. Existing names that break today's rules " \
+            "keep working; only a change is validated."
+        say "  See \"Adopting an existing column\" in the README."
+      end
+
+      def index_doubt
+        return "the unique index isn't trustworthy yet (it may not even be addable)" if add_index?
+
+        "#{matching_index.name} can't vouch for them yet: to it a stored JAVI and a new javi are two names"
+      end
+
+      def warn_about_the_database
+        say "\nCouldn't reach the database to look at #{table}.#{column}, so the migration assumes the column " \
+            "doesn't exist yet. If it does, delete the add_column line before migrating.", :yellow
+      end
+
+      def migration_summary
+        return "" if nothing_to_migrate?
+
+        steps = []
+        steps << "to add #{table}.#{column}" if add_column?
+        steps << (collation ? "to set its collation to #{collation.inspect}" : "to make it a string column") if
+          change_collation?
+        steps << "#{steps.empty? ? 'to add' : 'and add'} its unique index, #{index[:name]}" if add_index?
+        " (#{steps.join(' ')})"
+      end
+    end
+  end
+end

data/lib/generators/usernames/locale_generator.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module Usernames
+  module Generators
+    # rails generate usernames:locale --locale=fr
+    #
+    # Copies the gem's English messages to config/locales/usernames.fr.yml,
+    # under the `fr:` key, for you to translate. Rails loads an engine's
+    # locale files before the app's, so every key you translate wins over
+    # the gem's, and every key you leave out still has a message.
+    class LocaleGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../../config/locales", __dir__)
+
+      desc "Copy the English messages to config/locales/usernames.<locale>.yml for you to translate."
+
+      class_option :locale, type: :string, required: true, desc: "The locale to translate into, like fr or pt-BR"
+
+      # A locale key as I18n spells it: fr, pt-BR, zh-Hant-TW.
+      LOCALE = /\A[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*\z/
+
+      def copy_locale
+        raise Thor::Error, "--locale must be a locale like fr or pt-BR (got #{locale.inspect})" unless LOCALE.match?(locale)
+
+        create_file "config/locales/usernames.#{locale}.yml", translated_copy
+      end
+
+      def display_post_install_message
+        say "\n\tconfig/locales/usernames.#{locale}.yml is ready to translate.", :green
+        say "\nTranslate the values; keep the keys and every placeholder (count, letters, separators_phrase…) " \
+            "as it is, and add the plural keys your language needs (one/other are English's). Never add a value " \
+            "placeholder: a message must not echo what was typed."
+        say "The gem already ships #{locale}; your file overrides it key by key.", :yellow if shipped?
+        say "\nThen please consider sending it upstream: https://github.com/rameerez/usernames", :green
+      end
+
+      private
+
+      def locale
+        options[:locale].to_s
+      end
+
+      # The English file with its top-level key swapped, and a note saying so.
+      def translated_copy
+        english = File.read(File.join(self.class.source_root, "usernames.en.yml"), encoding: "UTF-8")
+        note = "# Copied from the usernames gem's English messages by `rails generate usernames:locale --locale=#{locale}`.\n"
+        note + english.sub(/^en:$/, "#{locale}:")
+      end
+
+      def shipped?
+        File.exist?(File.join(self.class.source_root, "usernames.#{locale}.yml"))
+      end
+    end
+  end
+end

data/lib/generators/usernames/templates/add_username.rb.erb

@@ -0,0 +1,53 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+<% if add_column? -%>
+<% if collation.nil? && adapter == :postgresql -%>
+    # No collation of its own: the unique index below compares through
+    # lower(<%= column %> COLLATE "C"), byte by byte, whatever the column's
+    # collation is — so ORDER BY <%= column %> keeps the database's own order.
+<% else -%>
+    # Compared byte by byte (<%= collation ? "collation #{collation.inspect}" : "SQLite's default" %>), so the database agrees
+    # with Ruby about what "the same name" means: no locale lowercasing I to
+    # ı, no collation that thinks jose and josé are one name.
+<% end -%>
+    add_column <%= ruby_name(table) %>, <%= ruby_name(column) %>, :string<%= column_options %>
+<% elsif change_collation? -%>
+<% if collation -%>
+    # Compared byte by byte ("C"), so the database agrees with Ruby about what
+    # "the same name" means: no locale lowercasing I to ı, no collation that
+    # ignores case or punctuation. Run `rails usernames:audit` first.
+<% else -%>
+    # citext compares under the database locale; the gem compares through
+    # lower(<%= column %> COLLATE "C") on a plain string column. Run
+    # `rails usernames:audit` first.
+<% end -%>
+    reversible do |direction|
+      direction.up { change_column <%= ruby_name(table) %>, <%= ruby_name(column) %>, :string<%= column_options %> }
+    end
+<% elsif mysql_collation_note? -%>
+    # The comparison contract wants a byte-wise collation. MySQL's change_column
+    # restates the whole column, so restate its null/default here too:
+    # change_column <%= ruby_name(table) %>, <%= ruby_name(column) %>, :string, collation: <%= collation.inspect %>
+<% end -%>
+<% if (existing = conflicting_index) -%>
+<% if column_step? -%>
+
+<% end -%>
+    # <%= existing.name %> isn't the unique index the gem needs; replace it.
+    <%= Usernames::Generators::ExistingSchema.remove_index_line(table, existing) %>
+<% end -%>
+<% if add_index? -%>
+<% if column_step? || conflicting_index -%>
+
+<% end -%>
+<% if mode == :preserve -%>
+    # Case is kept as typed, and compared without it: CoolCat and coolcat are
+    # one name. Every query the gem makes uses this same expression.
+<% else -%>
+    # Usernames are stored lowercase, so a plain unique index is the whole
+    # contract: uniqueness is `<%= column %> = ?`, and this index serves it.
+<% end -%>
+    add_index <%= ruby_name(table) %>, <%= index_column %>, unique: true, name: <%= index[:name].inspect %>
+<% end -%>
+  end
+end

data/lib/generators/usernames/templates/availability/_field.html.erb.tt

@@ -0,0 +1,25 @@
+<%%# locals: (form:, attribute: :<%= column %>, label: nil) -%>
+<%%#
+  A username field with live hints and an availability check.
+  Generated by `rails generate usernames:availability`. It's yours: edit it.
+
+  Render it inside a form, handing it the form builder:
+
+    render "usernames/field", form: form
+
+  Hints are advisory: nothing here stops the form from submitting, and the
+  model's validations have the last word.
+-%>
+<div data-controller="username-check"
+     data-username-check-url-value="<%%= usernames_availability_path %>"
+     data-username-check-param-value="<%= column %>"
+     data-username-check-rules-value="<%%= <%= model_name %>.<%= column %>_rules_for_browser.to_json %>"
+     data-username-check-lowercase-value="<%%= <%= model_name %>.<%= column %>_options[:case] != :preserve %>">
+  <%%= form.label attribute, label %>
+  <%%= form.text_field attribute,
+        autocomplete: "username", autocapitalize: "none", autocorrect: "off", spellcheck: false,
+        aria: { describedby: "#{form.field_id(attribute)}_hint #{form.field_id(attribute)}_status" },
+        data: { username_check_target: "input", action: "input->username-check#check" } %>
+  <p id="<%%= form.field_id(attribute) %>_hint" data-username-check-target="hint" aria-live="polite"></p>
+  <p id="<%%= form.field_id(attribute) %>_status" data-username-check-target="status" aria-live="polite"></p>
+</div>

data/lib/generators/usernames/templates/availability/availability_controller.rb.tt

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Usernames
+  # GET /usernames/availability?<%= column %>=javi
+  #   => { "state": "free" | "taken" | "invalid", "message": "…" }
+  #
+  # Generated by `rails generate usernames:availability`. It's yours: edit it.
+  #
+  # An availability endpoint tells anyone which names exist — that is its
+  # job — so it comes with guard rails:
+  #
+  # * Rails' own rate_limit, on a store this controller checks. With the
+  #   NullStore (Rails' default in development and test) the limiter silently
+  #   counts nothing, so in production this answers 503, with a log line,
+  #   until config.cache_store is a shared store (Solid Cache, Redis,
+  #   Memcached). A MemoryStore works, but per process: each worker counts on
+  #   its own, so it logs a warning once.
+  # * Taken, reserved and not-allowed names all answer "taken", with one
+  #   message: it never says which list a name is on, or which word matched.
+  # * Never cached (no-store), and advisory only: the model's validations and
+  #   the unique index decide at save time.
+  class AvailabilityController < ApplicationController
+    # Captured once: the very object the limiter writes to, so the guard
+    # below checks the store that is actually in use.
+    RATE_LIMIT_STORE = cache_store
+
+    MEMORY_STORE_WARNED = Concurrent::AtomicBoolean.new(false)
+
+    # Format failures are shown as they are (the browser hints them anyway);
+    # reserved and not-allowed names are reported as taken (see above).
+    FORMAT_FAILURES = %i[
+      username_spaces username_characters username_unicode too_short too_long username_edges
+      username_consecutive username_first_character username_digits_only username_extension
+    ].freeze
+
+    # Before everything else, the limiter included: an answer about who
+    # exists is never cached, and neither is a 429 or a 503.
+    prepend_before_action :no_store
+
+    rate_limit to: 30, within: 1.minute, store: RATE_LIMIT_STORE, with: -> { head :too_many_requests }
+
+    before_action :require_a_working_rate_limit_store
+
+    def show
+      render json: answer_for(params[:<%= column %>].to_s)
+    end
+
+    private
+
+    # Every message in <%= model_name %>'s own words: a translation under
+    # activerecord.errors.models.<%= singular %>.attributes.<%= column %> wins here as on the form.
+    def answer_for(value)
+      result = <%= model_name %>.check_<%= column %>(value)
+
+      if result.canonical.empty?
+        { state: "invalid", message: message(:blank) }
+      elsif own?(result.canonical)
+        { state: "free", message: available }
+      elsif FORMAT_FAILURES.include?(result.reason)
+        { state: "invalid", message: result.message }
+      elsif result.ok? && <%= model_name %>.<%= column %>_available?(result.canonical)
+        { state: "free", message: available }
+      else
+        { state: "taken", message: message(:taken) }
+      end
+    end
+
+    def message(type)
+      <%= model_name %>.new.errors.generate_message(:<%= column %>, type)
+    end
+
+    # Said out loud too: the status is a live region, so a screen reader
+    # hears that the name is free, not just silence.
+    def available
+      I18n.t(:available, scope: :usernames)
+    end
+
+    def rules
+      <%= model_name %>.<%= column %>_options
+    end
+
+    # The signed-in person's own name is free: it's theirs. Devise and most
+    # authentication gems define current_user; with Rails' own authentication
+    # generator, use Current.user instead.
+    def own?(canonical)
+      user = current_user if respond_to?(:current_user, true)
+      name = user.try(:<%= column %>)
+      name.present? && Usernames.comparison_key(name, **rules) == Usernames.comparison_key(canonical, **rules)
+    end
+
+    def require_a_working_rate_limit_store
+      case RATE_LIMIT_STORE
+      when ActiveSupport::Cache::NullStore
+        return unless Rails.env.production?
+
+        Rails.logger.error "[usernames] The availability check is off (503): config.cache_store is the NullStore, " \
+                           "where Rails' rate_limit counts nothing. Use a shared store: Solid Cache, Redis or Memcached."
+        head :service_unavailable
+      when ActiveSupport::Cache::MemoryStore
+        if MEMORY_STORE_WARNED.make_true
+          Rails.logger.warn "[usernames] The availability check's rate limit uses a MemoryStore, which each process " \
+                            "counts on its own. Use a shared store (Solid Cache, Redis, Memcached) for one limit per client."
+        end
+      end
+    end
+  end
+end