rubocop 0.89.0 → 0.92.0

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for working with nodes containing comments.
+    module CommentsHelp
+      include VisibilityHelp
+
+      def source_range_with_comment(node)
+        begin_pos = begin_pos_with_comment(node)
+        end_pos = end_position_for(node)
+        end_pos += 1 if node.def_type?
+
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      private
+
+      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
+
+        processed_source.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 buffer
+        processed_source.buffer
+      end
+    end
+  end
+end

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

@@ -8,8 +8,8 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case: /^@{0,2}[\da-z_]+[!?=]?$/,
-        camelCase:  /^@{0,2}(?:_|_?[a-z][\da-zA-Z]*)[!?=]?$/
+        snake_case: /^@{0,2}[\d[[:lower:]]_]+[!?=]?$/,
+        camelCase:  /^@{0,2}(?:_|_?[[[:lower:]]][\d[[:lower:]][[:upper:]]]*)[!?=]?$/
       }.freeze
     end
   end

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

@@ -8,9 +8,9 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case:  /(?:[a-z_]|_\d+)$/,
-        normalcase:  /(?:_\D*|[A-Za-z]\d*)$/,
-        non_integer: /[A-Za-z_]$/
+        snake_case:  /(?:[[[:lower:]]_]|_\d+)$/,
+        normalcase:  /(?:_\D*|[[[:upper:]][[:lower:]]]\d*)$/,
+        non_integer: /[[[:upper:]][[:lower:]]_]$/
       }.freeze
     end
   end

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

@@ -19,7 +19,8 @@ module RuboCop
         private
 
         def_node_matcher :constant_definition?, '{class module}'
-        def_node_matcher :empty_line_required?, '{def defs class module}'
+        def_node_matcher :empty_line_required?,
+                         '{def defs class module (send nil? {:private :protected :public})}'
 
         def check(node, body, adjusted_first_line: nil)
           return if valid_body_style?(body)
@@ -100,7 +101,9 @@ module RuboCop
 
           offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
           range = source_range(processed_source.buffer, line + offset, 0)
-          add_offense([style, range], location: range, message: msg)
+          add_offense(range, message: msg) do |corrector|
+            EmptyLineCorrector.correct(corrector, [style, range])
+          end
         end
 
         def check_deferred_empty_line(body)
@@ -112,11 +115,9 @@ module RuboCop
 
           range = source_range(processed_source.buffer, line + 2, 0)
 
-          add_offense(
-            [:empty_lines, range],
-            location: range,
-            message: deferred_message(node)
-          )
+          add_offense(range, message: deferred_message(node)) do |corrector|
+            EmptyLineCorrector.correct(corrector, [:empty_lines, range])
+          end
         end
 
         def namespace?(body, with_one_child: false)

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

@@ -16,7 +16,9 @@ module RuboCop
         empty_arguments?(node) do |args|
           return if args.empty_and_without_delimiters?
 
-          add_offense(args)
+          add_offense(args) do |corrector|
+            autocorrect(corrector, args)
+          end
         end
       end
     end

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

@@ -39,6 +39,15 @@ module RuboCop
         end
       end
 
+      def start_line_range(node)
+        expr   = node.source_range
+        buffer = expr.source_buffer
+        source = buffer.source_line(expr.line)
+        range  = buffer.line_range(expr.line)
+
+        range_between(range.begin_pos + (source =~ /\S/), range.begin_pos + (source =~ /\s*\z/))
+      end
+
       def add_offense_for_misalignment(node, align_with)
         end_loc = node.loc.end
         msg = format(MSG, end_line: end_loc.line,
@@ -46,7 +55,9 @@ module RuboCop
                           source: align_with.source,
                           align_line: align_with.line,
                           align_col: align_with.column)
-        add_offense(node, location: end_loc, message: msg)
+        add_offense(end_loc, message: msg) do |corrector|
+          autocorrect(corrector, node)
+        end
       end
 
       def accept_end_kw_alignment?(end_loc)

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

@@ -5,8 +5,6 @@ module RuboCop
     # Common functionality for enforcing a specific superclass
     module EnforceSuperclass
       def self.included(base)
