rubocop 1.3.1 → 1.5.1

data/lib/rubocop/config_regeneration.rb

@@ -16,7 +16,7 @@ module RuboCop
       match = generation_command.match(COMMAND_REGEX)
       return DEFAULT_OPTIONS unless match
 
-      options = match[1].split(' ')
+      options = match[1].split
       Options.new.parse(options).first
     end
 

data/lib/rubocop/config_validator.rb

@@ -42,7 +42,7 @@ module RuboCop
         ConfigLoader.default_configuration.key?(key)
       end
 
-      @config_obsoletion.reject_obsolete_cops_and_parameters
+      check_obsoletions
 
       alert_about_unrecognized_cops(invalid_cop_names)
       check_target_ruby
@@ -68,6 +68,13 @@ module RuboCop
 
     attr_reader :target_ruby
 
+    def check_obsoletions
+      @config_obsoletion.reject_obsolete_cops_and_parameters
+      return unless @config_obsoletion.warnings.any?
+
+      warn Rainbow("Warning: #{@config_obsoletion.warnings.join("\n")}").yellow
+    end
+
     def check_target_ruby
       return if target_ruby.supported?
 

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -39,16 +39,31 @@ module RuboCop
       private
 
       def disable_offense(range)
-        eol_comment = " # rubocop:todo #{cop_name}"
-        needed_line_length = (range.source_line + eol_comment).length
-        if needed_line_length <= max_line_length
-          disable_offense_at_end_of_line(range_of_first_line(range),
-                                         eol_comment)
+        heredoc_range = surrounding_heredoc(range)
+        if heredoc_range
+          disable_offense_before_and_after(range_by_lines(heredoc_range))
         else
-          disable_offense_before_and_after(range_by_lines(range))
+          eol_comment = " # rubocop:todo #{cop_name}"
+          needed_line_length = (range.source_line + eol_comment).length
+          if needed_line_length <= max_line_length
+            disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
+          else
+            disable_offense_before_and_after(range_by_lines(range))
+          end
         end
       end
 
+      def surrounding_heredoc(offense_range)
+        # The empty offense range is an edge case that can be reached from the Lint/Syntax cop.
+        return nil if offense_range.empty?
+
+        heredoc_nodes = processed_source.ast.each_descendant.select do |node|
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+        heredoc_nodes.map { |node| node.loc.expression.join(node.loc.heredoc_end) }
+                     .find { |range| range.contains?(offense_range) }
+      end
+
       def range_of_first_line(range)
         begin_of_first_line = range.begin_pos - range.column
         end_of_first_line = begin_of_first_line + range.source_line.length

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -48,7 +48,7 @@ module RuboCop
       def autocorrect_multiline_words(node, escape, delimiters)
         contents = process_multiline_words(node, escape, delimiters)
         contents << end_content(node.source)
-        contents.join('')
+        contents.join
       end
 
       def autocorrect_words(node, escape, delimiters)

data/lib/rubocop/cop/generator.rb

@@ -139,7 +139,7 @@ module RuboCop
                                     badge: badge,
                                     version_added: version_added)
 
-        injector.inject do
+        injector.inject do # rubocop:disable Lint/UnexpectedBlockArity
           output.puts(format(CONFIGURATION_ADDED_MESSAGE,
                              configuration_file_path: config_file_path))
         end

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

@@ -38,7 +38,7 @@ module RuboCop
 
         def assertions_using_described_class_msg
           described_class_msg(processed_source.ast).reject do |node|
-            node.ancestors.any?(&method(:rspec_expectation_on_msg?))
+            node.ancestors.any? { |ancestor| rspec_expectation_on_msg?(ancestor) }
           end
         end
 

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

@@ -3,17 +3,18 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether method definitions are
-      # separated by one empty line.
+      # This cop checks whether class/module/method definitions are
+      # separated by one or more empty lines.
       #
       # `NumberOfEmptyLines` can be an integer (default is 1) or
       # an array (e.g. [1, 2]) to specify a minimum and maximum
       # number of empty lines permitted.
       #
       # `AllowAdjacentOneLineDefs` configures whether adjacent
-      # one-line method definitions are considered an offense.
+      # one-line 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/empty_lines_around_arguments.rb

@@ -45,7 +45,8 @@ module RuboCop
         MSG = 'Empty line detected around arguments.'
 
         def on_send(node)
-          return if node.single_line? || node.arguments.empty?
+          return if node.single_line? || node.arguments.empty? ||
+                    receiver_and_method_call_on_different_lines?(node)
 
           extra_lines(node) do |range|
             add_offense(range) do |corrector|
@@ -57,6 +58,10 @@ module RuboCop
 
         private
 
+        def receiver_and_method_call_on_different_lines?(node)
+          node.receiver && node.receiver.loc.last_line != node.loc.selector&.line
+        end
+
         def empty_lines(node)
           lines = processed_lines(node)
           lines.select! { |code, _| code.empty? }

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

@@ -37,14 +37,14 @@ module RuboCop
       #   # good
       #   puts 'Hello' # Return character is CR+LF on all platfoms.
       #
-      class EndOfLine < Cop
+      class EndOfLine < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
 
         MSG_DETECTED = 'Carriage return character detected.'
         MSG_MISSING = 'Carriage return character missing.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           last_line = last_line(processed_source)
 
           processed_source.raw_source.each_line.with_index do |line, index|
@@ -54,9 +54,9 @@ module RuboCop
             next unless msg
             next if unimportant_missing_cr?(index, last_line, line)
 
-            range =
-              source_range(processed_source.buffer, index + 1, 0, line.length)
-            add_offense(nil, location: range, message: msg)
+            range = source_range(processed_source.buffer, index + 1, 0, line.length)
+
+            add_offense(range, message: msg)
             # Usually there will be carriage return characters on all or none
             # of the lines in a file, so we report only one offense.
             break

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

