rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/{style → layout}/indentation_consistency.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cops checks for inconsistent indentation.
       #
       # @example
@@ -15,8 +14,7 @@ module RuboCop
       #     end
       #   end
       class IndentationConsistency < Cop
-        include AutocorrectAlignment
-        include AccessModifierNode
+        include Alignment
         include ConfigurableEnforcedStyle
 
         MSG = 'Inconsistent indentation detected.'.freeze
@@ -29,6 +27,10 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
         private
 
         def check(node)
@@ -38,7 +40,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 modifier_node?(child)
+            if child.send_type? && child.access_modifier?
               children_to_check << [] if style == :rails
             else
               children_to_check.last << child

data/lib/rubocop/cop/{style → layout}/indentation_width.rb

@@ -1,40 +1,70 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
-      # This cops checks for indentation that doesn't use two spaces.
+    module Layout
+      # This cops checks for indentation that doesn't use the specified number
+      # of spaces.
       #
-      # @example
+      # See also the IndentationConsistency cop which is the companion to this
+      # one.
       #
+      # @example
+      #   # bad
       #   class A
       #    def test
       #     puts 'hello'
       #    end
       #   end
-      class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
+      #
+      #   # good
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #     end
+      #   end
+      #
+      # @example IgnoredPatterns: ['^\s*module']
+      #   # bad
+      #   module A
+      #   class B
+      #     def test
+      #     puts 'hello'
+      #     end
+      #   end
+      #   end
+      #
+      #   # good
+      #   module A
+      #   class B
+      #     def test
+      #       puts 'hello'
+      #     end
+      #   end
+      #   end
+      class IndentationWidth < Cop
         include EndKeywordAlignment
-        include AutocorrectAlignment
-        include OnMethodDef
+        include Alignment
         include CheckAssignment
-        include IfNode
-        include AccessModifierNode
+        include IgnoredPattern
+
+        MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
+              'spaces for%<name>s indentation.'.freeze
+
+        SPECIAL_MODIFIERS = %w[private protected].freeze
 
         def on_rescue(node)
-          _begin_node, *rescue_nodes, else_node = *node
-          rescue_nodes.each do |rescue_node|
-            _, _, body = *rescue_node
-            check_indentation(rescue_node.loc.keyword, body)
-          end
+          _begin_node, *_rescue_nodes, else_node = *node
           check_indentation(node.loc.else, else_node)
         end
 
         def on_ensure(node)
-          _body, ensure_body = *node
-          check_indentation(node.loc.keyword, ensure_body)
+          check_indentation(node.loc.keyword, node.body)
         end
 
+        alias on_resbody on_ensure
+        alias on_for     on_ensure
+
         def on_kwbegin(node)
           # Check indentation against end keyword but only if it's first on its
           # line.
@@ -43,125 +73,112 @@ module RuboCop
         end
 
         def on_block(node)
-          _method, _args, body = *node
-          # Check body against end/} indentation. Checking against variable
-          # assignments, etc, would be more difficult. The end/} must be at the
-          # beginning of its line.
-          loc = node.loc
-          check_indentation(loc.end, body) if begins_its_line?(loc.end)
+          end_loc = node.loc.end
+
+          return unless begins_its_line?(end_loc)
+
+          check_indentation(end_loc, node.body)
+
+          return unless indentation_consistency_style == 'rails'
+
+          check_members(end_loc, [node.body])
         end
 
         def on_module(node)
           _module_name, *members = *node
-          check_members(node, members)
+          check_members(node.loc.keyword, members)
         end
 
         def on_class(node)
           _class_name, _base_class, *members = *node
-          check_members(node, members)
-        end
-
-        def check_members(node, members)
-          check_indentation(node.loc.keyword, members.first)
-
-          return unless members.any? && members.first.begin_type?
-          style =
-            config.for_cop('Style/IndentationConsistency')['EnforcedStyle']
-          return unless style == 'rails'
-
-          special = %w(protected private) # Extra indentation step after these.
-          previous_modifier = nil
-          members.first.children.each do |m|
-            if modifier_node?(m) && special.include?(m.source)
-              previous_modifier = m
-            elsif previous_modifier
-              check_indentation(previous_modifier.source_range, m, style)
-              previous_modifier = nil
-            end
-          end
+          check_members(node.loc.keyword, members)
         end
 
         def on_send(node)
           super
