jsi 0.2.0 → 0.6.0

data/lib/jsi/validation/error.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JSI
+  module Validation
+    Error = Util::AttrStruct[*%w(
+      message
+      keyword
+      schema
+      instance_ptr
+      instance_document
+    )]
+
+    # a validation error of a schema instance against a schema
+    #
+    # @!attribute message
+    #   a message describing the error
+    #   @return [String]
+    # @!attribute keyword
+    #   the keyword of the schema which failed to validate.
+    #   this may be absent if the error is not from a schema keyword (i.e, `false` schema).
+    #   @return [String]
+    # @!attribute schema
+    #   the schema against which the instance failed to validate
+    #   @return [JSI::Schema]
+    # @!attribute instance_ptr
+    #   pointer to the instance in instance_document
+    #   @return [JSI::Ptr]
+    # @!attribute instance_document
+    #   document containing the instance at instance_ptr
+    #   @return [Object]
+    class Error
+    end
+  end
+end

data/lib/jsi/validation/result.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module JSI
+  module Validation
+    # a result of validating an instance against schemas which describe it.
+    # virtual base class.
+    class Result
+      include Util::Virtual
+
+      Builder = Util::AttrStruct[*%w(
+        result
+        schema
+        instance_ptr
+        instance_document
+        validate_only
+        visited_refs
+      )]
+
+      # @private
+      # a structure used to build a Result. virtual base class.
+      class Builder
+        def instance
+          instance_ptr.evaluate(instance_document)
+        end
+
+        def schema_issue(*_)
+          virtual_method
+        end
+
+        def schema_error(message, keyword = nil)
+          schema_issue(:error, message, keyword)
+        end
+
+        def schema_warning(message, keyword = nil)
+          schema_issue(:warning, message, keyword)
+        end
+
+        # @param subschema_ptr [JSI::Ptr, #to_ary]
+        # @return [JSI::Validation::Result]
+        def inplace_subschema_validate(subschema_ptr)
+          subresult = schema.subschema(subschema_ptr).internal_validate_instance(
+            instance_ptr,
+            instance_document,
+            validate_only: validate_only,
+            visited_refs: visited_refs,
+          )
+          merge_schema_issues(subresult)
+          subresult
+        end
+
+        # @param subschema_ptr [JSI::Ptr, #to_ary]
+        # @param subinstance_ptr [JSI::Ptr, #to_ary]
+        # @return [JSI::Validation::Result]
+        def child_subschema_validate(subschema_ptr, subinstance_ptr)
+          subresult = schema.subschema(subschema_ptr).internal_validate_instance(
+            instance_ptr + subinstance_ptr,
+            instance_document,
+            validate_only: validate_only,
+          )
+          merge_schema_issues(subresult)
+          subresult
+        end
+
+        # @param other_result [JSI::Validation::Result]
+        # @return [void]
+        def merge_schema_issues(other_result)
+          unless validate_only
+            # schema_issues are always merged from subschema results (not depending on validation results)
+            result.schema_issues.merge(other_result.schema_issues)
+          end
+          nil
+        end
+      end
+
+      def builder(schema, instance_ptr, instance_document, validate_only, visited_refs)
+        self.class::Builder.new(
+          result: self,
+          schema: schema,
+          instance_ptr: instance_ptr,
+          instance_document: instance_document,
+          validate_only: validate_only,
+          visited_refs: visited_refs,
+        )
+      end
+
+      # is the instance valid against its schemas?
+      # @return [Boolean]
+      def valid?
+        # :nocov:
+        virtual_method
+        # :nocov:
+      end
+
+      include Util::FingerprintHash
+    end
+
+    # a full result of validating an instance against its schemas, with each validation error
+    class FullResult < Result
+      # @private
+      class Builder < Result::Builder
+        def validate(
+            valid,
+            message,
+            keyword: nil,
+            results: []
+        )
+          results.each { |res| result.schema_issues.merge(res.schema_issues) }
+          if !valid
+            results.each { |res| result.validation_errors.merge(res.validation_errors) }
+            result.validation_errors << Validation::Error.new({
+              message: message,
+              keyword: keyword,
+              schema: schema,
+              instance_ptr: instance_ptr,
+              instance_document: instance_document,
+            })
+          end
+        end
+
+        def schema_issue(level, message, keyword = nil)
+          result.schema_issues << Schema::Issue.new({
+            level: level,
+            message: message,
+            keyword: keyword,
+            schema: schema,
+          })
+        end
+      end
+
+      def initialize
+        @validation_errors = Set.new
+        @schema_issues = Set.new
+      end
+
+      attr_reader :validation_errors
+      attr_reader :schema_issues
+
+      def valid?
+        validation_errors.empty?
+      end
+
+      def freeze
+        @validation_errors.each(&:freeze)
+        @schema_issues.each(&:freeze)
+        @validation_errors.freeze
+        @schema_issues.freeze
+        super
+      end
+
+      def merge(result)
+        unless result.is_a?(FullResult)
+          raise(TypeError, "not a #{FullResult.name}: #{result.pretty_inspect.chomp}")
+        end
+        validation_errors.merge(result.validation_errors)
+        schema_issues.merge(result.schema_issues)
+        self
+      end
+
+      def +(result)
+        FullResult.new.merge(self).merge(result)
+      end
+
+      # @private
+      def jsi_fingerprint
+        {
+          class: self.class,
+          validation_errors: validation_errors,
+          schema_issues: schema_issues,
+        }
+      end
+    end
+
+    # a result indicating only whether an instance is valid against its schemas
+    class ValidityResult < Result
+      # @private
+      class Builder < Result::Builder
+        def validate(
+            valid,
+            message,
+            keyword: nil,
+            results: []
+        )
+          if !valid
+            throw(:jsi_validation_result, INVALID)
+          end
+        end
+
+        def schema_issue(*_)
+          # noop
+        end
+      end
+
+      def initialize(valid)
+        @valid = valid
+      end
+
+      def valid?
+        @valid
+      end
+
+      # @private
+      def jsi_fingerprint
+        {
+          class: self.class,
+          valid: valid?,
+        }
+      end
+    end
+  end
+end

