rubocop-canon 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8b4a8966824947c873a90109b21e96a5d2c3fa1d01c71c3423ffe45afa7864e
-  data.tar.gz: eea9755c6e9ceab22ab0a316c5ec3eb52e3f290baa9cfe1a546adaaa25dc1bb3
+  metadata.gz: 899e2d0ddeff784568a001baef67ad0d3e42cf79178a89be152a3daaea76211d
+  data.tar.gz: a2e3f4f4e9cb206feb78327e911762bcbd42a9f082454da51251cfbfc20dd21d
 SHA512:
-  metadata.gz: fd398ceccc79ca4d5d8f575dcf9141e84bd0648e7ca673edb166955c56898b65f61efcd4988435cb21831a83485c2972b7e12c97defeb9f5ab7610eead5ad805
-  data.tar.gz: 65d340eb6eec5fba2b6d95c592abc238d869dd047135059089583596558191633f227a7a0e9aaa125383c241fd433214a435a252f03ca511e808f067a432adca
+  metadata.gz: c1b5e6bd6c16a23b28e8ab256dadad94566e0e3ed7780273072d09736758ed804bc42cc15928e60898a06e64199fa0af166c9f9d86e875aa2fad9cbd74b84352
+  data.tar.gz: 29236733c6b92470a145bb9ca1d1fd4182c365f5bbdd14aba418bd9d57898314c6721bba2c64da8c0089270f4f33f02ed3c725c476053c6a22d097397fc67d74

data/lib/rubocop/canon/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Canon
-    VERSION = '0.5.0'
+    VERSION = '0.6.0'
   end
 end

data/lib/rubocop/cop/canon/blank_line_help.rb

@@ -7,17 +7,23 @@ module RuboCop
       #
       # A cop mixing this in supplies the decision — how many blank lines a
       # pair of statements takes — and leaves the counting, the comment guard,
-      # the source ranges and the corrections here.
+      # the source ranges and the corrections here. A statement ends where its
+      # last heredoc ends, so a heredoc is part of the statement, not blank
+      # lines after it.
       module BlankLineHelp
         include RangeHelp
 
         BLOCK_TYPES = %i[block numblock].freeze
+        HEREDOC_TYPES = %i[str dstr xstr].freeze
         MSG_MULTILINE = 'Add a blank line around the multiline statement.'
 
         private
 
         def body_statements(node)
-          body = node.body
+          statements(node.body)
+        end
+
+        def statements(body)
           return [] if body.nil?
           return body.children if body.begin_type?
 
@@ -25,11 +31,11 @@ module RuboCop
         end
 
         def blank_lines_between(previous, following)
-          following.first_line - previous.last_line - 1
+          following.first_line - end_line(previous) - 1
         end
 
         def multiline?(node)
-          node.first_line != node.last_line
+          node.first_line != end_line(node)
         end
 
         def multiline_pair?(previous, following)
@@ -38,6 +44,14 @@ module RuboCop
           multiline?(following)
         end
 
+        def end_line(node)
+          [node.last_line, *heredoc_end_lines(node)].max
+        end
+
+        def heredoc_end_lines(node)
+          node.each_node(*HEREDOC_TYPES).select(&:heredoc?).map { |heredoc| heredoc.loc.heredoc_end.line }
+        end
+
         def require_blank_line(previous, following, message)
           return if comments_between?(previous, following)
           return unless blank_lines_between(previous, following).zero?
@@ -54,7 +68,7 @@ module RuboCop
 
         def comments_between?(previous, following)
           processed_source.comments.any? do |comment|
-            comment.loc.line >= previous.last_line && comment.loc.line < following.first_line
+            comment.loc.line >= end_line(previous) && comment.loc.line < following.first_line
           end
         end
 
@@ -66,7 +80,7 @@ module RuboCop
 
         def register_missing_blank_line(previous, following, message)
           add_offense(first_line_range(following), message:) do |corrector|
-            corrector.insert_after(line_range(previous.last_line), "\n")
+            corrector.insert_after(line_range(end_line(previous)), "\n")
           end
         end
 
@@ -94,11 +108,11 @@ module RuboCop
         end
 
         def blank_line_range(previous)
