rubocop 0.75.1 → 0.93.1

data/lib/rubocop/cop/layout/{tab.rb → indentation_style.rb}

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for tabs inside the source code.
+      # This cop checks that the indentation method is consistent.
+      # Either tabs only or spaces only are used for indentation.
       #
-      # @example
+      # @example EnforcedStyle: spaces (default)
       #   # bad
       #   # This example uses a tab to indent bar.
       #   def foo
@@ -20,17 +19,30 @@ module RuboCop
       #     bar
       #   end
       #
-      class Tab < Cop
+      # @example EnforcedStyle: tabs
+      #   # bad
+      #   # This example uses spaces to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   # This example uses a tab to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      class IndentationStyle < Cop
         include Alignment
+        include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG = 'Tab detected.'
+        MSG = '%<type>s detected in indentation.'
 
         def investigate(processed_source)
           str_ranges = string_literal_ranges(processed_source.ast)
 
           processed_source.lines.each.with_index(1) do |line, lineno|
-            match = line.match(/\t+/)
+            match = find_offence(line)
             next unless match
 
             range = source_range(processed_source.buffer,
@@ -43,13 +55,37 @@ module RuboCop
         end
 
         def autocorrect(range)
+          if range.source.include?("\t")
+            autocorrect_lambda_for_tabs(range)
+          else
+            autocorrect_lambda_for_spaces(range)
+          end
+        end
+
+        private
+
+        def find_offence(line)
+          if style == :spaces
+            line.match(/\A\s*\t+/)
+          else
+            line.match(/\A\s* +/)
+          end
+        end
+
+        def autocorrect_lambda_for_tabs(range)
           lambda do |corrector|
             spaces = ' ' * configured_indentation_width
             corrector.replace(range, range.source.gsub(/\t/, spaces))
           end
         end
 
-        private
+        def autocorrect_lambda_for_spaces(range)
+          lambda do |corrector|
+            corrector.replace(range, range.source.gsub(/\A\s+/) do |match|
+              "\t" * (match.size / configured_indentation_width)
+            end)
+          end
+        end
 
         def in_string_literal?(ranges, tabs_range)
           ranges.any? { |range| range.contains?(tabs_range) }
@@ -69,6 +105,10 @@ module RuboCop
             end
           end
         end
+
+        def message(_node)
+          format(MSG, type: style == :spaces ? 'Tab' : 'Space')
+        end
       end
     end
   end

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

@@ -263,9 +263,7 @@ module RuboCop
         def offense(body_node, indentation, style)
           # This cop only auto-corrects the first statement in a def body, for
           # example.
-          if body_node.begin_type? && !parentheses?(body_node)
-            body_node = body_node.children.first
-          end
+          body_node = body_node.children.first if body_node.begin_type? && !parentheses?(body_node)
 
           # Since autocorrect changes a number of lines, and not only the line
           # where the reported offending range is, we avoid auto-correction if

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

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_blank_lines.rb → leading_empty_lines.rb}

@@ -27,23 +27,18 @@ module RuboCop
       #   # good
       #   # (start of file)
       #   # a comment
-      class LeadingBlankLines < 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/{metrics → layout}/line_length.rb

@@ -2,14 +2,13 @@
 
 require 'uri'
 
-# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
-    module Metrics
+    module Layout
       # 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.
@@ -20,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.)
       #
-      #   - AlignArray
-      #   - AlignHash
-      #   - AlignParameters
-      #   - ClosingParenthesisIndentation
-      #   - IndentFirstArgument
-      #   - IndentFirstArrayElement
-      #   - IndentFirstHashElement
-      #   - IndentFirstParameter
-      #   - 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
@@ -58,9 +63,14 @@ module RuboCop
         include ConfigurableMax
         include IgnoredPattern
         include RangeHelp
+        include LineLengthHelp
 
         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,6 +78,10 @@ module RuboCop
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
 
+        def investigate(processed_source)
+          check_for_breakable_semicolons(processed_source)
+        end
+
         def investigate_post_walk(processed_source)
           processed_source.lines.each_with_index do |line, line_index|
             check_line(line, line_index)
@@ -89,33 +103,67 @@ module RuboCop
           return if breakable_node.nil?
 
           line_index = breakable_node.first_line - 1
-          breakable_nodes_by_line_index[line_index] = breakable_node
+          range = breakable_node.source_range
+
+          existing = breakable_range_by_line_index[line_index]
+          return if existing
+
+          breakable_range_by_line_index[line_index] = range
         end
 
