rubocop 1.1.0 → 1.4.1

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

@@ -13,7 +13,8 @@ module RuboCop
       # `AllowAdjacentOneLineDefs` configures whether adjacent
       # one-line method definitions are considered an offense.
       #
-      # @example
+      # @example EmptyLineBetweenMethodDefs: true (default)
+      #   # checks for empty lines between method definitions.
       #
       #   # bad
       #   def a
@@ -29,11 +30,57 @@ module RuboCop
       #
       #   def b
       #   end
+      #
+      # @example EmptyLineBetweenClassDefs: true (default)
+      #   # checks for empty lines between class definitions.
+      #
+      #   # bad
+      #   class A
+      #   end
+      #   class B
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   class A
+      #   end
+      #
+      #   class B
+      #   end
+      #
+      #   def b
+      #   end
+      #
+      # @example EmptyLineBetweenModuleDefs: true (default)
+      #   # checks for empty lines between module definitions.
+      #
+      #   # bad
+      #   module A
+      #   end
+      #   module B
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   module A
+      #   end
+      #
+      #   module B
+      #   end
+      #
+      #   def b
+      #   end
       class EmptyLineBetweenDefs < Base
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use empty lines between method definitions.'
+        MSG = 'Use empty lines between %<type>s definitions.'
 
         def self.autocorrect_incompatible_with
           [Layout::EmptyLines]
@@ -47,7 +94,7 @@ module RuboCop
         def on_begin(node)
           node.children.each_cons(2) do |prev, n|
             nodes = [prev, n]
-            check_defs(nodes) if nodes.all?(&method(:def_node?))
+            check_defs(nodes) if nodes.all? { |def_candidate| candidate?(def_candidate) }
           end
         end
 
@@ -57,8 +104,9 @@ module RuboCop
           return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
-          location = nodes.last.loc.keyword.join(nodes.last.loc.name)
-          add_offense(location) do |corrector|
+          correction_node = nodes.last
+          location = correction_node.loc.keyword.join(correction_node.loc.name)
+          add_offense(location, message: message(correction_node)) do |corrector|
             autocorrect(corrector, *nodes)
           end
         end
@@ -83,10 +131,32 @@ module RuboCop
 
         private
 
-        def def_node?(node)
+        def candidate?(node)
           return unless node
 
-          node.def_type? || node.defs_type?
+          method_candidate?(node) || class_candidate?(node) || module_candidate?(node)
+        end
+
+        def method_candidate?(node)
+          cop_config['EmptyLineBetweenMethodDefs'] && (node.def_type? || node.defs_type?)
+        end
+
+        def class_candidate?(node)
+          cop_config['EmptyLineBetweenClassDefs'] && node.class_type?
+        end
+
+        def module_candidate?(node)
+          cop_config['EmptyLineBetweenModuleDefs'] && node.module_type?
+        end
+
+        def message(node)
+          type = case node.type
+                 when :def, :defs
+                   :method
+                 else
+                   node.type
+                 end
+          format(MSG, type: type)
         end
 
         def multiple_blank_lines_groups?(first_def_node, second_def_node)

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

@@ -137,10 +137,10 @@ module RuboCop
         def asgn_variable_align_with(outer_node, inner_node)
           expr = outer_node.source_range
 
-          if !line_break_before_keyword?(expr, inner_node)
-            range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
-          else
+          if line_break_before_keyword?(expr, inner_node)
             inner_node.loc.keyword
+          else
+            range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
           end
         end
 

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

@@ -296,13 +296,13 @@ module RuboCop
           # just give each lambda the same reference and they would all get the
           # last value of each. A local variable fixes the problem.
 
-          if !node.value
-            delta_value = delta[:key] || 0
-            correct_no_value(corrector, delta_value, node.source_range)
-          else
+          if node.value
             correct_key_value(corrector, delta, node.key.source_range,
                               node.value.source_range,
                               node.loc.operator)
+          else
+            delta_value = delta[:key] || 0
+            correct_no_value(corrector, delta_value, node.source_range)
           end
         end
 

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

@@ -88,6 +88,10 @@ module RuboCop
           end
         end
 
+        def correctable?
+          super && !breakable_range.nil?
+        end
+
         def autocorrect(range)
           return if range.nil?
 
@@ -98,6 +102,8 @@ module RuboCop
 
         private
 
+        attr_accessor :breakable_range
+
         def check_for_breakable_node(node)
           breakable_node = extract_breakable_node(node, max)
           return if breakable_node.nil?
@@ -195,7 +201,8 @@ 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]
+          self.breakable_range = breakable_range_by_line_index[line_index]
+
           add_offense(breakable_range, location: loc, message: message) do
             self.max = line_length(line)
           end

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

@@ -54,17 +54,11 @@ module RuboCop
         end
 
         def check_inside_pipes(arguments)
-          opening_pipe, closing_pipe = pipes(arguments)
-
           case style
           when :no_space
