rubocop-kata 0.4.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9226aba3b639a61e0aa92d657538bb69f79352d54c1c81db90a7d3c751b4d207
-  data.tar.gz: c817aafced4a83b1204330bbf7054a4af1a578011ad59b748a23d0e2a75a0d5e
+  metadata.gz: 4d84b32b4beb311cd73ed3af609400cc07a4a1e7fb41258e813feab7a7477ae9
+  data.tar.gz: 3038bc491f3197c6623f30f68742fda4008c4519cbacc2c95dc36e0ebc10276c
 SHA512:
-  metadata.gz: 0c99d13ee22eb68d9d2052d708048c931b63427fdc8ecd637dd8fc935391daf968506a5bc5c9494e17cf87b0f5f44a274c726233180d2931e518c73576e0f81d
-  data.tar.gz: f9d9b2461802ad1e59accd6fa0729875812bf4d140a5e84e8e68fa4dd0eea7ee47d8b2adcdda2304fc53d01675e3395428f97e0ffdb2e0e468d031c528027904
+  metadata.gz: b38144839ec596e2f646f89f2c28328978cf030d7bbc9c31deccad49fe94ad9775e75a2af69d51961cfed832f3acc7b49c32c43f0830fc98d300c8033cda1230
+  data.tar.gz: 5ab77b46b9eab5d756368860c1f40866111964217dc0fda9cda532c49574fc6472dc60fb2a091c1e3d54269b63266b956f4bfd9a900ad50528dae96a8a8dd3de

data/CHANGELOG.md

@@ -1,7 +1,81 @@
 # Changelog
 