@@ -207,8 +207,13 @@ module RuboCop
         PATTERN
 
         def base_range(send_node, arg_node)
-          range_between(send_node.source_range.begin_pos,
-                        arg_node.source_range.begin_pos)
+          parent = send_node.parent
+          start_node = if parent && (parent.splat_type? || parent.kwsplat_type?)
+                         send_node.parent
+                       else
+                         send_node
+                       end
+          range_between(start_node.source_range.begin_pos, arg_node.source_range.begin_pos)
         end
 
         # Returns the column of the given range. For single line ranges, this

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/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/interpolation_check.rb

@@ -23,10 +23,11 @@ module RuboCop
               'Use double quoted strings if you need interpolation.'
 
         def on_str(node)
-          parent = node.parent
-          return if parent && (parent.dstr_type? || parent.regexp_type?)
+          return unless node
+          return if string_or_regex?(node.parent)
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
+          return unless node.loc.begin && node.loc.end
 
           add_offense(node) do |corrector|
             autocorrect(corrector, node)
@@ -35,6 +36,10 @@ module RuboCop
 
         private
 
+        def string_or_regex?(node)
+          node&.dstr_type? || node&.regexp_type?
+        end
+
         def autocorrect(corrector, node)
           starting_token, ending_token = if node.source.include?('"')
                                            ['%{', '}']

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

@@ -95,7 +95,7 @@ module RuboCop
         def autocorrected_value_for_array(node)
           return node.source.gsub('"', '\"') unless node.percent_literal?
 
-          contents_range(node).source.split(' ').to_s.gsub('"', '\"')
+          contents_range(node).source.split.to_s.gsub('"', '\"')
         end
 
         # Does node print its own source when converted to a string?

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

@@ -6,6 +6,11 @@ module RuboCop
       # This cop checks for the presence of constructors and lifecycle callbacks
       # without calls to `super`.
       #
+      # This cop does not consider `method_missing` (and `respond_to_missing?`)
+      # because in some cases it makes sense to overtake what is considered a
+      # missing method. In other cases, the theoretical ideal handling could be
+      # challenging or verbose for no actual gain.
+      #
       # @example
       #   # bad
       #   class Employee < Person
@@ -43,15 +48,13 @@ module RuboCop
 
         STATELESS_CLASSES = %w[BasicObject Object].freeze
 
-        OBJECT_LIFECYCLE_CALLBACKS  = %i[method_missing respond_to_missing?].freeze
         CLASS_LIFECYCLE_CALLBACKS   = %i[inherited].freeze
         METHOD_LIFECYCLE_CALLBACKS  = %i[method_added method_removed method_undefined
                                          singleton_method_added singleton_method_removed
                                          singleton_method_undefined].freeze
 
-        CALLBACKS = (OBJECT_LIFECYCLE_CALLBACKS +
-                      CLASS_LIFECYCLE_CALLBACKS +
-                      METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
+        CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS +
+                     METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
 
         def on_def(node)
           return unless offender?(node)

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

@@ -40,7 +40,7 @@ module RuboCop
       #                     do_something
       #                   end
       #
-      class NoReturnInBeginEndBlocks < Cop
+      class NoReturnInBeginEndBlocks < Base
         MSG = 'Do not `return` in `begin..end` blocks in assignment contexts.'
 
         def on_lvasgn(node)

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for a block that is known to need more positional
+      # block arguments than are given (by default this is configured for
+      # `Enumerable` methods needing 2 arguments). Optional arguments are allowed,
+      # although they don't generally make sense as the default value will
+      # be used. Blocks that have no receiver, or take splatted arguments
+      # (ie. `*args`) are always accepted.
+      #
+      # Keyword arguments (including `**kwargs`) do not get counted towards
+      # this, as they are not used by the methods in question.
+      #
+      # NOTE: This cop matches for method names only and hence cannot tell apart
+      # methods with same name in different classes.
+      #
+      # Method names and their expected arity can be configured like this:
+      #
+      # Methods:
+      #   inject: 2
+      #   reduce: 2
+      #
+      # @example
+      #   # bad
+      #   values.reduce {}
+      #   values.min { |a| a }
+      #   values.sort { |a; b| a + b }
+      #
+      #   # good
+      #   values.reduce { |memo, obj| memo << obj }
+      #   values.min { |a, b| a <=> b }
+      #   values.sort { |*x| x[0] <=> x[1] }
+      #
+      class UnexpectedBlockArity < Base
+        MSG = '`%<method>s` expects at least %<expected>i positional arguments, got %<actual>i.'
+
+        def on_block(node)
+          return if acceptable?(node)
+
+          expected = expected_arity(node.method_name)
+          actual = arg_count(node)
+          return if actual >= expected
+
+          message = format(MSG, method: node.method_name, expected: expected, actual: actual)
+          add_offense(node, message: message)
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def methods
+          cop_config.fetch('Methods', [])
+        end
+
+        def acceptable?(node)
+          !(included_method?(node.method_name) && node.receiver)
+        end
+
+        def included_method?(name)
+          methods.key?(name.to_s)
+        end
+
+        def expected_arity(method)
+          cop_config['Methods'][method.to_s]
+        end
+
+        def arg_count(node)
+          return node.children[1] if node.numblock_type? # the maximum numbered param for the block
+
+          # Only `arg`, `optarg` and `mlhs` (destructuring) count as arguments that
+          # can be used. Keyword arguments are not used for these methods so are
+          # ignored.
+          node.arguments.count do |arg|
+            return Float::INFINITY if arg.restarg_type?
+
+            arg.arg_type? || arg.optarg_type? || arg.mlhs_type?
+          end
+        end
+      end
+    end
+  end
+end