rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use symbols as procs when possible.
+      #
+      # If you prefer a style that allows block for method with arguments,
+      # please set `true` to `AllowMethodsWithArguments`.
+      # `define_method?` methods are allowed by default.
+      # These are customizable with `AllowedMethods` option.
+      #
+      # @safety
+      #   This cop is unsafe because there is a difference that a `Proc`
+      #   generated from `Symbol#to_proc` behaves as a lambda, while
+      #   a `Proc` generated from a block does not.
+      #   For example, a lambda will raise an `ArgumentError` if the
+      #   number of arguments is wrong, but a non-lambda `Proc` will not.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Foo
+      #     def bar
+      #       :bar
+      #     end
+      #   end
+      #
+      #   def call(options = {}, &block)
+      #     block.call(Foo.new, options)
+      #   end
+      #
+      #   call { |x| x.bar }
+      #   #=> :bar
+      #   call(&:bar)
+      #   # ArgumentError: wrong number of arguments (given 1, expected 0)
+      #   ----
+      #
+      #   It is also unsafe because `Symbol#to_proc` does not work with
+      #   `protected` methods which would otherwise be accessible.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Box
+      #     def initialize
+      #       @secret = rand
+      #     end
+      #
+      #     def normal_matches?(*others)
+      #       others.map { |other| other.secret }.any?(secret)
+      #     end
+      #
+      #     def symbol_to_proc_matches?(*others)
+      #       others.map(&:secret).any?(secret)
+      #     end
+      #
+      #     protected
+      #
+      #     attr_reader :secret
+      #   end
+      #
+      #   boxes = [Box.new, Box.new]
+      #   Box.new.normal_matches?(*boxes)
+      #   # => false
+      #   boxes.first.normal_matches?(*boxes)
+      #   # => true
+      #   Box.new.symbol_to_proc_matches?(*boxes)
+      #   # => NoMethodError: protected method `secret' called for #<Box...>
+      #   boxes.first.symbol_to_proc_matches?(*boxes)
+      #   # => NoMethodError: protected method `secret' called for #<Box...>
+      #   ----
+      #
+      # @example
+      #   # bad
+      #   something.map { |s| s.upcase }
+      #   something.map { _1.upcase }
+      #
+      #   # good
+      #   something.map(&:upcase)
+      #
+      # @example AllowMethodsWithArguments: false (default)
+      #   # bad
+      #   something.do_something(foo) { |o| o.bar }
+      #
+      #   # good
+      #   something.do_something(foo, &:bar)
+      #
+      # @example AllowMethodsWithArguments: true
+      #   # good
+      #   something.do_something(foo) { |o| o.bar }
+      #
+      # @example AllowComments: false (default)
+      #   # bad
+      #   something.do_something do |s| # some comment
+      #     # some comment
+      #     s.upcase # some comment
+      #     # some comment
+      #   end
+      #
+      # @example AllowComments: true
+      #   # good  - if there are comment in either position
+      #   something.do_something do |s| # some comment
+      #     # some comment
+      #     s.upcase # some comment
+      #     # some comment
+      #   end
+      #
+      # @example AllowedMethods: [define_method] (default)
+      #   # good
+      #   define_method(:foo) { |foo| foo.bar }
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # bad
+      #   something.map { |s| s.upcase }
+      #
+      # @example AllowedPatterns: ['map'] (default)
+      #   # good
+      #   something.map { |s| s.upcase }
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #   # bad
+      #   ->(x) { x.foo }
+      #   proc { |x| x.foo }
+      #   Proc.new { |x| x.foo }
+      #
+      #   # good
+      #   lambda(&:foo)
+      #   proc(&:foo)
+      #   Proc.new(&:foo)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #   # good
+      #   ->(x) { x.foo }
+      #   proc { |x| x.foo }
+      #   Proc.new { |x| x.foo }
+      #
+      class SymbolProc < Base
+        include CommentsHelp
+        include RangeHelp
+        include AllowedMethods
+        include AllowedPattern
+        extend AutoCorrector
+
+        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
+        SUPER_TYPES = %i[super zsuper].freeze
+        LAMBDA_OR_PROC = %i[lambda proc].freeze
+
+        # @!method proc_node?(node)
+        def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
+
+        # @!method symbol_proc_receiver?(node)
+        def_node_matcher :symbol_proc_receiver?, '{(call ...) (super ...) zsuper}'
+
+        # @!method symbol_proc?(node)
+        def_node_matcher :symbol_proc?, <<~PATTERN
+          {
+            (block $#symbol_proc_receiver? $(args (arg _var)) (send (lvar _var) $_))
+            (numblock $#symbol_proc_receiver? $1 (send (lvar :_1) $_))
+            (itblock $#symbol_proc_receiver? $_ (send (lvar :it) $_))
+          }
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [Layout::SpaceBeforeBlockBraces]
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def on_block(node)
+          symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
+            if active_support_extensions_enabled?
+              return if proc_node?(dispatch_node)
+              return if LAMBDA_OR_PROC.include?(dispatch_node.method_name)
+            end
+            return if unsafe_hash_usage?(dispatch_node)
+            return if unsafe_array_usage?(dispatch_node)
+            return if allowed_method_name?(dispatch_node.method_name)
+            return if allow_if_method_has_argument?(node.send_node)
+            return if node.block_type? && destructuring_block_argument?(arguments_node)
+            return if allow_comments? && contains_comments?(node)
+
+            register_offense(node, method_name, dispatch_node.method_name)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def destructuring_block_argument?(argument_node)
+          argument_node.one? && argument_node.source.include?(',')
+        end
+
+        private
+
+        # See: https://github.com/rubocop/rubocop/issues/10864
+        def unsafe_hash_usage?(node)
+          node.receiver&.hash_type? && %i[reject select].include?(node.method_name)
+        end
+
+        def unsafe_array_usage?(node)
+          node.receiver&.array_type? && %i[min max].include?(node.method_name)
+        end
+
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
+        def register_offense(node, method_name, block_method_name)
+          block_start = node.loc.begin.begin_pos
+          block_end = node.loc.end.end_pos
+          range = range_between(block_start, block_end)
+          message = format(MSG, method: method_name, block_method: block_method_name)
+
+          add_offense(range, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+
+        def autocorrect(corrector, node)
+          if node.send_node.arguments?
+            autocorrect_with_args(corrector, node, node.send_node.arguments, node.body.method_name)
+          else
+            autocorrect_without_args(corrector, node)
+          end
+        end
+
+        def autocorrect_without_args(corrector, node)
+          if node.send_node.lambda_literal?
+            if node.send_node.loc.selector.source == '->'
+              corrector.replace(node, "lambda(&:#{node.body.method_name})")
+              return
+            else
+              autocorrect_lambda_block(corrector, node)
+            end
+          end
+
+          corrector.replace(block_range_with_space(node), "(&:#{node.body.method_name})")
+        end
+
+        def autocorrect_with_args(corrector, node, args, method_name)
+          arg_range = args.last.source_range
+          arg_range = range_with_surrounding_comma(arg_range, :right)
+          replacement = " &:#{method_name}"
+          replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
+          corrector.insert_after(arg_range, replacement)
+          corrector.remove(block_range_with_space(node))
+        end
+
+        def autocorrect_lambda_block(corrector, node)
+          send_node_loc = node.send_node.loc
+          corrector.replace(send_node_loc.selector, 'lambda')
+
+          range = range_between(send_node_loc.selector.end_pos, node.loc.begin.end_pos - 2)
+          corrector.remove(range)
+        end
+
+        def block_range_with_space(node)
+          block_range = range_between(begin_pos_for_replacement(node), node.loc.end.end_pos)
+          range_with_surrounding_space(block_range, side: :left)
+        end
+
+        def begin_pos_for_replacement(node)
+          expr = node.send_node.source_range
+
+          if (paren_pos = (expr.source =~ /\(\s*\)$/))
+            expr.begin_pos + paren_pos
+          else
+            node.loc.begin.begin_pos
+          end
+        end
+
+        def allow_if_method_has_argument?(send_node)
+          !!cop_config.fetch('AllowMethodsWithArguments', false) && !send_node.arguments.count.zero?
+        end
+
+        def allow_comments?
+          cop_config.fetch('AllowComments', false)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the presence of parentheses around ternary
+      # conditions. It is configurable to enforce inclusion or omission of
+      # parentheses using `EnforcedStyle`. Omission is only enforced when
+      # removing the parentheses won't cause a different behavior.
+      #
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
+      #
+      # @example EnforcedStyle: require_no_parentheses (default)
+      #   # bad
+      #   foo = (bar?) ? a : b
+      #   foo = (bar.baz?) ? a : b
+      #   foo = (bar && baz) ? a : b
+      #
+      #   # good
+      #   foo = bar? ? a : b
+      #   foo = bar.baz? ? a : b
+      #   foo = bar && baz ? a : b
+      #
+      # @example EnforcedStyle: require_parentheses
+      #   # bad
+      #   foo = bar? ? a : b
+      #   foo = bar.baz? ? a : b
+      #   foo = bar && baz ? a : b
+      #
+      #   # good
+      #   foo = (bar?) ? a : b
+      #   foo = (bar.baz?) ? a : b
+      #   foo = (bar && baz) ? a : b
+      #
+      # @example EnforcedStyle: require_parentheses_when_complex
+      #   # bad
+      #   foo = (bar?) ? a : b
+      #   foo = (bar.baz?) ? a : b
+      #   foo = bar && baz ? a : b
+      #
+      #   # good
+      #   foo = bar? ? a : b
+      #   foo = bar.baz? ? a : b
+      #   foo = (bar && baz) ? a : b
+      #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   foo = (bar = baz) ? a : b
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   foo = (bar = baz) ? a : b
+      #
+      class TernaryParentheses < Base
+        include SafeAssignment
+        include ConfigurableEnforcedStyle
+        include SurroundingSpace
+        extend AutoCorrector
+
+        VARIABLE_TYPES = AST::Node::VARIABLES
+        NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
+
+        MSG = '%<command>s parentheses for ternary conditions.'
+        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with complex conditions.'
+
+        def on_if(node)
+          condition = node.condition
+
+          return if only_closing_parenthesis_is_last_line?(condition)
+          return if condition_as_parenthesized_one_line_pattern_matching?(condition)
+          return unless node.ternary? && offense?(node)
+
+          message = message(node)
+
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def only_closing_parenthesis_is_last_line?(condition)
+          condition.source.split("\n").last == ')'
+        end
+
+        def condition_as_parenthesized_one_line_pattern_matching?(condition)
+          return false unless condition.parenthesized_call?
+          return false unless (first_child = condition.children.first)
+
+          if target_ruby_version >= 3.0
+            first_child.match_pattern_p_type?
+          else
+            first_child.match_pattern_type? # For Ruby 2.7's one line pattern matching AST.
+          end
+        end
+
+        def autocorrect(corrector, node)
+          condition = node.condition
+
+          return nil if parenthesized?(condition) &&
+                        (safe_assignment?(condition) || unsafe_autocorrect?(condition))
+
+          if parenthesized?(condition)
+            correct_parenthesized(corrector, condition)
+          else
+            correct_unparenthesized(corrector, condition)
+          end
+        end
+
+        def offense?(node)
+          condition = node.condition
+
+          if safe_assignment?(condition)
+            !safe_assignment_allowed?
+          else
+            parens = parenthesized?(condition)
+            case style
+            when :require_parentheses_when_complex
+              complex_condition?(condition) ? !parens : parens
+            else
+              require_parentheses? ? !parens : parens
+            end
+          end
+        end
+
+        # If the condition is parenthesized we recurse and check for any
+        # complex expressions within it.
+        def complex_condition?(condition)
+          if condition.begin_type?
+            condition.to_a.any? { |x| complex_condition?(x) }
+          else
+            !non_complex_expression?(condition)
+          end
+        end
+
+        # Anything that is not a variable, constant, or method/.method call
+        # will be counted as a complex expression.
+        def non_complex_expression?(condition)
+          NON_COMPLEX_TYPES.include?(condition.type) || non_complex_send?(condition)
+        end
+
+        def non_complex_send?(node)
+          return false unless node.call_type?
+
+          !node.operator_method? || node.method?(:[])
+        end
+
+        def message(node)
+          if require_parentheses_when_complex?
+            command = parenthesized?(node.condition) ? 'Only use' : 'Use'
+            format(MSG_COMPLEX, command: command)
+          else
+            command = require_parentheses? ? 'Use' : 'Omit'
+            format(MSG, command: command)
+          end
+        end
+
+        def require_parentheses?
+          style == :require_parentheses
+        end
+
+        def require_parentheses_when_complex?
+          style == :require_parentheses_when_complex
+        end
+
+        def parenthesized?(node)
+          node.begin_type?
+        end
+
+        def unsafe_autocorrect?(condition)
+          condition.children.any? { |child| below_ternary_precedence?(child) }
+        end
+
+        def unparenthesized_method_call?(child)
+          /^[a-z]/i.match?(method_name(child)) && !child.parenthesized?
+        end
+
+        def below_ternary_precedence?(child)
+          # Handle English "or", e.g. 'foo or bar ? a : b'
+          (child.or_type? && child.semantic_operator?) ||
+            # Handle English "and", e.g. 'foo and bar ? a : b'
+            (child.and_type? && child.semantic_operator?) ||
+            # Handle English "not", e.g. 'not foo ? a : b'
+            (child.send_type? && child.prefix_not?)
+        end
+
+        # @!method method_name(node)
+        def_node_matcher :method_name, <<~PATTERN
+          {($:defined? _ ...)
+           (call {_ nil?} $_ _ ...)}
+        PATTERN
+
+        def correct_parenthesized(corrector, condition)
+          corrector.remove(condition.loc.begin)
+          corrector.remove(condition.loc.end)
+
+          # Ruby allows no space between the question mark and parentheses.
+          # If we remove the parentheses, we need to add a space or we'll
+          # generate invalid code.
+          corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
+
+          if (send_node = condition.child_nodes.last) && node_args_need_parens?(send_node)
+            parenthesize_condition_arguments(corrector, send_node)
+          end
+        end
+
+        def correct_unparenthesized(corrector, condition)
+          corrector.wrap(condition, '(', ')')
+        end
+
+        def parenthesize_condition_arguments(corrector, send_node)
+          range_start = send_node.defined_type? ? send_node.loc.keyword : send_node.loc.selector
+          opening_range = range_start.end.join(send_node.first_argument.source_range.begin)
+
+          corrector.replace(opening_range, '(')
+          corrector.insert_after(send_node.last_argument, ')')
+        end
+
+        def whitespace_after?(node)
+          last_token = processed_source.last_token_of(node)
+          last_token.space_after?
+        end
+
+        def node_args_need_parens?(send_node)
+          return false unless node_with_args?(send_node)
+          return false if send_node.arguments.none? || send_node.parenthesized?
+
+          send_node.dot? || send_node.safe_navigation? || unparenthesized_method_call?(send_node)
+        end
+
+        def node_with_args?(node)
+          node.type?(:call, :defined?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Newcomers to ruby applications may write top-level methods,
+      # when ideally they should be organized in appropriate classes or modules.
+      # This cop looks for definitions of top-level methods and warns about them.
+      #
+      # However for ruby scripts it is perfectly fine to use top-level methods.
+      # Hence this cop is disabled by default.
+      #
+      # @example
+      #   # bad
+      #   def some_method
+      #   end
+      #
+      #   # bad
+      #   def self.some_method
+      #   end
+      #
+      #   # bad
+      #   define_method(:foo) { puts 1 }
+      #
+      #   # good
+      #   module Foo
+      #     def some_method
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def self.some_method
+      #     end
+      #   end
+      #
+      #   # good
+      #   Struct.new do
+      #     def some_method
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     define_method(:foo) { puts 1 }
+      #   end
+      class TopLevelMethodDefinition < Base
+        MSG = 'Do not define methods at the top-level.'
+
+        RESTRICT_ON_SEND = %i[define_method].freeze
+
+        def on_def(node)
+          return unless top_level_method_definition?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+        alias on_send on_def
+
+        def on_block(node)
+          return unless define_method_block?(node) && top_level_method_definition?(node)
+
+          add_offense(node)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def top_level_method_definition?(node)
+          if node.parent&.begin_type?
+            node.parent.root?
+          else
+            node.root?
+          end
+        end
+
+        # @!method define_method_block?(node)
+        def_node_matcher :define_method_block?, <<~PATTERN
+          (any_block (send _ :define_method _) ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for trailing code after the class definition.
+      #
+      # @example
+      #   # bad
+      #   class Foo; def foo; end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def foo; end
+      #   end
+      #
+      class TrailingBodyOnClass < Base
+        include Alignment
+        include TrailingBody
+        extend AutoCorrector
+
+        MSG = 'Place the first line of class body on its own line.'
+
+        def on_class(node)
+          return unless trailing_body?(node)
+
+          add_offense(first_part_of(node.to_a.last)) do |corrector|
+            LineBreakCorrector.correct_trailing_body(
+              configured_width: configured_indentation_width,
+              corrector: corrector,
+              node: node,
+              processed_source: processed_source
+            )
+          end
+        end
+        alias on_sclass on_class
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for trailing code after the method definition.
+      #
+      # NOTE: It always accepts endless method definitions that are basically on the same line.
+      #
+      # @example
+      #   # bad
+      #   def some_method; do_stuff
+      #   end
+      #
+      #   def f(x); b = foo
+      #     b[c: x]
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_stuff
+      #   end
+      #
+      #   def f(x)
+      #     b = foo
+      #     b[c: x]
+      #   end
+      #
+      #   def endless_method = do_stuff
+      #
+      class TrailingBodyOnMethodDefinition < Base
+        include Alignment
+        include TrailingBody
+        extend AutoCorrector
+
+        MSG = "Place the first line of a multi-line method definition's body on its own line."
+
+        def on_def(node)
+          return unless trailing_body?(node)
+          return if node.endless?
+
+          add_offense(first_part_of(node.body)) do |corrector|
+            LineBreakCorrector.correct_trailing_body(
+              configured_width: configured_indentation_width,
+              corrector: corrector,
+              node: node,
+              processed_source: processed_source
+            )
+          end
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end