-## [0.4.0] - 2026-08-14
+## [0.7.0] - 2026-08-16
+
+- New `rubocop-kata doctor` command: reports `.rubocop.yml` entries that
+  configure a cop the inherited configuration already disables, and
+  `rubocop:disable`/`enable` comments naming a cop that is not enabled where
+  the comment sits. RuboCop reports neither. Exits non-zero when it finds
+  something.
+- `Style/DisableCopsWithinSourceCodeDirective` is now on.
+- `Kata/AgentNoun` suggests a name when it can derive one: a compound minus its
+  agent word (`PaymentProcessor` -> `Payment`), or a regular
+  -ator/-ector/-isor/-izer noun the shipped dictionary confirms (`Selector` ->
+  `Selection`, `Synthesizer` -> `Synthesis`). It never proposes a name it would
+  flag in turn.
+- `Kata/AgentNoun` `AllowedNames` entries now match a whole name or a trailing
+  segment of one, so the default `Error` also exempts `UsageError` and
+  `ParseError` without listing them.
+- `Kata/BuilderNoun` gained `AllowedNames`, for the method whose name an
+  external API dictates (`get_callbacks`).
+- The dictionary moved to `RuboCop::Kata::Dictionary`, shared by
+  `Kata/RealWords` and `Kata/AgentNoun`.
+
+## [0.6.0] - 2026-08-15
+
+- The base dictionary is now SCOWL en-US size 60 (~83k words including
+  inflections — https://wordlist.aspell.net, see data/SCOWL-COPYRIGHT), so the
+  hand-rolled stemmer shrank to productive derivations only (-able, -er/-or
+  agent nouns, -less, plurals for supplement/software terms).
+- `Kata/RealWords` now also draws on a vendored dictionary of software
+  vocabulary (`data/software.txt.gz`, ~4300 words) built from the MIT-licensed
+  cspell `software-terms`, `ruby`, and `shell` dictionaries
+  (https://github.com/streetsidesoftware/cspell-dicts) — `argv`, `stderr`,
+  `klass`, `mutex`, `regex`, and friends no longer need per-project `Terms`.
+- The stemmer understands comparatives (`newer`, `deeper`), superlatives
+  (`longest`), and `-ied` pasts (`denied`); common irregular pasts (`held`,
+  `paid`, `heard`) joined the supplement.
+- `Kata/GoodMethodName` ignores operator methods (`[]`, `==`, `<=>`, `<<`) —
+  Ruby dictates their names.
+- `Kata/GoodVariableName` ships `_include_private` (the `respond_to_missing?`
+  protocol argument) in its default `AllowedNames`.
 
+## [0.5.0] - 2026-08-15
+
+- New cops `Kata/GoodMethodName` and `Kata/GoodVariableName`. One word is the
+  default and the goal; a second word is allowed only when it is not hiding a
+  missing object — a role prefix (`after_fork`, `each_group`, `to_h`), a role
+  suffix (`file_of`, `tests_for`, `points_at`), or a compound noun listed in
+  `Terms:`. `Terms:` is a budget you spend consciously, like `max_ignored` in a
+  mutation-testing config, not a silent escape hatch. `verb_receiver` names
+  (`build_adapter`, `apply_excludes`, `covering_count`) stay offenses, and so do
+  three-word names. The variable cop understands `@`, `@@`, `$`, and the
+  `_unused`/`@_memo` conventions.
+- New cop `Kata/RealWords` replaces `Kata/NoAbbreviation`. A blocklist has to
+  enumerate its whole domain to work: an abbreviation nobody thought to ban
+  passed silently, and deleting the underscore (`matching_ids` → `matchingids`)
+  dodged the naming cops entirely. The check is now inverted — every
+  underscore-separated segment of a name must be a word the gem's shipped
+  dictionary knows, so `errorcount` and `cfg` fail with zero configuration
+  while `deadline` and `mutant` sail through. The dictionary is the web2
+  wordlist (lowercase, 2–16 letters, gzipped in `data/`), a visible
+  `data/supplement.txt` of modern vocabulary web2 predates (`json`,
+  `memoize`, `timestamp`), and a light stemmer for plurals, `-ed`, `-ing`,
+  `-able`, and `un-`/`re-`/`non-`. `BannedWords:` keeps flagging abbreviations
+  that happen to be dictionary words (`err`, `res`, `pos`); `Terms:` is the
+  reviewed domain-jargon budget and overrides `BannedWords:`; `AllowedNames:`
+  exempts names an external protocol dictates (`def pos` on a scanner,
+  `def env` for Rack). Operator names, single-letter segments, and the
+  `_unused`/`@_memo` shapes are ignored. Method names, ivars, class variables,
+  and globals are all checked — `Kata/NoAbbreviation` saw only locals and
+  parameters.
+- `Elegant/GoodMethodName` and `Elegant/GoodVariableName` are now disabled:
+  Kata owns naming, and the upstream one-word-only rule is what pushed people
+  into deleting underscores in the first place.
+- Removed `Kata/NoNilReturn`: duplicate of the bundled `Elegant/NoNilReturn`,
+  which covers a superset (blocks, lambdas, `kwbegin` tails).
+
+## [0.4.0] - 2026-08-14
 - `Naming/MemoizedInstanceVariableName` enforced with
   `EnforcedStyleForLeadingUnderscores: required`: memoization caches are
   named `@_name`, marking lazy state at the read site.

data/README.md

@@ -1,19 +1,33 @@
 # rubocop-kata
 
-A RuboCop plugin that replaces a pile of linter gems and config with one dependency. Install it and your `.rubocop.yml` shrinks to project-specific overrides. Everything else comes from the gem: a curated stack of RuboCop extensions, opinionated style defaults, and fourteen house cops.
+A RuboCop plugin that replaces a pile of linter gems and config with one dependency. Install it and your `.rubocop.yml` shrinks to project-specific overrides. Everything else comes from the gem: a curated stack of RuboCop extensions, opinionated style defaults, and fifteen house cops.
+
+`Kata/GoodMethodName` asks for one word per method name. A second word is
+allowed only when it is not hiding a missing object: a role prefix
+(`after_fork`), a role suffix (`file_of`), or a compound noun you have added to
+`Terms` on purpose. The wrong way to satisfy the cop is `matching_ids` →
+`matchingids`: if you need two words, that is a modelling smell — the concept is
+missing, or the method belongs on a different object. `Kata/RealWords` catches
+that dodge with a shipped dictionary instead of a word list you maintain:
+`matchingids` is not a word, so it fails with zero configuration — and so does
+`cfg`.
 
 - **One dependency.** Bundles rubocop-rspec, rubocop-performance, rubocop-elegant, rubocop-packaging, and rubocop-thread_safety behind a single gem.
 - **Opinionated defaults.** Methods under 5 lines, classes under 100, 4 parameters max, 120-column lines, double quotes, `NewCops: enable`. See [config/default.yml](config/default.yml).
-- **Fourteen house cops.** Naming, dependency discipline, and data honesty in the Elegant Objects spirit — from `Kata/AgentNoun` to `Kata/ClockDiscipline`.
+- **Fifteen house cops.** Naming, dependency discipline, and data honesty in the Elegant Objects spirit — from `Kata/AgentNoun` to `Kata/ClockDiscipline`.
 
 ```ruby
-class PaymentProcessor  # Kata/AgentNoun: `PaymentProcessor` names a doer;
-end                     #   name the class for the thing it is, not the work it does.
+class PaymentProcessor  # Kata/AgentNoun: `PaymentProcessor` names a doer; name the class
+end                     #   for the thing it is, not the work it does. Try `Payment`.
 
 class Payment           # OK
 end
 ```
 
+It suggests a name only when it can derive one: a compound minus its agent word,
+or a regular `-ator`/`-ector`/`-isor`/`-izer` noun the shipped dictionary
+confirms (`Selector` → `Selection`, `Synthesizer` → `Synthesis`).
+
 ## Getting started
 
 Add the gem to your `Gemfile`:
@@ -43,29 +57,66 @@ That's it. The plugin loads the bundled extensions and the shared defaults, so y
 
 | Cop | Default | What it enforces |
 | --- | --- | --- |
-| `Kata/AgentNoun` | on | Classes named for what they are, not `-er`/`-or` doers. Allow exceptions via `AllowedNames`. |
+| `Kata/AgentNoun` | on | Classes named for what they are, not `-er`/`-or` doers. Suggests the better name when it can derive one. `AllowedNames` matches a whole name or a trailing segment, so `Error` covers `UsageError`. |
 | `Kata/NoComments` | on | No prose comments; say it in the code. Magic comments, linter directives, and licence headers survive. Autocorrects. |
 | `Kata/IoDiscipline` | on | No bare `puts`/`warn`/`pp`/`p` outside specs/scripts; write through an injected `@io` or an explicit receiver. |
 | `Kata/ProsePlacement` | off | Sentence-length strings belong in the presentation layer. Enable with an `Include`/`Exclude` matching your layering. |
 | `Kata/NoUtilName` | on | No junk-drawer names (`Util`, `Helper`, `Manager`, `Service`, …). Tune via `BannedNames`. |
-| `Kata/NoAbbreviation` | on | Spell words out; no `usr`, `cfg`, `res`. Tune via `BannedNames`. |
-| `Kata/BuilderNoun` | on | Builders named for what they return: `total`, not `calculate_total`. Tune via `BannedPrefixes`. |
+| `Kata/RealWords` | on | Every name segment is a word the shipped dictionary knows — `errorcount` (smash) and `cfg` (abbreviation) both fail, with no word list to maintain. Tune via `Terms`/`BannedWords`/`AllowedNames`. |
+| `Kata/GoodMethodName` | on | One word per method name; a second word needs a role prefix (`after_fork`), a role suffix (`file_of`), or a reviewed `Terms` entry. Tune via `MaxWords`/`Prefixes`/`Suffixes`/`Terms`/`AllowedNames`. |
+| `Kata/GoodVariableName` | on | The same rule for locals, parameters, ivars, class variables, and globals; `_name` and `@_name` stay exempt. |
+| `Kata/BuilderNoun` | on | Builders named for what they return: `total`, not `calculate_total`. Tune via `BannedPrefixes`/`AllowedNames`. |
 | `Kata/NoBooleanFlag` | on | No positional boolean arguments; split the method or use a keyword. |
 | `Kata/ConstructorDiscipline` | on | `initialize` assigns, raises, or freezes — never computes. |
 | `Kata/NoClassMethodLogic` | on | Class methods construct (`build`, `parse`, `of`, `from_*`); instances do the work. |
 | `Kata/NoHashAsObject` | on | A hash with `MaxKeys`+ keys (default 4) wants to be an object. Keyword-argument call sites exempt. |
-| `Kata/NoNilReturn` | on | No `return nil` or trailing `nil`; raise or return a real object. |
 | `Kata/ClockDiscipline` | on | No bare `Time.now`/`Date.today`/`.current`; inject a clock. |
 | `Kata/EnvDiscipline` | on | `ENV` reads only in the boot layer (`config/`, `bin/`, `exe/`). |
 
+## Dead configuration
+
+`doctor` reports configuration that no longer does anything: a `.rubocop.yml`
+entry for a cop the inherited configuration disables, and a
+`rubocop:disable`/`enable` comment naming a cop that is not enabled where the
+comment sits. RuboCop reports neither.
+
+```sh
+bundle exec rubocop-kata doctor          # or: doctor path/to/project
+```
+
+```
+.rubocop.yml:20: `Elegant/GoodMethodName` is disabled by the configuration this project inherits; the entry does nothing.
+lib/registry.rb:44: the directive names `Elegant/GoodMethodName`, which is not enabled here; the comment does nothing.
+2 dead entries
+```
+
+It exits non-zero when it finds something, so it can gate CI.
+
 ## The defaults
 
 Double-quoted strings, `Metrics/MethodLength: 5`, `Metrics/ClassLength: 100`,
 `Metrics/ParameterLists: 4`, 120-column lines, endless methods on one line,
-`rescue => error`, `NewCops: enable`, and heredocs counted as one line in
-spec examples. See
+`rescue => error`, `NewCops: enable`, heredocs counted as one line in spec
+examples, and no inline `rubocop:disable` comments
+(`Style/DisableCopsWithinSourceCodeDirective`). See
 [config/default.yml](config/default.yml).
 
 ## License
 
-MIT.
+The code is MIT — see [LICENSE.txt](LICENSE.txt). The shipped dictionaries are
+third-party data under their own terms:
+
+- **`data/words.txt.gz`** — a *modified* subset of [SCOWL](https://wordlist.aspell.net)
+  en-US size 60: filtered, deduplicated, and gzipped. SCOWL is the collective work of
+  Kevin Atkinson and the contributors named in
+  [data/SCOWL-COPYRIGHT](data/SCOWL-COPYRIGHT), which is distributed with this gem and
+  reproduced verbatim. It includes, among others, Copyright 2000–2018 Kevin Atkinson;
+  WordNet 1.6 Copyright 1997 by Princeton University, all rights reserved; and Copyright
+  1993 Geoff Kuenning, Granada Hills, CA, all rights reserved. Princeton University makes
+  no representations or warranties, express or implied, as to this database, and its name
+  may not be used in advertising or publicity pertaining to this distribution.
+- **`data/software.txt.gz`** — built from the `software-terms`, `ruby`, and `shell`
+  dictionaries of [cspell-dicts](https://github.com/streetsidesoftware/cspell-dicts),
+  each MIT-licensed. Copyright (c) 2017–2025 Street Side Software; the notice and
+  permission text are reproduced in [data/CSPELL-LICENSE](data/CSPELL-LICENSE).
+- **`data/supplement.txt`** — this project's own additions, MIT.

data/config/default.yml

@@ -11,9 +11,13 @@ AllCops:
     - "vendor/**/*"
 
 Kata/AgentNoun:
-  Description: "Name classes for the thing they are, not the work they do."
+  Description: >-
+    Name classes for the thing they are, not the work they do. `AllowedNames`
+    entries match a whole name or a trailing segment of one, so `Error` also
+    exempts `UsageError`.
   Enabled: true
   VersionAdded: "0.1"
+  VersionChanged: "0.7"
   AllowedNames:
     - Error
 
@@ -25,6 +29,118 @@ Kata/NoComments:
     - "spec/**/*"
     - "*.gemspec"
 
+Kata/GoodMethodName:
+  Description: >-
+    One word per method name. A second word is allowed only when it does not
+    hide a missing object: a role prefix (`after_fork`), a role suffix
+    (`file_of`), or a reviewed domain term. Do not delete the underscore —
+    Kata/RealWords catches the smash.
+  Enabled: true
+  VersionAdded: "0.5"
+  MaxWords: 2
+  Pattern: "^[a-z][a-z0-9]{0,15}$"
+  Prefixes:
+    - after
+    - all
+    - any
+    - around
+    - as
+    - at
+    - before
+    - by
+    - each
+    - every
+    - fake
+    - for
+    - from
+    - into
+    - "no"
+    - non
+    - "on"
+    - per
+    - test
+    - the
+    - to
+    - unless
+    - until
+    - when
+    - while
+    - with
+    - without
+  Suffixes:
+    - at
+    - by
+    - for
+    - from
+    - in
+    - into
+    - of
+    - on
+    - over
+    - per
+    - to
+    - under
+    - with
+    - without
+  Terms: []
+  AllowedNames: []
+
+Kata/GoodVariableName:
+  Description: >-
+    One word per variable name. A second word means a missing object, not a
+    name to smash together — Kata/RealWords catches the smash. Role prefixes, role
+    suffixes, and reviewed domain terms are the three exceptions.
+  Enabled: true
+  VersionAdded: "0.5"
+  MaxWords: 2
+  Pattern: "^[a-z][a-z0-9]{0,15}$"
+  Prefixes:
+    - after
+    - all
+    - any
+    - around
+    - as
+    - at
+    - before
+    - by
+    - each
+    - every
+    - fake
+    - for
+    - from
+    - into
+    - "no"
+    - non
+    - "on"
+    - per
+    - test
+    - the
+    - to
+    - unless
+    - until
+    - when
+    - while
+    - with
+    - without
+  Suffixes:
+    - at
+    - by
+    - for
+    - from
+    - in
+    - into
+    - of
+    - on
+    - over
+    - per
+    - to
+    - under
+    - with
+    - without
+  Terms: []
+  AllowedNames:
+    - _include_private
+
 Kata/IoDiscipline:
   Description: "Write through an injected io, not bare puts/warn/pp/p."
   Enabled: true
@@ -58,11 +174,15 @@ Kata/NoUtilName:
     - Misc
     - Shared
 
-Kata/NoAbbreviation:
-  Description: "Spell words out; code reads aloud like prose."
+Kata/RealWords:
+  Description: >-
+    Every name segment is a dictionary word: `errorcount` is a smash, `cfg`
+    is an abbreviation, `mutant` is fine. The dictionary ships with the gem;
+    `Terms` holds reviewed domain jargon, `AllowedNames` exempts names an
+    external protocol dictates.
   Enabled: true
-  VersionAdded: "0.3"
-  BannedNames:
+  VersionAdded: "0.5"
+  BannedWords:
     - usr
     - cfg
     - tmp
@@ -75,17 +195,25 @@ Kata/NoAbbreviation:
     - idx
     - ctx
     - err
+    - len
+    - msg
+    - pos
+    - ptr
+  Terms: []
+  AllowedNames: []
 
 Kata/BuilderNoun:
   Description: "Builders are named for what they return; verbs are for side effects."
   Enabled: true
   VersionAdded: "0.3"
+  VersionChanged: "0.7"
   BannedPrefixes:
     - get
     - calculate
     - compute
     - retrieve
     - generate
+  AllowedNames: []
 
 Kata/NoBooleanFlag:
   Description: "A boolean flag is two methods trapped in one."
@@ -121,13 +249,6 @@ Kata/NoHashAsObject:
     - "spec/**/*"
     - "config/**/*"
 
-Kata/NoNilReturn:
-  Description: "Raise or return a real object; never nil."
-  Enabled: true
-  VersionAdded: "0.3"
-  Exclude:
-    - "spec/**/*"
-
 Kata/ClockDiscipline:
   Description: "Read time from an injected clock, not the ambient one."
   Enabled: true
@@ -171,13 +292,18 @@ Naming/RescuedExceptionsVariableName:
   PreferredName: error
 
 # Memoization caches are marked with a leading underscore (@_name), so lazy
-# state is visible at the read site; Elegant/GoodVariableName learns the
+# state is visible at the read site; Kata/GoodVariableName knows the
 # same @_word shape.
 Naming/MemoizedInstanceVariableName:
   EnforcedStyleForLeadingUnderscores: required
 
+# Kata owns naming now; the upstream cops force strictly one word, which is
+# what drives the underscore-smashing dodge.
+Elegant/GoodMethodName:
+  Enabled: false
+
 Elegant/GoodVariableName:
-  Pattern: '^(_.*|@_[a-z]{1,16}|(@{1,2}|\$)?(the_|test_|fake_)?[a-z]{1,16})$'
+  Enabled: false
 
 Layout/LineLength:
   Max: 120
@@ -259,6 +385,11 @@ Layout/EmptyLinesAroundAccessModifier:
 Layout/EmptyLinesAfterModuleInclusion:
   Enabled: false
 
+# --- A disable comment is a note saying what the code should have said;
+# `rubocop-kata doctor` finds the ones core cannot see.
+Style/DisableCopsWithinSourceCodeDirective:
+  Enabled: true
+
 # --- Correctors known to rewrite code incorrectly; report only.
 # Inlines a variable past side effects (ivar resets, later statements) and
 # corrupts Ruby 3.1 keyword shorthand.

data/data/CSPELL-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Street Side Software <support@streetsidesoftware.nl>
+
+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/data/SCOWL-COPYRIGHT

@@ -0,0 +1,248 @@
+The collective work is Copyright 2000-2018 by Kevin Atkinson as well
+as any of the copyrights mentioned below:
+
+  Copyright 2000-2018 by Kevin Atkinson
+
+  Permission to use, copy, modify, distribute and sell these word
+  lists, the associated scripts, the output created from the scripts,
+  and its documentation for any purpose is hereby granted without fee,
+  provided that the above copyright notice appears in all copies and
+  that both that copyright notice and this permission notice appear in
+  supporting documentation. Kevin Atkinson makes no representations
+  about the suitability of this array for any purpose. It is provided
+  "as is" without express or implied warranty.
+
+Alan Beale <biljir@pobox.com> also deserves special credit as he has,
+in addition to providing the 12Dicts package and being a major
+contributor to the ENABLE word list, given me an incredible amount of
+feedback and created a number of special lists (those found in the
+Supplement) in order to help improve the overall quality of SCOWL.
+
+The 10 level includes the 1000 most common English words (according to
+the Moby (TM) Words II [MWords] package), a subset of the 1000 most
+common words on the Internet (again, according to Moby Words II), and
+frequently class 16 from Brian Kelk's "UK English Wordlist
+with Frequency Classification".
+
+The MWords package was explicitly placed in the public domain:
+
+    The Moby lexicon project is complete and has
+    been place into the public domain. Use, sell,
+    rework, excerpt and use in any way on any platform.
+
+    Placing this material on internal or public servers is
+    also encouraged. The compiler is not aware of any
+    export restrictions so freely distribute world-wide.
+
+    You can verify the public domain status by contacting
+
+    Grady Ward
+    3449 Martha Ct.
+    Arcata, CA  95521-4884
+
+    grady@netcom.com
+    grady@northcoast.com
+
+The "UK English Wordlist With Frequency Classification" is also in the
+Public Domain:
+
+  Date: Sat, 08 Jul 2000 20:27:21 +0100
+  From: Brian Kelk <Brian.Kelk@cl.cam.ac.uk>
+
+  > I was wondering what the copyright status of your "UK English
+  > Wordlist With Frequency Classification" word list as it seems to
+  > be lacking any copyright notice.
+
+  There were many many sources in total, but any text marked
+  "copyright" was avoided. Locally-written documentation was one
+  source. An earlier version of the list resided in a filespace called
+  PUBLIC on the University mainframe, because it was considered public
+  domain.
+
+  Date: Tue, 11 Jul 2000 19:31:34 +0100
+
+  > So are you saying your word list is also in the public domain?
+
+  That is the intention.
+
+The 20 level includes frequency classes 7-15 from Brian's word list.
+
+The 35 level includes frequency classes 2-6 and words appearing in at
+least 11 of 12 dictionaries as indicated in the 12Dicts package.  All
+words from the 12Dicts package have had likely inflections added via
+my inflection database.
+
+The 12Dicts package and Supplement is in the Public Domain.
+
+The WordNet database, which was used in the creation of the
+Inflections database, is under the following copyright:
+
+  This software and database is being provided to you, the LICENSEE,
+  by Princeton University under the following license.  By obtaining,
+  using and/or copying this software and database, you agree that you
+  have read, understood, and will comply with these terms and
+  conditions.:
+
+  Permission to use, copy, modify and distribute this software and
+  database and its documentation for any purpose and without fee or
+  royalty is hereby granted, provided that you agree to comply with
+  the following copyright notice and statements, including the
+  disclaimer, and that the same appear on ALL copies of the software,
+  database and documentation, including modifications that you make
+  for internal use or for distribution.
+
+  WordNet 1.6 Copyright 1997 by Princeton University.  All rights
+  reserved.
+
+  THIS SOFTWARE AND DATABASE IS PROVIDED "AS IS" AND PRINCETON
+  UNIVERSITY MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+  IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PRINCETON
+  UNIVERSITY MAKES NO REPRESENTATIONS OR WARRANTIES OF MERCHANT-
+  ABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE
+  LICENSED SOFTWARE, DATABASE OR DOCUMENTATION WILL NOT INFRINGE ANY
+  THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
+
+  The name of Princeton University or Princeton may not be used in
+  advertising or publicity pertaining to distribution of the software
+  and/or database.  Title to copyright in this software, database and
+  any associated documentation shall at all times remain with
+  Princeton University and LICENSEE agrees to preserve same.
+
+The 40 level includes words from Alan's 3esl list found in version 4.0
+of his 12dicts package.  Like his other stuff the 3esl list is also in the
+public domain.
+
+The 50 level includes Brian's frequency class 1, words appearing
+in at least 5 of 12 of the dictionaries as indicated in the 12Dicts
+package, and uppercase words in at least 4 of the previous 12
+dictionaries.  A decent number of proper names is also included: The
+top 1000 male, female, and Last names from the 1990 Census report; a
+list of names sent to me by Alan Beale; and a few names that I added
+myself.  Finally a small list of abbreviations not commonly found in
+other word lists is included.
+
+The name files form the Census report is a government document which I
+don't think can be copyrighted.
+
+The file special-jargon.50 uses common.lst and word.lst from the
+"Unofficial Jargon File Word Lists" which is derived from "The Jargon
+File".  All of which is in the Public Domain.  This file also contain
+a few extra UNIX terms which are found in the file "unix-terms" in the
+special/ directory.
+
+The 55 level includes words from Alan's 2of4brif list found in version
+4.0 of his 12dicts package.  Like his other stuff the 2of4brif is also
+in the public domain.
+
+The 60 level includes all words appearing in at least 2 of the 12
+dictionaries as indicated by the 12Dicts package.
+
+The 70 level includes Brian's frequency class 0 and the 74,550 common
+dictionary words from the MWords package.  The common dictionary words,
+like those from the 12Dicts package, have had all likely inflections
+added.  The 70 level also included the 5desk list from version 4.0 of
+the 12Dics package which is in the public domain.
+
+The 80 level includes the ENABLE word list, all the lists in the
+ENABLE supplement package (except for ABLE), the "UK Advanced Cryptics
+Dictionary" (UKACD), the list of signature words from the YAWL package,
+and the 10,196 places list from the MWords package.
+
+The ENABLE package, mainted by M\Cooper <thegrendel@theriver.com>,
+is in the Public Domain:
+
+  The ENABLE master word list, WORD.LST, is herewith formally released
+  into the Public Domain. Anyone is free to use it or distribute it in
+  any manner they see fit. No fee or registration is required for its
+  use nor are "contributions" solicited (if you feel you absolutely
+  must contribute something for your own peace of mind, the authors of
+  the ENABLE list ask that you make a donation on their behalf to your
+  favorite charity). This word list is our gift to the Scrabble
+  community, as an alternate to "official" word lists. Game designers
+  may feel free to incorporate the WORD.LST into their games. Please
+  mention the source and credit us as originators of the list. Note
+  that if you, as a game designer, use the WORD.LST in your product,
+  you may still copyright and protect your product, but you may *not*
+  legally copyright or in any way restrict redistribution of the
+  WORD.LST portion of your product. This *may* under law restrict your
+  rights to restrict your users' rights, but that is only fair.
+
+UKACD, by J Ross Beresford <ross@bryson.demon.co.uk>, is under the
+following copyright:
+
+  Copyright (c) J Ross Beresford 1993-1999. All Rights Reserved.
+
+  The following restriction is placed on the use of this publication:
+  if The UK Advanced Cryptics Dictionary is used in a software package
+  or redistributed in any form, the copyright notice must be
+  prominently displayed and the text of this document must be included
+  verbatim.
+
+  There are no other restrictions: I would like to see the list
+  distributed as widely as possible.
+
+The 95 level includes the 354,984 single words, 256,772 compound
+words, 4,946 female names and the 3,897 male names, and 21,986 names
+from the MWords package, ABLE.LST from the ENABLE Supplement, and some
+additional words found in my part-of-speech database that were not
+found anywhere else.
+
+Accent information was taken from UKACD.
+
+The VarCon package was used to create the American, British, Canadian,
+and Australian word list.  It is under the following copyright:
+
+  Copyright 2000-2016 by Kevin Atkinson
+
+  Permission to use, copy, modify, distribute and sell this array, the
+  associated software, and its documentation for any purpose is hereby
+  granted without fee, provided that the above copyright notice appears
+  in all copies and that both that copyright notice and this permission
+  notice appear in supporting documentation. Kevin Atkinson makes no
+  representations about the suitability of this array for any
+  purpose. It is provided "as is" without express or implied warranty.
+
+  Copyright 2016 by Benjamin Titze
+
+  Permission to use, copy, modify, distribute and sell this array, the
+  associated software, and its documentation for any purpose is hereby
+  granted without fee, provided that the above copyright notice appears
+  in all copies and that both that copyright notice and this permission
+  notice appear in supporting documentation. Benjamin Titze makes no
+  representations about the suitability of this array for any
+  purpose. It is provided "as is" without express or implied warranty.
+
+  Since the original words lists come from the Ispell distribution:
+
+  Copyright 1993, Geoff Kuenning, Granada Hills, CA
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  3. All modifications to the source code must be clearly marked as
+     such.  Binary redistributions based on modified source code
+     must be clearly marked as modified versions in the documentation
+     and/or other materials provided with the distribution.
+  (clause 4 removed with permission from Geoff Kuenning)
+  5. The name of Geoff Kuenning may not be used to endorse or promote
+     products derived from this software without specific prior
+     written permission.
+
+  THIS SOFTWARE IS PROVIDED BY GEOFF KUENNING AND CONTRIBUTORS ``AS IS'' AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED.  IN NO EVENT SHALL GEOFF KUENNING OR CONTRIBUTORS BE LIABLE
+  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+  SUCH DAMAGE.

data/data/supplement.txt

@@ -0,0 +1,92 @@
+accessor
+api
+app
+async
+autocorrect
+backend
+began
+blew
+boilerplate
+boolean
+callback
+changelog
+classify
+cli
+config
+cron
+css
+csv
+cwd
+database
+dataset
+debugger
+dequeue
+deserialize
+diff
+download
+email
+endpoint
+enqueue
+formatter
+frontend
+frontmatter
+gemspec
+glyph
+gui
+heard
+held
+html
+http
+https
+initializer
+inline
+internet
+iterator
+json
+jwt
+keyword
+logout
+max
+memoization
+memoize
+metadata
+middleware
+min
+mixin
+multiline
+namespace
+oauth
+offline
+online
+paid
+payload
+plugin
+proc
+queueing
+readme
+refactor
+runtime
+scheduler
+screenshot
+serializer
+sigil
+signup
+sql
+timeout
+timestamp
+tokenizer
+tui
+tuple
+unshift
+uri
+url
+uuid
+validator
+webhook
+webpage
+website
+whitespace
+workflow
+workspace
+xml
+yaml

data/exe/rubocop-kata

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rubocop-kata"
+require "rubocop/kata/checkup"
+
+abort("usage: rubocop-kata doctor [path]") unless ARGV.first == "doctor"
+
+exit(RuboCop::Kata::Checkup.new(ARGV.fetch(1, Dir.pwd)).run)

data/lib/rubocop/cop/kata/agent_noun.rb

@@ -2,8 +2,10 @@
 
 class RuboCop::Cop::Kata::AgentNoun < RuboCop::Cop::Base
   MSG = "`%s` names a doer; name the class for the thing it is, not the work it does."
-
+  HINT = "#{MSG} Try `%s`.".freeze
   SUFFIX = /(?:er|or)\z/
+  SEGMENT = /[A-Z]+(?=[A-Z][a-z]|\z)|[A-Z][a-z0-9]*/
+  DERIVATIONS = [[/ator\z/, "ation"], [/ector\z/, "ection"], [/isor\z/, "ision"], [/i[zs]er\z/, "is"]].freeze
 
   def on_class(node) = check(node)
 
@@ -15,8 +17,29 @@ class RuboCop::Cop::Kata::AgentNoun < RuboCop::Cop::Base
     name = node.identifier.short_name.to_s
     return unless SUFFIX.match?(name)
     return if allowed?(name)
-    add_offense(node.identifier, message: format(MSG, name))
+    add_offense(node.identifier, message: message(name))
+  end
+
+  def message(name)
+    hint = suggestion(name)
+    hint ? format(HINT, name, hint) : format(MSG, name)
+  end
+
+  def suggestion(name)
+    segments = name.scan(SEGMENT)
+    return proposal(segments[0..-2].join) if segments.length > 1
+    DERIVATIONS.filter_map { proposal(name.sub(it.first, it.last)) }.first
   end
 
-  def allowed?(name) = Array(cop_config["AllowedNames"]).map(&:to_s).include?(name)
+  def proposal(name)
+    return if name.empty? || SUFFIX.match?(name)
+    return unless known?(name)
+    name
+  end
+
+  def known?(name) = RuboCop::Kata::Dictionary::ENTRIES.include?(name.scan(SEGMENT).last.to_s.downcase)
+
+  def allowed?(name) = list.any? { name.end_with?(it) }
+
+  def list = Array(cop_config["AllowedNames"]).map(&:to_s).reject(&:empty?)
 end

data/lib/rubocop/cop/kata/builder_noun.rb

@@ -12,10 +12,12 @@ class RuboCop::Cop::Kata::BuilderNoun < RuboCop::Cop::Base
   def check(node)
     name = node.method_name.to_s
     verb = prefix(name)
-    return unless verb
+    return if verb.nil? || allowed?(name)
     add_offense(node.loc.name, message: format(MSG, name.delete_prefix("#{verb}_"), name))
   end
 
+  def allowed?(name) = Array(cop_config["AllowedNames"]).map(&:to_s).include?(name)
+
   def prefix(name)
     Array(cop_config["BannedPrefixes"]).map(&:to_s).find { name.start_with?("#{it}_") }
   end

data/lib/rubocop/cop/kata/good_method_name.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class RuboCop::Cop::Kata::GoodMethodName < RuboCop::Cop::Base
+  MSG = "`%s` needs two words: either a concept is missing, or the method belongs on the object " \
+    "the second word names. Say it in one word, move it, give the role a `Prefixes`/`Suffixes` " \
+    "word — or, if `%s` is one domain concept here, add it to `Terms`."
+
+  def on_def(node) = check(node, node.method_name)
+
+  def on_defs(node) = check(node, node.method_name)
+
+  private
+
+  def check(node, name)
+    return unless name.match?(/\A[a-z_]/)
+    stem = name.to_s.sub(/[?!=]\z/, "")
+    return if allowed?(name.to_s) || allowed?(stem)
+    return if good?(stem)
+    add_offense(node.loc.name, message: format(MSG, name, name))
+  end
+
+  def good?(stem)
+    words = stem.split("_")
+    return false unless words.all? { pattern.match?(it) }
+    core = core(words)
+    return words.size == 1 if core.size == words.size
+    core.size.between?(1, max)
+  end
+
+  def core(words)
+    rest = prefix?(words.first) && words.size > 1 ? words.drop(1) : words
+    suffix?(rest.last) && rest.size > 1 ? rest[0..-2] : rest
+  end
+
+  def prefix?(word) = list("Prefixes").include?(word)
+
+  def suffix?(word) = list("Suffixes").include?(word)
+
+  def allowed?(name) = list("AllowedNames").include?(name) || list("Terms").include?(name)
+
+  def list(key) = Array(cop_config[key]).map(&:to_s)
+
+  def max = Integer(cop_config.fetch("MaxWords", 2))
+
+  def pattern = Regexp.new(cop_config.fetch("Pattern", "^[a-z][a-z0-9]{0,15}$"))
+end

data/lib/rubocop/cop/kata/good_variable_name.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class RuboCop::Cop::Kata::GoodVariableName < RuboCop::Cop::Base
+  MSG = "`%s` needs two words: the second word names an object you have not introduced yet. " \
+    "Name that object, use a `Prefixes`/`Suffixes` role word — or, if `%s` is one domain concept " \
+    "here, add it to `Terms`."
+
+  SIGIL = /\A(@@|@|\$)/
+
+  def on_lvasgn(node) = check(node, node.name)
+
+  def on_ivasgn(node) = check(node, node.name)
+
+  def on_cvasgn(node) = check(node, node.name)
+
+  def on_gvasgn(node) = check(node, node.name)
+
+  def on_arg(node) = check(node, node.name)
+
+  def on_optarg(node) = check(node, node.name)
+
+  def on_kwarg(node) = check(node, node.name)
+
+  def on_kwoptarg(node) = check(node, node.name)
+
+  private
+
+  def check(node, name)
+    stem = name.to_s.sub(SIGIL, "").delete_prefix("_")
+    return if allowed?(name.to_s) || allowed?(stem) || stem.empty?
+    return if good?(stem)
+    add_offense(node.loc.name, message: format(MSG, name, name))
+  end
+
+  def good?(stem)
+    words = stem.split("_")
+    return false unless words.all? { pattern.match?(it) }
+    core = core(words)
+    return words.size == 1 if core.size == words.size
+    core.size.between?(1, max)
+  end
+
+  def core(words)
+    rest = prefix?(words.first) && words.size > 1 ? words.drop(1) : words
+    suffix?(rest.last) && rest.size > 1 ? rest[0..-2] : rest
+  end
+
+  def prefix?(word) = list("Prefixes").include?(word)
+
+  def suffix?(word) = list("Suffixes").include?(word)
+
+  def allowed?(name) = list("AllowedNames").include?(name) || list("Terms").include?(name)
+
+  def list(key) = Array(cop_config[key]).map(&:to_s)
+
+  def max = Integer(cop_config.fetch("MaxWords", 2))
+
+  def pattern = Regexp.new(cop_config.fetch("Pattern", "^[a-z][a-z0-9]{0,15}$"))
+end

data/lib/rubocop/cop/kata/real_words.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class RuboCop::Cop::Kata::RealWords < RuboCop::Cop::Base
+  MSG = "%s is not in the dictionary — restore the underscore between smashed words, spell the " \
+    "abbreviation out, or add it to `Terms` if it is one domain term here."
+  ABBREVIATION_MSG = "%s is an abbreviation; spell the word out."
+  SIGIL = /\A(@@|@|\$)/
+  DERIVATIONS = [
+    [/s\z/, ""], [/es\z/, ""], [/ies\z/, "y"],
+    [/able\z/, ""], [/able\z/, "e"], [/([b-df-hj-np-tv-z])\1able\z/, '\1'],
+    [/er\z/, ""], [/[eo]r\z/, "e"], [/ier\z/, "y"],
+    [/([b-df-hj-np-tv-z])\1er\z/, '\1'], [/or\z/, ""], [/less\z/, ""]
+  ].freeze
+
+  def on_def(node) = check(node, node.method_name)
+
+  def on_defs(node) = check(node, node.method_name)
+
+  def on_lvasgn(node) = check(node, node.name)
+
+  def on_ivasgn(node) = check(node, node.name)
+
+  def on_cvasgn(node) = check(node, node.name)
+
+  def on_gvasgn(node) = check(node, node.name)
+
+  def on_arg(node) = check(node, node.name)
+
+  def on_optarg(node) = check(node, node.name)
+
+  def on_kwarg(node) = check(node, node.name)
+
+  def on_kwoptarg(node) = check(node, node.name)
+
+  private
+
+  def check(node, name)
+    stem = name.to_s.sub(SIGIL, "").delete_prefix("_").sub(/[?!=]\z/, "")
+    segment = flaw(name.to_s, stem)
+    return unless segment
+    add_offense(node.loc.name, message: message(name, stem, segment))
+  end
+
+  def flaw(name, stem)
+    return if allowed?(name) || allowed?(stem) || !stem.match?(/\A[a-z]/)
+    stem.split("_").find { !word?(it) }
+  end
+
+  def message(name, stem, segment)
+    format(banned?(segment) ? ABBREVIATION_MSG : MSG, label(name, stem, segment))
+  end
+
+  def label(name, stem, segment) = stem == segment ? "`#{name}`" : "`#{segment}` (in `#{name}`)"
+
+  def word?(segment) = segment.length < 2 || term?(segment) || (known?(segment) && !banned?(segment))
+
+  def known?(segment) = forms(segment).any? { RuboCop::Kata::Dictionary::ENTRIES.include?(it) }
+
+  def forms(segment)
+    base = segment.sub(/\d+\z/, "")
+    [base, base.delete_prefix("un"), base.delete_prefix("re"), base.delete_prefix("non"), base.delete_prefix("sub")]
+      .flat_map { [it, *derivations(it)] }
+  end
+
+  def derivations(base) = DERIVATIONS.map { |pattern, stem| base.sub(pattern, stem) }
+
+  def term?(segment) = list("Terms").include?(segment)
+
+  def banned?(segment) = list("BannedWords").include?(segment)
+
+  def allowed?(name) = list("AllowedNames").include?(name)
+
+  def list(key) = Array(cop_config[key]).map(&:to_s)
+end

data/lib/rubocop/kata/checkup.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+class RuboCop::Kata::Checkup
+  INERT = "%s:%d: `%s` is disabled by the configuration this project inherits; the entry does nothing."
+  DEAD = "%s:%d: the directive names `%s`, which is not enabled here; the comment does nothing."
+  TALLY = "%d dead entr%s"
+  KEY = %r{\A([A-Z]\w*/\w+):}
+
+  def initialize(root, io: $stdout)
+    @root = root
+    @io = io
+  end
+
+  def run
+    found = inert + dead
+    found.each { @io.puts(it) }
+    @io.puts(found.empty? ? "clean" : tally(found))
+    found.empty? ? 0 : 1
+  end
+
+  private
+
+  def tally(found) = format(TALLY, found.length, found.one? ? "y" : "ies")
+
+  def inert
+    entries.filter_map { |key, line| format(INERT, file, line, key) unless live?(key) }
+  end
+
+  def entries
+    lines.each_with_index.filter_map { |text, index| [text[KEY, 1], index + 1] if text.match?(KEY) }
+  end
+
+  def lines = File.file?(file) ? File.readlines(file) : []
+
+  def file = File.join(@root, ".rubocop.yml")
+
+  def live?(key) = config.cop_enabled?(key) || off?(key)
+
+  def off?(key) = project.dig(key, "Enabled") == false
+
+  def project = @_project ||= (YAML.safe_load_file(file, aliases: true) if File.file?(file)) || {}
+
+  def dead = targets.flat_map { directives(it) }
+
+  def targets = RuboCop::TargetFinder.new(store).find([@root], :only_recognized_file_types)
+
+  def directives(path)
+    RuboCop::ProcessedSource.from_file(path, config.target_ruby_version).comments
+      .map { RuboCop::DirectiveComment.new(it) }
+      .filter_map { finding(path, it) }
+  rescue StandardError
+    []
+  end
+
+  def finding(path, directive)
+    return unless directive.start_with_marker? && !directive.all_cops?
+    stale = directive.cop_names.reject { active?(it, path) }
+    return if stale.empty?
+    format(DEAD, path, directive.line_number, stale.join("`, `"))
+  end
+
+  def active?(name, path)
+    configuration = store.for_file(path)
+    cop = RuboCop::Cop::Registry.global.find_by_cop_name(name)
+    configuration.cop_enabled?(name) && cop&.new(configuration)&.relevant_file?(path)
+  end
+
+  def config = @_config ||= store.for_dir(@root)
+
+  def store = @_store ||= RuboCop::ConfigStore.new
+end

data/lib/rubocop/kata/dictionary.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module RuboCop::Kata::Dictionary
+  WORDS = File.expand_path("../../../data/words.txt.gz", __dir__)
+  SOFTWARE = File.expand_path("../../../data/software.txt.gz", __dir__)
+  EXTRA = File.expand_path("../../../data/supplement.txt", __dir__)
+  ENTRIES = Set.new(
+    [WORDS, SOFTWARE].flat_map { Zlib.gunzip(File.binread(it)).split("\n") } +
+      File.readlines(EXTRA, chomp: true)
+  ).freeze
+end

data/lib/rubocop/kata/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Kata
-    VERSION = "0.4.0"
+    VERSION = "0.7.0"
   end
 end

data/lib/rubocop-kata.rb

@@ -17,14 +17,16 @@ require_relative "rubocop/cop/kata/builder_noun"
 require_relative "rubocop/cop/kata/clock_discipline"
 require_relative "rubocop/cop/kata/constructor_discipline"
 require_relative "rubocop/cop/kata/env_discipline"
+require_relative "rubocop/cop/kata/good_method_name"
+require_relative "rubocop/cop/kata/good_variable_name"
 require_relative "rubocop/cop/kata/io_discipline"
-require_relative "rubocop/cop/kata/no_abbreviation"
 require_relative "rubocop/cop/kata/no_boolean_flag"
 require_relative "rubocop/cop/kata/no_class_method_logic"
 require_relative "rubocop/cop/kata/no_comments"
 require_relative "rubocop/cop/kata/no_hash_as_object"
-require_relative "rubocop/cop/kata/no_nil_return"
 require_relative "rubocop/cop/kata/no_util_name"
 require_relative "rubocop/cop/kata/prose_placement"
+require_relative "rubocop/cop/kata/real_words"
+require_relative "rubocop/kata/dictionary"
 require_relative "rubocop/kata/plugin"
 require_relative "rubocop/kata/version"

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-kata
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Giacomo GK
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -107,12 +107,16 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
-description: 'Bundles a curated RuboCop stack (rspec, performance, elegant, packaging,
+description: Bundles a curated RuboCop stack (rspec, performance, elegant, packaging,
   thread_safety) behind one dependency, layers opinionated style defaults on top,
-  and adds four cops of its own: AgentNoun, NoComments, IoDiscipline, and ProsePlacement.'
+  and adds fifteen cops of its own — naming (GoodMethodName, GoodVariableName, dictionary-backed
+  RealWords, AgentNoun, BuilderNoun, NoUtilName), discipline (IoDiscipline, ClockDiscipline,
+  EnvDiscipline, ConstructorDiscipline, NoClassMethodLogic), and shape (NoComments,
+  NoBooleanFlag, NoHashAsObject, ProsePlacement).
 email:
 - giaco@hey.com
-executables: []
+executables:
+- rubocop-kata
 extensions: []
 extra_rdoc_files: []
 files:
@@ -120,21 +124,30 @@ files:
 - LICENSE.txt
 - README.md
 - config/default.yml
+- data/CSPELL-LICENSE
+- data/SCOWL-COPYRIGHT
+- data/software.txt.gz
+- data/supplement.txt
+- data/words.txt.gz
+- exe/rubocop-kata
 - lib/rubocop-kata.rb
 - lib/rubocop/cop/kata/agent_noun.rb
 - lib/rubocop/cop/kata/builder_noun.rb
 - lib/rubocop/cop/kata/clock_discipline.rb
 - lib/rubocop/cop/kata/constructor_discipline.rb
 - lib/rubocop/cop/kata/env_discipline.rb
+- lib/rubocop/cop/kata/good_method_name.rb
+- lib/rubocop/cop/kata/good_variable_name.rb
 - lib/rubocop/cop/kata/io_discipline.rb
-- lib/rubocop/cop/kata/no_abbreviation.rb
 - lib/rubocop/cop/kata/no_boolean_flag.rb
 - lib/rubocop/cop/kata/no_class_method_logic.rb
 - lib/rubocop/cop/kata/no_comments.rb
 - lib/rubocop/cop/kata/no_hash_as_object.rb
-- lib/rubocop/cop/kata/no_nil_return.rb
 - lib/rubocop/cop/kata/no_util_name.rb
 - lib/rubocop/cop/kata/prose_placement.rb
+- lib/rubocop/cop/kata/real_words.rb
+- lib/rubocop/kata/checkup.rb
+- lib/rubocop/kata/dictionary.rb
 - lib/rubocop/kata/plugin.rb
 - lib/rubocop/kata/version.rb
 homepage: https://github.com/giacope/rubocop-kata
@@ -163,5 +176,5 @@ requirements: []
 rubygems_version: 4.0.17
 specification_version: 4
 summary: 'Practiced forms for Ruby: a RuboCop plugin with opinionated defaults and
-  four house cops'
+  fifteen house cops'
 test_files: []

data/lib/rubocop/cop/kata/no_abbreviation.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-class RuboCop::Cop::Kata::NoAbbreviation < RuboCop::Cop::Base
-  MSG = "`%s` is an abbreviation; spell the word out."
-
-  def on_lvasgn(node) = check(node)
-
-  def on_arg(node) = check(node)
-
-  def on_optarg(node) = check(node)
-
-  def on_kwarg(node) = check(node)
-
-  def on_kwoptarg(node) = check(node)
-
-  private
-
-  def check(node)
-    name = node.name.to_s
-    return unless banned?(name)
-    add_offense(node.loc.name, message: format(MSG, name))
-  end
-
-  def banned?(name) = Array(cop_config["BannedNames"]).map(&:to_s).include?(name.sub(/\d+\z/, ""))
-end

data/lib/rubocop/cop/kata/no_nil_return.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-class RuboCop::Cop::Kata::NoNilReturn < RuboCop::Cop::Base
-  MSG = "Returning nil hands the caller a bomb; raise or return a real object."
-
-  def on_return(node)
-    add_offense(node, message: MSG) if node.children.first&.nil_type?
-  end
-
-  def on_def(node)
-    last = tail(node.body)
-    add_offense(last, message: MSG) if last&.nil_type?
-  end
-  alias on_defs on_def
-
-  private
-
-  def tail(body) = body&.begin_type? ? body.children.last : body
-end