json_skooma 0.1.0

data/lib/json_skooma/keywords/applicator/prefix_items.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class PrefixItems < Base
+        self.key = "prefixItems"
+        self.instance_types = "array"
+        self.value_schema = :array_of_schemas
+
+        def evaluate(instance, result)
+          annotation = nil
+          error = []
+          instance.take(json.length).each_with_index do |item, index|
+            annotation = index
+            result.call(item, index.to_s) do |subresult|
+              unless json[index].evaluate(item, subresult).passed?
+                error << index
+              end
+            end
+          end
+          return result.failure(error) unless error.empty?
+          return if annotation.nil?
+
+          annotation = true if annotation == instance.length - 1
+          result.annotate(annotation)
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/applicator/properties.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class Properties < Base
+        self.key = "properties"
+        self.instance_types = "object"
+        self.value_schema = :object_of_schemas
+
+        def evaluate(instance, result)
+          annotation = []
+          err_names = []
+          instance.each do |name, item|
+            next unless json.value.key?(name)
+
+            result.call(item, name) do |subresult|
+              json[name].evaluate(item, subresult)
+              if subresult.passed?
+                annotation << name
+              else
+                err_names << name
+              end
+            end
+          end
+
+          return result.annotate(annotation) if err_names.empty?
+
+          result.failure("Properties #{err_names} are invalid")
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/applicator/property_names.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class PropertyNames < Base
+        self.key = "propertyNames"
+        self.instance_types = "object"
+        self.value_schema = :schema
+
+        def evaluate(instance, result)
+          error = []
+          instance.each do |name,|
+            next if json.evaluate(JSONNode.new(name, key: name, parent: instance), result).passed?
+
+            error << name
+            result.success
+          end
+
+          result.failure(error) if error.any?
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/applicator/then.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class Then < Base
+        self.key = "then"
+        self.value_schema = :schema
+        self.depends_on = %w[if]
+
+        def evaluate(instance, result)
+          condition = result.sibling(instance, "if")
+          if condition&.valid?
+            json.evaluate(instance, result)
+          else
+            result.discard
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/base.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    class Base
+      attr_reader :json, :parent_schema
+
+      class << self
+        attr_accessor :static, :depends_on, :schema_value_class
+        attr_writer :key
+        attr_reader :instance_types
+
+        def key
+          @key or raise "Key must be defined"
+        end
+
+        def instance_types=(value)
+          @instance_types = Array(value)
+        end
+
+        def value_schema=(schema_keys)
+          Array(schema_keys).each do |k|
+            prepend ValueSchemas[k]
+          end
+        end
+
+        def set_defaults
+          @instance_types = %w[boolean object array string number null]
+          @static = false
+          @depends_on = []
+        end
+
+        def inherited(subclass)
+          subclass.set_defaults
+        end
+      end
+
+      def initialize(parent_schema, value)
+        @parent_schema = parent_schema
+        @json = wrap_value(value)
+      end
+
+      def key
+        self.class.key
+      end
+
+      def static
+        self.class.static
+      end
+
+      def instance_types
+        self.class.instance_types
+      end
+
+      def evaluate(instance, result)
+      end
+
+      def each_schema(&block)
+      end
+
+      def resolve
+        each_schema do |schema|
+          schema.resolve_references if schema.respond_to?(:resolve_references)
+        end
+      end
+
+      private
+
+      def wrap_value(value)
+        JSONNode.new(value, key: key, parent: parent_schema)
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/base_annotation.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    class BaseAnnotation < Base
+      def evaluate(instance, result)
+        result.annotate(json.value)
+        result.skip_assertion
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/content/content_encoding.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Content
+      class ContentEncoding < BaseAnnotation
+        self.key = "contentEncoding"
+        self.instance_types = %w[string]
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/content/content_media_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Content
+      class ContentMediaType < BaseAnnotation
+        self.key = "contentMediaType"
+        self.instance_types = %w[string]
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/content/content_schema.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Content
+      class ContentSchema < BaseAnnotation
+        self.key = "contentSchema"
+        self.instance_types = %w[string]
+        self.depends_on = %w[contentMediaType]
+
+        def evaluate(instance, result)
+          return super if result.sibling(instance, "contentMediaType")
+
+          result.discard
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/core/anchor.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Core
+      class Anchor < Base
+        self.key = "$anchor"
+        self.static = true
+
+        def initialize(parent_schema, value)
+          super
+
+          base_uri = parent_schema.base_uri
+          raise Error, "No base URI for `$anchor` value `#{value}`" if base_uri.nil?
+
+          uri = base_uri.dup.tap { |u| u.fragment = value }
+          parent_schema.registry.add_schema(uri, parent_schema, cache_id: parent_schema.cache_id)
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/core/comment.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Core
+      class Comment < Base
+        self.key = "$comment"
+        self.static = true
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/core/defs.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Core
+      class Defs < Base
+        self.key = "$defs"
+        self.static = true
+        self.value_schema = :object_of_schemas
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/core/dynamic_anchor.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Core
+      class DynamicAnchor < Base
+        self.key = "$dynamicAnchor"
+        self.static = true
+
+        def initialize(parent_schema, value)
+          super
+
+          base_uri = parent_schema.base_uri
+          raise Error, "No base URI for `$dynamicAnchor` value `#{value}`" if base_uri.nil?
+
+          uri = base_uri.dup.tap { |u| u.fragment = value }
+          parent_schema.registry.add_schema(uri, parent_schema, cache_id: parent_schema.cache_id)
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/core/dynamic_ref.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Core
+      class DynamicRef < Base
+        self.key = "$dynamicRef"
+
+        def initialize(parent_schema, value)
+          super
+          @fragment = URI.parse(value).fragment
+          @dynamic = false
+        end
+
+        def resolve
+          uri = URI.parse(json)
+          if uri.relative?
+            base_uri = parent_schema.base_uri
+            if base_uri.nil?
+              raise "No base URI against which to resolve the `$dynamicRef` value `#{uri}`"
+            end
+
+            uri = base_uri + uri
+          end
+          @ref_schema = parent_schema.registry.schema(
+            uri,
+            metaschema_uri: parent_schema.metaschema_uri,
+            cache_id: parent_schema.cache_id
+          )
+          dynamic_anchor = @ref_schema["$dynamicAnchor"]
+          @dynamic = dynamic_anchor == @fragment
+        end
+
+        def evaluate(instance, result)
+          ref_schema = @ref_schema
+          if @dynamic
+            target = result
+            checked_uris = Set.new
+            while target
+              base_uri = target.schema.base_uri
+              if base_uri && !checked_uris.include?(base_uri)
+                checked_uris << base_uri
+                target_uri = base_uri.dup.tap { |u| u.fragment = @fragment }
+
+                begin
+                  found_schema = parent_schema.registry.schema(
+                    target_uri,
+                    cache_id: parent_schema.cache_id
+                  )
+                  dynamic_anchor = found_schema["$dynamicAnchor"]
+                  ref_schema = found_schema if dynamic_anchor == @fragment
+                rescue RegistryError, Hana::Pointer::FormatError
+                  # do nothing
+                end
+              end
+
+              target = target.parent
+            end
+          end
+
+          ref_schema.evaluate(instance, result)
+          result.ref_schema = ref_schema
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/core/id.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Core
+      class Id < Base
+        self.key = "$id"
+        self.static = true
+
+        def initialize(parent_schema, value)
+          super
+
+          uri = URI.parse(value)
+          if uri.relative?
+            base_uri = parent_schema.base_uri
+            if base_uri
+              uri = base_uri + uri
+            else
+              raise "No base URI against which to resolve the `$id` value `#{value}`"
+            end
+          end
+
+          parent_schema.uri = uri
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/core/ref.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Core
+      class Ref < Base
+        self.key = "$ref"
+
+        def resolve
+          uri = resolve_uri
+          @ref_schema = parent_schema.registry.schema(
+            uri,
+            metaschema_uri: parent_schema.metaschema_uri,
+            cache_id: parent_schema.cache_id
+          )
+        end
+
+        def evaluate(instance, result)
+          @ref_schema.evaluate(instance, result)
+          result.ref_schema = @ref_schema
+        end
+
+        private
+
+        def resolve_uri
+          uri = URI.parse(json)
+          return uri if uri.absolute?
+          return parent_schema.base_uri + uri if parent_schema.base_uri
+
+          raise Error, "No base URI against which to resolve the `$ref` value `#{uri}`"
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/core/schema.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Core
+      class Schema < Base
+        self.key = "$schema"
+        self.static = true
+
+        def initialize(parent_schema, value)
+          super
+
+          # todo: validate URI.validate(require_scheme=True, require_normalized=True)
+          uri = URI.parse(value)
+          parent_schema.metaschema_uri = uri
+
+          if parent_schema.is_a?(Metaschema)
+            metaschema = parent_schema.registry.metaschema(uri)
+            parent_schema.core_vocabulary ||= metaschema.core_vocabulary
+            parent_schema.default_vocabularies ||= metaschema.default_vocabularies
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/core/vocabulary.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Core
+      class Vocabulary < Base
+        self.key = "$vocabulary"
+        self.static = true
+
+        def initialize(parent_schema, value)
+          super
+
+          return unless parent_schema.is_a?(Metaschema)
+
+          core_vocab_uri = parent_schema.core_vocabulary&.uri.to_s
+          if core_vocab_uri.empty? || !value[core_vocab_uri]
+            raise Error, "The `$vocabulary` keyword must list the core vocabulary with a value of true"
+          end
+
+          value.each do |vocabulary_uri, vocabulary_required|
+            uri = URI.parse(vocabulary_uri)
+
+            vocabulary = parent_schema.registry.vocabulary(uri)
+            parent_schema.kw_classes.merge!(vocabulary.kw_classes)
+          rescue RegistryError
+            if vocabulary_required
+              raise Error, "The metaschema requires an unrecognized vocabulary #{vocabulary_uri}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/draft_2019_09/additional_items.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Draft201909
+      class AdditionalItems < Base
+        self.key = "additionalItems"
+        self.instance_types = "array"
+        self.value_schema = :schema
+        self.depends_on = %w[items]
+
+        def evaluate(instance, result)
+          items = result.sibling(instance, "items")
+          return result.discard unless items&.annotation.is_a?(Integer)
+
+          annotation = nil
+          error = []
+
+          instance.each_with_index do |item, index|
+            next if items.annotation >= index
+
+            if json.evaluate(item, result).passed?
+              annotation = true
+            else
+              error << index
+              # reset to passed for the next iteration
+              result.success
+            end
+          end
+
+          if error.any?
+            result.failure(error)
+          else
+            result.annotate(annotation)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/draft_2019_09/items.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Draft201909
+      class Items < Base
+        self.key = "items"
+        self.instance_types = %w[array]
+        self.value_schema = [:schema, :array_of_schemas]
+
+        def evaluate(instance, result)
+          return if instance.empty?
+
+          if json.type == "boolean"
+            json.evaluate(instance, result)
+          elsif json.is_a?(JSONSchema)
+            instance.each do |item|
+              json.evaluate(item, result)
+            end
+            result.annotate(true) if result.passed?
+          elsif json.type == "array"
+            annotation = nil
+            error = []
+
+            instance.take(json.length).each_with_index do |item, index|
+              annotation = index
+              result.call(item, index.to_s) do |subresult|
+                unless json[index].evaluate(item, subresult).passed?
+                  error << index
+                end
+              end
+            end
+            return result.failure(error) unless error.empty?
+
+            result.annotate(annotation)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/draft_2019_09/recursive_anchor.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Draft201909
+      class RecursiveAnchor < Base
+        self.key = "$recursiveAnchor"
+        self.static = true
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/draft_2019_09/recursive_ref.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Draft201909
+      class RecursiveRef < Base
+        self.key = "$recursiveRef"
+
+        def initialize(parent_schema, value)
+          super
+          raise "`$recursiveRef` may only take the value `#`" if value != "#"
+        end
+
+        def resolve
+          base_uri = parent_schema.base_uri
+          if base_uri.nil?
+            raise "No base URI against which to resolve the `$recursiveRef`"
+          end
+
+          @ref_schema = parent_schema.registry.schema(
+            base_uri,
+            metaschema_uri: parent_schema.metaschema_uri,
+            cache_id: parent_schema.cache_id
+          )
+        end
+
+        def evaluate(instance, result)
+          ref_schema = @ref_schema
+          recursive_anchor = ref_schema["$recursiveAnchor"]
+          if recursive_anchor&.value
+            target = result
+            while target
+              base_anchor = target.schema["$recursiveAnchor"]
+              if base_anchor&.value
+                ref_schema = target.schema
+              end
+              target = target.parent
+            end
+          end
+          ref_schema.evaluate(instance, result)
+          result.ref_schema = ref_schema
+        end
+      end
+    end
+  end
+end