rubocop 0.78.0 → 0.82.0

data/lib/rubocop/cop/style/hash_each_methods.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of `each_key` and `each_value` Hash methods.
+      #
+      # Note: If you have an array of two-element arrays, you can put
+      #   parentheses around the block arguments to indicate that you're not
+      #   working with a hash, and suppress RuboCop offenses.
+      #
+      # @example
+      #   # bad
+      #   hash.keys.each { |k| p k }
+      #   hash.values.each { |v| p v }
+      #
+      #   # good
+      #   hash.each_key { |k| p k }
+      #   hash.each_value { |v| p v }
+      class HashEachMethods < Cop
+        include Lint::UnusedArgument
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        def_node_matcher :kv_each, <<~PATTERN
+          (block $(send (send _ ${:keys :values}) :each) ...)
+        PATTERN
+
+        def on_block(node)
+          register_kv_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            correct_key_value_each(node, corrector)
+          end
+        end
+
+        private
+
+        def register_kv_offense(node)
+          kv_each(node) do |target, method|
+            return unless target.receiver.receiver
+
+            msg = format(message, prefer: "each_#{method[0..-2]}",
+                                  current: "#{method}.each")
+
+            add_offense(target, location: kv_range(target), message: msg)
+          end
+        end
+
+        def check_argument(variable)
+          return unless variable.block_argument?
+
+          (@block_args ||= []).push(variable)
+        end
+
+        def used?(arg)
+          @block_args.find { |var| var.declaration_node.loc == arg.loc }.used?
+        end
+
+        def correct_implicit(node, corrector, method_name)
+          corrector.replace(node, method_name)
+          correct_args(node, corrector)
+        end
+
+        def correct_key_value_each(node, corrector)
+          receiver = node.receiver.receiver
+          name = "each_#{node.receiver.method_name.to_s.chop}"
+          return correct_implicit(node, corrector, name) unless receiver
+
+          new_source = receiver.source + ".#{name}"
+          corrector.replace(node, new_source)
+        end
+
+        def correct_args(node, corrector)
+          args = node.parent.arguments
+          name, = *args.children.find { |arg| used?(arg) }
+
+          corrector.replace(args, "|#{name}|")
+        end
+
+        def kv_range(outer_node)
+          outer_node.receiver.loc.selector.join(outer_node.loc.selector)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/hash_syntax.rb

@@ -144,11 +144,11 @@ module RuboCop
             # Prefer { :production? => false } over { production?: false } and
             # similarly for other non-alnum final characters (except quotes,
             # to prefer { "x y": 1 } over { :"x y" => 1 }).
