usernames 0.1.3 → 0.2.0

data/lib/usernames/model.rb

@@ -25,7 +25,7 @@ module Usernames
       base.class_attribute :_usernames, instance_accessor: false, default: {}.freeze
     end
 
-    # has_username(column = :username, required: false, generate: nil, **rules)
+    # has_username(column = :username, required: false, generate: nil, seed: nil, clearable: true, **rules)
     #
     # Installs, for that column:
     #
@@ -35,17 +35,30 @@ module Usernames
     #    attributes;
     # 3. with `required:`, presence — on create, and on an update that
     #    changes it (a legacy blank still saves unrelated changes);
-    # 4. uniqueness, compared the way the unique index compares (Comparison);
-    # 5. a generated name on create when none was given — by default, unless
-    #    a name is required for that record;
-    # 6. a race wrapper, so two sign-ups racing for one name end in a redraw
+    # 4. with `clearable: false`, no clearing: a saved name cannot be saved
+    #    blank again, required or not — other people link to it;
+    # 5. uniqueness, compared the way the unique index compares (Comparison);
+    # 6. a generated name for a new record that has none — by default,
+    #    unless a name is required for it in the context it is validated in —
+    #    drawn from `seed:` when that has a value;
+    # 7. a race wrapper, so two sign-ups racing for one name end in a redraw
     #    (a generated name) or in "has already been taken" (a typed one) —
     #    never a RecordNotUnique 500.
     #
     # `required:` and `generate:` take true, false, a method name or a proc,
     # evaluated on the record the way Rails' `if:` is: a sign-up flow that
     # asks for a name (`required: :handle_required`) gets presence, and every
-    # other record a generated name.
+    # other record a generated name. `required: { on: :profile }` asks for
+    # one only in that validation context (`save(context: :profile)`), on
+    # every save there.
+    #
+    # `seed:` is a method name or a proc (evaluated the same way) whose value
+    # a generated name starts from: `seed: :first_name` makes `ana` (or
+    # `ana_42` when that is taken) rather than `quiet_otter_42`. It is read
+    # once per save, and a redraw after a lost race reuses it. A blank seed
+    # draws the default shape. Whatever it returns becomes part of a public
+    # name: an email is used only if the seed returns one, and then as
+    # Usernames.generate reads it (the local part, or the domain for info@).
     #
     # And the class helpers, named after the column: `username_available?`,
     # `suggest_usernames`, `generate_username`, `find_by_username` (and `!`),
@@ -56,8 +69,9 @@ module Usernames
     # mode, so the model keeps comparing in it even if the configuration
     # changes later. Every other rule is read from the configuration on each
     # check.
-    def has_username(column = :username, required: false, generate: nil, **rules)
-      column = Column.new(self, column, required: required, generate: generate, rules: rules)
+    def has_username(column = :username, required: false, generate: nil, seed: nil, clearable: true, **rules)
+      column = Column.new(self, column, required: required, generate: generate, seed: seed, clearable: clearable,
+                                        rules: rules)
       if _usernames.key?(column.name)
         raise ConfigurationError, "has_username :#{column.name} is already declared on #{name || self}"
       end
@@ -73,36 +87,62 @@ module Usernames
       result =
         case condition
         when true, false then condition
-        when Symbol then record.send(condition)
-        else condition.arity.zero? ? record.instance_exec(&condition) : condition.call(record)
+        else value_of(condition, record)
         end
       result ? true : false
     end
 
+    # What a method name or a proc gives for `record`, evaluated as
+    # applies? evaluates a condition. :nodoc:
+    def self.value_of(source, record)
+      return record.send(source) if source.is_a?(Symbol)
+
+      source.arity.zero? ? record.instance_exec(&source) : source.call(record)
+    end
+
     # One has_username declaration, and everything that column needs: the
     # rules in force, the comparison expression, and the queries behind the
     # class helpers. :nodoc:
     class Column
-      attr_reader :model, :name, :required, :generate, :options
+      attr_reader :model, :name, :required, :generate, :seed, :options
 
-      def initialize(model, name, required:, generate:, rules:)
+      def initialize(model, name, required:, generate:, rules:, seed: nil, clearable: true)
         @model = model
         @name = name.to_sym
-        @required = condition(:required, required)
+        @required = required.is_a?(Hash) ? contexts(required) : condition(:required, required)
         # By default a name is generated exactly where none is required: where
         # one is, the person chooses.
         @generate = generate.nil? ? nil : condition(:generate, generate)
