i18nlint 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9a03e19f03f55ba5879300aca6350eefd4853c115f2147ba8e9ddf75fb2f2a21
+  data.tar.gz: a3f96e3e9edb03bc7ef0ae5b5dbeee5d1b2e2bef2f491312a15e1f58e509675f
+SHA512:
+  metadata.gz: d2ea838d73172ba085ad48459ded3c50c6cf61a7f5dcd11d845faadac5b0241038d43e64d9ff594723fe3574a003326a33fcc4a56afd2c8b4ca3a8d5d662bbfd
+  data.tar.gz: 2651d1a65b6fedf1ce26946dee33c991b610d206bdd997160ae3517d84e3b8345a67b5718cce0bafde003f41994350a9a4b3df3d95ec72ff1e361f7dfadb5a55

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [1.0.0] - 2026-08-28
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Henry Blyth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,206 @@
+# I18nLint
+
+Lint your i18n for common problems, so you can be sure your copy doesn't get broken.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add i18nlint --git='https://github.com/henrahmagix/i18nlint' --ref='0.1.0'
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+git clone https://github.com/henrahmagix/i18nlint
+cd i18nlint
+gem build i18nlint.gemspec
+gem install i18nlint i18nlint-0.1.0.gem
+```
+
+## Usage
+
+### Rails
+
+```bash
+bin/rails i18nlint
+```
+
+This task depends on the Rails task `:environment`, so your application will be loaded, including your I18n configuration, to detect your `I18n.default_locale`.
+
+If there's a `.i18nlint.yml` config file in the root folder, it'll get loaded automatically.
+
+### CLI
+As a command-line tool with arguments:
+```bash
+i18nlint --source=en --config=lint.yml config/locales/*.yml
+```
+
+### Ruby
+As a Ruby script:
+```rb
+require "i18nlint"
+
+class MyRule < I18nLint::Rule
+  # Define at least one method of :on_file, :on_segment, or :on_segment_comparison.
+end
+I18nLint.register_rule(MyRule)
+
+offences = I18nLint.lint("path/to/locales/*.{yml,rb,json}", source_locale: "en") # array of offences
+
+# Each offence has the `rule` that added it, the `filepath`, `lineno`, and `text` of the segment or file, and an optional `message` string.
+# Segment offences also have `locale` and their full `key`.
+# It may also contain a `highlight` array of match offsets pointing to the exact location of the offence in `text`.
+# Also if `source_offence` is not nil, it holds the same attributes but about the segment of the same key defined under the source locale.
+offences.each do |o|
+  puts "#{o.rule} offence at #{o.filepath}:#{o.lineno}"
+  puts "#{o.key} in locale: #{o.locale}" unless o.locale && o.key
+  puts "compared to #{o.source_offence.key} in source #{o.source_offence.locale}" if o.source_offence
+  puts o.text, o.message
+end
+```
+
+## Configuration
+
+A YAML file named `.i18nlint.yml` is looked for automatically in the current directory and your home directory.
+
+It can be used to add your own rules and configure them.
+```yml
+require:
+  - ./path/to/my/rule
+  - ./path/to/other/rule
+
+BuiltIn/Interpolations:
+  Enabled: false # disable a built-in that always runs; all rules are enabled by default
+
+MyRules/Amazing: # this matches a class named MyRules::Amazing, defined in any of the `require:` paths above
+  Enabled: true
+  Exclude:  # every rule config can have a list of Pathname#fnmatch to exclude
+    - '*.exclude.yml'
+
+match-segment:
+  # A list of `Pattern:` configurations to search for in each individual segment, where each match is an offence.
+  - Pattern: 'https://.*\.example.org'
+  - Pattern: 'https://.*\.bad.url'
+    Exclude:
+      - urls-*.yml
+  - Pattern: 'Word'
+    CaseSensitive: false # makes the Regexp made from Pattern case-insensitive with Regexp::IGNORECASE
+
+match-file:
+  # Same as match-segment but passes in a whole file
+  - Pattern: something
+
+mismatch-to-source:
+  # Same as match-segment but it matches on both translated segments and their
+  # source, and then compares the matches: if there are any that are in the
+  # source locale but not the translation, or vice versa, an offence is marked.
+  - Pattern: '\[[A-Z_]+\]' # some custom tags used in your renderer like `[NAME]`, `[EMAIL_ADDRESS]`, etc.
+```
+
+## Custom rules
+
+You can define your own custom rules by defining classes extending `I18nLint::Rule`, and requiring them before I18nLint runs if you're using it in ruby, or linking them under `require:` in the configuration file if you're calling the binary. I18nLint will automatically register all of the subclasses of `I18nLint::Rule` that exist at runtime.
+
+You must define at least one of `on_file`, `on_segment`, or `on_segment_comparison` instance methods. Your rule will get a noop definition for any that is missing.
+- `on_file` receives a `I18nLint::File` that has:
+  - `filepath` string
+  - `parsed` Ruby value of the contents as loaded by I18n
+  - `raw` string contents of the file.
+- `on_segment` receives a `I18nLint::Segment` that has:
+  - `file` (the `I18nLint::File` it's in)
+  - `filepath` delegated to `file.filepath`
+  - `lineno` integer of the start of the segment definition within the file
+  - `key` string of the full segment that you would use in `I18n.t()`
+  - `text` string content of the segment
+  - if `text` is nil, `value` will be the Ruby value of the segment (it could be an array... if you're putting arrays in your I18n 🤷)
+  - `locale` symbol of the segment (or string if i18n gem is < 1.9.1)
+  - `source_locale` string of the project source locale
+  - `source?` true if the locale is the project source
+- `on_segment_comparison` receives two `I18nLint::Segment`s: the first is a translation segment, the second is the same segment in the source locale.
+
+To register an offence, use:
+- for `on_file` call `add_file_offence(file, msg = nil, lineno: nil, source: nil, highlight: nil)` where:
+  - `file` is the input argument to `on_file`
+  - `msg` will be displayed alongside the offence
+  - `lineno` is helpful to pass if the issue is isolated to or starts at a certain line in the file
+  - `source` should be the string on which the offence occurred, if any
+  - `highlight` can be passed as an array of tuples to indicate a range of the file content; if you pass this, you probably don't need to pass the `source`
+- for `on_segment` call `add_segment_offence(segment, msg = nil, highlight: nil)` where:
+  - `segment` is the input argument to `on_segment`
+  - `msg` and `highlight` are the same as above
+- for `on_segment_comparison` call `add_segment_compare_offence(segment, source_segment, msg = nil, src_msg = nil, highlight: nil, source_highlight: nil)` where:
+  - `segment` and `source_segment` are the input arguments to `on_segment_comparison`
+  - `msg` and `highlight` are the same as above
+  - `src_msg` and `source_highlight` are the same but attached to the source segment
+
+If you're using Regexp in your rule, more often than not you can pass `highlight: Regexp.last_match.offset(0)` to the add-offence method.
+
+There is a singleton method `on_init` available to add a block that gets evaluated on the rule instance after initialisation, so you can do some one-time setup of configuration values, available as `config`.
+
+A rule can define a `description` instance or class method to describe the rule. Without it, the class name will be used with `::` replaced by `/`.
+
+A message can be passed in per offence, or it will be taken automatically from a `Message` property on the rule configuration.
+
+### Example
+
+```rb
+# lib/linters/i18n.rb
+module MyI18nRules # the module namespace doesn't matter and is entirely optional
+  class DontAllowHelloAndGoodbyeInSameSentence < I18nLint::Rule
+    def on_segment(segment)
+      segment.text.downcase.scan(/[^.?!]*?[.?!]\s*/) do |sentence|
+        if sentence.include?('hello') && sentence.include?('goodbye')
+          add_segment_offence(segment, 'Thou Shalt Not greet and leave in the same sentence', highlight: Regexp.last_match.offset(0))
+        end
+      end
+    end
+  end
+end
+```
+```yml
+# content.yml
+en:
+  welcome: "One two three. Hello and goodbye! One more finally."
+fr:
+  welcome: "Un deux trois. Bonjour et au revoir! Encore."
+```
+```yml
+# .i18nlint.yml
+require:
+  - ./lib/linters/i18n.rb
+```
+```bash
+$ i18nlint --source=en content.yml
+Inspecting 1 files
+F.
+Comparing segments to source EN
+.
+
+Offences:
+
+content.yml:2 in en.welcome: MyI18nRules/DontAllowHelloAndGoodbyeInSameSentence: Thou Shalt Not greet and leave in the same sentence
+  One two three. Hello and goodbye! One more finally.
+                 ^^^^^^^^^^^^^^^^^^^
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec appraisal rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+`bundle exec rake` also runs an example of the CLI tool, and RuboCop.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/henrahmagix/i18nlint. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/henrahmagix/i18nlint/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the I18nLint project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/henrahmagix/i18nlint/blob/main/CODE_OF_CONDUCT.md).