-            return false unless sym_name =~ /[\p{Alnum}"']\z/
+            return false unless /[\p{Alnum}"']\z/.match?(sym_name)
           end
 
           # Most hash keys can be matched against a simple regex.
-          return true if sym_name =~ /\A[_a-z]\w*[?!]?\z/i
+          return true if /\A[_a-z]\w*[?!]?\z/i.match?(sym_name)
 
           # For more complicated hash keys, let the parser validate the syntax.
           parse("{ #{sym_name}: :foo }").valid_syntax?
@@ -188,11 +188,9 @@ module RuboCop
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
-          key = pair_node.key.source_range
           op = pair_node.loc.operator
 
-          corrector.insert_after(key, pair_node.inverse_delimiter(true))
-          corrector.insert_before(key, ':')
+          corrector.wrap(pair_node.key, ':', pair_node.inverse_delimiter(true))
           corrector.remove(range_with_surrounding_space(range: op))
         end
 

data/lib/rubocop/cop/style/hash_transform_keys.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of `_.each_with_object({}) {...}`,
+      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # transforming the keys of a hash, and tries to use a simpler & faster
+      # call to `transform_keys` instead.
+      #
+      # This can produce false positives if we are transforming an enumerable
+      # of key-value-like pairs that isn't actually a hash, e.g.:
+      # `[[k1, v1], [k2, v2], ...]`
+      #
+      # This cop should only be enabled on Ruby version 2.5 or newer
+      # (`transform_keys` was added in Ruby 2.5.)
+      #
+      # @example
+      #   # bad
+      #   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[foo(k)] = v }
+      #   {a: 1, b: 2}.map { |k, v| [k.to_s, v] }
+      #
+      #   # good
+      #   {a: 1, b: 2}.transform_keys { |k| foo(k) }
+      #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
+      class HashTransformKeys < Cop
+        extend TargetRubyVersion
+        include HashTransformMethod
+
+        minimum_target_ruby_version 2.5
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :each_with_object (hash))
+            (args
+              (mlhs
+                (arg $_)
+                (arg _val))
+              (arg _memo))
+            ({send csend} (lvar _memo) :[]= $_ $(lvar _val)))
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const _ :Hash)
+            :[]
+            (block
+              ({send csend} !(send _ :each_with_index) {:map :collect})
+              (args
+                (arg $_)
+                (arg _val))
+              (array $_ $(lvar _val))))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          ({send csend}
+            (block
+              ({send csend}
+                !{(send _ :each_with_index) (array ...)}
+                {:map :collect})
+              (args
+                (arg $_)
+                (arg _val))
+              (array $_ $(lvar _val)))
+            :to_h)
+        PATTERN
+
+        private
+
+        def extract_captures(match)
+          key_argname, key_body_expr, val_body_expr = *match
+          Captures.new(key_argname, key_body_expr, val_body_expr)
+        end
+
+        def new_method_name
+          'transform_keys'
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/hash_transform_values.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of `_.each_with_object({}) {...}`,
+      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # transforming the values of a hash, and tries to use a simpler & faster
+      # call to `transform_values` instead.
+      #
+      # This can produce false positives if we are transforming an enumerable
+      # of key-value-like pairs that isn't actually a hash, e.g.:
+      # `[[k1, v1], [k2, v2], ...]`
+      #
+      # This cop should only be enabled on Ruby version 2.4 or newer
+      # (`transform_values` was added in Ruby 2.4.)
+      #
+      # @example
+      #   # bad
+      #   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[k] = foo(v) }
+      #   {a: 1, b: 2}.map { |k, v| [k, v * v] }
+      #
+      #   # good
+      #   {a: 1, b: 2}.transform_values { |v| foo(v) }
+      #   {a: 1, b: 2}.transform_values { |v| v * v }
+      class HashTransformValues < Cop
+        include HashTransformMethod
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :each_with_object (hash))
+            (args
+              (mlhs
+                (arg _key)
+                (arg $_))
+              (arg _memo))
+            ({send csend} (lvar _memo) :[]= $(lvar _key) $_))
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const _ :Hash)
+            :[]
+            (block
+              ({send csend} !(send _ :each_with_index) {:map :collect})
+              (args
+                (arg _key)
+                (arg $_))
+              (array $(lvar _key) $_)))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          ({send csend}
+            (block
+              ({send csend}
+                !{(send _ :each_with_index) (array ...)}
+                 {:map :collect})
+              (args
+                (arg _key)
+                (arg $_))
+              (array $(lvar _key) $_))
+            :to_h)
+        PATTERN
+
+        private
+
+        def extract_captures(match)
+          val_argname, key_body_expr, val_body_expr = *match
+          Captures.new(val_argname, val_body_expr, key_body_expr)
+        end
+
+        def new_method_name
+          'transform_values'
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/if_unless_modifier.rb

@@ -9,7 +9,7 @@ module RuboCop
       #
       # The maximum line length is configured in the `Layout/LineLength`
       # cop. The tab size is configured in the `IndentationWidth` of the
-      # `Layout/Tab` cop.
+      # `Layout/IndentationStyle` cop.
       #
       # @example
       #   # bad
