wsdl 1.0.0 → 1.1.0

data/vendor/bundle/ruby/4.0.0/gems/json-2.19.0/lib/json/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module JSON
-  VERSION = '2.19.0'
-end

data/vendor/bundle/ruby/4.0.0/gems/json-schema-6.2.0/LICENSE.md

@@ -1,19 +0,0 @@
-Copyright (c) 2010-2011, Lookingglass Cyber Solutions
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/vendor/bundle/ruby/4.0.0/gems/json-schema-6.2.0/README.md

@@ -1,526 +0,0 @@
-# Ruby JSON Schema Validator
-
-[![License](https://img.shields.io/github/license/voxpupuli/json-schema.svg)](https://github.com/voxpupuli/json-schema/blob/master/LICENSE.md)
-[![Test](https://github.com/voxpupuli/json-schema/actions/workflows/test.yml/badge.svg)](https://github.com/voxpupuli/json-schema/actions/workflows/test.yml)
-[![Release](https://github.com/voxpupuli/json-schema/actions/workflows/release.yml/badge.svg)](https://github.com/voxpupuli/json-schema/actions/workflows/release.yml)
-[![RubyGem Version](https://img.shields.io/gem/v/json-schema.svg)](https://rubygems.org/gems/json-schema)
-[![RubyGem Downloads](https://img.shields.io/gem/dt/json-schema.svg)](https://rubygems.org/gems/json-schema)
-[![Donated by Iain Beeston](https://img.shields.io/badge/donated%20by-Iain%20Beeston-fb7047.svg)](#transfer-notice)
-
-This library is intended to provide Ruby with an interface for validating JSON
-objects against a JSON schema conforming to [JSON Schema Draft
-6](https://tools.ietf.org/html/draft-wright-json-schema-01). Legacy support for
-[JSON Schema Draft 4](http://tools.ietf.org/html/draft-zyp-json-schema-04),
-[JSON Schema Draft 3](http://tools.ietf.org/html/draft-zyp-json-schema-03),
-[JSON Schema Draft 2](http://tools.ietf.org/html/draft-zyp-json-schema-02), and
-[JSON Schema Draft 1](http://tools.ietf.org/html/draft-zyp-json-schema-01) is
-also included.
-
-Additional Resources
---------------------
-
-- [Google Groups](https://groups.google.com/forum/#!forum/ruby-json-schema)
-- #voxpupuli on irc.libera.chat
-
-Version 2.0.0 Upgrade Notes
----------------------------
-
-Please be aware that the upgrade to version 2.0.0 will use Draft-04 **by
-default**, so schemas that do not declare a validator using the `$schema`
-keyword will use Draft-04 now instead of Draft-03. This is the reason for the
-major version upgrade.
-
-Version 3.0.0 Upgrade Notes
----------------------------
-
-All individual changes are documented in the CHANGELOG.md. The biggest change
-is that the new version only supports Ruby 2.5 and newer. Take a look into the
-gemspec file to see the currently supported Ruby version and also
-`.github/workflows/test.yml` to see the Ruby versions we test on.
-
-Installation
-------------
-
-From rubygems.org:
-
-```sh
-gem install json-schema
-```
-
-From the git repo:
-
-```sh
-gem build json-schema.gemspec
-gem install json-schema-*.gem
-```
-
-Validation
------
-
-Three base validation methods exist:
-
-1. `validate`: returns a boolean on whether a validation attempt passes
-2. `validate!`: throws a `JSON::Schema::ValidationError` with an appropriate message/trace on where the validation failed
-3. `fully_validate`: builds an array of validation errors return when validation is complete
-
-All methods take two arguments, which can be either a JSON string, a file
-containing JSON, or a Ruby object representing JSON data. The first argument to
-these methods is always the schema, the second is always the data to validate.
-An optional third options argument is also accepted; available options are used
-in the examples below.
-
-By default, the validator uses the [JSON Schema Draft
-4](http://tools.ietf.org/html/draft-zyp-json-schema-04) specification for
-validation; however, the user is free to specify additional specifications or
-extend existing ones. Legacy support for Draft 1, Draft 2, and Draft 3 is
-included by either passing an optional `:version` parameter to the `validate`
-method (set either as `:draft1` or `draft2`), or by declaring the `$schema`
-attribute in the schema and referencing the appropriate specification URI. Note
-that the `$schema` attribute takes precedence over the `:version` option during
-parsing and validation.
-
-For further information on json schema itself refer to <a
-href="https://json-schema.org/understanding-json-schema">Understanding
-JSON Schema</a>.
-
-Basic Usage
---------------
-
-```ruby
-require "json-schema"
-
-schema = {
-  "type" => "object",
-  "required" => ["a"],
-  "properties" => {
-    "a" => {"type" => "integer"}
-  }
-}
-
-#
-# validate ruby objects against a ruby schema
-#
-
-# => true
-JSON::Validator.validate(schema, { "a" => 5 })
-# => false
-JSON::Validator.validate(schema, {})
-
-#
-# validate a json string against a json schema file
-#
-
-require "json"
-File.write("schema.json", JSON.dump(schema))
-
-# => true
-JSON::Validator.validate('schema.json', '{ "a": 5 }')
-
-#
-# raise an error when validation fails
-#
-
-# => "The property '#/a' of type String did not match the following type: integer"
-begin
-  JSON::Validator.validate!(schema, { "a" => "taco" })
-rescue JSON::Schema::ValidationError => e
-  e.message
-end
-
-#
-# return an array of error messages when validation fails
-#
-
-# => ["The property '#/a' of type String did not match the following type: integer in schema 18a1ffbb-4681-5b00-bd15-2c76aee4b28f"]
-JSON::Validator.fully_validate(schema, { "a" => "taco" })
-```
-
-Advanced Options
------------------
-
-```ruby
-require "json-schema"
-
-schema = {
-  "type"=>"object",
-  "required" => ["a"],
-  "properties" => {
-    "a" => {
-      "type" => "integer",
-      "default" => 42
-    },
-    "b" => {
-      "type" => "object",
-      "properties" => {
-        "x" => {
-          "type" => "integer"
-        }
-      }
-    }
-  }
-}
-
-#
-# with the `:list` option, a list can be validated against a schema that represents the individual objects
-#
-
-# => true
-JSON::Validator.validate(schema, [{"a" => 1}, {"a" => 2}, {"a" => 3}], :list => true)
-# => false
-JSON::Validator.validate(schema, [{"a" => 1}, {"a" => 2}, {"a" => 3}])
-
-#
-# with the `:errors_as_objects` option, `#fully_validate` returns errors as hashes instead of strings
-#
-
-# => [{:schema=>#<Addressable::URI:0x3ffa69cbeed8 URI:18a1ffbb-4681-5b00-bd15-2c76aee4b28f>, :fragment=>"#/a", :message=>"The property '#/a' of type String did not match the following type: integer in schema 18a1ffbb-4681-5b00-bd15-2c76aee4b28f", :failed_attribute=>"TypeV4"}]
-JSON::Validator.fully_validate(schema, { "a" => "taco" }, :errors_as_objects => true)
-
-#
-# with the `:strict` option, all properties are considered to have `"required": true` and all objects `"additionalProperties": false`
-#
-
-# => true
-JSON::Validator.validate(schema, { "a" => 1, "b" => { "x" => 2 } }, :strict => true)
-# => false
-JSON::Validator.validate(schema, { "a" => 1, "b" => { "x" => 2 }, "c" => 3 }, :strict => true)
-# => false
-JSON::Validator.validate(schema, { "a" => 1 }, :strict => true)
-
-#
-# with the `:fragment` option, only a fragment of the schema is used for validation
-#
-
-# => true
-JSON::Validator.validate(schema, { "x" => 1 }, :fragment => "#/properties/b")
-# => false
-JSON::Validator.validate(schema, { "x" => 1 })
-
-#
-# with the `:validate_schema` option, the schema is validated (against the json schema spec) before the json is validated (against the specified schema)
-#
-
-# => true
-JSON::Validator.validate(schema, { "a" => 1 }, :validate_schema => true)
-# => false
-JSON::Validator.validate({ "required" => true }, { "a" => 1 }, :validate_schema => true)
-
-#
-# with the `:insert_defaults` option, any undefined values in the json that have a default in the schema are replaced with the default before validation
-#
-
-# => true
-JSON::Validator.validate(schema, {}, :insert_defaults => true)
-# => false
-JSON::Validator.validate(schema, {})
-
-#
-# with the `:version` option, schemas conforming to older drafts of the json schema spec can be used
-#
-
-v2_schema = {
-  "type" => "object",
-  "properties" => {
-    "a" => {
-      "type" => "integer"
-    }
-  }
-}
-
-# => false
-JSON::Validator.validate(v2_schema, {}, :version => :draft2)
-# => true
-JSON::Validator.validate(v2_schema, {})
-
-#
-# with the `:parse_data` option set to false, the json must be a parsed ruby object (not a json text, a uri or a file path)
-#
-
-# => true
-JSON::Validator.validate(schema, { "a" => 1 }, :parse_data => false)
-# => false
-JSON::Validator.validate(schema, '{ "a": 1 }', :parse_data => false)
-
-#
-# with the `:parse_integer` option set to false, the integer value given as string will not be parsed.
-#
-
-# => true
-JSON::Validator.validate({type: "integer"}, "23")
-# => false
-JSON::Validator.validate({type: "integer"}, "23", parse_integer: false)
-# => true
-JSON::Validator.validate({type: "string"}, "123", parse_integer: false)
-# => false
-JSON::Validator.validate({type: "string"}, "123")
-
-#
-# with the `:json` option, the json must be an unparsed json text (not a hash, a uri or a file path)
-#
-
-# => true
-JSON::Validator.validate(schema, '{ "a": 1 }', :json => true)
-# => "no implicit conversion of Hash into String"
-begin
-  JSON::Validator.validate(schema, { "a" => 1 }, :json => true)
-rescue TypeError => e
-  e.message
-end
-
-#
-# with the `:uri` option, the json must be a uri or file path (not a hash or a json text)
-#
-
-File.write("data.json", '{ "a": 1 }')
-
-# => true
-JSON::Validator.validate(schema, "data.json", :uri => true)
-# => "Can't convert Hash into String."
-begin
-  JSON::Validator.validate(schema, { "a"  => 1 }, :uri => true)
-rescue TypeError => e
-  e.message
-end
-
-#
-# with the `:clear_cache` option set to true, the internal cache of schemas is
-# cleared after validation (otherwise schemas are cached for efficiency)
-#
-
-File.write("schema.json", v2_schema.to_json)
-
-# => true
-JSON::Validator.validate("schema.json", {})
-
-File.write("schema.json", schema.to_json)
-
-# => true
-JSON::Validator.validate("schema.json", {}, :clear_cache => true)
-
-# => false
-JSON::Validator.validate("schema.json", {})
-```
-
-Extending Schemas
------------------
-
-For this example, we are going to extend the [JSON Schema Draft
-3](http://tools.ietf.org/html/draft-zyp-json-schema-03) specification by adding
-a 'bitwise-and' property for validation.
-
-```ruby
-require "json-schema"
-
-class BitwiseAndAttribute < JSON::Schema::Attribute
-  def self.validate(current_schema, data, fragments, processor, validator, options = {})
-    if data.is_a?(Integer) && data & current_schema.schema['bitwise-and'].to_i == 0
-      message = "The property '#{build_fragment(fragments)}' did not evaluate  to true when bitwise-AND'd with  #{current_schema.schema['bitwise-or']}"
-      validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-    end
-  end
-end
-
-class ExtendedSchema < JSON::Schema::Draft3
-  def initialize
-    super
-    @attributes["bitwise-and"] = BitwiseAndAttribute
-    @uri = JSON::Util::URI.parse("http://test.com/test.json")
-    @names = ["http://test.com/test.json"]
-  end
-
-  JSON::Validator.register_validator(self.new)
-end
-
-schema = {
-  "$schema" => "http://test.com/test.json",
-  "properties" => {
-    "a" => {
-      "bitwise-and" => 1
-    },
-    "b" => {
-      "type" => "string"
-    }
-  }
-}
-
-data = {
-  "a" => 0
-}
-
-data = {"a" => 1, "b" => "taco"}
-JSON::Validator.validate(schema,data) # => true
-data = {"a" => 1, "b" => 5}
-JSON::Validator.validate(schema,data) # => false
-data = {"a" => 0, "b" => "taco"}
-JSON::Validator.validate(schema,data) # => false
-```
-
-Custom format validation
-------------------------
-
-The JSON schema standard allows custom formats in schema definitions which
-should be ignored by validators that do not support them. JSON::Schema allows
-registering procs as custom format validators which receive the value to be
-checked as parameter and must raise a `JSON::Schema::CustomFormatError` to
-indicate a format violation. The error message will be prepended by the property
-name, e.g. [The property '#a']()
-
-```ruby
-require "json-schema"
-
-format_proc = -> value {
-  raise JSON::Schema::CustomFormatError.new("must be 42") unless value == "42"
-}
-
-# register the proc for format 'the-answer' for draft4 schema
-JSON::Validator.register_format_validator("the-answer", format_proc, ["draft4"])
-
-# omitting the version parameter uses ["draft1", "draft2", "draft3", "draft4"] as default
-JSON::Validator.register_format_validator("the-answer", format_proc)
-
-# deregistering the custom validator
-# (also ["draft1", "draft2", "draft3", "draft4"] as default version)
-JSON::Validator.deregister_format_validator('the-answer', ["draft4"])
-
-# shortcut to restore the default formats for validators (same default as before)
-JSON::Validator.restore_default_formats(["draft4"])
-
-# with the validator registered as above, the following results in
-# ["The property '#a' must be 42"] as returned errors
-schema = {
-  "$schema" => "http://json-schema.org/draft-04/schema#",
-  "properties" => {
-    "a" => {
-      "type" => "string",
-      "format" => "the-answer",
-    }
-  }
-}
-errors = JSON::Validator.fully_validate(schema, {"a" => "23"})
-```
-
-Validating a JSON Schema
-------------------------
-
-To validate that a JSON Schema conforms to the JSON Schema standard,
-you need to validate your schema against the metaschema for the appropriate
-JSON Schema Draft. All of the normal validation methods can be used
-for this. First retrieve the appropriate metaschema from the internal
-cache (using `JSON::Validator.validator_for_name()` or
-`JSON::Validator.validator_for_uri()`) and then simply validate your
-schema against it.
-
-
-```ruby
-require "json-schema"
-
-schema = {
-  "type" => "object",
-  "properties" => {
-    "a" => {"type" => "integer"}
-  }
-}
-
-metaschema = JSON::Validator.validator_for_name("draft4").metaschema
-# => true
-JSON::Validator.validate(metaschema, schema)
-```
-
-Controlling Remote Schema Reading
----------------------------------
-
-In some cases, you may wish to prevent the JSON Schema library from making HTTP
-calls or reading local files in order to resolve `$ref` schemas. If you fully
-control all schemas which should be used by validation, this could be
-accomplished by registering all referenced schemas with the validator in
-advance:
-
-```ruby
-schema = JSON::Schema.new(some_schema_definition, Addressable::URI.parse('http://example.com/my-schema'))
-JSON::Validator.add_schema(schema)
-```
-
-If more extensive control is necessary, the `JSON::Schema::Reader` instance used
-can be configured in a few ways:
-
-```ruby
-# Change the default schema reader used
-JSON::Validator.schema_reader = JSON::Schema::Reader.new(:accept_uri => true, :accept_file => false)
-
-# For this validation call, use a reader which only accepts URIs from my-website.com
-schema_reader = JSON::Schema::Reader.new(
-  :accept_uri => proc { |uri| uri.host == 'my-website.com' }
-)
-JSON::Validator.validate(some_schema, some_object, :schema_reader => schema_reader)
-```
-
-The `JSON::Schema::Reader` interface requires only an object which responds to
-`read(string)` and returns a `JSON::Schema` instance. See the [API
-documentation](http://www.rubydoc.info/github/ruby-json-schema/json-schema/master/JSON/Schema/Reader)
-for more information.
-
-JSON Backends
--------------
-
-The JSON Schema library currently supports the `json` and `yajl-ruby` backend
-JSON parsers. If either of these libraries are installed, they will be
-automatically loaded and used to parse any JSON strings supplied by the user.
-
-If more than one of the supported JSON backends are installed, the `yajl-ruby`
-parser is used by default. This can be changed by issuing the following before
-validation:
-
-```ruby
-JSON::Validator.json_backend = :json
-```
-
-Optionally, the JSON Schema library supports using the MultiJSON library for
-selecting JSON backends. If the MultiJSON library is installed, it will be
-autoloaded.
-
-**Deprecation notice:** MultiJSON support is deprecated and will be removed in a
-future version. To stop using MultiJSON, add the following to your application's
-initialization code:
-
-```ruby
-JSON::Validator.use_multi_json = false
-```
-
-Notes
------
-
-The 'format' attribute is only validated for the following values:
-
-- date-time
-- date
-- time
-- ip-address (IPv4 address in draft1, draft2 and draft3)
-- ipv4 (IPv4 address in draft4)
-- ipv6
-- uri
-
-All other 'format' attribute values are simply checked to ensure the instance
-value is of the correct datatype (e.g., an instance value is validated to be an
-integer or a float in the case of 'utc-millisec').
-
-Additionally, JSON::Validator does not handle any json hyperschema attributes.
-
-# Transfer Notice
-
-This plugin was originally authored by [Iain Beeston](https://github.com/iainbeeston).
-The maintainer preferred that [Vox Pupuli](https://voxpupuli.org/) take ownership of the module for future improvement and maintenance.
-Existing pull requests and issues were transferred, please fork and continue to contribute [here](https://github.com/voxpupuli/json-schema).
-
-# License
-
-This gem is licensed under the [MIT license](LICENSE.md).
-
-## Release information
-
-To make a new release, please do:
-* update the version in VERSION.yml
-* Install gems with `bundle install --with release --path .vendor`
-* generate the changelog with `bundle exec rake changelog`
-* Check if the new version matches the closed issues/PRs in the changelog
-* Create a PR with it
-* After it got merged, push a tag. GitHub actions will do the actual release to rubygems and GitHub Packages

data/vendor/bundle/ruby/4.0.0/gems/json-schema-6.2.0/lib/json-schema/attribute.rb

@@ -1,52 +0,0 @@
-require 'json-schema/errors/validation_error'
-
-module JSON
-  class Schema
-    class Attribute
-      def self.validate(current_schema, data, fragments, processor, validator, options = {}); end
-
-      def self.build_fragment(fragments)
-        "#/#{fragments.join('/')}"
-      end
-
-      def self.validation_error(processor, message, fragments, current_schema, failed_attribute, record_errors, properties = [])
-        error = ValidationError.new(message, fragments, failed_attribute, current_schema, properties)
-        if record_errors
-          processor.validation_error(error)
-        else
-          raise error
-        end
-      end
-
-      def self.validation_errors(validator)
-        validator.validation_errors
-      end
-
-      TYPE_CLASS_MAPPINGS = {
-        'string' => String,
-        'number' => Numeric,
-        'integer' => Integer,
-        'boolean' => [TrueClass, FalseClass],
-        'object' => Hash,
-        'array' => Array,
-        'null' => NilClass,
-        'any' => Object,
-      }
-
-      def self.data_valid_for_type?(data, type)
-        valid_classes = TYPE_CLASS_MAPPINGS.fetch(type) { return true }
-        Array(valid_classes).any? { |c| data.is_a?(c) }
-      end
-
-      # Lookup Schema type of given class instance
-      def self.type_of_data(data)
-        type, = TYPE_CLASS_MAPPINGS.map { |k, v| [k, v] }.sort_by do |(_, v)|
-          -Array(v).map { |klass| klass.ancestors.size }.max
-        end.find do |(_, v)|
-          Array(v).any? { |klass| data.is_a?(klass) }
-        end
-        type
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/4.0.0/gems/json-schema-6.2.0/lib/json-schema/attributes/additionalitems.rb

@@ -1,29 +0,0 @@
-require 'json-schema/attribute'
-
-module JSON
-  class Schema
-    class AdditionalItemsAttribute < Attribute
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        return unless data.is_a?(Array)
-
-        schema = current_schema.schema
-        return unless schema['items'].is_a?(Array)
-
-        case schema['additionalItems']
-        when false
-          if schema['items'].length < data.length
-            message = "The property '#{build_fragment(fragments)}' contains additional array elements outside of the schema when none are allowed"
-            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-          end
-        when Hash
-          additional_items_schema = JSON::Schema.new(schema['additionalItems'], current_schema.uri, validator)
-          data.each_with_index do |item, i|
-            next if i < schema['items'].length
-
-            additional_items_schema.validate(item, fragments + [i.to_s], processor, options)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/4.0.0/gems/json-schema-6.2.0/lib/json-schema/attributes/additionalproperties.rb

@@ -1,55 +0,0 @@
-require 'json-schema/attribute'
-require 'json-schema/attributes/extends'
-
-module JSON
-  class Schema
-    class AdditionalPropertiesAttribute < Attribute
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        schema = current_schema.schema
-        return unless data.is_a?(Hash) && (schema['type'].nil? || schema['type'] == 'object')
-
-        extra_properties = remove_valid_properties(data.keys, current_schema, validator)
-
-        addprop = schema['additionalProperties']
-        if addprop.is_a?(Hash)
-          matching_properties = extra_properties # & addprop.keys
-          matching_properties.each do |key|
-            additional_property_schema = JSON::Schema.new(addprop, current_schema.uri, validator)
-            additional_property_schema.validate(data[key], fragments + [key], processor, options)
-          end
-          extra_properties -= matching_properties
-        end
-
-        if extra_properties.any? && (addprop == false || (addprop.is_a?(Hash) && !addprop.empty?))
-          message = "The property '#{build_fragment(fragments)}' contains additional properties #{extra_properties.inspect} outside of the schema when none are allowed"
-          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-        end
-      end
-
-      def self.remove_valid_properties(extra_properties, current_schema, validator)
-        schema = current_schema.schema
-
-        if schema['properties']
-          extra_properties -= schema['properties'].keys
-        end
-
-        schema['patternProperties']&.each_key do |key|
-          regexp = Regexp.new(key)
-          extra_properties.reject! { |prop| regexp.match(prop) }
-        end
-
-        if extended_schemas = schema['extends']
-          extended_schemas = [extended_schemas] unless extended_schemas.is_a?(Array)
-          extended_schemas.each do |schema_value|
-            _, extended_schema = JSON::Schema::ExtendsAttribute.get_extended_uri_and_schema(schema_value, current_schema, validator)
-            if extended_schema
-              extra_properties = remove_valid_properties(extra_properties, extended_schema, validator)
-            end
-          end
-        end
-
-        extra_properties
-      end
-    end
-  end
-end