-        super
-
         base.def_node_matcher :class_definition, <<~PATTERN
           (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
         PATTERN

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

@@ -31,7 +31,9 @@ module RuboCop
         max = last_by_line(children)
         return if line == max.last_line
 
-        add_offense(min)
+        add_offense(min) do |corrector|
+          EmptyLineCorrector.insert_before(corrector, min)
+        end
       end
 
       def first_by_line(nodes)

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

@@ -4,11 +4,25 @@ module RuboCop
   module Cop
     # Common functionality for Style/HashTransformKeys and
     # Style/HashTransformValues
-    module HashTransformMethod
+    module HashTransformMethod # rubocop:disable Metrics/ModuleLength
+      extend NodePattern::Macros
+
+      RESTRICT_ON_SEND = %i[[] to_h].freeze
+
+      def_node_matcher :array_receiver?, <<~PATTERN
+        {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
+      PATTERN
+
       def on_block(node)
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
+
+        return if target_ruby_version < 2.6
+
+        on_bad_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'to_h {...}')
+        end
       end
 
       def on_send(node)
@@ -26,13 +40,6 @@ module RuboCop
         end
       end
 
-      def autocorrect(node)
-        lambda do |corrector|
-          correction = prepare_correction(node)
-          execute_correction(corrector, node, correction)
-        end
-      end
-
       private
 
       # @abstract Implemented with `def_node_matcher`
@@ -50,6 +57,11 @@ module RuboCop
         raise NotImplementedError
       end
 
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_to_h(_node)
+        raise NotImplementedError
+      end
+
       def handle_possible_offense(node, match, match_desc)
         captures = extract_captures(match)
 
@@ -61,10 +73,11 @@ module RuboCop
         # `transform_values` if value transformation uses key.
         return if captures.transformation_uses_both_args?
 
-        add_offense(
-          node,
-          message: "Prefer `#{new_method_name}` over `#{match_desc}`."
-        )
+        message = "Prefer `#{new_method_name}` over `#{match_desc}`."
+        add_offense(node, message: message) do |corrector|
+          correction = prepare_correction(node)
+          execute_correction(corrector, node, correction)
+        end
       end
 
       # @abstract
@@ -88,6 +101,8 @@ module RuboCop
           Autocorrection.from_hash_brackets_map(node, match)
         elsif (match = on_bad_map_to_h(node))
           Autocorrection.from_map_to_h(node, match)
+        elsif (match = on_bad_to_h(node))
+          Autocorrection.from_to_h(node, match)
         else
           raise 'unreachable'
         end
@@ -143,6 +158,10 @@ module RuboCop
           new(match, node.children.first, 0, strip_trailing_chars)
         end
 
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
         def strip_prefix_and_suffix(node, corrector)
           expression = node.loc.expression
           corrector.remove_leading(expression, leading)

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

@@ -12,9 +12,7 @@ module RuboCop
 
       def directive_on_source_line?(line_index)
         source_line_number = line_index + processed_source.buffer.first_line
-        comment =
-          processed_source.comments
-                          .detect { |e| e.location.line == source_line_number }
+        comment = processed_source.comment_at_line(source_line_number)
 
         return false unless comment
 

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

@@ -16,7 +16,9 @@ module RuboCop
         last_seen_line = -1
         children.each do |child|
           if last_seen_line >= child.first_line
-            add_offense(child)
+            add_offense(child) do |corrector|
+              EmptyLineCorrector.insert_before(corrector, child)
+            end
           else
             last_seen_line = child.last_line
           end

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

@@ -27,8 +27,7 @@ module RuboCop
         last_element_line =
           last_element_range_with_trailing_comma(node).last_line
 
-        last_element_commented =
-          processed_source.comments.any? { |c| c.loc.line == last_element_line }
+        last_element_commented = processed_source.comment_at_line(last_element_line)
 
         last_element_commented && (node.chained? || node.argument?)
       end
@@ -44,30 +43,32 @@ module RuboCop
       def check_new_line(node)
         return unless closing_brace_on_same_line?(node)
 
-        add_offense(node,
-                    location: :end,
-                    message: self.class::ALWAYS_NEW_LINE_MESSAGE)
+        add_offense(node.loc.end, message: self.class::ALWAYS_NEW_LINE_MESSAGE) do |corrector|
+          MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+        end
       end
 
       def check_same_line(node)
         return if closing_brace_on_same_line?(node)
 
-        add_offense(node,
-                    location: :end,
-                    message: self.class::ALWAYS_SAME_LINE_MESSAGE)
+        add_offense(node.loc.end, message: self.class::ALWAYS_SAME_LINE_MESSAGE) do |corrector|
+          MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+        end
       end
 
       def check_symmetrical(node)
         if opening_brace_on_same_line?(node)
           return if closing_brace_on_same_line?(node)
 
-          add_offense(node, location: :end,
-                            message: self.class::SAME_LINE_MESSAGE)
+          add_offense(node.loc.end, message: self.class::SAME_LINE_MESSAGE) do |corrector|
+            MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+          end
         else
           return unless closing_brace_on_same_line?(node)
 
-          add_offense(node, location: :end,
-                            message: self.class::NEW_LINE_MESSAGE)
+          add_offense(node.loc.end, message: self.class::NEW_LINE_MESSAGE) do |corrector|
+            MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+          end
         end
       end
 

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

@@ -15,7 +15,7 @@ module RuboCop
       def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
       def_node_matcher :empty_condition?, '(begin)'
 
-      def check_negative_conditional(node)
+      def check_negative_conditional(node, message:, &block)
         condition = node.condition
 
         return if empty_condition?(condition)
@@ -25,7 +25,7 @@ module RuboCop
         return unless single_negative?(condition)
         return if node.if_type? && node.else?
 
-        add_offense(node)
+        add_offense(node, message: message, &block)
       end
     end
   end

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

@@ -28,24 +28,31 @@ module RuboCop
       end
 
       def comments_in_array?(node)
-        comments = processed_source.comments
-        array_range = node.source_range.to_a
-
-        comments.any? do |comment|
-          !(comment.loc.expression.to_a & array_range).empty?
-        end
+        line_span = node.source_range.first_line...node.source_range.last_line
+        processed_source.each_comment_in_lines(line_span).any?
       end
 
       def check_percent_array(node)
         array_style_detected(:percent, node.values.size)
-        add_offense(node) if style == :brackets
+
+        return unless style == :brackets
+
+        add_offense(node) do |corrector|
+          correct_bracketed(corrector, node)
+        end
       end
 
-      def check_bracketed_array(node)
+      def check_bracketed_array(node, literal_prefix)
         return if allowed_bracket_array?(node)
 
         array_style_detected(:brackets, node.values.size)
-        add_offense(node) if style == :percent
+
+        return unless style == :percent
+
+        add_offense(node) do |corrector|
+          percent_literal_corrector = PercentLiteralCorrector.new(@config, @preferred_delimiters)
+          percent_literal_corrector.correct(corrector, node, literal_prefix)
+        end
       end
     end
   end

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

@@ -46,7 +46,8 @@ module RuboCop
       end
 
       def range_with_surrounding_space(range:, side: :both,
-                                       newlines: true, whitespace: false)
+                                       newlines: true, whitespace: false,
+                                       continuations: false)
         buffer = @processed_source.buffer
         src = buffer.source
 