@@ -47,7 +47,7 @@ module RuboCop
         def on_if(node)
           msg = if eligible_node?(node)
                   MSG_USE_MODIFIER unless named_capture_in_condition?(node)
-                elsif node.modifier_form? && too_long_single_line?(node)
+                elsif too_long_due_to_modifier?(node)
                   MSG_USE_NORMAL
                 end
           return unless msg
@@ -63,11 +63,16 @@ module RuboCop
                         else
                           to_modifier_form(node)
                         end
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
+          ->(corrector) { corrector.replace(node, replacement) }
         end
 
         private
 
+        def too_long_due_to_modifier?(node)
+          node.modifier_form? && too_long_single_line?(node) &&
+            !another_statement_on_same_line?(node)
+        end
+
         def ignored_patterns
           config.for_cop('Layout/LineLength')['IgnoredPatterns'] || []
         end
@@ -129,6 +134,21 @@ module RuboCop
           node.ternary? || node.modifier_form? || node.elsif? || node.else?
         end
 
+        def another_statement_on_same_line?(node)
+          line_no = node.source_range.last_line
+
+          # traverse the AST upwards until we find a 'begin' node
+          # we want to look at the following child and see if it is on the
+          #   same line as this 'if' node
+          while node && !node.begin_type?
+            index = node.sibling_index
+            node  = node.parent
+          end
+
+          node && (sibling = node.children[index + 1]) &&
+            sibling.source_range.first_line == line_no
+        end
+
         def parenthesize?(node)
           # Parenthesize corrected expression if changing to modifier-if form
           # would change the meaning of the parent expression

data/lib/rubocop/cop/style/inverse_methods.rb

@@ -44,7 +44,7 @@ module RuboCop
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
 
         def self.autocorrect_incompatible_with
-          [Style::Not]
+          [Style::Not, Style::SymbolProc]
         end
 
         def_node_matcher :inverse_candidate?, <<~PATTERN
@@ -109,10 +109,7 @@ module RuboCop
             corrector.remove(not_to_receiver(node, method_call))
             corrector.replace(method_call.loc.selector,
                               inverse_methods[method].to_s)
-
-            if EQUALITY_METHODS.include?(method)
-              corrector.remove(end_parentheses(node, method_call))
-            end
+            remove_end_parenthesis(corrector, node, method, method_call)
           end
         end
 
@@ -187,6 +184,13 @@ module RuboCop
         def dot_range(loc)
           range_between(loc.dot.begin_pos, loc.expression.end_pos)
         end
+
+        def remove_end_parenthesis(corrector, node, method, method_call)
+          return unless EQUALITY_METHODS.include?(method) ||
+                        method_call.parent.begin_type?
+
+          corrector.remove(end_parentheses(node, method_call))
+        end
       end
     end
   end

data/lib/rubocop/cop/style/lambda.rb

@@ -73,6 +73,7 @@ module RuboCop
                       location: node.send_node.source_range,
                       message: message(node, selector))
         end
+        alias on_numblock on_block
 
         def autocorrect(node)
           if node.send_node.source == 'lambda'
@@ -108,13 +109,13 @@ module RuboCop
         end
 
         def autocorrect_method_to_literal(corrector, node)
-          corrector.replace(node.send_node.source_range, '->')
+          corrector.replace(node.send_node, '->')
 
           return unless node.arguments?
 
           arg_str = "(#{lambda_arg_string(node.arguments)})"
 
-          corrector.insert_after(node.send_node.source_range, arg_str)
+          corrector.insert_after(node.send_node, arg_str)
           corrector.remove(arguments_with_whitespace(node))
         end
 

data/lib/rubocop/cop/style/lambda_call.rb

@@ -37,7 +37,7 @@ module RuboCop
               receiver = node.receiver.source
               replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
 
-              corrector.replace(node.source_range, replacement)
+              corrector.replace(node, replacement)
             else
               add_parentheses(node, corrector) unless node.parenthesized?
               corrector.remove(node.loc.selector)