+        @seed = seed.nil? ? nil : source(:seed, seed)
+        @clearable = switch(:clearable, clearable)
         # Resolving them now raises ConfigurationError for a bad option when
         # the model is defined, and pins the case mode (see has_username).
         @options = rules.merge(case: Usernames.configuration.rules_for(**rules).case).freeze
       end
 
-      # Whether `record` must have a name.
+      # Whether `record` must have a name. With `required: { on: … }`, while
+      # it is being validated in one of those contexts.
       def required?(record)
-        Model.applies?(required, record)
+        return Model.applies?(required, record) unless required.is_a?(Hash)
+
+        Array(record.validation_context).intersect?(required.fetch(:on))
+      end
+
+      # Whether a saved name may be saved blank again (`clearable: false` says no).
+      def clearable?
+        @clearable
+      end
+
+      # What a generated name for `record` starts from: the seed's value, or
+      # nil (the default shape) when there is no seed or it is blank.
+      def seed_for(record)
+        return if seed.nil?
+
+        value = Model.value_of(seed, record)
+        value.to_s unless value.blank?
       end
 
-      # Whether `record` gets a generated name on create when it has none.
+      # Whether `record`, while new and without a name, gets a generated one.
       def generate?(record)
         generate.nil? ? !required?(record) : Model.applies?(generate, record)
       end
@@ -174,28 +214,60 @@ module Usernames
 
       def install_normalization_and_rules
         column = name
-        definition = self
         changed = :"will_save_change_to_#{column}?"
         model.normalizes column, with: Usernames.normalizer(**options)
         model.validates column, username: options, if: changed
+        install_presence
+        install_no_clearing
+      end
+
+      # On create, and when an update touches it: a pre-existing blank
+      # saves unrelated changes; clearing a name is :blank. Not when
+      # generation already said why the name is blank
+      # (:username_unavailable): one error per name. In a named context
+      # (`required: { on: :profile }`), on every save in it: that form is
+      # where the person types one.
+      def install_presence
         return if required == false
+        return install_presence_in_context if required.is_a?(Hash)
 
-        # On create, and when an update touches it: a pre-existing blank
-        # saves unrelated changes; clearing a name is :blank. Not when
-        # generation already said why the name is blank
-        # (:username_unavailable): one error per name.
+        column = name
+        definition = self
         model.validates column, presence: true, if: lambda {
           (new_record? || will_save_change_to_attribute?(column)) && definition.required?(self) &&
             !errors.of_kind?(column, :username_unavailable)
         }
       end
 
+      def install_presence_in_context
+        column = name
+        model.validates column, presence: true, on: required.fetch(:on),
+                                if: -> { !errors.of_kind?(column, :username_unavailable) }
+      end
+
+      # `clearable: false`: a saved name other people link to stays.
+      # Saving it blank is :blank, required or not (once, if presence already
+      # said so). A stored blank (nil, "", "  ") was never a name, so saving
+      # it blank again is not clearing; a new record has nothing saved to
+      # clear. It is a validation: update_column and update_all skip it.
+      def install_no_clearing
+        return if clearable?
+
+        column = name
+        model.validate(if: lambda {
+          persisted? && will_save_change_to_attribute?(column) && public_send(column).blank? &&
+            attribute_in_database(column).present? && !errors.of_kind?(column, :blank)
+        }) { errors.add(column, :blank) }
+      end
+
       # Left out altogether when no record can ever get a generated name.
+      # Gated on new_record?, not `on: :create`: a new record validated in a
+      # context of its own (`save(context: :import)`) is still new.
       def install_generation
         return if generate == false || (generate.nil? && required == true)
 
         definition = self
-        model.before_validation(:"assign_#{name}", on: :create, if: -> { definition.generate?(self) })
+        model.before_validation(:"assign_#{name}", if: -> { new_record? && definition.generate?(self) })
       end
 
       # Lowercase mode stores the canonical value, so Rails' own exact
@@ -219,8 +291,33 @@ module Usernames
       def condition(option, value)
         return value if [true, false].include?(value) || value.is_a?(Symbol) || value.is_a?(Proc)
 
