fablicop 1.10.2 → 1.10.3

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/accessor_grouping.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for grouping of accessors in `class` and `module` bodies.
+      # By default it enforces accessors to be placed in grouped declarations,
+      # but it can be configured to enforce separating them in multiple declarations.
+      #
+      # NOTE: If there is a method call before the accessor method it is always allowed
+      # as it might be intended like Sorbet.
+      #
+      # @example EnforcedStyle: grouped (default)
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_reader :bax
+      #     attr_reader :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :bar, :bax, :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     # may be intended comment for bar.
+      #     attr_reader :bar
+      #
+      #     sig { returns(String) }
+      #     attr_reader :bax
+      #
+      #     may_be_intended_annotation :baz
+      #     attr_reader :baz
+      #   end
+      #
+      # @example EnforcedStyle: separated
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar, :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_reader :baz
+      #   end
+      #
+      class AccessorGrouping < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        include VisibilityHelp
+        extend AutoCorrector
+
+        GROUPED_MSG = 'Group together all `%<accessor>s` attributes.'
+        SEPARATED_MSG = 'Use one attribute per `%<accessor>s`.'
+
+        def on_class(node)
+          class_send_elements(node).each do |macro|
+            next unless macro.attribute_accessor?
+
+            check(macro)
+          end
+        end
+        alias on_sclass on_class
+        alias on_module on_class
+
+        private
+
+        def check(send_node)
+          return if previous_line_comment?(send_node) || !groupable_accessor?(send_node)
+          return unless (grouped_style? && groupable_sibling_accessors(send_node).size > 1) ||
+                        (separated_style? && send_node.arguments.size > 1)
+
+          message = message(send_node)
+          add_offense(send_node, message: message) do |corrector|
+            autocorrect(corrector, send_node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          if (preferred_accessors = preferred_accessors(node))
+            corrector.replace(node, preferred_accessors)
+          else
+            range = range_with_surrounding_space(node.source_range, side: :left)
+            corrector.remove(range)
+          end
+        end
+
+        def previous_line_comment?(node)
+          comment_line?(processed_source[node.first_line - 2])
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def groupable_accessor?(node)
+          return true unless (previous_expression = node.left_siblings.last)
+
+          # Accessors with Sorbet `sig { ... }` blocks shouldn't be groupable.
+          if previous_expression.block_type?
+            previous_expression.child_nodes.each do |child_node|
+              break previous_expression = child_node if child_node.send_type?
+            end
+          end
+
+          return true unless previous_expression.send_type?
+
+          previous_expression.attribute_accessor? ||
+            previous_expression.access_modifier? ||
+            node.first_line - previous_expression.last_line > 1 # there is a space between nodes
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def class_send_elements(class_node)
+          class_def = class_node.body
+
+          if !class_def || class_def.def_type?
+            []
+          elsif class_def.send_type?
+            [class_def]
+          else
+            class_def.each_child_node(:send).to_a
+          end
+        end
+
+        def grouped_style?
+          style == :grouped
+        end
+
+        def separated_style?
+          style == :separated
+        end
+
+        def groupable_sibling_accessors(send_node)
+          send_node.parent.each_child_node(:send).select do |sibling|
+            sibling.attribute_accessor? &&
+              sibling.method?(send_node.method_name) &&
+              node_visibility(sibling) == node_visibility(send_node) &&
+              groupable_accessor?(sibling) && !previous_line_comment?(sibling)
+          end
+        end
+
+        def message(send_node)
+          msg = grouped_style? ? GROUPED_MSG : SEPARATED_MSG
+          format(msg, accessor: send_node.method_name)
+        end
+
+        def preferred_accessors(node)
+          if grouped_style?
+            accessors = groupable_sibling_accessors(node)
+            group_accessors(node, accessors) if node.loc == accessors.first.loc
+          else
+            separate_accessors(node)
+          end
+        end
+
+        def group_accessors(node, accessors)
+          accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }.uniq
+
+          "#{node.method_name} #{accessor_names.join(', ')}"
+        end
+
+        def separate_accessors(node)
+          node.arguments.flat_map do |arg|
+            lines = [
+              *processed_source.ast_with_comments[arg].map(&:text),
+              "#{node.method_name} #{arg.source}"
+            ]
+            if arg == node.arguments.first
+              lines
+            else
+              indent = ' ' * node.loc.column
+              lines.map { |line| "#{indent}#{line}" }
+            end
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/alias.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of either `#alias` or `#alias_method`
+      # depending on configuration.
+      # It also flags uses of `alias :symbol` rather than `alias bareword`.
+      #
+      # However, it will always enforce `method_alias` when used `alias`
+      # in an instance method definition and in a singleton method definition.
+      # If used in a block, always enforce `alias_method`
+      # unless it is an `instance_eval` block.
+      #
+      # @example EnforcedStyle: prefer_alias (default)
+      #   # bad
+      #   alias_method :bar, :foo
+      #   alias :bar :foo
+      #
+      #   # good
+      #   alias bar foo
+      #
+      # @example EnforcedStyle: prefer_alias_method
+      #   # bad
+      #   alias :bar :foo
+      #   alias bar foo
+      #
+      #   # good
+      #   alias_method :bar, :foo
+      #
+      class Alias < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG_ALIAS = 'Use `alias_method` instead of `alias`.'
+        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` %<current>s.'
+        MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of `alias %<current>s`.'
+
+        RESTRICT_ON_SEND = %i[alias_method].freeze
+
+        def on_send(node)
+          return unless node.command?(:alias_method)
+          return unless style == :prefer_alias && alias_keyword_possible?(node)
+
+          msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
+          add_offense(node.loc.selector, message: msg) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def on_alias(node)
+          return unless alias_method_possible?(node)
+
+          if scope_type(node) == :dynamic || style == :prefer_alias_method
+            add_offense(node.loc.keyword, message: MSG_ALIAS) do |corrector|
+              autocorrect(corrector, node)
+            end
+          elsif node.children.none? { |arg| bareword?(arg) }
+            add_offense_for_args(node) { |corrector| autocorrect(corrector, node) }
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          if node.send_type?
+            correct_alias_method_to_alias(corrector, node)
+          elsif scope_type(node) == :dynamic || style == :prefer_alias_method
+            correct_alias_to_alias_method(corrector, node)
+          else
+            correct_alias_with_symbol_args(corrector, node)
+          end
+        end
+
+        def alias_keyword_possible?(node)
+          scope_type(node) != :dynamic && node.arguments.all?(&:sym_type?)
+        end
+
+        def alias_method_possible?(node)
+          scope_type(node) != :instance_eval &&
+            node.children.none?(&:gvar_type?) &&
+            node&.parent&.type != :def
+        end
+
+        def add_offense_for_args(node, &block)
+          existing_args  = node.children.map(&:source).join(' ')
+          preferred_args = node.children.map { |a| a.source[1..] }.join(' ')
+          arg_ranges     = node.children.map(&:source_range)
+          msg            = format(MSG_SYMBOL_ARGS, prefer: preferred_args, current: existing_args)
+          add_offense(arg_ranges.reduce(&:join), message: msg, &block)
+        end
+
+        # In this expression, will `self` be the same as the innermost enclosing
+        # class or module block (:lexical)? Or will it be something else
+        # (:dynamic)? If we're in an instance_eval block, return that.
+        def scope_type(node)
+          while (parent = node.parent)
+            case parent.type
+            when :class, :module
+              return :lexical
+            when :def, :defs
+              return :dynamic
+            when :block
+              return :instance_eval if parent.method?(:instance_eval)
+
+              return :dynamic
+            end
+            node = parent
+          end
+          :lexical
+        end
+
+        def lexical_scope_type(node)
+          ancestor = node.each_ancestor(:class, :module).first
+          if ancestor.nil?
+            'at the top level'
+          elsif ancestor.class_type?
+            'in a class body'
+          else
+            'in a module body'
+          end
+        end
+
+        def bareword?(sym_node)
+          !sym_node.source.start_with?(':')
+        end
+
+        def correct_alias_method_to_alias(corrector, send_node)
+          new, old = *send_node.arguments
+          replacement = "alias #{identifier(new)} #{identifier(old)}"
+
+          corrector.replace(send_node, replacement)
+        end
+
+        def correct_alias_to_alias_method(corrector, node)
+          replacement =
+            'alias_method ' \
+            ":#{identifier(node.new_identifier)}, " \
+            ":#{identifier(node.old_identifier)}"
+
+          corrector.replace(node, replacement)
+        end
+
+        def correct_alias_with_symbol_args(corrector, node)
+          corrector.replace(node.new_identifier, node.new_identifier.source[1..])
+          corrector.replace(node.old_identifier, node.old_identifier.source[1..])
+        end
+
+        # @!method identifier(node)
+        def_node_matcher :identifier, <<~PATTERN
+          (sym $_)
+        PATTERN
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/and_or.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of `and` and `or`, and suggests using `&&` and
+      # `||` instead. It can be configured to check only in conditions or in
+      # all contexts.
+      #
+      # @safety
+      #   Autocorrection is unsafe because there is a different operator precedence
+      #   between logical operators (`&&` and `||`) and semantic operators (`and` and `or`),
+      #   and that might change the behavior.
+      #
+      # @example EnforcedStyle: conditionals (default)
+      #   # bad
+      #   if foo and bar
+      #   end
+      #
+      #   # good
+      #   foo.save && return
+      #
+      #   # good
+      #   foo.save and return
+      #
+      #   # good
+      #   if foo && bar
+      #   end
+      #
+      # @example EnforcedStyle: always
+      #   # bad
+      #   foo.save and return
+      #
+      #   # bad
+      #   if foo and bar
+      #   end
+      #
+      #   # good
+      #   foo.save && return
+      #
+      #   # good
+      #   if foo && bar
+      #   end
+      class AndOr < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        def on_and(node)
+          process_logical_operator(node) if style == :always
+        end
+        alias on_or on_and
+
+        def on_if(node)
+          on_conditionals(node) if style == :conditionals
+        end
+        alias on_while      on_if
+        alias on_while_post on_if
+        alias on_until      on_if
+        alias on_until_post on_if
+
+        private
+
+        def process_logical_operator(node)
+          return if node.logical_operator?
+
+          message = message(node)
+          add_offense(node.loc.operator, message: message) do |corrector|
+            node.each_child_node do |expr|
+              if expr.send_type?
+                correct_send(expr, corrector)
+              elsif expr.return_type? || expr.assignment?
+                correct_other(expr, corrector)
+              end
+            end
+
+            corrector.replace(node.loc.operator, node.alternate_operator)
+
+            keep_operator_precedence(corrector, node)
+          end
+        end
+
+        def on_conditionals(node)
+          node.condition.each_node(*AST::Node::OPERATOR_KEYWORDS) do |operator|
+            process_logical_operator(operator)
+          end
+        end
+
+        def message(node)
+          format(MSG, prefer: node.alternate_operator, current: node.operator)
+        end
+
+        def correct_send(node, corrector)
+          return correct_not(node, node.receiver, corrector) if node.method?(:!)
+          return correct_setter(node, corrector) if node.setter_method?
+          return correct_other(node, corrector) if node.comparison_method?
+
+          return unless correctable_send?(node)
+
+          whitespace_before_arg_range = whitespace_before_arg(node)
+          corrector.remove(whitespace_before_arg_range)
+          corrector.insert_before(whitespace_before_arg_range, '(')
+          corrector.insert_after(node.last_argument, ')')
+        end
+
+        def correct_setter(node, corrector)
+          corrector.insert_before(node.receiver, '(')
+          corrector.insert_after(node.last_argument, ')')
+        end
+
+        # ! is a special case:
+        # 'x and !obj.method arg' can be autocorrected if we
+        # recurse down a level and add parens to 'obj.method arg'
+        # however, 'not x' also parses as (send x :!)
+        def correct_not(node, receiver, corrector)
+          if node.prefix_bang?
+            return unless receiver.send_type?
+
+            correct_send(receiver, corrector)
+          elsif node.prefix_not?
+            correct_other(node, corrector)
+          else
+            raise 'unrecognized unary negation operator'
+          end
+        end
+
+        def correct_other(node, corrector)
+          return if node.source_range.begin.is?('(')
+
+          corrector.wrap(node, '(', ')')
+        end
+
+        def keep_operator_precedence(corrector, node)
+          if node.or_type? && node.parent&.and_type?
+            corrector.wrap(node, '(', ')')
+          elsif node.and_type? && node.rhs.or_type?
+            corrector.wrap(node.rhs, '(', ')')
+          end
+        end
+
+        def correctable_send?(node)
+          !node.parenthesized? && node.arguments? && !node.method?(:[])
+        end
+
+        def whitespace_before_arg(node)
+          begin_paren = node.loc.selector.end_pos
+          end_paren = begin_paren
+          # Increment position of parenthesis, unless message is a predicate
+          # method followed by a non-whitespace char (e.g. is_a?String).
+          end_paren += 1 unless /\?\S/.match?(node.source)
+          range_between(begin_paren, end_paren)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/arguments_forwarding.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # In Ruby 2.7, arguments forwarding has been added.
+      #
+      # This cop identifies places where `do_something(*args, &block)`
+      # can be replaced by `do_something(...)`.
+      #
+      # @example
+      #   # bad
+      #   def foo(*args, &block)
+      #     bar(*args, &block)
+      #   end
+      #
+      #   # bad
+      #   def foo(*args, **kwargs, &block)
+      #     bar(*args, **kwargs, &block)
+      #   end
+      #
+      #   # good
+      #   def foo(...)
+      #     bar(...)
+      #   end
+      #
+      # @example AllowOnlyRestArgument: true (default)
+      #   # good
+      #   def foo(*args)
+      #     bar(*args)
+      #   end
+      #
+      #   def foo(**kwargs)
+      #     bar(**kwargs)
+      #   end
+      #
+      # @example AllowOnlyRestArgument: false
+      #   # bad
+      #   # The following code can replace the arguments with `...`,
+      #   # but it will change the behavior. Because `...` forwards block also.
+      #   def foo(*args)
+      #     bar(*args)
+      #   end
+      #
+      #   def foo(**kwargs)
+      #     bar(**kwargs)
+      #   end
+      #
+      class ArgumentsForwarding < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.7
+
+        MSG = 'Use arguments forwarding.'
+
+        # @!method use_rest_arguments?(node)
+        def_node_matcher :use_rest_arguments?, <<~PATTERN
+          (args ({restarg kwrestarg} $_) $...)
+        PATTERN
+
+        # @!method only_rest_arguments?(node, name)
+        def_node_matcher :only_rest_arguments?, <<~PATTERN
+          {
+            (send _ _ (splat (lvar %1)))
+            (send _ _ (hash (kwsplat (lvar %1))))
+          }
+        PATTERN
+
+        # @!method forwarding_method_arguments?(node, rest_name, block_name, kwargs_name)
+        def_node_matcher :forwarding_method_arguments?, <<~PATTERN
+          {
+            (send _ _
+              (splat (lvar %1))
+              (block-pass {(lvar %2) nil?}))
+            (send _ _
+              (splat (lvar %1))
+              (hash (kwsplat (lvar %3)))
+              (block-pass {(lvar %2) nil?}))
+          }
+        PATTERN
+
+        def on_def(node)
+          return unless node.body
+          return unless (rest_args_name, args = use_rest_arguments?(node.arguments))
+          return if args.any?(&:default?)
+
+          node.each_descendant(:send) do |send_node|
+            kwargs_name, block_name = extract_argument_names_from(args)
+
+            next unless forwarding_method?(send_node, rest_args_name, kwargs_name, block_name) &&
+                        all_lvars_as_forwarding_method_arguments?(node, send_node)
+
+            register_offense_to_forwarding_method_arguments(send_node)
+            register_offense_to_method_definition_arguments(node)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def extract_argument_names_from(args)
+          kwargs_name = args.first.source.delete('**') if args.first&.kwrestarg_type?
+          block_arg_name = args.last.source.delete('&') if args.last&.blockarg_type?
+
+          [kwargs_name, block_arg_name].map { |name| name&.to_sym }
+        end
+
+        def forwarding_method?(node, rest_arg, kwargs, block_arg)
+          return only_rest_arguments?(node, rest_arg) unless allow_only_rest_arguments?
+
+          forwarding_method_arguments?(node, rest_arg, block_arg, kwargs)
+        end
+
+        def all_lvars_as_forwarding_method_arguments?(def_node, forwarding_method)
+          lvars = def_node.body.each_descendant(:lvar, :lvasgn)
+
+          begin_pos = forwarding_method.source_range.begin_pos
+          end_pos = forwarding_method.source_range.end_pos
+
+          lvars.all? { |lvar| lvar.source_range.begin_pos.between?(begin_pos, end_pos) }
+        end
+
+        def register_offense_to_forwarding_method_arguments(forwarding_method)
+          add_offense(arguments_range(forwarding_method)) do |corrector|
+            begin_pos = forwarding_method.loc.selector&.end_pos || forwarding_method.loc.dot.end_pos
+            range = range_between(begin_pos, forwarding_method.source_range.end_pos)
+
+            corrector.replace(range, '(...)')
+          end
+        end
+
+        def register_offense_to_method_definition_arguments(method_definition)
+          add_offense(arguments_range(method_definition)) do |corrector|
+            arguments_range = range_with_surrounding_space(
+              method_definition.arguments.source_range, side: :left
+            )
+            corrector.replace(arguments_range, '(...)')
+          end
+        end
+
+        def arguments_range(node)
+          arguments = node.arguments
+
+          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
+        end
+
+        def allow_only_rest_arguments?
+          cop_config.fetch('AllowOnlyRestArgument', true)
+        end
+      end
+    end
+  end
+end