-        def breakable_nodes_by_line_index
-          @breakable_nodes_by_line_index ||= {}
+        def check_for_breakable_semicolons(processed_source)
+          tokens = processed_source.tokens.select { |t| t.type == :tSEMI }
+          tokens.reverse_each do |token|
+            range = breakable_range_after_semicolon(token)
+            breakable_range_by_line_index[range.line - 1] = range if range
+          end
         end
 
-        def heredocs
-          @heredocs ||= extract_heredocs(processed_source.ast)
+        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 tab_indentation_width
-          config.for_cop('Layout/Tab')['IndentationWidth']
+        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 indentation_difference(line)
-          return 0 unless tab_indentation_width
+        def breakable_range_after_semicolon(semicolon_token)
+          range = semicolon_token.pos
+          end_pos = range.end_pos
+          next_range = range_between(end_pos, end_pos + 1)
+          return nil unless next_range.line == range.line
+
+          next_char = next_range.source
+          return nil if /[\r\n]/.match?(next_char)
+          return nil if next_char == ';'
 
-          line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+          next_range
         end
 
-        def line_length(line)
-          line.length + indentation_difference(line)
+        def breakable_range_by_line_index
+          @breakable_range_by_line_index ||= {}
+        end
+
+        def heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
         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)
@@ -128,10 +176,7 @@ module RuboCop
           return check_uri_line(line, line_index) if allow_uri?
 
           register_offense(
-            source_range(
-              processed_source.buffer, line_index,
-              highlight_start(line)...line_length(line)
-            ),
+            excess_range(nil, line, line_index),
             line,
             line_index
           )
@@ -150,33 +195,12 @@ module RuboCop
         def register_offense(loc, line, line_index)
           message = format(MSG, length: line_length(line), max: max)
 
-          breakable_range = breakable_range(line, line_index)
+          breakable_range = breakable_range_by_line_index[line_index]
           add_offense(breakable_range, location: loc, message: message) do
             self.max = line_length(line)
           end
         end
 
-        def breakable_range(line, line_index)
-          return if line_in_heredoc?(line_index + 1)
-
-          semicolon_range = breakable_semicolon_range(line, line_index)
-          return semicolon_range if semicolon_range
-
-          breakable_node = breakable_nodes_by_line_index[line_index]
-          return breakable_node.source_range if breakable_node
-        end
-
-        def breakable_semicolon_range(line, line_index)
-          semicolon_separated_parts = line.split(';')
-          return if semicolon_separated_parts.length <= 1
-
-          column = semicolon_separated_parts.first.length + 1
-          range = source_range(processed_source.buffer, line_index, column, 1)
-          return if processed_source.commented?(range)
-
-          range
-        end
-
         def excess_range(uri_range, line, line_index)
           excessive_position = if uri_range && uri_range.begin < max
                                  uri_range.end
@@ -225,53 +249,6 @@ module RuboCop
           end
         end
 
-        def allow_uri?
-          cop_config['AllowURI']
-        end
-
-        def ignore_cop_directives?
-          cop_config['IgnoreCopDirectives']
-        end
-
-        def allowed_uri_position?(line, uri_range)
-          uri_range.begin < max &&
-            (uri_range.end == line_length(line) ||
-             uri_range.end == line_length(line) - 1)
-        end
-
-        def find_excessive_uri_range(line)
-          last_uri_match = match_uris(line).last
-          return nil unless last_uri_match
-
-          begin_position, end_position =
-            last_uri_match.offset(0).map do |pos|
-              pos + indentation_difference(line)
-            end
-          return nil if begin_position < max && end_position < max
-
-          begin_position...end_position
-        end
-
-        def match_uris(string)
-          matches = []
-          string.scan(uri_regexp) do
-            matches << $LAST_MATCH_INFO if valid_uri?($LAST_MATCH_INFO[0])
-          end
-          matches
-        end
-
-        def valid_uri?(uri_ish_string)
-          URI.parse(uri_ish_string)
-          true
-        rescue URI::InvalidURIError, NoMethodError
-          false
-        end
-
-        def uri_regexp
-          @uri_regexp ||=
-            URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
-        end
-
         def check_directive_line(line, line_index)
           return if line_length_without_directive(line) <= max
 
@@ -287,23 +264,6 @@ module RuboCop
           )
         end
 
-        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 }
-
-          return false unless comment
-
-          comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-        end
-
-        def line_length_without_directive(line)
-          before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-          before_comment.rstrip.length
-        end
-
         def check_uri_line(line, line_index)
           uri_range = find_excessive_uri_range(line)
           return if uri_range && allowed_uri_position?(line, uri_range)
@@ -318,4 +278,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Metrics/ClassLength