rubocop-elegant 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d208aee894da49bf76dac6b393ecd907d137ce125f445903078f34def9435955
-  data.tar.gz: 2bb699562cc741372c3ab5f708a815cc2e046476d3a7646b267c72eb4c49ca98
+  metadata.gz: 0441b4d9f29a02a65680ffc46fb56985251723336a076999f7867ad7eb92185d
+  data.tar.gz: 92771eff5ed80253a14a85fd96ecaace40e7ce0476f2e26c6cb42372a26b9706
 SHA512:
-  metadata.gz: 2c74ed34a71c7fc3b89799f80dc97a77afecf8c2d3d1220b27454b829b27ffd452937a9779a0b17bb562308ef023e9a93ecda0fb6a87c6d10413ef78abf69ca5
-  data.tar.gz: 472da807a9a7530dcdf5cb5147115b060a379a149d05adf53762134b07314d51d70fe57b855fdf8355a1c0190855a8f1ce59b663a7073ca7f0765aa24f716450
+  metadata.gz: b1fd06eba3ce66013593a26400d81698fa3eeb01725890aa3ae5e0f78d086729b6b633f9d6a0551e61e2c1118ad844a12daba2ab97da5306ff13b8feb48a3d2b
+  data.tar.gz: 7595e8287a2f7f3904d643c98c1bafc412c2bfebcf4eb2de364ae13af4badf491985eba022f86cf93362efb997d0df57a171068a3ecc1ffb0b27d0c0cbf6e028

data/README.md

@@ -18,6 +18,19 @@ Default RuboCop configuration is too permissive, allowing coding practices
   cryptic variable names, and so on.
 This plugin configures existing RuboCop cops with stricter settings
   and adds custom cops for rules that RuboCop doesn't provide out of the box.
+The custom cops add the following restrictions:
+
+* Classes must live inside a module; top-level classes are forbidden.
+* A class nested in a module must use compact namespace syntax.
+* Method names must be single lowercase verbs.
+* Variable names must be single lowercase nouns.
+* Each indentation step must add exactly two spaces.
+* Comments are forbidden, except SPDX, magic, RuboCop directives, and class docblocks.
+* Empty lines inside block bodies are forbidden.
+* Empty lines inside method bodies are forbidden.
+* A method cannot return `nil` explicitly.
+* Local variables that are assigned once and read once must be inlined.
+* Brackets must be paired on the same line, or start/end their own line.
 
 First, install it:
 

data/config/default.yml

@@ -21,6 +21,10 @@ Elegant/NoNilReturn:
   Description: 'Forbids a method or function from returning nil on any code path'
   Enabled: true
   VersionAdded: '0.1.0'
+Elegant/NoRedundantVariable:
+  Description: 'Forbids local variables that are assigned once and read once; such variables must be inlined'
+  Enabled: true
+  VersionAdded: '0.3.0'
 Elegant/PairedBrackets:
   Description: 'Enforces the paired brackets notation: a bracket must pair on the same line, or start/end its line'
   Enabled: true

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

@@ -21,8 +21,7 @@ class RuboCop::Cop::Elegant::ClassInModule < RuboCop::Cop::Base
   private
 
   def namespaced?(node)
-    const = node.children[0]
-    scope = const.children[0]
+    scope = node.children[0].children[0]
     !scope.nil? && scope.type != :cbase
   end
 

data/lib/rubocop/cop/elegant/indentation_ladder.rb

@@ -44,7 +44,6 @@ class RuboCop::Cop::Elegant::IndentationLadder < RuboCop::Cop::Base
   end
 
   def register(num, step)
-    target = processed_source.buffer.line_range(num)
-    add_offense(target, message: format(MSG, step: step))
+    add_offense(processed_source.buffer.line_range(num), message: format(MSG, step: step))
   end
 end

data/lib/rubocop/cop/elegant/no_comments.rb

@@ -48,8 +48,7 @@ class RuboCop::Cop::Elegant::NoComments < RuboCop::Cop::Base
   end
 
   def docblock?(comment)
-    line = comment.location.line
-    successor = codeline(line)
+    successor = codeline(comment.location.line)
     successor.positive? && definition?(successor)
   end
 
@@ -88,15 +87,13 @@ class RuboCop::Cop::Elegant::NoComments < RuboCop::Cop::Base
   end
 
   def fullrange(target)
-    start = target.begin_pos - target.column
     ending = target.end_pos
     ending += 1 if newline?(ending)
-    target.with(begin_pos: start, end_pos: ending)
+    target.with(begin_pos: target.begin_pos - target.column, end_pos: ending)
   end
 
   def prefixed(target, prefix)
-    spaces = prefix.match(/\s*$/)[0]
-    target.with(begin_pos: target.begin_pos - spaces.length, end_pos: target.end_pos)
+    target.with(begin_pos: target.begin_pos - prefix.match(/\s*$/)[0].length, end_pos: target.end_pos)
   end
 
   def newline?(pos)

data/lib/rubocop/cop/elegant/no_empty_lines_in_blocks.rb