data/lib/jsi/validation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module JSI
+  module Validation
+    autoload :Error, 'jsi/validation/error'
+
+    autoload :Result, 'jsi/validation/result'
+    autoload :FullResult, 'jsi/validation/result'
+    autoload :ValidityResult, 'jsi/validation/result'
+
+    VALID = ValidityResult.new(true).freeze
+
+    INVALID = ValidityResult.new(false).freeze
+  end
+end

data/lib/jsi/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSI
-  VERSION = "0.2.0".freeze
+  VERSION = "0.6.0".freeze
 end

data/lib/jsi.rb

@@ -1,33 +1,96 @@
+# frozen_string_literal: true
+
 require "jsi/version"
 require "pp"
 require "set"
-require "jsi/json-schema-fragments"
+require "json"
+require "pathname"
+require "bigdecimal"
+require "addressable/uri"
+
 require "jsi/util"
+require "jsi/typelike_modules"
 
 module JSI
   # generally put in code paths that are not expected to be valid control flow paths.
   # rather a NotImplementedCorrectlyError. but that's too long.
+  #
+  # if you've found this class because JSI has raised this error, please open an issue with the backtrace
+  # and any context you can provide at https://github.com/notEthan/jsi/issues
   class Bug < NotImplementedError
   end
 
-  autoload :JSON, 'jsi/json'
+  # @private
+  ROOT_PATH = Pathname.new(__FILE__).dirname.parent.expand_path
+
+  # @private
+  RESOURCES_PATH = ROOT_PATH.join('{resources}')
+
+  # @private
+  SCHEMAS_PATH = RESOURCES_PATH.join('schemas')
+
+  autoload :Ptr, 'jsi/ptr'
+
+  # @private
+  # @deprecated
+  module JSON
+    Pointer = Ptr
+  end
+
   autoload :PathedNode, 'jsi/pathed_node'
   autoload :Typelike, 'jsi/typelike_modules'
   autoload :Hashlike, 'jsi/typelike_modules'
   autoload :Arraylike, 'jsi/typelike_modules'
   autoload :Schema, 'jsi/schema'