-            check_no_space_style_inside_pipes(arguments.children,
-                                              opening_pipe,
-                                              closing_pipe)
+            check_no_space_style_inside_pipes(arguments)
           when :space
-            check_space_style_inside_pipes(arguments.children,
-                                           opening_pipe,
-                                           closing_pipe)
+            check_space_style_inside_pipes(arguments)
           end
         end
 
@@ -76,22 +70,29 @@ module RuboCop
                       closing_pipe, 'after closing `|`')
         end
 
-        def check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+        def check_no_space_style_inside_pipes(arguments)
+          args = arguments.children
+          opening_pipe, closing_pipe = pipes(arguments)
+
           first = args.first.source_range
           last = args.last.source_range
 
           check_no_space(opening_pipe.end_pos, first.begin_pos,
                          'Space before first')
-          check_no_space(last_end_pos_inside_pipes(last),
+          check_no_space(last_end_pos_inside_pipes(arguments, last),
                          closing_pipe.begin_pos, 'Space after last')
         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)
+        def check_space_style_inside_pipes(arguments)
+          opening_pipe, closing_pipe = pipes(arguments)
+
+          check_opening_pipe_space(arguments, opening_pipe)
+          check_closing_pipe_space(arguments, closing_pipe)
         end
 
-        def check_opening_pipe_space(args, opening_pipe)
+        def check_opening_pipe_space(arguments, opening_pipe)
+          args = arguments.children
+
           first_arg = args.first
           range = first_arg.source_range
 
@@ -101,9 +102,11 @@ module RuboCop
                          'Extra space before first')
         end
 
-        def check_closing_pipe_space(args, closing_pipe)
+        def check_closing_pipe_space(arguments, closing_pipe)
+          args = arguments.children
+
           last         = args.last.source_range
-          last_end_pos = last_end_pos_inside_pipes(last)
+          last_end_pos = last_end_pos_inside_pipes(arguments, last)
 
           check_space(last_end_pos, closing_pipe.begin_pos, last,
                       'after last block parameter')
@@ -111,9 +114,12 @@ module RuboCop
                          'Extra space after last')
         end
 
-        def last_end_pos_inside_pipes(range)
+        def last_end_pos_inside_pipes(arguments, range)
           pos = range.end_pos
-          range.source_buffer.source[pos] == ',' ? pos + 1 : pos
+          num = pos - arguments.source_range.begin_pos
+          trailing_comma_index = arguments.source[num..-1].index(',')
+
+          trailing_comma_index ? pos + trailing_comma_index + 1 : pos
         end
 
         def check_each_arg(args)

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

@@ -51,7 +51,7 @@ module RuboCop
         alias on_csend on_send
 
         def on_const(node)
-          return unless node.loc.double_colon
+          return unless node.loc.respond_to?(:double_colon) && node.loc.double_colon
 
           check_space_after_double_colon(node)
         end

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

@@ -11,10 +11,12 @@ module RuboCop
       #   # bad
       #   f( 3)
       #   g = (a + 3 )
+      #   f( )
       #
       #   # good
       #   f(3)
       #   g = (a + 3)
+      #   f()
       #
       # @example EnforcedStyle: space
       #   # The `space` style enforces that parentheses have a space at the
@@ -44,11 +46,7 @@ module RuboCop
           @processed_source = processed_source
 
           if style == :space
-            each_missing_space(processed_source.tokens) do |range|
-              add_offense(range, message: MSG_SPACE) do |corrector|
-                corrector.insert_before(range, ' ')
-              end
-            end
+            process_with_space_style(processed_source)
           else
             each_extraneous_space(processed_source.tokens) do |range|
               add_offense(range) do |corrector|
@@ -60,6 +58,21 @@ module RuboCop
 
         private
 
+        def process_with_space_style(processed_source)
+          processed_source.tokens.each_cons(2) do |token1, token2|
+            each_extraneous_space_in_empty_parens(token1, token2) do |range|
+              add_offense(range) do |corrector|
+                corrector.remove(range)
+              end
+            end
+            each_missing_space(token1, token2) do |range|
+              add_offense(range, message: MSG_SPACE) do |corrector|
+                corrector.insert_before(range, ' ')
+              end
+            end
+          end
+        end
+
         def each_extraneous_space(tokens)
           tokens.each_cons(2) do |token1, token2|
             next unless parens?(token1, token2)
@@ -73,15 +86,21 @@ module RuboCop
           end
         end
 
-        def each_missing_space(tokens)
-          tokens.each_cons(2) do |token1, token2|
-            next if can_be_ignored?(token1, token2)
+        def each_extraneous_space_in_empty_parens(token1, token2)
+          return unless token1.left_parens? && token2.right_parens?
 