data/exe/i18nlint

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "i18nlint/cli"
+I18nLint::CLI.run(ARGV)

data/lib/i18nlint/cli.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "yaml"
+
+require "i18nlint"
+
+module I18nLint
+  # Run the linter in your terminal.
+  class CLI
+    def self.run(...) = new.run(...)
+
+    def run(args = []) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity
+      conf = Configuration.new(args)
+      conf.on_problems { |e| warn e.message }
+
+      conf.load_from_argv_and_file!
+
+      if conf.source_locale.to_s.empty?
+        warn Configuration.help
+        exit 1
+      end
+
+      if conf.config_file_does_not_exist
+        warn "Config file does not exist: #{conf.config_file_does_not_exist}"
+        warn Configuration.help
+        exit 1
+      end
+
+      conf.register_rules!
+      conf.remaining_rule_options.each_key do |key|
+        warn "Unused configuration #{key.inspect} expects class #{key.gsub("/", "::")} to subclass I18nLint::Rule. " \
+             "If this is a rule you're expecting to be used, that means it hasn't been loaded in the `require:` " \
+             "list, or it doesn't subclass I18nLint::Rule."
+        warn
+      end
+
+      linter = Linter.new(filepaths: conf.filepaths, source_locale: conf.source_locale)
+
+      if linter.num_files.zero?
+        warn "No files given"
+        warn Configuration.help
+        exit 0
+      end
+
+      if Registry.rules.empty?
+        warn "No rules configured"
+        warn Configuration.help
+        exit 0
+      end
+
+      tick = ->(num_offences) { print num_offences.zero? ? "." : "F" }
+      linter.tick_each_file(&tick)
+      linter.tick_each_comparison(&tick)
+
+      puts "Inspecting #{linter.num_files} files"
+      linter.run
+      puts "\nComparing segments to source #{conf.source_locale}"
+      linter.run_comparison
+      puts "\n\n"
+
+      if linter.offences.empty?
+        puts "No offences detected"
+        exit 0
+      end
+
+      puts "Offences:\n\n"
+      puts linter.offences.map { format_offence(_1) }.join("\n\n")
+      puts "\n#{linter.offences.size} offences detected"
+      exit 1
+    end
+
+    FILE_OFFENCE_DISPLAY = <<~MSG
+      %<filepath>s:%<lineno>s: %<rule>s: %<message>s
+      %<text_indented>s
+    MSG
+
+    SEGMENT_OFFENCE_DISPLAY = <<~MSG
+      %<filepath>s:%<lineno>s in %<locale>s.%<key>s: %<rule>s: %<message>s
+      %<text_indented>s
+    MSG
+
+    COMPARE_SEGMENT_OFFENCE_DISPLAY = <<~MSG # 🏳️‍⚧️🏳️‍🌈🫶
+      Comparison: %<rule>s
+      %<trans_filepath>s:%<trans_lineno>s in %<trans_locale>s.%<trans_key>s: %<trans_message>s
+      %<trans_text_indented>s
+      %<source_filepath>s:%<source_lineno>s in %<source_locale>s.%<source_key>s: %<source_message>s
+      %<source_text_indented>s
+    MSG
+
+    private
+
+    def format_offence(offence)
+      o = offence_hash_for_formatting(offence)
+
+      case offence
+      when FileOffence then FILE_OFFENCE_DISPLAY % o
+      when SegmentOffence then SEGMENT_OFFENCE_DISPLAY % o
+      when CompareSegmentOffence
+        source = offence_hash_for_formatting(offence.source_offence)
+
+        COMPARE_SEGMENT_OFFENCE_DISPLAY % rename_keys(o, 'trans_\0').merge(rename_keys(source, 'source_\0'))
+      end.gsub(/:? +$/, "").strip
+    end
+
+    def offence_hash_for_formatting(offence)
+      o = offence.to_h
+      o[:text] = highlight(o[:text], offence.highlight)
+      indent(o)
+    end
+
+    def indent(hash)
+      hash.keys.each do |k|
+        hash[:"#{k}_indented"] = "  #{hash[k].to_s.chomp.gsub("\n", "\n  ")}"
+      end
+      hash
+    end
+
+    def rename_keys(hash, gsub)
+      hash.transform_keys! { _1 == :rule ? _1 : _1.to_s.gsub(/^(.*)$/, gsub).to_sym }
+    end
+
+    def highlight(text, range)
+      return text if range.nil? || range.to_a.empty?
+
+      range = [range] unless range[0].is_a?(Array)
+
+      Highlighters.indicate(text, *range)
+    end
+  end
+end

