rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/mixin/def_node.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking def nodes.
+    module DefNode
+      extend NodePattern::Macros
+
+      NON_PUBLIC_MODIFIERS = %w[private protected].freeze
+
+      private
+
+      def non_public?(node)
+        non_public_modifier?(node.parent) ||
+          preceding_non_public_modifier?(node)
+      end
+
+      def preceding_non_public_modifier?(node)
+        stripped_source_upto(node.first_line).any? do |line|
+          NON_PUBLIC_MODIFIERS.include?(line)
+        end
+      end
+
+      def_node_matcher :non_public_modifier?, <<-PATTERN
+        (send nil? {:private :protected} ({def defs} ...))
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/mixin/documentation_comment.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking documentation.
+    module DocumentationComment
+      extend NodePattern::Macros
+      include Style::AnnotationComment
+
+      private
+
+      def_node_matcher :constant_definition?, '{class module casgn}'
+
+      def documentation_comment?(node)
+        preceding_lines = preceding_lines(node)
+
+        return false unless preceding_comment?(node, preceding_lines.last)
+
+        preceding_lines.any? do |comment|
+          !annotation?(comment) &&
+            !interpreter_directive_comment?(comment) &&
+            !rubocop_directive_comment?(comment)
+        end
+      end
+
+      def preceding_comment?(n1, n2)
+        n1 && n2 && precede?(n2, n1) &&
+          comment_line?(n2.loc.expression.source)
+      end
+
+      def preceding_lines(node)
+        processed_source.ast_with_comments[node].select do |line|
+          line.loc.line < node.loc.line
+        end
+      end
+
+      def interpreter_directive_comment?(comment)
+        comment.text =~ /^#\s*(frozen_string_literal|encoding):/
+      end
+
+      def rubocop_directive_comment?(comment)
+        comment.text =~ CommentConfig::COMMENT_DIRECTIVE_REGEXP
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/duplication.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for dealing with duplication.
+    module Duplication
+      private
+
+      # Whether the `collection` contains any duplicates.
+      #
+      # @param [Array] collection an array to check for duplicates
+      # @return [Boolean] whether the array contains any duplicates
+      def duplicates?(collection)
+        collection.size > 1 && collection.size > collection.uniq.size
+      end
+
+      # Returns all duplicates, including the first instance of the duplicated
+      # elements.
+      #
+      # @param [Array] collection an array to return duplicates for
+      # @return [Array] all the duplicates
+      def duplicates(collection)
+        grouped_duplicates(collection).flatten
+      end
+
+      # Returns the consecutive duplicates, leaving out the first instance of
+      # the duplicated elements.
+      #
+      # @param [Array] collection an array to return consecutive duplicates for
+      # @return [Array] the consecutive duplicates
+      def consecutive_duplicates(collection)
+        grouped_duplicates(collection).flat_map { |items| items[1..-1] }
+      end
+
+      # Returns a hash of grouped duplicates. The key will be the first
+      # instance of the element, and  the value an `array` of the initial
+      # element and all duplicate instances.
+      #
+      # @param [Array] collection an array to group duplicates for
+      # @return [Array] the grouped duplicates
+      def grouped_duplicates(collection)
+        collection.group_by { |item| item }.values.reject(&:one?)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/empty_lines_around_body.rb

@@ -1,28 +1,25 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Common functionality for checking if presence/absence of empty lines
       # around some kind of body matches the configuration.
       module EmptyLinesAroundBody
+        extend NodePattern::Macros
         include ConfigurableEnforcedStyle
 
-        MSG_EXTRA = 'Extra empty line detected at %s body %s.'.freeze
-        MSG_MISSING = 'Empty line missing at %s body %s.'.freeze
-
-        def autocorrect(range)
-          lambda do |corrector|
-            case style
-            when :no_empty_lines then corrector.remove(range)
-            when :empty_lines    then corrector.insert_before(range, "\n")
-            end
-          end
-        end
+        MSG_EXTRA = 'Extra empty line detected at %<kind>s body ' \
+                    '%<location>s.'.freeze
+        MSG_MISSING = 'Empty line missing at %<kind>s body %<location>s.'.freeze
+        MSG_DEFERRED = 'Empty line missing before first %<type>s ' \
+                       'definition'.freeze
 
         private
 
+        def_node_matcher :constant_definition?, '{class module}'
+        def_node_matcher :empty_line_required?, '{def defs class module}'
+
         def check(node, body)
           # When style is `empty_lines`, if the body is empty, we don't enforce
           # the presence OR absence of an empty line
@@ -30,33 +27,128 @@ module RuboCop
           return unless body || style == :no_empty_lines
           return if node.single_line?
 
