rubocop 1.7.0 → 1.10.0

data/lib/rubocop/cop/internal_affairs/redundant_described_class_as_subject.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # This cop checks for redundant `subject(:cop) { described_class.new }`.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe RuboCop::Cop::Department::Foo do
+      #     subject(:cop) { described_class.new(config) }
+      #   end
+      #
+      #   # good
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #   end
+      #
+      class RedundantDescribedClassAsSubject < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `subject`%<additional_message>s.'
+
+        def_node_matcher :described_class_subject?, <<~PATTERN
+          (block
+            (send nil? :subject
+              (sym :cop))
+            (args)
+            (send
+              (send nil? :described_class) :new
+              $...))
+        PATTERN
+
+        def on_block(node)
+          return unless (described_class_arguments = described_class_subject?(node))
+          return if described_class_arguments.count >= 2
+
+          describe = find_describe_method_node(node)
+
+          unless (exist_config = describe.last_argument.source == ':config')
+            additional_message = ' and specify `:config` in `describe`'
+          end
+
+          message = format(MSG, additional_message: additional_message)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+
+            corrector.insert_after(describe.last_argument, ', :config') unless exist_config
+          end
+        end
+
+        private
+
+        def find_describe_method_node(block_node)
+          block_node.ancestors.find { |node| node.block_type? && node.method?(:describe) }.send_node
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_let_rubocop_config_new.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # This cop checks that `let` is `RuboCop::Config.new` with no arguments.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #     let(:config) { RuboCop::Config.new }
+      #   end
+      #
+      #   # good
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #   end
+      #
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #     let(:config) { RuboCop::Config.new(argument) }
+      #   end
+      #
+      class RedundantLetRuboCopConfigNew < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove `let` that is `RuboCop::Config.new` with no arguments%<additional_message>s.'
+
+        def_node_matcher :let_rubocop_config_new?, <<~PATTERN
+          (block
+            (send nil? :let
+              (sym :config))
+            (args)
+            (send
+              (const
+                (const nil? :RuboCop) :Config) :new))
+        PATTERN
+
+        def on_block(node)
+          return unless let_rubocop_config_new?(node)
+
+          describe = find_describe_method_node(node)
+
+          unless (exist_config = describe.last_argument.source == ':config')
+            additional_message = ' and specify `:config` in `describe`'
+          end
+
+          message = format(MSG, additional_message: additional_message)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+
+            corrector.insert_after(describe.last_argument, ', :config') unless exist_config
+          end
+        end
+
+        private
+
+        def find_describe_method_node(block_node)
+          block_node.ancestors.find { |node| node.block_type? && node.method?(:describe) }.send_node
+        end
+      end
+    end
+  end
+end

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

@@ -213,7 +213,12 @@ module RuboCop
           name = node.method_name.to_s
           category, = categories.find { |_, names| names.include?(name) }
           key = category || name
-          visibility_key = "#{node_visibility(node)}_#{key}"
+          visibility_key =
+            if node.def_modifier?
+              "#{name}_methods"
+            else
+              "#{node_visibility(node)}_#{key}"
+            end
           expected_order.include?(visibility_key) ? visibility_key : key
         end
 
@@ -264,7 +269,7 @@ module RuboCop
 
         def source_range_with_comment(node)
           begin_pos, end_pos =
-            if node.def_type?
+            if node.def_type? && !node.method?(:initialize) || node.send_type? && node.def_modifier?
               start_node = find_visibility_start(node) || node
               end_node = find_visibility_end(node) || node
               [begin_pos_with_comment(start_node),

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

@@ -88,7 +88,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use empty lines between %<type>s definitions.'
+        MSG = 'Expected %<expected>s between %<type>s definitions; found %<actual>d.'
 
         def self.autocorrect_incompatible_with
           [Layout::EmptyLines]
@@ -107,19 +107,21 @@ module RuboCop
         end
 
         def check_defs(nodes)
-          return if blank_lines_between?(*nodes)
+          count = blank_lines_count_between(*nodes)
+
+          return if line_count_allowed?(count)
           return if multiple_blank_lines_groups?(*nodes)
           return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
           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)
+          add_offense(location, message: message(correction_node, count: count)) do |corrector|
+            autocorrect(corrector, *nodes, count)
           end
         end
 
-        def autocorrect(corrector, prev_def, node)
+        def autocorrect(corrector, prev_def, node, count)
           # finds position of first newline
           end_pos = end_loc(prev_def).end_pos
           source_buffer = end_loc(prev_def).source_buffer
@@ -128,8 +130,6 @@ module RuboCop
           # Handle the case when multiple one-liners are on the same line.
           newline_pos = end_pos + 1 if newline_pos > node.source_range.begin_pos
 
