rubocop-kata 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c1ecc1a90d7d43dba2861011f7f9c8c1ecc97e71040908f1018df3199aca660
-  data.tar.gz: 216cb124bc0565ab89d5cf3ee52225e24771d6f4d0812e8a272b0fc14517e45e
+  metadata.gz: 0d5931b8e8bdf39595150f5f4c4785fd1e7c267c4abfda47d02999913aa4bdd2
+  data.tar.gz: 56fdf88f035c7833469f0a290351696b2a1197f1f5cee2282ad60928201b3323
 SHA512:
-  metadata.gz: 5a806b0b657d6fa01fe422361616304f6581e23e041f76a70d3dc33f61814a600a808439282417de3f8ea34d03612927fdfcbced3f18010b90660407ffa165f7
-  data.tar.gz: 687dd4b67fb477cd51e4440e79f7d81a020f4712c1802541447eb489f97be8fab728cb26460c947113a2789f1fddf1f0e93ecd9bad70d2eadd232cbe025bf74d
+  metadata.gz: 122b3da618e42d4137b1c4986bd21ba63374e275168d84181afa87cfae319465fe07270d12d54c3cece22ac6b73585a137d7ac5780f22f5a9c4fb0f667a40a07
+  data.tar.gz: b9bfb1dc0d5be32ea85898cfae3fbe3ce3338578f2e57b1e7b9effd2e00b2847c50bedcb5f9d259292de8141fe3579e11b0bb925a9840534047f26577f5dff26

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.10.0] - 2026-08-30
+
+- `Elegant/NoRedundantVariable`, `Elegant/PairedBrackets`, and
+  `Elegant/ClassInModule` now ship here, fixed, as `Kata/*` cops derived from
+  rubocop-elegant under MIT (`LICENSE.txt`); the originals are
+  off. The git-source Gemfile line is no longer needed: the correctors run
+  out of the box, and `ClassInModule` clears.
+
 ## [0.9.0] - 2026-08-27
 
 - The shared rule behind the naming cops is now explicit: compound syntax is

data/LICENSE.txt

@@ -19,3 +19,29 @@ 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.
+
+---
+
+Portions of this software are derived from rubocop-elegant
+(https://github.com/yegor256/rubocop-elegant), used under the same MIT
+License, whose notice is reproduced here as it requires:
+
+Copyright (c) 2019-2026 Yegor Bugayenko
+
+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

@@ -1,6 +1,6 @@
 # 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 fifteen 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 eighteen 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
@@ -14,7 +14,7 @@ that dodge with a shipped dictionary instead of a word list you maintain:
 
 - **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).
