simple_json_schema 0.1.3

data/lib/simple_json_schema/checker.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  module Checker
+    class << self
+      def at_value(scope, check, operation)
+        over = scope[check]
+        scope.error(check) if over && scope.value&.public_send(operation, over)
+      end
+
+      def at_size(scope, check, operation)
+        over = scope[check]
+        scope.error(check) if over && scope.value&.size&.public_send(operation, over)
+      end
+
+      def required(scope)
+        required = scope[:required]
+        return unless required
+
+        missing_keys = required - scope.value.keys
+        scope.error(:required, missing_keys: missing_keys) if missing_keys.any?
+      end
+
+      def unique_items(scope)
+        value = scope.value
+        scope.error(:uniqueItems) if scope[:uniqueItems] && value.size != value.uniq.size
+      end
+
+      def enum(scope)
+        enum = scope[:enum]
+        scope.error(:enum) if enum && !enum.include?(scope.value)
+      end
+
+      def const(scope)
+        return if scope.segment.is_a?(Array)
+
+        scope.error(:const) if scope.key?(:const) && scope[:const] != scope.value
+      end
+    end
+  end
+end

data/lib/simple_json_schema/concerns/hash_acessor.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  module Concerns
+    module HashAccessor
+      def hash_accessor(hash_name, *accessors)
+        define_method(hash_name) do
+          instance_variable_get("@#{hash_name}") ||
+            instance_variable_set("@#{hash_name}", {})
+        end
+
+        accessors.each do |name|
+          define_method(name) do
+            instance_variable_get("@#{hash_name}")[name]
+          end
+
+          define_method("#{name}=") do |value|
+            instance_variable_get("@#{hash_name}")[name] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_json_schema/items_helper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  module ItemsHelper
+    class << self
+      def checkers(scope)
+        Checker.at_size(scope, :maxItems, :>)
+        Checker.at_size(scope, :minItems, :<)
+        Checker.unique_items(scope)
+      end
+
+      def contains_in_items?(scope, &block)
+        contains = scope[:contains]
+        return if contains.nil?
+
+        scope.error(:contains) unless scope.value.each_index.any?(&block)
+      end
+
+      def each_path(scope)
+        items = scope[:items]
+        additional_items = scope[:additionalItems]
+        many_types = items.is_a?(Array)
+
+        scope.value.each_index do |index|
+          if many_types
+            if index < items.size
+              yield [:items, index], index
+            elsif !additional_items.nil?
+              yield [:additionalItems], index
+            else
+              break # protect over big arrays.
+            end
+          else
+            yield [:items], index
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_json_schema/properties_helper.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  module PropertiesHelper
+    class << self
+      def checkers(scope)
+        Checker.required(scope)
+        Checker.at_size(scope, :maxProperties, :>)
+        Checker.at_size(scope, :minProperties, :<)
+      end
+
+      def processe_defualt(scope)
+        return unless scope.options[:insert_defaults] == true
+
+        properties = scope[:properties]
+        return unless properties
+
+        value = scope.value
+        properties.each do |property_name, property_schema|
+          if !value.key?(property_name) && property_schema.is_a?(Hash) && property_schema.key?('default')
+            value[property_name] = property_schema.fetch('default').clone
+          end
+        end
+      end
+
+      def each_property_name(scope, &block)
+        property_names = scope[:propertyNames]
+        return if property_names.nil?
+
+        scope.value.each_key(&block)
+      end
+
+      def map_property_schema_path(scope, property_name)
+        paths = []
+        paths << [:properties, property_name] if scope[:properties]&.key?(property_name)
+
+        if scope.key?(:patternProperties)
+          select_patten_properties(scope, property_name).each do |pattern|
+            paths << [:patternProperties, pattern]
+          end
+        end
+
+        paths << [:additionalProperties] if paths.empty? && scope.key?(:additionalProperties)
+        paths
+      end
+
+      private
+
+      def select_patten_properties(scope, property_name)
+        scope[:patternProperties].keys.select do |pattern|
+          RegexHelper.ecma_262_regex(pattern, scope.cache).match?(property_name)
+        end
+      end
+    end
+  end
+end

data/lib/simple_json_schema/regex_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  module RegexHelper
+    RUBY_REGEX_ANCHORS_TO_ECMA_262 = {
+      bos: 'A',
+      eos: 'z',
+      bol: '\A',
+      eol: '\z'
+    }.freeze
+
+    class << self
+      def ecma_262_regex(pattern, cache)
+        cache.fetch(pattern) do
+          Regexp.new(
+            Regexp::Scanner.scan(pattern).map do |type, token, text|
+              type == :anchor ? RUBY_REGEX_ANCHORS_TO_ECMA_262.fetch(token, text) : text
+            end.join
+          )
+        end
+      end
+    end
+  end
+end

