rubocop 0.56.0 → 0.57.0

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      #
+      # Checks the indentation of here document closings.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     def bar
+      #       <<~SQL
+      #         'Hi'
+      #     SQL
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def bar
+      #       <<~SQL
+      #         'Hi'
+      #       SQL
+      #     end
+      #   end
+      #
+      #   # bad
+      #
+      #   # heredoc contents is before closing heredoc.
+      #   foo arg,
+      #       <<~EOS
+      #     Hi
+      #       EOS
+      #
+      #   # good
+      #   foo arg,
+      #       <<~EOS
+      #     Hi
+      #   EOS
+      #
+      #   # good
+      #   foo arg,
+      #       <<~EOS
+      #         Hi
+      #       EOS
+      #
+      class ClosingHeredocIndentation < Cop
+        include Heredoc
+
+        MSG = '`%<closing>s` is not aligned with `%<opening>s`.'.freeze
+        MSG_ARG = '`%<closing>s` is not aligned with `%<opening>s` or ' \
+                  'beginning of method definition.'.freeze
+
+        def on_heredoc(node)
+          if node.loc.heredoc_body.source.empty? ||
+             contents_indentation(node) >= closing_indentation(node)
+            return if opening_indentation(node) == closing_indentation(node)
+            return if node.argument? &&
+                      opening_indentation(
+                        find_node_used_heredoc_argument(node.parent)
+                      ) == closing_indentation(node)
+          end
+
+          add_offense(node, location: :heredoc_end)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.heredoc_end, indented_end(node))
+          end
+        end
+
+        private
+
+        def opening_indentation(node)
+          indent_level(heredoc_opening(node))
+        end
+
+        def contents_indentation(node)
+          source_lines = node.loc.heredoc_body.source.split("\n")
+
+          source_lines.reject(&:empty?).map do |line|
+            indent_level(line)
+          end.min
+        end
+
+        def closing_indentation(node)
+          indent_level(heredoc_closing(node))
+        end
+
+        def heredoc_opening(node)
+          node.loc.expression.source_line
+        end
+
+        def heredoc_closing(node)
+          node.loc.heredoc_end.source_line
+        end
+
+        def indented_end(node)
+          closing_indent = closing_indentation(node)
+          opening_indent = opening_indentation(node)
+          closing_text = heredoc_closing(node)
+          closing_text.gsub(/^\s{#{closing_indent}}/, ' ' * opening_indent)
+        end
+
+        def find_node_used_heredoc_argument(node)
+          if node.parent && node.parent.send_type?
+            find_node_used_heredoc_argument(node.parent)
+          else
+            node
+          end
+        end
+
+        def message(node)
+          format(
+            node.argument? ? MSG_ARG : MSG,
+            closing: heredoc_closing(node).strip,
+            opening: heredoc_opening(node).strip
+          )
+        end
+
+        def indent_level(source_line)
+          source_line[/\A */].length
+        end
+      end
+    end
+  end
+end

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

@@ -89,12 +89,8 @@ module RuboCop
         end
 
         def selector_range(node)
-          if node.loc.selector
-            node.loc.selector
-          else
-            # l.(1) has no selector, so we use the opening parenthesis instead
-            node.loc.begin
-          end
+          # l.(1) has no selector, so we use the opening parenthesis instead
+          node.loc.selector || node.loc.begin
         end
       end
     end

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

@@ -30,7 +30,7 @@ module RuboCop
                                '`%<modifier>s`.'.freeze
 
         def on_send(node)
-          return unless node.access_modifier?
+          return unless node.bare_access_modifier?
 
           return if empty_lines_around?(node)
 

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

@@ -1,4 +1,3 @@
-
 # frozen_string_literal: true
 
 module RuboCop

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

@@ -13,12 +13,12 @@ module RuboCop
       #   name      = "RuboCop"
       #   # Some comment and an empty line
       #
-      #   website  += "/bbatsov/rubocop" unless cond
+      #   website  += "/rubocop-hq/rubocop" unless cond
       #   puts        "rubocop"          if     debug
       #
       #   # bad for any configuration
       #   set_app("RuboCop")
-      #   website  = "https://github.com/bbatsov/rubocop"
+      #   website  = "https://github.com/rubocop-hq/rubocop"
       class ExtraSpacing < Cop
         include PrecedingFollowingAlignment
         include RangeHelp

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

@@ -8,7 +8,7 @@ module RuboCop
       # In Ruby 2.3 or newer, squiggly heredocs (`<<~`) should be used. If you
       # use the older rubies, you should introduce some library to your project
       # (e.g. ActiveSupport, Powerpack or Unindent).
-      # Note: When `Metrics/LineLength`'s `AllowHeredoc` is false(not default),
+      # Note: When `Metrics/LineLength`'s `AllowHeredoc` is false (not default),
       #       this cop does not add any offenses for long here documents to
       #       avoid `Metrics/LineLength`'s offenses.
       #
@@ -193,15 +193,24 @@ module RuboCop
           return if target_ruby_version < 2.3
           lambda do |corrector|
             if heredoc_indent_type(node) == '~'
-              corrector.replace(node.loc.heredoc_body, indented_body(node))
+              adjust_squiggly(corrector, node)
             else
-              heredoc_beginning = node.loc.expression.source
-              corrected = heredoc_beginning.sub(/<<-?/, '<<~')
-              corrector.replace(node.loc.expression, corrected)
+              adjust_minus(corrector, node)
             end
           end
         end
 
+        def adjust_squiggly(corrector, node)
+          corrector.replace(node.loc.heredoc_body, indented_body(node))
+          corrector.replace(node.loc.heredoc_end, indented_end(node))
+        end
+
+        def adjust_minus(corrector, node)
+          heredoc_beginning = node.loc.expression.source
+          corrected = heredoc_beginning.sub(/<<-?/, '<<~')
+          corrector.replace(node.loc.expression, corrected)
+        end
+
         def correct_by_library(node)
           lambda do |corrector|
             corrector.replace(node.loc.heredoc_body, indented_body(node))
@@ -230,6 +239,17 @@ module RuboCop
           body.gsub(/^\s{#{body_indent_level}}/, ' ' * correct_indent_level)
         end
 
+        def indented_end(node)
+          end_ = heredoc_end(node)
+          end_indent_level = indent_level(end_)
+          correct_indent_level = base_indent_level(node)
+          if end_indent_level < correct_indent_level
+            end_.gsub(/^\s{#{end_indent_level}}/, ' ' * correct_indent_level)
+          else
+            end_
+          end
+        end
+
         def base_indent_level(node)
           base_line_num = node.loc.expression.line
           base_line = processed_source.lines[base_line_num - 1]
@@ -255,6 +275,10 @@ module RuboCop
         def heredoc_body(node)
           node.loc.heredoc_body.source.scrub
         end
+
+        def heredoc_end(node)
+          node.loc.heredoc_end.source.scrub
+        end
       end
     end
   end

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

@@ -144,7 +144,7 @@ module RuboCop
             # the AccessModifierIndentation cop. This cop uses them as dividers
             # in rails mode. Then consistency is checked only within each
             # section delimited by a modifier node.
-            if child.send_type? && child.access_modifier?
+            if child.send_type? && child.bare_access_modifier?
               children_to_check << [] if style == :rails
             else
               children_to_check.last << child

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

@@ -173,7 +173,7 @@ module RuboCop
         end
 
         def special_modifier?(node)
-          node.access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
+          node.bare_access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
         end
 
         def indentation_consistency_style
@@ -307,7 +307,7 @@ module RuboCop
           return unless body_node.begin_type?
 
           starting_node = body_node.children.first
-          starting_node.send_type? && starting_node.access_modifier?
+          starting_node.send_type? && starting_node.bare_access_modifier?
         end
 
         def configured_indentation_width

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for unnecessary leading blank lines at the beginning
+      # of a file.
+      #
+      # @example
+      #
+      # # bad
+      # # (start of file)
+      #
+      # class Foo
+      # end
+      #
+      # # bad
+      # # (start of file)
+      #
+      # # a comment
+      #
+      # # good
+      # # (start of file)
+      # class Foo
+      # end
+      #
+      # # good
+      # # (start of file)
+      # # a comment
+      class LeadingBlankLines < Cop
+        MSG = 'Unnecessary blank line at the beginning of the source.'.freeze
+
+        def investigate(processed_source)
+          token = processed_source.tokens[0]
+          return unless token && token.line > 1
+
+          add_offense(processed_source.tokens[0],
+                      location: processed_source.tokens[0].pos)
+        end
+
+        def autocorrect(node)
+          range = Parser::Source::Range.new(processed_source.raw_source,
+                                            0,
+                                            node.begin_pos)
+
+          lambda do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -111,10 +111,14 @@ module RuboCop
         end
 
         def left_ref_bracket(node, tokens)
-          if node.method?(:[]=)
+          current_token = tokens.reverse.find(&:left_ref_bracket?)
+          previous_token = previous_token(current_token)
+
+          if node.method?(:[]=) ||
+             previous_token && !previous_token.right_bracket?
             tokens.find(&:left_ref_bracket?)
           else
-            tokens.reverse.find(&:left_ref_bracket?)
+            current_token
           end
         end
 
@@ -131,6 +135,11 @@ module RuboCop
           end
         end
 
+        def previous_token(current_token)
+          index = processed_source.tokens.index(current_token)
+          index.nil? || index.zero? ? nil : processed_source.tokens[index - 1]
+        end
+
         def empty_config
           cop_config['EnforcedStyleForEmptyBrackets']
         end

data/lib/rubocop/cop/lint/ineffective_access_modifier.rb

@@ -116,7 +116,7 @@ module RuboCop
         end
 
         def check_send(node, cur_vis)
-          if node.access_modifier? && !node.method?(:module_function)
+          if node.bare_access_modifier? && !node.method?(:module_function)
             @last_access_modifier = node
             return node.method_name
           elsif (methods = private_class_method(node))

data/lib/rubocop/cop/lint/string_conversion_in_interpolation.rb

@@ -22,12 +22,13 @@ module RuboCop
         MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
                    'interpolation.'.freeze
 
+        def_node_matcher :to_s_without_args?, '(send _ :to_s)'
+
         def on_dstr(node)
           node.each_child_node(:begin) do |begin_node|
             final_node = begin_node.children.last
 
-            next unless final_node && final_node.send_type? &&
-                        final_node.method?(:to_s) && !final_node.arguments?
+            next unless to_s_without_args?(final_node)
 
             add_offense(final_node, location: :selector)
           end
@@ -35,7 +36,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            receiver, _method_name, *_args = *node
+            receiver = node.receiver
             corrector.replace(
               node.source_range,
               if receiver

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -134,7 +134,7 @@ module RuboCop
 
           if node.begin_type?
             check_scope(node)
-          elsif node.send_type? && node.access_modifier?
+          elsif node.send_type? && node.bare_access_modifier?
             add_offense(node, message: format(MSG, current: node.method_name))
           end
         end
@@ -147,7 +147,7 @@ module RuboCop
 
         def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
-            if child.send_type? && child.access_modifier?
+            if child.send_type? && child.bare_access_modifier?
               cur_vis, unused =
                 check_new_visibility(child, unused, child.method_name, cur_vis)
             elsif method_definition?(child)

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

@@ -8,7 +8,7 @@ module RuboCop
       private
 
       def bracketed_array_of?(element_type, node)
-        return false unless node.square_brackets? && node.values.size > 1
+        return false unless node.square_brackets? && !node.values.empty?
 
         node.values.all? { |value| value.type == element_type }
       end

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

@@ -63,17 +63,13 @@ module RuboCop
       def range_by_whole_lines(range, include_final_newline: false)
         buffer = @processed_source.buffer
 
-        begin_pos = range.begin_pos
-        begin_offset = range.column
-        begin_of_first_line = begin_pos - begin_offset
-
         last_line = buffer.source_line(range.last_line)
-        end_pos = range.end_pos
         end_offset = last_line.length - range.last_column
         end_offset += 1 if include_final_newline
-        end_of_last_line = end_pos + end_offset
 
-        Parser::Source::Range.new(buffer, begin_of_first_line, end_of_last_line)
+        range
+          .adjust(begin_pos: -range.column, end_pos: end_offset)
+          .intersect(buffer.source_range)
       end
 
       ## Helpers for above range methods. Do not use inside Cops.

data/lib/rubocop/cop/rails/assert_not.rb

@@ -16,7 +16,7 @@ module RuboCop
       class AssertNot < RuboCop::Cop::Cop
         MSG = 'Prefer `assert_not` over `assert !`.'.freeze
 
-        def_node_matcher :offensive?, '(send nil? :assert (send ... :!))'
+        def_node_matcher :offensive?, '(send nil? :assert (send ... :!) ...)'
 
         def on_send(node)
           add_offense(node) if offensive?(node)