json_skooma 0.1.0

data/lib/json_skooma/keywords/validation/type.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class Type < Base
+        self.key = "type"
+
+        def evaluate(instance, result)
+          return if json.value.include?(instance.type)
+          return if integer?(instance)
+
+          result.failure("The instance must be of type #{json.value}, but was #{instance.type}")
+        end
+
+        private
+
+        def integer?(instance)
+          instance.type == "number" &&
+            json.include?("integer") &&
+            instance == instance.to_i
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/validation/unique_items.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class UniqueItems < Base
+        self.key = "uniqueItems"
+        self.instance_types = "array"
+
+        def evaluate(instance, result)
+          return unless json.value
+
+          if instance.uniq.size != instance.size
+            result.failure("The array's elements must all be unique")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/value_schemas.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module ValueSchemas
+      class << self
+        def [](key)
+          value_schemas&.[](key) or raise "Unknown value schema: #{key}, known schemas: #{value_schemas.keys.inspect}"
+        end
+
+        def register_value_schema(key, klass)
+          (self.value_schemas ||= {})[key] = klass
+        end
+
+        private
+
+        attr_accessor :value_schemas
+      end
+
+      module Schema
+        def wrap_value(value)
+          return super unless value.is_a?(Hash) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+          (self.class.schema_value_class || JSONSchema).new(
+            value,
+            parent: parent_schema,
+            key: key,
+            registry: parent_schema.registry,
+            cache_id: parent_schema.cache_id
+          )
+        end
+
+        def each_schema
+          return super unless json.is_a?(JSONSchema)
+
+          yield json
+        end
+      end
+      register_value_schema(:schema, Schema)
+
+      module ArrayOfSchemas
+        def wrap_value(value)
+          return super unless value.is_a?(Array)
+
+          JSONNode.new(
+            value,
+            parent: parent_schema,
+            key: key,
+            item_class: self.class.schema_value_class || JSONSchema,
+            registry: parent_schema.registry,
+            cache_id: parent_schema.cache_id
+          )
+        end
+
+        def each_schema(&block)
+          return super unless json.type == "array"
+
+          json.each(&block)
+        end
+      end
+
+      register_value_schema(:array_of_schemas, ArrayOfSchemas)
+
+      module ObjectOfSchemas
+        def wrap_value(value)
+          return super unless value.is_a?(Hash)
+
+          JSONNode.new(
+            value,
+            parent: parent_schema,
+            key: key,
+            item_class: self.class.schema_value_class || JSONSchema,
+            registry: parent_schema.registry,
+            cache_id: parent_schema.cache_id
+          )
+        end
+
+        def each_schema(&block)
+          return super unless json.type == "object"
+
+          json.each_value(&block)
+        end
+      end
+      register_value_schema(:object_of_schemas, ObjectOfSchemas)
+    end
+  end
+end

data/lib/json_skooma/memoizable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Memoizable
+    def self.included(base)
+      base.extend(Memoizable)
+    end
+
+    def memoize(method_name)
+      this = respond_to?(:prepend) ? self : singleton_class
+      var_name = "@memoized_#{method_name}"
+      this.prepend(Module.new do
+        define_method(method_name) do
+          return instance_variable_get(var_name) if instance_variable_defined?(var_name)
+
+          instance_variable_set(var_name, super())
+        end
+      end)
+    end
+  end
+end

data/lib/json_skooma/metaschema.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  class Metaschema < JSONSchema
+    attr_accessor :core_vocabulary, :default_vocabularies
+    attr_reader :kw_classes
+
+    def initialize(value, core_vocabulary, *default_vocabularies, **options)
+      @core_vocabulary = core_vocabulary
+      @default_vocabularies = default_vocabularies
+      @kw_classes = {}
+      super(value, cache_id: "__meta__", **options)
+    end
+
+    def kw_class(key)
+      kw_classes[key] ||= Keywords::Unknown[key]
+    end
+
+    private
+
+    def bootstrap(value)
+      super
+
+      kw = Keywords::Core::Vocabulary.new(self, value.fetch("$vocabulary", default_vocabulary_urls))
+      add_keyword(kw) if value.key?("$vocabulary")
+    end
+
+    def default_vocabulary_urls
+      (default_vocabularies + [core_vocabulary]).filter_map(&:uri).map { |uri| [uri.to_s, true] }.to_h
+    end
+  end
+end