data/lib/simple_json_schema/scope.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  class Scope
+    extend Concerns::HashAccessor
+
+    CLASS_TYPE_TRANSLATE = {
+      Array => 'array',
+      Float => 'number',
+      Hash => 'object',
+      Integer => 'integer',
+      Numeric => 'number',
+      String => 'string'
+    }.freeze
+
+    hash_accessor :scope, :data, :schema, :type, :draft, :data_paths, :schema_paths, :errors, :options
+
+    def initialize(**args)
+      scope.merge!(args)
+
+      self.data_paths ||= []
+      self.schema_paths ||= []
+      self.errors ||= []
+      self.options ||= {}
+      self.type ||= evaluate_type
+    end
+
+    def path_to(data_path: nil, schema_path: nil, type: nil)
+      new_data_paths = data_paths + [data_path].flatten.compact
+      new_schema_paths = schema_paths + [schema_path].flatten.compact
+
+      self.class.new(scope.merge(data_paths: new_data_paths, schema_paths: new_schema_paths, type: type))
+    end
+
+    def replace_data(new_data)
+      self.data = new_data
+      self.data_paths = []
+      self.type = evaluate_type
+      self
+    end
+
+    def error(type, details = nil)
+      error = {
+        type: type,
+        segment: segment,
+        value: value,
+        data_pointer: "/#{data_paths.join('/')}",
+        schema_pointer: "/#{schema_paths.join('/')}"
+      }
+
+      error[:details] = details if details
+
+      errors.push(error)
+    end
+
+    def value
+      dig(data, data_paths)
+    end
+
+    def value=(new_value)
+      return if errors.any? # only convert value until be invalid.
+
+      *steps, leaf = data_paths
+
+      if steps.empty?
+        data[leaf] = new_value
+      else
+        data.dig(*steps)[leaf] = new_value
+      end
+    end
+
+    def segment
+      @segment ||= dig(schema, schema_paths)
+    end
+
+    def [](key)
+      return unless segment.is_a?(Hash)
+
+      segment[key]
+    end
+
+    def key?(key)
+      segment.is_a?(Hash) && segment.key?(key)
+    end
+
+    def segment?
+      if segment == false
+        error('schema')
+        return false
+      end
+
+      !(segment == true || segment.nil?)
+    end
+
+    def cache
+      options[:cache] ||= {}
+    end
+
+    def around_hooks
+      options[:before_property_validation]&.call(self)
+      yield
+      options[:after_property_validation]&.call(self)
+    end
+
+    private
+
+    def evaluate_type
+      if key?(:type)
+        segment[:type]
+      else
+        CLASS_TYPE_TRANSLATE[value.class]
+      end
+    end
+
+    def dig(hash, paths)
+      return hash if paths.empty?
+
+      hash.dig(*paths) if hash.respond_to?(:dig)
+    rescue TypeError
+      nil
+    end
+  end
+end

data/lib/simple_json_schema/validator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  class Validator
+    VALIDATORES = {
+      'null' => Validators::Null.new,
+      'boolean' => Validators::Boolean.new,
+      'integer' => Validators::Integer.new,
+      'number' => Validators::Number.new,
+      'string' => Validators::String.new
+    }.freeze
+
+    class << self
+      def validate(scope)
+        return unless scope.segment?
+
+        Checker.enum(scope)
+        Checker.const(scope)
+
+        case scope.type
+        when 'object'
+          valid_object(scope)
+        when 'array'
+          valid_array(scope)
+        when Array
+          scope.error(:type) unless scope.type.any? { |type| validate?(scope.path_to(type: type)) }
+        else
+          validate_base_types(scope)
+        end
+      end
+
+      private
+
+      def validate?(scope)
+        scope.errors = []
+        scope.options = { cache: scope.cache }
+
+        validate(scope)
+        scope.errors.none?
+      end
+
+      def validate_base_types(scope)
+        VALIDATORES[scope.type]&.valid(scope)
+      end
+
+      def valid_object(scope)
+        value = scope.value
+
+        return scope.error(:object) unless value.is_a?(Hash)
+
+        PropertiesHelper.processe_defualt(scope)
+        PropertiesHelper.checkers(scope)
+
+        PropertiesHelper.each_property_name(scope) do |property_name|
+          validate(scope.path_to(schema_path: :propertyNames).replace_data(property_name))
+        end
+
+        value.each_key do |property_name|
+          PropertiesHelper.map_property_schema_path(scope, property_name).each do |schema_path|
+            new_scope = scope.path_to(schema_path: schema_path, data_path: property_name)
+            new_scope.around_hooks do
+              validate(new_scope)
+            end
+          end
+        end
+      end
+
+      def valid_array(scope)
+        value = scope.value
+        return scope.error(:array) unless value.is_a?(Array)
+
+        ItemsHelper.checkers(scope)
+
+        ItemsHelper.contains_in_items?(scope) do |index|
+          validate?(scope.path_to(schema_path: :contains, data_path: index))
+        end
+
+        ItemsHelper.each_path(scope) do |path, index|
+          validate(scope.path_to(schema_path: path, data_path: index))
+        end
+      end
+    end
+  end
+end

data/lib/simple_json_schema/validators/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  module Validators
+    class Base
+      def valid(scope)
+        cast(scope) if scope.options[:cast] == true
+        validate(scope)
+      end
+
+      private
+
+      def validate(scope)
+        raise NotImplementedError
+      end
+
+      def cast(scope)
+        value = casting(scope.value)
+        scope.value = value unless value.nil? && scope.value != value
+      end
+
+      def casting(value); end
+    end
+  end
+end

data/lib/simple_json_schema/validators/boolean.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  module Validators
+    class Boolean < Base
+      TRUE_VALUES  = ['true', '1', 1, 'yes'].freeze
+      FALSE_VALUES = ['false', '0', 0, 'no'].freeze
+
+      BOOLEANS = Set[true, false].freeze
+
+      def validate(scope)
+        value = scope.value
+
+        return scope.error(:boolean) unless BOOLEANS.include?(value)
+      end
+
+      def casting(value)
+        return true if TRUE_VALUES.include?(value)
+        return false if FALSE_VALUES.include?(value)
+      end
+    end
+  end
+end