-- **Fifteen house cops.** Naming, dependency discipline, and data honesty in the Elegant Objects spirit — from `Kata/GoodClassName` to `Kata/ClockDiscipline`.
+- **Eighteen house cops.** Naming, dependency discipline, and data honesty in the Elegant Objects spirit — from `Kata/GoodClassName` to `Kata/ClockDiscipline`.
 
 ```ruby
 class PaymentProcessor  # Kata/GoodClassName: `PaymentProcessor` names a doer; name the class
@@ -65,38 +65,16 @@ reports a class nested in a class as global
 test-file exclusions never match a Rails or RSpec suite
 ([#77](https://github.com/yegor256/rubocop-elegant/issues/77)).
 
-The defaults here neutralise all four. `Elegant/ClassInModule` is off, because
-its offences cannot be cleared: the cop it ships beside forbids the module it
-asks for. The two broken correctors are set to report only, because their
-offences can be cleared, by hand. The exclusions are widened. Nothing corrupts
-your code out of the box, and nothing reports a defect you cannot fix.
+Until upstream releases the fixes, the three cops ship here, fixed, as
+`Kata/NoRedundantVariable`, `Kata/PairedBrackets`, and `Kata/ClassInModule`;
+the `Elegant/*` originals are off so each offence is reported once. They are
+derived from rubocop-elegant under its MIT licence, and the notice travels
+with the gem as `LICENSE.txt`. The exclusions are widened.
+Once upstream ships, the copies go and the originals come back on.
 
-A gemspec cannot name a git source, so to take the fixes themselves rather than
-the workarounds, add this to your own `Gemfile`:
-
-```ruby
-gem "rubocop-elegant", github: "giacope/rubocop-elegant", branch: "fixes"
-```
-
-That branch is the released gem plus the five pull requests, with the version
-pinned so Bundler resolves it. With it in place you can turn the two correctors
-back on:
-
-```yaml
-Elegant/NoRedundantVariable:
-  AutoCorrect: true
-
-Elegant/PairedBrackets:
-  AutoCorrect: true
-
-Elegant/ClassInModule:
-  Enabled: true
-```
-
-Drop all three once upstream releases the fixes. On a Rails codebase, consider
-leaving `Elegant/ClassInModule` off for good: it wants every class inside a
-module, and Zeitwerk resolves `class Account` from `app/models/account.rb` as a
-top-level constant by design.
+On a Rails codebase, consider turning `Kata/ClassInModule` off: it wants
+every class inside a module, and Zeitwerk resolves `class Account` from
+`app/models/account.rb` as a top-level constant by design.
 
 ## The cops
 
@@ -104,6 +82,9 @@ top-level constant by design.
 | --- | --- | --- |
 | `Kata/GoodClassName` | on | A class names one object that exists in the model: no `-er`/`-or` doers (suggests the better name when it can derive one), no junk drawers (`Service`, `Util`, `Data`), no packing several concepts into one name (`CustomerOrderPayment`). Compound syntax is not the smell — `CreditCard` is one concept, and `Terms` holds those. `AllowedNames` and `BannedNames` match a whole name or a trailing segment, so `Error` covers `UsageError` and `Service` catches `InvoiceService`. |
 | `Kata/GoodModuleName` | on | A module names a domain vocabulary (`Billing`, `AccessControl`), not an implementation category: no layer buckets (`Services`, `Helpers`, `Logic`), no vague shared namespaces (`Common`, `Shared`, `Core`), no doers. Tune via `BannedNames`/`Terms`/`AllowedNames`. |
+| `Kata/NoRedundantVariable` | on | A local assigned once and read once is inlined at its read, unless the move would cross a loop, a branch, or a side effect. Autocorrects, and keeps Ruby 3.1 shorthand intact. Fixed copy of `Elegant/NoRedundantVariable`. |
+| `Kata/PairedBrackets` | on | Every bracket pairs on its line, or opens at line end and closes at line start. Autocorrects without drifting the indent. Fixed copy of `Elegant/PairedBrackets`. |
+| `Kata/ClassInModule` | on | A class lives in a module, a class, or a compact namespace, never at the top level. Fixed copy of `Elegant/ClassInModule`. |
 | `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 the test suite and the boot layer; 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. |

data/config/default.yml

@@ -778,17 +778,35 @@ Layout/EmptyLinesAfterModuleInclusion:
 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.
+# --- Three Elegant cops ship here as Kata/*, fixed (see README); the
+# originals are off so an offence is reported once.
 Elegant/NoRedundantVariable:
-  AutoCorrect: false
+  Enabled: false
 
-# Inserts a newline beside a bracket without taking the whitespace already
-# there, so every corrected line drifts right and MonotonicIndents then
-# reports the line it just wrote.
 Elegant/PairedBrackets:
-  AutoCorrect: false
+  Enabled: false
+
+Elegant/ClassInModule:
+  Enabled: false
+
+Kata/NoRedundantVariable:
+  Description: "A local assigned once and read once is inlined at its read."
+  Enabled: true
+  VersionAdded: "0.10"
+
+Kata/PairedBrackets:
+  Description: "A bracket pairs on its line, or opens at the end of one and closes at the start of another."
+  Enabled: true
+  VersionAdded: "0.10"
+
+Kata/ClassInModule:
+  Description: "A class lives in a module, a class, or a compact namespace, never at the top level."
+  Enabled: true
+  VersionAdded: "0.10"
+  Exclude:
+    - "**/*_test.rb"
+    - "test/**/*"
+    - "spec/**/*"
 
 # Rewrites reopened classes into modules, clashing with the primary
 # class definition at boot.
@@ -811,20 +829,6 @@ ThreadSafety/DirChdir:
 
 # --- Elegant's test-file exclusions never match Rails' `foo_test.rb`, nor a
 # suite addressed by directory.