@@ -55,10 +56,13 @@ module RuboCop
         begin_pos = range.begin_pos
         if go_left
           begin_pos =
-            final_pos(src, begin_pos, -1, newlines, whitespace)
+            final_pos(src, begin_pos, -1, continuations, newlines, whitespace)
         end
         end_pos = range.end_pos
-        end_pos = final_pos(src, end_pos, 1, newlines, whitespace) if go_right
+        if go_right
+          end_pos =
+            final_pos(src, end_pos, 1, continuations, newlines, whitespace)
+        end
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
@@ -101,17 +105,27 @@ module RuboCop
         end
       end
 
-      def final_pos(src, pos, increment, newlines, whitespace)
+      # rubocop:disable Metrics/ParameterLists
+      def final_pos(src, pos, increment, continuations, newlines, whitespace)
         pos = move_pos(src, pos, increment, true, /[ \t]/)
+        pos = move_pos_str(src, pos, increment, continuations, "\\\n")
         pos = move_pos(src, pos, increment, newlines, /\n/)
         move_pos(src, pos, increment, whitespace, /\s/)
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def move_pos(src, pos, step, condition, regexp)
         offset = step == -1 ? -1 : 0
         pos += step while condition && regexp.match?(src[pos + offset])
         pos.negative? ? 0 : pos
       end
+
+      def move_pos_str(src, pos, step, condition, needle)
+        size = needle.length
+        offset = step == -1 ? -size : 0
+        pos += size * step while condition && src[pos + offset, size] == needle
+        pos.negative? ? 0 : pos
+      end
     end
   end
 end