@@ -54,7 +54,7 @@ module RuboCop
 
         def add_parentheses(node, corrector)
           if node.arguments.empty?
-            corrector.insert_after(node.source_range, '()')
+            corrector.insert_after(node, '()')
           else
             corrector.replace(args_begin(node), '(')
             corrector.insert_after(args_end(node), ')')

data/lib/rubocop/cop/style/method_call_with_args_parentheses.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Style
@@ -43,7 +42,6 @@ module RuboCop
       #
       # @example EnforcedStyle: require_parentheses (default)
       #
-      #
       #   # bad
       #   array.delete e
       #
@@ -150,94 +148,23 @@ module RuboCop
         include IgnoredMethods
         include IgnoredPattern
 
-        TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
+        def initialize(*)
+          super
+          return unless style_configured?
 
-        def on_send(node)
           case style
           when :require_parentheses
-            add_offense_for_require_parentheses(node)
+            extend RequireParentheses
           when :omit_parentheses
-            add_offense_for_omit_parentheses(node)
+            extend OmitParentheses
           end
         end
-        alias on_csend on_send
-        alias on_super on_send
-        alias on_yield on_send
 
-        def autocorrect(node)
-          case style
-          when :require_parentheses
-            autocorrect_for_require_parentheses(node)
-          when :omit_parentheses
-            autocorrect_for_omit_parentheses(node)
-          end
-        end
-
-        def message(_node = nil)
-          case style
-          when :require_parentheses
-            'Use parentheses for method calls with arguments.'
-          when :omit_parentheses
-            'Omit parentheses for method calls with arguments.'
-          end
-        end
+        # @abstract Overridden in style modules
+        def autocorrect(_node); end
 
         private
 
-        def add_offense_for_require_parentheses(node)
-          return if ignored_method?(node.method_name)
-          return if matches_ignored_pattern?(node.method_name)
-          return if eligible_for_parentheses_omission?(node)
-          return unless node.arguments? && !node.parenthesized?
-
-          add_offense(node)
-        end
-
-        def add_offense_for_omit_parentheses(node)
-          return unless node.parenthesized?
-          return if node.implicit_call?
-          return if super_call_without_arguments?(node)
-          return if allowed_camel_case_method_call?(node)
-          return if legitimate_call_with_parentheses?(node)
-
-          add_offense(node, location: node.loc.begin.join(node.loc.end))
-        end
-
-        def autocorrect_for_require_parentheses(node)
-          lambda do |corrector|
-            corrector.replace(args_begin(node), '(')
-
-            unless args_parenthesized?(node)
-              corrector.insert_after(args_end(node), ')')
-            end
-          end
-        end
-
-        def autocorrect_for_omit_parentheses(node)
-          lambda do |corrector|
-            if parentheses_at_the_end_of_multiline_call?(node)
-              corrector.replace(args_begin(node), ' \\')
-            else
-              corrector.replace(args_begin(node), ' ')
-            end
-            corrector.remove(node.loc.end)
-          end
-        end
-
-        def eligible_for_parentheses_omission?(node)
-          node.operator_method? || node.setter_method? || ignored_macro?(node)
-        end
-
-        def included_macros_list
-          cop_config.fetch('IncludedMacros', []).map(&:to_sym)
-        end
-
-        def ignored_macro?(node)
-          cop_config['IgnoreMacros'] &&
-            node.macro? &&
-            !included_macros_list.include?(node.method_name)
-        end
-
         def args_begin(node)
           loc = node.loc
           selector =
@@ -257,132 +184,7 @@ module RuboCop
           first_node = node.arguments.first
           first_node.begin_type? && first_node.parenthesized_call?
         end