-          check_source(node.loc.expression.first_line,
-                       node.loc.expression.last_line)
+          first_line = node.source_range.first_line
+          last_line = node.source_range.last_line
+
+          case style
+          when :empty_lines_except_namespace
+            check_empty_lines_except_namespace(body, first_line, last_line)
+          when :empty_lines_special
+            check_empty_lines_special(body, first_line, last_line)
+          else
+            check_both(style, first_line, last_line)
+          end
+        end
+
+        def check_empty_lines_except_namespace(body, first_line, last_line)
+          if namespace?(body, with_one_child: true)
+            check_both(:no_empty_lines, first_line, last_line)
+          else
+            check_both(:empty_lines, first_line, last_line)
+          end
+        end
+
+        def check_empty_lines_special(body, first_line, last_line)
+          return unless body
+          if namespace?(body, with_one_child: true)
+            check_both(:no_empty_lines, first_line, last_line)
+          else
+            if first_child_requires_empty_line?(body)
+              check_beginning(:empty_lines, first_line)
+            else
+              check_beginning(:no_empty_lines, first_line)
+              check_deferred_empty_line(body)
+            end
+            check_ending(:empty_lines, last_line)
+          end
+        end
+
+        def check_both(style, first_line, last_line)
+          check_beginning(style, first_line)
+          check_ending(style, last_line)
         end
 
-        def check_source(start_line, end_line)
+        def check_beginning(style, first_line)
+          check_source(style, first_line, 'beginning')
+        end
+
+        def check_ending(style, last_line)
+          check_source(style, last_line - 2, 'end')
+        end
+
+        def check_source(style, line_no, desc)
           case style
           when :no_empty_lines
-            check_both(start_line, end_line, MSG_EXTRA, &:empty?)
+            check_line(style, line_no, message(MSG_EXTRA, desc), &:empty?)
           when :empty_lines
-            check_both(start_line, end_line, MSG_MISSING) do |line|
+            check_line(style, line_no, message(MSG_MISSING, desc)) do |line|
               !line.empty?
             end
           end
         end
 
-        def check_both(start_line, end_line, msg, &block)
-          kind = self.class::KIND
-          check_line(start_line, format(msg, kind, 'beginning'), &block)
-          check_line(end_line - 2, format(msg, kind, 'end'), &block)
-        end
-
-        def check_line(line, msg)
-          return unless yield processed_source.lines[line]
+        def check_line(style, line, msg)
+          return unless yield(processed_source.lines[line])
 
           offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
           range = source_range(processed_source.buffer, line + offset, 0)
-          add_offense(range, range, msg)
+          add_offense([style, range], location: range, message: msg)
+        end
+
+        def check_deferred_empty_line(body)
+          node = first_empty_line_required_child(body)
+          return unless node
+
+          line = previous_line_ignoring_comments(node.first_line)
+          return if processed_source[line].empty?
+
+          range = source_range(processed_source.buffer, line + 2, 0)
+
+          add_offense(
+            [:empty_lines, range],
+            location: range,
+            message: deferred_message(node)
+          )
+        end
+
+        def namespace?(body, with_one_child: false)
+          if body.begin_type?
+            return false if with_one_child
+            body.children.all? { |child| constant_definition?(child) }
+          else
+            constant_definition?(body)
+          end
+        end
+
+        def first_child_requires_empty_line?(body)
+          if body.begin_type?
+            empty_line_required?(body.children.first)
+          else
+            empty_line_required?(body)
+          end
+        end
+
+        def first_empty_line_required_child(body)
+          if body.begin_type?
+            body.children.find { |child| empty_line_required?(child) }
+          elsif empty_line_required?(body)
+            body
+          end
+        end
+
+        def previous_line_ignoring_comments(send_line)
+          (send_line - 2).downto(0) do |line|
+            return line unless comment_line?(processed_source[line])
+          end
+          0
+        end
+
+        def message(type, desc)
+          format(type, kind: self.class::KIND, location: desc)
+        end
+
+        def deferred_message(node)
+          format(MSG_DEFERRED, type: node.type)
         end
       end
     end

data/lib/rubocop/cop/mixin/empty_parameter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for empty parameter cops.
+    module EmptyParameter
+      extend NodePattern::Macros
+
+      private
+
+      def_node_matcher :empty_arguments?, <<-PATTERN
+        (block _ $(args) _)
+      PATTERN
+
+      def check(node)
+        empty_arguments?(node) do |args|
+          return if args.empty_and_without_delimiters?
+          add_offense(args)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,7 +6,8 @@ module RuboCop
     module EndKeywordAlignment
       include ConfigurableEnforcedStyle
 