+  autoload :SchemaSet, 'jsi/schema_set'
   autoload :Base, 'jsi/base'
-  autoload :BaseArray, 'jsi/base'
-  autoload :BaseHash, 'jsi/base'
+  autoload :Metaschema, 'jsi/metaschema'
+  autoload :MetaschemaNode, 'jsi/metaschema_node'
   autoload :SchemaClasses, 'jsi/schema_classes'
+  autoload :SchemaRegistry, 'jsi/schema_registry'
+  autoload :Validation, 'jsi/validation'
   autoload :JSICoder, 'jsi/jsi_coder'
 
+  autoload :JSONSchemaOrgDraft04, 'schemas/json-schema.org/draft-04/schema'
+  autoload :JSONSchemaOrgDraft06, 'schemas/json-schema.org/draft-06/schema'
+  autoload :JSONSchemaOrgDraft07, 'schemas/json-schema.org/draft-07/schema'
+
   autoload :SimpleWrap, 'jsi/simple_wrap'
 
-  # @return [Class subclassing JSI::Base] a JSI class which represents the
-  #   given schema. instances of the class represent JSON Schema instances
-  #   for the given schema.
-  def self.class_for_schema(*a, &b)
-    SchemaClasses.class_for_schema(*a, &b)
+  # instantiates a given schema object as a JSI Schema.
+  #
+  # see {JSI::Schema.new_schema}
+  #
+  # @param (see JSI::Schema.new_schema)
+  # @return (see JSI::Schema.new_schema)
+  def self.new_schema(schema_object, **kw)
+    JSI::Schema.new_schema(schema_object, **kw)
+  end
+
+  # instantiates a given schema object as a JSI Schema and returns its JSI Schema Module.
+  #
+  # shortcut to chain {JSI::Schema.new_schema} + {Schema#jsi_schema_module}.
+  #
+  # @param (see JSI::Schema.new_schema)
+  # @return [Module, JSI::SchemaModule] the JSI Schema Module of the schema
+  def self.new_schema_module(schema_object, **kw)
+    JSI::Schema.new_schema(schema_object, **kw).jsi_schema_module
+  end
+
+  # @private @deprecated
+  def self.class_for_schemas(schemas)
+    SchemaClasses.class_for_schemas(schemas.map { |schema| JSI.new_schema(schema) })
+  end
+
+  # `JSI.schema_registry` is the {JSI::SchemaRegistry} in which schemas are registered.
+  #
+  # @return [JSI::SchemaRegistry]
+  def self.schema_registry
+    return @schema_registry if instance_variable_defined?(:@schema_registry)
+    @schema_registry = SchemaRegistry.new
   end
 end
+
+JSI.schema_registry.autoload_uri("http://json-schema.org/draft-04/schema") { JSI::JSONSchemaOrgDraft04.schema }
+JSI.schema_registry.autoload_uri("http://json-schema.org/draft-06/schema") { JSI::JSONSchemaOrgDraft06.schema }
+JSI.schema_registry.autoload_uri("http://json-schema.org/draft-07/schema") { JSI::JSONSchemaOrgDraft07.schema }

data/lib/schemas/json-schema.org/draft-04/schema.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSI
+  metaschema_document = ::JSON.parse(SCHEMAS_PATH.join('json-schema.org/draft-04/schema.json').read)
+  JSONSchemaOrgDraft04 = MetaschemaNode.new(metaschema_document,
+    metaschema_instance_modules: [JSI::Schema::Draft04],
+  ).jsi_schema_module
+
+  # the JSI schema module for `http://json-schema.org/draft-04/schema`
+  module JSONSchemaOrgDraft04
+  end
+end

data/lib/schemas/json-schema.org/draft-06/schema.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSI
+  metaschema_document = ::JSON.parse(SCHEMAS_PATH.join('json-schema.org/draft-06/schema.json').read)
+  JSONSchemaOrgDraft06 = MetaschemaNode.new(metaschema_document,
+    metaschema_instance_modules: [JSI::Schema::Draft06],
+  ).jsi_schema_module
+
+  # the JSI schema module for `http://json-schema.org/draft-06/schema`
+  module JSONSchemaOrgDraft06
+  end
+end