data/lib/json_skooma/registry.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  class RegistryError < Error; end
+
+  class Registry
+    class << self
+      attr_accessor :registries
+
+      def [](key)
+        return key if key.is_a?(Registry)
+
+        raise RegistryError, "Registry `#{key}` not found" unless registries.key?(key)
+
+        registries[key]
+      end
+    end
+
+    self.registries = {}
+
+    DEFAULT_NAME = "registry"
+
+    def initialize(name: DEFAULT_NAME)
+      @uri_sources = {}
+      @vocabularies = {}
+      @schema_cache = {}
+      @enabled_formats = Set.new
+
+      self.class.registries[name] = self
+    end
+
+    def add_format(key, validator = nil)
+      JSONSkooma::Validators.register(key, validator) if validator
+      raise RegistryError, "Format validator `#{key}` not found" unless Validators.validators.key?(key)
+
+      @enabled_formats << key
+    end
+
+    def format_enabled?(key)
+      @enabled_formats.include?(key)
+    end
+
+    def add_vocabulary(uri, *keywords)
+      @vocabularies[uri.to_s] = Vocabulary.new(uri, *keywords)
+    end
+
+    def vocabulary(uri)
+      @vocabularies[uri.to_s] or raise RegistryError, "vocabulary #{uri} not found"
+    end
+
+    def add_schema(uri, schema, cache_id: "default")
+      @schema_cache[cache_id] ||= {}
+      @schema_cache[cache_id][uri.to_s] = schema
+    end
+
+    def delete_schema(uri, cache_id: "default")
+      @schema_cache[cache_id].delete(uri.to_s)
+    end
+
+    def schema(uri, metaschema_uri: nil, cache_id: "default", schema_class: JSONSchema, expected_class: JSONSchema)
+      schema = @schema_cache.dig(cache_id, uri.to_s)
+      return schema if schema
+
+      base_uri = uri.dup.tap { |u| u.fragment = nil }
+      schema = @schema_cache.dig(cache_id, base_uri.to_s) if uri.fragment
+
+      if schema.nil?
+        doc = load_json(base_uri)
+
+        schema = schema_class.new(
+          doc,
+          registry: self,
+          cache_id: cache_id,
+          uri: base_uri,
+          metaschema_uri: metaschema_uri
+        )
+        return @schema_cache.dig(cache_id, uri.to_s) if @schema_cache.dig(cache_id, uri.to_s)
+      end
+      schema = JSONPointer.new(uri.fragment).eval(schema) if uri.fragment
+      return schema if schema.is_a?(expected_class)
+
+      raise RegistryError, "The object referenced by #{uri} is not #{expected_class}"
+    end
+
+    def add_metaschema(uri, default_core_vocabulary_uri = nil, *default_vocabulary_uris)
+      metaschema_doc = load_json(uri)
+      default_core_vocabulary = vocabulary(default_core_vocabulary_uri) if default_core_vocabulary_uri
+      default_vocabularies = default_vocabulary_uris.map { |vocabulary_uri| vocabulary(vocabulary_uri) }
+
+      metaschema = Metaschema.new(
+        metaschema_doc,
+        default_core_vocabulary,
+        *default_vocabularies,
+        registry: self,
+        uri: uri
+      )
+
+      return metaschema if metaschema.validate.valid?
+
+      raise RegistryError, "The metaschema is invalid against its own metaschema #{metaschema_doc["$schema"]}"
+    end
+
+    def metaschema(uri)
+      schema = @schema_cache.dig("__meta__", uri.to_s) || add_metaschema(uri.to_s)
+      return schema if schema
+
+      raise RegistryError, "The schema referenced by #{uri} is not a metaschema"
+    end
+
+    def add_source(uri, source)
+      raise RegistryError, "uri must end with '/'" unless uri.end_with?("/")
+
+      @uri_sources[uri] = source
+    end
+
+    private
+
+    def load_json(uri)
+      candidates = @uri_sources
+        .select { |source_uri| uri.to_s.start_with?(source_uri) }
+        .sort_by { |source_uri| -source_uri.length }
+
+      raise RegistryError, "A source is not available for #{uri}" if candidates.empty?
+
+      base_uri, candidate = candidates.first
+      relative_path = uri.to_s.sub(base_uri, "")
+      candidate.call(relative_path)
+    end
+  end
+end

