json_skooma 0.1.0

data/lib/json_skooma/json_node.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module JSONSkooma
+  class JSONNode < SimpleDelegator
+    extend Memoizable
+
+    attr_reader :parent, :root, :key, :type
+
+    def initialize(value, key: nil, parent: nil, item_class: JSONNode, **item_params)
+      @key = key
+      @parent = parent
+      @root = parent&.root || self
+      @item_class = item_class
+      @item_params = item_params
+      @type, data = parse_value(value)
+
+      super(data)
+    end
+
+    def [](key)
+      case type
+      when "array"
+        super(key.to_i)
+      when "object"
+        super(key.to_s)
+      else
+        raise Error, "Cannot get key #{key} from #{__getobj__.class} in #{path}"
+      end
+    end
+
+    def value
+      case type
+      when "array"
+        map(&:value)
+      when "object"
+        transform_values(&:value)
+      else
+        __getobj__
+      end
+    end
+    memoize :value
+
+    def path
+      result = []
+      each_parent { |node| result.unshift(node.key) }
+      JSONPointer.new(result)
+    end
+    memoize :path
+
+    def ==(other)
+      return super(other.__getobj__) if other.is_a?(self.class)
+      super
+    end
+
+    def !=(other)
+      return super(other.__getobj__) if other.is_a?(self.class)
+      super
+    end
+
+    private
+
+    def each_parent
+      node = self
+
+      while node.parent
+        yield node
+        node = node.parent
+      end
+    end
+
+    def parse_value(value)
+      case value
+      when true, false
+        ["boolean", value]
+      when String
+        ["string", value]
+      when Integer, Float
+        ["number", value]
+      when nil
+        ["null", value]
+      when Hash
+        ["object", map_object_value(value)]
+      when Array
+        ["array", map_array_value(value)]
+      else
+        raise Error, "Unknown JSON type: #{value.class}"
+      end
+    end
+
+    def map_array_value(value)
+      value.map.with_index { |v, i| @item_class.new(v, key: i.to_s, parent: self, **@item_params) }
+    end
+
+    def map_object_value(value)
+      value.map { |k, v| [k.to_s, @item_class.new(v, key: k.to_s, parent: self, **@item_params)] }.to_h
+    end
+  end
+end

