siteimprove_api_client 1.0.4 → 1.0.5

data/vendor/bundle/ruby/3.2.0/gems/json-2.19.3/LEGAL

@@ -1,20 +0,0 @@
-# -*- rdoc -*-
-
-= LEGAL NOTICE INFORMATION
---------------------------
-
-All the files in this distribution are covered under either the Ruby's
-license (see the file COPYING) or public-domain except some files
-mentioned below.
-
-ext/json/ext/vendor/fpconv.h::
-  This file is adapted from https://github.com/night-shift/fpconv
-  It is licensed under Boost Software License 1.0.
-
-ext/json/ext/vendor/jeaiii-ltoa.h::
-  This file is adapted from https://github.com/jeaiii/itoa
-  It is licensed under the MIT License
-
-ext/json/ext/vendor/ryu.h::
-  This file is adapted from the Ryu algorithm by Ulf Adams https://github.com/ulfjack/ryu.
-  It is dual-licensed under Apache License 2.0 OR Boost Software License 1.0.

data/vendor/bundle/ruby/3.2.0/gems/json-2.19.3/README.md

@@ -1,299 +0,0 @@
-# JSON implementation for Ruby
-
-[![CI](https://github.com/ruby/json/actions/workflows/ci.yml/badge.svg)](https://github.com/ruby/json/actions/workflows/ci.yml)
-
-## Description
-
-This is an implementation of the JSON specification according to RFC 7159
-http://www.ietf.org/rfc/rfc7159.txt .
-
-The JSON generator generate UTF-8 character sequences by default.
-If an :ascii\_only option with a true value is given, they escape all
-non-ASCII and control characters with \uXXXX escape sequences, and support
-UTF-16 surrogate pairs in order to be able to generate the whole range of
-unicode code points.
-
-All strings, that are to be encoded as JSON strings, should be UTF-8 byte
-sequences on the Ruby side. To encode raw binary strings, that aren't UTF-8
-encoded, please use the to\_json\_raw\_object method of String (which produces
-an object, that contains a byte array) and decode the result on the receiving
-endpoint.
-
-## Installation
-
-Install the gem and add to the application's Gemfile by executing:
-
-    $ bundle add json
-
-If bundler is not being used to manage dependencies, install the gem by executing:
-
-    $ gem install json
-
-## Basic Usage
-
-To use JSON you can
-
-```ruby
-require 'json'
-```
-
-Now you can parse a JSON document into a ruby data structure by calling
-
-```ruby
-JSON.parse(document)
-```
-
-If you want to generate a JSON document from a ruby data structure call
-```ruby
-JSON.generate(data)
-```
-
-You can also use the `pretty_generate` method (which formats the output more
-verbosely and nicely) or `fast_generate` (which doesn't do any of the security
-checks generate performs, e. g. nesting deepness checks).
-
-## Casting non native types
-
-JSON documents can only support Hashes, Arrays, Strings, Integers and Floats.
-
-By default if you attempt to serialize something else, `JSON.generate` will
-search for a `#to_json` method on that object:
-
-```ruby
-Position = Struct.new(:latitude, :longitude) do
-  def to_json(state = nil, *)
-    JSON::State.from_state(state).generate({
-      latitude: latitude,
-      longitude: longitude,
-    })
-  end
-end
-
-JSON.generate([
-  Position.new(12323.234, 435345.233),
-  Position.new(23434.676, 159435.324),
-]) # => [{"latitude":12323.234,"longitude":435345.233},{"latitude":23434.676,"longitude":159435.324}]
-```
-
-If a `#to_json` method isn't defined on the object, `JSON.generate` will fallback to call `#to_s`:
-
-```ruby
-JSON.generate(Object.new) # => "#<Object:0x000000011e768b98>"
-```
-
-Both of these behavior can be disabled using the `strict: true` option:
-
-```ruby
-JSON.generate(Object.new, strict: true) # => Object not allowed in JSON (JSON::GeneratorError)
-JSON.generate(Position.new(1, 2)) # => Position not allowed in JSON (JSON::GeneratorError)
-```
-
-## JSON::Coder
-
-Since `#to_json` methods are global, it can sometimes be problematic if you need a given type to be
-serialized in different ways in different locations.
-
-Instead it is recommended to use the newer `JSON::Coder` API:
-
-```ruby
-module MyApp
-  API_JSON_CODER = JSON::Coder.new do |object, is_object_key|
-    case object
-    when Time
-      object.iso8601(3)
-    else
-      object
-    end
-  end
-end
-
-puts MyApp::API_JSON_CODER.dump(Time.now.utc) # => "2025-01-21T08:41:44.286Z"
-```
-
-The provided block is called for all objects that don't have a native JSON equivalent, and
-must return a Ruby object that has a native JSON equivalent.
-
-It is also called for objects that do have a JSON equivalent, but are used as Hash keys, for instance `{ 1 => 2}`,
-as well as for strings that aren't valid UTF-8:
-
-```ruby
-coder = JSON::Combining.new do |object, is_object_key|
-  case object
-  when String
-    if !string.valid_encoding? || string.encoding != Encoding::UTF_8
-      Base64.encode64(string)
-    else
-      string
-    end
-  else
-    object
-  end
-end
-```
-
-## Combining JSON fragments
-
-To combine JSON fragments into a bigger JSON document, you can use `JSON::Fragment`:
-
-```ruby
-posts_json = cache.fetch_multi(post_ids) do |post_id|
-  JSON.generate(Post.find(post_id))
-end
-posts_json.map! { |post_json| JSON::Fragment.new(post_json) }
-JSON.generate({ posts: posts_json, count: posts_json.count })
-```
-
-## Round-tripping arbitrary types
-
-> [!CAUTION]
-> You should never use `JSON.unsafe_load` nor `JSON.parse(str, create_additions: true)` to parse untrusted user input,
-> as it can lead to remote code execution vulnerabilities.
-
-To create a JSON document from a ruby data structure, you can call
-`JSON.generate` like that:
-
-```ruby
-json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
-# => "[1,2,{\"a\":3.141},false,true,null,\"4..10\"]"
-```
-
-To get back a ruby data structure from a JSON document, you have to call
-JSON.parse on it:
-
-```ruby
-JSON.parse json
-# => [1, 2, {"a"=>3.141}, false, true, nil, "4..10"]
-```
-
-Note, that the range from the original data structure is a simple
-string now. The reason for this is, that JSON doesn't support ranges
-or arbitrary classes. In this case the json library falls back to call
-`Object#to_json`, which is the same as `#to_s.to_json`.
-
-It's possible to add JSON support serialization to arbitrary classes by
-simply implementing a more specialized version of the `#to_json method`, that
-should return a JSON object (a hash converted to JSON with `#to_json`) like
-this (don't forget the `*a` for all the arguments):
-
-```ruby
-class Range
-  def to_json(*a)
-    {
-      'json_class'   => self.class.name, # = 'Range'
-      'data'         => [ first, last, exclude_end? ]
-    }.to_json(*a)
-  end
-end
-```
-
-The hash key `json_class` is the class, that will be asked to deserialise the
-JSON representation later. In this case it's `Range`, but any namespace of
-the form `A::B` or `::A::B` will do. All other keys are arbitrary and can be
-used to store the necessary data to configure the object to be deserialised.
-
-If the key `json_class` is found in a JSON object, the JSON parser checks
-if the given class responds to the `json_create` class method. If so, it is
-called with the JSON object converted to a Ruby hash. So a range can
-be deserialised by implementing `Range.json_create` like this:
-
-```ruby
-class Range
-  def self.json_create(o)
-    new(*o['data'])
-  end
-end
-```
-
-Now it possible to serialise/deserialise ranges as well:
-
-```ruby
-json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
-# => "[1,2,{\"a\":3.141},false,true,null,{\"json_class\":\"Range\",\"data\":[4,10,false]}]"
-JSON.parse json
-# => [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
-json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
-# => "[1,2,{\"a\":3.141},false,true,null,{\"json_class\":\"Range\",\"data\":[4,10,false]}]"
-JSON.unsafe_load json
-# => [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
-```
-
-`JSON.generate` always creates the shortest possible string representation of a
-ruby data structure in one line. This is good for data storage or network
-protocols, but not so good for humans to read. Fortunately there's also
-`JSON.pretty_generate` (or `JSON.pretty_generate`) that creates a more readable
-output:
-
-```ruby
- puts JSON.pretty_generate([1, 2, {"a"=>3.141}, false, true, nil, 4..10])
- [
-   1,
-   2,
-   {
-     "a": 3.141
-   },
-   false,
-   true,
-   null,
-   {
-     "json_class": "Range",
-     "data": [
-       4,
-       10,
-       false
-     ]
-   }
- ]
-```
-
-There are also the methods `Kernel#j` for generate, and `Kernel#jj` for
-`pretty_generate` output to the console, that work analogous to Core Ruby's `p` and
-the `pp` library's `pp` methods.
-
-## Development
-
-### Prerequisites
-
-1. Clone the repository
-2. Install dependencies with `bundle install`
-
-### Testing
-
-The full test suite can be run with:
-
-```bash
-bundle exec rake test
-```
-
-### Release
-
-Update the `lib/json/version.rb` file.
-
-```
-rbenv shell 2.6.5
-rake build
-gem push pkg/json-2.3.0.gem
-
-rbenv shell jruby-9.2.9.0
-rake build
-gem push pkg/json-2.3.0-java.gem
-```
-
-## Author
-
-Florian Frank <mailto:flori@ping.de>
-
-## License
-
-Ruby License, see https://www.ruby-lang.org/en/about/license.txt.
-
-## Download
-
-The latest version of this library can be downloaded at
-
-* https://rubygems.org/gems/json
-
-Online Documentation should be located at
-
-* https://www.rubydoc.info/gems/json
-
-[Ragel]: http://www.colm.net/open-source/ragel/

data/vendor/bundle/ruby/3.2.0/gems/json-2.19.3/ext/json/ext/fbuffer/fbuffer.h

@@ -1,251 +0,0 @@
-#ifndef _FBUFFER_H_
-#define _FBUFFER_H_
-
-#include "../json.h"
-#include "../vendor/jeaiii-ltoa.h"
-
-enum fbuffer_type {
-    FBUFFER_HEAP_ALLOCATED = 0,
-    FBUFFER_STACK_ALLOCATED = 1,
-};
-
-typedef struct FBufferStruct {
-    enum fbuffer_type type;
-    size_t initial_length;
-    size_t len;
-    size_t capa;
-#if JSON_DEBUG
-    size_t requested;
-#endif
-    char *ptr;
-    VALUE io;
-} FBuffer;
-
-#define FBUFFER_STACK_SIZE 512
-#define FBUFFER_IO_BUFFER_SIZE (16384 - 1)
-#define FBUFFER_INITIAL_LENGTH_DEFAULT 1024
-
-#define FBUFFER_PTR(fb) ((fb)->ptr)
-#define FBUFFER_LEN(fb) ((fb)->len)
-#define FBUFFER_CAPA(fb) ((fb)->capa)
-#define FBUFFER_PAIR(fb) FBUFFER_PTR(fb), FBUFFER_LEN(fb)
-
-static void fbuffer_free(FBuffer *fb);
-static void fbuffer_clear(FBuffer *fb);
-static void fbuffer_append(FBuffer *fb, const char *newstr, size_t len);
-static void fbuffer_append_long(FBuffer *fb, long number);
-static inline void fbuffer_append_char(FBuffer *fb, char newchr);
-static VALUE fbuffer_finalize(FBuffer *fb);
-
-static void fbuffer_stack_init(FBuffer *fb, size_t initial_length, char *stack_buffer, size_t stack_buffer_size)
-{
-    fb->initial_length = (initial_length > 0) ? initial_length : FBUFFER_INITIAL_LENGTH_DEFAULT;
-    if (stack_buffer) {
-        fb->type = FBUFFER_STACK_ALLOCATED;
-        fb->ptr = stack_buffer;
-        fb->capa = stack_buffer_size;
-    }
-#if JSON_DEBUG
-    fb->requested = 0;
-#endif
-}
-
-static inline void fbuffer_consumed(FBuffer *fb, size_t consumed)
-{
-#if JSON_DEBUG
-    if (consumed > fb->requested) {
-        rb_bug("fbuffer: Out of bound write");
-    }
-    fb->requested = 0;
-#endif
-    fb->len += consumed;
-}
-
-static void fbuffer_free(FBuffer *fb)
-{
-    if (fb->ptr && fb->type == FBUFFER_HEAP_ALLOCATED) {
-        ruby_xfree(fb->ptr);
-    }
-}
-
-static void fbuffer_clear(FBuffer *fb)
-{
-    fb->len = 0;
-}
-
-static void fbuffer_flush(FBuffer *fb)
-{
-    rb_io_write(fb->io, rb_utf8_str_new(fb->ptr, fb->len));
-    fbuffer_clear(fb);
-}
-
-static void fbuffer_realloc(FBuffer *fb, size_t required)
-{
-    if (required > fb->capa) {
-        if (fb->type == FBUFFER_STACK_ALLOCATED) {
-            const char *old_buffer = fb->ptr;
-            fb->ptr = ALLOC_N(char, required);
-            fb->type = FBUFFER_HEAP_ALLOCATED;
-            MEMCPY(fb->ptr, old_buffer, char, fb->len);
-        } else {
-            REALLOC_N(fb->ptr, char, required);
-        }
-        fb->capa = required;
-    }
-}
-
-static void fbuffer_do_inc_capa(FBuffer *fb, size_t requested)
-{
-    if (RB_UNLIKELY(fb->io)) {
-        if (fb->capa < FBUFFER_IO_BUFFER_SIZE) {
-            fbuffer_realloc(fb, FBUFFER_IO_BUFFER_SIZE);
-        } else {
-            fbuffer_flush(fb);
-        }
-
-        if (RB_LIKELY(requested < fb->capa)) {
-            return;
-        }
-    }
-
-    size_t required;
-
-    if (RB_UNLIKELY(!fb->ptr)) {
-        fb->ptr = ALLOC_N(char, fb->initial_length);
-        fb->capa = fb->initial_length;
-    }
-
-    for (required = fb->capa; requested > required - fb->len; required <<= 1);
-
-    fbuffer_realloc(fb, required);
-}
-
-static inline void fbuffer_inc_capa(FBuffer *fb, size_t requested)
-{
-#if JSON_DEBUG
-    fb->requested = requested;
-#endif
-
-    if (RB_UNLIKELY(requested > fb->capa - fb->len)) {
-        fbuffer_do_inc_capa(fb, requested);
-    }
-}
-
-static inline void fbuffer_append_reserved(FBuffer *fb, const char *newstr, size_t len)
-{
-    MEMCPY(fb->ptr + fb->len, newstr, char, len);
-    fbuffer_consumed(fb, len);
-}
-
-static inline void fbuffer_append(FBuffer *fb, const char *newstr, size_t len)
-{
-    if (len > 0) {
-        fbuffer_inc_capa(fb, len);
-        fbuffer_append_reserved(fb, newstr, len);
-    }
-}
-
-/* Appends a character into a buffer. The buffer needs to have sufficient capacity, via fbuffer_inc_capa(...). */
-static inline void fbuffer_append_reserved_char(FBuffer *fb, char chr)
-{
-#if JSON_DEBUG
-    if (fb->requested < 1) {
-        rb_bug("fbuffer: unreserved write");
-    }
-    fb->requested--;
-#endif
-
-    fb->ptr[fb->len] = chr;
-    fb->len++;
-}
-
-static void fbuffer_append_str(FBuffer *fb, VALUE str)
-{
-    const char *ptr;
-    size_t len;
-    RSTRING_GETMEM(str, ptr, len);
-
-    fbuffer_append(fb, ptr, len);
-    RB_GC_GUARD(str);
-}
-
-static void fbuffer_append_str_repeat(FBuffer *fb, VALUE str, size_t repeat)
-{
-    const char *ptr;
-    size_t len;
-    RSTRING_GETMEM(str, ptr, len);
-
-    fbuffer_inc_capa(fb, repeat * len);
-    while (repeat) {
-#if JSON_DEBUG
-        fb->requested = len;
-#endif
-        fbuffer_append_reserved(fb, ptr, len);
-        repeat--;
-    }
-    RB_GC_GUARD(str);
-}
-
-static inline void fbuffer_append_char(FBuffer *fb, char newchr)
-{
-    fbuffer_inc_capa(fb, 1);
-    *(fb->ptr + fb->len) = newchr;
-    fbuffer_consumed(fb, 1);
-}
-
-static inline char *fbuffer_cursor(FBuffer *fb)
-{
-    return fb->ptr + fb->len;
-}
-
-static inline void fbuffer_advance_to(FBuffer *fb, char *end)
-{
-    fbuffer_consumed(fb, (end - fb->ptr) - fb->len);
-}
-
-/*
- * Appends the decimal string representation of \a number into the buffer.
- */
-static void fbuffer_append_long(FBuffer *fb, long number)
-{
-    /*
-     * The jeaiii_ultoa() function produces digits left-to-right,
-     * allowing us to write directly into the buffer, but we don't know
-     * the number of resulting characters.
-     *
-     * We do know, however, that the `number` argument is always in the
-     * range 0xc000000000000000 to 0x3fffffffffffffff, or, in decimal,
-     * -4611686018427387904 to 4611686018427387903. The max number of chars
-     * generated is therefore 20 (including a potential sign character).
-     */
-
-    static const int MAX_CHARS_FOR_LONG = 20;
-
-    fbuffer_inc_capa(fb, MAX_CHARS_FOR_LONG);
-
-    if (number < 0) {
-        fbuffer_append_reserved_char(fb, '-');
-
-        /*
-         * Since number is always > LONG_MIN, `-number` will not overflow
-         * and is always the positive abs() value.
-         */
-        number = -number;
-    }
-
-    char *end = jeaiii_ultoa(fbuffer_cursor(fb), number);
-    fbuffer_advance_to(fb, end);
-}
-
-static VALUE fbuffer_finalize(FBuffer *fb)
-{
-    if (fb->io) {
-        fbuffer_flush(fb);
-        rb_io_flush(fb->io);
-        return fb->io;
-    } else {
-        return rb_utf8_str_new(FBUFFER_PTR(fb), FBUFFER_LEN(fb));
-    }
-}
-
-#endif // _FBUFFER_H_

data/vendor/bundle/ruby/3.2.0/gems/json-2.19.3/ext/json/ext/generator/extconf.rb

@@ -1,16 +0,0 @@
-require 'mkmf'
-
-if RUBY_ENGINE == 'truffleruby'
-  # The pure-Ruby generator is faster on TruffleRuby, so skip compiling the generator extension
-  File.write('Makefile', dummy_makefile("").join)
-else
-  append_cflags("-std=c99")
-  $defs << "-DJSON_GENERATOR"
-  $defs << "-DJSON_DEBUG" if ENV.fetch("JSON_DEBUG", "0") != "0"
-
-  if enable_config('generator-use-simd', default=!ENV["JSON_DISABLE_SIMD"])
-    load __dir__ + "/../simd/conf.rb"
-  end
-
-  create_makefile 'json/ext/generator'
-end