data/lib/json_skooma/result.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  class Result
+    attr_writer :ref_schema
+
+    attr_reader :children, :path, :relative_path, :schema, :instance, :parent, :annotation, :error, :key, :root
+
+    def initialize(schema, instance, parent: nil, key: nil)
+      @schema = schema
+      @instance = instance
+      @parent = parent
+      @root = parent&.root || self
+      @key = key
+      @children = {}
+      @valid = true
+      if parent.nil?
+        @path = JSONPointer.new([])
+        @relative_path = JSONPointer.new([])
+      else
+        @path = parent.path.child(key)
+        @relative_path =
+          if schema.equal?(parent.schema)
+            parent.relative_path.child(key)
+          else
+            JSONPointer.new_root(key)
+          end
+      end
+    end
+
+    def call(instance, key, schema = nil, subclass: self.class)
+      child = subclass.new(schema || @schema, instance, parent: self, key: key)
+
+      yield child
+
+      @children[[key, instance.path]] = child unless child.discard?
+    end
+
+    def schema_node
+      relative_path.eval(schema)
+    end
+
+    def sibling(instance, key)
+      @parent.children[[key, instance.path]] if @parent
+    end
+
+    def annotate(value)
+      @annotation = value
+    end
+
+    def failure(error = nil)
+      @valid = false
+      @error = error
+    end
+
+    def success
+      @valid = true
+      @error = nil
+    end
+
+    def skip_assertion
+      @skip_assertion = true
+    end
+
+    def discard
+      @discard = true
+    end
+
+    def discard?
+      @discard
+    end
+
+    def valid?
+      @valid
+    end
+
+    def passed?
+      @valid || @skip_assertion
+    end
+
+    def absolute_uri
+      return @ref_schema.canonical_uri if @ref_schema
+      return nil if schema.canonical_uri.nil?
+
+      path = JSONPointer.new(schema.canonical_uri.fragment || "") << relative_path
+      schema.canonical_uri.dup.tap { |u| u.fragment = path.to_s }
+    end
+
+    def collect_annotations(instance = nil, key = nil)
+      return if !valid? || discard?
+
+      if @annotation &&
+          (key.nil? || key == @key) &&
+          (instance.nil? || instance.path == @instance.path)
+        yield @annotation
+      end
+
+      @children.each do |_, child|
+        child.collect_annotations(instance, key) do |annotation|
+          yield annotation
+        end
+      end
+    end
+
+    def collect_errors(instance: nil, key: nil)
+      return if valid? || discard?
+
+      if @error &&
+          (key.nil? || key == @key) &&
+          (instance.nil? || instance.path == @instance.path)
+        yield @error
+      end
+
+      @children.each do |_, child|
+        child.collect_errors(instance, key) do |error|
+          yield error
+        end
+      end
+    end
+
+    def output(format, **options)
+      Formatters[format].call(self, **options)
+    end
+  end
+end

data/lib/json_skooma/sources.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "open-uri"
+require "yaml"
+
+module JSONSkooma
+  module Sources
+    class Error < JSONSkooma::Error; end
+
+    class Base
+      def initialize(base, suffix: nil)
+        @base = base
+        @suffix = suffix
+      end
+
+      def call(relative_path)
+        YAML.safe_load(read(relative_path))
+      rescue Psych::SyntaxError
+        raise Error, "Could not parse file #{relative_path}"
+      end
+
+      private
+
+      attr_reader :base, :suffix
+
+      def read(path)
+        raise "Not implemented"
+      end
+    end
+
+    class Local < Base
+      private
+
+      def read(relative_path)
+        path = File.expand_path(relative_path, base)
+        path += suffix if suffix
+        File.read(path)
+      rescue Errno::ENOENT
+        raise Error, "Could not find file #{path}"
+      end
+    end
+
+    class Remote < Base
+      private
+
+      def read(relative_path)
+        path = suffix ? relative_path + suffix : relative_path
+        url = URI.join(base, path)
+        URI.parse(url).open.read
+      rescue OpenURI::HTTPError, SocketError
+        raise Error, "Could not fetch #{url}"
+      end
+    end
+  end
+end

