rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/layout/class_structure.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks if the code style follows the ExpectedOrder configuration:
+      #
+      # `Categories` allows us to map macro names into a category.
+      #
+      # Consider an example of code style that covers the following order:
+      # - Constants
+      # - Associations (has_one, has_many)
+      # - Attributes (attr_accessor, attr_writer, attr_reader)
+      # - Initializer
+      # - Instance methods
+      # - Protected methods
+      # - Private methods
+      #
+      # You can configure the following order:
+      #
+      # ```yaml
+      #  Layout/ClassStructure:
+      #    Categories:
+      #      module_inclusion:
+      #        - include
+      #        - prepend
+      #        - extend
+      #    ExpectedOrder:
+      #        - module_inclusion
+      #        - constants
+      #        - public_class_methods
+      #        - initializer
+      #        - public_methods
+      #        - protected_methods
+      #        - private_methods
+      #
+      # ```
+      # Instead of putting all literals in the expected order, is also
+      # possible to group categories of macros.
+      #
+      # ```yaml
+      #  Layout/ClassStructure:
+      #    Categories:
+      #      association:
+      #        - has_many
+      #        - has_one
+      #      attribute:
+      #        - attr_accessor
+      #        - attr_reader
+      #        - attr_writer
+      # ```
+      #
+      # @example
+      #   # bad
+      #   # Expect extend be before constant
+      #   class Person < ApplicationRecord
+      #     has_many :orders
+      #     ANSWER = 42
+      #
+      #     extend SomeModule
+      #     include AnotherModule
+      #   end
+      #
+      #   # good
+      #   class Person
+      #     # extend and include go first
+      #     extend SomeModule
+      #     include AnotherModule
+      #
+      #     # inner classes
+      #     CustomError = Class.new(StandardError)
+      #
+      #     # constants are next
+      #     SOME_CONSTANT = 20
+      #
+      #     # afterwards we have attribute macros
+      #     attr_reader :name
+      #
+      #     # followed by other macros (if any)
+      #     validates :name
+      #
+      #     # public class methods are next in line
+      #     def self.some_method
+      #     end
+      #
+      #     # initialization goes between class methods and instance methods
+      #     def initialize
+      #     end
+      #
+      #     # followed by other public instance methods
+      #     def some_method
+      #     end
+      #
+      #     # protected and private methods are grouped near the end
+      #     protected
+      #
+      #     def some_protected_method
+      #     end
+      #
+      #     private
+      #
+      #     def some_private_method
+      #     end
+      #   end
+      #
+      # @see https://github.com/bbatsov/ruby-style-guide#consistent-classes
+      class ClassStructure < Cop
+        HUMANIZED_NODE_TYPE = {
+          casgn: :constants,
+          defs: :class_methods,
+          def: :public_methods
+        }.freeze
+
+        VISIBILITY_SCOPES = %i[private protected public].freeze
+        MSG = '`%s` is supposed to appear before `%s`.'.freeze
+
+        def_node_matcher :visibility_block?, <<-PATTERN
+          (send nil? { :private :protected :public })
+        PATTERN
+
+        # Validates code style on class declaration.
+        # Add offense when find a node out of expected order.
+        def on_class(class_node)
+          previous = -1
+          walk_over_nested_class_definition(class_node) do |node, category|
+            index = expected_order.index(category)
+            if index < previous
+              message = format(MSG, category, expected_order[previous])
+              add_offense(node, message: message)
+            end
+            previous = index
+          end
+        end
+
+        # Autocorrect by swapping between two nodes autocorrecting them
+        def autocorrect(node)
+          node_classification = classify(node)
+          previous = left_siblings_of(node).find do |sibling|
+            classification = classify(sibling)
+            !ignore?(classification) && node_classification != classification
+          end
+
+          current_range = source_range_with_comment(node)
+          previous_range = source_range_with_comment(previous)
+
+          lambda do |corrector|
+            corrector.insert_before(previous_range, current_range.source)
+            corrector.remove(current_range)
+          end
+        end
+
+        private
+
+        # Classifies a node to match with something in the {expected_order}
+        # @param node to be analysed
+        # @return String when the node type is a `:block` then
+        #   {classify} recursively with the first children
+        # @return String when the node type is a `:send` then {find_category}
+        #   by method name
+        # @return String otherwise trying to {humanize_node} of the current node
+        def classify(node)
+          return node.to_s unless node.respond_to?(:type)
+          case node.type
+          when :block
+            classify(node.send_node)
+          when :send
+            find_category(node.method_name)
+          else
+            humanize_node(node)
+          end.to_s
+        end
+
+        # Categorize a method_name according to the {expected_order}
+        # @param method_name try to match {categories} values
+        # @return [String] with the key category or the `method_name` as string
+        def find_category(method_name)
+          name = method_name.to_s
+          category, = categories.find { |_, names| names.include?(name) }
+          category || name
+        end
+
+        def walk_over_nested_class_definition(class_node)
+          class_elements(class_node).each do |node|
+            classification = classify(node)
+            next if ignore?(classification)
+            yield node, classification
+          end
+        end
+
+        def class_elements(class_node)
+          *, class_def = class_node.children
+          return [] unless class_def
+          if class_def.def_type? || class_def.send_type?
+            [class_def]
+          else
+            class_def.children.compact
+          end
+        end
+
+        def ignore?(classification)
+          classification.nil? ||
+            classification.to_s.end_with?('=') ||
+            expected_order.index(classification).nil?
+        end
+
+        def node_visibility(node)
+          _, method_name, = *find_visibility_start(node)
+          method_name || :public
+        end
+
+        def find_visibility_start(node)
+          left_siblings_of(node)
+            .reverse
+            .find(&method(:visibility_block?))
+        end
+
+        # Navigate to find the last protected method
+        def find_visibility_end(node)
+          possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
+          right = right_siblings_of(node)
+          right.find do |child_node|
+            possible_visibilities.include?(node_visibility(child_node))
+          end || right.last
+        end
+
+        def siblings_of(node)
+          node.parent.children
+        end
+
+        def right_siblings_of(node)
+          siblings_of(node)[node.sibling_index..-1]
+        end
+
+        def left_siblings_of(node)
+          siblings_of(node)[0, node.sibling_index]
+        end
+
+        def humanize_node(node)
+          method_name, = *node
+          if node.def_type?
+            return :initializer if method_name == :initialize
+            return "#{node_visibility(node)}_methods"
+          end
+          HUMANIZED_NODE_TYPE[node.type] || node.type
+        end
+
+        def source_range_with_comment(node)
+          begin_pos, end_pos =
+            if node.def_type?
+              start_node = find_visibility_start(node) || node
+              end_node = find_visibility_end(node) || node
+              [begin_pos_with_comment(start_node),
+               end_position_for(end_node) + 1]
+            else
+              [begin_pos_with_comment(node), end_position_for(node)]
+            end
+
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+
+        def end_position_for(node)
+          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          buffer.line_range(end_line).end_pos
+        end
+
+        def begin_pos_with_comment(node)
+          annotation_line = node.first_line - 1
+          first_comment = nil
+
+          comments_before_line(annotation_line).reverse_each do |comment|
+            if comment.location.line == annotation_line
+              first_comment = comment
+              annotation_line -= 1
+            end
+          end
+
+          start_line_position(first_comment || node)
+        end
+
+        def start_line_position(node)
+          buffer.line_range(node.first_line).begin_pos - 1
+        end
+
+        def comments_before_line(line)
+          processed_source.comments.select { |c| c.location.line <= line }
+        end
+
+        def buffer
+          processed_source.buffer
+        end
+
+        # Load expected order from `ExpectedOrder` config.
+        # Define new terms in the expected order by adding new {categories}.
+        def expected_order
+          cop_config['ExpectedOrder']
+        end
+
+        # Setting categories hash allow you to group methods in group to match
+        # in the {expected_order}.
+        def categories
+          cop_config['Categories']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → layout}/closing_parenthesis_indentation.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cops checks the indentation of hanging closing parentheses in
       # method calls, method definitions, and grouped expressions. A hanging
       # closing parenthesis means `)` preceded by a line break.
