simple_json_schema 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd9171c82ee82f6182b25f9e8cb4d6f139dce7ff84d66131a9ea50c3c9728197
-  data.tar.gz: 4b9fbb3fe5dc2101a66dfe70a46d11d368ecd7811aa7056f18c1d4dc91f27b7d
+  metadata.gz: 8bfd995209a8432bc92730f10961b61d8d9e0d1e3cd1aaf06432d76654dd7d66
+  data.tar.gz: 043f347f1c497be224fcefdd153b23bb16024410d8d8865555c6dd752d28a2f2
 SHA512:
-  metadata.gz: 557d9a88155358cffb6e13e2b4ca2b9036ad2d38f60f61ab4692080f72a4d19028d63981a4cb965aeb735def558d2b2697d00cb057577c93769200ee7f78e916
-  data.tar.gz: 8f57abf5721f17ff7695c5372554b1c35a6e91b273e85b3becffdbfda225e677130dc2eae5761e1d5fc269b5d9f5936f981a9eeb427e10a745e3b97dad99a2a7
+  metadata.gz: 016b1db271f0eada2ef8dd65ccc2eaf89294685231fe6645578b8959e20011a6418e9176333c6b1ff9f9f455d309cc232177a7b1958f7e9f84fc88994b668b77
+  data.tar.gz: 3c8e6f11c651ccd1537eaf5ecfb010125f837568bce1d9b07bfebd431ad5eb09c7760e8f43b1ffb62c24977276e3b9959372b2152c012a23e19f17aa81c766a2

data/.rubocop.yml

@@ -7,7 +7,6 @@ AllCops:
   SuggestExtensions: false
   TargetRubyVersion: 2.6
   Exclude:
-    - bin/**/*
     - vendor/ruby/**/*
     - .irbrc
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple_json_schema (0.1.3)
+    simple_json_schema (0.1.4)
       activesupport (~> 6.0)
       addressable (~> 2.7)
       ecma-re-validator (~> 0.3)

data/README.md

