rubocop 0.55.0 → 0.56.0

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

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop enforces empty line after guard clause
       #
       # @example

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

@@ -6,12 +6,12 @@ module RuboCop
       # This cop checks whether method definitions are
       # separated by one empty line.
       #
-      # `NumberOfEmptyLines` can be and integer (e.g. 1 by default) or
-      # an array (e.g. [1, 2]) to specificy a minimum and a maximum of
-      # 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` can be used to configure is adjacent
-      # one line methods definitions are an offense
+      # `AllowAdjacentOneLineDefs` configures whether adjacent
+      # one-line method definitions are considered an offense.
       #
       # @example
       #

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Layout
       # This cop checks the indentation of the first parameter in a method call.
-      # Parameters after the first one are checked by Style/AlignParameters, not
-      # by this cop.
+      # Parameters after the first one are checked by Layout/AlignParameters,
+      # not by this cop.
       #
       # @example
       #
@@ -14,10 +14,119 @@ module RuboCop
       #   first_param,
       #   second_param)
       #
+      #   foo = some_method(
+      #   first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #   nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #   nested_call(
+      #   nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #   nested_first_param),
+      #   second_param
+      #
+      #   # Style: consistent
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #     nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     nested_call(
+      #       nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #     nested_first_param),
+      #   second_param
+      #
+      #   # Style: consistent_relative_to_receiver
+      #
       #   # good
       #   some_method(
       #     first_param,
       #   second_param)
+      #
+      #   foo = some_method(
+      #           first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #                       nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #           nested_call(
+      #             nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #                 nested_first_param),
+      #   second_params
+      #
+      #   # Style: special_for_inner_method_call
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #                       nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     nested_call(
+      #       nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #                 nested_first_param),
+      #   second_param
+      #
+      #   # Style: special_for_inner_method_call_in_parentheses
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #                       nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     nested_call(
+      #       nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #     nested_first_param),
+      #   second_param
+      #
       class FirstParameterIndentation < Cop
         include Alignment
         include ConfigurableEnforcedStyle
@@ -65,6 +174,7 @@ module RuboCop
 
         def special_inner_call_indentation?(node)
           return false if style == :consistent
+          return true  if style == :consistent_relative_to_receiver
 
           parent = node.parent
 

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

@@ -66,7 +66,7 @@ module RuboCop
           return if node.multiline?
           return unless bracket_method?(node)
           tokens = tokens(node)
-          left_token = left_ref_bracket(tokens)
+          left_token = left_ref_bracket(node, tokens)
           return unless left_token
           right_token = closing_bracket(tokens, left_token)
 
@@ -101,7 +101,7 @@ module RuboCop
 
         def reference_brackets(node)
           tokens = tokens(node)
-          left = left_ref_bracket(tokens)
+          left = left_ref_bracket(node, tokens)
           [left, closing_bracket(tokens, left)]
         end
 
@@ -110,8 +110,12 @@ module RuboCop
           BRACKET_METHODS.include?(method)
         end
 
-        def left_ref_bracket(tokens)
-          tokens.reverse.find(&:left_ref_bracket?)
+        def left_ref_bracket(node, tokens)
+          if node.method?(:[]=)
+            tokens.find(&:left_ref_bracket?)
+          else
+            tokens.reverse.find(&:left_ref_bracket?)
+          end
         end
 
         def closing_bracket(tokens, opening_bracket)

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # This cop emulates the following Ruby warnings in Ruby 2.6.
+      #
+      # % cat example.rb
+      # ERB.new('hi', nil, '-', '@output_buffer')
+      # % ruby -rerb example.rb
+      # example.rb:1: warning: Passing safe_level with the 2nd argument of
+      # ERB.new is deprecated. Do not use it, and specify other arguments as
+      # keyword arguments.
+      # example.rb:1: warning: Passing trim_mode with the 3rd argument of
+      # ERB.new is deprecated. Use keyword argument like
+      # ERB.new(str, trim_mode:...) instead.
+      # example.rb:1: warning: Passing eoutvar with the 4th argument of ERB.new
+      # is deprecated. Use keyword argument like ERB.new(str, eoutvar: ...)
+      # instead.
+      #
+      # Now non-keyword arguments other than first one are softly deprecated
+      # and will be removed when Ruby 2.5 becomes EOL.
+      # `ERB.new` with non-keyword arguments is deprecated since ERB 2.2.0.
+      # Use `:trim_mode` and `:eoutvar` keyword arguments to `ERB.new`.
+      # This cop identifies places where `ERB.new(str, trim_mode, eoutvar)` can
+      # be replaced by `ERB.new(str, :trim_mode: trim_mode, eoutvar: eoutvar)`.
+      #
+      # @example
+      #   # Target codes supports Ruby 2.6 and higher only
+      #   # bad
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # good
+      #   ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #
+      #   # Target codes supports Ruby 2.5 and lower only
+      #   # good
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # Target codes supports Ruby 2.6, 2.5 and lower
+      #   # bad
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # good
+      #   # Ruby standard library style
+      #   # https://github.com/ruby/ruby/commit/3406c5d
+      #   if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
+      #     ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #   else
+      #     ERB.new(str, nil, '-', '@output_buffer')
+      #   end
+      #
+      #   # good
+      #   # Use `RUBY_VERSION` style
+      #   if RUBY_VERSION >= '2.6'
+      #     ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #   else
+      #     ERB.new(str, nil, '-', '@output_buffer')
+      #   end
+      #
+      class ErbNewArguments < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
+
+        MESSAGES = [
+          'Passing safe_level with the 2nd argument of `ERB.new` is ' \
+          'deprecated. Do not use it, and specify other arguments as ' \
+          'keyword arguments.',
+          'Passing trim_mode with the 3rd argument of `ERB.new` is ' \
+          'deprecated. Use keyword argument like ' \
+          '`ERB.new(str, trim_mode: %<arg_value>s)` instead.',
+          'Passing eoutvar with the 4th argument of `ERB.new` is ' \
+          'deprecated. Use keyword argument like ' \
+          '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
+        ].freeze
+
+        def_node_matcher :erb_new_with_non_keyword_arguments, <<-PATTERN
+          (send
+            (const {nil? cbase} :ERB) :new $...)
+        PATTERN
+
+        def on_send(node)
+          erb_new_with_non_keyword_arguments(node) do |arguments|
+            return if correct_arguments?(arguments)
+
+            1.upto(3) do |i|
+              next if !arguments[i] || arguments[i].hash_type?
+
+              message = format(MESSAGES[i - 1], arg_value: arguments[i].source)
+
+              add_offense(
+                node, location: arguments[i].source_range, message: message
+              )
+            end
+          end
+        end
+
+        def correct_arguments?(arguments)
+          arguments.size == 1 ||
+            arguments.size == 2 && arguments[1].hash_type?
+        end
+      end
+    end
+  end
+end

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

