rubocop 0.49.1 → 0.50.0

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

@@ -15,7 +15,6 @@ module RuboCop
       #   end
       class IndentationConsistency < Cop
         include AutocorrectAlignment
-        include AccessModifierNode
         include ConfigurableEnforcedStyle
 
         MSG = 'Inconsistent indentation detected.'.freeze
@@ -37,7 +36,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/layout/indentation_width.rb

@@ -48,9 +48,7 @@ module RuboCop
       class IndentationWidth < Cop
         include EndKeywordAlignment
         include AutocorrectAlignment
-        include OnMethodDef
         include CheckAssignment
-        include AccessModifierNode
         include IgnoredPattern
 
         SPECIAL_MODIFIERS = %w[private protected].freeze
@@ -98,7 +96,7 @@ module RuboCop
 
         def on_send(node)
           super
-          return unless modifier_and_def_on_same_line?(node)
+          return unless node.adjacent_def_modifier?
 
           *_, body = *node.first_argument
 
@@ -110,9 +108,12 @@ module RuboCop
           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)
+        def on_def(node)
+          return if ignored_node?(node)
+
+          check_indentation(node.loc.keyword, node.body)
         end
+        alias on_defs on_def
 
         def on_while(node, base = node)
           return if ignored_node?(node)
@@ -157,7 +158,7 @@ module RuboCop
         def each_member(members)
           previous_modifier = nil
           members.first.children.each do |member|
-            if special_modifier?(member)
+            if member.send_type? && special_modifier?(member)
               previous_modifier = member
             elsif previous_modifier
               yield member, previous_modifier.source_range
@@ -167,7 +168,7 @@ module RuboCop
         end
 
         def special_modifier?(node)
-          modifier_node?(node) && SPECIAL_MODIFIERS.include?(node.source)
+          node.access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
         end
 
         def indentation_consistency_style
@@ -289,7 +290,10 @@ module RuboCop
         end
 
         def starts_with_access_modifier?(body_node)
-          body_node.begin_type? && 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/leading_comment_space.rb

@@ -3,39 +3,54 @@
 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, etc. Neither is it required for
-      # =begin/=end comments.
+      # 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
+        MSG = 'Missing space after `#`.'.freeze
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
             next unless comment.text =~ /\A#+[^#\s=:+-]/
-            next if comment.text.start_with?('#!') && comment.loc.line == 1
+            next if comment.loc.line == 1 && allowed_on_first_line?(comment)
 
-            # in config.ru files, if the first line starts with #\ it is treated
-            # as options (e.g. `#\ -p 8765` sets the request port to 8765)
-            next if comment.text.start_with?('#\\') && comment.loc.line == 1 &&
-                    config_ru?(processed_source.buffer.name)
-
-            add_offense(comment, :expression)
+            add_offense(comment)
           end
         end
 
+        private
+
         def autocorrect(comment)
           expr = comment.loc.expression
-          b = expr.begin_pos
-          hash_mark = range_between(b, b + 1)
+          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 config_ru?(file_path)
-          File.basename(file_path).eql?('config.ru')
+        def rackup_config_file?
+          File.basename(processed_source.buffer.name).eql?('config.ru')
         end
       end
     end

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

@@ -144,25 +144,21 @@ module RuboCop
         def syntactic_alignment_base(lhs, rhs)
           # a if b
           #      .c
-          n = kw_node_with_special_indentation(lhs)
-          if n
-            case n.type
-            when :for            then _, expression, = *n
-            when :return         then expression, = *n
-            when *MODIFIER_NODES then expression, = *n
-            end
-            return expression.source_range
+          kw_node_with_special_indentation(lhs) do |base|
+            return indented_keyword_expression(base).source_range
           end
 
           # a = b
           #     .c
-          n = part_of_assignment_rhs(lhs, rhs)
-          return assignment_rhs(n).source_range if n
+          part_of_assignment_rhs(lhs, rhs) do |base|
+            return assignment_rhs(base).source_range
+          end
 
           # a + b
           #     .c
-          n = operation_rhs(lhs)
-          return n.source_range if n
+          operation_rhs(lhs) do |base|
+            return base.source_range
+          end
         end
 
         # a.b
@@ -202,12 +198,19 @@ module RuboCop
 
         def operation_rhs(node)
           receiver, = *node