-      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'.freeze
+      MSG = '`end` at %<end_line>d, %<end_col>d is not aligned with ' \
+            '`%<source>s` at %<align_line>d, %<align_col>d.'.freeze
 
       private
 
@@ -40,13 +40,16 @@ module RuboCop
 
       def add_offense_for_misalignment(node, align_with)
         end_loc = node.loc.end
-        msg = format(MSG, end_loc.line, end_loc.column, align_with.source,
-                     align_with.line, align_with.column)
-        add_offense(node, end_loc, msg)
+        msg = format(MSG, end_line: end_loc.line,
+                          end_col: end_loc.column,
+                          source: align_with.source,
+                          align_line: align_with.line,
+                          align_col: align_with.column)
+        add_offense(node, location: end_loc, message: msg)
       end
 
-      def parameter_name
-        'AlignWith'
+      def style_parameter_name
+        'EnforcedStyleAlignWith'
       end
 
       def variable_alignment?(whole_expression, rhs, end_alignment_style)
@@ -55,26 +58,7 @@ module RuboCop
       end
 
       def line_break_before_keyword?(whole_expression, rhs)
-        rhs.loc.line > whole_expression.line
-      end
-
-      def align(node, align_to)
-        source_buffer = node.source_range.source_buffer
-        begin_pos = node.loc.end.begin_pos
-        whitespace = Parser::Source::Range.new(source_buffer,
-                                               begin_pos - node.loc.end.column,
-                                               begin_pos)
-        return false unless whitespace.source.strip.empty?
-
-        column = if !align_to
-                   0
-                 elsif align_to.respond_to?(:loc)
-                   align_to.source_range.column
-                 else
-                   align_to.column
-                 end
-
-        ->(corrector) { corrector.replace(whitespace, ' ' * column) }
+        rhs.first_line > whole_expression.line
       end
     end
   end

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for enforcing a specific superclass
+    module EnforceSuperclass
+      def self.included(base)
+        base.def_node_matcher :class_definition, <<-PATTERN
+        (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
+        PATTERN
+
+        base.def_node_matcher :class_new_definition, <<-PATTERN
+        [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
+        PATTERN
+      end
+
+      def on_class(node)
+        class_definition(node) do
+          add_offense(node.children[1])
+        end
+      end
+
+      def on_send(node)
+        class_new_definition(node) do
+          add_offense(node.children.last)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/first_element_line_break.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,10 +5,6 @@ module RuboCop
     # Common functionality for checking for a line break before the first
     # element in a multi-line collection.
     module FirstElementLineBreak
-      def autocorrect(node)
-        ->(corrector) { corrector.insert_before(node.source_range, "\n") }
-      end
-
       private
 
       def check_method_line_break(node, children)
@@ -28,14 +23,23 @@ module RuboCop
       def check_children_line_break(node, children, start = node)
         return if children.size < 2
 
-        line = start.loc.line
-        min = children.min_by { |n| n.loc.first_line }
-        return if line != min.loc.first_line
+        line = start.first_line
+
+        min = first_by_line(children)
+        return if line != min.first_line
+
+        max = last_by_line(children)
+        return if line == max.last_line
 
-        max = children.max_by { |n| n.loc.last_line }
-        return if line == max.loc.last_line
+        add_offense(min)
+      end
+
+      def first_by_line(nodes)
+        nodes.min_by(&:first_line)
+      end
 
-        add_offense(min, :expression, self.class::MSG)
+      def last_by_line(nodes)
+        nodes.max_by(&:last_line)
       end
     end
   end

data/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,26 +8,29 @@ module RuboCop
 
       FROZEN_STRING_LITERAL = '# frozen_string_literal:'.freeze
       FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'.freeze
-      FROZEN_STRING_LITERAL_TYPES = [:str, :dstr].freeze
+      FROZEN_STRING_LITERAL_TYPES = %i[str dstr].freeze
 
-      def frozen_string_literal_comment_exists?(processed_source,
-                                                comment = FROZEN_STRING_LITERAL)
-        first_three_lines =
-          [processed_source[0], processed_source[1], processed_source[2]]
-        first_three_lines.compact!
-        first_three_lines.any? do |line|
-          line.start_with?(comment)
+      def frozen_string_literal_comment_exists?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal_specified?
         end
       end
 
-      def frozen_string_literals_enabled?(processed_source)
+      private
+
+      def frozen_string_literals_enabled?
         ruby_version = processed_source.ruby_version
         return false unless ruby_version
         return true if ruby_version >= 3.0
         return false unless ruby_version >= 2.3
-        frozen_string_literal_comment_exists?(
-          processed_source, FROZEN_STRING_LITERAL_ENABLED
-        )
+
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal?
+        end
+      end
+
+      def leading_comment_lines
+        processed_source[0..2].compact
       end
     end
   end

data/lib/rubocop/cop/mixin/hash_alignment.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking hash alignment.
+    module HashAlignment
+      # Handles calculation of deltas when the enforced style is 'key'.
+      class KeyAlignment
+        def checkable_layout?(_node)
+          true
+        end
+
+        def deltas_for_first_pair(*)
+          {}
+        end
+
+        def deltas(first_pair, current_pair)
+          if Util.begins_its_line?(current_pair.source_range)
+            { key: first_pair.key_delta(current_pair) }
+          else
+            {}
+          end
+        end
+      end
+
+      # Common functionality for checking alignment of hash values.
+      module ValueAlignment
+        def checkable_layout?(node)
+          !node.pairs_on_same_line? && !node.mixed_delimiters?
+        end
+
+        def deltas(first_pair, current_pair)
+          key_delta = key_delta(first_pair, current_pair)
+          separator_delta = separator_delta(first_pair, current_pair,
+                                            key_delta)
+          value_delta = value_delta(first_pair, current_pair) -
+                        key_delta - separator_delta
+
+          { key: key_delta, separator: separator_delta, value: value_delta }
+        end
+
+        private
+
+        def separator_delta(first_pair, current_pair, key_delta)
+          if current_pair.hash_rocket?
+            hash_rocket_delta(first_pair, current_pair) - key_delta
+          else
+            0
+          end
+        end
+      end
+
+      # Handles calculation of deltas when the enforced style is 'table'.
+      class TableAlignment
+        include ValueAlignment
+
+        # The table style is the only one where the first key-value pair can
+        # be considered to have bad alignment.
+        def deltas_for_first_pair(first_pair, node)
+          self.max_key_width = node.keys.map { |key| key.source.length }.max
+
+          separator_delta = separator_delta(first_pair, first_pair, 0)
+          {
+            separator: separator_delta,
+            value: value_delta(first_pair, first_pair) - separator_delta
+          }
+        end
+
+        private
+
+        attr_accessor :max_key_width
+
+        def key_delta(first_pair, current_pair)
+          first_pair.key_delta(current_pair)
+        end
+
+        def hash_rocket_delta(first_pair, current_pair)
+          first_pair.loc.column + max_key_width + 1 -
+            current_pair.loc.operator.column
+        end
+
+        def value_delta(first_pair, current_pair)
+          return 0 if current_pair.kwsplat_type?
+
+          correct_value_column = first_pair.key.loc.column +
+                                 current_pair.delimiter(true).length +
+                                 max_key_width
+          correct_value_column - current_pair.value.loc.column
+        end
+      end
+
+      # Handles calculation of deltas when the enforced style is 'separator'.
+      class SeparatorAlignment
+        include ValueAlignment
+
+        def deltas_for_first_pair(*)
+          {}
+        end
+
+        private
+
+        def key_delta(first_pair, current_pair)
+          first_pair.key_delta(current_pair, :right)
+        end
+
+        def hash_rocket_delta(first_pair, current_pair)
+          first_pair.delimiter_delta(current_pair)
+        end
+
+        def value_delta(first_pair, current_pair)
+          first_pair.value_delta(current_pair)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/heredoc.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for working with heredoc strings.
+    module Heredoc
+      OPENING_DELIMITER = /<<[~-]?['"`]?([^'"`]+)['"`]?/
+
+      def on_str(node)
+        return unless node.heredoc?
+
+        on_heredoc(node)
+      end
+      alias on_dstr on_str
+      alias on_xstr on_str
+
+      def on_heredoc(_node)
+        raise NotImplementedError
+      end
+
+      private
+
+      def delimiter_string(node)
+        node.source.match(OPENING_DELIMITER).captures.first
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/ignored_pattern.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to ignore certain lines when
+    # parsing.
+    module IgnoredPattern
+      private
+
+      def ignored_line?(line)
+        line = if line.respond_to?(:source_line)
+                 line.source_line
+               elsif line.respond_to?(:node)
+                 line.node.source_range.source_line
+               end
+
+        matches_ignored_pattern?(line)
+      end
+
+      def matches_ignored_pattern?(line)
+        ignored_patterns.any? { |pattern| Regexp.new(pattern).match(line) }
+      end
+
+      def ignored_patterns
+        cop_config['IgnoredPatterns'] || []
+      end
+    end
+  end
+end