rubocop 0.78.0 → 1.13.0

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

@@ -17,21 +17,20 @@ module RuboCop
       #     def foo; end
       #   end
       #
-      class InitialIndentation < Cop
+      class InitialIndentation < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Indentation of first line in file detected.'
 
-        def investigate(_processed_source)
+        def on_new_investigation
           space_before(first_token) do |space|
-            add_offense(space, location: first_token.pos)
+            add_offense(first_token.pos) do |corrector|
+              corrector.remove(space)
+            end
           end
         end
 
-        def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def first_token
@@ -42,10 +41,7 @@ module RuboCop
           return unless token
           return if token.column.zero?
 
-          space_range =
-            range_with_surrounding_space(range: token.pos,
-                                         side: :left,
-                                         newlines: false)
+          space_range = range_with_surrounding_space(range: token.pos, side: :left, newlines: false)
           # If the file starts with a byte order mark (BOM), the column can be
           # non-zero, but then we find out here if there's no space to the left
           # of the first token.

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

@@ -35,30 +35,47 @@ module RuboCop
       #   # Another line of comment
       #   #*
       #
-      class LeadingCommentSpace < Cop
+      # @example AllowGemfileRubyComment: false (default)
+      #
+      #   # bad
+      #
+      #   #ruby=2.7.0
+      #   #ruby-gemset=myproject
+      #
+      # @example AllowGemfileRubyComment: true
+      #
+      #   # good
+      #
+      #   #ruby=2.7.0
+      #   #ruby-gemset=myproject
+      #
+      class LeadingCommentSpace < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Missing space after `#`.'
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
-            next unless comment.text =~ /\A#+[^#\s=:+-]/
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            next unless /\A#+[^#\s=:+-]/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
-            next if allow_doxygen_comment? && doxygen_comment_style?(comment)
+            next if doxygen_comment_style?(comment)
+            next if gemfile_ruby_comment?(comment)
 
-            add_offense(comment)
+            add_offense(comment) do |corrector|
+              expr = comment.loc.expression
+
+              corrector.insert_after(hash_mark(expr), ' ')
+            end
           end
         end
 
-        def autocorrect(comment)
-          expr = comment.loc.expression
-          hash_mark = range_between(expr.begin_pos, expr.begin_pos + 1)
+        private
 
-          ->(corrector) { corrector.insert_after(hash_mark, ' ') }
+        def hash_mark(expr)
+          range_between(expr.begin_pos, expr.begin_pos + 1)
         end
 
-        private
-
         def allowed_on_first_line?(comment)
           shebang?(comment) || rackup_config_file? && rackup_options?(comment)
         end
@@ -80,7 +97,23 @@ module RuboCop
         end
 
         def doxygen_comment_style?(comment)
-          comment.text.start_with?('#*')
+          allow_doxygen_comment? && comment.text.start_with?('#*')
+        end
+
+        def allow_gemfile_ruby_comment?
+          cop_config['AllowGemfileRubyComment']
+        end
+
+        def gemfile?
+          File.basename(processed_source.file_path).eql?('Gemfile')
+        end
+
+        def ruby_comment_in_gemfile?(comment)
+          gemfile? && comment.text.start_with?('#ruby')
+        end
+
+        def gemfile_ruby_comment?(comment)
+          allow_gemfile_ruby_comment? && ruby_comment_in_gemfile?(comment)
         end
       end
     end

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

@@ -27,23 +27,18 @@ module RuboCop
       #   # good
       #   # (start of file)
       #   # a comment
-      class LeadingEmptyLines < Cop
+      class LeadingEmptyLines < Base
+        extend AutoCorrector
+
         MSG = 'Unnecessary blank line at the beginning of the source.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           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.buffer,
-                                            0,
-                                            node.begin_pos)
+          add_offense(token.pos) do |corrector|
+            range = Parser::Source::Range.new(processed_source.buffer, 0, token.begin_pos)
 
-          lambda do |corrector|
             corrector.remove(range)
           end
         end

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

@@ -8,7 +8,7 @@ module RuboCop
       # This cop checks the length of lines in the source code.
       # The maximum length is configurable.
       # The tab size is configured in the `IndentationWidth`
-      # of the `Layout/Tab` cop.
+      # of the `Layout/IndentationStyle` cop.
       # It also ignores a shebang line by default.
       #
       # This cop has some autocorrection capabilities.
@@ -19,19 +19,25 @@ module RuboCop
       #
       # If autocorrection is enabled, the following Layout cops
       # are recommended to further format the broken lines.