data/lib/schemas/json-schema.org/draft-07/schema.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSI
+  metaschema_document = ::JSON.parse(SCHEMAS_PATH.join('json-schema.org/draft-07/schema.json').read)
+  JSONSchemaOrgDraft07 = MetaschemaNode.new(metaschema_document,
+    metaschema_instance_modules: [JSI::Schema::Draft07],
+  ).jsi_schema_module
+
+  # the JSI schema module for `http://json-schema.org/draft-07/schema`
+  module JSONSchemaOrgDraft07
+  end
+end

data/readme.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# a small script following the code samples in the README
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+require 'jsi'
+
+puts "creating a schema and assigning its schema module to a constant"
+puts
+
+contact_schema = JSI.new_schema({
+  "$schema" => "http://json-schema.org/draft-07/schema",
+  "description" => "A Contact",
+  "type" => "object",
+  "properties" => {
+    "name" => {
+      "type" => "string",
+    },
+    "phone" => {
+      "type" => "array",
+      "items" => {
+        "type" => "object",
+        "properties" => {
+          "location" => {
+            "type" => "string",
+          },
+          "number" => {
+            "type" => "string",
+          }
+        }
+      }
+    }
+  }
+})
+
+print 'contact_schema: '
+pp contact_schema
+
+print 'contact_schema.jsi_schema_module: '
+pp contact_schema.jsi_schema_module
+
+puts "constant assignment: Contact = contact_schema.jsi_schema_module"
+Contact = contact_schema.jsi_schema_module
+
+print 'contact_schema.jsi_schema_module: '
+pp contact_schema.jsi_schema_module
+
+puts
+puts "creating and using an instance described by the schema"
+puts
+
+bill = Contact.new_jsi({
+  "name" => "bill",
+  "phone" => [
+    {
+      "location" => "home",
+      "number" => "555",
+    }
+  ],
+  "nickname" => "big b",
+})
+
+print 'bill: '
+pp bill
+
+print 'bill.name: '
+pp bill.name
+
+print 'bill.phone.map(&:location): '
+pp bill.phone.map(&:location)
+
+print 'bill.jsi_valid?: '
+pp bill.jsi_valid?
+
+bad = Contact.new_jsi({'phone' => [{'number' => [5, 5, 5]}]})
+
+print 'bad: '
+pp bad
+
+print 'bad.phone.jsi_validate: '
+pp bad.phone.jsi_validate
+
+print 'bill.transform_values(&:size): '
+pp bill.transform_values(&:size)
+
+print "bill['nickname']: "
+pp bill['nickname']
+
+puts
+puts "OOP: application-defined methods on schema modules apply to their instances"
+puts
+
+module Contact
+  def phone_numbers
+    phone.map(&:number)
+  end
+  def name
+    super + ' esq.'
+  end
+  def name=(name)
+    super(name.chomp(' esq.'))
+  end
+end
+
+print 'bill.name: '
+pp bill.name
+
+puts "bill.name = 'rob esq.'"
+bill.name = 'rob esq.'
+
+print "bill['name']: "
+pp bill['name']
+
+print 'bill.phone_numbers: '
+pp bill.phone_numbers
+
+puts
+puts "OOP on subschemas"
+puts
+
+print "Contact.properties['phone'].items: "
+pp Contact.properties['phone'].items
+
+module Contact
+  Phone = properties['phone'].items
+  module Phone
+    def number_with_dashes
+      number.split(//).join('-')
+    end
+  end
+end
+
+print "Contact.properties['phone'].items: "
+pp Contact.properties['phone'].items
+
+print 'bill.phone.first.number_with_dashes: '
+pp bill.phone.first.number_with_dashes

data/{resources}/schemas/json-schema.org/draft-04/schema.json

@@ -0,0 +1,149 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string"
+        },
+        "$schema": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}