siteimprove_api_client 1.0.4 → 1.0.5

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.86.1/lib/rubocop/cop/style/sole_nested_conditional.rb

@@ -1,244 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # If the branch of a conditional consists solely of a conditional node,
-      # its conditions can be combined with the conditions of the outer branch.
-      # This helps to keep the nesting level from getting too deep.
-      #
-      # @example
-      #   # bad
-      #   if condition_a
-      #     if condition_b
-      #       do_something
-      #     end
-      #   end
-      #
-      #   # bad
-      #   if condition_b
-      #     do_something
-      #   end if condition_a
-      #
-      #   # good
-      #   if condition_a && condition_b
-      #     do_something
-      #   end
-      #
-      # @example AllowModifier: false (default)
-      #   # bad
-      #   if condition_a
-      #     do_something if condition_b
-      #   end
-      #
-      #   # bad
-      #   if condition_b
-      #     do_something
-      #   end if condition_a
-      #
-      # @example AllowModifier: true
-      #   # good
-      #   if condition_a
-      #     do_something if condition_b
-      #   end
-      #
-      #   # good
-      #   if condition_b
-      #     do_something
-      #   end if condition_a
-      class SoleNestedConditional < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Consider merging nested conditions into outer `%<conditional_type>s` conditions.'
-
-        def self.autocorrect_incompatible_with
-          [Style::NegatedIf, Style::NegatedUnless]
-        end
-
-        def on_if(node)
-          return if node.ternary? || node.else? || node.elsif?
-
-          if_branch = node.if_branch
-          return if use_variable_assignment_in_condition?(node.condition, if_branch)
-          return unless offending_branch?(node, if_branch)
-
-          message = format(MSG, conditional_type: node.keyword)
-          add_offense(if_branch.loc.keyword, message: message) do |corrector|
-            autocorrect(corrector, node, if_branch)
-          end
-        end
-
-        private
-
-        def use_variable_assignment_in_condition?(condition, if_branch)
-          assigned_variables = assigned_variables(condition)
-
-          assigned_variables && if_branch&.if_type? &&
-            assigned_variables.include?(if_branch.condition.source)
-        end
-
-        def assigned_variables(condition)
-          assigned_variables = condition.assignment? ? [condition.children.first.to_s] : []
-
-          assigned_variables + condition.descendants.select(&:assignment?).map do |node|
-            node.children.first.to_s
-          end
-        end
-
-        def offending_branch?(node, branch)
-          return false unless branch
-
-          branch.if_type? &&
-            !branch.else? &&
-            !branch.ternary? &&
-            !((node.modifier_form? || branch.modifier_form?) && allow_modifier?)
-        end
-
-        def autocorrect(corrector, node, if_branch)
-          if node.modifier_form?
-            autocorrect_outer_condition_modify_form(corrector, node, if_branch)
-          else
-            autocorrect_outer_condition_basic(corrector, node, if_branch)
-          end
-        end
-
-        def autocorrect_outer_condition_basic(corrector, node, if_branch)
-          correct_node(corrector, node)
-
-          if if_branch.modifier_form?
-            correct_for_guard_condition_style(corrector, node, if_branch)
-          else
-            correct_for_basic_condition_style(corrector, node, if_branch)
-            correct_for_comment(corrector, node, if_branch)
-          end
-        end
-
-        def correct_node(corrector, node)
-          corrector.replace(node.loc.keyword, 'if') if node.unless? && !part_of_ignored_node?(node)
-          corrector.replace(node.condition, chainable_condition(node))
-          ignore_node(node)
-        end
-
-        def correct_for_guard_condition_style(corrector, node, if_branch)
-          corrector.insert_after(node.condition, " && #{chainable_condition(if_branch)}")
-
-          range = range_between(
-            if_branch.loc.keyword.begin_pos, if_branch.condition.source_range.end_pos
-          )
-          corrector.remove(range_with_surrounding_space(range, newlines: false))
-        end
-
-        # rubocop:disable Metrics/AbcSize
-        def correct_for_basic_condition_style(corrector, node, if_branch)
-          range = range_between(
-            node.condition.source_range.end_pos, if_branch.condition.source_range.begin_pos
-          )
-          corrector.replace(range, ' && ')
-
-          corrector.replace(if_branch.condition, chainable_condition(if_branch))
-
-          end_range = if same_line?(node.loc.end, node.if_branch.loc.end)
-                        node.loc.end
-                      else
-                        range_by_whole_lines(node.loc.end, include_final_newline: true)
-                      end
-          corrector.remove(end_range)
-        end
-        # rubocop:enable Metrics/AbcSize
-
-        def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
-          correct_node(corrector, if_branch)
-
-          corrector.insert_before(if_branch.condition, "#{chainable_condition(node)} && ")
-
-          range = range_between(node.loc.keyword.begin_pos, node.condition.source_range.end_pos)
-          corrector.remove(range_with_surrounding_space(range, newlines: false))
-        end
-
-        def correct_for_comment(corrector, node, if_branch)
-          comments = processed_source.ast_with_comments[if_branch].select do |comment|
-            comment.loc.line < if_branch.condition.first_line
-          end
-          comment_text = comments.map(&:text).join("\n") << "\n"
-
-          corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?
-        end
-
-        def chainable_condition(node)
-          wrapped_condition = add_parentheses_if_needed(node.condition)
-
-          return wrapped_condition if node.if?
-
-          node.condition.and_type? ? "!(#{wrapped_condition})" : "!#{wrapped_condition}"
-        end
-
-        def add_parentheses_if_needed(condition)
-          # Handle `send` and `block` nodes that need to be wrapped in parens
-          # FIXME: autocorrection prevents syntax errors by wrapping the entire node in parens,
-          #        but wrapping the argument list would be a more ergonomic correction.
-          node_to_check = condition&.any_block_type? ? condition.send_node : condition
-          return condition.source unless add_parentheses?(node_to_check)
-
-          if parenthesize_method?(condition)
-            parenthesized_method_arguments(condition)
-          elsif condition.and_type?
-            parenthesized_and(condition)
-          else
-            "(#{condition.source})"
-          end
-        end
-
-        def parenthesize_method?(node)
-          node.call_type? && node.arguments.any? && !node.parenthesized? &&
-            !node.comparison_method? && !node.operator_method?
-        end
-
-        def add_parentheses?(node)
-          return true if node.assignment? || node.or_type?
-          return true if assignment_in_and?(node)
-          return false unless node.call_type?
-
-          (node.arguments.any? && !node.parenthesized?) || node.prefix_not?
-        end
-
-        def assignment_in_and?(node)
-          return false unless node.and_type?
-
-          node.each_descendant.any?(&:assignment?)
-        end
-
-        def parenthesized_method_arguments(node)
-          method_call = node.source_range.begin.join(node.loc.selector.end).source
-          arguments = node.first_argument.source_range.begin.join(node.source_range.end).source
-
-          "#{method_call}(#{arguments})"
-        end
-
-        def parenthesized_and(node)
-          # We only need to add parentheses around the last clause if it's an assignment,
-          # because other clauses will be unchanged by merging conditionals.
-          lhs = node.lhs.source
-          rhs = parenthesized_and_clause(node.rhs)
-          operator = range_with_surrounding_space(node.loc.operator, whitespace: true).source
-
-          "#{lhs}#{operator}#{rhs}"
-        end
-
-        def parenthesized_and_clause(node)
-          if node.and_type?
-            parenthesized_and(node)
-          elsif node.assignment?
-            "(#{node.source})"
-          else
-            node.source
-          end
-        end
-
-        def allow_modifier?
-          cop_config['AllowModifier']
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.86.1/lib/rubocop/cop/style/struct_inheritance.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for inheritance from `Struct.new`. Inheriting from `Struct.new`
-      # adds a superfluous level in inheritance tree.
-      #
-      # @safety
-      #   Autocorrection is unsafe because it will change the inheritance
-      #   tree (e.g. return value of `Module#ancestors`) of the constant.
-      #
-      # @example
-      #   # bad
-      #   class Person < Struct.new(:first_name, :last_name)
-      #     def age
-      #       42
-      #     end
-      #   end
-      #
-      #   Person.ancestors
-      #   # => [Person, #<Class:0x000000010b4e14a0>, Struct, (...)]
-      #
-      #   # good
-      #   Person = Struct.new(:first_name, :last_name) do
-      #     def age
-      #       42
-      #     end
-      #   end
-      #
-      #   Person.ancestors
-      #   # => [Person, Struct, (...)]
-      class StructInheritance < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = "Don't extend an instance initialized by `Struct.new`. " \
-              'Use a block to customize the struct.'
-
-        def on_class(node)
-          return unless struct_constructor?(node.parent_class)
-
-          add_offense(node.parent_class) do |corrector|
-            corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
-            corrector.replace(node.loc.operator, '=')
-
-            correct_parent(node.parent_class, corrector)
-          end
-        end
-
-        # @!method struct_constructor?(node)
-        def_node_matcher :struct_constructor?, <<~PATTERN
-          {(send (const {nil? cbase} :Struct) :new ...)
-           (block (send (const {nil? cbase} :Struct) :new ...) ...)}
-        PATTERN
-
-        private
-
-        def correct_parent(parent, corrector)
-          if parent.block_type?
-            corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))
-          elsif (class_node = parent.parent).body.nil?
-            corrector.remove(range_for_empty_class_body(class_node, parent))
-          else
-            corrector.insert_after(parent, ' do')
-          end
-        end
-
-        def range_for_empty_class_body(class_node, struct_new)
-          if class_node.single_line?
-            range_between(struct_new.source_range.end_pos, class_node.source_range.end_pos)
-          else
-            range_by_whole_lines(class_node.loc.end, include_final_newline: true)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.86.1/lib/rubocop/cop/style/symbol_proc.rb

@@ -1,283 +0,0 @@
-# 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?(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.any?
-        end
-
-        def allow_comments?(node)
-          cop_config.fetch('AllowComments', false) && contains_comments?(node) &&
-            !comments_contain_disables?(node, name)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.86.1/lib/rubocop/cop/style/top_level_method_definition.rb

@@ -1,86 +0,0 @@
-# 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