-          count = blank_lines_count_between(prev_def, node)
-
           if count > maximum_empty_lines
             autocorrect_remove_lines(corrector, newline_pos, count)
           else
@@ -157,14 +157,22 @@ module RuboCop
           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)
+        def message(node, count: nil)
+          type = node_type(node)
+
+          format(MSG,
+                 type: type,
+                 expected: expected_lines,
+                 actual: count)
+        end
+
+        def expected_lines
+          if allowance_range?
+            "#{minimum_empty_lines..maximum_empty_lines} empty lines"
+          else
+            lines = maximum_empty_lines == 1 ? 'line' : 'lines'
+            "#{maximum_empty_lines} empty #{lines}"
+          end
         end
 
         def multiple_blank_lines_groups?(first_def_node, second_def_node)
@@ -176,8 +184,7 @@ module RuboCop
           blank_start > non_blank_end
         end
 
-        def blank_lines_between?(first_def_node, second_def_node)
-          count = blank_lines_count_between(first_def_node, second_def_node)
+        def line_count_allowed?(count)
           (minimum_empty_lines..maximum_empty_lines).cover?(count)
         end
 
@@ -210,7 +217,7 @@ module RuboCop
         end
 
         def end_loc(node)
-          if node.def_type? && node.endless?
+          if (node.def_type? || node.defs_type?) && node.endless?
             node.loc.expression.end
           else
             node.loc.end
@@ -230,6 +237,19 @@ module RuboCop
 
           corrector.insert_after(where_to_insert, "\n" * difference)
         end
+
+        def node_type(node)
+          case node.type
+          when :def, :defs
+            :method
+          else
+            node.type
+          end
+        end
+
+        def allowance_range?
+          minimum_empty_lines != maximum_empty_lines
+        end
       end
     end
   end

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

@@ -4,11 +4,14 @@ module RuboCop
   module Cop
     module Layout
       # This cop checks the indentation of the first argument in a method call.
-      # Arguments after the first one are checked by Layout/ArgumentAlignment,
+      # Arguments after the first one are checked by `Layout/ArgumentAlignment`,
       # not by this cop.
       #
       # For indenting the first parameter of method _definitions_, check out
-      # Layout/FirstParameterIndentation.
+      # `Layout/FirstParameterIndentation`.
+      #
+      # This cop will respect `Layout/ArgumentAlignment` and will not work when
+      # `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArgumentAlignment`.
       #
       # @example
       #
@@ -149,6 +152,7 @@ module RuboCop
         MSG = 'Indent the first argument one step more than %<base>s.'
 
         def on_send(node)
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
           return if !node.arguments? || node.operator_method?
 
           indent = base_indentation(node) + configured_indentation_width
@@ -250,6 +254,16 @@ module RuboCop
         def on_new_investigation
           @comment_lines = nil
         end
+
+        def enforce_first_argument_with_fixed_indentation?
+          return false unless argument_alignment_config['Enabled']
+
+          argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def argument_alignment_config
+          config.for_cop('Layout/ArgumentAlignment')
+        end
       end
     end
   end

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

@@ -60,12 +60,13 @@ module RuboCop
       #   }
       class LineLength < Base
         include CheckLineBreakable
-        include ConfigurableMax
         include IgnoredPattern
         include RangeHelp
         include LineLengthHelp
         extend AutoCorrector
 
+        exclude_limit 'Max'
+
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
         def on_block(node)

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

@@ -31,6 +31,32 @@ module RuboCop
       #   foo = if expression
       #     'bar'
       #   end
+      #
+      # @example SupportedTypes: ['block', 'case', 'class', 'if', 'kwbegin', 'module'] (default)
+      #   # good
+      #   foo =
+      #     if expression
+      #       'bar'
+      #     end
+      #
+      #   # good
+      #   foo =
+      #     [1].map do |i|
+      #       i + 1
+      #     end
+      #
+      # @example SupportedTypes: ['block']
+      #   # good
+      #   foo = if expression
+      #     'bar'
+      #   end
+      #
+      #   # good
+      #   foo =
+      #     [1].map do |i|
+      #       'bar' * i
+      #     end
+      #
       class MultilineAssignmentLayout < Base
         include CheckAssignment
         include ConfigurableEnforcedStyle

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

@@ -16,14 +16,14 @@ module RuboCop
       #   if a +
       #       b
       #     something &&
-      #     something_else
+      #       something_else
       #   end
       #
       #   # good
       #   if a +
       #      b
       #     something &&
-      #       something_else
+      #     something_else
       #   end
       #
       # @example EnforcedStyle: indented

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

@@ -6,10 +6,6 @@ module RuboCop
       # Checks for space between the name of a receiver and a left
       # brackets.
       #