@@ -70,8 +70,7 @@ class RuboCop::Cop::Elegant::NoEmptyLinesInBlocks < RuboCop::Cop::Base
     result = []
     lines.each do |num|
       next if @gaps.include?(num)
-      line = processed_source.lines[num - 1]
-      result << num if line.strip.empty?
+      result << num if processed_source.lines[num - 1].strip.empty?
     end
     result
   end

data/lib/rubocop/cop/elegant/no_empty_lines_in_methods.rb

@@ -36,8 +36,7 @@ class RuboCop::Cop::Elegant::NoEmptyLinesInMethods < RuboCop::Cop::Base
   def empty(lines)
     result = []
     lines.each do |num|
-      line = processed_source.lines[num - 1]
-      result << num if line.strip.empty?
+      result << num if processed_source.lines[num - 1].strip.empty?
     end
     result
   end

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+# Forbids local variables that are assigned exactly once and then
+# referenced exactly once, since such variables can be inlined at
+# the place of their single use without loss of clarity. The cop
+# inspects each method body in isolation, ignores compound
+# assignments (+=, ||=, &&=), multiple assignments, +for+ loops,
+# rescue variables, and assignments embedded into expressions such
+# as +if+ or +while+ conditions; only top-level statements of a
+# sequence are considered. A variable whose single read sits inside
+# a context that does not also enclose the assignment is left alone:
+# loops or blocks (+block+, +numblock+, +while+, +until+, +for+) so
+# that inlining does not move the right-hand side into a hot path,
+# and conditional branches (+if+, +case+, +case_match+, +and+, +or+,
+# +rescue+, +resbody+, +ensure+) so that inlining does not change
+# whether or when the right-hand side is evaluated. A variable that
+# is reassigned, read more than once, or never read is left alone
+# too.
+#
+# Auto-correct inlines the redundant assignment: it replaces the
+# single +lvar+ read with the source of the assignment's right-hand
+# side, then removes the whole assignment line including its leading
+# indent and trailing newline. The right-hand side is wrapped in
+# parentheses unless it is already a primary expression (literal,
+# variable, parenthesized expression, or method call with parentheses
+# or no arguments), so that operator precedence at the read site is
+# preserved.
+class RuboCop::Cop::Elegant::NoRedundantVariable < RuboCop::Cop::Base
+  extend RuboCop::Cop::AutoCorrector
+  include RuboCop::Cop::RangeHelp
+
+  MSG = 'Variable "%<name>s" is redundant and must be inlined: it is read only once'
+  public_constant :MSG
+
+  STATEMENT_PARENTS = %i[begin kwbegin def defs block numblock].freeze
+  public_constant :STATEMENT_PARENTS
+
+  LOOP_TYPES = %i[block numblock while until while_post until_post for].freeze
+  public_constant :LOOP_TYPES
+
+  ALWAYS_FIRST_TYPES = %i[if case case_match and or].freeze
+  public_constant :ALWAYS_FIRST_TYPES
+
+  ALWAYS_HOIST_TYPES = %i[rescue resbody ensure].freeze
+  public_constant :ALWAYS_HOIST_TYPES
+
+  PRIMARY_TYPES = %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
+  public_constant :PRIMARY_TYPES
+
+  def on_def(node)
+    check(node.body)
+  end
+
+  def on_defs(node)
+    check(node.body)
+  end
+
+  private
+
+  def check(body)
+    return if body.nil?
+    assigns = Hash.new { |h, k| h[k] = [] }
+    reads = Hash.new { |h, k| h[k] = [] }
+    tainted = []
+    walk(body, assigns, reads, tainted)
+    assigns.each do |name, nodes|
+      next if tainted.include?(name)
+      next unless nodes.size == 1
+      next unless reads[name].size == 1
+      next if hoisted?(reads[name].first, nodes.first)
+      register(nodes.first, reads[name].first, name)
+    end
+  end
+
+  def register(assign, read, name)
+    return add_offense(assign, message: format(MSG, name: name)) unless solo?(assign)
+    add_offense(assign, message: format(MSG, name: name)) do |corrector|
+      corrector.replace(read.source_range, inlined(assign.children.last, read))
+      corrector.remove(range_by_whole_lines(assign.source_range, include_final_newline: true))
+    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
+
+  def inlined(rhs, read)
+    return "(#{braced(rhs)})" if wrap?(rhs, read)
+    braced(rhs)
+  end
+
+  def braced(rhs)
+    return "{ #{rhs.source} }" if rhs.hash_type? && rhs.loc.begin.nil?
+    rhs.source
+  end
+
+  def wrap?(rhs, read)
+    return true unless primary?(rhs)
+    rhs.hash_type? && bare?(read)
+  end
+
+  def primary?(node)
+    return true if PRIMARY_TYPES.include?(node.type)
+    return !node.loc.begin.nil? || node.arguments.empty? if node.send_type? || node.csend_type?
+    node.begin_type? && node.children.size == 1
+  end
+
+  def bare?(read)
+    parent = read.parent
+    return false if parent.nil?
+    return false unless parent.send_type? || parent.csend_type?
+    parent.loc.begin.nil? && parent.arguments.include?(read)
+  end
+
+  def walk(node, assigns, reads, tainted)
+    return unless node.is_a?(RuboCop::AST::Node)
+    return if node.def_type? || node.defs_type?
+    record(node, assigns, reads, tainted)
+    node.each_child_node { |child| walk(child, assigns, reads, tainted) }
+  end
+
+  def record(node, assigns, reads, tainted)
+    if node.op_asgn_type? || node.or_asgn_type? || node.and_asgn_type?
+      taint(node.children.first, tainted)
+    elsif node.lvasgn_type? && statement?(node)
+      assigns[node.children.first] << node
+    elsif node.lvar_type?
+      reads[node.children.first] << node
+    end
+  end
+
+  def taint(target, tainted)
+    return unless target.is_a?(RuboCop::AST::Node)
+    return unless target.lvasgn_type?
+    tainted << target.children.first
+  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
+    return false if parent.nil?
+    STATEMENT_PARENTS.include?(parent.type)
+  end
+
+  def hoisted?(read, assign)
+    boundary = assign.parent
+    return true if boundary.nil?
+    child = read
+    parent = read.parent
+    while !parent.nil? && !parent.equal?(boundary)
+      return true if LOOP_TYPES.include?(parent.type)
+      return true if ALWAYS_HOIST_TYPES.include?(parent.type)
+      return true if ALWAYS_FIRST_TYPES.include?(parent.type) && !parent.children.first.equal?(child)
+      child = parent
+      parent = parent.parent
+    end
+    parent.nil?
+  end
+end

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