+      # (Many of these are enabled by default.)
       #
-      #   - ParameterAlignment
-      #   - ArgumentAlignment
-      #   - ClosingParenthesisIndentation
-      #   - FirstArgumentIndentation
-      #   - FirstArrayElementIndentation
-      #   - FirstHashElementIndentation
-      #   - FirstParameterIndentation
-      #   - HashAlignment
-      #   - MultilineArrayLineBreaks
-      #   - MultilineHashBraceLayout
-      #   - MultilineHashKeyLineBreaks
-      #   - MultilineMethodArgumentLineBreaks
+      # * ArgumentAlignment
+      # * BlockAlignment
+      # * BlockDelimiters
+      # * BlockEndNewline
+      # * ClosingParenthesisIndentation
+      # * FirstArgumentIndentation
+      # * FirstArrayElementIndentation
+      # * FirstHashElementIndentation
+      # * FirstParameterIndentation
+      # * HashAlignment
+      # * IndentationWidth
+      # * MultilineArrayLineBreaks
+      # * MultilineBlockLayout
+      # * MultilineHashBraceLayout
+      # * MultilineHashKeyLineBreaks
+      # * MultilineMethodArgumentLineBreaks
+      # * ParameterAlignment
       #
       # Together, these cops will pretty print hashes, arrays,
       # method calls, etc. For example, let's say the max columns
@@ -52,15 +58,21 @@ module RuboCop
       #     bar: "0000000000",
       #     baz: "0000000000",
       #   }
-      class LineLength < Cop
+      class LineLength < Base
         include CheckLineBreakable
-        include ConfigurableMax
         include IgnoredPattern
         include RangeHelp
         include LineLengthHelp
+        extend AutoCorrector
+
+        exclude_limit 'Max'
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
+        def on_block(node)
+          check_for_breakable_block(node)
+        end
+
         def on_potential_breakable_node(node)
           check_for_breakable_node(node)
         end
@@ -68,26 +80,20 @@ module RuboCop
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
 
-        def investigate(processed_source)
+        def on_new_investigation
           check_for_breakable_semicolons(processed_source)
         end
 
-        def investigate_post_walk(processed_source)
+        def on_investigation_end
           processed_source.lines.each_with_index do |line, line_index|
             check_line(line, line_index)
           end
         end
 
-        def autocorrect(range)
-          return if range.nil?
-
-          lambda do |corrector|
-            corrector.insert_before(range, "\n")
-          end
-        end
-
         private
 
+        attr_accessor :breakable_range
+
         def check_for_breakable_node(node)
           breakable_node = extract_breakable_node(node, max)
           return if breakable_node.nil?
@@ -109,6 +115,24 @@ module RuboCop
           end
         end
 
+        def check_for_breakable_block(block_node)
+          return unless block_node.single_line?
+
+          line_index = block_node.loc.line - 1
+          range = breakable_block_range(block_node)
+          pos = range.begin_pos + 1
+
+          breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
+        end
+
+        def breakable_block_range(block_node)
+          if block_node.arguments? && !block_node.lambda?
+            block_node.arguments.loc.end
+          else
+            block_node.loc.begin
+          end
+        end
+
         def breakable_range_after_semicolon(semicolon_token)
           range = semicolon_token.pos
           end_pos = range.end_pos
@@ -116,7 +140,7 @@ module RuboCop
           return nil unless next_range.line == range.line
 
           next_char = next_range.source
-          return nil if /[\r\n]/ =~ next_char
+          return nil if /[\r\n]/.match?(next_char)
           return nil if next_char == ';'
 
           next_range
@@ -131,7 +155,10 @@ module RuboCop
         end
 
         def highlight_start(line)
-          max - indentation_difference(line)
+          # TODO: The max with 0 is a quick fix to avoid crashes when a line
+          # begins with many tabs, but getting a correct highlighting range
+          # when tabs are used for indentation doesn't work currently.
+          [max - indentation_difference(line), 0].max
         end
 
         def check_line(line, line_index)
@@ -143,11 +170,7 @@ module RuboCop
           end
           return check_uri_line(line, line_index) if allow_uri?
 
-          register_offense(
-            excess_range(nil, line, line_index),
-            line,
-            line_index
-          )
+          register_offense(excess_range(nil, line, line_index), line, line_index)
         end
 
         def ignored_line?(line, line_index)
@@ -163,9 +186,11 @@ module RuboCop
         def register_offense(loc, line, line_index)
           message = format(MSG, length: line_length(line), max: max)
 