@@ -26,41 +25,47 @@ module RuboCop
       #     x,
       #     y
       #     )
+      #   end
       class ClosingParenthesisIndentation < Cop
-        include AutocorrectAlignment
-        include OnMethodDef
+        include Alignment
 
         MSG_INDENT =
           'Indent `)` the same as the start of the line where `(` is.'.freeze
         MSG_ALIGN = 'Align `)` with `(`.'.freeze
 
         def on_send(node)
-          _receiver, _method_name, *args = *node
-          check(node, args)
+          check(node, node.arguments)
         end
 
         def on_begin(node)
           check(node, node.children)
         end
 
-        private
+        def on_def(node)
+          check(node.arguments, node.arguments)
+        end
+        alias on_defs on_def
 
-        def on_method_def(_node, _method_name, args, _body)
-          check(args, args.children)
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
         end
 
+        private
+
         def check(node, elements)
           right_paren = node.loc.end
-          return unless right_paren
-          return unless begins_its_line?(right_paren)
+
+          return unless right_paren && begins_its_line?(right_paren)
 
           correct_column = expected_column(node, elements)
           @column_delta = correct_column - right_paren.column
+
           return if @column_delta.zero?
 
           left_paren = node.loc.begin
           msg = correct_column == left_paren.column ? MSG_ALIGN : MSG_INDENT
