wallee-ruby-sdk 5.2.0 → 6.0.0

data/vendor/bundle/ruby/3.3.0/gems/json-2.15.1/COPYING

@@ -1,56 +0,0 @@
-Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
-You can redistribute it and/or modify it under either the terms of the
-2-clause BSDL (see the file BSDL), or the conditions below:
-
-  1. You may make and give away verbatim copies of the source form of the
-     software without restriction, provided that you duplicate all of the
-     original copyright notices and associated disclaimers.
-
-  2. You may modify your copy of the software in any way, provided that
-     you do at least ONE of the following:
-
-       a) place your modifications in the Public Domain or otherwise
-          make them Freely Available, such as by posting said
-	  modifications to Usenet or an equivalent medium, or by allowing
-	  the author to include your modifications in the software.
-
-       b) use the modified software only within your corporation or
-          organization.
-
-       c) give non-standard binaries non-standard names, with
-          instructions on where to get the original software distribution.
-
-       d) make other distribution arrangements with the author.
-
-  3. You may distribute the software in object code or binary form,
-     provided that you do at least ONE of the following:
-
-       a) distribute the binaries and library files of the software,
-	  together with instructions (in the manual page or equivalent)
-	  on where to get the original distribution.
-
-       b) accompany the distribution with the machine-readable source of
-	  the software.
-
-       c) give non-standard binaries non-standard names, with
-          instructions on where to get the original software distribution.
-
-       d) make other distribution arrangements with the author.
-
-  4. You may modify and include the part of the software into any other
-     software (possibly commercial).  But some files in the distribution
-     are not written by the author, so that they are not under these terms.
-
-     For the list of those files and their copying conditions, see the
-     file LEGAL.
-
-  5. The scripts and library files supplied as input to or produced as
-     output from the software do not automatically fall under the
-     copyright of the software, but belong to whomever generated them,
-     and may be sold commercially, and may be aggregated with this
-     software.
-
-  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
-     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-     PURPOSE.

data/vendor/bundle/ruby/3.3.0/gems/json-2.15.1/LEGAL

@@ -1,8 +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.

data/vendor/bundle/ruby/3.3.0/gems/json-2.15.1/README.md

@@ -1,283 +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}`.
-
-## 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.3.0/gems/json-2.15.1/ext/json/ext/fbuffer/fbuffer.h

@@ -1,296 +0,0 @@
-#ifndef _FBUFFER_H_
-#define _FBUFFER_H_
-
-#include "ruby.h"
-#include "ruby/encoding.h"
-#include "../vendor/jeaiii-ltoa.h"
-
-/* shims */
-/* This is the fallback definition from Ruby 3.4 */
-
-#ifndef RBIMPL_STDBOOL_H
-#if defined(__cplusplus)
-# if defined(HAVE_STDBOOL_H) && (__cplusplus >= 201103L)
-#  include <cstdbool>
-# endif
-#elif defined(HAVE_STDBOOL_H)
-# include <stdbool.h>
-#elif !defined(HAVE__BOOL)
-typedef unsigned char _Bool;
-# define bool  _Bool
-# define true  ((_Bool)+1)
-# define false ((_Bool)+0)
-# define __bool_true_false_are_defined
-#endif
-#endif
-
-#ifndef NOINLINE
-#if defined(__has_attribute) && __has_attribute(noinline)
-#define NOINLINE() __attribute__((noinline))
-#else
-#define NOINLINE()
-#endif
-#endif
-
-#ifndef RB_UNLIKELY
-#define RB_UNLIKELY(expr) expr
-#endif
-
-#ifndef RB_LIKELY
-#define RB_LIKELY(expr) expr
-#endif
-
-#ifndef MAYBE_UNUSED
-# define MAYBE_UNUSED(x) x
-#endif
-
-#ifdef RUBY_DEBUG
-#ifndef JSON_DEBUG
-#define JSON_DEBUG RUBY_DEBUG
-#endif
-#endif
-
-enum fbuffer_type {
-    FBUFFER_HEAP_ALLOCATED = 0,
-    FBUFFER_STACK_ALLOCATED = 1,
-};
-
-typedef struct FBufferStruct {
-    enum fbuffer_type type;
-    unsigned long initial_length;
-    unsigned long len;
-    unsigned long capa;
-#ifdef JSON_DEBUG
-    unsigned long 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, unsigned long 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, unsigned long initial_length, char *stack_buffer, long 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;
-    }
-#ifdef JSON_DEBUG
-    fb->requested = 0;
-#endif
-}
-
-static inline void fbuffer_consumed(FBuffer *fb, unsigned long consumed)
-{
-#ifdef 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, unsigned long 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, unsigned long 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;
-        }
-    }
-
-    unsigned long 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, unsigned long requested)
-{
-#ifdef 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, unsigned long len)
-{
-    MEMCPY(fb->ptr + fb->len, newstr, char, len);
-    fbuffer_consumed(fb, len);
-}
-
-static inline void fbuffer_append(FBuffer *fb, const char *newstr, unsigned long 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)
-{
-#ifdef 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 *newstr = StringValuePtr(str);
-    unsigned long len = RSTRING_LEN(str);
-
-    fbuffer_append(fb, newstr, len);
-}
-
-static void fbuffer_append_str_repeat(FBuffer *fb, VALUE str, size_t repeat)
-{
-    const char *newstr = StringValuePtr(str);
-    unsigned long len = RSTRING_LEN(str);
-
-    fbuffer_inc_capa(fb, repeat * len);
-    while (repeat) {
-#ifdef JSON_DEBUG
-        fb->requested = len;
-#endif
-        fbuffer_append_reserved(fb, newstr, len);
-        repeat--;
-    }
-}
-
-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);
-        fbuffer_free(fb);
-        rb_io_flush(fb->io);
-        return fb->io;
-    } else {
-        VALUE result = rb_utf8_str_new(FBUFFER_PTR(fb), FBUFFER_LEN(fb));
-        fbuffer_free(fb);
-        return result;
-    }
-}
-
-#endif