siteimprove_api_client 1.0.4 → 1.0.5

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/registry.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Error raised when an unqualified cop name is used that could
+    # refer to two or more cops under different departments
+    class AmbiguousCopName < RuboCop::Error
+      MSG = 'Ambiguous cop name `%<name>s` used in %<origin>s needs ' \
+            'department qualifier. Did you mean %<options>s?'
+
+      def initialize(name, origin, badges)
+        super(
+          format(MSG, name: name, origin: origin, options: badges.to_a.join(' or '))
+        )
+      end
+    end
+
+    # Registry that tracks all cops by their badge and department.
+    class Registry # rubocop:disable Metrics/ClassLength
+      include Enumerable
+
+      def self.all
+        global.without_department(:Test).cops
+      end
+
+      def self.qualified_cop_name(name, origin, warn: true)
+        global.qualified_cop_name(name, origin, warn: warn)
+      end
+
+      # Changes momentarily the global registry
+      # Intended for testing purposes
+      def self.with_temporary_global(temp_global = global.dup)
+        previous = @global
+        @global = temp_global
+        yield
+      ensure
+        @global = previous
+      end
+
+      def self.reset!
+        @global = new
+      end
+
+      def self.qualified_cop?(name)
+        badge = Badge.parse(name)
+        global.qualify_badge(badge).first == badge
+      end
+
+      attr_reader :options, :warnings
+
+      def initialize(cops = [], options = {})
+        @departments = Set.new
+        @cops_by_badge = {}
+        @lazy_loaded_cops_by_badge = {}
+
+        @enrollment_queue = cops
+        @options = options
+
+        @enabled_cache = {}.compare_by_identity
+        @disabled_cache = {}.compare_by_identity
+        @warnings = {}
+      end
+
+      def lazy_load(cop_name, constant_name)
+        badge = Badge.parse(cop_name)
+        @departments << badge.department
+        @lazy_loaded_cops_by_badge[badge] = constant_name
+      end
+
+      def enlist(cop)
+        @enrollment_queue << cop
+      end
+
+      def dismiss(cop)
+        raise "Cop #{cop} could not be dismissed" unless @enrollment_queue.delete(cop)
+      end
+
+      # @return [Array<Symbol>] list of departments for current cops.
+      def departments
+        clear_enrollment_queue
+        @departments.to_a
+      end
+
+      # @return [Registry] Cops for that specific department.
+      def with_department(department)
+        with(cops.select { |cop| cop.department == department })
+      end
+
+      # @return [Registry] Cops not for a specific department.
+      def without_department(department)
+        with(cops.reject { |cop| cop.department == department })
+      end
+
+      # @return [Boolean] Checks if given name is department
+      def department?(name)
+        departments.include?(name.to_sym)
+      end
+
+      def contains_cop_matching?(names)
+        cops.any? { |cop| cop.match?(names) }
+      end
+
+      # Convert a user provided cop name into a properly namespaced name
+      #
+      # @example gives back a correctly qualified cop name
+      #
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('Layout/EndOfLine', '') # => 'Layout/EndOfLine'
+      #
+      # @example fixes incorrect namespaces
+      #
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('Lint/EndOfLine', '') # => 'Layout/EndOfLine'
+      #
+      # @example namespaces bare cop identifiers
+      #
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('EndOfLine', '') # => 'Layout/EndOfLine'
+      #
+      # @example passes back unrecognized cop names
+      #
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('NotACop', '') # => 'NotACop'
+      #
+      # @param name [String] Cop name extracted from config
+      # @param path [String, nil] Path of file that `name` was extracted from
+      # @param warn [Boolean] Print a warning if no department given for `name`
+      #
+      # @raise [AmbiguousCopName]
+      #   if a bare identifier with two possible namespaces is provided
+      #
+      # @note Emits a warning if the provided name has an incorrect namespace
+      #
+      # @return [String] Qualified cop name
+      def qualified_cop_name(name, path, warn: true)
+        badge = Badge.parse(name)
+        print_department_missing_warning(name, path) if warn && department_missing?(badge, name)
+        return name if registered?(badge)
+
+        potential_badges = qualify_badge(badge)
+
+        case potential_badges.size
+        when 0 then name # No namespace found. Deal with it later in caller.
+        when 1 then resolve_badge(badge, potential_badges.first, path, warn: warn)
+        else raise AmbiguousCopName.new(badge, path, potential_badges)
+        end
+      end
+
+      def department_missing?(badge, name)
+        !badge.qualified? && unqualified_cop_names.include?(name)
+      end
+
+      def print_department_missing_warning(name, path)
+        message = "no department given for #{name}."
+        if path.end_with?('.rb')
+          message += ' Run `rubocop -a --only Migration/DepartmentName` to fix.'
+        end
+        emit_warning(path, message)
+      end
+
+      def unqualified_cop_names
+        clear_enrollment_queue
+        @unqualified_cop_names ||=
+          (@cops_by_badge.keys | @lazy_loaded_cops_by_badge.keys)
+          .to_set { |badge| File.basename(badge.to_s) } << 'RedundantCopDisableDirective'
+      end
+
+      def qualify_badge(badge)
+        clear_enrollment_queue
+        @departments
+          .map { |department| badge.with_department(department) }
+          .select { |potential_badge| registered?(potential_badge) }
+      end
+
+      # @return [Hash{String => Array<Class>}]
+      def to_h
+        clear_enrollment_queue
+        load_all_lazy_cops
+        @cops_by_badge.to_h { |_badge, cop| [cop.cop_name, [cop]] }
+      end
+
+      def cops
+        clear_enrollment_queue
+        load_all_lazy_cops
+        @cops_by_badge.values
+      end
+
+      def length
+        clear_enrollment_queue
+        @cops_by_badge.size + @lazy_loaded_cops_by_badge.size
+      end
+
+      def enabled(config)
+        @enabled_cache[config] ||= select { |cop| enabled?(cop, config) }
+      end
+
+      def disabled(config)
+        @disabled_cache[config] ||= reject { |cop| enabled?(cop, config) }
+      end
+
+      def enabled?(cop, config)
+        return true if options[:only]&.include?(cop.cop_name)
+
+        # We need to use `cop_name` in this case, because `for_cop` uses caching
+        # which expects cop names or cop classes as keys.
+        cfg = config.for_cop(cop.cop_name)
+
+        cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config)
+
+        if options.fetch(:safe, false)
+          cop_enabled && cfg.fetch('Safe', true)
+        else
+          cop_enabled
+        end
+      end
+
+      def enabled_pending_cop?(cop_cfg, config)
+        return false if @options[:disable_pending_cops]
+
+        cop_cfg.fetch('Enabled') == 'pending' &&
+          (@options[:enable_pending_cops] || config.enabled_new_cops?)
+      end
+
+      def names
+        clear_enrollment_queue
+        @cops_by_badge.keys.map(&:to_s) | @lazy_loaded_cops_by_badge.keys.map(&:to_s)
+      end
+
+      def cops_for_department(department)
+        cops.select { |cop| cop.department == department.to_sym }
+      end
+
+      def names_for_department(department)
+        cops_for_department(department).map(&:cop_name)
+      end
+
+      def ==(other)
+        cops == other.cops
+      end
+
+      def sort!
+        clear_enrollment_queue
+        load_all_lazy_cops
+        @cops_by_badge = @cops_by_badge.sort_by { |badge, _cop| badge.cop_name }.to_h
+
+        self
+      end
+
+      def select(&block)
+        cops.select(&block)
+      end
+
+      def each(&block)
+        cops.each(&block)
+      end
+
+      # @param [String] cop_name
+      # @return [Class, nil]
+      def find_by_cop_name(cop_name)
+        clear_enrollment_queue
+        badge = Badge.parse(cop_name)
+        @cops_by_badge[badge] || load_lazy_cop(badge)
+      end
+
+      # When a cop name is given returns a single-element array with the cop class.
+      # When a department name is given returns an array with all the cop classes
+      # for that department.
+      def find_cops_by_directive(directive)
+        cop = find_by_cop_name(directive)
+        cop ? [cop] : cops_for_department(directive)
+      end
+
+      def freeze
+        clear_enrollment_queue
+        load_all_lazy_cops
+        unqualified_cop_names # build cache
+        super
+      end
+
+      @global = new
+
+      class << self
+        attr_reader :global
+      end
+
+      def warnings?(path)
+        @warnings[path]
+      end
+
+      private
+
+      def initialize_copy(reg)
+        initialize(reg.cops, reg.options)
+      end
+
+      def clear_enrollment_queue
+        return if @enrollment_queue.empty?
+
+        @enrollment_queue.each do |cop|
+          @cops_by_badge[cop.badge] = cop
+          @departments << cop.department
+        end
+        @enrollment_queue = []
+      end
+
+      def load_all_lazy_cops
+        @lazy_loaded_cops_by_badge.each_key { |badge| load_lazy_cop(badge) }
+      end
+
+      def load_lazy_cop(badge)
+        constant_name = @lazy_loaded_cops_by_badge.delete(badge)
+        return unless constant_name
+
+        @cops_by_badge[badge] = Kernel.const_get(constant_name)
+      end
+
+      def with(cops)
+        self.class.new(cops)
+      end
+
+      def resolve_badge(given_badge, real_badge, source_path, warn: true)
+        if warn && !given_badge.match?(real_badge)
+          emit_warning(source_path,
+                       "#{given_badge} has the wrong namespace - " \
+                       "replace it with #{given_badge.with_department(real_badge.department)}")
+        end
+
+        real_badge.to_s
+      end
+
+      def emit_warning(path, message)
+        Registry.global.warnings[path] = true
+        warn "#{PathUtil.smart_path(path)}: Warning: #{message}"
+      end
+
+      def registered?(badge)
+        clear_enrollment_queue
+        @cops_by_badge.key?(badge) || @lazy_loaded_cops_by_badge.key?(badge)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/security/io_methods.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # Checks for the first argument to `IO.read`, `IO.binread`, `IO.write`, `IO.binwrite`,
+      # `IO.foreach`, and `IO.readlines`.
+      #
+      # If argument starts with a pipe character (`'|'`) and the receiver is the `IO` class,
+      # a subprocess is created in the same way as `Kernel#open`, and its output is returned.
+      # `Kernel#open` may allow unintentional command injection, which is the reason these
+      # `IO` methods are a security risk.
+      # Consider using `File.read` to disable the behavior of subprocess invocation.
+      #
+      # @safety
+      #   This cop is unsafe because false positive will occur if the variable passed as
+      #   the first argument is a command that is not a file path.
+      #
+      # @example
+      #
+      #   # bad
+      #   IO.read(path)
+      #   IO.read('path')
+      #
+      #   # good
+      #   File.read(path)
+      #   File.read('path')
+      #   IO.read('| command') # Allow intentional command invocation.
+      #
+      class IoMethods < Base
+        extend AutoCorrector
+
+        MSG = '`File.%<method_name>s` is safer than `IO.%<method_name>s`.'
+        RESTRICT_ON_SEND = %i[read binread write binwrite foreach readlines].freeze
+
+        def on_send(node)
+          return unless (receiver = node.receiver) && receiver.source == 'IO'
+
+          argument = node.first_argument
+          return if argument.respond_to?(:value) && argument.value.strip.start_with?('|')
+
+          add_offense(node, message: format(MSG, method_name: node.method_name)) do |corrector|
+            corrector.replace(receiver, 'File')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of either `#alias` or `#alias_method`
+      # depending on configuration. Consistent use of one or the
+      # other prevents confusion about their different semantics
+      # (e.g., `alias` is resolved at parse time, while `alias_method`
+      # is resolved at runtime).
+      # It also flags uses of `alias :symbol` rather than `alias bareword`.
+      #
+      # However, it will always enforce `alias_method` when `alias` is used
+      # 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)
+          return unless node.arguments.count == 2
+          return if alias_method_value_used?(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
+
+        # `alias_method` is a method call whose return value can be used
+        # (e.g., as an argument to `public`/`module_function`, or as an assignment),
+        # but `alias` is a keyword statement that cannot appear in such positions.
+        # Detect these positions so the conversion does not produce a syntax error.
+        def alias_method_value_used?(node)
+          node.argument? || node.parent&.assignment?
+        end
+
+        def alias_method_possible?(node)
+          scope_type(node) != :instance_eval &&
+            node.children.none?(&:gvar_type?) &&
+            node.each_ancestor(:def).none?
+        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?(':') || sym_node.dsym_type?
+        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
+
+        def identifier(node)
+          if node.sym_type?
+            ":#{node.children.first}"
+          else
+            node.source
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.87.0/lib/rubocop/cop/style/character_literal.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of the character literal ?x.
+      # Starting with Ruby 1.9 character literals are
+      # essentially one-character strings, so this syntax
+      # is mostly redundant at this point.
+      #
+      # A `?` character literal can be used to express meta and control characters.
+      # That's a good use case of a `?` literal so it doesn't count as an offense.
+      #
+      # @example
+      #   # bad
+      #   ?x
+      #
+      #   # good
+      #   'x'
+      #
+      #   # good - control & meta escapes
+      #   ?\C-\M-d
+      #   "\C-\M-d" # same as above
+      class CharacterLiteral < Base
+        include StringHelp
+        extend AutoCorrector
+
+        MSG = 'Do not use the character literal - use string literal instead.'
+
+        def offense?(node)
+          # we don't register an offense for things like ?\C-\M-d
+          node.character_literal? && node.source.size.between?(2, 3)
+        end
+
+        def autocorrect(corrector, node)
+          string = node.source[1..]
+
+          # special character like \n
+          # or ' which needs to use "" or be escaped.
+          if string.length == 2 || string == "'"
+            corrector.replace(node, %("#{string}"))
+          elsif string.length == 1 # normal character
+            corrector.replace(node, "'#{string}'")
+          end
+        end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def opposite_style_detected; end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def correct_style_detected; end
+      end
+    end
+  end
+end