rubocop 1.22.0 → 1.23.0

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

@@ -77,13 +77,34 @@ module RuboCop
       #   def b
       #   end
       #
-      # @example AllowAdjacentOneLineDefs: true
+      # @example AllowAdjacentOneLineDefs: true (default)
       #
       #   # good
       #   class ErrorA < BaseError; end
       #   class ErrorB < BaseError; end
       #   class ErrorC < BaseError; end
       #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #
+      #   class ErrorB < BaseError; end
+      #
+      #   class ErrorC < BaseError; end
+      #
+      # @example AllowAdjacentOneLineDefs: false
+      #
+      #   # bad
+      #   class ErrorA < BaseError; end
+      #   class ErrorB < BaseError; end
+      #   class ErrorC < BaseError; end
+      #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #
+      #   class ErrorB < BaseError; end
+      #
+      #   class ErrorC < BaseError; end
+      #
       class EmptyLineBetweenDefs < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -65,21 +65,24 @@ module RuboCop
         MSG = 'Extra empty line detected %<location>s the `%<keyword>s`.'
 
         def on_def(node)
-          check_body(node.body)
+          check_body(node.body, node.loc.line)
         end
         alias on_defs on_def
 
         def on_kwbegin(node)
           body, = *node
-          check_body(body)
+          check_body(body, node.loc.line)
         end
 
         private
 
-        def check_body(node)
-          locations = keyword_locations(node)
+        def check_body(body, line_of_def_or_kwbegin)
+          locations = keyword_locations(body)
+
           locations.each do |loc|
             line = loc.line
+            next if line == line_of_def_or_kwbegin
+
             keyword = loc.source
             # below the keyword
             check_line(style, line, message('after', keyword), &:empty?)

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

@@ -165,8 +165,7 @@ module RuboCop
         end
 
         def alignment_node_for_variable_style(node)
-          return node.parent if node.case_type? && node.argument? &&
-                                node.loc.line == node.parent.loc.line
+          return node.parent if node.case_type? && node.argument? && same_line?(node, node.parent)
 
           assignment = assignment_or_operator_method(node)
 

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

@@ -115,7 +115,7 @@ module RuboCop
           left_bracket = array_node.loc.begin
           first_elem = array_node.values.first
           if first_elem
-            return if first_elem.source_range.line == left_bracket.line
+            return if same_line?(first_elem, left_bracket)
 
             check_first(first_elem, left_bracket, left_parenthesis, 0)
           end

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

@@ -116,7 +116,7 @@ module RuboCop
           first_pair = hash_node.pairs.first
 
           if first_pair
-            return if first_pair.first_line == left_brace.line
+            return if same_line?(first_pair, left_brace)
 
             if separator_style?(first_pair)
               check_based_on_longest_key(hash_node, left_brace, left_parenthesis)

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

@@ -74,7 +74,7 @@ module RuboCop
           left_parenthesis = def_node.arguments.loc.begin
           first_elem = def_node.arguments.first
           return unless first_elem
-          return if first_elem.source_range.line == left_parenthesis.line
+          return if same_line?(first_elem, left_parenthesis)
 
           check_first(first_elem, left_parenthesis, nil, 0)
         end

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

@@ -224,7 +224,7 @@ module RuboCop
 
           parent_loc = node.parent.loc
           selector = parent_loc.selector || parent_loc.expression
-          selector.line == node.pairs.first.loc.line
+          same_line?(selector, node.pairs.first)
         end
 
         def reset!

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

@@ -167,7 +167,7 @@ module RuboCop
 
           end_of_outer_send = outermost_send.loc.end
 
-          end_of_outer_send.line == end_of_last_arg_of_outer_send.line &&
+          same_line?(end_of_outer_send, end_of_last_arg_of_outer_send) &&
             end_of_outer_send.column == end_of_last_arg_of_outer_send.column + 1
         end
 

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