-          line_range(previous.last_line + 1)
+          line_range(end_line(previous) + 1)
         end
 
         def newline_range(previous)
-          range_between(line_range(previous.last_line).end_pos, line_range(previous.last_line + 1).end_pos)
+          range_between(line_range(end_line(previous)).end_pos, line_range(end_line(previous) + 1).end_pos)
         end
 
         def first_line_range(node)

data/lib/rubocop/cop/canon/declaration_groups.rb

@@ -3,19 +3,30 @@
 module RuboCop
   module Cop
     module Canon
-      # Enforces blank lines between declaration groups in a class, module or
-      # DSL block body.
+      # Enforces blank lines between declaration groups in a class, module,
+      # singleton class or DSL block body.
       #
-      # `GroupedMethods` is the whole specification: two declarations calling
-      # methods listed in the same group take no blank line between them, and
-      # two calling methods listed in different groups take exactly one. The
-      # cop says nothing about a method name it has not been given, so a DSL
-      # it does not know stays as its author wrote it.
+      # Every method name is its own group: two declarations calling the same
+      # method take no blank line between them, and two calling different
+      # methods take exactly one. `GroupedMethods` merges names into one
+      # group — `belongs_to` with `has_many`, `validate` with `validates`.
+      # Constants are a group of their own, and so are the two Ruby families
+      # RuboCop's layout cops already treat as one: `attr`, `attr_accessor`,
+      # `attr_reader` and `attr_writer`; `extend`, `include` and `prepend`.
       #
-      # A declaration spanning several lines, and any block, is a group of one
-      # whatever it calls, so it always stands apart from its neighbours.
-      # Everything else the cop has not been told about — an unlisted method
-      # name on one line, a constant — it leaves alone.
+      # A declaration is a call without a receiver or on `self`, or a constant
+      # assignment. A declaration spanning several lines, a block and a method
+      # definition are each a group of one whatever they call, so they always
+      # stand apart from their neighbours. Two definitions in a row belong to
+      # `Layout/EmptyLineBetweenDefs` and the lines around an access modifier
+      # to `Layout/EmptyLinesAroundAccessModifier`, so this cop leaves those
+      # alone. Anything else — an assignment, a conditional — it has no
+      # opinion about.
+      #
+      # A DSL block counts when it has no receiver and is a statement of a
+      # class, module or singleton class body, or of such a block: `included
+      # do`, `with_options ... do`, `action :index do`. A block passed as an
+      # argument — the lambda given to `scope` — is left alone.
       #
       # @example GroupedMethods: [[belongs_to, has_many], [validate, validates]]
       #   # bad
@@ -24,6 +35,9 @@ module RuboCop
       #
       #     has_many :shift_assignments, dependent: :destroy
       #     validates :starts_at, presence: true
+      #     scope :upcoming, -> { where(starts_at: Time.current..) }
+      #
+      #     scope :past, -> { where(starts_at: ...Time.current) }
       #   end
       #
       #   # good
@@ -32,12 +46,9 @@ module RuboCop
       #     has_many :shift_assignments, dependent: :destroy
       #
       #     validates :starts_at, presence: true
-      #   end
       #
-      #   # good — neither name is listed, so the cop leaves the body alone
-      #   class Filtering < Capability::Base
-      #     request_transformer RequestTransformer
-      #     api_builder APIBuilder
+      #     scope :upcoming, -> { where(starts_at: Time.current..) }
+      #     scope :past, -> { where(starts_at: ...Time.current) }
       #   end
       class DeclarationGroups < Base
         extend AutoCorrector
@@ -46,9 +57,9 @@ module RuboCop
         MSG_EXTRA = 'Remove the blank line between declarations of the same group.'
         MSG_MISSING = 'Add a blank line between declaration groups.'
         ACCESS_MODIFIERS = %i[private protected public module_function private_class_method].freeze
+        BODY_TYPES = %i[class module sclass].freeze
+        BUILT_IN_GROUPS = [%w[attr attr_accessor attr_reader attr_writer], %w[extend include prepend]].freeze
         DEFINITION_TYPES = %i[def defs].freeze
-        BLOCK_TYPES = %i[block numblock].freeze
-        STANDALONE_TYPES = %i[block numblock def defs].freeze
 
         def on_class(node)
           check_declarations(node)