-          add_offense(right_paren, right_paren, msg)
+
+          add_offense(right_paren, location: right_paren, message: msg)
         end
 
         def expected_column(node, elements)
@@ -75,7 +80,7 @@ module RuboCop
         end
 
         def fixed_parameter_indentation?
-          config.for_cop('Style/AlignParameters')['EnforcedStyle'] ==
+          config.for_cop('Layout/AlignParameters')['EnforcedStyle'] ==
             'with_fixed_indentation'
         end
 

data/lib/rubocop/cop/{style → layout}/comment_indentation.rb

@@ -1,19 +1,51 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cops checks the indentation of comments.
+      #
+      # @example
+      #   # bad
+      #     # comment here
+      #   def method_name
+      #   end
+      #
+      #     # comment here
+      #   a = 'hello'
+      #
+      #   # yet another comment
+      #     if true
+      #       true
+      #     end
+      #
+      #   # good
+      #   # comment here
+      #   def method_name
+      #   end
+      #
+      #   # comment here
+      #   a = 'hello'
+      #
+      #   # yet another comment
+      #   if true
+      #     true
+      #   end
+      #
       class CommentIndentation < Cop
-        include AutocorrectAlignment
+        include Alignment
 
-        MSG = 'Incorrect indentation detected (column %d instead of %d).'.freeze
+        MSG = 'Incorrect indentation detected (column %<column>d ' \
+          'instead of %<correct_comment_indentation>d).'.freeze
 
         def investigate(processed_source)
           processed_source.comments.each { |comment| check(comment) }
         end
 
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
         private
 
         def check(comment)
@@ -34,8 +66,18 @@ module RuboCop
             return if column == correct_comment_indentation
           end
 
-          add_offense(comment, comment.loc.expression,
-                      format(MSG, column, correct_comment_indentation))
+          add_offense(
+            comment,
+            message: message(column, correct_comment_indentation)
+          )
+        end
+
+        def message(column, correct_comment_indentation)
+          format(
+            MSG,
+            column: column,
+            correct_comment_indentation: correct_comment_indentation
+          )
         end
 
         def own_line_comment?(comment)

data/lib/rubocop/cop/{style → layout}/dot_position.rb

@@ -1,20 +1,49 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks the . position in multi-line method calls.
+      #
+      # @example EnforcedStyle: leading (default)
+      #   # bad
+      #   something.
+      #     mehod
+      #
+      #   # good
+      #   something
+      #     .method
+      #
+      # @example EnforcedStyle: trailing
+      #   # bad
+      #   something
+      #     .method
+      #
+      #   # good
+      #   something.
+      #     mehod
       class DotPosition < Cop
         include ConfigurableEnforcedStyle
 
         def on_send(node)
-          return unless node.loc.dot
+          return unless node.dot?
 
           if proper_dot_position?(node)
             correct_style_detected
           else
-            add_offense(node, :dot) { opposite_style_detected }
+            add_offense(node, location: :dot) { opposite_style_detected }
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.dot)
+            case style
+            when :leading
+              corrector.insert_before(selector_range(node), '.')
+            when :trailing
+              corrector.insert_after(node.receiver.source_range, '.')
+            end
           end
         end
 
@@ -31,9 +60,7 @@ module RuboCop
         end
 
         def proper_dot_position?(node)
-          receiver, _method_name, *_args = *node
-
-          receiver_line = receiver.source_range.end.line
+          receiver_line = node.receiver.source_range.end.line
           selector_line = selector_range(node).line
 
           # receiver and selector are on the same line
@@ -61,20 +88,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          receiver, _method_name, *_args = *node
-
-          lambda do |corrector|
-            corrector.remove(node.loc.dot)
-            case style
-            when :leading
-              corrector.insert_before(selector_range(node), '.')
-            when :trailing
-              corrector.insert_after(receiver.source_range, '.')
-            end
-          end
-        end
-
         def selector_range(node)
           if node.loc.selector
             node.loc.selector