@@ -50,6 +50,10 @@ module RuboCop
 
         def autocorrected_value(node)
           case node.type
+          when :int
+            node.children.last.to_i.to_s
+          when :float
+            node.children.last.to_f.to_s
           when :str
             node.children.last
           when :sym

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

@@ -38,14 +38,6 @@ module RuboCop
 
         private
 
-        def str_content(node)
-          if node.str_type?
-            node.children[0]
-          else
-            node.children.map { |c| str_content(c) }.join
-          end
-        end
-
         def contains_percent_literals?(node)
           node.each_child_node.any? do |child|
             literal = child.children.first.to_s.scrub

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

@@ -62,7 +62,7 @@ module RuboCop
             literal = value.children.first.to_s.scrub
 
             # To avoid likely false positives (e.g. a single ' or ")
-            next if literal.gsub(/[^\p{Alnum}]/, '').empty?
+            next if literal.gsub(/[^[[:alnum:]]]/, '').empty?
 
             QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
           end

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

@@ -55,7 +55,7 @@ module RuboCop
             literal = child.children.first
 
             # To avoid likely false positives (e.g. a single ' or ")
-            next if literal.to_s.gsub(/[^\p{Alnum}]/, '').empty?
+            next if literal.to_s.gsub(/[^[[:alnum:]]]/, '').empty?
 
             patterns.any? { |pat| literal =~ pat }
           end

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

@@ -31,7 +31,10 @@ module RuboCop
               ' after safe navigation operator.'.freeze
 
         def_node_matcher :bad_method?, <<-PATTERN
+        {
           (send $(csend ...) $_ ...)
+          (send $(block (csend ...) ...) $_ ...)
+        }
         PATTERN
 
         minimum_target_ruby_version 2.3

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

@@ -27,6 +27,9 @@ module RuboCop
       #   foo&.bar && (foobar.baz || foo&.baz)
       #
       class SafeNavigationConsistency < Cop
+        include IgnoredNode
+        include NilMethods
+
         MSG = 'Ensure that safe navigation is used consistently ' \
           'inside of `&&` and `||`.'.freeze
 
@@ -42,15 +45,16 @@ module RuboCop
           safe_nav_receiver = node.receiver
 
           method_calls = conditions.select(&:send_type?)
-          unsafe_method_calls = method_calls.select do |method_call|
-            safe_nav_receiver == method_call.receiver
-          end
+          unsafe_method_calls =
+            unsafe_method_calls(method_calls, safe_nav_receiver)
 
           unsafe_method_calls.each do |unsafe_method_call|
             location =
               node.loc.expression.join(unsafe_method_call.loc.expression)
             add_offense(unsafe_method_call,
                         location: location)
+
+            ignore_node(unsafe_method_call)
           end
         end
 
@@ -69,11 +73,20 @@ module RuboCop
           unless parent &&
                  (AST::Node::OPERATOR_KEYWORDS.include?(parent.type) ||
                   (parent.begin_type? &&
+                   parent.parent &&
                    AST::Node::OPERATOR_KEYWORDS.include?(parent.parent.type)))
             return node
           end
           top_conditional_ancestor(parent)
         end
+
+        def unsafe_method_calls(method_calls, safe_nav_receiver)
+          method_calls.select do |method_call|
+            safe_nav_receiver == method_call.receiver &&
+              !nil_methods.include?(method_call.method_name) &&
+              !ignored_node?(method_call)
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # This cop emulates the following Ruby warnings in Ruby 2.6.
+      #
+      # % ruby -we "def m(a) end; h = {foo: 1}; m(**h)"
+      # -e:1: warning: passing splat keyword arguments as a single Hash to `m'
+      #
+      # It checks for use of splat keyword arguments as a single Hash.
+      #
+      # @example
+      #   # bad
+      #   do_something(**arguments)
+      #
+      #   # good
+      #   do_something(arguments)
+      #
+      class SplatKeywordArguments < Cop
+        MSG = 'Do not use splat keyword arguments as a single Hash.'.freeze
+
+        def on_send(node)
+          node.arguments.each do |argument|
+            next unless argument.hash_type?
+
+            argument.children.each do |element|
+              add_offense(element) if element.kwsplat_type?
+            end
+          end
+        end
+      end
+    end
+  end
+end