-      # This cop is marked as unsafe because it can occur false positives
-      # for `do_something [this_is_an_array_literal_argument]` that take
-      # an array without parentheses as an argument.
-      #
       # @example
       #
       #   # bad
@@ -25,28 +21,35 @@ module RuboCop
         MSG = 'Remove the space before the opening brackets.'
 
         def on_send(node)
-          return if node.parenthesized? || node.parent&.send_type?
           return unless (first_argument = node.first_argument)
 
           begin_pos = first_argument.source_range.begin_pos
-
-          return unless (range = offense_range(node, first_argument, begin_pos))
+          return unless (range = offense_range(node, begin_pos))
 
           register_offense(range)
         end
 
         private
 
-        def offense_range(node, first_argument, begin_pos)
-          if space_before_brackets?(node, first_argument)
-            range_between(node.loc.selector.end_pos, begin_pos)
+        def offense_range(node, begin_pos)
+          if reference_variable_with_brackets?(node)
+            receiver_end_pos = node.receiver.source_range.end_pos
+            selector_begin_pos = node.loc.selector.begin_pos
+            return if receiver_end_pos >= selector_begin_pos
+
+            range_between(receiver_end_pos, selector_begin_pos)
           elsif node.method?(:[]=)
-            end_pos = node.receiver.source_range.end_pos
+            offense_range_for_assignment(node, begin_pos)
+          end
+        end
 
-            return if begin_pos - end_pos == 1
+        def offense_range_for_assignment(node, begin_pos)
+          end_pos = node.receiver.source_range.end_pos
 
-            range_between(end_pos, begin_pos - 1)
-          end
+          return if begin_pos - end_pos == 1 ||
+                    (range = range_between(end_pos, begin_pos - 1)).source.start_with?('[')
+
+          range
         end
 
         def register_offense(range)
@@ -55,8 +58,8 @@ module RuboCop
           end
         end
 
-        def space_before_brackets?(node, first_argument)
-          node.receiver.nil? && first_argument.array_type? && node.arguments.size == 1
+        def reference_variable_with_brackets?(node)
+          node.receiver&.variable? && node.method?(:[]) && node.arguments.size == 1
         end
       end
     end

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

@@ -3,8 +3,21 @@
 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.
+      # This cop checks for debug calls (such as `debugger` or `binding.pry`) that should
+      # not be kept for production code.
+      #
+      # The cop can be configured using `DebuggerMethods`. By default, a number of gems
+      # debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `Pry`, `Rails`,
+      # and `WebConsole`). Additional methods can be added.
+      #
+      # Specific default groups can be disabled if necessary:
+      #
+      # [source,yaml]
+      # ----
+      # Lint/Debugger:
+      #   WebConsole: ~
+      # ---
+      #
       #
       # @example
       #
@@ -33,14 +46,32 @@ module RuboCop
       #   def some_method
       #     do_something
       #   end
+      #
+      # @example DebuggerMethods: [my_debugger]
+      #
+      #   # bad (ok during development)
+      #
+      #   def some_method
+      #     my_debugger
+      #   end
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
         RESTRICT_ON_SEND = [].freeze
 
+        def_node_matcher :kernel?, <<~PATTERN
+          (const {nil? cbase} :Kernel)
+        PATTERN
+
+        def_node_matcher :valid_receiver?, <<~PATTERN
+          {
+            (const {nil? cbase} %1)
+            (send {nil? #kernel?} %1)
+          }
+        PATTERN
+
         def on_send(node)
-          return unless debugger_method?(node.method_name)
-          return if !node.receiver.nil? && !debugger_receiver?(node)
+          return unless debugger_method?(node)
 
           add_offense(node)
         end
@@ -51,19 +82,32 @@ module RuboCop
           format(MSG, source: node.source)
         end
 
-        def debugger_method?(name)
-          cop_config.fetch('DebuggerMethods', []).include?(name.to_s)
+        def debugger_methods
+          @debugger_methods ||= begin
+            config = cop_config.fetch('DebuggerMethods', [])
+            values = config.is_a?(Array) ? config : config.values.flatten
+            values.map do |v|
+              next unless v
+
+              *receiver, method_name = v.split('.')
+              {
+                receiver: receiver.empty? ? nil : receiver.join.to_sym,
+                method_name: method_name.to_sym
+              }
+            end.compact
+          end
         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
+        def debugger_method?(send_node)
+          debugger_methods.any? do |method|
+            next unless method[:method_name] == send_node.method_name
 
-          cop_config.fetch('DebuggerReceivers', []).include?(receiver.to_s)
+            if method[:receiver].nil?
+              send_node.receiver.nil?
+            else
+              valid_receiver?(send_node.receiver, method[:receiver])
+            end
+          end
         end
       end
     end