data/lib/json_skooma/validators/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Validators
+    class Base
+      class << self
+        attr_reader :instance_types
+
+        def instance_types=(value)
+          @instance_types = Array(value)
+        end
+
+        def assert?(instance)
+          instance_types.include?(instance.type)
+        end
+
+        def call(instance)
+          new.call(instance)
+        end
+
+        def inherited(subclass)
+          subclass.instance_types = "string"
+        end
+      end
+
+      def call(_instance)
+        raise NotImplementedError, "must be implemented by subclass"
+      end
+    end
+  end
+end

data/lib/json_skooma/validators/date.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Validators
+    class Date < Base
+      REGEXP = /\A#{DateTime::DATE_REGEXP}\z/
+
+      def call(data)
+        match = REGEXP.match(data)
+        raise FormatError, "must be a valid RFC 3339 date string" if match.nil?
+
+        ::Date.new(match[:Y].to_i, match[:M].to_i, match[:D].to_i)
+      rescue ::Date::Error
+        raise FormatError, "must be a valid RFC 3339 date string"
+      end
+    end
+  end
+end

data/lib/json_skooma/validators/date_time.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Validators
+    class DateTime < Base
+      DATE_REGEXP = /(?<Y>\d{4})-(?<M>\d{2})-(?<D>\d{2})/
+      PARTIAL_TIME = /(?<h>[01]\d|2[0-3]):(?<m>[0-5]\d):(?<s>[0-5]\d|60)(?<f>\.\d+)?/
+      TIME_OFFSET = /[Zz]|(?<on>[+-])(?<oh>[01]\d|2[0-3]):(?<om>[0-5]\d)/
+      FULL_TIME = /#{PARTIAL_TIME}#{TIME_OFFSET}/
+
+      REGEXP = /\A(?<date>#{DATE_REGEXP})[Tt](?<time>#{FULL_TIME})\z/
+
+      def call(data)
+        match = REGEXP.match(data)
+        raise FormatError, "must be a valid RFC 3339 date string" if match.nil?
+
+        Date.call(match[:date])
+        Time.call(match[:time])
+      rescue FormatError
+        raise FormatError, "must be a valid RFC 3339 date string"
+      end
+    end
+  end
+end

data/lib/json_skooma/validators/duration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Validators
+    class Duration < Base
+      SECOND = /\d+S/
+      MINUTE = /\d+M#{SECOND}?/
+      HOUR = /\d+H#{MINUTE}?/
+      DAY = /\d+D/
+      WEEK = /\d+W/
+      MONTH = /\d+M#{DAY}?/
+      YEAR = /\d+Y#{MONTH}?/
+      TIME = /T(#{HOUR}|#{MINUTE}|#{SECOND})/
+      DATE = /(#{DAY}|#{MONTH}|#{YEAR})#{TIME}?/
+      DURATION = /P(#{DATE}|#{TIME}|#{WEEK})/
+      REGEXP = /\A#{DURATION}\z/
+
+      def call(data)
+        return if REGEXP.match?(data)
+
+        raise FormatError, "#{data} is not a valid duration"
+      end
+    end
+  end
+end

data/lib/json_skooma/validators/email.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Validators
+    class Email < Base
+      ATOM = /[a-zA-Z0-9!#$%&'*+\-\/=?^_`{|}~]+/
+      DOT_STRING = /#{ATOM}(\.#{ATOM})*/
+      QUOTED_PAIR_SMTP = /\x5C[\x20-\x7E]/
+      QTEXT_SMTP = /[\x20-\x21\x23-\x5B\x5D-\x7E]/
+      Q_CONTENT_SMTP = /#{QTEXT_SMTP}|#{QUOTED_PAIR_SMTP}/
+      QUOTED_STRING = /"(#{Q_CONTENT_SMTP})*"/
+      LOCAL_PART = /#{DOT_STRING}|#{QUOTED_STRING}/
+      LET_DIG = /[a-zA-Z0-9]/
+      LDH_STR = /[a-zA-Z0-9-]*#{LET_DIG}/
+      SUB_DOMAIN = /#{LET_DIG}(#{LDH_STR})?/
+      DOMAIN = /#{SUB_DOMAIN}(\.#{SUB_DOMAIN})*/
+      IPV4 = /((25[0-5]|(2[0-4]|1\d|[1-9])?\d)\.?\b){4}/
+      IPV6_FULL = /IPv6:\h{1,4}(:\h{1,4}){7}/
+      IPV6_COMP = /IPv6:(\h{1,4}(:\h{1,4}){0,5})?::(\h{1,4}(:\h{1,4}){0,5})?/
+      IPV6V4_FULL = /IPv6:\h{1,4}(:\h{1,4}){5}:\d{1,3}(\.\d{1,3}){3}/
+      IPV6V4_COMP = /IPv6:(\h{1,4}(:\h{1,4}){0,3})?::(\h{1,4}(:\h{1,4}){0,3}:)?\d{1,3}(\.\d{1,3}){3}/
+      IPV6 = /#{IPV6_FULL}|#{IPV6_COMP}|#{IPV6V4_FULL}|#{IPV6V4_COMP}/
+      GENERAL_ADDRESS = /#{LDH_STR}:[\x21-\x5A\x5E-\x7E]+/
+      ADDRESS_LITERAL = /\[(#{IPV4}|#{IPV6}|#{GENERAL_ADDRESS})\]/
+      MAILBOX = /#{LOCAL_PART}@(#{DOMAIN}|#{ADDRESS_LITERAL})/
+
+      REGEXP = /\A#{MAILBOX}\z/
+
+      def call(data)
+        return if REGEXP.match?(data)
+
+        raise FormatError, "#{data} is not a valid email"
+      end
+    end
+  end
+end

data/lib/json_skooma/validators/hostname.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Validators
+    class Hostname < Base
+      HOSTNAME = /(?=.{1,253}\.?\z)[a-z\d](?:[a-z\d-]{0,61}[a-z\d])?(?:\.[a-z\d](?:[a-z\d-]{0,61}[a-z\d])?)*\.?/
+
+      REGEXP = /\A#{HOSTNAME}\z/i
+
+      def call(data)
+        return if REGEXP.match?(data.value)
+
+        raise FormatError, "#{data} is not a valid hostname"
+      end
+    end
+  end
+end

data/lib/json_skooma/validators/idn_email.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Validators
+    class IdnEmail < Base
+      UTF8_NON_ASCII = /[\u0080-\u{10FFFF}]/
+      ATOM = /([a-zA-Z0-9!#$%&'*+\-\/=?^_`{|}~]|#{UTF8_NON_ASCII})+/
+      DOT_STRING = /#{ATOM}(\.#{ATOM})*/
+      QTEXT_SMTP = /[\x20-\x21\x23-\x5B\x5D-\x7E]|#{UTF8_NON_ASCII}/
+      Q_CONTENT_SMTP = /#{QTEXT_SMTP}|#{Email::QUOTED_PAIR_SMTP}/
+      QUOTED_STRING = /"(#{Q_CONTENT_SMTP})*"/
+      LOCAL_PART = /#{DOT_STRING}|#{QUOTED_STRING}/
+      LET_DIG = /[a-zA-Z0-9\u0080-\u{10FFFF}]/
+      LDH_STR = /[a-zA-Z0-9\u0080-\u{10FFFF}-]*#{LET_DIG}/
+      SUB_DOMAIN = /#{LET_DIG}(#{LDH_STR})?/
+      DOMAIN = /#{SUB_DOMAIN}(\.#{SUB_DOMAIN})*/
+      GENERAL_ADDRESS = /#{LDH_STR}:[\x21-\x5A\x5E-\x7E]+/
+      ADDRESS_LITERAL = /\[(#{Email::IPV4}|#{Email::IPV6}|#{GENERAL_ADDRESS})\]/
+      MAILBOX = /#{LOCAL_PART}@(#{DOMAIN}|#{ADDRESS_LITERAL})/
+
+      REGEXP = /\A#{MAILBOX}\z/
+
+      def call(data)
+        return if REGEXP.match?(data.value)
+
+        raise FormatError, "#{data} is not a valid IDN email"
+      end
+    end
+  end
+end