data/lib/rubocop/cop/{style → layout}/else_alignment.rb

@@ -1,47 +1,57 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cops checks the alignment of else keywords. Normally they should
       # be aligned with an if/unless/while/until/begin/def keyword, but there
       # are special cases when they should follow the same rules as the
       # alignment of end.
+      #
+      # @example
+      #   # bad
+      #   if something
+      #     code
+      #    else
+      #     code
+      #   end
+      #
+      #   # bad
+      #   if something
+      #     code
+      #    elsif something
+      #     code
+      #   end
+      #
+      #   # good
+      #   if something
+      #     code
+      #   else
+      #     code
+      #   end
       class ElseAlignment < Cop
         include EndKeywordAlignment
-        include AutocorrectAlignment
+        include Alignment
         include CheckAssignment
 
-        MSG = 'Align `%s` with `%s`.'.freeze
+        MSG = 'Align `%<else_range>s` with `%<base_range>s`.'.freeze
 
         def on_if(node, base = nil)
           return if ignored_node?(node)
-          return unless node.loc.respond_to?(:else)
-          return if node.loc.else.nil?
+          return unless node.else? && begins_its_line?(node.loc.else)
 
-          else_range = node.loc.else
-          return unless begins_its_line?(else_range)
-
-          check_alignment(base_range(node, base), else_range)
+          check_alignment(base_range(node, base), node.loc.else)
 
-          return if else_range.source != 'elsif'
+          return unless node.elsif_conditional?
 
-          # If the `else` part is actually an `elsif`, we check the `elsif`
-          # node in case it contains an `else` within, because that `else`
-          # should have the same alignment (base).
-          _condition, _if_body, else_body = *node
-          on_if(else_body, base)
-          # The `elsif` node will get an `on_if` call from the framework later,
-          # but we're done here, so we set it to ignored.
-          ignore_node(else_body)
+          check_nested(node.else_branch, base)
         end
 
         def on_rescue(node)
-          return unless node.loc.else
+          return unless node.loc.respond_to?(:else) && node.loc.else
 
           parent = node.parent
-          parent = parent.parent if parent.type == :ensure
+          parent = parent.parent if parent.ensure_type?
           base = case parent.type
                  when :def, :defs then base_for_method_definition(parent)
                  when :kwbegin then parent.loc.begin
@@ -51,28 +61,34 @@ module RuboCop
         end
 
         def on_case(node)
-          _cond, *whens, _else = *node
-          return unless node.loc.else
-          check_alignment(whens.last.loc.keyword, node.loc.else)
+          return unless node.else?
+
+          check_alignment(node.when_branches.last.loc.keyword, node.loc.else)
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
         end
 
         private
 
+        def check_nested(node, base)
+          on_if(node, base)
+          ignore_node(node)
+        end
+
         def base_range(node, base)
           if base
             base.source_range
           else
-            base = node
-            until %w(if unless).include?(base.loc.keyword.source)
-              base = base.parent
-            end
-            base.loc.keyword
+            lineage = [node, *node.each_ancestor(:if)]
+            lineage.find { |parent| parent.if? || parent.unless? }.loc.keyword
           end
         end
 
         def base_for_method_definition(node)
           parent = node.parent
-          if parent && parent.type == :send
+          if parent && parent.send_type?
             parent.loc.selector # For example "private def ..."
           else
             node.loc.keyword
@@ -87,13 +103,12 @@ module RuboCop
           return unless rhs
 
           end_config = config.for_cop('Lint/EndAlignment')
-          style = end_config['AlignWith'] || 'keyword'
+          style = end_config['EnforcedStyleAlignWith'] || 'keyword'
           base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
-          return if rhs.type != :if
+          return unless rhs.if_type?
 
-          on_if(rhs, base)
-          ignore_node(rhs)
+          check_nested(rhs, base)
         end
 
         def check_alignment(base_range, else_range)
@@ -101,9 +116,12 @@ module RuboCop
 
           @column_delta = effective_column(base_range) - else_range.column
           return if @column_delta.zero?
-
-          add_offense(else_range, else_range,
-                      format(MSG, else_range.source, base_range.source[/^\S*/]))
+          message = format(
+            MSG,
+            else_range: else_range.source,
+            base_range: base_range.source[/^\S*/]
+          )
+          add_offense(else_range, location: else_range, message: message)
         end
       end
     end