-          receiver.each_ancestor(:send) do |a|
-            _, method, args = *a
-            return args if operator?(method) && args &&
-                           within_node?(receiver, args)
+
+          operation_rhs = receiver.each_ancestor(:send).find do |rhs|
+            operator_rhs?(rhs, receiver)
           end
-          nil
+
+          return unless operation_rhs
+
+          yield operation_rhs.first_argument
+        end
+
+        def operator_rhs?(node, receiver)
+          node.operator_method? && node.arguments? &&
+            within_node?(receiver, node.first_argument)
         end
       end
     end

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

@@ -56,7 +56,6 @@ module RuboCop
       #       b
       #     )
       class MultilineMethodDefinitionBraceLayout < Cop
-        include OnMethodDef
         include MultilineLiteralBraceLayout
 
         SAME_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
@@ -73,9 +72,10 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
           'on the same line as the last parameter.'.freeze
 
-        def on_method_def(_node, _method_name, args, _body)
-          check_brace_layout(args)
+        def on_def(node)
+          check_brace_layout(node.arguments)
         end
+        alias on_defs on_def
       end
     end
   end

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

@@ -12,6 +12,12 @@ module RuboCop
       #   b
       #     something
       #   end
+      #
+      #   # good
+      #   if a +
+      #      b
+      #     something
+      #   end
       class MultilineOperationIndentation < Cop
         include ConfigurableEnforcedStyle
         include AutocorrectAlignment

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

@@ -6,6 +6,13 @@ module RuboCop
       # Checks for colon (:) not followed by some kind of space.
       # N.B. this cop does not handle spaces after a ternary operator, which are
       # instead handled by Layout/SpaceAroundOperators.
+      #
+      # @example
+      #   # bad
+      #   def f(a:, b:2); {a:3}; end
+      #
+      #   # good
+      #   def f(a:, b: 2); {a: 3}; end
       class SpaceAfterColon < Cop
         MSG = 'Space missing after colon.'.freeze
 

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

@@ -4,6 +4,16 @@ module RuboCop
   module Cop
     module Layout
       # Checks for comma (,) not followed by some kind of space.
+      #
+      # @example
+      #
+      #   # bad
+      #   1,2
+      #   { foo:bar,}
+      #
+      #   # good
+      #   1, 2
+      #   { foo:bar, }
       class SpaceAfterComma < Cop
         include SpaceAfterPunctuation
 

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

@@ -13,12 +13,11 @@ module RuboCop
       #   # good
       #   def func(x) ... end
       class SpaceAfterMethodName < Cop
-        include OnMethodDef
-
         MSG = 'Do not put a space between a method name and the opening ' \
               'parenthesis.'.freeze
 