-          breakable_range = breakable_range_by_line_index[line_index]
-          add_offense(breakable_range, location: loc, message: message) do
+          self.breakable_range = breakable_range_by_line_index[line_index]
+
+          add_offense(loc, message: message) do |corrector|
             self.max = line_length(line)
+            corrector.insert_before(breakable_range, "\n") unless breakable_range.nil?
           end
         end
 
@@ -212,9 +237,7 @@ module RuboCop
         end
 
         def line_in_heredoc?(line_number)
-          heredocs.any? do |range, _delimiter|
-            range.cover?(line_number)
-          end
+          heredocs.any? { |range, _delimiter| range.cover?(line_number) }
         end
 
         def check_directive_line(line, line_index)
@@ -236,11 +259,7 @@ module RuboCop
           uri_range = find_excessive_uri_range(line)
           return if uri_range && allowed_uri_position?(line, uri_range)
 
-          register_offense(
-            excess_range(uri_range, line, line_index),
-            line,
-            line_index
-          )
+          register_offense(excess_range(uri_range, line, line_index), line, line_index)
         end
       end
     end

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

@@ -88,8 +88,9 @@ module RuboCop
       #     # good
       #     [ :a,
       #       :b ]
-      class MultilineArrayBraceLayout < Cop
+      class MultilineArrayBraceLayout < Base
         include MultilineLiteralBraceLayout
+        extend AutoCorrector
 
         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 ' \
@@ -108,10 +109,6 @@ module RuboCop
         def on_array(node)
           check_brace_layout(node)
         end
-
-        def autocorrect(node)
-          MultilineLiteralBraceCorrector.new(node, processed_source)
-        end
       end
     end
   end

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

@@ -20,19 +20,15 @@ module RuboCop
       #     b,
       #     c
       #   ]
-      class MultilineArrayLineBreaks < Cop
+      class MultilineArrayLineBreaks < Base
         include MultilineElementLineBreaks
+        extend AutoCorrector
 
-        MSG = 'Each item in a multi-line array must start ' \
-          'on a separate line.'
+        MSG = 'Each item in a multi-line array must start on a separate line.'
 
         def on_array(node)
           check_line_breaks(node, node.children)
         end
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
       end
     end
   end

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

@@ -31,10 +31,37 @@ module RuboCop
       #   foo = if expression
       #     'bar'
       #   end
-      class MultilineAssignmentLayout < Cop
+      #
+      # @example SupportedTypes: ['block', 'case', 'class', 'if', 'kwbegin', 'module'] (default)
+      #   # good
+      #   foo =
+      #     if expression
+      #       'bar'
+      #     end
+      #
+      #   # good
+      #   foo =
+      #     [1].map do |i|
+      #       i + 1
+      #     end
+      #
+      # @example SupportedTypes: ['block']
+      #   # good
+      #   foo = if expression
+      #     'bar'
+      #   end
+      #
+      #   # good
+      #   foo =
+      #     [1].map do |i|
+      #       'bar' * i
+      #     end
+      #
+      class MultilineAssignmentLayout < Base
         include CheckAssignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         NEW_LINE_OFFENSE = 'Right hand side of multi-line assignment is on ' \
           'the same line as the assignment operator `=`.'
@@ -63,24 +90,19 @@ module RuboCop
         def check_new_line_offense(node, rhs)
           return unless node.loc.operator.line == rhs.first_line
 
-          add_offense(node, message: NEW_LINE_OFFENSE)
+          add_offense(node, message: NEW_LINE_OFFENSE) do |corrector|
+            corrector.insert_after(node.loc.operator, "\n")
+          end
         end
 
         def check_same_line_offense(node, rhs)
           return unless node.loc.operator.line != rhs.first_line
 
-          add_offense(node, message: SAME_LINE_OFFENSE)
-        end
-
-        def autocorrect(node)
-          case style
-          when :new_line
-            ->(corrector) { corrector.insert_after(node.loc.operator, "\n") }
-          when :same_line
-            range = range_between(node.loc.operator.end_pos,
-                                  extract_rhs(node).source_range.begin_pos)
-
-            ->(corrector) { corrector.replace(range, ' ') }
+          add_offense(node, message: SAME_LINE_OFFENSE) do |corrector|
+            range = range_between(
+              node.loc.operator.end_pos, extract_rhs(node).source_range.begin_pos
+            )
+            corrector.replace(range, ' ')
           end
         end