-# Off until upstream ships: it reports a class nested in a class as global, and
-# Elegant/NoClassInModule forbids the module the message asks for, so the pair
-# admits no shape. It also reads a top-level constant as a defect, which is how
-# Rails resolves one. https://github.com/yegor256/rubocop-elegant/issues/75
-Elegant/ClassInModule:
-  Enabled: false
-  inherit_mode:
-    merge:
-      - Exclude
-  Exclude:
-    - "**/*_test.rb"
-    - "test/**/*"
-    - "spec/**/*"
-
 Elegant/NoClassInModule:
   inherit_mode:
     merge:

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+# Derived from rubocop-elegant (https://github.com/yegor256/rubocop-elegant), see LICENSE.txt
+
+class RuboCop::Cop::Kata::ClassInModule < RuboCop::Cop::Base
+  MSG = "Class %s must be defined inside a module, not globally"
+  public_constant :MSG
+
+  def on_class(node)
+    return if namespaced?(node)
+    return if scoped?(node)
+    add_offense(node, message: format(MSG, name: label(node)))
+  end
+
+  private
+
+  def namespaced?(node)
+    scope = outer(node)
+    !scope.nil? && scope.type != :cbase
+  end
+
+  def scoped?(node)
+    return false unless outer(node).nil?
+    node.each_ancestor(:module, :class).any?
+  end
+
+  def outer(node)
+    node.children[0].children[0]
+  end
+
+  def label(node)
+    node.children[0].source
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+# Derived from rubocop-elegant (https://github.com/yegor256/rubocop-elegant), see LICENSE.txt
+
+class RuboCop::Cop::Kata::NoRedundantVariable < RuboCop::Cop::Base
+  extend RuboCop::Cop::AutoCorrector
+  include RuboCop::Cop::RangeHelp
+
+  MSG = 'Variable "%s" is redundant and must be inlined: it is read only once'
+
+  def on_def(node) = check(node.body)
+
+  def on_defs(node) = check(node.body)
+
+  private
+
+  def check(body)
+    return if body.nil?
+    singles = RuboCop::Kata::Variable::Ledger.new(body).pairs
+    movable = singles.select { |assign, _| solo?(assign) && !swallows?(assign, singles) }
+    gap = RuboCop::Kata::Variable::Gap.new(movable)
+    singles.each { |assign, read| register(assign, read, movable) unless gap.crossed?(assign, read) }
+  end
+
+  def register(assign, read, movable)
+    return inline(assign, read) if movable.key?(assign)
+    add_offense(assign, message: format(MSG, assign.children.first))
+  end
+
+  def inline(assign, read)
+    inlining = RuboCop::Kata::Variable::Inlining.new(assign.children.last, read)
+    add_offense(assign, message: format(MSG, assign.children.first)) do |corrector|
+      corrector.replace(inlining.range, inlining.text)
+      corrector.remove(range_by_whole_lines(assign.source_range, include_final_newline: true))
+    end
+  end
+
+  def swallows?(assign, singles)
+    range = assign.source_range
+    singles.any? do |_, read|
+      read.source_range.begin_pos > range.begin_pos && read.source_range.end_pos <= range.end_pos
+    end
+  end
+
+  def solo?(assign)
+    range = assign.source_range
+    return false unless range.first_line == range.last_line
+    range.source_buffer.source_line(range.first_line).strip == range.source.strip
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+# Derived from rubocop-elegant (https://github.com/yegor256/rubocop-elegant), see LICENSE.txt
+
+class RuboCop::Cop::Kata::PairedBrackets < RuboCop::Cop::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  MSG = "Bracket %s must be paired on the same line, or start/end its line"
+
+  OPENERS = %i[tLPAREN tLPAREN2 tLPAREN_ARG tLBRACK tLBRACK2 tLCURLY tLBRACE tLBRACE_ARG].freeze
+  CLOSERS = %i[tRPAREN tRBRACK tRCURLY].freeze
+  BLANKS = [" ", "\t"].freeze
+
+  def on_new_investigation
+    super
+    pairs.each { |opener, closer| check(opener, closer) }
+  end
+
+  private
+
+  def pairs
+    stack = []
+    processed_source.tokens.each_with_object([]) do |token, found|
+      stack << token if OPENERS.include?(token.type)
+      found << [stack.pop, token] if CLOSERS.include?(token.type) && !stack.empty?
+    end
+  end
+
+  def check(opener, closer)
+    return if opener.line == closer.line
+    indent = leading(opener)
+    after(opener, indent) unless ends?(opener)
+    before(closer, indent) unless starts?(closer)
+  end
+
+  def after(token, indent)
+    register(token) { it.replace(trailing(token), "\n#{indent}  ") }
+  end
+
+  def before(token, indent)
+    register(token) { it.replace(preceding(token), "\n#{indent}") }
+  end
+
+  def trailing(token)
+    text = processed_source.buffer.source
+    stop = token.pos.end_pos
+    stop += 1 while BLANKS.include?(text[stop])
+    token.pos.end.resize(stop - token.pos.end_pos)
+  end
+
+  def preceding(token)
+    text = processed_source.buffer.source
+    from = token.pos.begin_pos
+    from -= 1 while from.positive? && BLANKS.include?(text[from - 1])
+    token.pos.begin.adjust(begin_pos: from - token.pos.begin_pos)
+  end
+
+  def starts?(token) = processed_source.lines[token.line - 1][0...token.column].strip.empty?
+
+  def ends?(token)
+    after = processed_source.lines[token.line - 1][(token.column + token.text.length)..].to_s.strip
+    after.empty? || after.start_with?("#")
+  end
+
+  def leading(token) = processed_source.lines[token.line - 1][/\A[ \t]*/]
+
+  def register(token, &) = add_offense(token.pos, message: format(MSG, token.text), &)
+end