-          return unless modifier_and_def_on_same_line?(node)
-          _, _, *args = *node
+          return unless node.adjacent_def_modifier?
 
-          *_, body = *args.first
+          *_, body = *node.first_argument
 
           def_end_config = config.for_cop('Lint/DefEndAlignment')
-          style = def_end_config['AlignWith'] || 'start_of_line'
-          base = style == 'def' ? args.first : node
+          style = def_end_config['EnforcedStyleAlignWith'] || 'start_of_line'
+          base = style == 'def' ? node.first_argument : node
 
           check_indentation(base.source_range, body)
-          ignore_node(args.first)
+          ignore_node(node.first_argument)
         end
 
-        def on_method_def(node, _method_name, _args, body)
-          check_indentation(node.loc.keyword, body) unless ignored_node?(node)
-        end
+        def on_def(node)
+          return if ignored_node?(node)
 
-        def on_for(node)
-          _variable, _collection, body = *node
-          check_indentation(node.loc.keyword, body)
+          check_indentation(node.loc.keyword, node.body)
         end
+        alias on_defs on_def
 
         def on_while(node, base = node)
           return if ignored_node?(node)
 
-          _condition, body = *node
-          return unless node.loc.keyword.begin_pos ==
-                        node.source_range.begin_pos
+          return unless node.single_line_condition?
 
-          check_indentation(base.loc, body)
+          check_indentation(base.loc, node.body)
         end
 
         alias on_until on_while
 
-        def on_case(node)
-          _condition, *branches = *node
-          latest_when = nil
-          branches.compact.each do |b|
-            if b.type == :when
-              # TODO: Revert to the original expression once the fix in Rubinius
-              #   is released.
-              #
-              # Originally this expression was:
-              #
-              #   *_conditions, body = *b
-              #
-              # However it fails on Rubinius 2.2.9 due to its bug:
-              #
-              #   RuntimeError:
-              #     can't modify frozen instance of Array
-              #   # kernel/common/array.rb:988:in `pop'
-              #   # ./lib/rubocop/cop/style/indentation_width.rb:99:in `on_case'
-              #
-              # It seems to be fixed on the current master (0a92c3c).
-              body = b.children.last
-
-              # Check "when" body against "when" keyword indentation.
-              check_indentation(b.loc.keyword, body)
-              latest_when = b
-            else
-              # Since it's not easy to get the position of the "else" keyword,
-              # we check "else" body against latest "when" keyword indentation.
-              check_indentation(latest_when.loc.keyword, b)
-            end
+        def on_case(case_node)
+          case_node.each_when do |when_node|
+            check_indentation(when_node.loc.keyword, when_node.body)
           end
+
+          check_indentation(case_node.when_branches.last.loc.keyword,
+                            case_node.else_branch)
         end
 
         def on_if(node, base = node)
-          return if ignored_node?(node)
-          return if ternary?(node)
-          return if modifier_if?(node)
+          return if ignored_node?(node) || !node.body
+          return if node.ternary? || node.modifier_form?
 
-          _condition, body, else_clause = if_node_parts(node)
+          check_if(node, node.body, node.else_branch, base.loc)
+        end
 
-          check_if(node, body, else_clause, base.loc) if body
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
         end
 
         private
 
+        def check_members(base, members)
+          check_indentation(base, members.first)
+
+          return unless members.any? && members.first.begin_type?
+          return unless indentation_consistency_style == 'rails'
+
+          each_member(members) do |member, previous_modifier|
+            check_indentation(previous_modifier, member,
+                              indentation_consistency_style)
+          end
+        end
+
+        def each_member(members)
+          previous_modifier = nil
+          members.first.children.each do |member|
+            if member.send_type? && special_modifier?(member)
+              previous_modifier = member
+            elsif previous_modifier
+              yield member, previous_modifier.source_range
+              previous_modifier = nil
+            end
+          end
+        end
+
+        def special_modifier?(node)
+          node.access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
+        end
+
+        def indentation_consistency_style
+          config.for_cop('Layout/IndentationConsistency')['EnforcedStyle']
+        end
+
         def check_assignment(node, rhs)
           # If there are method calls chained to the right hand side of the
           # assignment, we let rhs be the receiver of those method calls before
