rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks that the indentation method is consistent.
+      # Either tabs only or spaces only are used for indentation.
+      #
+      # @example EnforcedStyle: spaces (default)
+      #   # bad
+      #   # This example uses a tab to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   # This example uses spaces to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      #
+      # @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 = '%<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 = find_offence(line)
+            next unless match
+
+            range = source_range(processed_source.buffer,
+                                 lineno,
+                                 match.begin(0)...match.end(0))
+            next if in_string_literal?(str_ranges, range)
+
+            add_offense(range, location: range)
+          end
+        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
+
+        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) }
+        end
+
+        def string_literal_ranges(ast)
+          # which lines start inside a string literal?
+          return [] if ast.nil?
+
+          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, ranges|
+            loc = str.location
+
+            if str.heredoc?
+              ranges << loc.heredoc_body
+            elsif loc.respond_to?(:begin) && loc.begin
+              ranges << loc.expression
+            end
+          end
+        end
+
+        def message(_node)
+          format(MSG, type: style == :spaces ? 'Tab' : 'Space')
+        end
+      end
+    end
+  end
+end

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

@@ -3,41 +3,38 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks for indentation that doesn't use the specified number
+      # This cop checks for indentation that doesn't use the specified number
       # of spaces.
       #
       # See also the IndentationConsistency cop which is the companion to this
       # one.
       #
       # @example
-      #   # bad, Width: 2
+      #   # bad
       #   class A
       #    def test
       #     puts 'hello'
       #    end
       #   end
       #
-      #   # bad, Width: 2,
-      #          IgnoredPatterns:
-      #            - '^\s*module'
-      #   module A
-      #   class B
+      #   # good
+      #   class A
       #     def test
-      #     puts 'hello'
+      #       puts 'hello'
       #     end
       #   end
-      #   end
       #
-      #   # good, Width: 2
-      #   class A
+      # @example IgnoredPatterns: ['^\s*module']
+      #   # bad
+      #   module A
+      #   class B
       #     def test
-      #       puts 'hello'
+      #     puts 'hello'
       #     end
       #   end
+      #   end
       #
-      #   # good, Width: 2,
-      #           IgnoredPatterns:
-      #             - '^\s*module'
+      #   # good
       #   module A
       #   class B
       #     def test
@@ -45,15 +42,19 @@ module RuboCop
       #     end
       #   end
       #   end
-      class IndentationWidth < Cop
+      class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
         include EndKeywordAlignment
-        include AutocorrectAlignment
+        include Alignment
         include CheckAssignment
         include IgnoredPattern
+        include RangeHelp
 
-        MSG = 'Use %d (not %d) spaces for%s indentation.'.freeze
+        MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
+              'spaces for%<name>s indentation.'
 
-        SPECIAL_MODIFIERS = %w[private protected].freeze
+        def_node_matcher :access_modifier?, <<~PATTERN
+          [(send ...) access_modifier?]
+        PATTERN
 
         def on_rescue(node)
           _begin_node, *_rescue_nodes, else_node = *node
@@ -71,6 +72,7 @@ module RuboCop
           # Check indentation against end keyword but only if it's first on its
           # line.
           return unless begins_its_line?(node.loc.end)
+
           check_indentation(node.loc.end, node.children.first)
         end
 
@@ -81,34 +83,33 @@ module RuboCop
 
           check_indentation(end_loc, node.body)
 
-          return unless indentation_consistency_style == 'rails'
+          return unless indented_internal_methods_style?
 
           check_members(end_loc, [node.body])
         end
 
-        def on_module(node)
-          _module_name, *members = *node
-          check_members(node.loc.keyword, members)
-        end
-
         def on_class(node)
-          _class_name, _base_class, *members = *node
-          check_members(node.loc.keyword, members)
+          check_members(node.loc.keyword, [node.body])
         end
