rubocop 0.77.0 → 0.81.0

data/lib/rubocop/cop/style/hash_transform_values.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 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
+        extend TargetRubyVersion
+        include HashTransformMethod
+
+        minimum_target_ruby_version 2.4
+
+        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

@@ -7,7 +7,7 @@ module RuboCop
       # written as modifier `if`/`unless`. The cop also checks for modifier
       # `if`/`unless` lines that exceed the maximum line length.
       #
-      # The maximum line length is configured in the `Metrics/LineLength`
+      # The maximum line length is configured in the `Layout/LineLength`
       # cop. The tab size is configured in the `IndentationWidth` of the
       # `Layout/Tab` cop.
       #
@@ -32,6 +32,8 @@ module RuboCop
       #   end
       class IfUnlessModifier < Cop
         include StatementModifier
+        include LineLengthHelp
+        include IgnoredPattern
 
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
                            'single-line body. Another good alternative is ' \
@@ -66,6 +68,10 @@ module RuboCop
 
         private
 
+        def ignored_patterns
+          config.for_cop('Layout/LineLength')['IgnoredPatterns'] || []
+        end
+
         def too_long_single_line?(node)
           return false unless max_line_length
 
@@ -73,12 +79,41 @@ module RuboCop
           return false unless range.first_line == range.last_line
           return false unless line_length_enabled_at_line?(range.first_line)
 
-          range.last_column > max_line_length
+          line = range.source_line
+          return false if line_length(line) <= max_line_length
+
+          too_long_line_based_on_config?(range, line)
+        end
+
+        def too_long_line_based_on_config?(range, line)
+          return false if matches_ignored_pattern?(line)
+
+          too_long = too_long_line_based_on_ignore_cop_directives?(range, line)
+          return too_long unless too_long == :undetermined
+
+          too_long_line_based_on_allow_uri?(line)
+        end
+
+        def too_long_line_based_on_ignore_cop_directives?(range, line)
+          if ignore_cop_directives? && directive_on_source_line?(range.line - 1)
+            return line_length_without_directive(line) > max_line_length
+          end
+
+          :undetermined
+        end
+
+        def too_long_line_based_on_allow_uri?(line)
+          if allow_uri?
+            uri_range = find_excessive_uri_range(line)
+            return false if uri_range && allowed_uri_position?(line, uri_range)
+          end
+
+          true
         end
 
         def line_length_enabled_at_line?(line)
           processed_source.comment_config
-                          .cop_enabled_at_line?('Metrics/LineLength', line)
+                          .cop_enabled_at_line?('Layout/LineLength', line)
         end
 
         def named_capture_in_condition?(node)

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

@@ -58,7 +58,7 @@ module RuboCop
           # `loop do` without further modification. The reason is that a
           # variable that's introduced inside a while/until loop is in scope
           # outside of that loop too, but a variable that's assigned for the
-          # first time inside a block can not be accessed after the block. In
+          # first time inside a block cannot be accessed after the block. In
           # those more complicated cases we don't report an offense.
           return if @variables.any? do |var|
             assigned_inside_loop?(var, range) &&

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'

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