data/lib/rubocop/kata/plugin.rb

@@ -6,7 +6,7 @@ class RuboCop::Kata::Plugin < LintRoller::Plugin
   def about
     LintRoller::About.new(
       name: "rubocop-kata", version: RuboCop::Kata::VERSION, homepage: "https://github.com/giacope/rubocop-kata",
-      description: "Practiced forms for Ruby: opinionated defaults and fourteen house cops."
+      description: "Practiced forms for Ruby: opinionated defaults and eighteen house cops."
     )
   end
 

data/lib/rubocop/kata/variable/boundary.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+# Derived from rubocop-elegant (https://github.com/yegor256/rubocop-elegant), see LICENSE.txt
+
+class RuboCop::Kata::Variable::Boundary
+  LOOPS = %i[block numblock while until while_post until_post for].freeze
+  FIRSTS = %i[if case case_match and or].freeze
+  HOISTS = %i[rescue resbody ensure].freeze
+
+  def initialize(assign, read)
+    @assign = assign
+    @read = read
+  end
+
+  def crossed?
+    return true unless @read.each_ancestor.any? { it.equal?(@assign.parent) }
+    steps.any? { |child, parent| blocks?(child, parent) }
+  end
+
+  private
+
+  def steps
+    lineage = @read.each_ancestor.take_while { !it.equal?(@assign.parent) }
+    [@read, *lineage].each_cons(2)
+  end
+
+  def blocks?(child, parent)
+    return true if LOOPS.include?(parent.type) || HOISTS.include?(parent.type)
+    FIRSTS.include?(parent.type) && !parent.children.first.equal?(child)
+  end
+end

data/lib/rubocop/kata/variable/gap.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+# Derived from rubocop-elegant (https://github.com/yegor256/rubocop-elegant), see LICENSE.txt
+
+class RuboCop::Kata::Variable::Gap
+  PURE = %i[
+    int float rational complex str sym true false nil array hash regexp regopt
+    irange erange lvar self pair begin
+  ].freeze
+
+  def initialize(movable)
+    @movable = movable
+    @memo = {}
+  end
+
+  def crossed?(assign, read)
+    @memo[assign] = scan?(assign, read) unless @memo.key?(assign)
+    @memo[assign]
+  end
+
+  private
+
+  def scan?(assign, read)
+    steps(assign, read).any? do |child, parent|
+      before(parent, child, assign).any? { !deferred?(it, read) }
+    end
+  end
+
+  def steps(assign, read)
+    lineage = read.each_ancestor.to_a
+    [read, *lineage[..(lineage.index { it.equal?(assign.parent) })]].each_cons(2)
+  end
+
+  def before(parent, child, assign)
+    kids = parent.children
+    stop = kids.index { it.equal?(child) }
+    return [] if stop.nil?
+    kids[(parent.equal?(assign.parent) ? kids.index { it.equal?(assign) } + 1 : 0)...stop]
+  end
+
+  def deferred?(node, read)
+    return true if pure?(node)
+    twin = @movable[node]
+    !twin.nil? && twin.source_range.begin_pos >= read.source_range.begin_pos && !crossed?(node, twin)
+  end
+
+  def pure?(node)
+    return true unless node.is_a?(RuboCop::AST::Node)
+    PURE.include?(node.type) && node.each_child_node.all? { pure?(it) }
+  end
+end