+        alias on_sclass on_class
+        alias on_module on_class
 
         def on_send(node)
           super
           return unless node.adjacent_def_modifier?
 
-          *_, body = *node.first_argument
-
-          def_end_config = config.for_cop('Lint/DefEndAlignment')
+          def_end_config = config.for_cop('Layout/DefEndAlignment')
           style = def_end_config['EnforcedStyleAlignWith'] || 'start_of_line'
-          base = style == 'def' ? node.first_argument : node
+          base = if style == 'def'
+                   node.first_argument
+                 else
+                   leftmost_modifier_of(node) || node
+                 end
 
-          check_indentation(base.source_range, body)
+          check_indentation(base.source_range, node.first_argument.body)
           ignore_node(node.first_argument)
         end
+        alias on_csend on_send
 
         def on_def(node)
           return if ignored_node?(node)
@@ -137,30 +138,61 @@ 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)
         end
 
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
         private
 
         def check_members(base, members)
-          check_indentation(base, members.first)
+          check_indentation(base, select_check_member(members.first))
 
           return unless members.any? && members.first.begin_type?
-          return unless indentation_consistency_style == 'rails'
 
+          if indentation_consistency_style == 'indented_internal_methods'
+            check_members_for_indented_internal_methods_style(members)
+          else
+            check_members_for_normal_style(base, members)
+          end
+        end
+
+        def select_check_member(member)
+          return unless member
+
+          if access_modifier?(member.children.first)
+            return if access_modifier_indentation_style == 'outdent'
+
+            member.children.first
+          else
+            member
+          end
+        end
+
+        def check_members_for_indented_internal_methods_style(members)
           each_member(members) do |member, previous_modifier|
             check_indentation(previous_modifier, member,
                               indentation_consistency_style)
           end
         end
 
+        def check_members_for_normal_style(base, members)
+          members.first.children.each do |member|
+            next if member.send_type? && member.access_modifier?
+
+            check_indentation(base, member)
+          end
+        end
+
         def each_member(members)
           previous_modifier = nil
           members.first.children.each do |member|
-            if member.send_type? && special_modifier?(member)
+            if member.send_type? && member.special_modifier?
               previous_modifier = member
             elsif previous_modifier
               yield member, previous_modifier.source_range
@@ -169,8 +201,16 @@ module RuboCop
           end
         end
 
+        def indented_internal_methods_style?
+          indentation_consistency_style == 'indented_internal_methods'
+        end
+
         def special_modifier?(node)
-          node.access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
+          node.bare_access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
+        end
+
+        def access_modifier_indentation_style
+          config.for_cop('Layout/AccessModifierIndentation')['EnforcedStyle']
         end
 
         def indentation_consistency_style
@@ -184,7 +224,7 @@ module RuboCop
           rhs = first_part_of_call_chain(rhs)
           return unless rhs
 
-          end_config = config.for_cop('Lint/EndAlignment')
+          end_config = config.for_cop('Layout/EndAlignment')
           style = end_config['EnforcedStyleAlignWith'] || 'keyword'
           base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
@@ -213,7 +253,7 @@ module RuboCop
         def check_indentation(base_loc, body_node, style = 'normal')
           return unless indentation_to_check?(base_loc, body_node)
 
-          indentation = body_node.loc.column - effective_column(base_loc)
+          indentation = column_offset_between(body_node.loc, base_loc)
           @column_delta = configured_indentation_width - indentation
           return if @column_delta.zero?
 
@@ -223,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
@@ -239,10 +277,19 @@ module RuboCop
                  end
 
           name = style == 'normal' ? '' : " #{style}"
-          msg = format(MSG, configured_indentation_width, indentation, name)
+          message = message(configured_indentation_width, indentation, name)
 
           add_offense(node, location: offending_range(body_node, indentation),
-                            message: msg)
+                            message: message)
+        end
+
+        def message(configured_indentation_width, indentation, name)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            indentation: indentation,
+            name: name
+          )
         end
 
         # Returns true if the given node is within another node that has