-        raise ConfigurationError, "has_username #{option}: must be true, false, a method name or a proc " \
-                                  "(got #{value.inspect})"
+        expected = if option == :required
+                     "true, false, a method name, a proc or { on: :context }"
+                   else
+                     "true, false, a method name or a proc"
+                   end
+        raise ConfigurationError, "has_username #{option}: must be #{expected} (got #{value.inspect})"
+      end
+
+      # `{ on: :profile }` or `{ on: %i[profile settings] }`, as Rails' own `on:`.
+      def contexts(value)
+        on = Array(value[:on])
+        return { on: on.freeze }.freeze if value.keys == [:on] && on.any? && on.all?(Symbol)
+
+        raise ConfigurationError, "has_username required: takes { on: :context } (one or more validation " \
+                                  "contexts) as a Hash (got #{value.inspect})"
+      end
+
+      def source(option, value)
+        return value if value.is_a?(Symbol) || value.is_a?(Proc)
+
+        raise ConfigurationError, "has_username #{option}: must be a method name or a proc (got #{value.inspect})"
+      end
+
+      def switch(option, value)
+        return value if [true, false].include?(value)
+
+        raise ConfigurationError, "has_username #{option}: must be true or false (got #{value.inspect})"
       end
     end
 
@@ -327,12 +424,26 @@ module Usernames
           drawn = instance_variable_get(generated)
           !drawn.nil? && drawn == public_send(column)
         end
+        define_drawing(methods, column, generated)
+      end
+
+      # Assigning a name to a blank new record reads the seed once (it is the
+      # app's code: whatever it raises is the app's error); a redraw after a
+      # lost race reuses it.
+      def self.define_drawing(methods, column, generated)
+        seed = :"@#{column}_seed"
         methods.define_method(:"draw_#{column}") do
-          public_send(:"#{column}=", instance_variable_set(generated, self.class.public_send(:"generate_#{column}")))
+          drawn = self.class.public_send(:"generate_#{column}", from: instance_variable_get(seed))
+          public_send(:"#{column}=", instance_variable_set(generated, drawn))
         rescue NoFreeNameError
           errors.add(column, :username_unavailable)
         end
-        methods.define_method(:"assign_#{column}") { send(:"draw_#{column}") if public_send(column).blank? }
+        methods.define_method(:"assign_#{column}") do
+          return unless public_send(column).blank?
+
+          instance_variable_set(seed, self.class._usernames.fetch(column).seed_for(self))
+          send(:"draw_#{column}")
+        end
         methods.send(:private, :"draw_#{column}", :"assign_#{column}")
       end
 

data/lib/usernames/reserved/listing.rb

@@ -37,6 +37,7 @@ module Usernames
           words.each { |word, source| io.puts "  #{word.ljust(width)}  #{source}" }
           lifted = allowed(rules)
           io.puts "Lifted by config.allowed: #{lifted.join(' ')}" if lifted.any?
+          io.puts "And whatever config.reserved_if reserves, asked after these lists." if rules.reserved_if
           words.size
         end
 

data/lib/usernames/reserved.rb

@@ -32,8 +32,8 @@ module Usernames
     Sets = ::Data.define(:exact, :custom, :impersonation, :allowed)
 
     class << self
-      # The kind of reservation that matched — :impersonation, :exact, :route
-      # or :custom — or nil when the name is free to use. `key` is
+      # The kind of reservation that matched — :impersonation, :exact, :route,
+      # :custom or :reserved_if — or nil when the name is free to use. `key` is
       # Usernames.comparison_key of a name that already passed every format
       # rule; `rules` is the Usernames::Rules in force.
       #
@@ -44,15 +44,16 @@ module Usernames
       # word and reported as :impersonation; :custom names a config.reserved
       # word that is not bundled. A reserved prefix (`.well-known`, `xn--`)
       # is reported as :exact.
-      def verdict(key, rules)
+      #
+      # Last, after every list, config.reserved_if is asked about `name` —
+      # the name as normalised, case kept in preserve mode — and a truthy
+      # answer is :reserved_if. It runs on the checks the lists let
+      # through, and whatever it raises is the app's.
+      def verdict(key, rules, name = key)
         sets = sets_for(rules)
         return if sets.allowed.include?(key)
 
-        if impersonation?(key, sets.impersonation) then :impersonation
-        elsif sets.custom.include?(key) then :custom
-        elsif sets.exact.include?(key) || prefix?(key) then :exact
-        elsif rules.reserve_routes && routes.include?(key) then :route
-        end
+        listed(key, sets, rules) || (:reserved_if if rules.reserved_if&.call(name))
       end
 
       # Whether any spelling of the name is an impersonation entry: the name
@@ -115,6 +116,15 @@ module Usernames
 
       private
 
