alloy_sdk 0.1.0

data/vendor/bundle/ruby/3.0.0/gems/rspec-support-3.11.0/lib/rspec/support/object_formatter.rb

@@ -0,0 +1,275 @@
+RSpec::Support.require_rspec_support 'matcher_definition'
+
+module RSpec
+  module Support
+    # Provide additional output details beyond what `inspect` provides when
+    # printing Time, DateTime, or BigDecimal
+    # @api private
+    class ObjectFormatter # rubocop:disable Metrics/ClassLength
+      ELLIPSIS = "..."
+
+      attr_accessor :max_formatted_output_length
+
+      # Methods are deferred to a default instance of the class to maintain the interface
+      # For example, calling ObjectFormatter.format is still possible
+      def self.default_instance
+        @default_instance ||= new
+      end
+
+      def self.format(object)
+        default_instance.format(object)
+      end
+
+      def self.prepare_for_inspection(object)
+        default_instance.prepare_for_inspection(object)
+      end
+
+      def initialize(max_formatted_output_length=200)
+        @max_formatted_output_length = max_formatted_output_length
+        @current_structure_stack = []
+      end
+
+      def format(object)
+        if max_formatted_output_length.nil?
+          prepare_for_inspection(object).inspect
+        else
+          formatted_object = prepare_for_inspection(object).inspect
+          if formatted_object.length < max_formatted_output_length
+            formatted_object
+          else
+            beginning = truncate_string formatted_object, 0, max_formatted_output_length / 2
+            ending = truncate_string formatted_object, -max_formatted_output_length / 2, -1
+            beginning + ELLIPSIS + ending
+          end
+        end
+      end
+
+      # Prepares the provided object to be formatted by wrapping it as needed
+      # in something that, when `inspect` is called on it, will produce the
+      # desired output.
+      #
+      # This allows us to apply the desired formatting to hash/array data structures
+      # at any level of nesting, simply by walking that structure and replacing items
+      # with custom items that have `inspect` defined to return the desired output
+      # for that item. Then we can just use `Array#inspect` or `Hash#inspect` to
+      # format the entire thing.
+      def prepare_for_inspection(object)
+        case object
+        when Array
+          prepare_array(object)
+        when Hash
+          prepare_hash(object)
+        else
+          inspector_class = INSPECTOR_CLASSES.find { |inspector| inspector.can_inspect?(object) }
+          inspector_class.new(object, self)
+        end
+      end
+
+      def prepare_array(array)
+        with_entering_structure(array) do
+          array.map { |element| prepare_element(element) }
+        end
+      end
+
+      def prepare_hash(input_hash)
+        with_entering_structure(input_hash) do
+          sort_hash_keys(input_hash).inject({}) do |output_hash, key_and_value|
+            key, value = key_and_value.map { |element| prepare_element(element) }
+            output_hash[key] = value
+            output_hash
+          end
+        end
+      end
+
+      def sort_hash_keys(input_hash)
+        if input_hash.keys.all? { |k| k.is_a?(String) || k.is_a?(Symbol) }
+          Hash[input_hash.sort_by { |k, _v| k.to_s }]
+        else
+          input_hash
+        end
+      end
+
+      def prepare_element(element)
+        if recursive_structure?(element)
+          case element
+          when Array then InspectableItem.new('[...]')
+          when Hash then InspectableItem.new('{...}')
+          else raise # This won't happen
+          end
+        else
+          prepare_for_inspection(element)
+        end
+      end
+
+      def with_entering_structure(structure)
+        @current_structure_stack.push(structure)
+        return_value = yield
+        @current_structure_stack.pop
+        return_value
+      end
+
+      def recursive_structure?(object)
+        @current_structure_stack.any? { |seen_structure| seen_structure.equal?(object) }
+      end
+
+      InspectableItem = Struct.new(:text) do
+        def inspect
+          text
+        end
+
+        def pretty_print(pp)
+          pp.text(text)
+        end
+      end
+
+      BaseInspector = Struct.new(:object, :formatter) do
+        def self.can_inspect?(_object)
+          raise NotImplementedError
+        end
+
+        def inspect
+          raise NotImplementedError
+        end
+
+        def pretty_print(pp)
+          pp.text(inspect)
+        end
+      end
+
+      class TimeInspector < BaseInspector
+        FORMAT = "%Y-%m-%d %H:%M:%S"
+
+        def self.can_inspect?(object)
+          Time === object
+        end
+
+        if Time.method_defined?(:nsec)
+          def inspect
+            object.strftime("#{FORMAT}.#{"%09d" % object.nsec} %z")
+          end
+        else # for 1.8.7
+          def inspect
+            object.strftime("#{FORMAT}.#{"%06d" % object.usec} %z")
+          end
+        end
+      end
+
+      class DateTimeInspector < BaseInspector
+        FORMAT = "%a, %d %b %Y %H:%M:%S.%N %z"
+
+        def self.can_inspect?(object)
+          defined?(DateTime) && DateTime === object
+        end
+
+        # ActiveSupport sometimes overrides inspect. If `ActiveSupport` is
+        # defined use a custom format string that includes more time precision.
+        def inspect
+          if defined?(ActiveSupport)
+            object.strftime(FORMAT)
+          else
+            object.inspect
+          end
+        end
+      end
+
+      class BigDecimalInspector < BaseInspector
+        def self.can_inspect?(object)
+          defined?(BigDecimal) && BigDecimal === object
+        end
+
+        def inspect
+          "#{object.to_s('F')} (#{object.inspect})"
+        end
+      end
+
+      class DescribableMatcherInspector < BaseInspector
+        def self.can_inspect?(object)
+          Support.is_a_matcher?(object) && object.respond_to?(:description)
+        end
+
+        def inspect
+          object.description
+        end
+      end
+
+      class UninspectableObjectInspector < BaseInspector
+        OBJECT_ID_FORMAT = '%#016x'
+
+        def self.can_inspect?(object)
+          object.inspect
+          false
+        rescue NoMethodError
+          true
+        end
+
+        def inspect
+          "#<#{klass}:#{native_object_id}>"
+        end
+
+        def klass
+          Support.class_of(object)
+        end
+
+        # http://stackoverflow.com/a/2818916
+        def native_object_id
+          OBJECT_ID_FORMAT % (object.__id__ << 1)
+        rescue NoMethodError
+          # In Ruby 1.9.2, BasicObject responds to none of #__id__, #object_id, #id...
+          '-'
+        end
+      end
+
+      class DelegatorInspector < BaseInspector
+        def self.can_inspect?(object)
+          defined?(Delegator) && Delegator === object
+        end
+
+        def inspect
+          "#<#{object.class}(#{formatter.format(object.send(:__getobj__))})>"
+        end
+      end
+
+      class InspectableObjectInspector < BaseInspector
+        def self.can_inspect?(object)
+          object.inspect
+          true
+        rescue NoMethodError
+          false
+        end
+
+        def inspect
+          object.inspect
+        end
+      end
+
+      INSPECTOR_CLASSES = [
+        TimeInspector,
+        DateTimeInspector,
+        BigDecimalInspector,
+        UninspectableObjectInspector,
+        DescribableMatcherInspector,
+        DelegatorInspector,
+        InspectableObjectInspector
+      ].tap do |classes|
+        # 2.4 has improved BigDecimal formatting so we do not need
+        # to provide our own.
+        # https://github.com/ruby/bigdecimal/pull/42
+        classes.delete(BigDecimalInspector) if RUBY_VERSION >= '2.4'
+      end
+
+    private
+
+      # Returns the substring defined by the start_index and end_index
+      # If the string ends with a partial ANSI code code then that
+      # will be removed as printing partial ANSI
+      # codes to the terminal can lead to corruption
+      def truncate_string(str, start_index, end_index)
+        cut_str = str[start_index..end_index]
+
+        # ANSI color codes are like: \e[33m so anything with \e[ and a
+        # number without a 'm' is an incomplete color code
+        cut_str.sub(/\e\[\d+$/, '')
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/rspec-support-3.11.0/lib/rspec/support/recursive_const_methods.rb

@@ -0,0 +1,76 @@
+module RSpec
+  module Support
+    # Provides recursive constant lookup methods useful for
+    # constant stubbing.
+    module RecursiveConstMethods
+      # We only want to consider constants that are defined directly on a
+      # particular module, and not include top-level/inherited constants.
+      # Unfortunately, the constant API changed between 1.8 and 1.9, so
+      # we need to conditionally define methods to ignore the top-level/inherited
+      # constants.
+      #
+      # Given:
+      #   class A; B = 1; end
+      #   class C < A; end
+      #
+      # On 1.8:
+      #   - C.const_get("Hash") # => ::Hash
+      #   - C.const_defined?("Hash") # => false
+      #   - C.constants # => ["B"]
+      #   - None of these methods accept the extra `inherit` argument
+      # On 1.9:
+      #   - C.const_get("Hash") # => ::Hash
+      #   - C.const_defined?("Hash") # => true
+      #   - C.const_get("Hash", false) # => raises NameError
+      #   - C.const_defined?("Hash", false) # => false
+      #   - C.constants # => [:B]
+      #   - C.constants(false) #=> []
+      if Module.method(:const_defined?).arity == 1
+        def const_defined_on?(mod, const_name)
+          mod.const_defined?(const_name)
+        end
+
+        def get_const_defined_on(mod, const_name)
+          return mod.const_get(const_name) if const_defined_on?(mod, const_name)
+
+          raise NameError, "uninitialized constant #{mod.name}::#{const_name}"
+        end
+
+        def constants_defined_on(mod)
+          mod.constants.select { |c| const_defined_on?(mod, c) }
+        end
+      else
+        def const_defined_on?(mod, const_name)
+          mod.const_defined?(const_name, false)
+        end
+
+        def get_const_defined_on(mod, const_name)
+          mod.const_get(const_name, false)
+        end
+
+        def constants_defined_on(mod)
+          mod.constants(false)
+        end
+      end
+
+      def recursive_const_get(const_name)
+        normalize_const_name(const_name).split('::').inject(Object) do |mod, name|
+          get_const_defined_on(mod, name)
+        end
+      end
+
+      def recursive_const_defined?(const_name)
+        parts = normalize_const_name(const_name).split('::')
+        parts.inject([Object, '']) do |(mod, full_name), name|
+          yield(full_name, name) if block_given? && !(Module === mod)
+          return false unless const_defined_on?(mod, name)
+          [get_const_defined_on(mod, name), [mod.name, name].join('::')]
+        end
+      end
+
+      def normalize_const_name(const_name)
+        const_name.sub(/\A::/, '')
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/rspec-support-3.11.0/lib/rspec/support/reentrant_mutex.rb

@@ -0,0 +1,78 @@
+module RSpec
+  module Support
+    # Allows a thread to lock out other threads from a critical section of code,
+    # while allowing the thread with the lock to reenter that section.
+    #
+    # Based on Monitor as of 2.2 -
+    # https://github.com/ruby/ruby/blob/eb7ddaa3a47bf48045d26c72eb0f263a53524ebc/lib/monitor.rb#L9
+    #
+    # Depends on Mutex, but Mutex is only available as part of core since 1.9.1:
+    #   exists - http://ruby-doc.org/core-1.9.1/Mutex.html
+    #   dne    - http://ruby-doc.org/core-1.9.0/Mutex.html
+    #
+    # @private
+    class ReentrantMutex
+      def initialize
+        @owner = nil
+        @count = 0
+        @mutex = Mutex.new
+      end
+
+      def synchronize
+        enter
+        yield
+      ensure
+        exit
+      end
+
+    private
+
+      # This is fixing a bug #501 that is specific to Ruby 3.0. The new implementation
+      # depends on `owned?` that was introduced in Ruby 2.0, so both should work for Ruby 2.x.
+      if RUBY_VERSION.to_f >= 3.0
+        def enter
+          @mutex.lock unless @mutex.owned?
+          @count += 1
+        end
+
+        def exit
+          unless @mutex.owned?
+            raise ThreadError, "Attempt to unlock a mutex which is locked by another thread/fiber"
+          end
+          @count -= 1
+          @mutex.unlock if @count == 0
+        end
+      else
+        def enter
+          @mutex.lock if @owner != Thread.current
+          @owner = Thread.current
+          @count += 1
+        end
+
+        def exit
+          @count -= 1
+          return unless @count == 0
+          @owner = nil
+          @mutex.unlock
+        end
+      end
+    end
+
+    if defined? ::Mutex
+      # On 1.9 and up, this is in core, so we just use the real one
+      class Mutex < ::Mutex
+        # If you mock Mutex.new you break our usage of Mutex, so
+        # instead we capture the original method to return Mutexs.
+        NEW_MUTEX_METHOD = Mutex.method(:new)
+
+        def self.new
+          NEW_MUTEX_METHOD.call
+        end
+      end
+    else # For 1.8.7
+      # :nocov:
+      RSpec::Support.require_rspec_support "mutex"
+      # :nocov:
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/rspec-support-3.11.0/lib/rspec/support/ruby_features.rb

@@ -0,0 +1,191 @@
+require 'rbconfig'
+RSpec::Support.require_rspec_support "comparable_version"
+
+module RSpec
+  module Support
+    # @api private
+    #
+    # Provides query methods for different OS or OS features.
+    module OS
+    module_function
+
+      def windows?
+        !!(RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/)
+      end
+
+      def windows_file_path?
+        ::File::ALT_SEPARATOR == '\\'
+      end
+    end
+
+    # @api private
+    #
+    # Provides query methods for different rubies
+    module Ruby
+    module_function
+
+      def jruby?
+        RUBY_PLATFORM == 'java'
+      end
+
+      def jruby_version
+        @jruby_version ||= ComparableVersion.new(JRUBY_VERSION)
+      end
+
+      def jruby_9000?
+        jruby? && JRUBY_VERSION >= '9.0.0.0'
+      end
+
+      def rbx?
+        defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+      end
+
+      def non_mri?
+        !mri?
+      end
+
+      def mri?
+        !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+      end
+
+      def truffleruby?
+        defined?(RUBY_ENGINE) && RUBY_ENGINE == 'truffleruby'
+      end
+    end
+
+    # @api private
+    #
+    # Provides query methods for ruby features that differ among
+    # implementations.
+    module RubyFeatures
+    module_function
+
+      if Ruby.jruby? && RUBY_VERSION.to_f < 1.9
+        # On JRuby 1.7 `--1.8` mode, `Process.respond_to?(:fork)` returns true,
+        # but when you try to fork, it raises an error:
+        #   NotImplementedError: fork is not available on this platform
+        #
+        # When we drop support for JRuby 1.7 and/or Ruby 1.8, we can drop
+        # this special case.
+        def fork_supported?
+          false
+        end
+      else
+        def fork_supported?
+          Process.respond_to?(:fork)
+        end
+      end
+
+      def optional_and_splat_args_supported?
+        Method.method_defined?(:parameters)
+      end
+
+      def caller_locations_supported?
+        respond_to?(:caller_locations, true)
+      end
+
+      if Exception.method_defined?(:cause)
+        def supports_exception_cause?
+          true
+        end
+      else
+        def supports_exception_cause?
+          false
+        end
+      end
+
+      if RUBY_VERSION.to_f >= 2.7
+        def supports_taint?
+          false
+        end
+      else
+        def supports_taint?
+          true
+        end
+      end
+      ripper_requirements = [ComparableVersion.new(RUBY_VERSION) >= '1.9.2']
+
+      ripper_requirements.push(false) if Ruby.rbx?
+
+      if Ruby.jruby?
+        ripper_requirements.push(Ruby.jruby_version >= '1.7.5')
+        # Ripper on JRuby 9.0.0.0.rc1 - 9.1.8.0 reports wrong line number
+        # or cannot parse source including `:if`.
+        # Ripper on JRuby 9.x.x.x < 9.1.17.0 can't handle keyword arguments
+        # Neither can JRuby 9.2, e.g. < 9.2.1.0
+        ripper_requirements.push(!Ruby.jruby_version.between?('9.0.0.0.rc1', '9.2.0.0'))
+      end
+
+      if ripper_requirements.all?
+        def ripper_supported?
+          true
+        end
+      else
+        def ripper_supported?
+          false
+        end
+      end
+
+      if Ruby.mri?
+        def kw_args_supported?
+          RUBY_VERSION >= '2.0.0'
+        end
+
+        def required_kw_args_supported?
+          RUBY_VERSION >= '2.1.0'
+        end
+
+        def supports_rebinding_module_methods?
+          RUBY_VERSION.to_i >= 2
+        end
+      else
+        # RBX / JRuby et al support is unknown for keyword arguments
+        begin
+          eval("o = Object.new; def o.m(a: 1); end;"\
+               " raise SyntaxError unless o.method(:m).parameters.include?([:key, :a])")
+
+          def kw_args_supported?
+            true
+          end
+        rescue SyntaxError
+          def kw_args_supported?
+            false
+          end
+        end
+
+        begin
+          eval("o = Object.new; def o.m(a: ); end;"\
+               "raise SyntaxError unless o.method(:m).parameters.include?([:keyreq, :a])")
+
+          def required_kw_args_supported?
+            true
+          end
+        rescue SyntaxError
+          def required_kw_args_supported?
+            false
+          end
+        end
+
+        begin
+          Module.new { def foo; end }.instance_method(:foo).bind(Object.new)
+
+          def supports_rebinding_module_methods?
+            true
+          end
+        rescue TypeError
+          def supports_rebinding_module_methods?
+            false
+          end
+        end
+      end
+
+      def module_refinement_supported?
+        Module.method_defined?(:refine) || Module.private_method_defined?(:refine)
+      end
+
+      def module_prepends_supported?
+        Module.method_defined?(:prepend) || Module.private_method_defined?(:prepend)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/rspec-support-3.11.0/lib/rspec/support/source/location.rb

@@ -0,0 +1,21 @@
+module RSpec
+  module Support
+    class Source
+      # @private
+      # Represents a source location of node or token.
+      Location = Struct.new(:line, :column) do
+        include Comparable
+
+        def self.location?(array)
+          array.is_a?(Array) && array.size == 2 && array.all? { |e| e.is_a?(Integer) }
+        end
+
+        def <=>(other)
+          line_comparison = (line <=> other.line)
+          return line_comparison unless line_comparison == 0
+          column <=> other.column
+        end
+      end
+    end
+  end
+end