@@ -58,8 +69,12 @@ module RuboCop
           check_declarations(node)
         end
 
+        def on_sclass(node)
+          check_declarations(node)
+        end
+
         def on_block(node)
-          return unless declaration_context?(node)
+          return unless declaration_block?(node)
 
           check_declarations(node)
         end
@@ -71,7 +86,6 @@ module RuboCop
         def check_declarations(node)
           statements = body_statements(node)
           return if statements.size < 2
-          return unless statements.all? { |statement| declaration?(statement) }
 
           statements.each_cons(2) do |previous, following|
             next if definitions?(previous, following)
@@ -112,35 +126,54 @@ module RuboCop
         end
 
         def standalone?(node)
-          return true if STANDALONE_TYPES.include?(node.type)
+          return true if BLOCK_TYPES.include?(node.type)
+          return true if definition?(node)
 
           multiline?(node)
         end
 
         def group_key(node)
-          return unless node.send_type?
+          return :constant if node.casgn_type?
+          return unless declaration_call?(node)
 
-          grouped_methods.index { |group| group.include?(node.method_name.to_s) }
+          name = node.method_name.to_s
+          group = groups.find { |members| members.include?(name) }
+          group.nil? ? name : group.first
         end
 
-        def declaration_context?(node)
-          enclosing = node.each_ancestor(:def, :defs, :class, :module).first
-          return false if enclosing.nil?
-          return true if enclosing.class_type?
+        def declaration_call?(node)
+          return false unless node.send_type?
+          return true if node.receiver.nil?
 
-          enclosing.module_type?
+          node.receiver.self_type?
         end
 
-        def declaration?(node)
-          return true if node.casgn_type?
+        def declaration_block?(node)
+          return false unless node.send_node.receiver.nil?
+
+          declaration_body?(node.parent)
+        end
+
+        def declaration_body?(node)
+          return false if node.nil?
+          return declaration_body?(node.parent) if node.begin_type?
+          return true if BODY_TYPES.include?(node.type)
+          return false unless BLOCK_TYPES.include?(node.type)
+
+          declaration_block?(node)
+        end
+
+        def definition?(node)
           return true if DEFINITION_TYPES.include?(node.type)
-          return node.send_node.receiver.nil? if BLOCK_TYPES.include?(node.type)
+          return false unless node.send_type?
 
-          node.send_type? && node.receiver.nil?
+          node.arguments.any? { |argument| DEFINITION_TYPES.include?(argument.type) }
         end
 
         def definitions?(previous, following)
-          DEFINITION_TYPES.include?(previous.type) && DEFINITION_TYPES.include?(following.type)
+          return false unless definition?(previous)
+
+          definition?(following)
         end
 
         def access_modifier?(node)
@@ -150,8 +183,8 @@ module RuboCop
           ACCESS_MODIFIERS.include?(node.method_name)
         end
 
-        def grouped_methods
-          @grouped_methods ||= Array(cop_config['GroupedMethods']).map { |group| Array(group).map(&:to_s) }
+        def groups
+          @groups ||= BUILT_IN_GROUPS + Array(cop_config['GroupedMethods']).map { |group| Array(group).map(&:to_s) }
         end
       end
     end

data/lib/rubocop/cop/canon/method_body_blank_lines.rb

@@ -15,15 +15,22 @@ module RuboCop
       # The list is empty by default, so the cop only removes until it is
       # configured.
       #
-      # Guard clauses group: two in a row take no blank line between them.
-      # The position after the last guard belongs to
-      # `Layout/EmptyLineAfterGuardClause`, so this cop leaves it alone — and
-      # recognises a guard by that cop's own definition: an `if` whose branch
-      # is a single-line `return`, `break`, `next`, `raise` or `fail`. A bare
-      # `raise` on its own line is a statement, not a guard.
+      # Guard clauses group by what they do: the guards that return sit
+      # together, the guards that raise sit together, and one blank line
+      # separates the two groups. The position after the last guard belongs
+      # to `Layout/EmptyLineAfterGuardClause`, so this cop leaves it alone —
+      # and recognises a guard by that cop's own definition: an `if` whose
+      # branch is a single-line `return`, `break`, `next`, `raise` or `fail`.
+      # A bare `raise` on its own line is a statement, not a guard. A guard
+      # whose branch spans several lines is a multiline statement to both
+      # cops, so this cop sets it apart.
       #