data/lib/json_skooma/json_pointer.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "hana"
+require "cgi"
+
+module JSONSkooma
+  class JSONPointer < Hana::Pointer
+    extend Memoizable
+    ESC_REGEX = /[\/^~]/.freeze
+    ESC2 = {"^" => "^^", "~" => "~0", "/" => "~1"}.freeze
+    ESCAPE_REGEX = /([^ a-zA-Z0-9_.\-~\/!$&'()*+,;=]+)/.freeze
+
+    def self.new_root(path)
+      return [""] if path == ""
+
+      parts = ((path.include?("%") || path.include?("+")) ? CGI.unescape(path) : path).split(/(?<!\^)\//).each { |part|
+        part.gsub!(/\^[\/^]|~[01]/) { |m| ESC[m] }
+      }
+
+      parts.push("") if path.end_with?("/")
+
+      new(parts)
+    end
+
+    def initialize(path)
+      if path.is_a?(Array)
+        @path = path
+      else
+        super CGI.unescape(path)
+      end
+    end
+
+    def child(key)
+      self.class.new(@path.dup.push(key))
+    end
+
+    def <<(part)
+      case part
+      when Array
+        @path.concat(part.map(&:to_s))
+      when JSONPointer
+        @path.concat(part.path)
+      else
+        @path << part.to_s
+      end
+      self
+    end
+
+    def to_s
+      return "" if @path == []
+      return "/" if @path == [""]
+
+      "/" + @path.map(&method(:escape)).join("/")
+    end
+
+    memoize :to_s
+
+    def ==(other)
+      return super unless other.is_a?(self.class)
+      other.path == path
+    end
+
+    protected
+
+    attr_reader :path
+
+    private
+
+    def escape(part)
+      string = part.gsub(ESC_REGEX) { |m| ESC2[m] }
+      encoding = string.encoding
+      string.b.gsub!(ESCAPE_REGEX) do |m|
+        "%" + m.unpack("H2" * m.bytesize).join("%").upcase
+      end
+      string.tr!(" ", "+")
+      string.force_encoding(encoding)
+    end
+  end
+end

data/lib/json_skooma/json_schema.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  class JSONSchema < JSONNode
+    extend Memoizable
+
+    attr_reader :uri, :cache_id, :registry
+
+    attr_writer :metaschema_uri
+
+    def initialize(value, registry: Registry::DEFAULT_NAME, cache_id: "default", uri: nil, metaschema_uri: nil, parent: nil, key: nil)
+      super(value, parent: parent, key: key)
+
+      @keywords = {}
+
+      @cache_id = cache_id
+      @registry = Registry[registry]
+      self.metaschema_uri = metaschema_uri.is_a?(String) ? URI.parse(metaschema_uri) : metaschema_uri
+      self.uri = uri.is_a?(String) ? URI.parse(uri) : uri
+
+      return if type != "object"
+
+      self.uri ||= URI("urn:uuid:#{SecureRandom.uuid}") if parent.nil?
+      resolve_keywords(value.transform_keys(&:to_s))
+      resolve_references if parent.nil?
+    end
+
+    def evaluate(instance, result = nil)
+      instance = JSONSkooma::JSONNode.new(instance) unless instance.is_a?(JSONNode)
+
+      result ||= Result.new(self, instance)
+      case value
+      when true
+        # do nothing
+      when false
+        result.failure("The instance is disallowed by a boolean false schema")
+      else
+        @keywords.each do |key, keyword|
+          next if keyword.static || !keyword.instance_types.include?(instance.type)
+
+          result.call(instance, key, self) do |subresult|
+            keyword.evaluate(instance, subresult)
+          end
+        end
+
+        if result.children.any? { |_, child| !child.passed? && child.instance.path == instance.path }
+          result.failure
+        end
+      end
+
+      result
+    end
+
+    def validate
+      metaschema.evaluate(self)
+    end
+
+    def parent_schema
+      node = parent
+      while node
+        return node if node.is_a?(JSONSchema)
+
+        node = node.parent
+      end
+    end
+    memoize :parent_schema
+
+    def uri=(uri)
+      return if @uri == uri
+
+      @base_uri = nil
+      @registry.delete_schema(@uri, cache_id: @cache_id) if @uri
+      @uri = uri
+      @registry.add_schema(@uri, self, cache_id: @cache_id) if @uri
+    end
+
+    def metaschema
+      raise RegistryError, "The schema's metaschema URI has not been set" if metaschema_uri.nil?
+
+      @metaschema ||= @registry.metaschema(metaschema_uri)
+    end
+
+    def metaschema_uri
+      @metaschema_uri || parent_schema&.metaschema_uri
+    end
+    memoize :metaschema_uri
+
+    def base_uri
+      return parent_schema&.base_uri unless uri
+
+      @base_uri ||= uri.dup.tap { |u| u.fragment = nil }
+    end
+
+    def canonical_uri
+      return uri if uri
+
+      keys = []
+      node = self
+      while node.parent
+        keys.unshift(node.key)
+        node = node.parent
+
+        if node.is_a?(JSONSchema) && node.uri
+          fragment = JSONPointer.new(node.uri.fragment || "") << keys
+          return node.uri.dup.tap { |u| u.fragment = fragment.to_s }
+        end
+      end
+    end
+    memoize :canonical_uri
+
+    def resolve_references
+      @keywords.each_value { |kw| kw.resolve }
+    end
+
+    private
+
+    def resolve_keywords(value)
+      bootstrap(value)
+
+      kw_classes = value.keys
+        .reject { |k| @keywords.key?(k) }
+        .map { |k| [k, kw_class(k)] }
+        .to_h
+
+      dependencies_in_order(kw_classes) do |kw_class|
+        add_keyword(kw_class.new(self, value[kw_class.key]))
+      end
+    end
+
+    def bootstrap(value)
+      bootstrap_kw_classes = {
+        "$schema" => Keywords::Core::Schema,
+        "$id" => Keywords::Core::Id
+      }
+
+      bootstrap_kw_classes.each do |key, kw_class|
+        next unless value.key?(key)
+
+        add_keyword(kw_class.new(self, value[key]))
+      end
+    end
+
+    def kw_class(k)
+      metaschema.kw_class(k)
+    end
+
+    def add_keyword(kw)
+      @keywords[kw.key] = kw
+      __getobj__[kw.key] = kw.json
+    end
+
+    def dependencies_in_order(kw_classes)
+      dependencies = kw_classes.map do |_, kw_class|
+        [kw_class, kw_class.depends_on.map { |dep| kw_classes[dep] }.compact]
+      end.to_h
+
+      while dependencies.any?
+        kw_class, _ = dependencies.find { |_, depclasses| depclasses.empty? }
+        dependencies.delete(kw_class)
+        dependencies.each { |_, deps| deps.delete(kw_class) }
+        yield kw_class
+      end
+    end
+
+    def parse_value(value, **options)
+      case value
+      when true, false
+        ["boolean", value]
+      when Hash
+        ["object", {}]
+      else
+        raise TypeError, "#{value} is not JSONSchema-compatible"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class AdditionalProperties < Base
+        self.key = "additionalProperties"
+        self.instance_types = "object"
+        self.value_schema = :schema
+        self.depends_on = %w[properties patternProperties]
+
+        def evaluate(instance, result)
+          known_property_names = result.sibling(instance, "properties")&.schema_node&.keys || []
+          known_property_patterns = result.sibling(instance, "patternProperties")&.schema_node&.keys || []
+
+          annotation = []
+          error = []
+
+          instance.each do |name, item|
+            if !known_property_names.include?(name) && !known_property_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
+              if json.evaluate(item, result).passed?
+                annotation << name
+              else
+                error << name
+                # reset to success for the next iteration
+                result.success
+              end
+            end
+          end
+          return result.annotate(annotation) if error.empty?
+
+          result.failure(error)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class AllOf < Base
+        self.key = "allOf"
+        self.value_schema = :array_of_schemas
+
+        def evaluate(instance, result)
+          err_indices = []
+          json.each.with_index do |subschema, index|
+            result.call(instance, index.to_s) do |subresult|
+              subschema.evaluate(instance, subresult)
+              err_indices << index unless subresult.passed?
+            end
+          end
+          return if err_indices.empty?
+
+          result.failure("The instance is invalid against subschemas #{err_indices}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class AnyOf < Base
+        self.key = "anyOf"
+        self.value_schema = :array_of_schemas
+
+        def evaluate(instance, result)
+          valid = false
+          json.each.with_index do |subschema, index|
+            result.call(instance, index.to_s) do |subresult|
+              subschema.evaluate(instance, subresult)
+              valid = true if subresult.passed?
+            end
+          end
+
+          return if valid
+
+          result.failure("The instance must be valid against at least one subschema")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class Contains < Base
+        self.key = "contains"
+        self.instance_types = "array"
+        self.value_schema = :schema
+
+        def evaluate(instance, result)
+          annotation = []
+          instance.each_with_index do |item, index|
+            if json.evaluate(item, result).passed?
+              annotation << index
+            else
+              result.success
+            end
+          end
+          result.annotate(annotation)
+
+          return if annotation.any?
+
+          result.failure(
+            "The array does not contain any element that is valid against the `#{key}` subschema"
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class DependentSchemas < Base
+        self.key = "dependentSchemas"
+        self.instance_types = "object"
+        self.value_schema = :object_of_schemas
+
+        def evaluate(instance, result)
+          annotation = []
+          err_names = []
+
+          json.each do |name, subschema|
+            next unless instance.key?(name)
+
+            result.call(instance, name) do |subresult|
+              if subschema.evaluate(instance, subresult).passed?
+                annotation << name
+              else
+                err_names << name
+              end
+            end
+          end
+          return result.annotate(annotation) if err_names.none?
+
+          result.failure(
+            "Properties #{err_names} are invalid against the corresponding `dependentSchemas` subschemas"
+          )
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class If < Base
+        self.key = "if"
+        self.value_schema = :schema
+
+        def evaluate(instance, result)
+          json.evaluate(instance, result)
+          result.skip_assertion
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class Items < Base
+        self.key = "items"
+        self.instance_types = %w[array]
+        self.value_schema = :schema
+        self.depends_on = %w[prefixItems]
+
+        def evaluate(instance, result)
+          prefix_items = result.sibling(instance, "prefixItems")
+          start_index = prefix_items&.schema_node&.length || 0
+
+          annotation = nil
+          error = []
+          instance.each_with_index do |item, index|
+            next if index < start_index
+
+            if json.evaluate(item, result).passed?
+              annotation = true
+            else
+              error << index
+              # reset to passed for the next iteration
+              result.success
+            end
+          end
+          return result.annotate(annotation) if error.empty?
+
+          result.failure(error)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class Not < Base
+        self.key = "not"
+        self.value_schema = :schema
+
+        def evaluate(instance, result)
+          json.evaluate(instance, result)
+          return result.success unless result.passed?
+
+          result.failure("The instance must not be valid against the subschema")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class OneOf < Base
+        self.key = "oneOf"
+        self.value_schema = :array_of_schemas
+
+        def evaluate(instance, result)
+          valid_indices = []
+          err_indices = []
+
+          json.each.with_index do |subschema, index|
+            result.call(instance, index.to_s) do |subresult|
+              subschema.evaluate(instance, subresult)
+              if subresult.passed?
+                valid_indices << index
+              else
+                err_indices << index
+              end
+            end
+          end
+
+          return if valid_indices.size == 1
+
+          result.failure(
+            "The instance must be valid against exactly one subschema; " \
+            "it is valid against #{valid_indices} and invalid against #{err_indices}'"
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Applicator
+      class PatternProperties < Base
+        self.key = "patternProperties"
+        self.instance_types = "object"
+        self.value_schema = :object_of_schemas
+
+        def initialize(parent_schema, value)
+          super
+          @patterned = json.map do |pattern, subschema|
+            [Regexp.new(pattern), pattern, subschema]
+          end
+        end
+
+        def evaluate(instance, result)
+          matched_names = Set.new
+          err_names = []
+
+          instance.each do |name, item|
+            @patterned.each do |regexp, pattern, subschema|
+              if regexp.match?(name)
+                result.call(item, pattern) do |subresult|
+                  subschema.evaluate(item, subresult)
+                  if subresult.passed?
+                    matched_names << name
+                  else
+                    err_names << name
+                  end
+                end
+              end
+            end
+          end
+
+          if err_names.any?
+            result.failure("Properties #{err_names} are invalid")
+          else
+            result.annotate(matched_names.to_a)
+          end
+        end
+      end
+    end
+  end
+end