rubocop 0.49.1 → 0.52.0

data/lib/rubocop/cop/internal_affairs/useless_message_assertion.rb

@@ -17,16 +17,16 @@ module RuboCop
         MSG = 'Do not specify cop behavior using `described_class::MSG`.'.freeze
 
         def_node_search :described_class_msg, <<-PATTERN
-          (const (send nil :described_class) :MSG)
+          (const (send nil? :described_class) :MSG)
         PATTERN
 
         def_node_matcher :rspec_expectation_on_msg?, <<-PATTERN
-          (send (send nil :expect #contains_described_class_msg?) :to ...)
+          (send (send nil? :expect #contains_described_class_msg?) :to ...)
         PATTERN
 
         def investigate(_processed_source)
           assertions_using_described_class_msg.each do |node|
-            add_offense(node, :expression)
+            add_offense(node)
           end
         end
 

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

@@ -6,9 +6,7 @@ module RuboCop
       # Modifiers should be indented as deep as method definitions, or as deep
       # as the class/module keyword, depending on configuration.
       #
-      # @example
-      #   # EnforcedStyle: indent (default)
-      #
+      # @example EnforcedStyle: indent (default)
       #   # bad
       #   class Plumbus
       #   private
@@ -21,8 +19,7 @@ module RuboCop
       #     def smooth; end
       #   end
       #
-      #   # EnforcedStyle: outdent
-      #
+      # @example EnforcedStyle: outdent
       #   # bad
       #   class Plumbus
       #     private
@@ -37,9 +34,8 @@ module RuboCop
       class AccessModifierIndentation < Cop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
-        include AccessModifierNode
 
-        MSG = '%s access modifiers like `%s`.'.freeze
+        MSG = '%<style>s access modifiers like `%<node>s`.'.freeze
 
         def on_class(node)
           _name, _base_class, body = *node
@@ -67,7 +63,7 @@ module RuboCop
         def check_body(body, node)
           return if body.nil? # Empty class etc.
 
-          modifiers = body.each_child_node.select { |c| modifier_node?(c) }
+          modifiers = body.each_child_node(:send).select(&:access_modifier?)
           class_column = node.source_range.column
 
           modifiers.each { |modifier| check_modifier(modifier, class_column) }
@@ -81,7 +77,7 @@ module RuboCop
           if @column_delta.zero?
             correct_style_detected
           else
-            add_offense(send_node, :expression) do
+            add_offense(send_node) do
               if offset == unexpected_indent_offset
                 opposite_style_detected
               else
@@ -92,7 +88,7 @@ module RuboCop
         end
 
         def message(node)
-          format(MSG, style.capitalize, node.loc.selector.source)
+          format(MSG, style: style.capitalize, node: node.loc.selector.source)
         end
 
         def expected_indent_offset

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

@@ -8,14 +8,14 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   a = [1, 2, 3
+      #   a = [1, 2, 3,
       #     4, 5, 6]
       #   array = ['run',
       #        'forrest',
       #        'run']
       #
       #   # good
-      #   a = [1, 2, 3
+      #   a = [1, 2, 3,
       #        4, 5, 6]
       #   a = ['run',
       #        'forrest',

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

@@ -116,7 +116,7 @@ module RuboCop
 
         def on_hash(node)
           return if ignored_node?(node)
-          return if node.pairs.empty? || node.single_line?
+          return if node.empty? || node.single_line?
 
           return unless alignment_for_hash_rockets.checkable_layout?(node) &&
                         alignment_for_colons.checkable_layout?(node)
@@ -124,6 +124,21 @@ module RuboCop
           check_pairs(node)
         end
 
+        def autocorrect(node)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get the
+          # last value of each. A local variable fixes the problem.
+          key_delta = column_deltas[:key] || 0
+
+          if !node.value
+            correct_no_value(key_delta, node.source_range)
+          else
+            correct_key_value(key_delta, node.key.source_range,
+                              node.value.source_range,
+                              node.loc.operator)
+          end
+        end
+
         private
 
         attr_accessor :column_deltas
@@ -136,12 +151,12 @@ module RuboCop
           first_pair = node.pairs.first
           self.column_deltas = alignment_for(first_pair)
                                .deltas_for_first_pair(first_pair, node)
-          add_offense(first_pair, :expression) unless good_alignment?
+          add_offense(first_pair) unless good_alignment?
 
           node.children.each do |current|
             self.column_deltas = alignment_for(current)
                                  .deltas(first_pair, current)
-            add_offense(current, :expression) unless good_alignment?
+            add_offense(current) unless good_alignment?
           end
         end
 
@@ -172,21 +187,6 @@ module RuboCop
             new_alignment('EnforcedColonStyle')
         end
 
-        def autocorrect(node)
-          # We can't use the instance variable inside the lambda. That would
-          # just give each lambda the same reference and they would all get the
-          # last value of each. A local variable fixes the problem.
-          key_delta = column_deltas[:key] || 0
-
-          if !node.value
-            correct_no_value(key_delta, node.source_range)
-          else
-            correct_key_value(key_delta, node.key.source_range,
-                              node.value.source_range,
-                              node.loc.operator)
-          end
-        end
-
         def correct_no_value(key_delta, key)
           ->(corrector) { adjust(corrector, key_delta, key) }
         end

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

@@ -6,10 +6,7 @@ module RuboCop
       # Here we check if the parameters on a multi-line method call or
       # definition are aligned.
       #
-      # @example
-      #
-      #   # EnforcedStyle: with_first_parameter
-      #
+      # @example EnforcedStyle: with_first_parameter (default)
       #   # good
       #
       #   foo :bar,
@@ -20,10 +17,7 @@ module RuboCop
       #   foo :bar,
       #     :baz
       #
-      # @example
-      #
-      #   # EnforcedStyle: with_fixed_indentation
-      #
+      # @example EnforcedStyle: with_fixed_indentation
       #   # good
       #
       #   foo :bar,
@@ -35,37 +29,31 @@ module RuboCop
       #       :baz
       class AlignParameters < Cop
         include AutocorrectAlignment
-        include OnMethodDef
 
-        ALIGN_PARAMS_MSG = 'Align the parameters of a method %s if they span ' \
-          'more than one line.'.freeze
+        ALIGN_PARAMS_MSG = 'Align the parameters of a method %<type>s if ' \
+          'they span more than one line.'.freeze
 
         FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
-          'following the first line of a multi-line method %s.'.freeze
+          'following the first line of a multi-line method %<type>s.'.freeze
 
         def on_send(node)
-          return if node.arguments.size < 2 || node.method?(:[]=)
+          return if node.arguments.size < 2 ||
+                    node.send_type? && node.method?(:[]=)
 
           check_alignment(node.arguments, base_column(node, node.arguments))
         end
+        alias on_def  on_send
+        alias on_defs on_send
 
-        def on_method_def(node, _method_name, args, _body)
-          args = args.children
-
-          return if args.size < 2
-
-          check_alignment(args, base_column(node, args))
-        end
+        private
 
         def message(node)
           type = node && node.parent.send_type? ? 'call' : 'definition'
           msg = fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
 
-          format(msg, type)
+          format(msg, type: type)
         end
 
-        private
-
         def fixed_indentation?
           cop_config['EnforcedStyle'] == 'with_fixed_indentation'
         end

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

@@ -25,7 +25,8 @@ module RuboCop
       #     foo(i)
       #   }
       class BlockEndNewline < Cop
-        MSG = 'Expression at %d, %d should be on its own line.'.freeze
+        MSG = 'Expression at %<line>d, %<column>d should be on its own line.'
+              .freeze
 
         def on_block(node)
           return if node.single_line?
@@ -35,26 +36,39 @@ module RuboCop
           # If the end is on its own line, there is no offense
           return if end_loc.source_line =~ /^\s*#{end_loc.source}/
 
-          add_offense(node, end_loc)
+          add_offense(node, location: end_loc)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             indentation = indentation_of_block_start_line(node)
-            corrector.insert_before(node.loc.end, "\n" + (' ' * indentation))
+            new_block_end = "\n" + node.loc.end.source + (' ' * indentation)
+            corrector.replace(delimiter_range(node), new_block_end)
           end
         end
 
+        private
+
         def message(node)
-          format(MSG, node.loc.end.line, node.loc.end.column + 1)
+          format(MSG, line: node.loc.end.line, column: node.loc.end.column + 1)
         end
 
         def indentation_of_block_start_line(node)
           match = /\S.*/.match(node.loc.begin.source_line)
           match.begin(0)
         end
+
+        def delimiter_range(node)
+          Parser::Source::Range.new(
+            node.loc.end.source_buffer,
+            index_of_delimiter_with_whitespaces(node),
+            node.source.length
+          )
+        end
+
+        def index_of_delimiter_with_whitespaces(node)
+          node.source =~ /\s*#{node.closing_delimiter}/
+        end
       end
     end
   end

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

@@ -30,13 +30,11 @@ module RuboCop
       #     y / 3
       #   end
       #
-      # @example
+      # @example EnforcedStyle: case (default)
       #   # if EndAlignment is set to other style such as
       #   # start_of_line (as shown below), then *when* alignment
       #   # configuration does have an effect.
       #
-      #   # EnforcedStyle: case (default)
-      #
       #   # bad
       #   a = case n
       #   when 0
@@ -53,8 +51,7 @@ module RuboCop
       #         y / 3
       #   end
       #
-      #   # EnforcedStyle: end
-      #
+      # @example EnforcedStyle: end
       #   # bad
       #   a = case n
       #       when 0
@@ -74,7 +71,7 @@ module RuboCop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
 
-        MSG = 'Indent `when` %s `%s`.'.freeze
+        MSG = 'Indent `when` %<depth>s `%<base>s`.'.freeze
 
         def on_case(case_node)
           return if case_node.single_line?
@@ -84,6 +81,16 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          whitespace = whitespace_range(node)
+
+          return false unless whitespace.source.strip.empty?
+
+          lambda do |corrector|
+            corrector.replace(whitespace, replacement(node))
+          end
+        end
+
         private
 
         def check_when(when_node)
@@ -109,7 +116,7 @@ module RuboCop
           when_column = when_node.loc.keyword.column
           base_column = base_column(when_node.parent, alternative_style)
 
-          add_offense(when_node, :keyword, message(style)) do
+          add_offense(when_node, location: :keyword, message: message(style)) do
             if when_column == base_column
               opposite_style_detected
             else
@@ -121,7 +128,7 @@ module RuboCop
         def message(base)
           depth = indent_one_step? ? 'one step more than' : 'as deep as'
 
-          format(MSG, depth, base)
+          format(MSG, depth: depth, base: base)
         end
 
         def base_column(case_node, base)
@@ -131,16 +138,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          whitespace = whitespace_range(node)
-
-          return false unless whitespace.source.strip.empty?
-
-          lambda do |corrector|
-            corrector.replace(whitespace, replacement(node))
-          end
-        end
-
         def whitespace_range(node)
           when_column = node.location.keyword.column
           begin_pos = node.loc.keyword.begin_pos

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.loc.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.loc.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