+      # The list that reserves `key`, in the order they are asked.
+      def listed(key, sets, rules)
+        if impersonation?(key, sets.impersonation) then :impersonation
+        elsif sets.custom.include?(key) then :custom
+        elsif sets.exact.include?(key) || prefix?(key) then :exact
+        elsif rules.reserve_routes && routes.include?(key) then :route
+        end
+      end
+
       def sets_for(rules)
         rules.compiled(:reserved) do
           bundled = Data.reserved.to_set

data/lib/usernames/routes.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Usernames
+  # The engine draws the availability route itself, after your routes, so
+  # anything you declare wins. A catch-all such as `get "*path"` (or a
+  # dynamic `get ":section/:page"`) would win too, and swallow it: declare
+  # it yourself, above the catch-all, and the engine draws nothing.
+  #
+  #   Rails.application.routes.draw do
+  #     usernames_availability
+  #     get "*path", to: "pages#show"
+  #   end
+  #
+  # Call it at the top level of the routes, outside any namespace or scope.
+  # It answers at config.availability.path (or the path you pass), is named
+  # `usernames_availability`, and takes no format: `/usernames/availability.json`
+  # is not a route.
+  module Routes
+    DEFAULT_PATH = "/usernames/availability"
+
+    def usernames_availability(path = nil)
+      path ||= Usernames.configuration.availability.path || DEFAULT_PATH
+      get path, to: "usernames/availability#show", as: :usernames_availability, format: false
+    end
+  end
+end

data/lib/usernames/rules/options.rb

@@ -9,7 +9,7 @@ module Usernames
     module Options
       NAMES = %i[
         length separators edge_separators case first_character reserve_routes app_name
-        reserved forbidden allowed offensive on_adapter_failure generator unique_index
+        reserved forbidden allowed reserved_if offensive on_adapter_failure generator unique_index
       ].freeze
 
       OFFENSIVE_NAMES = %i[severity languages allowed adapters].freeze
@@ -53,6 +53,7 @@ module Usernames
         @reserved = valid_words(:reserved, options.fetch(:reserved))
         @forbidden = valid_words(:forbidden, options.fetch(:forbidden))
         @allowed = valid_words(:allowed, options.fetch(:allowed))
+        @reserved_if = valid_callable(:reserved_if, options.fetch(:reserved_if), "->(name) { … }")
         @on_adapter_failure = one_of(:on_adapter_failure, options.fetch(:on_adapter_failure), ADAPTER_FAILURE_MODES)
       end
 
@@ -145,6 +146,13 @@ module Usernames
 
       # nil detects the name from the Rails application; false opts out; a
       # String names it explicitly (an app whose brand is not its module name).
+      # nil, or anything that answers `call`.
+      def valid_callable(name, value, example)
+        invalid!(name, value, "nil or a callable such as #{example}") unless value.nil? || value.respond_to?(:call)
+
+        value
+      end
+
       def valid_app_name(value)
         valid = value.nil? || value == false || (value.is_a?(String) && !value.strip.empty?)
         invalid!(:app_name, value, "a String, false to opt out, or nil to detect it") unless valid

data/lib/usernames/rules.rb

@@ -51,6 +51,14 @@ module Usernames
       defined?(Mime::EXTENSION_LOOKUP) ? Mime::EXTENSION_LOOKUP.keys.map(&:to_s) : []
     end
 
+    # Every reason a format rule can give, in the order the rules check:
+    # those of rules with every optional format rule switched on (all three
+    # separators, a letter first), so a new rule is in it the day it exists.
+    def self.format_reasons
+      @format_reasons ||= Configuration.new.rules_for(separators: Options::SEPARATORS, first_character: :letter)
+        .format_checks.map(&:first).freeze
+    end
+
     attr_reader :format_checks
 
     def initialize(**options)
@@ -143,7 +151,7 @@ module Usernames
     # Reserved words are matched on the comparison key alone; the offensive
     # matcher also reads the case the name was typed in (Offensive.verdict).
     def content_failure(string)
-      if (rule = Reserved.verdict(comparison_key(string), self))
+      if (rule = Reserved.verdict(comparison_key(string), self, string))
         Failure.new(reason: :username_reserved, rule: rule)
       elsif (rule = Offensive.verdict(string, self))
         Failure.new(reason: :username_not_allowed, rule: rule)

