rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for uses of `map.to_h` or `collect.to_h` that could be
+      # written with just `to_h` in Ruby >= 2.6.
+      #
+      # NOTE: `Style/HashTransformKeys` and `Style/HashTransformValues` will
+      # also change this pattern if only hash keys or hash values are being
+      # transformed.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Enumerable`.
+      #
+      # @example
+      #   # bad
+      #   something.map { |v| [v, v * 2] }.to_h
+      #
+      #   # good
+      #   something.to_h { |v| [v, v * 2] }
+      #
+      #   # bad
+      #   {foo: bar}.collect { |k, v| [k.to_s, v.do_something] }.to_h
+      #
+      #   # good
+      #   {foo: bar}.to_h { |k, v| [k.to_s, v.do_something] }
+      #
+      class MapToHash < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Pass a block to `to_h` instead of calling `%<method>s%<dot>sto_h`.'
+        RESTRICT_ON_SEND = %i[to_h].freeze
+
+        # @!method map_to_h(node)
+        def_node_matcher :map_to_h, <<~PATTERN
+          {
+            $(call (any_block $(call _ {:map :collect}) ...) :to_h)
+            $(call $(call _ {:map :collect} (block_pass sym)) :to_h)
+          }
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [Layout::SingleLineBlockChain]
+        end
+
+        def on_send(node)
+          return unless (to_h_node, map_node = map_to_h(node))
+
+          message = format(MSG, method: map_node.loc.selector.source, dot: to_h_node.loc.dot.source)
+          add_offense(map_node.loc.selector, message: message) do |corrector|
+            # If the `to_h` call already has a block, do not autocorrect.
+            next if to_h_node.block_literal?
+
+            autocorrect(corrector, to_h_node, map_node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, to_h, map)
+          removal_range = range_between(to_h.loc.dot.begin_pos, to_h.loc.selector.end_pos)
+
+          corrector.remove(range_with_surrounding_space(removal_range, side: :left))
+          if (map_dot = map.loc.dot)
+            corrector.replace(map_dot, to_h.loc.dot.source)
+          end
+          corrector.replace(map.loc.selector, 'to_h')
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for uses of `map.to_set` or `collect.to_set` that could be
+      # written with just `to_set`.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Enumerable`.
+      #
+      # @example
+      #   # bad
+      #   something.map { |i| i * 2 }.to_set
+      #
+      #   # good
+      #   something.to_set { |i| i * 2 }
+      #
+      #   # bad
+      #   [1, 2, 3].collect { |i| i.to_s }.to_set
+      #
+      #   # good
+      #   [1, 2, 3].to_set { |i| i.to_s }
+      #
+      class MapToSet < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Pass a block to `to_set` instead of calling `%<method>s.to_set`.'
+        RESTRICT_ON_SEND = %i[to_set].freeze
+
+        # @!method map_to_set?(node)
+        def_node_matcher :map_to_set?, <<~PATTERN
+          {
+            $(call (any_block $(call _ {:map :collect}) ...) :to_set)
+            $(call $(call _ {:map :collect} (block_pass sym)) :to_set)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (to_set_node, map_node = map_to_set?(node))
+
+          message = format(MSG, method: map_node.loc.selector.source)
+          add_offense(map_node.loc.selector, message: message) do |corrector|
+            # If the `to_set` call already has a block, do not autocorrect.
+            next if to_set_node.block_literal?
+
+            autocorrect(corrector, to_set_node, map_node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def autocorrect(corrector, to_set, map)
+          removal_range = range_between(to_set.loc.dot.begin_pos, to_set.loc.selector.end_pos)
+
+          corrector.remove(range_with_surrounding_space(removal_range, side: :left))
+          corrector.replace(map.loc.selector, 'to_set')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      class MethodCallWithArgsParentheses
+        # Style omit_parentheses
+        # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
+        module OmitParentheses
+          include RangeHelp
+
+          TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
+          OMIT_MSG = 'Omit parentheses for method calls with arguments.'
+          private_constant :OMIT_MSG
+
+          private
+
+          def omit_parentheses(node) # rubocop:disable Metrics/PerceivedComplexity
+            return unless node.parenthesized?
+            return if inside_endless_method_def?(node)
+            return if require_parentheses_for_hash_value_omission?(node)
+            return if syntax_like_method_call?(node)
+            return if method_call_before_constant_resolution?(node)
+            return if super_call_without_arguments?(node)
+            return if legitimate_call_with_parentheses?(node)
+            return if allowed_camel_case_method_call?(node)
+            return if allowed_string_interpolation_method_call?(node)
+
+            add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
+              autocorrect(corrector, node)
+            end
+          end
+
+          def autocorrect(corrector, node)
+            range = args_begin(node)
+            if parentheses_at_the_end_of_multiline_call?(node)
+              # Whitespace after line continuation (`\ `) is a syntax error
+              with_whitespace = range_with_surrounding_space(range, side: :right, newlines: false)
+              corrector.replace(with_whitespace, ' \\')
+            else
+              corrector.replace(range, ' ')
+            end
+            corrector.remove(node.loc.end)
+          end
+
+          def offense_range(node)
+            node.loc.begin.join(node.loc.end)
+          end
+
+          def inside_endless_method_def?(node)
+            # parens are required around arguments inside an endless method
+            node.each_ancestor(:any_def).any?(&:endless?) && node.arguments.any?
+          end
+
+          def require_parentheses_for_hash_value_omission?(node) # rubocop:disable Metrics/PerceivedComplexity
+            return false unless (last_argument = node.last_argument)
+            return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
+
+            node.parent&.conditional? || node.parent&.single_line? || !last_expression?(node)
+          end
+
+          # Require hash value omission be enclosed in parentheses to prevent the following issue:
+          # https://bugs.ruby-lang.org/issues/18396.
+          def last_expression?(node)
+            !(node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling)
+          end
+
+          def syntax_like_method_call?(node)
+            node.implicit_call? || node.operator_method?
+          end
+
+          def method_call_before_constant_resolution?(node)
+            node.parent&.const_type?
+          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 allowed_string_interpolation_method_call?(node)
+            cop_config['AllowParenthesesInStringInterpolation'] &&
+              inside_string_interpolation?(node)
+          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 legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
+            call_in_literals?(node) ||
+              node.parent&.when_type? ||
+              call_with_ambiguous_arguments?(node) ||
+              call_in_logical_operators?(node) ||
+              call_in_optional_arguments?(node) ||
+              call_in_single_line_inheritance?(node) ||
+              allowed_multiline_call_with_parentheses?(node) ||
+              allowed_chained_call_with_parentheses?(node) ||
+              assignment_in_condition?(node) ||
+              forwards_anonymous_rest_arguments?(node)
+          end
+
+          def call_in_literals?(node)
+            parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
+            return false unless parent
+
+            parent.type?(:pair, :array, :range) ||
+              splat?(parent) ||
+              ternary_if?(parent)
+          end
+
+          def call_in_logical_operators?(node)
+            parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
+            return false unless parent
+
+            logical_operator?(parent) ||
+              (parent.send_type? &&
+              parent.arguments.any? { |argument| logical_operator?(argument) })
+          end
+
+          def call_in_optional_arguments?(node)
+            node.parent&.type?(:optarg, :kwoptarg)
+          end
+
+          def call_in_single_line_inheritance?(node)
+            node.parent&.class_type? && node.parent.single_line?
+          end
+
+          # rubocop:disable Metrics/PerceivedComplexity
+          def call_with_ambiguous_arguments?(node)
+            call_with_braced_block?(node) ||
+              call_in_argument_with_block?(node) ||
+              call_as_argument_or_chain?(node) ||
+              call_in_match_pattern?(node) ||
+              hash_literal_in_arguments?(node) ||
+              ambiguous_range_argument?(node) ||
+              node.descendants.any? do |n|
+                n.type?(:forwarded_args, :any_block) ||
+                  ambiguous_literal?(n) || logical_operator?(n)
+              end
+          end
+          # rubocop:enable Metrics/PerceivedComplexity
+
+          def call_with_braced_block?(node)
+            node.type?(:call, :super) && node.block_node&.braces?
+          end
+
+          def call_in_argument_with_block?(node)
+            parent = node.parent&.any_block_type? && node.parent.parent
+            return false unless parent
+
+            parent.type?(:call, :super, :yield)
+          end
+
+          def call_as_argument_or_chain?(node)
+            node.parent&.type?(:call, :super, :yield) &&
+              !assigned_before?(node.parent, node)
+          end
+
+          def call_in_match_pattern?(node)
+            return false unless (parent = node.parent)
+
+            parent.type?(:match_pattern, :match_pattern_p)
+          end
+
+          def hash_literal_in_arguments?(node)
+            node.arguments.any? do |n|
+              hash_literal?(n) ||
+                (n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) })
+            end
+          end
+
+          def ambiguous_range_argument?(node)
+            return true if (first_arg = node.first_argument)&.range_type? && first_arg.begin.nil?
+            return true if (last_arg = node.last_argument)&.range_type? && last_arg.end.nil?
+
+            false
+          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 ambiguous_literal?(node)
+            splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) || unary_literal?(node)
+          end
+
+          def splat?(node)
+            node.type?(:splat, :kwsplat, :block_pass)
+          end
+
+          def ternary_if?(node)
+            node.if_type? && node.ternary?
+          end
+
+          def logical_operator?(node)
+            node.operator_keyword? && 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
+
+          def inside_string_interpolation?(node)
+            node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
+          end
+
+          def assignment_in_condition?(node)
+            parent = node.parent
+            return false unless parent
+
+            grandparent = parent.parent
+            return false unless grandparent
+
+            parent.assignment? && (grandparent.conditional? || grandparent.when_type?)
+          end
+
+          def forwards_anonymous_rest_arguments?(node)
+            return false unless (last_argument = node.last_argument)
+            return true if last_argument.forwarded_restarg_type?
+
+            last_argument.hash_type? && last_argument.children.first&.forwarded_kwrestarg_type?
+          end
+        end
+        # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      class MethodCallWithArgsParentheses
+        # Style require_parentheses
+        module RequireParentheses
+          REQUIRE_MSG = 'Use parentheses for method calls with arguments.'
+          private_constant :REQUIRE_MSG
+
+          private
+
+          def require_parentheses(node)
+            return if allowed_method_name?(node.method_name)
+            return if matches_allowed_pattern?(node.method_name)
+            return if eligible_for_parentheses_omission?(node)
+            return unless node.arguments? && !node.parenthesized?
+
+            add_offense(node, message: REQUIRE_MSG) do |corrector|
+              corrector.replace(args_begin(node), '(')
+
+              corrector.insert_after(args_end(node), ')') unless args_parenthesized?(node)
+            end
+          end
+
+          def allowed_method_name?(name)
+            allowed_method?(name) || matches_allowed_pattern?(name)
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the presence (default) or absence of parentheses in
+      # method calls containing arguments.
+      #
+      # In the default style (require_parentheses), macro methods are allowed.
+      # Additional methods can be added to the `AllowedMethods` or
+      # `AllowedPatterns` list. These options are valid only in the default
+      # style. Macros can be included by either setting `IgnoreMacros` to false
+      # or adding specific macros to the `IncludedMacros` list.
+      #
+      # Precedence of options is as follows:
+      #
+      # 1. `AllowedMethods`
+      # 2. `AllowedPatterns`
+      # 3. `IncludedMacros`
+      #
+      # If a method is listed in both `IncludedMacros` and `AllowedMethods`,
+      # then the latter takes precedence (that is, the method is allowed).
+      #
+      # In the alternative style (omit_parentheses), there are three additional
+      # options.
+      #
+      # 1. `AllowParenthesesInChaining` is `false` by default. Setting it to
+      #    `true` allows the presence of parentheses in the last call during
+      #    method chaining.
+      #
+      # 2. `AllowParenthesesInMultilineCall` is `false` by default. Setting it
+      #     to `true` allows the presence of parentheses in multi-line method
+      #     calls.
+      #
+      # 3. `AllowParenthesesInCamelCaseMethod` is `false` by default. This
+      #     allows the presence of parentheses when calling a method whose name
+      #     begins with a capital letter and which has no arguments. Setting it
+      #     to `true` allows the presence of parentheses in such a method call
+      #     even with arguments.
+      #
+      # NOTE: The style of `omit_parentheses` allows parentheses in cases where
+      # omitting them results in ambiguous or syntactically incorrect code.
+      #
+      # Non-exhaustive list of examples:
+      #
+      # - Parentheses are required allowed in method calls with arguments inside
+      #   literals, logical operators, setting default values in position and
+      #   keyword arguments, chaining and more.
+      # - Parentheses are allowed in method calls with arguments inside
+      #   operators to avoid ambiguity.
+      #   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+      #   endless range.
+      # - Parentheses are allowed when forwarding arguments with the
+      #   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+      #   endless range.
+      # - Parentheses are required in calls with arguments when inside an
+      #   endless method definition introduced in Ruby 3.0.
+      # - Ruby 3.1's hash omission syntax allows parentheses if the method call
+      #   is in conditionals and requires parentheses if the call
+      #   is not the value-returning expression. See
+      #   https://bugs.ruby-lang.org/issues/18396.
+      # - Parentheses are required in anonymous arguments, keyword arguments
+      #   and block passing in Ruby 3.2.
+      # - Parentheses are required when the first argument is a beginless range or
+      #   the last argument is an endless range.
+      #
+      # @example EnforcedStyle: require_parentheses (default)
+      #
+      #   # bad
+      #   array.delete e
+      #
+      #   # good
+      #   array.delete(e)
+      #
+      #   # good
+      #   # Operators don't need parens
+      #   foo == bar
+      #
+      #   # good
+      #   # Setter methods don't need parens
+      #   foo.bar = baz
+      #
+      #   # okay with `puts` listed in `AllowedMethods`
+      #   puts 'test'
+      #
+      #   # okay with `^assert` listed in `AllowedPatterns`
+      #   assert_equal 'test', x
+      #
+      # @example EnforcedStyle: omit_parentheses
+      #
+      #   # bad
+      #   array.delete(e)
+      #
+      #   # good
+      #   array.delete e
+      #
+      #   # bad
+      #   action.enforce(strict: true)
+      #
+      #   # good
+      #   action.enforce strict: true
+      #
+      #   # good
+      #   # Parentheses are allowed for code that can be ambiguous without
+      #   # them.
+      #   action.enforce(condition) || other_condition
+      #
+      #   # good
+      #   # Parentheses are allowed for calls that won't produce valid Ruby
+      #   # without them.
+      #   yield path, File.basename(path)
+      #
+      #   # good
+      #   # Omitting the parentheses in Ruby 3.1 hash omission syntax can lead
+      #   # to ambiguous code. We allow them in conditionals and non-last
+      #   # expressions. See https://bugs.ruby-lang.org/issues/18396
+      #   if meets(criteria:, action:)
+      #     safe_action(action) || dangerous_action(action)
+      #   end
+      #
+      # @example IgnoreMacros: true (default)
+      #
+      #   # good
+      #   class Foo
+      #     bar :baz
+      #   end
+      #
+      # @example IgnoreMacros: false
+      #
+      #   # bad
+      #   class Foo
+      #     bar :baz
+      #   end
+      #
+      # @example AllowParenthesesInMultilineCall: false (default)
+      #
+      #   # bad
+      #   foo.enforce(
+      #     strict: true
+      #   )
+      #
+      #   # good
+      #   foo.enforce \
+      #     strict: true
+      #
+      # @example AllowParenthesesInMultilineCall: true
+      #
+      #   # good
+      #   foo.enforce(
+      #     strict: true
+      #   )
+      #
+      #   # good
+      #   foo.enforce \
+      #     strict: true
+      #
+      # @example AllowParenthesesInChaining: false (default)
+      #
+      #   # bad
+      #   foo().bar(1)
+      #
+      #   # good
+      #   foo().bar 1
+      #
+      # @example AllowParenthesesInChaining: true
+      #
+      #   # good
+      #   foo().bar(1)
+      #
+      #   # good
+      #   foo().bar 1
+      #
+      # @example AllowParenthesesInCamelCaseMethod: false (default)
+      #
+      #   # bad
+      #   Array(1)
+      #
+      #   # good
+      #   Array 1
+      #
+      # @example AllowParenthesesInCamelCaseMethod: true
+      #
+      #   # good
+      #   Array(1)
+      #
+      #   # good
+      #   Array 1
+      #
+      # @example AllowParenthesesInStringInterpolation: false (default)
+      #
+      #   # bad
+      #   "#{t('this.is.bad')}"
+      #
+      #   # good
+      #   "#{t 'this.is.better'}"
+      #
+      # @example AllowParenthesesInStringInterpolation: true
+      #
+      #   # good
+      #   "#{t('this.is.good')}"
+      #
+      #   # good
+      #   "#{t 'this.is.also.good'}"
+      class MethodCallWithArgsParentheses < Base
+        require_relative 'method_call_with_args_parentheses/omit_parentheses'
+        require_relative 'method_call_with_args_parentheses/require_parentheses'
+
+        include ConfigurableEnforcedStyle
+        include AllowedMethods
+        include AllowedPattern
+        include RequireParentheses
+        include OmitParentheses
+        extend AutoCorrector
+
+        def self.autocorrect_incompatible_with
+          [Style::NestedParenthesizedCalls, Style::RescueModifier]
+        end
+
+        def on_send(node)
+          send(style, node) # call require_parentheses or omit_parentheses
+        end
+        alias on_csend on_send
+        alias on_yield on_send
+
+        private
+
+        def args_begin(node)
+          loc = node.loc
+          selector = node.yield_type? ? loc.keyword : loc.selector
+
+          resize_by = args_parenthesized?(node) ? 2 : 1
+          selector.end.resize(resize_by)
+        end
+
+        def args_end(node)
+          node.source_range.end
+        end
+
+        def args_parenthesized?(node)
+          return false unless node.arguments.one?
+
+          first_node = node.first_argument
+          first_node.begin_type? && first_node.parenthesized_call?
+        end
+      end
+    end
+  end
+end