siteimprove_api_client 1.0.1 → 1.0.2

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.73.1/lib/rubocop/cop/style/single_line_do_end_block.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for single-line `do`...`end` block.
-      #
-      # In practice a single line `do`...`end` is autocorrected when `EnforcedStyle: semantic`
-      # is configured for `Style/BlockDelimiters`. The autocorrection maintains the
-      # `do` ... `end` syntax to preserve semantics and does not change it to `{`...`}` block.
-      #
-      # NOTE: If `InspectBlocks` is set to `true` for `Layout/RedundantLineBreak`, blocks will
-      # be autocorrected to be on a single line if possible. This cop respects that configuration
-      # by not registering an offense if it would subsequently cause a
-      # `Layout/RedundantLineBreak` offense.
-      #
-      # @example
-      #
-      #   # bad
-      #   foo do |arg| bar(arg) end
-      #
-      #   # good
-      #   foo do |arg|
-      #     bar(arg)
-      #   end
-      #
-      #   # bad
-      #   ->(arg) do bar(arg) end
-      #
-      #   # good
-      #   ->(arg) { bar(arg) }
-      #
-      class SingleLineDoEndBlock < Base
-        extend AutoCorrector
-        include CheckSingleLineSuitability
-
-        MSG = 'Prefer multiline `do`...`end` block.'
-
-        # rubocop:disable Metrics/AbcSize
-        def on_block(node)
-          return if !node.single_line? || node.braces?
-          return if single_line_blocks_preferred? && suitable_as_single_line?(node)
-
-          add_offense(node) do |corrector|
-            corrector.insert_after(do_line(node), "\n")
-
-            node_body = node.body
-
-            if node_body.respond_to?(:heredoc?) && node_body.heredoc?
-              corrector.remove(node.loc.end)
-              corrector.insert_after(node_body.loc.heredoc_end, "\nend")
-            else
-              corrector.insert_before(node.loc.end, "\n")
-            end
-          end
-        end
-        # rubocop:enable Metrics/AbcSize
-        alias on_numblock on_block
-
-        private
-
-        def do_line(node)
-          if node.numblock_type? || node.arguments.children.empty? || node.send_node.lambda_literal?
-            node.loc.begin
-          else
-            node.arguments
-          end
-        end
-
-        def single_line_blocks_preferred?
-          @config.for_enabled_cop('Layout/RedundantLineBreak')['InspectBlocks']
-        end
-      end
-    end
-  end
-end

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

