rubocop 0.78.0

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant message arguments to `#add_offense`. This method
+      # will automatically use `#message` or `MSG` (in that order of priority)
+      # if they are defined.
+      #
+      # @example
+      #
+      #   # bad
+      #   add_offense(node, message: MSG)
+      #   add_offense(node, message: message)
+      #   add_offense(node, message: message(node))
+      #
+      #   # good
+      #   add_offense(node)
+      #   add_offense(node, message: CUSTOM_MSG)
+      #   add_offense(node, message: message(other_node))
+      #
+      class RedundantMessageArgument < Cop
+        include RangeHelp
+
+        MSG = 'Redundant message argument to `#add_offense`.'
+
+        def_node_matcher :node_type_check, <<~PATTERN
+          (send nil? :add_offense $_node $hash)
+        PATTERN
+
+        def_node_matcher :redundant_message_argument, <<~PATTERN
+          (pair
+            (sym :message)
+            ${(const nil? :MSG) (send nil? :message) (send nil? :message _)})
+        PATTERN
+
+        def_node_matcher :message_method_call, '(send nil? :message $_node)'
+
+        def on_send(node)
+          node_type_check(node) do |node_arg, kwargs|
+            find_offending_argument(node_arg, kwargs) do |pair|
+              add_offense(pair)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          range = offending_range(node)
+
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def offending_range(node)
+          with_space = range_with_surrounding_space(range: node.loc.expression)
+
+          range_with_surrounding_comma(with_space, :left)
+        end
+
+        def find_offending_argument(searched_node, kwargs)
+          kwargs.pairs.each do |pair|
+            redundant_message_argument(pair) do |message_argument|
+              node = message_method_call(message_argument)
+
+              yield pair if !node || node == searched_node
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that cops are not tested using `described_class::MSG`.
+      #
+      # @example
+      #
+      #     # bad
+      #     expect(cop.messages).to eq([described_class::MSG])
+      #
+      #     # good
+      #     expect(cop.messages).to eq(['Do not write bad code like that.'])
+      #
+      class UselessMessageAssertion < Cop
+        MSG = 'Do not specify cop behavior using `described_class::MSG`.'
+
+        def_node_search :described_class_msg, <<~PATTERN
+          (const (send nil? :described_class) :MSG)
+        PATTERN
+
+        def_node_matcher :rspec_expectation_on_msg?, <<~PATTERN
+          (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)
+          end
+        end
+
+        private
+
+        def contains_described_class_msg?(node)
+          described_class_msg(node).any?
+        end
+
+        def assertions_using_described_class_msg
+          described_class_msg(processed_source.ast).reject do |node|
+            node.ancestors.any?(&method(:rspec_expectation_on_msg?))
+          end
+        end
+
+        # Only process spec files
+        def relevant_file?(file)
+          file.end_with?('_spec.rb')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Bare access modifiers (those not applying to specific methods) should be
+      # indented as deep as method definitions, or as deep as the class/module
+      # keyword, depending on configuration.
+      #
+      # @example EnforcedStyle: indent (default)
+      #   # bad
+      #   class Plumbus
+      #   private
+      #     def smooth; end
+      #   end
+      #
+      #   # good
+      #   class Plumbus
+      #     private
+      #     def smooth; end
+      #   end
+      #
+      # @example EnforcedStyle: outdent
+      #   # bad
+      #   class Plumbus
+      #     private
+      #     def smooth; end
+      #   end
+      #
+      #   # good
+      #   class Plumbus
+      #   private
+      #     def smooth; end
+      #   end
+      class AccessModifierIndentation < Cop
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = '%<style>s access modifiers like `%<node>s`.'
+
+        def on_class(node)
+          return unless node.body&.begin_type?
+
+          check_body(node.body, node)
+        end
+        alias on_sclass on_class
+        alias on_module on_class
+        alias on_block  on_class
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
+        private
+
+        def check_body(body, node)
+          modifiers = body.each_child_node(:send)
+                          .select(&:bare_access_modifier?)
+          end_range = node.loc.end
+
+          modifiers.each { |modifier| check_modifier(modifier, end_range) }
+        end
+
+        def check_modifier(send_node, end_range)
+          offset = column_offset_between(send_node.source_range, end_range)
+
+          @column_delta = expected_indent_offset - offset
+          if @column_delta.zero?
+            correct_style_detected
+          else
+            add_offense(send_node) do
+              if offset == unexpected_indent_offset
+                opposite_style_detected
+              else
+                unrecognized_style_detected
+              end
+            end
+          end
+        end
+
+        def message(node)
+          format(MSG, style: style.capitalize, node: node.loc.selector.source)
+        end
+
+        def expected_indent_offset
+          style == :outdent ? 0 : configured_indentation_width
+        end
+
+        # An offset that is not expected, but correct if the configuration is
+        # changed.
+        def unexpected_indent_offset
+          configured_indentation_width - expected_indent_offset
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Here we check if the arguments on a multi-line method
+      # definition are aligned.
+      #
+      # @example EnforcedStyle: with_first_argument (default)
+      #   # good
+      #
+      #   foo :bar,
+      #       :baz
+      #
+      #   foo(
+      #     :bar,
+      #     :baz
+      #   )
+      #
+      #   # bad
+      #
+      #   foo :bar,
+      #     :baz
+      #
+      #   foo(
+      #     :bar,
+      #       :baz
+      #   )
+      #
+      # @example EnforcedStyle: with_fixed_indentation
+      #   # good
+      #
+      #   foo :bar,
+      #     :baz
+      #
+      #   # bad
+      #
+      #   foo :bar,
+      #       :baz
+      class ArgumentAlignment < Cop
+        include Alignment
+
+        ALIGN_PARAMS_MSG = 'Align the arguments of a method call if ' \
+          'they span more than one line.'
+
+        FIXED_INDENT_MSG = 'Use one level of indentation for arguments ' \
+          'following the first line of a multi-line method call.'
+
+        def on_send(node)
+          return if node.arguments.size < 2 ||
+                    node.send_type? && node.method?(:[]=)
+
+          check_alignment(node.arguments, base_column(node, node.arguments))
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
+        private
+
+        def message(_node)
+          fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
+        end
+
+        def fixed_indentation?
+          cop_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def base_column(node, args)
+          if fixed_indentation?
+            lineno = target_method_lineno(node)
+            line = node.source_range.source_buffer.source_line(lineno)
+            indentation_of_line = /\S.*/.match(line).begin(0)
+            indentation_of_line + configured_indentation_width
+          else
+            display_column(args.first.source_range)
+          end
+        end
+
+        def target_method_lineno(node)
+          if node.loc.selector
+            node.loc.selector.line
+          else
+            # l.(1) has no selector, so we use the opening parenthesis instead
+            node.loc.begin.line
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Here we check if the elements of a multi-line array literal are
+      # aligned.
+      #
+      # @example
+      #   # bad
+      #   a = [1, 2, 3,
+      #     4, 5, 6]
+      #   array = ['run',
+      #        'forrest',
+      #        'run']
+      #
+      #   # good
+      #   a = [1, 2, 3,
+      #        4, 5, 6]
+      #   a = ['run',
+      #        'forrest',
+      #        'run']
+      class ArrayAlignment < Cop
+        include Alignment
+
+        MSG = 'Align the elements of an array literal if they span more ' \
+              'than one line.'
+
+        def on_array(node)
+          check_alignment(node.children)
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the first line of the
+      # right-hand-side of a multi-line assignment.
+      #
+      # @example
+      #   # bad
+      #   value =
+      #   if foo
+      #     'bar'
+      #   end
+      #
+      #   # good
+      #   value =
+      #     if foo
+      #       'bar'
+      #     end
+      #
+      # The indentation of the remaining lines can be corrected with
+      # other cops such as `IndentationConsistency` and `EndAlignment`.
+      class AssignmentIndentation < Cop
+        include CheckAssignment
+        include Alignment
+
+        MSG = 'Indent the first line of the right-hand-side of a ' \
+              'multi-line assignment.'
+
+        def check_assignment(node, rhs)
+          return unless rhs
+          return unless node.loc.operator
+          return if node.loc.operator.line == rhs.first_line
+
+          base = display_column(leftmost_multiple_assignment(node).source_range)
+          check_alignment([rhs], base + configured_indentation_width)
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
+        def leftmost_multiple_assignment(node)
+          return node unless same_line?(node, node.parent) &&
+                             node.parent.assignment?
+
+          leftmost_multiple_assignment(node.parent)
+
+          node.parent
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether the end keywords are aligned properly for do
+      # end blocks.
+      #
+      # Three modes are supported through the `EnforcedStyleAlignWith`
+      # configuration parameter:
+      #
+      # `start_of_block` : the `end` shall be aligned with the
+      # start of the line where the `do` appeared.
+      #
+      # `start_of_line` : the `end` shall be aligned with the
+      # start of the line where the expression started.
+      #
+      # `either` (which is the default) : the `end` is allowed to be in either
+      # location. The autofixer will default to `start_of_line`.
+      #
+      # @example EnforcedStyleAlignWith: either (default)
+      #   # bad
+      #
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
+      #
+      #   # good
+      #
+      #   variable = lambda do |i|
+      #     i
+      #   end
+      #
+      # @example EnforcedStyleAlignWith: start_of_block
+      #   # bad
+      #
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
+      #
+      #   # good
+      #
+      #   foo.bar
+      #     .each do
+      #       baz
+      #     end
+      #
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
+      #
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
+      #
+      #   # good
+      #
+      #   foo.bar
+      #     .each do
+      #        baz
+      #   end
+      class BlockAlignment < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = '%<current>s is not aligned with %<prefer>s%<alt_prefer>s.'
+
+        def_node_matcher :block_end_align_target?, <<~PATTERN
+          {assignment?
+           splat
+           and
+           or
+           (send _ :<<  ...)
+           (send equal?(%1) !:[] ...)}
+        PATTERN
+
+        def on_block(node)
+          check_block_alignment(start_for_block_node(node), node)
+        end
+
+        def style_parameter_name
+          'EnforcedStyleAlignWith'
+        end
+
+        def autocorrect(node)
+          ancestor_node = start_for_block_node(node)
+          start_col = compute_start_col(ancestor_node, node)
+          loc_end = node.loc.end
+          delta = start_col - loc_end.column
+
+          if delta.positive?
+            add_space_before(loc_end, delta)
+          elsif delta.negative?
+            remove_space_before(loc_end.begin_pos, -delta)
+          end
+        end
+
+        private
+
+        def start_for_block_node(block_node)
+          # Which node should we align the 'end' with?
+          result = block_end_align_target(block_node)
+
+          # In offense message, we want to show the assignment LHS rather than
+          # the entire assignment
+          result, = *result while result.op_asgn_type? || result.masgn_type?
+          result
+        end
+
+        def block_end_align_target(node)
+          lineage = [node, *node.ancestors]
+
+          target = lineage.each_cons(2) do |current, parent|
+            break current if end_align_target?(current, parent)
+          end
+
+          target || lineage.last
+        end
+
+        def end_align_target?(node, parent)
+          disqualified_parent?(parent, node) ||
+            !block_end_align_target?(parent, node)
+        end
+
+        def disqualified_parent?(parent, node)
+          parent&.loc && parent.first_line != node.first_line &&
+            !parent.masgn_type?
+        end
+
+        def check_block_alignment(start_node, block_node)
+          end_loc = block_node.loc.end
+          return unless begins_its_line?(end_loc)
+
+          start_loc = start_node.source_range
+          return unless start_loc.column != end_loc.column ||
+                        style == :start_of_block
+
+          do_source_line_column =
+            compute_do_source_line_column(block_node, end_loc)
+          return unless do_source_line_column
+
+          register_offense(
+            block_node,
+            start_loc,
+            end_loc,
+            do_source_line_column
+          )
+        end
+
+        def register_offense(block_node,
+                             start_loc,
+                             end_loc,
+                             do_source_line_column)
+
+          error_source_line_column = if style == :start_of_block
+                                       do_source_line_column
+                                     else
+                                       loc_to_source_line_column(start_loc)
+                                     end
+
+          message = format_message(start_loc, end_loc, do_source_line_column,
+                                   error_source_line_column)
+
+          add_offense(block_node, location: end_loc, message: message)
+        end
+
+        def format_message(start_loc, end_loc, do_source_line_column,
+                           error_source_line_column)
+          format(
+            MSG,
+            current: format_source_line_column(
+              loc_to_source_line_column(end_loc)
+            ),
+            prefer: format_source_line_column(error_source_line_column),
+            alt_prefer: alt_start_msg(start_loc, do_source_line_column)
+          )
+        end
+
+        def compute_do_source_line_column(node, end_loc)
+          do_loc = node.loc.begin # Actually it's either do or {.
+
+          # We've found that "end" is not aligned with the start node (which
+          # can be a block, a variable assignment, etc). But we also allow
+          # the "end" to be aligned with the start of the line where the "do"
+          # is, which is a style some people use in multi-line chains of
+          # blocks.
+          match = /\S.*/.match(do_loc.source_line)
+          indentation_of_do_line = match.begin(0)
+          return unless end_loc.column != indentation_of_do_line ||
+                        style == :start_of_line
+
+          {
+            source: match[0],
+            line: do_loc.line,
+            column: indentation_of_do_line
+          }
+        end
+
+        def loc_to_source_line_column(loc)
+          {
+            source: loc.source.lines.to_a.first.chomp,
+            line: loc.line,
+            column: loc.column
+          }
+        end
+
+        def alt_start_msg(start_loc, source_line_column)
+          if style != :either
+            ''
+          elsif start_loc.line == source_line_column[:line] &&
+                start_loc.column == source_line_column[:column]
+            ''
+          else
+            ' or ' + format_source_line_column(source_line_column)
+          end
+        end
+
+        def format_source_line_column(source_line_column)
+          "`#{source_line_column[:source]}` at #{source_line_column[:line]}, " \
+          "#{source_line_column[:column]}"
+        end
+
+        def compute_start_col(ancestor_node, node)
+          if style == :start_of_block
+            do_loc = node.loc.begin
+            return do_loc.source_line =~ /\S/
+          end
+          (ancestor_node || node).source_range.column
+        end
+
+        def add_space_before(loc, delta)
+          ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
+        end
+
+        def remove_space_before(end_pos, delta)
+          range = range_between(end_pos - delta, end_pos)
+          ->(corrector) { corrector.remove(range) }
+        end
+      end
+    end
+  end
+end