rubocop 0.60.0 → 0.61.0

data/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb

@@ -5,58 +5,64 @@ module RuboCop
     # Autocorrection logic for the closing brace of a literal either
     # on the same line as the last contained elements, or a new line.
     class MultilineLiteralBraceCorrector
-      extend MultilineLiteralBraceLayout
-      extend RangeHelp
-
-      class << self
-        attr_reader :processed_source
-
-        # rubocop:disable Metrics/MethodLength
-        def correct(processed_source, node)
-          @processed_source = processed_source
-          if closing_brace_on_same_line?(node)
-            lambda do |corrector|
-              corrector.insert_before(node.loc.end, "\n".freeze)
-            end
-          else
-            # When a comment immediately before the closing brace gets in the
-            # way of an easy correction, the offense is reported but not auto-
-            # corrected. The user must handle the delicate decision of where to
-            # put the comment.
-            return if new_line_needed_before_closing_brace?(node)
-
-            lambda do |corrector|
-              corrector.remove(range_with_surrounding_space(range: node.loc.end,
-                                                            side: :left))
-
-              corrector.insert_after(
-                last_element_range_with_trailing_comma(node),
-                node.loc.end.source
-              )
-            end
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
+      include MultilineLiteralBraceLayout
+      include RangeHelp
+
+      def initialize(node, processed_source)
+        @node = node
+        @processed_source = processed_source
+      end
 
-        private
+      def call(corrector)
+        if closing_brace_on_same_line?(node)
+          correct_same_line_brace(corrector)
+        else
+          # When a comment immediately before the closing brace gets in the
+          # way of an easy correction, the offense is reported but not auto-
+          # corrected. The user must handle the delicate decision of where to
+          # put the comment.
+          return if new_line_needed_before_closing_brace?(node)
 
-        def last_element_range_with_trailing_comma(node)
-          trailing_comma_range = last_element_trailing_comma_range(node)
-          if trailing_comma_range
-            children(node).last.source_range.join(trailing_comma_range)
-          else
-            children(node).last.source_range
-          end
+          correct_next_line_brace(corrector)
         end
+      end
+
+      private
+
+      attr_reader :node, :processed_source
+
+      def correct_same_line_brace(corrector)
+        corrector.insert_before(node.loc.end, "\n".freeze)
+      end
+
+      def correct_next_line_brace(corrector)
+        corrector.remove(
+          range_with_surrounding_space(range: node.loc.end, side: :left)
+        )
+
+        corrector.insert_after(
+          last_element_range_with_trailing_comma(node),
+          node.loc.end.source
+        )
+      end
 
-        def last_element_trailing_comma_range(node)
-          range = range_with_surrounding_space(
-            range: children(node).last.source_range,
-            side: :right
-          ).end.resize(1)
-          range.source == ',' ? range : nil
+      def last_element_range_with_trailing_comma(node)
+        trailing_comma_range = last_element_trailing_comma_range(node)
+        if trailing_comma_range
+          children(node).last.source_range.join(trailing_comma_range)
+        else
+          children(node).last.source_range
         end
       end
+
+      def last_element_trailing_comma_range(node)
+        range = range_with_surrounding_space(
+          range: children(node).last.source_range,
+          side: :right
+        ).end.resize(1)
+
+        range.source == ',' ? range : nil
+      end
     end
   end
 end

data/lib/rubocop/cop/generator.rb

@@ -98,6 +98,11 @@ module RuboCop
         end
       SPEC
 
+      CONFIGURATION_ADDED_MESSAGE = <<-MESSAGE.strip_indent
+        [modify] A configuration for the cop is added into %<configuration_file_path>s.
+                 If you want to disable the cop by default, set `Enabled` option to false.
+      MESSAGE
+
       def initialize(name, github_user, output: $stdout)
         @badge = Badge.parse(name)
         @github_user = github_user
@@ -123,24 +128,15 @@ module RuboCop
       end
 
       def inject_config(config_file_path: 'config/default.yml')