-      # A statement spanning several lines is always set apart by a blank
-      # line on each side, guards included.
+      # A statement spanning several lines — a heredoc counts — is always set
+      # apart by a blank line on each side, guards included.
+      #
+      # A method that rescues has several bodies: the statements it protects,
+      # each `rescue` clause, the `else` and the `ensure`. The rules apply
+      # inside each of them.
       #
       # An entry matches a method name anywhere in the call chain. Write it
       # dotted — `errors.add` — to match a receiver and method together, so
@@ -61,12 +68,24 @@ module RuboCop
       #
       #     order.items.sum(&:amount)
       #   end
+      #
+      #   # good — the guards that return and the guard that raises are two groups
+      #   def resolve(name)
+      #     return nil if name.nil?
+      #     return name if name.is_a?(Array)
+      #
+      #     raise ArgumentError, "#{name} not found" unless enums.key?(name)
+      #
+      #     enums.fetch(name)
+      #   end
       class MethodBodyBlankLines < Base
         extend AutoCorrector
         include BlankLineHelp
 
         MSG_EXTRA = 'Remove the blank line inside the method body.'
         MSG_MISSING = 'Add a blank line around the standalone call.'
+        MSG_MIXED_GUARDS = 'Add a blank line between a guard that returns and a guard that raises.'
+        CLAUSE_TYPES = %i[ensure rescue resbody].freeze
         JUMP_METHODS = %i[raise fail].freeze
 
         def on_def(node)
@@ -80,9 +99,24 @@ module RuboCop
         private
 
         def check_method_body(node)
-          statements = body_statements(node)
-          return if statements.size < 2
+          statement_lists(node.body).each { |statements| check_statements(statements) }
+        end
+
+        def statement_lists(node)
+          return [] if node.nil?
+          return [statements(node)] unless CLAUSE_TYPES.include?(node.type)
 
+          clause_bodies(node).flat_map { |body| statement_lists(body) }
+        end
+
+        def clause_bodies(node)
+          return [node.children.first, node.branch] if node.ensure_type?
+          return [node.body] if node.resbody_type?
+
+          [node.body, *node.resbody_branches, node.else_branch]
+        end
+
+        def check_statements(statements)
           statements.each_cons(2) do |previous, following|
             next if guard_boundary?(previous, following)
 
@@ -93,12 +127,14 @@ module RuboCop
         def guard_boundary?(previous, following)
           return false unless guard?(previous)
 
-          !guard?(following)
+          !contains_guard?(following)
         end
 
         def check_gap(previous, following)
           if multiline_pair?(previous, following)
             require_blank_line(previous, following, MSG_MULTILINE)
+          elsif mixed_guards?(previous, following)
+            require_blank_line(previous, following, MSG_MIXED_GUARDS)
           elsif separated_pair?(previous, following)
             require_blank_line(previous, following, MSG_MISSING)
           else
@@ -125,9 +161,25 @@ module RuboCop
           chain.each_cons(2).any? { |pair| pair.join('.') == name }
         end
 
+        def mixed_guards?(previous, following)
+          return false unless guard?(previous)
+          return false unless guard?(following)
+
+          raising_guard?(previous) != raising_guard?(following)
+        end
+
         def guard?(node)
           return false unless node.if_type?
 
+          branch = node.if_branch
+          return false if branch.nil?
+
+          branch.guard_clause?
+        end
+
+        def contains_guard?(node)
+          return false unless node.if_type?
+
           branch = node.if_branch
           return false if branch.nil?
           return true if branch.guard_clause?
@@ -145,6 +197,13 @@ module RuboCop
           JUMP_METHODS.include?(node.method_name)
         end
 
+        def raising_guard?(node)
+          jump = node.if_branch
+          jump = jump.rhs if jump.operator_keyword?
+
+          jump.send_type?
+        end
+
         def separated_methods
           @separated_methods ||= Array(cop_config['SeparatedMethods']).map(&:to_s)
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-canon
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - skiftle