@@ -341,7 +341,7 @@ module RuboCop
           return true unless body_node
 
           # Don't check if expression is on same line as "then" keyword, etc.
-          return true if body_node.loc.line == base_loc.line
+          return true if same_line?(body_node, base_loc)
 
           return true if starts_with_access_modifier?(body_node)
 

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

@@ -137,7 +137,7 @@ module RuboCop
           range = semicolon_token.pos
           end_pos = range.end_pos
           next_range = range_between(end_pos, end_pos + 1)
-          return nil unless next_range.line == range.line
+          return nil unless same_line?(next_range, range)
 
           next_char = next_range.source
           return nil if /[\r\n]/.match?(next_char)

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

@@ -88,7 +88,7 @@ module RuboCop
         end
 
         def check_new_line_offense(node, rhs)
-          return unless node.loc.operator.line == rhs.first_line
+          return unless same_line?(node.loc.operator, rhs)
 
           add_offense(node, message: NEW_LINE_OFFENSE) do |corrector|
             corrector.insert_after(node.loc.operator, "\n")

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

@@ -63,7 +63,7 @@ module RuboCop
             add_offense_for_expression(node, node.arguments, ARG_MSG)
           end
 
-          return unless node.body && node.loc.begin.line == node.body.first_line
+          return unless node.body && same_line?(node.loc.begin, node.body)
 
           add_offense_for_expression(node, node.body, MSG)
         end
@@ -110,7 +110,7 @@ module RuboCop
 
           expr_before_body ||= node.loc.begin
 
-          return unless expr_before_body.line == node.body.first_line
+          return unless same_line?(expr_before_body, node.body)
 
           autocorrect_body(corrector, node, node.body)
         end

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

@@ -75,7 +75,7 @@ module RuboCop
         def right_hand_side(send_node)
           dot = send_node.loc.dot
           selector = send_node.loc.selector
-          if send_node.dot? && selector && dot.line == selector.line
+          if send_node.dot? && selector && same_line?(dot, selector)
             dot.join(selector)
           elsif selector
             selector

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

@@ -61,7 +61,7 @@ module RuboCop
           alignment_loc = alignment_location(alignment_node)
           kw_loc        = node.loc.keyword
 
-          return if alignment_loc.column == kw_loc.column || alignment_loc.line == kw_loc.line
+          return if alignment_loc.column == kw_loc.column || same_line?(alignment_loc, kw_loc)
 
           add_offense(
             kw_loc, message: format_message(alignment_node, alignment_loc, kw_loc)

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

@@ -20,7 +20,7 @@ module RuboCop
         def on_new_investigation
           processed_source.sorted_tokens.each_cons(2) do |token1, token2|
             next unless token2.comment?
-            next unless token1.line == token2.line
+            next unless same_line?(token1, token2)
             next unless token1.pos.end == token2.pos.begin
 
             range = token2.pos

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

@@ -30,15 +30,17 @@ module RuboCop
         def on_send(node)
           return unless arrow_lambda_with_args?(node)
 
-          lambda_node = range_of_offense(node)
-
           if style == :require_space && !space_after_arrow?(node)
+            lambda_node = range_of_offense(node)
+
             add_offense(lambda_node, message: MSG_REQUIRE_SPACE) do |corrector|
-              corrector.insert_before(node.parent.children[1], ' ')
+              corrector.insert_before(lambda_arguments(node), ' ')
             end
           elsif style == :require_no_space && space_after_arrow?(node)
-            add_offense(lambda_node, message: MSG_REQUIRE_NO_SPACE) do |corrector|
-              corrector.remove(space_after_arrow(node))
+            space = space_after_arrow(node)
+
+            add_offense(space, message: MSG_REQUIRE_NO_SPACE) do |corrector|
+              corrector.remove(space)
             end
           end
         end
@@ -66,6 +68,10 @@ module RuboCop
             node.parent.arguments.loc.expression.end_pos
           )
         end
+
+        def lambda_arguments(node)
+          node.parent.children[1]
+        end
       end
     end
   end

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