@@ -295,12 +342,20 @@ module RuboCop
           return unless body_node.begin_type?
 
           starting_node = body_node.children.first
-          starting_node.send_type? && starting_node.access_modifier?
+          return unless starting_node
+
+          starting_node.send_type? && starting_node.bare_access_modifier?
         end
 
         def configured_indentation_width
           cop_config['Width']
         end
+
+        def leftmost_modifier_of(node)
+          return node unless node.parent&.send_type?
+
+          leftmost_modifier_of(node.parent)
+        end
       end
     end
   end

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

@@ -3,10 +3,24 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks for indentation of the first non-blank non-comment
+      # This cop checks for indentation of the first non-blank non-comment
       # line in a file.
+      #
+      # @example
+      #   # bad
+      #      class A
+      #        def foo; end
+      #      end
+      #
+      #   # good
+      #   class A
+      #     def foo; end
+      #   end
+      #
       class InitialIndentation < Cop
-        MSG = 'Indentation of first line in file detected.'.freeze
+        include RangeHelp
+
+        MSG = 'Indentation of first line in file detected.'
 
         def investigate(_processed_source)
           space_before(first_token) do |space|
@@ -21,21 +35,23 @@ module RuboCop
         private
 
         def first_token
-          processed_source.tokens.find { |t| !t.text.start_with?('#') }
+          processed_source.find_token { |t| !t.text.start_with?('#') }
         end
 
         def space_before(token)
           return unless token
-          return if token.pos.column.zero?
+          return if token.column.zero?
 
-          token_with_space =
-            range_with_surrounding_space(token.pos, :left, 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.
-          return if token_with_space == token.pos
+          return if space_range == token.pos
 
-          yield range_between(token_with_space.begin_pos, token.pos.begin_pos)
+          yield range_between(space_range.begin_pos, token.begin_pos)
         end
       end
     end

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

@@ -16,20 +16,55 @@ module RuboCop
       #
       #   # good
       #   # Some comment
+      #
+      # @example AllowDoxygenCommentStyle: false (default)
+      #
+      #   # bad
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
+      # @example AllowDoxygenCommentStyle: true
+      #
+      #   # good
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
+      # @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 < Cop
-        MSG = 'Missing space after `#`.'.freeze
+        include RangeHelp
+
+        MSG = 'Missing space after `#`.'
 
         def investigate(processed_source)
-          processed_source.comments.each do |comment|
-            next unless comment.text =~ /\A#+[^#\s=:+-]/
+          processed_source.each_comment do |comment|
+            next unless /\A#+[^#\s=:+-]/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
+            next if doxygen_comment_style?(comment)
+            next if gemfile_ruby_comment?(comment)
 
             add_offense(comment)
           end
         end
 
-        private
-
         def autocorrect(comment)
           expr = comment.loc.expression
           hash_mark = range_between(expr.begin_pos, expr.begin_pos + 1)
@@ -37,6 +72,8 @@ module RuboCop
           ->(corrector) { corrector.insert_after(hash_mark, ' ') }
         end
 
+        private
+
         def allowed_on_first_line?(comment)
           shebang?(comment) || rackup_config_file? && rackup_options?(comment)
         end
@@ -50,7 +87,31 @@ module RuboCop
         end
 
         def rackup_config_file?
-          File.basename(processed_source.buffer.name).eql?('config.ru')
+          File.basename(processed_source.file_path).eql?('config.ru')
+        end
+
+        def allow_doxygen_comment?
+          cop_config['AllowDoxygenCommentStyle']
+        end
+
+        def doxygen_comment_style?(comment)
+          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

@@ -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 LeadingEmptyLines < Cop
+        MSG = 'Unnecessary blank line at the beginning of the source.'
+
+        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.buffer,
+                                            0,
+                                            node.begin_pos)
+
+          lambda do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end