-        config = File.readlines(config_file_path)
-        content = <<-YAML.strip_indent
-          #{badge}:
-            Description: 'TODO: Write a description of the cop.'
-            Enabled: true
-            VersionAdded: #{bump_minor_version}
-
-        YAML
-        target_line = config.find.with_index(1) do |line, index|
-          next if line =~ /^[\s#]/
-          break index - 1 if badge.to_s < line
+        injector =
+          ConfigurationInjector.new(configuration_file_path: config_file_path,
+                                    badge: badge,
+                                    version_added: bump_minor_version)
+
+        injector.inject do
+          output.puts(format(CONFIGURATION_ADDED_MESSAGE,
+                             configuration_file_path: config_file_path))
         end
-        config.insert(target_line, content)
-        File.write(config_file_path, config.join)
-        output.puts <<-MESSAGE.strip_indent
-          [modify] A configuration for the cop is added into #{config_file_path}.
-                   If you want to disable the cop by default, set `Enabled` option to false.
-        MESSAGE
       end
 
       def todo

data/lib/rubocop/cop/generator/configuration_injector.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class Generator
+      # A class that injects a require directive into the root RuboCop file.
+      # It looks for other directives that require files in the same (cop)
+      # namespace and injects the provided one in alpha
+      class ConfigurationInjector
+        TEMPLATE = <<-YAML.strip_indent
+                     %<badge>s:
+                       Description: 'TODO: Write a description of the cop.'
+                       Enabled: true
+                       VersionAdded: '%<version_added>s'
+
+        YAML
+
+        def initialize(configuration_file_path:, badge:, version_added:)
+          @configuration_file_path = configuration_file_path
+          @badge = badge
+          @version_added = version_added
+          @output = output
+        end
+
+        def inject
+          configuration_entries.insert(find_target_line,
+                                       new_configuration_entry)
+
+          File.write(configuration_file_path, configuration_entries.join)
+
+          yield if block_given?
+        end
+
+        private
+
+        attr_reader :configuration_file_path, :badge, :version_added, :output
+
+        def configuration_entries
+          @configuration_entries ||= File.readlines(configuration_file_path)
+        end
+
+        def new_configuration_entry
+          format(TEMPLATE, badge: badge, version_added: version_added)
+        end
+
+        def find_target_line
+          configuration_entries.find.with_index do |line, index|
+            next if comment?(line)
+
+            break index if badge.to_s < line
+          end
+        end
+
+        def comment?(yaml)
+          yaml =~ /^[\s#]/
+        end
+      end
+    end
+  end
+end

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

@@ -182,6 +182,7 @@ module RuboCop
 
         def on_send(node)
           return if double_splat?(node)
+          return unless node.arguments?
 
           last_argument = node.last_argument
 
@@ -190,6 +191,8 @@ module RuboCop
 
           ignore_node(last_argument)
         end
+        alias on_super on_send
+        alias on_yield on_send
 
         def on_hash(node)
           return if ignored_node?(node)

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

@@ -42,12 +42,42 @@ module RuboCop
           processed_source.each_comment { |comment| check(comment) }
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        def autocorrect(comment)
+          corrections = autocorrect_preceding_comments(comment) <<
+                        autocorrect_one(comment)
+          ->(corrector) { corrections.each { |corr| corr.call(corrector) } }
         end
 
         private
 
+        # Corrects all comment lines that occur immediately before the given
+        # comment and have the same indentation. This is to avoid a long chain
+        # of correcting, saving the file, parsing and inspecting again, and
+        # then correcting one more line, and so on.
+        def autocorrect_preceding_comments(comment)
+          corrections = []
+          line_no = comment.loc.line
+          column = comment.loc.column
+          comments = processed_source.comments
+          (comments.index(comment) - 1).downto(0) do |ix|
+            previous_comment = comments[ix]
+            break unless should_correct?(previous_comment, column, line_no - 1)
+
+            corrections << autocorrect_one(previous_comment)
+            line_no -= 1
+          end
+          corrections
+        end
+
+        def should_correct?(comment, column, line_no)
+          loc = comment.loc
+          loc.line == line_no && loc.column == column
+        end
+
+        def autocorrect_one(comment)
+          AlignmentCorrector.correct(processed_source, comment, @column_delta)
+        end
+
         def check(comment)
           return unless own_line_comment?(comment)
 

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

@@ -99,7 +99,7 @@ module RuboCop
             return unless body_indent_level.zero?
           end
 
-          return if too_long_line?(node)
+          return if line_too_long?(node)
 
           add_offense(node, location: :heredoc_body)
         end
@@ -173,8 +173,8 @@ module RuboCop
           )
         end
 
-        def too_long_line?(node)
-          return false if config.for_cop('Metrics/LineLength')['AllowHeredoc']
+        def line_too_long?(node)
+          return false if unlimited_heredoc_length?
 
           body = heredoc_body(node)
 
@@ -182,9 +182,15 @@ module RuboCop
           actual_indent = indent_level(body)
           increase_indent_level = expected_indent - actual_indent
 
-          max_line = body.each_line.map { |line| line.chomp.size }.max
+          longest_line(body).size + increase_indent_level >= max_line_length
+        end
+
+        def longest_line(lines)
+          lines.each_line.max_by { |line| line.chomp.size }.chomp
+        end
 
-          max_line + increase_indent_level >= max_line_length
+        def unlimited_heredoc_length?
+          config.for_cop('Metrics/LineLength')['AllowHeredoc']
         end
 
         def max_line_length

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

@@ -96,6 +96,12 @@ module RuboCop
           check_members(node.loc.keyword, members)
         end
 
+        def on_sclass(node)
+          _class_name, *members = *node
+
+          check_members(node.loc.keyword, members)
+        end
+
         def on_send(node)
           super
           return unless node.adjacent_def_modifier?
@@ -141,7 +147,7 @@ module RuboCop
         end
 
         def on_if(node, base = node)
-          return if ignored_node?(node) || !node.body
+          return if ignored_node?(node)
           return if node.ternary? || node.modifier_form?
 
           check_if(node, node.body, node.else_branch, base.loc)

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

@@ -91,26 +91,26 @@ module RuboCop
       class MultilineArrayBraceLayout < Cop
         include MultilineLiteralBraceLayout
 
-        SAME_LINE_MESSAGE = 'Closing array brace must be on the same line as ' \
-          'the last array element when opening brace is on the same line as ' \
-          'the first array element.'.freeze
+        SAME_LINE_MESSAGE = 'The closing array brace must be on the same ' \
+          'line as the last array element when the opening brace is on the ' \
+          'same line as the first array element.'.freeze
 
-        NEW_LINE_MESSAGE = 'Closing array brace must be on the line after ' \
-          'the last array element when opening brace is on a separate line ' \
-          'from the first array element.'.freeze
+        NEW_LINE_MESSAGE = 'The closing array brace must be on the line ' \
+          'after the last array element when the opening brace is on a ' \
+          'separate line from the first array element.'.freeze
 
-        ALWAYS_NEW_LINE_MESSAGE = 'Closing array brace must be on the line ' \
-          'after the last array element.'.freeze
+        ALWAYS_NEW_LINE_MESSAGE = 'The closing array brace must be on the ' \
+          'line after the last array element.'.freeze
 
-        ALWAYS_SAME_LINE_MESSAGE = 'Closing array brace must be on the same ' \
-          'line as the last array element.'.freeze
+        ALWAYS_SAME_LINE_MESSAGE = 'The closing array brace must be on the ' \
+          'same line as the last array element.'.freeze
 
         def on_array(node)
           check_brace_layout(node)
         end
 
         def autocorrect(node)
-          MultilineLiteralBraceCorrector.correct(processed_source, node)
+          MultilineLiteralBraceCorrector.new(node, processed_source)
         end
       end
     end

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

@@ -114,7 +114,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          MultilineLiteralBraceCorrector.correct(processed_source, node)
+          MultilineLiteralBraceCorrector.new(node, processed_source)
         end
       end
     end

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

@@ -110,7 +110,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          MultilineLiteralBraceCorrector.correct(processed_source, node)
+          MultilineLiteralBraceCorrector.new(node, processed_source)
         end
 
         private

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

@@ -123,7 +123,7 @@ module RuboCop
         alias on_defs on_def
 
         def autocorrect(node)
-          MultilineLiteralBraceCorrector.correct(processed_source, node)
+          MultilineLiteralBraceCorrector.new(node, processed_source)
         end
       end
     end

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

@@ -28,8 +28,9 @@ module RuboCop
               'aligned with `%<beginning>s` at ' \
               '%<begin_loc_line>d, %<begin_loc_column>d.'.freeze
         ANCESTOR_TYPES = %i[kwbegin def defs class module].freeze
-        RUBY_2_5_ANCESTOR_TYPES = (ANCESTOR_TYPES + [:block]).freeze
+        RUBY_2_5_ANCESTOR_TYPES = (ANCESTOR_TYPES + %i[block]).freeze
         ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
+        ASSIGNMENT_TYPES = %i[lvasgn].freeze
 
         def on_resbody(node)
           check(node) unless modifier?(node)
@@ -115,10 +116,13 @@ module RuboCop
           ancestor_node = ancestor_node(node)
           return nil if ancestor_node.nil?
 
+          assignment_node = assignment_node(ancestor_node)
+          return assignment_node unless assignment_node.nil?
+
           access_modifier_node = access_modifier_node(ancestor_node)
-          return ancestor_node if access_modifier_node.nil?
+          return access_modifier_node unless access_modifier_node.nil?
 
-          access_modifier_node
+          ancestor_node
         end
 
         def ancestor_node(node)
@@ -132,6 +136,15 @@ module RuboCop
           node.each_ancestor(*ancestor_types).first
         end
 
+        def assignment_node(node)
+          assignment_node = node.ancestors.first
+          return nil unless
+            assignment_node &&
+            ASSIGNMENT_TYPES.include?(assignment_node.type)
+
+          assignment_node
+        end
+
         def access_modifier_node(node)
           return nil unless
             ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS.include?(node.type)