data/lib/rubocop/kata/variable/inlining.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+# Derived from rubocop-elegant (https://github.com/yegor256/rubocop-elegant), see LICENSE.txt
+
+class RuboCop::Kata::Variable::Inlining
+  PRIMARY = %i[
+    int float str sym dstr dsym xstr true false nil array hash regexp
+    lvar ivar cvar gvar const self nth_ref back_ref
+  ].freeze
+
+  def initialize(rhs, read)
+    @rhs = rhs
+    @read = read
+  end
+
+  def range = pair.nil? ? @read.source_range : pair.source_range
+
+  def text = pair.nil? ? value : "#{pair.children.first.source}: #{value}"
+
+  private
+
+  def pair
+    parent = @read.parent
+    return if parent.nil? || !parent.pair_type?
+    key, value = parent.children
+    parent if value.equal?(@read) && key.source_range == value.source_range
+  end
+
+  def value = wrap? ? "(#{braced})" : braced
+
+  def braced = @rhs.hash_type? && @rhs.loc.begin.nil? ? "{ #{@rhs.source} }" : @rhs.source
+
+  def wrap? = !primary? || (@rhs.hash_type? && bare?)
+
+  def primary?
+    return true if PRIMARY.include?(@rhs.type)
+    return !@rhs.loc.begin.nil? || @rhs.arguments.empty? if @rhs.send_type? || @rhs.csend_type?
+    @rhs.begin_type? && @rhs.children.size == 1
+  end
+
+  def bare?
+    parent = @read.parent
+    return false if parent.nil? || !(parent.send_type? || parent.csend_type?)
+    parent.loc.begin.nil? && parent.arguments.include?(@read)
+  end
+end

data/lib/rubocop/kata/variable/ledger.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+# Derived from rubocop-elegant (https://github.com/yegor256/rubocop-elegant), see LICENSE.txt
+
+class RuboCop::Kata::Variable::Ledger
+  STATEMENT_PARENTS = %i[begin kwbegin def defs block numblock].freeze
+
+  def initialize(body)
+    @body = body
+  end
+
+  def pairs
+    singles.reject { |assign, read| RuboCop::Kata::Variable::Boundary.new(assign, read).crossed? }.to_h
+  end
+
+  private
+
+  def singles
+    reads = self.reads
+    tainted = self.tainted
+    assigns.filter_map { |name, found| single(found, reads.fetch(name, [])) unless tainted.include?(name) }
+  end
+
+  def single(found, once) = ([found.first, once.first] if found.size == 1 && once.size == 1)
+
+  def assigns = nodes.select { it.lvasgn_type? && statement?(it) }.group_by { it.children.first }
+
+  def reads = nodes.select(&:lvar_type?).group_by { it.children.first }
+
+  def tainted
+    nodes.select { it.op_asgn_type? || it.or_asgn_type? || it.and_asgn_type? }.map { it.children.first }
+      .select { it.is_a?(RuboCop::AST::Node) && it.lvasgn_type? }.map { it.children.first }
+  end
+
+  def nodes(node = @body, found = [])
+    return found unless node.is_a?(RuboCop::AST::Node) && !node.def_type? && !node.defs_type?
+    found << node
+    node.each_child_node { nodes(it, found) }
+    found
+  end
+
+  def statement?(node)
+    return false unless node.children.size == 2
+    parent = node.parent
+    parent = parent.parent while !parent.nil? && parent.type == :begin && parent.children.size == 1
+    !parent.nil? && STATEMENT_PARENTS.include?(parent.type)
+  end
+end