data/lib/usernames/targets.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Usernames
+  # The username columns the availability endpoint answers for, by alias:
+  # config.availability.targets, `{ "user" => "User#handle" }`.
+  #
+  # A request names an alias, and the alias is only ever a key looked up in
+  # that Hash: the class name resolved is the one the app configured, never
+  # anything a client sent. It is resolved on every lookup, so in
+  # development a reloaded model is the new class, and a model that no
+  # longer declares has_username fails loudly instead of answering for a
+  # column that is gone. :nodoc:
+  module Targets
+    class << self
+      # [model, column] for a configured alias; nil for anything else (the
+      # endpoint's 404). Raises ConfigurationError when the alias is
+      # configured but does not name a model with that has_username.
+      def find(name)
+        target = configured[name] if name.is_a?(String)
+        resolve(name, target) if target
+      end
+
+      # The alias the form of a `model` record sends for `column`: the target
+      # naming its class or, for a single-table subclass, the nearest parent
+      # that one names. Compared by name; nothing is loaded.
+      def alias_for(model, column)
+        wanted = column.to_s
+        model.ancestors.each do |ancestor|
+          next unless ancestor.is_a?(Class) && ancestor.name
+
+          found = configured.find { |_name, target| target == "#{ancestor.name}##{wanted}" }
+          return found.first if found
+        end
+        nil
+      end
+
+      private
+
+      def configured
+        Usernames.configuration.availability.targets
+      end
+
+      def resolve(name, target)
+        model_name, column = target.split("#", 2)
+        model = constant(name, target, model_name)
+        declared = model.is_a?(Class) && model.respond_to?(:_usernames) && model._usernames.key?(column.to_sym)
+        unless declared && !model.abstract_class?
+          broken!(name, target, "#{model_name} isn't a model that declares has_username :#{column}")
+        end
+
+        [model, column.to_sym]
+      end
+
+      def constant(name, target, model_name)
+        Object.const_get(model_name)
+      rescue NameError => e
+        broken!(name, target, "#{model_name} can't be loaded (#{e.message})")
+      end
+
+      def broken!(name, target, why)
+        raise ConfigurationError, "config.availability.targets[#{name.inspect}] is #{target.inspect}, but #{why}"
+      end
+    end
+  end
+end

data/lib/usernames/unique_violation.rb

@@ -49,7 +49,6 @@ module Usernames
       # connection is used. `conflict` answers whether another row has the
       # record's name under the gem's comparison; without one, an ambiguous
       # SQLite message is not ours.