@@ -170,7 +187,7 @@ module RuboCop
           return unless rhs
 
           end_config = config.for_cop('Lint/EndAlignment')
-          style = end_config['AlignWith'] || 'keyword'
+          style = end_config['EnforcedStyleAlignWith'] || 'keyword'
           base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
           case rhs.type
@@ -183,14 +200,14 @@ module RuboCop
         end
 
         def check_if(node, body, else_clause, base_loc)
-          return if ternary?(node)
+          return if node.ternary?
 
           check_indentation(base_loc, body)
           return unless else_clause
 
           # If the else clause is an elsif, it will get its own on_if call so
           # we don't need to process it here.
-          return if elsif?(else_clause)
+          return if else_clause.if_type? && else_clause.elsif?
 
           check_indentation(node.loc.else, else_clause)
         end
@@ -208,7 +225,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.type == :begin && !parentheses?(body_node)
+          if body_node.begin_type? && !parentheses?(body_node)
             body_node = body_node.children.first
           end
 
@@ -223,11 +240,20 @@ module RuboCop
                    body_node
                  end
 
-          indentation_name = style == 'normal' ? '' : "#{style} "
-          add_offense(node, offending_range(body_node, indentation),
-                      format("Use #{configured_indentation_width} (not %d) " \
-                             "spaces for #{indentation_name}indentation.",
-                             indentation))
+          name = style == 'normal' ? '' : " #{style}"
+          message = message(configured_indentation_width, indentation, name)
+
+          add_offense(node, location: offending_range(body_node, indentation),
+                            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
@@ -243,24 +269,29 @@ module RuboCop
         end
 
         def indentation_to_check?(base_loc, body_node)
-          return false unless body_node
+          return false if skip_check?(base_loc, body_node)
+
+          if %i[rescue ensure].include?(body_node.type)
+            block_body, = *body_node
+            return unless block_body
+          end
+
+          true
+        end
+
+        def skip_check?(base_loc, body_node)
+          return true if ignored_line?(base_loc)
+          return true unless body_node
 
           # Don't check if expression is on same line as "then" keyword, etc.
-          return false if body_node.loc.line == base_loc.line
+          return true if body_node.loc.line == base_loc.line
 
-          return false if starts_with_access_modifier?(body_node)
+          return true if starts_with_access_modifier?(body_node)
 
           # Don't check indentation if the line doesn't start with the body.
           # For example, lines like "else do_something".
           first_char_pos_on_line = body_node.source_range.source_line =~ /\S/
-          return false unless body_node.loc.column == first_char_pos_on_line
-
-          if [:rescue, :ensure].include?(body_node.type)
-            block_body, = *body_node
-            return unless block_body
-          end
-
-          true
+          return true unless body_node.loc.column == first_char_pos_on_line
         end
 
         def offending_range(body_node, indentation)
@@ -268,11 +299,14 @@ module RuboCop
           begin_pos = expr.begin_pos
           ind = expr.begin_pos - indentation
           pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
-          Parser::Source::Range.new(expr.source_buffer, pos.begin, pos.end)
+          range_between(pos.begin, pos.end)
         end
 
         def starts_with_access_modifier?(body_node)
-          body_node.type == :begin && modifier_node?(body_node.children.first)
+          return unless body_node.begin_type?
+
+          starting_node = body_node.children.first
+          starting_node.send_type? && starting_node.access_modifier?
         end
 
         def configured_indentation_width

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cops checks for indentation of the first non-blank non-comment
+      # line in a file.
+      class InitialIndentation < Cop
+        MSG = 'Indentation of first line in file detected.'.freeze
+
+        def investigate(_processed_source)
+          space_before(first_token) do |space|
+            add_offense(space, location: first_token.pos)
+          end
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def first_token
+          processed_source.tokens.find { |t| !t.text.start_with?('#') }
+        end
+
+        def space_before(token)
+          return unless token
+          return if token.column.zero?
+
+          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 space_range == token.pos
+
+          yield range_between(space_range.begin_pos, token.begin_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether comments have a leading space after the
+      # `#` denoting the start of the comment. The leading space is not
+      # required for some RDoc special syntax, like `#++`, `#--`,
+      # `#:nodoc`, `=begin`- and `=end` comments, "shebang" directives,
+      # or rackup options.
+      #
+      # @example
+      #
+      #   # bad
+      #   #Some comment
+      #
+      #   # good
+      #   # Some comment
+      class LeadingCommentSpace < Cop
+        MSG = 'Missing space after `#`.'.freeze
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next unless comment.text =~ /\A#+[^#\s=:+-]/
+            next if comment.loc.line == 1 && allowed_on_first_line?(comment)
+
+            add_offense(comment)
+          end
+        end
+
+        def autocorrect(comment)
+          expr = comment.loc.expression
+          hash_mark = range_between(expr.begin_pos, expr.begin_pos + 1)
+
+          ->(corrector) { corrector.insert_after(hash_mark, ' ') }
+        end
+
+        private
+
+        def allowed_on_first_line?(comment)
+          shebang?(comment) || rackup_config_file? && rackup_options?(comment)
+        end
+
+        def shebang?(comment)
+          comment.text.start_with?('#!')
+        end
+
+        def rackup_options?(comment)
+          comment.text.start_with?('#\\')
+        end
+
+        def rackup_config_file?
+          File.basename(processed_source.buffer.name).eql?('config.ru')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → layout}/multiline_array_brace_layout.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks that the closing brace in an array literal is either
       # on the same line as the last array element, or a new line.
       #
@@ -27,35 +26,68 @@ module RuboCop
       # The closing brace of a multi-line array literal must be on the same
       # line as the last element of the array.
       #
-      # @example
+      # @example EnforcedStyle: symmetrical (default)
+      #     # bad
+      #     [ :a,
+      #       :b
+      #     ]
       #
-      #     # symmetrical: bad
-      #     # new_line: good
-      #     # same_line: bad
+      #     # bad
+      #     [
+      #       :a,
+      #       :b ]
+      #
+      #     # good
       #     [ :a,
+      #       :b ]
+      #
+      #     # good
+      #     [
+      #       :a,
       #       :b
       #     ]
       #
-      #     # symmetrical: bad
-      #     # new_line: bad
-      #     # same_line: good
+      # @example EnforcedStyle: new_line
+      #     # bad
       #     [
       #       :a,
       #       :b ]
       #
-      #     # symmetrical: good
-      #     # new_line: bad
-      #     # same_line: good
+      #     # bad
       #     [ :a,
       #       :b ]
       #
-      #     # symmetrical: good
-      #     # new_line: good
-      #     # same_line: bad
+      #     # good
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # good
       #     [
       #       :a,
       #       :b
       #     ]
+      #
+      # @example EnforcedStyle: same_line
+      #     # bad
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # bad
+      #     [
+      #       :a,
+      #       :b
+      #     ]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b ]
+      #
+      #     # good
+      #     [ :a,
+      #       :b ]
       class MultilineArrayBraceLayout < Cop
         include MultilineLiteralBraceLayout
 
@@ -71,11 +103,15 @@ module RuboCop
           'after the last array element.'.freeze
 
         ALWAYS_SAME_LINE_MESSAGE = 'Closing array brace must be on the same ' \
-          'line as teh last array element.'.freeze
+          'line as the last array element.'.freeze
 
         def on_array(node)
           check_brace_layout(node)
         end
+
+        def autocorrect(node)
+          MultilineLiteralBraceCorrector.correct(processed_source, node)
+        end
       end
     end
   end