@@ -4,7 +4,7 @@
 [![coverage report](https://gitlab.com/vliper/simple_json_schema/badges/master/coverage.svg)](https://gitlab.com/vliper/simple_json_schema/-/commits/master)
 [![Gem Version](https://badge.fury.io/rb/simple_json_schema.svg)](https://badge.fury.io/rb/simple_json_schema)
 
-This implementation of the JSON Schema validation is based on the [JSONSchemer](https://github.com/davishmcclurg/json_schemer) (whit is the recommended to be used), but only implement the Draft7, whit [limitations](https://gitlab.com/vliper/simple_json_schema/-/blob/master/spec/simple_json_schema/json_schema_test_suite_spec.rb#L15) and some feature embedded.
+This implementation of the JSON Schema validation is based on the [JSONSchemer](https://github.com/davishmcclurg/json_schemer) (WHIT IS THE RECOMMENDED TO BE USED!), but only implement the Draft7, whit [limitations](https://gitlab.com/vliper/simple_json_schema/-/blob/master/spec/simple_json_schema/json_schema_test_suite_spec.rb#L26) and some feature embedded.
 
 # Installation
 
@@ -64,10 +64,18 @@ Whit options is possible to improve the behavior.
 | ---- | ----------- | ------- | -------------- |
 | after_property_validation | Call after validate a Property | nil | Proc to receive Scope object |
 | before_property_validation | Call before validate a Property | nil | Proc to receive Scope object |
-| cache | The object to do the cache for schema (future) and regex | {} per execution | any object whit implement fetch(name) { callback } |
+| cache | The object to do the cache for schema ref and regex | Cache class per execution | any object whit implement fetch(name) { callback } |
 | cast | Cast the values | false | true/false |
 | insert_defaults | Insert the default property if not defined at the validation | false | true/false |
 
+#### Extra attributes
+Some extra implementations on types (THIS IS NOT ON THE DRAFT7 DEFINITION!)
+
+| Type | Attribute | Description | Allowed values |
+| string | required | Will evaluate the `blank?` concept on the string | true/false |
+| integer | required | Will enforce value != 0 | true/false |
+| number | required | Will enforce value != 0.0 | true/false |
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/simple_json_schema

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'pry-byebug'
+
+require 'simple_json_schema'
+require 'json'
+
+if ARGV.size != 2
+  puts 'simple_json_schema <JSON_DATA> <JSON_SCHEMA>'
+  exit(1)
+end
+
+data = JSON.parse(ARGV[0])
+schema = JSON.parse(ARGV[1])
+
+valid = SimpleJSONSchema.valid(data, schema, resolver: proc do |uri|
+  if uri.host == 'localhost'
+    # Resolve localhost test schemas
+    path = Pathname.new(__dir__).join('..', 'spec', 'json-schema-test-suite', 'remotes', uri.path.delete_prefix('/'))
+    JSON.parse(path.read)
+  else
+    JSON.parse(::Net::HTTP.get(uri))
+  end
+end)
+
+if valid.empty?
+  puts 'valid!'
+else
+  puts valid
+end

data/lib/simple_json_schema.rb

@@ -2,6 +2,8 @@
 
 require 'simple_json_schema/version'
 
+require 'net/http'
+
 require 'active_support/core_ext/hash'
 require 'addressable/template'
 require 'ecma-re-validator'
@@ -17,10 +19,13 @@ require 'simple_json_schema/validators/number'
 require 'simple_json_schema/validators/string'
 
 require 'simple_json_schema/concerns/hash_acessor'
+require 'simple_json_schema/uri_extender'
+require 'simple_json_schema/cache'
 require 'simple_json_schema/checker'
 require 'simple_json_schema/items_helper'
 require 'simple_json_schema/properties_helper'
 require 'simple_json_schema/regex_helper'
+require 'simple_json_schema/ref_helper'
 require 'simple_json_schema/scope'
 require 'simple_json_schema/validator'
 
@@ -31,6 +36,7 @@ module SimpleJSONSchema
     'http://json-schema.org/draft-07/schema#' => :draft7
   }.freeze
 
+  NET_HTTP_REF_RESOLVER = proc { |uri| JSON.parse(Net::HTTP.get(uri)) }
   DEFAULT_SCHEMA = 'http://json-schema.org/draft-07/schema#'
 
   class << self
@@ -48,6 +54,8 @@ module SimpleJSONSchema
       scope = Scope.new(data: data, schema: schema, draft: draft_class(schema), options: options)
       Validator.validate(scope)
       scope.errors
+    rescue StandardError => e
+      scope.error(:invalid, exception: e.message)
     end
 
     private

data/lib/simple_json_schema/cache.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  class Cache
+    attr_reader :memory
+
+    def initialize
+      @memory = {}
+    end
+
+    def fetch(key)
+      memory[key] ||= yield
+    end
+  end
+end

data/lib/simple_json_schema/checker.rb

@@ -2,20 +2,24 @@
 
 module SimpleJSONSchema
   module Checker
+    JSON_POINTER_REGEX_STRING = '(\/([^~\/]|~[01])*)*'
+    JSON_POINTER_REGEX = /\A#{JSON_POINTER_REGEX_STRING}\z/.freeze
+    RELATIVE_JSON_POINTER_REGEX = /\A(0|[1-9]\d*)(#|#{JSON_POINTER_REGEX_STRING})?\z/.freeze
+
     class << self
       def at_value(scope, check, operation)
         over = scope[check]
-        scope.error(check) if over && scope.value&.public_send(operation, over)
+        scope.error(check, fail_on: "#{operation} #{over}") 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)
+        scope.error(check, fail_on: "#{operation} #{over}") if over && scope.value&.size&.public_send(operation, over)
       end
 
-      def required(scope)
+      def required_keys(scope)
         required = scope[:required]
-        return unless required
+        return unless required.is_a?(Array)
 
         missing_keys = required - scope.value.keys
         scope.error(:required, missing_keys: missing_keys) if missing_keys.any?
@@ -36,6 +40,14 @@ module SimpleJSONSchema
 
         scope.error(:const) if scope.key?(:const) && scope[:const] != scope.value
       end
+
+      def json_pointer?(value)
+        JSON_POINTER_REGEX.match?(value)
+      end
+
+      def relative_json_pointer?(value)
+        RELATIVE_JSON_POINTER_REGEX.match?(value)
+      end
     end
   end
 end

data/lib/simple_json_schema/concerns/hash_acessor.rb

@@ -3,7 +3,7 @@
 module SimpleJSONSchema
   module Concerns
     module HashAccessor
-      def hash_accessor(hash_name, *accessors)
+      def hash_accessor(hash_name, accessors)
         define_method(hash_name) do
           instance_variable_get("@#{hash_name}") ||
             instance_variable_set("@#{hash_name}", {})

data/lib/simple_json_schema/properties_helper.rb

@@ -4,11 +4,25 @@ module SimpleJSONSchema
   module PropertiesHelper
     class << self
       def checkers(scope)
-        Checker.required(scope)
+        Checker.required_keys(scope)
         Checker.at_size(scope, :maxProperties, :>)
         Checker.at_size(scope, :minProperties, :<)
       end
 
+      def each_dependency(scope)
+        dependencies = scope[:dependencies]
+        return unless dependencies.is_a?(Hash)
+
+        value = scope.value
+        return unless value.is_a?(Hash)
+
+        dependencies.each_key do |dependency|
+          next unless value.key?(dependency)
+
+          yield([:dependencies, dependency])
+        end
+      end
+
       def processe_defualt(scope)
         return unless scope.options[:insert_defaults] == true
 

data/lib/simple_json_schema/ref_helper.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  module RefHelper
+    INTEGER_REGEX = /\A-?\d+\Z/.freeze
+    POINTER_SPLIT = %r{(?<!\^)/}.freeze
+    POINTER_GSUB = %r{\^[/^]|~[01]}.freeze
+    POINTER_ESC = { '^/' => '/', '^^' => '^', '~0' => '~', '~1' => '/' }.freeze
+    RefPointer = Struct.new(:ref_paths, :segment, :segment_paths, :parent_uri, keyword_init: true)
+
+    class << self
+      def pointer(scope)
+        ref = scope[:$ref]
+        return nil if ref.nil?
+
+        if ref.start_with?('#')
+          local_ref(scope, ref[1..])
+        else
+          ref_uri = URIExtender.join_uri(scope.parent_uri, ref)
+          if (id = scope.loaded_ids[ref_uri.to_s])
+            return RefPointer.new(ref_paths: id[:schema_paths], segment: id[:schema], parent_uri: ref_uri)
+          end
+
+          uri_ref(scope, ref_uri)
+        end
+      end
+
+      private
+
+      def local_ref(scope, ref)
+        return RefPointer.new unless Checker.json_pointer?(ref)
+
+        paths, parent_uri = path_of_ref(scope.schema, ref)
+        RefPointer.new(ref_paths: paths, parent_uri: parent_uri || scope.parent_uri)
+      end
+
+      def uri_ref(scope, ref_uri)
+        segment = resolver_uri(scope, ref_uri)
+        reref_base(segment, scope.schema_paths)
+        segment_paths, parent_uri = path_of_ref(segment, ref_uri.fragment) if Checker.json_pointer?(ref_uri.fragment)
+
+        RefPointer.new(ref_paths: scope.schema_paths, segment: segment,
+                       segment_paths: segment_paths || [], parent_uri: parent_uri || ref_uri)
+      end
+
+      def resolver_uri(scope, uri)
+        schema = scope.cache.fetch(uri.to_s) do
+          if (resolver = scope.options[:resolver]) && resolver.respond_to?(:call)
+            resolver.call(uri)
+          else
+            JSON.parse(::Net::HTTP.get(uri))
+          end
+        end
+
+        schema.is_a?(Hash) ? schema.with_indifferent_access : schema
+      end
+
+      def path_of_ref(schema, ref)
+        paths = decoded_ref(ref)
+        parent_uri = pointer_uri(schema, paths)
+        [paths, parent_uri]
+      end
+
+      def decoded_ref(pointer)
+        URI.decode_www_form_component(pointer).split(POINTER_SPLIT).map do |part|
+          if INTEGER_REGEX.match?(part)
+            part.to_i
+          else
+            part.gsub(POINTER_GSUB) { |m| POINTER_ESC[m] }
+          end
+        end.reject(&:blank?)
+      end
+
+      def pointer_uri(schema, paths)
+        uri_parts = nil
+
+        paths.reduce(schema) do |obj, token|
+          next obj.fetch(token.to_i) if obj.is_a?(Array)
+
+          if (obj_id = obj[:$id])
+            uri_parts ||= []
+            uri_parts << obj_id
+          end
+          obj.fetch(token)
+        end
+        uri_parts ? URI.join(*uri_parts) : nil
+      end
+
+      def reref_base(schema, paths)
+        return if schema.nil? || paths.empty?
+
+        nested_ref_replace_value(schema) do
+          "#/#{paths.join('/')}"
+        end
+      end
+
+      def nested_ref_replace_value(object, &block)
+        if object.respond_to?(:key?) && object.key?(:$ref) && object[:$ref].start_with?('#')
+          object[:$ref] = yield()
+        elsif object.respond_to?(:each)
+          r = nil
+          object.find { |*a| r = nested_ref_replace_value(a.last, &block) }
+          r
+        end
+      end
+    end
+  end
+end

data/lib/simple_json_schema/scope.rb

@@ -13,7 +13,7 @@ module SimpleJSONSchema
       String => 'string'
     }.freeze
 
-    hash_accessor :scope, :data, :schema, :type, :draft, :data_paths, :schema_paths, :errors, :options
+    hash_accessor :scope, %i[data schema type draft data_paths schema_paths errors parent_uri ids options]
 
     def initialize(**args)
       scope.merge!(args)
@@ -21,15 +21,25 @@ module SimpleJSONSchema
       self.data_paths ||= []
       self.schema_paths ||= []
       self.errors ||= []
+      self.ids ||= {}
       self.options ||= {}
       self.type ||= evaluate_type
     end
 
     def path_to(data_path: nil, schema_path: nil, type: nil)
+      return self if 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))
+      merge(data_paths: new_data_paths, schema_paths: new_schema_paths, type: type)
+    end
+
+    def merge(data_paths: self.data_paths, schema_paths: self.schema_paths, type: nil, parent_uri: nil)
+      self.class.new(scope.merge(data_paths: data_paths,
+                                 schema_paths: schema_paths,
+                                 type: type,
+                                 parent_uri: parent_uri || URIExtender.join_uri(self.parent_uri, id)))
     end
 
     def replace_data(new_data)
@@ -53,6 +63,11 @@ module SimpleJSONSchema
       errors.push(error)
     end
 
+    def only_cache
+      self.options = { cache: cache }
+      self
+    end
+
     def value
       dig(data, data_paths)
     end
@@ -60,27 +75,15 @@ module SimpleJSONSchema
     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
+      replace(data, data_paths, new_value) { self.data = new_value }
     end
 
     def segment
-      @segment ||= dig(schema, schema_paths)
-    end
-
-    def [](key)
-      return unless segment.is_a?(Hash)
-
-      segment[key]
+      dig(schema, schema_paths)
     end
 
-    def key?(key)
-      segment.is_a?(Hash) && segment.key?(key)
+    def segment=(new_segment)
+      replace(schema, schema_paths, new_segment) { self.schema = new_segment }
     end
 
     def segment?
@@ -92,8 +95,22 @@ module SimpleJSONSchema
       !(segment == true || segment.nil?)
     end
 
+    def id
+      self[:$id]
+    end
+
+    def [](key)
+      return unless segment.is_a?(Hash)
+
+      segment[key]
+    end
+
+    def key?(key)
+      segment.is_a?(Hash) && segment.key?(key)
+    end
+
     def cache
-      options[:cache] ||= {}
+      options[:cache] ||= Cache.new
     end
 
     def around_hooks
@@ -102,11 +119,19 @@ module SimpleJSONSchema
       options[:after_property_validation]&.call(self)
     end
 
+    def loaded_ids
+      if ids.empty?
+        resolve_ids(ids, schema)
+        ids[:$loaded] = true
+      end
+      ids
+    end
+
     private
 
     def evaluate_type
       if key?(:type)
-        segment[:type]
+        self[:type]
       else
         CLASS_TYPE_TRANSLATE[value.class]
       end
@@ -119,5 +144,34 @@ module SimpleJSONSchema
     rescue TypeError
       nil
     end
+
+    def replace(hash, paths, value)
+      *steps, leaf = paths
+
+      if steps.empty?
+        if leaf.nil?
+          yield if block_given?
+        else
+          hash[leaf] = value
+        end
+      else
+        hash.dig(*steps)[leaf] = value
+      end
+    end
+
+    def resolve_ids(ids, schema, parent_uri = nil, schema_paths = [])
+      case schema
+      when Array
+        schema.each_with_index { |subschema, index| resolve_ids(ids, subschema, parent_uri, schema_paths + [index]) }
+      when Hash
+        uri = URIExtender.join_uri(parent_uri, schema[:$id])
+
+        schema.each do |key, value|
+          ids[uri.to_s] = { schema: schema, schema_paths: schema_paths } if key == '$id' && uri != parent_uri
+
+          resolve_ids(ids, value, uri, schema_paths + [key])
+        end
+      end
+    end
   end
 end

data/lib/simple_json_schema/uri_extender.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SimpleJSONSchema
+  module URIExtender
+    class << self
+      def join_uri(base, complement)
+        complement = URI.parse(complement) if complement
+
+        if base && complement
+          return complement if base.relative? && complement.relative?
+
+          URI.join(base, complement)
+        else
+          complement || base
+        end
+      end
+    end
+  end
+end

data/lib/simple_json_schema/validator.rb

@@ -13,10 +13,86 @@ module SimpleJSONSchema
     class << self
       def validate(scope)
         return unless scope.segment?
+        return if validate_ref(scope)
 
         Checker.enum(scope)
         Checker.const(scope)
 
+        validate_correlations(scope)
+        validate_by_type(scope)
+      end
+
+      private
+
+      def validate?(scope)
+        scope.errors = []
+
+        validate(scope.only_cache)
+        scope.errors.none?
+      end
+
+      def validate_ref(scope)
+        ref_pointer = RefHelper.pointer(scope)
+        return if ref_pointer.nil?
+
+        new_scope = scope.merge(schema_paths: ref_pointer.ref_paths, parent_uri: ref_pointer.parent_uri)
+        new_scope.segment = ref_pointer.segment unless ref_pointer.segment.nil?
+        validate(new_scope.path_to(schema_path: ref_pointer.segment_paths))
+        true
+      end
+
+      def validate_correlations(scope)
+        validate_all_of(scope)
+        validate_any_of(scope)
+        validate_one_of(scope)
+        validate_not(scope)
+        validate_if_then_else(scope)
+      end
+
+      def validate_all_of(scope)
+        scope[:allOf]&.each_index do |index|
+          validate(scope.path_to(schema_path: [:allOf, index]).only_cache)
+        end
+      end
+
+      def validate_any_of(scope)
+        any_of = scope[:anyOf]
+        return if any_of.nil?
+        return if any_of.each_index.any? { |index| validate?(scope.path_to(schema_path: [:anyOf, index])) }
+
+        any_of.each_index { |index| validate(scope.path_to(schema_path: [:anyOf, index]).only_cache) }
+      end
+
+      def validate_one_of(scope)
+        one_of = scope[:oneOf]
+        return if one_of.nil?
+
+        valid_count = one_of.each_index.count { |index| validate?(scope.path_to(schema_path: [:oneOf, index])) }
+
+        if valid_count > 1
+          scope.error(:oneOf)
+        elsif valid_count.zero?
+          one_of.each_index { |index| validate(scope.path_to(schema_path: [:oneOf, index]).only_cache) }
+        end
+      end
+
+      def validate_not(scope)
+        return unless scope.key?(:not)
+
+        scope.error(:not) if validate?(scope.path_to(schema_path: :not))
+      end
+
+      def validate_if_then_else(scope)
+        return unless scope.key?(:if)
+
+        if validate?(scope.path_to(schema_path: :if))
+          validate(scope.path_to(schema_path: :then)) if scope.key?(:then)
+        elsif scope.key?(:else)
+          validate(scope.path_to(schema_path: :else))
+        end
+      end
+
+      def validate_by_type(scope)
         case scope.type
         when 'object'
           valid_object(scope)
@@ -29,33 +105,37 @@ module SimpleJSONSchema
         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)
+        return scope.error(:object) unless scope.value.is_a?(Hash)
 
         PropertiesHelper.processe_defualt(scope)
         PropertiesHelper.checkers(scope)
 
+        valid_object_dependencies(scope)
+        valid_object_property_names(scope)
+        valid_object_properties(scope)
+      end
+
+      def valid_object_dependencies(scope)
+        PropertiesHelper.each_dependency(scope) do |schema_path|
+          new_scope = scope.path_to(schema_path: schema_path)
+          new_scope.segment = { required: new_scope.segment } if new_scope.segment.is_a?(Array)
+          validate(new_scope)
+        end
+      end
+
+      def valid_object_property_names(scope)
         PropertiesHelper.each_property_name(scope) do |property_name|
           validate(scope.path_to(schema_path: :propertyNames).replace_data(property_name))
         end
+      end
 
-        value.each_key do |property_name|
+      def valid_object_properties(scope)
+        scope.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

data/lib/simple_json_schema/validators/concerns/format.rb

@@ -8,9 +8,6 @@ module SimpleJSONSchema
         EMAIL_REGEX = /\A[^@\s]+@([\p{L}\d-]+\.)+[\p{L}\d\-]{2,}\z/i.freeze
         LABEL_REGEX_STRING = '[\p{L}\p{N}]([\p{L}\p{N}\-]*[\p{L}\p{N}])?'
         HOSTNAME_REGEX = /\A(#{LABEL_REGEX_STRING}\.)*#{LABEL_REGEX_STRING}\z/i.freeze
-        JSON_POINTER_REGEX_STRING = '(\/([^~\/]|~[01])*)*'
-        JSON_POINTER_REGEX = /\A#{JSON_POINTER_REGEX_STRING}\z/.freeze
-        RELATIVE_JSON_POINTER_REGEX = /\A(0|[1-9]\d*)(#|#{JSON_POINTER_REGEX_STRING})?\z/.freeze
         DATE_TIME_OFFSET_REGEX = /(Z|[+\-]([01][0-9]|2[0-3]):[0-5][0-9])\z/i.freeze
         INVALID_QUERY_REGEX = /[[:space:]]/.freeze
         ASCII_REGEX = /[^[:ascii:]]/.freeze
@@ -57,9 +54,9 @@ module SimpleJSONSchema
           # when 'uri-template'
           #   valid_uri_template?(value)
           when 'json-pointer'
-            JSON_POINTER_REGEX.match?(value)
+            Checker.json_pointer?(value)
           when 'relative-json-pointer'
-            RELATIVE_JSON_POINTER_REGEX.match?(value)
+            Checker.relative_json_pointer?(value)
           when 'regex'
             EcmaReValidator.valid?(value)
           end

data/lib/simple_json_schema/validators/string.rb

@@ -9,6 +9,7 @@ module SimpleJSONSchema
         value = scope.value
 
         return scope.error(:string) unless value.is_a?(::String)
+        return scope.error(:blank) if scope[:required] == true && value.blank?
 
         Checker.at_size(scope, :maxLength, :>)
         Checker.at_size(scope, :minLength, :<)

data/lib/simple_json_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleJSONSchema
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_json_schema
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Georgeo Rocco
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-22 00:00:00.000000000 Z
+date: 2021-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -187,13 +187,17 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- bin/simple_json_schema
 - lib/simple_json_schema.rb
+- lib/simple_json_schema/cache.rb
 - lib/simple_json_schema/checker.rb
 - lib/simple_json_schema/concerns/hash_acessor.rb
 - lib/simple_json_schema/items_helper.rb
 - lib/simple_json_schema/properties_helper.rb
+- lib/simple_json_schema/ref_helper.rb
 - lib/simple_json_schema/regex_helper.rb
 - lib/simple_json_schema/scope.rb
+- lib/simple_json_schema/uri_extender.rb
 - lib/simple_json_schema/validator.rb
 - lib/simple_json_schema/validators/base.rb
 - lib/simple_json_schema/validators/boolean.rb