@@ -146,10 +146,6 @@ module RuboCop
           end
         end
 
-        def same_line?(token1, token2)
-          token1.line == token2.line
-        end
-
         def parens?(token1, token2)
           token1.left_parens? || token2.right_parens?
         end

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

@@ -8,7 +8,7 @@ module RuboCop
       # Ranges have quite low precedence, which leads to unexpected behaviour when
       # using a range with other operators. This cop avoids that by making ranges
       # explicit by requiring parenthesis around complex range boundaries (anything
-      # that is not a basic literal: numerics, strings, symbols, etc.).
+      # that is not a literal: numerics, strings, symbols, etc.).
       #
       # This cop can be configured with `RequireParenthesesForMethodChains` in order to
       # specify whether method chains (including `self.foo`) should be wrapped in parens
@@ -81,8 +81,8 @@ module RuboCop
 
         def acceptable?(node)
           node.begin_type? ||
-            node.basic_literal? ||
-            node.variable? || node.const_type? ||
+            node.literal? ||
+            node.variable? || node.const_type? || node.self_type? ||
             (node.call_type? && acceptable_call?(node))
         end
 

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

@@ -42,11 +42,12 @@ module RuboCop
           #        Maybe further investigation of RuboCop AST will lead to an essential solution.
           return unless node.loc
 
-          constant = node.absolute? ? constant_name(node, node.short_name.to_s) : node.source
+          constant = node.absolute? ? constant_name(node, node.short_name) : node.source
           return unless (deprecated_constant = deprecated_constants[constant])
 
           alternative = deprecated_constant['Alternative']
           version = deprecated_constant['DeprecatedVersion']
+          return if target_ruby_version < version.to_f
 
           add_offense(node, message: message(alternative, node.source, version)) do |corrector|
             corrector.replace(node, alternative)
@@ -56,7 +57,7 @@ module RuboCop
         private
 
         def constant_name(node, nested_constant_name)
-          return nested_constant_name unless node.namespace.const_type?
+          return nested_constant_name.to_s unless node.namespace.const_type?
 
           constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
         end

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

@@ -72,7 +72,7 @@ module RuboCop
           first_else = else_branch.begin_type? ? else_branch.children.first : else_branch
 
           return unless first_else
-          return unless first_else.source_range.line == node.loc.else.line
+          return unless same_line?(first_else, node.loc.else)
 
           add_offense(first_else) { |corrector| autocorrect(corrector, node, first_else) }
         end

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

@@ -30,6 +30,7 @@ module RuboCop
       #   '10'.to_i
       #   '10.2'.to_f
       #   '10'.to_c
+      #   '1/3'.to_r
       #   ['1', '2', '3'].map(&:to_i)
       #   foo.try(:to_f)
       #   bar.send(:to_c)
@@ -39,6 +40,7 @@ module RuboCop
       #   Integer('10', 10)
       #   Float('10.2')
       #   Complex('10')
+      #   Rational('1/3')
       #   ['1', '2', '3'].map { |i| Integer(i, 10) }
       #   foo.try { |i| Float(i) }
       #   bar.send { |i| Complex(i) }
@@ -59,13 +61,14 @@ module RuboCop
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
           to_f: "#{Float.name}(%<number_object>s)",
-          to_c: "#{Complex.name}(%<number_object>s)"
+          to_c: "#{Complex.name}(%<number_object>s)",
+          to_r: "#{Rational.name}(%<number_object>s)"
         }.freeze
         MSG = 'Replace unsafe number conversion with number '\
               'class parsing, instead of using '\
               '`%<current>s`, use stricter '\
               '`%<corrected_method>s`.'
-        CONVERSION_METHODS = %i[Integer Float Complex to_i to_f to_c].freeze
+        CONVERSION_METHODS = %i[Integer Float Complex Rational to_i to_f to_c to_r].freeze
         METHODS = CONVERSION_METHOD_CLASS_MAPPING.keys.map(&:inspect).join(' ')
 
         # @!method to_method(node)

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