data/lib/i18nlint/cloneable_struct.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module I18nLint
+  # Ensure cloning an instance also clones its members.
+  class CloneableStruct < Struct
+    def clone
+      super.tap do |new_obj|
+        self.class.members.each do |m|
+          new_obj.send("#{m}=", send(m).clone)
+        end
+      end
+    end
+  end
+end

data/lib/i18nlint/configuration.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module I18nLint
+  # Central store of which locale is the source (only useful for comparative rules) and loading + registering rules.
+  class Configuration
+    def initialize(args, source_locale: "", rule_options: {}, requires: [])
+      @args = args
+      @source_locale = source_locale.upcase
+      @rule_options = rule_options
+      @requires = requires
+    end
+
+    def load_from_argv_and_file!
+      opts = {}
+      self.class.parser.parse!(@args, into: opts)
+
+      @source_locale = opts[:source]&.upcase
+      @config_filepath = opts[:config]
+
+      @filepaths = @args # remaining after being mutated by `parser.parse!`
+      @rule_options.merge!(load_rule_options_from_file)
+
+      @remaining_rule_options = rule_options.dup
+      @requires += @remaining_rule_options.delete("require") || []
+    end
+
+    def on_problems(&block)
+      @on_problems = block
+    end
+
+    def self.help = parser.help
+
+    attr_reader :filepaths, :source_locale, :requires, :rule_options,
+                :config_file_does_not_exist, :remaining_rule_options
+
+    def register_rules!
+      require_relative_from = ::File.dirname(config_filepath || Dir.pwd)
+      requires.each do |path|
+        require ::File.expand_path(path, require_relative_from)
+      end
+
+      register_built_ins
+
+      problems = register_rule_subclasses
+      problems.each { @on_problems.call(_1) } if @on_problems
+    end
+
+    def self.parser
+      @parser ||= OptionParser.new do |parser|
+        parser.banner = "Usage: i18nlint files... --source=LOCALE --config=path/to/.i18nlint.yml"
+
+        parser.on("--source=LOCALE", "The locale to configure segment comparisons against source.")
+        parser.on("--config=CONFIG", "The configuration of rules.")
+      end
+    end
+
+    private
+
+    def config_filepath
+      @config_filepath ||= [
+        ::File.join(Dir.pwd, ".i18nlint.yml"),
+        ::File.join(Dir.home, ".i18nlint.yml")
+      ].find { |f| ::File.exist?(f) }
+    end
+
+    def load_rule_options_from_file
+      return {} if config_filepath.nil?
+
+      ::File.open(config_filepath, "r:bom|utf-8") do |f|
+        load_yaml(f, config_filepath) || {}
+      end
+    rescue ::Errno::ENOENT
+      @config_file_does_not_exist = config_filepath
+      {}
+    end
+
+    if Gem.loaded_specs["psych"].version < Gem::Version.create("3.1.0")
+      def load_yaml(stream, filepath)
+        # Args: whitelist_classes = [], whitelist_symbols = [], aliases = false, filename = nil
+        ::YAML.safe_load(stream.read, [], [], false, filepath)
+      end
+    else
+      def load_yaml(stream, filepath)
+        ::YAML.safe_load(stream.read, filename: filepath)
+      end
+    end
+
+    def find_built_in = proc { _1.name&.start_with?(Rules::BuiltIn.name) }
+
+    def register_built_ins
+      Rule.rule_classes.select(&find_built_in).each do |klass|
+        config = @remaining_rule_options.delete(klass.rule_key) || {}
+        config = [config] unless config.is_a? Array
+        config.each do |conf|
+          register_from_options(conf, klass)
+        end
+      end
+    end
+
+    def register_from_options(conf, klass)
+      enabled = conf.delete("Enabled")
+      enabled = klass.enabled_by_default? if enabled.nil?
+      Registry.register_rule(klass, conf) if enabled
+    end
+
+    def register_rule_subclasses
+      Rule.rule_classes.reject(&find_built_in).filter_map do |klass|
+        conf = @remaining_rule_options.delete(klass.rule_key) if klass.rule_key
+        conf ||= {}
+
+        register_from_options(conf, klass)
+        nil
+      rescue Registry::WillNeverRun => e
+        e unless klass.rule_key.to_s.empty?
+      rescue Error => e
+        e
+      end
+    end
+  end
+end