json_skooma 0.1.0

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Draft201909
+      class UnevaluatedItems < Base
+        self.key = "unevaluatedItems"
+        self.instance_types = %w[array]
+        self.value_schema = :schema
+        self.depends_on = %w[
+          items additionalItems
+          if then else allOf anyOf oneOf not
+        ]
+
+        def evaluate(instance, result)
+          last_evaluated_item = -1
+
+          result.parent.collect_annotations(instance, "items") do |i|
+            next result.discard if i == true
+
+            last_evaluated_item = i if i > last_evaluated_item
+          end
+
+          result.parent.collect_annotations(instance, "additionalItems") do |i|
+            next result.discard if i == true
+          end
+
+          result.parent.collect_annotations(instance, "unevaluatedItems") do |i|
+            next result.discard if i == true
+          end
+
+          annotation = nil
+          error = []
+
+          instance.each_with_index do |item, index|
+            next if last_evaluated_item >= 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/format_annotation/format.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module FormatAnnotation
+      class Format < Base
+        self.key = "format"
+
+        def initialize(parent_schema, value)
+          super
+          if parent_schema.registry.format_enabled?(value)
+            @validator = Validators.validators[value]
+          end
+        end
+
+        def evaluate(instance, result)
+          result.annotate(json)
+          return result.skip_assertion unless @validator&.assert?(instance)
+
+          @validator.call(instance)
+        rescue Validators::FormatError => e
+          result.failure("The instance is invalid against the #{json.value} format: #{e}")
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/meta_data/default.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module MetaData
+      class Default < BaseAnnotation
+        self.key = "default"
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/meta_data/deprecated.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module MetaData
+      class Deprecated < BaseAnnotation
+        self.key = "deprecated"
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/meta_data/description.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module MetaData
+      class Description < BaseAnnotation
+        self.key = "description"
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/meta_data/examples.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module MetaData
+      class Examples < BaseAnnotation
+        self.key = "examples"
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/meta_data/read_only.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module MetaData
+      class ReadOnly < BaseAnnotation
+        self.key = "readOnly"
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/meta_data/title.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module MetaData
+      class Title < BaseAnnotation
+        self.key = "title"
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/meta_data/write_only.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module MetaData
+      class WriteOnly < BaseAnnotation
+        self.key = "writeOnly"
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/unevaluated/unevaluated_items.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Unevaluated
+      class UnevaluatedItems < Base
+        self.key = "unevaluatedItems"
+        self.instance_types = %w[array]
+        self.value_schema = :schema
+        self.depends_on = %w[
+          prefixItems items contains
+          if then else allOf anyOf oneOf not
+        ]
+
+        def evaluate(instance, result)
+          last_evaluated_item = -1
+
+          result.parent.collect_annotations(instance, "prefixItems") do |i|
+            next result.discard if i == true
+
+            last_evaluated_item = i if i > last_evaluated_item
+          end
+
+          result.parent.collect_annotations(instance, "items") do |i|
+            next result.discard if i == true
+          end
+
+          result.parent.collect_annotations(instance, "unevaluatedItems") do |i|
+            next result.discard if i == true
+          end
+
+          contains_indices = Set.new
+          result.parent.collect_annotations(instance, "contains") { |i| contains_indices += Set.new(i) }
+          annotation = nil
+          error = []
+
+          instance.each_with_index do |item, index|
+            next if last_evaluated_item >= index
+            next if contains_indices.include?(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/unevaluated/unevaluated_properties.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Unevaluated
+      class UnevaluatedProperties < Base
+        self.key = "unevaluatedProperties"
+        self.instance_types = %w[object]
+        self.value_schema = :schema
+        self.depends_on = %w[
+          properties patternProperties additionalProperties
+          if then else dependentSchemas allOf anyOf oneOf not
+        ]
+
+        def evaluate(instance, result)
+          evaluated_names = Set.new
+          result.parent.collect_annotations(instance, "properties") { |name| evaluated_names += Set.new(name) }
+          result.parent.collect_annotations(instance, "patternProperties") { |name| evaluated_names += Set.new(name) }
+          result.parent.collect_annotations(instance, "additionalProperties") { |name| evaluated_names += Set.new(name) }
+          result.parent.collect_annotations(instance, "unevaluatedProperties") { |name| evaluated_names += Set.new(name) }
+
+          annotation = []
+          error = []
+          instance.each do |name, item|
+            next if evaluated_names.include?(name)
+
+            if json.evaluate(item, result).passed?
+              annotation << name
+            else
+              error << name
+              # reset to success for the next iteration
+              result.success
+            end
+          end
+
+          return result.failure(error) if error.any?
+
+          result.annotate(annotation)
+        end
+      end
+    end
+  end
+end

data/lib/json_skooma/keywords/unknown.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Unknown
+      class << self
+        def [](key)
+          @unknown_keywords ||= {}
+          @unknown_keywords[key] ||= Class.new(Keywords::Base) do
+            self.key = key
+
+            def evaluate(instance, result)
+              result.annotate(json.value)
+              result.skip_assertion
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class Const < Base
+        self.key = "const"
+
+        def evaluate(instance, result)
+          return if instance == json
+
+          result.failure("The instance value #{instance.value.inspect} must be equal to the defined constant #{json.value.inspect}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class DependentRequired < Base
+        self.key = "dependentRequired"
+        self.instance_types = "object"
+
+        def evaluate(instance, result)
+          missing = {}
+          json.each do |name, dependents|
+            next unless instance.key?(name)
+
+            missing_deps = dependents.reject { |dep| instance.key?(dep) }
+            missing[name] = missing_deps if missing_deps.any?
+          end
+
+          result.failure("The object is missing dependent properties #{missing}") if missing.any?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class Enum < Base
+        self.key = "enum"
+
+        def evaluate(instance, result)
+          return if json.include?(instance)
+
+          result.failure(
+            "The instance value #{instance.value.inspect} must be equal to one of the elements in the defined enumeration: #{json.value}"
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class ExclusiveMaximum < Base
+        self.key = "exclusiveMaximum"
+        self.instance_types = "number"
+
+        def evaluate(instance, result)
+          if instance >= json
+            result.failure("The value must be less than #{json.value})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class ExclusiveMinimum < Base
+        self.key = "exclusiveMinimum"
+        self.instance_types = "number"
+
+        def evaluate(instance, result)
+          if instance <= json
+            result.failure("The value must be greater than #{json.value})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class MaxContains < Base
+        self.key = "maxContains"
+        self.instance_types = %w[array]
+        self.depends_on = %w[contains]
+
+        def evaluate(instance, result)
+          contains = result.sibling(instance, "contains")
+          return if contains.nil?
+
+          if contains.annotation && contains.annotation.length > json
+            result.failure(
+              "The array has too many elements matching the contains subschema (maximum #{json.value})"
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class MaxItems < Base
+        self.key = "maxItems"
+        self.instance_types = "array"
+
+        def evaluate(instance, result)
+          if instance.length > json
+            result.failure("The array has too many elements (maximum #{json.value})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class MaxLength < Base
+        self.key = "maxLength"
+        self.instance_types = "string"
+
+        def evaluate(instance, result)
+          if instance.length > json
+            result.failure("The text is too long (maximum #{json.value} characters))")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class MaxProperties < Base
+        self.key = "maxProperties"
+        self.instance_types = "object"
+
+        def evaluate(instance, result)
+          if instance.length > json
+            result.failure("The object has too many properties (maximum #{json.value})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class Maximum < Base
+        self.key = "maximum"
+        self.instance_types = "number"
+
+        def evaluate(instance, result)
+          if instance > json
+            result.failure("The value may not be greater than #{json.value})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class MinContains < Base
+        self.key = "minContains"
+        self.instance_types = %w[array]
+        self.depends_on = %w[contains maxContains]
+
+        def evaluate(instance, result)
+          contains = result.sibling(instance, "contains")
+          return if contains.nil?
+
+          contains_count = contains.annotation&.count || 0
+
+          valid = contains_count >= json
+
+          if valid && !contains.valid?
+            max_contains = result.sibling(instance, "maxContains")
+            contains.success if !max_contains || max_contains.valid?
+          end
+
+          return if valid
+
+          result.failure("The array has too few elements matching the `contains` subschema (minimum #{json.value})")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class MinItems < Base
+        self.key = "minItems"
+        self.instance_types = "array"
+
+        def evaluate(instance, result)
+          if instance.length < json
+            result.failure("The array has too few elements (minimum #{json.value})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class MinLength < Base
+        self.key = "minLength"
+        self.instance_types = "string"
+
+        def evaluate(instance, result)
+          if instance.length < json
+            result.failure("The text is too short (minimum #{json.value} characters))")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class MinProperties < Base
+        self.key = "minProperties"
+        self.instance_types = "object"
+
+        def evaluate(instance, result)
+          if instance.length < json
+            result.failure("The object has too few properties (minimum #{json.value})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class Minimum < Base
+        self.key = "minimum"
+        self.instance_types = "number"
+
+        def evaluate(instance, result)
+          if instance < json
+            result.failure("The value may not be less than #{json.value})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class MultipleOf < Base
+        self.key = "multipleOf"
+        self.instance_types = "number"
+
+        def evaluate(instance, result)
+          if BigDecimal(instance.value.to_s).modulo(BigDecimal(json.value.to_s)).nonzero?
+            result.failure("The value must be a multiple of #{json.value}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class Pattern < Base
+        self.key = "pattern"
+        self.instance_types = %w[string]
+
+        def initialize(parent_schema, value)
+          super
+          @regexp = Regexp.new(value)
+        end
+
+        def evaluate(instance, result)
+          return if @regexp.match(instance)
+
+          result.failure("The text must match the regular expression #{json.value}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module JSONSkooma
+  module Keywords
+    module Validation
+      class Required < Base
+        self.key = "required"
+        self.instance_types = "object"
+
+        def evaluate(instance, result)
+          missing_keys = json - instance.keys
+          return if missing_keys.empty?
+
+          result.failure("The object is missing required properties #{json.value}")
+        end
+      end
+    end
+  end
+end