@@ -27,6 +27,7 @@ module RuboCop
 
         def on_send(node)
           return unless (required_feature = node.first_argument)
+          return unless required_feature.respond_to?(:value)
           return unless same_file?(processed_source.file_path, required_feature.value)
 
           add_offense(node) do |corrector|

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop looks for `ruby2_keywords` calls for methods that do not need it.
+      #
+      # `ruby2_keywords` should only be called on methods that accept an argument splat
+      # (`*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
+      # a keyword splat (`**kwargs`).
+      #
+      # @example
+      #   # good (splat argument without keyword arguments)
+      #   ruby2_keywords def foo(*args); end
+      #
+      #   # bad (no arguments)
+      #   ruby2_keywords def foo; end
+      #
+      #   # good
+      #   def foo; end
+      #
+      #   # bad (positional argument)
+      #   ruby2_keywords def foo(arg); end
+      #
+      #   # good
+      #   def foo(arg); end
+      #
+      #   # bad (double splatted argument)
+      #   ruby2_keywords def foo(**args); end
+      #
+      #   # good
+      #   def foo(**args); end
+      #
+      #   # bad (keyword arguments)
+      #   ruby2_keywords def foo(i:, j:); end
+      #
+      #   # good
+      #   def foo(i:, j:); end
+      #
+      #   # bad (splat argument with keyword arguments)
+      #   ruby2_keywords def foo(*args, i:, j:); end
+      #
+      #   # good
+      #   def foo(*args, i:, j:); end
+      #
+      #   # bad (splat argument with double splat)
+      #   ruby2_keywords def foo(*args, **kwargs); end
+      #
+      #   # good
+      #   def foo(*args, **kwargs); end
+      #
+      #   # bad (ruby2_keywords given a symbol)
+      #   def foo; end
+      #   ruby2_keywords :foo
+      #
+      #   # good
+      #   def foo; end
+      #
+      #   # bad (ruby2_keywords with dynamic method)
+      #   define_method(:foo) { |arg| }
+      #   ruby2_keywords :foo
+      #
+      #   # good
+      #   define_method(:foo) { |arg| }
+      #
+      class UselessRuby2Keywords < Base
+        MSG = '`ruby2_keywords` is unnecessary for method `%<method_name>s`.'
+        RESTRICT_ON_SEND = %i[ruby2_keywords].freeze
+
+        # Looks for statically or dynamically defined methods with a given name
+        # @!method method_definition(node, method_name)
+        def_node_matcher :method_definition, <<~PATTERN
+          {
+            (def %1 ...)
+            ({block numblock} (send _ :define_method (sym %1)) ...)
+          }
+        PATTERN
+
+        def on_send(node)
+          if node.first_argument.def_type?
+            inspect_def(node, node.first_argument)
+          elsif node.first_argument.sym_type?
+            inspect_sym(node, node.first_argument)
+          end
+        end
+
+        private
+
+        def inspect_def(node, def_node)
+          return if allowed_arguments(def_node.arguments)
+
+          add_offense(node.loc.selector, message: format(MSG, method_name: def_node.method_name))
+        end
+
+        def inspect_sym(node, sym_node)
+          return unless node.parent
+
+          method_name = sym_node.value
+          definition = node.parent.each_child_node.detect { |n| method_definition(n, method_name) }
+
+          return unless definition
+          return if allowed_arguments(definition.arguments)
+
+          add_offense(node, message: format(MSG, method_name: method_name))
+        end
+
+        # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
+        def allowed_arguments(arguments)
+          return false if arguments.empty?
+
+          arguments.each_child_node(:restarg).any? &&
+            arguments.each_child_node(:kwarg, :kwoptarg, :kwrestarg).none?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -9,6 +9,9 @@ module RuboCop
       # Keyword arguments can optionally be excluded from the total count,
       # as they add less complexity than positional or optional parameters.
       #