@@ -9,8 +9,17 @@
 # closing). Brackets stranded in the middle of a multi-line expression
 # are forbidden because they hide the structure of the code.
 #
+# Auto-correct relocates the offending bracket onto its own line: an
+# opener that is not at end-of-line gets a newline and the opener-line
+# indent plus two spaces inserted right after it; a closer that is not
+# at start-of-line gets a newline and the opener-line indent inserted
+# right before it. Surrounding indentation may still need a follow-up
+# layout pass, but the brackets themselves end up paired.
+#
 # See https://www.yegor256.com/2014/10/23/paired-brackets-notation.html
 class RuboCop::Cop::Elegant::PairedBrackets < RuboCop::Cop::Base
+  extend RuboCop::Cop::AutoCorrector
+
   MSG = 'Bracket %<text>s must be paired on the same line, or start/end its line'
   public_constant :MSG
 
@@ -43,22 +52,25 @@ class RuboCop::Cop::Elegant::PairedBrackets < RuboCop::Cop::Base
   def check(duo)
     opener, closer = duo
     return if opener.line == closer.line
-    register(opener) unless ends?(opener)
-    register(closer) unless starts?(closer)
+    indent = leading(opener)
+    register(opener) { |corrector| corrector.insert_after(opener.pos, "\n#{indent}  ") } unless ends?(opener)
+    register(closer) { |corrector| corrector.insert_before(closer.pos, "\n#{indent}") } unless starts?(closer)
   end
 
   def starts?(tok)
-    line = processed_source.lines[tok.line - 1]
-    line[0...tok.column].strip.empty?
+    processed_source.lines[tok.line - 1][0...tok.column].strip.empty?
   end
 
   def ends?(tok)
-    line = processed_source.lines[tok.line - 1]
-    after = line[(tok.column + tok.text.length)..-1].to_s.strip
+    after = processed_source.lines[tok.line - 1][(tok.column + tok.text.length)..-1].to_s.strip
     after.empty? || after.start_with?('#')
   end
 
-  def register(tok)
-    add_offense(tok.pos, message: format(MSG, text: tok.text))
+  def leading(tok)
+    processed_source.lines[tok.line - 1][/\A[ \t]*/]
+  end
+
+  def register(tok, &block)
+    add_offense(tok.pos, message: format(MSG, text: tok.text), &block)
   end
 end

data/lib/rubocop/cop/elegant_cops.rb

@@ -14,4 +14,5 @@ require_relative 'elegant/no_comments'
 require_relative 'elegant/no_empty_lines_in_blocks'
 require_relative 'elegant/no_empty_lines_in_methods'
 require_relative 'elegant/no_nil_return'
+require_relative 'elegant/no_redundant_variable'
 require_relative 'elegant/paired_brackets'

data/rubocop-elegant.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to?(:required_rubygems_version=)
   s.required_ruby_version = '>=2.2'
   s.name = 'rubocop-elegant'
-  s.version = '0.2.0'
+  s.version = '0.4.0'
   s.license = 'MIT'
   s.summary = 'Set of custom RuboCop cops for elegant Ruby coding'
   s.description =

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-elegant
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Yegor Bugayenko
@@ -62,6 +62,7 @@ files:
 - lib/rubocop/cop/elegant/no_empty_lines_in_blocks.rb
 - lib/rubocop/cop/elegant/no_empty_lines_in_methods.rb
 - lib/rubocop/cop/elegant/no_nil_return.rb
+- lib/rubocop/cop/elegant/no_redundant_variable.rb
 - lib/rubocop/cop/elegant/paired_brackets.rb
 - lib/rubocop/cop/elegant_cops.rb
 - lib/rubocop/elegant/plugin.rb