data/lib/rubocop/kata/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Kata
-    VERSION = "0.9.0"
+    VERSION = "0.10.0"
   end
 end

data/lib/rubocop-kata.rb

@@ -4,6 +4,8 @@ require "rubocop"
 
 module RuboCop
   module Kata
+    module Variable
+    end
   end
 
   module Cop
@@ -13,6 +15,7 @@ module RuboCop
 end
 
 require_relative "rubocop/cop/kata/builder_noun"
+require_relative "rubocop/cop/kata/class_in_module"
 require_relative "rubocop/cop/kata/clock_discipline"
 require_relative "rubocop/cop/kata/constructor_discipline"
 require_relative "rubocop/cop/kata/env_discipline"
@@ -24,10 +27,16 @@ require_relative "rubocop/cop/kata/good_variable_name"
 require_relative "rubocop/cop/kata/io_discipline"
 require_relative "rubocop/cop/kata/no_boolean_flag"
 require_relative "rubocop/cop/kata/no_class_method_logic"
+require_relative "rubocop/cop/kata/no_redundant_variable"
 require_relative "rubocop/cop/kata/no_comments"
 require_relative "rubocop/cop/kata/no_hash_as_object"
+require_relative "rubocop/cop/kata/paired_brackets"
 require_relative "rubocop/cop/kata/prose_placement"
 require_relative "rubocop/cop/kata/real_words"
 require_relative "rubocop/kata/dictionary"
+require_relative "rubocop/kata/variable/boundary"
+require_relative "rubocop/kata/variable/gap"
+require_relative "rubocop/kata/variable/inlining"
+require_relative "rubocop/kata/variable/ledger"
 require_relative "rubocop/kata/plugin"
 require_relative "rubocop/kata/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-kata
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Giacomo GK
@@ -109,7 +109,7 @@ dependencies:
         version: '0.7'
 description: Bundles a curated RuboCop stack (rspec, performance, elegant, packaging,
   thread_safety) behind one dependency, layers opinionated style defaults on top,
-  and adds fifteen cops of its own — naming (GoodMethodName, GoodVariableName, dictionary-backed
+  and adds eighteen cops of its own — naming (GoodMethodName, GoodVariableName, dictionary-backed
   RealWords, GoodClassName, GoodModuleName, BuilderNoun), discipline (IoDiscipline,
   ClockDiscipline, EnvDiscipline, ConstructorDiscipline, NoClassMethodLogic), and
   shape (NoComments, NoBooleanFlag, NoHashAsObject, ProsePlacement). The rubocop-kata
@@ -135,6 +135,7 @@ files:
 - lib/rubocop-kata.rb
 - lib/rubocop/cop/kata/agent_noun.rb
 - lib/rubocop/cop/kata/builder_noun.rb
+- lib/rubocop/cop/kata/class_in_module.rb
 - lib/rubocop/cop/kata/clock_discipline.rb
 - lib/rubocop/cop/kata/constructor_discipline.rb
 - lib/rubocop/cop/kata/env_discipline.rb
@@ -147,6 +148,8 @@ files:
 - 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_redundant_variable.rb
+- lib/rubocop/cop/kata/paired_brackets.rb
 - lib/rubocop/cop/kata/prose_placement.rb
 - lib/rubocop/cop/kata/real_words.rb
 - lib/rubocop/kata/checkup.rb
@@ -154,6 +157,10 @@ files:
 - lib/rubocop/kata/kit.rb
 - lib/rubocop/kata/plan.rb
 - lib/rubocop/kata/plugin.rb
+- lib/rubocop/kata/variable/boundary.rb
+- lib/rubocop/kata/variable/gap.rb
+- lib/rubocop/kata/variable/inlining.rb
+- lib/rubocop/kata/variable/ledger.rb
 - lib/rubocop/kata/version.rb
 - skills/rubocop-kata/SKILL.md
 homepage: https://github.com/giacope/rubocop-kata
@@ -182,5 +189,5 @@ requirements: []
 rubygems_version: 4.0.17
 specification_version: 4
 summary: 'Practiced forms for Ruby: a RuboCop plugin with opinionated defaults and
-  fifteen house cops'
+  eighteen house cops'
 test_files: []