-        def on_method_def(_node, _method_name, args, _body)
+        def on_def(node)
+          args = node.arguments
           return unless args.loc.begin && args.loc.begin.is?('(')
           expr = args.source_range
           pos_before_left_paren = range_between(expr.begin_pos - 1,
@@ -27,6 +26,9 @@ module RuboCop
 
           add_offense(pos_before_left_paren, pos_before_left_paren)
         end
+        alias on_defs on_def
+
+        private
 
         def autocorrect(pos_before_left_paren)
           ->(corrector) { corrector.remove(pos_before_left_paren) }

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

@@ -17,7 +17,7 @@ module RuboCop
         def on_send(node)
           return unless node.keyword_bang? && whitespace_after_operator?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def whitespace_after_operator?(node)

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

@@ -75,16 +75,25 @@ module RuboCop
         end
 
         def check_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+          check_opening_pipe_space(args, opening_pipe)
+          check_closing_pipe_space(args, closing_pipe)
+        end
+
+        def check_opening_pipe_space(args, opening_pipe)
           first = args.first.source_range
-          last = args.last.source_range
-          last_end_pos = last_end_pos_inside_pipes(last.end_pos)
 
           check_space(opening_pipe.end_pos, first.begin_pos, first,
                       'before first block parameter')
-          check_space(last_end_pos, closing_pipe.begin_pos, last,
-                      'after last block parameter')
           check_no_space(opening_pipe.end_pos, first.begin_pos - 1,
                          'Extra space before first')
+        end
+
+        def check_closing_pipe_space(args, closing_pipe)
+          last         = args.last.source_range
+          last_end_pos = last_end_pos_inside_pipes(last.end_pos)
+
+          check_space(last_end_pos, closing_pipe.begin_pos, last,
+                      'after last block parameter')
           check_no_space(last_end_pos + 1, closing_pipe.begin_pos,
                          'Extra space after last')
         end

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

@@ -178,16 +178,20 @@ module RuboCop
         def space_after_missing?(range)
           pos = range.end_pos
           char = range.source_buffer.source[pos]
-          return false unless char
-          return false if accept_left_parenthesis?(range) &&
-                          char == '('.freeze
-          return false if accept_left_square_bracket?(range) &&
-                          char == '['.freeze
+
+          return false if accepted_opening_delimiter?(range, char)
           return false if safe_navigation_call?(range, pos)
 
           char !~ /[\s;,#\\\)\}\]\.]/
         end
 
+        def accepted_opening_delimiter?(range, char)
+          return true unless char
+
+          accept_left_square_bracket?(range) && char == '[' ||
+            accept_left_parenthesis?(range) && char == '('
+        end
+
         def accept_left_parenthesis?(range)
           ACCEPT_LEFT_PAREN.include?(range.source)
         end

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

@@ -5,9 +5,23 @@ module RuboCop
     module Layout
       # Checks that block braces have or don't have a space before the opening
       # brace depending on configuration.
+      #
+      # @example
+      #   # bad
+      #   foo.map{ |a|
+      #     a.bar.to_s
+      #   }
+      #
+      #   # good
+      #   foo.map { |a|
+      #     a.bar.to_s
+      #   }
       class SpaceBeforeBlockBraces < Cop
         include ConfigurableEnforcedStyle
 
+        MISSING_MSG = 'Space missing to the left of {.'.freeze
+        DETECTED_MSG = 'Space detected to the left of {.'.freeze
+
         def self.autocorrect_incompatible_with
           [Style::SymbolProc]
         end
@@ -20,6 +34,31 @@ module RuboCop
           used_style =
             space_plus_brace.source.start_with?('{') ? :no_space : :space
 
+          if empty_braces?(node.loc)
+            check_empty(left_brace, space_plus_brace, used_style)
+          else
+            check_non_empty(left_brace, space_plus_brace, used_style)
+          end
+        end
+
+        private
+
+        def check_empty(left_brace, space_plus_brace, used_style)
+          return if style_for_empty_braces == used_style
+
+          config_to_allow_offenses['EnforcedStyleForEmptyBraces'] =
+            used_style.to_s
+
+          if style_for_empty_braces == :space
+            add_offense(left_brace, left_brace, MISSING_MSG)
+          else
+            space = range_between(space_plus_brace.begin_pos,
+                                  left_brace.begin_pos)
+            add_offense(space, space, DETECTED_MSG)
+          end
+        end
+
+        def check_non_empty(left_brace, space_plus_brace, used_style)
           case used_style
           when style  then correct_style_detected
           when :space then space_detected(left_brace, space_plus_brace)
@@ -27,11 +66,8 @@ module RuboCop
           end
         end
 
-        private
-
         def space_missing(left_brace)
-          add_offense(left_brace, left_brace,
-                      'Space missing to the left of {.') do
+          add_offense(left_brace, left_brace, MISSING_MSG) do
             opposite_style_detected
           end
         end
@@ -39,11 +75,20 @@ module RuboCop
         def space_detected(left_brace, space_plus_brace)
           space = range_between(space_plus_brace.begin_pos,
                                 left_brace.begin_pos)
-          add_offense(space, space, 'Space detected to the left of {.') do
+          add_offense(space, space, DETECTED_MSG) do
             opposite_style_detected
           end
         end
 
+        def style_for_empty_braces
+          case cop_config['EnforcedStyleForEmptyBraces']
+          when 'space'    then :space
+          when 'no_space' then :no_space
+          when nil then style
+          else raise 'Unknown EnforcedStyleForEmptyBraces selected!'
+          end
+        end
+
         def autocorrect(range)
           lambda do |corrector|
             case range.source
@@ -52,6 +97,10 @@ module RuboCop
             end
           end
         end
+
+        def empty_braces?(loc)
+          loc.begin.end_pos == loc.end.begin_pos
+        end
       end
     end
   end