+      # NOTE: Explicit block argument `&block` is not counted to prevent
+      # erroneous change that is avoided by making block argument implicit.
+      #
       # @example Max: 3
       #   # good
       #   def foo(a, b, c = 1)
@@ -94,9 +97,9 @@ module RuboCop
 
         def args_count(node)
           if count_keyword_args?
-            node.children.size
+            node.children.count { |a| !a.blockarg_type? }
           else
-            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) }
+            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) && !a.blockarg_type? }
           end
         end
 

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -34,8 +34,7 @@ module RuboCop
 
       def matching_ranges(end_loc, align_ranges)
         align_ranges.select do |_, range|
-          range.line == end_loc.line ||
-            column_offset_between(range, end_loc).zero?
+          same_line?(range, end_loc) || column_offset_between(range, end_loc).zero?
         end
       end
 

data/lib/rubocop/cop/mixin/gemspec_help.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking gem declarations.
+    module GemspecHelp
+      extend NodePattern::Macros
+
+      # @!method gem_specification?(node)
+      def_node_matcher :gem_specification?, <<~PATTERN
+        (block
+          (send
+            (const
+              (const {cbase nil?} :Gem) :Specification) :new)
+          (args
+            (arg $_)) ...)
+      PATTERN
+
+      # @!method gem_specification(node)
+      def_node_search :gem_specification, <<~PATTERN
+        (block
+          (send
+            (const
+              (const {cbase nil?} :Gem) :Specification) :new)
+          (args
+            (arg $_)) ...)
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -139,9 +139,9 @@ module RuboCop
         end
 
         def self.from_map_to_h(node, match)
-          strip_trailing_chars = 0
-
-          unless node.parent&.block_type?
+          if node.parent&.block_type? && node.parent.send_node == node
+            strip_trailing_chars = 0
+          else
             map_range = node.children.first.source_range
             node_range = node.source_range
             strip_trailing_chars = node_range.end_pos - map_range.end_pos

data/lib/rubocop/cop/mixin/multiline_element_indentation.rb

@@ -15,7 +15,7 @@ module RuboCop
         node.arguments.each do |arg|
           on_node(type, arg, :send) do |type_node|
             left_brace = type_node.loc.begin
-            if left_brace && left_brace.line == left_parenthesis.line
+            if left_brace && same_line?(left_brace, left_parenthesis)
               yield type_node, left_parenthesis
               ignore_node(type_node)
             end

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -90,7 +90,7 @@ module RuboCop
       # This method depends on the fact that we have guarded
       # against implicit and empty literals.
       def opening_brace_on_same_line?(node)
-        node.loc.begin.line == children(node).first.first_line
+        same_line?(node.loc.begin, children(node).first)
       end
 
       # This method depends on the fact that we have guarded

data/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -28,7 +28,7 @@ module RuboCop
       end
 
       def space_missing?(token1, token2)
-        token1.line == token2.line && token2.column == token1.column + offset
+        same_line?(token1, token2) && token2.column == token1.column + offset
       end
 
       def space_required_before?(token)

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -32,7 +32,7 @@ module RuboCop
       end
 
       def space_missing?(token1, token2)
-        token1.line == token2.line && token2.begin_pos > token1.end_pos
+        same_line?(token1, token2) && token2.begin_pos > token1.end_pos
       end
 
       def space_required_after?(token)

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -54,7 +54,7 @@ module RuboCop
       end
 
       def first_line_comment(node)
-        comment = processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        comment = processed_source.find_comment { |c| same_line?(c, node) }
         return unless comment
 
         comment_source = comment.loc.expression.source

data/lib/rubocop/cop/mixin/trailing_body.rb

@@ -10,7 +10,7 @@ module RuboCop
       end
 
       def body_on_first_line?(node, body)
-        node.source_range.first_line == body.source_range.first_line
+        same_line?(node, body)
       end
 
       def first_part_of(body)