-
-        def parentheses_at_the_end_of_multiline_call?(node)
-          node.multiline? &&
-            node.loc.begin.source_line
-                .gsub(TRAILING_WHITESPACE_REGEX, '')
-                .end_with?('(')
-        end
-
-        def super_call_without_arguments?(node)
-          node.super_type? && node.arguments.none?
-        end
-
-        def allowed_camel_case_method_call?(node)
-          node.camel_case_method? &&
-            (node.arguments.none? ||
-             cop_config['AllowParenthesesInCamelCaseMethod'])
-        end
-
-        def legitimate_call_with_parentheses?(node)
-          call_in_literals?(node) ||
-            call_with_ambiguous_arguments?(node) ||
-            call_in_logical_operators?(node) ||
-            call_in_optional_arguments?(node) ||
-            allowed_multiline_call_with_parentheses?(node) ||
-            allowed_chained_call_with_parentheses?(node)
-        end
-
-        def call_in_literals?(node)
-          node.parent &&
-            (node.parent.pair_type? ||
-             node.parent.array_type? ||
-             node.parent.range_type? ||
-             splat?(node.parent) ||
-             ternary_if?(node.parent))
-        end
-
-        def call_in_logical_operators?(node)
-          node.parent &&
-            (logical_operator?(node.parent) ||
-             node.parent.send_type? &&
-             node.parent.arguments.any?(&method(:logical_operator?)))
-        end
-
-        def call_in_optional_arguments?(node)
-          node.parent &&
-            (node.parent.optarg_type? || node.parent.kwoptarg_type?)
-        end
-
-        def call_with_ambiguous_arguments?(node)
-          call_with_braced_block?(node) ||
-            call_as_argument_or_chain?(node) ||
-            hash_literal_in_arguments?(node) ||
-            node.descendants.any? do |n|
-              ambigious_literal?(n) || logical_operator?(n) ||
-                call_with_braced_block?(n)
-            end
-        end
-
-        def call_with_braced_block?(node)
-          (node.send_type? || node.super_type?) &&
-            node.block_node && node.block_node.braces?
-        end
-
-        def call_as_argument_or_chain?(node)
-          node.parent &&
-            (node.parent.send_type? && !assigned_before?(node.parent, node) ||
-             node.parent.csend_type? || node.parent.super_type?)
-        end
-
-        def hash_literal_in_arguments?(node)
-          node.arguments.any? do |n|
-            hash_literal?(n) ||
-              n.send_type? && node.descendants.any?(&method(:hash_literal?))
-          end
-        end
-
-        def allowed_multiline_call_with_parentheses?(node)
-          cop_config['AllowParenthesesInMultilineCall'] && node.multiline?
-        end
-
-        def allowed_chained_call_with_parentheses?(node)
-          return false unless cop_config['AllowParenthesesInChaining']
-
-          previous = node.descendants.first
-          return false unless previous&.send_type?
-
-          previous.parenthesized? ||
-            allowed_chained_call_with_parentheses?(previous)
-        end
-
-        def ambigious_literal?(node)
-          splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) ||
-            unary_literal?(node)
-        end
-
-        def splat?(node)
-          node.splat_type? || node.kwsplat_type? || node.block_pass_type?
-        end
-
-        def ternary_if?(node)
-          node.if_type? && node.ternary?
-        end
-
-        def logical_operator?(node)
-          (node.and_type? || node.or_type?) && node.logical_operator?
-        end
-
-        def hash_literal?(node)
-          node.hash_type? && node.braces?
-        end
-
-        def regexp_slash_literal?(node)
-          node.regexp_type? && node.loc.begin.source == '/'
-        end
-
-        def unary_literal?(node)
-          node.numeric_type? && node.sign? ||
-            node.parent&.send_type? && node.parent&.unary_operation?
-        end
-
-        def assigned_before?(node, target)
-          node.assignment? &&
-            node.loc.operator.begin < target.loc.begin
-        end
       end
     end
   end
 end
-# rubocop:enable Metrics/ClassLength