-      # rubocop:disable-next Metrics/ParameterLists -- each is one fact about the save, all by keyword
       def of?(error, table:, column:, rules: Usernames.configuration.rules_for, connection: nil, conflict: nil)
         target = Target.new(table: table.to_s, bare_table: table.to_s.split(".").last, column: column.to_s,
                             index: rules.unique_index&.to_s, mode: rules.case, connection: connection,

data/lib/usernames/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Usernames
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/lib/usernames.rb

@@ -20,11 +20,14 @@ require_relative "usernames/words"
 require_relative "usernames/generator"
 require_relative "usernames/candidates"
 require_relative "usernames/rules"
+require_relative "usernames/routes"
 require_relative "usernames/configuration"
 require_relative "usernames/validator"
 require_relative "usernames/comparison"
 require_relative "usernames/unique_violation"
 require_relative "usernames/model"
+require_relative "usernames/targets"
+require_relative "usernames/locale"
 require_relative "usernames/engine" if defined?(Rails::Engine)
 
 module Usernames

data/sig/usernames.rbs

@@ -1,5 +1,6 @@
 # The public surface of the usernames gem: the module functions, the result
-# of a check, the errors, and the has_username macro.
+# of a check, the errors, the has_username macro, the form helpers, the
+# availability routing method and its configuration.
 module Usernames
   VERSION: String
   ROUTE: Regexp
@@ -16,7 +17,7 @@ module Usernames
   class DataError < Error
   end
 
-  type rule = :impersonation | :exact | :route | :custom | :severe | :strong | :hate_number | :adapter
+  type rule = :impersonation | :exact | :route | :custom | :reserved_if | :severe | :strong | :hate_number | :adapter
 
   # Usernames.check("Ad_min") # => #<data Usernames::Result ok?=false, reason=:username_reserved, …>
   class Result
@@ -52,24 +53,50 @@ module Usernames
     attr_accessor reserved: Array[String]
     attr_accessor forbidden: Array[String]
     attr_accessor allowed: Array[String]
+    attr_accessor reserved_if: (^(String) -> boolish)?
     attr_accessor on_adapter_failure: :allow | :reject
     attr_accessor unique_index: (String | Symbol)?
     def offensive: () -> untyped
     def generator: () -> untyped
+    def availability: () -> Availability
     def generator=: (untyped callable) -> untyped
     def validate!: () -> self
+
+    # config.availability: the built-in "is this name free?" endpoint.
+    class Availability
+      attr_accessor path: (String | false)?
+      # { "user" => "User#handle" }: alias => "Model#column"
+      attr_accessor targets: Hash[String, String]
+      attr_accessor parent_controller: String?
+      attr_accessor rate_limit: { to: Integer, within: Numeric }
+      attr_accessor rate_limit_store: untyped
+    end
+  end
+
+  # f.username_field / f.username_status, on every ActionView form builder.
+  module FormBuilder
+    def username_field: (?(Symbol | String) column, ?availability: bool, ?static: bool, **untyped html) -> String
+    def username_status: (?(Symbol | String) column, **untyped html) -> String
+  end
+
+  # `usernames_availability` in config/routes.rb, above a catch-all.
+  module Routes
+    def usernames_availability: (?String? path) -> void
   end
 
-  # has_username(column = :username, required: false, generate: nil, **rules)
+  # has_username(column = :username, required: false, generate: nil, seed: nil, clearable: true, **rules)
   #
   # required: and generate: take true, false, a method name or a proc,
-  # evaluated on the record like Rails' if:. generate: nil (the default)
-  # means: wherever a name is not required.
+  # evaluated on the record like Rails' if:; required: also takes
+  # { on: context } (or an Array of contexts). generate: nil (the default)
+  # means: wherever a name is not required. seed: is a method name or a
+  # proc whose value a generated name starts from; clearable: false
+  # refuses saving a saved name blank.
   #
   # Also defines, named after the column: <column>_available?, suggest_<column>s,
   # generate_<column>, find_by_<column>, find_by_<column>!, <column>_options, check_<column>,
   # <column>_rules_for_browser, and <column>_generated? on instances.
   module Model
-    def has_username: (?(Symbol | String) column, ?required: (bool | Symbol | Proc), ?generate: (bool | Symbol | Proc)?, **untyped rules) -> void
+    def has_username: (?(Symbol | String) column, ?required: (bool | Symbol | Proc | { on: Symbol | Array[Symbol] }), ?generate: (bool | Symbol | Proc)?, ?seed: (Symbol | Proc)?, ?clearable: bool, **untyped rules) -> void
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: usernames
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - rameerez
@@ -106,6 +106,10 @@ files:
 - LICENSE.txt
 - README.md
 - SECURITY.md
+- app/assets/javascripts/usernames/index.js
+- app/assets/javascripts/usernames/username_check_controller.js
+- app/controllers/usernames/availability_controller.rb
+- config/importmap.rb
 - config/locales/usernames.en.yml
 - config/locales/usernames.es.yml
 - config/locales/usernames.pt.yml
@@ -146,11 +150,11 @@ files:
 - lib/generators/usernames/existing_schema.rb
 - lib/generators/usernames/install_generator.rb
 - lib/generators/usernames/install_messages.rb
+- lib/generators/usernames/javascript_generator.rb
+- lib/generators/usernames/javascript_setup.rb
 - lib/generators/usernames/locale_generator.rb
 - lib/generators/usernames/templates/add_username.rb.erb
 - lib/generators/usernames/templates/availability/_field.html.erb.tt
-- lib/generators/usernames/templates/availability/availability_controller.rb.tt
-- lib/generators/usernames/templates/availability/username_check_controller.js.tt
 - lib/generators/usernames/templates/usernames.rb
 - lib/tasks/usernames.rake
 - lib/usernames.rb
@@ -166,7 +170,9 @@ files:
 - lib/usernames/data.rb
 - lib/usernames/engine.rb
 - lib/usernames/errors.rb
+- lib/usernames/form_helpers.rb
 - lib/usernames/generator.rb
+- lib/usernames/locale.rb
 - lib/usernames/model.rb
 - lib/usernames/normalizer.rb
 - lib/usernames/offensive.rb
@@ -177,8 +183,10 @@ files:
 - lib/usernames/reserved.rb
 - lib/usernames/reserved/listing.rb
 - lib/usernames/result.rb
+- lib/usernames/routes.rb
 - lib/usernames/rules.rb
 - lib/usernames/rules/options.rb
+- lib/usernames/targets.rb
 - lib/usernames/unique_violation.rb
 - lib/usernames/validator.rb
 - lib/usernames/version.rb