@@ -1,270 +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.condition.or_type? || node.condition.assignment?
-            corrector.wrap(node.condition, '(', ')')
-          end
-
-          if outer_condition_modify_form?(node, if_branch)
-            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_from_unless_to_if(corrector, node) if node.unless?
-
-          outer_condition = node.condition
-          correct_outer_condition(corrector, outer_condition)
-
-          and_operator = if_branch.unless? ? ' && !' : ' && '
-          if if_branch.modifier_form?
-            correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
-          else
-            correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
-            correct_for_comment(corrector, node, if_branch)
-          end
-        end
-
-        def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
-          correct_from_unless_to_if(corrector, if_branch, is_modify_form: true) if if_branch.unless?
-          correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
-        end
-
-        def correct_from_unless_to_if(corrector, node, is_modify_form: false)
-          corrector.replace(node.loc.keyword, 'if')
-
-          insert_bang(corrector, node, is_modify_form)
-        end
-
-        def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
-          condition = if_branch.condition
-          corrector.insert_after(outer_condition, "#{and_operator}#{replace_condition(condition)}")
-
-          range = range_between(if_branch.loc.keyword.begin_pos, condition.source_range.end_pos)
-          corrector.remove(range_with_surrounding_space(range, newlines: false))
-          corrector.remove(if_branch.loc.keyword)
-        end
-
-        def correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
-          range = range_between(
-            node.condition.source_range.end_pos, if_branch.condition.source_range.begin_pos
-          )
-          corrector.replace(range, and_operator)
-          corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
-
-          wrap_condition(corrector, if_branch.condition)
-        end
-
-        def wrap_condition(corrector, 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 unless wrap_condition?(node_to_check)
-
-          if condition.call_type?
-            source = parenthesized_method_arguments(condition)
-
-            corrector.replace(condition, source)
-          else
-            corrector.wrap(condition, '(', ')')
-          end
-        end
-
-        def correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
-          condition = if_branch.condition
-          corrector.insert_before(condition,
-                                  "#{'!' if node.unless?}#{replace_condition(node.condition)} && ")
-
-          corrector.remove(node.condition)
-          corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
-          corrector.replace(if_branch.loc.keyword, 'if')
-        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 correct_outer_condition(corrector, condition)
-          return unless require_parentheses?(condition)
-
-          end_pos = condition.loc.selector.end_pos
-          begin_pos = condition.first_argument.source_range.begin_pos
-          return if end_pos > begin_pos
-
-          range = range_between(end_pos, begin_pos)
-          corrector.remove(range)
-          corrector.insert_after(range, '(')
-          corrector.insert_after(condition.last_argument, ')')
-        end
-
-        def insert_bang(corrector, node, is_modify_form)
-          condition = node.condition
-
-          if (condition.send_type? && condition.comparison_method? && !condition.parenthesized?) ||
-             (is_modify_form && wrap_condition?(condition))
-            corrector.wrap(node.condition, '!(', ')')
-          elsif condition.and_type?
-            insert_bang_for_and(corrector, node)
-          else
-            corrector.insert_before(condition, '!')
-          end
-        end
-
-        def insert_bang_for_and(corrector, node)
-          lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
-
-          if lhs.and_type?
-            insert_bang_for_and(corrector, lhs)
-            corrector.insert_before(rhs, '!') if rhs
-          else
-            corrector.insert_before(lhs, '!')
-            corrector.insert_before(rhs, '!')
-          end
-        end
-
-        def require_parentheses?(condition)
-          condition.call_type? && !condition.arguments.empty? && !condition.parenthesized? &&
-            !condition.comparison_method?
-        end
-
-        def arguments_range(node)
-          range_between(
-            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
-          )
-        end
-
-        def wrap_condition?(node)
-          node.operator_keyword? || (node.call_type? && node.arguments.any? && !node.parenthesized?)
-        end
-
-        def replace_condition(condition)
-          return condition.source unless wrap_condition?(condition)
-
-          if condition.call_type? && !condition.comparison_method?
-            parenthesized_method_arguments(condition)
-          else
-            "(#{condition.source})"
-          end
-        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 allow_modifier?
-          cop_config['AllowModifier']
-        end
-
-        def outer_condition_modify_form?(node, if_branch)
-          node.condition.source_range.begin_pos > if_branch.condition.source_range.begin_pos
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.73.1/lib/rubocop/cop/style/string_concatenation.rb

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for places where string concatenation
-      # can be replaced with string interpolation.
-      #
-      # The cop can autocorrect simple cases but will skip autocorrecting
-      # more complex cases where the resulting code would be harder to read.
-      # In those cases, it might be useful to extract statements to local
-      # variables or methods which you can then interpolate in a string.
-      #
-      # NOTE: When concatenation between two strings is broken over multiple
-      # lines, this cop does not register an offense; instead,
-      # `Style/LineEndConcatenation` will pick up the offense if enabled.
-      #
-      # Two modes are supported:
-      # 1. `aggressive` style checks and corrects all occurrences of `+` where
-      # either the left or right side of `+` is a string literal.
-      # 2. `conservative` style on the other hand, checks and corrects only if
-      # left side (receiver of `+` method call) is a string literal.
-      # This is useful when the receiver is some expression that returns string like `Pathname`
-      # instead of a string literal.
-      #
-      # @safety
-      #   This cop is unsafe in `aggressive` mode, as it cannot be guaranteed that
-      #   the receiver is actually a string, which can result in a false positive.
-      #
-      # @example Mode: aggressive (default)
-      #   # bad
-      #   email_with_name = user.name + ' <' + user.email + '>'
-      #   Pathname.new('/') + 'test'
-      #
-      #   # good
-      #   email_with_name = "#{user.name} <#{user.email}>"
-      #   email_with_name = format('%s <%s>', user.name, user.email)
-      #   "#{Pathname.new('/')}test"
-      #
-      #   # accepted, line-end concatenation
-      #   name = 'First' +
-      #     'Last'
-      #
-      # @example Mode: conservative
-      #   # bad
-      #   'Hello' + user.name
-      #
-      #   # good
-      #   "Hello #{user.name}"
-      #   user.name + '!!'
-      #   Pathname.new('/') + 'test'
-      #
-      class StringConcatenation < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Prefer string interpolation to string concatenation.'
-        RESTRICT_ON_SEND = %i[+].freeze
-
-        # @!method string_concatenation?(node)
-        def_node_matcher :string_concatenation?, <<~PATTERN
-          {
-            (send str_type? :+ _)
-            (send _ :+ str_type?)
-          }
-        PATTERN
-
-        def on_new_investigation
-          @corrected_nodes = nil
-        end
-
-        def on_send(node)
-          return unless string_concatenation?(node)
-          return if line_end_concatenation?(node)
-
-          topmost_plus_node = find_topmost_plus_node(node)
-          parts = collect_parts(topmost_plus_node)
-          return if mode == :conservative && !parts.first.str_type?
-
-          register_offense(topmost_plus_node, parts)
-        end
-
-        private
-
-        def register_offense(topmost_plus_node, parts)
-          add_offense(topmost_plus_node) do |corrector|
-            correctable_parts = parts.none? { |part| uncorrectable?(part) }
-            if correctable_parts && !corrected_ancestor?(topmost_plus_node)
-              corrector.replace(topmost_plus_node, replacement(parts))
-
-              @corrected_nodes ||= Set.new.compare_by_identity
-              @corrected_nodes.add(topmost_plus_node)
-            end
-          end
-        end
-
-        def line_end_concatenation?(node)
-          # If the concatenation happens at the end of the line,
-          # and both the receiver and argument are strings, allow
-          # `Style/LineEndConcatenation` to handle it instead.
-          node.receiver.str_type? &&
-            node.first_argument.str_type? &&
-            node.multiline? &&
-            node.source =~ /\+\s*\n/
-        end
-
-        def find_topmost_plus_node(node)
-          current = node
-          while (parent = current.parent) && plus_node?(parent)
-            current = parent
-          end
-          current
-        end
-
-        def collect_parts(node, parts = [])
-          return unless node
-
-          if plus_node?(node)
-            collect_parts(node.receiver, parts)
-            collect_parts(node.first_argument, parts)
-          else
-            parts << node
-          end
-        end
-
-        def plus_node?(node)
-          node.send_type? && node.method?(:+)
-        end
-
-        def uncorrectable?(part)
-          part.multiline? || heredoc?(part) || part.each_descendant(:any_block).any?
-        end
-
-        def heredoc?(node)
-          return false unless node.type?(:str, :dstr)
-
-          node.heredoc?
-        end
-
-        def corrected_ancestor?(node)
-          node.each_ancestor(:send).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
-        end
-
-        def replacement(parts)
-          interpolated_parts = parts.map do |part|
-            case part.type
-            when :str
-              adjust_str(part)
-            when :dstr
-              part.children.all?(&:str_type?) ? adjust_str(part) : contents_range(part).source
-            else
-              "\#{#{part.source}}"
-            end
-          end
-
-          "\"#{handle_quotes(interpolated_parts).join}\""
-        end
-
-        def adjust_str(node)
-          single_quoted?(node) ? node.value.gsub(/(\\|")/, '\\\\\&') : node.value.inspect[1..-2]
-        end
-
-        def handle_quotes(parts)
-          parts.map do |part|
-            part == '"' ? '\"' : part
-          end
-        end
-
-        def single_quoted?(str_node)
-          str_node.source.start_with?("'")
-        end
-
-        def mode
-          cop_config['Mode'].to_sym
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for inheritance from Struct.new.
-      #
-      # @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
-      #
-      #   # good
-      #   Person = Struct.new(:first_name, :last_name) do
-      #     def age
-      #       42
-      #     end
-      #   end
-      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