-            if token1.left_parens?
-              yield range_between(token2.begin_pos, token2.begin_pos + 1)
-            elsif token2.right_parens?
-              yield range_between(token2.begin_pos, token2.end_pos)
-            end
+          return if range_between(token1.begin_pos, token2.end_pos).source == '()'
+
+          yield range_between(token1.end_pos, token2.begin_pos)
+        end
+
+        def each_missing_space(token1, token2)
+          return if can_be_ignored?(token1, token2)
+
+          if token1.left_parens?
+            yield range_between(token2.begin_pos, token2.begin_pos + 1)
+          elsif token2.right_parens?
+            yield range_between(token2.begin_pos, token2.end_pos)
           end
         end
 
@@ -96,6 +115,9 @@ module RuboCop
         def can_be_ignored?(token1, token2)
           return true unless parens?(token1, token2)
 
+          # Ignore empty parentheses.
+          return true if range_between(token1.begin_pos, token2.end_pos).source == '()'
+
           # If the second token is a comment, that means that a line break
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?

data/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb

@@ -53,7 +53,8 @@ module RuboCop
         def find_offense_node(node, regexp_receiver)
           return node unless node.parent
 
-          if node.parent.send_type? || method_chain_to_regexp_receiver?(node, regexp_receiver)
+          if (node.parent.send_type? && node.receiver) ||
+             method_chain_to_regexp_receiver?(node, regexp_receiver)
             node = find_offense_node(node.parent, regexp_receiver)
           end
 

data/lib/rubocop/cop/lint/constant_definition_in_block.rb

@@ -49,7 +49,21 @@ module RuboCop
       #       const_set(:LIST, [])
       #     end
       #   end
+      #
+      # @example AllowedMethods: ['enums'] (default)
+      #   # good
+      #
+      #   # `enums` for Typed Enums via `T::Enum` in Sorbet.
+      #   # https://sorbet.org/docs/tenum
+      #   class TestEnum < T::Enum
+      #     enums do
+      #       Foo = new("foo")
+      #     end
+      #   end
+      #
       class ConstantDefinitionInBlock < Base
+        include AllowedMethods
+
         MSG = 'Do not define constants this way within a block.'
 
         def_node_matcher :constant_assigned_in_block?, <<~PATTERN
@@ -61,13 +75,23 @@ module RuboCop
         PATTERN
 
         def on_casgn(node)
-          add_offense(node) if constant_assigned_in_block?(node)
+          return if !constant_assigned_in_block?(node) || allowed_method?(method_name(node))
+
+          add_offense(node)
         end
 
         def on_class(node)
-          add_offense(node) if module_defined_in_block?(node)
+          return if !module_defined_in_block?(node) || allowed_method?(method_name(node))
+
+          add_offense(node)
         end
         alias on_module on_class
+
+        private
+
+        def method_name(node)
+          node.ancestors.find(&:block_type?).send_node.method_name
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/debugger.rb

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks for calls to debugger or pry.
+      # The cop can be configured to define which methods and receivers must be fixed.
       #
       # @example
       #
@@ -35,33 +36,11 @@ module RuboCop
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
-        RESTRICT_ON_SEND = %i[
-          debugger byebug remote_byebug pry remote_pry pry_remote console rescue
-          save_and_open_page save_and_open_screenshot irb
-        ].freeze
-
-        def_node_matcher :kernel?, <<~PATTERN
-          {
-            (const nil? :Kernel)
-            (const (cbase) :Kernel)
-          }
-        PATTERN
-
-        def_node_matcher :debugger_call?, <<~PATTERN
-          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
-           (send (send {#kernel? nil?} :binding)
-             {:pry :remote_pry :pry_remote :console} ...)
-           (send (const {nil? (cbase)} :Pry) :rescue ...)
-           (send nil? {:save_and_open_page
-                      :save_and_open_screenshot} ...)}
-        PATTERN
-
-        def_node_matcher :binding_irb_call?, <<~PATTERN
-          (send (send {#kernel? nil?} :binding) :irb ...)
-        PATTERN
+        RESTRICT_ON_SEND = [].freeze
 
         def on_send(node)
-          return unless debugger_call?(node) || binding_irb?(node)
+          return unless debugger_method?(node.method_name)
+          return if !node.receiver.nil? && !debugger_receiver?(node)
 
           add_offense(node)
         end
@@ -72,8 +51,19 @@ module RuboCop
           format(MSG, source: node.source)
         end
 
-        def binding_irb?(node)
-          binding_irb_call?(node)
+        def debugger_method?(name)
+          cop_config.fetch('DebuggerMethods', []).include?(name.to_s)
+        end
+
+        def debugger_receiver?(node)
+          receiver = case node.receiver
+                     when RuboCop::AST::SendNode
+                       node.receiver.method_name
+                     when RuboCop::AST::ConstNode
+                       node.receiver.const_name
+                     end
+
+          cop_config.fetch('DebuggerReceivers', []).include?(receiver.to_s)
         end
       end
     end