yaml-schema 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 162c65cfdc841b1a41db7d8f5d865b51a145361bfd1623723d73ad8c8fd7030a
-  data.tar.gz: 6a64e47154f5ed2c8910c588add2c5ff4bceeadea4240ccd3469b52277f5fe9f
+  metadata.gz: df10b8348eda9fb9eb5d36af1119234e00b48a4d1e5ef7f104d9fade49f02493
+  data.tar.gz: 0d208c8b1883843586bd30c9de3cb5cafb6a65e8978eb495902d34e5c660462f
 SHA512:
-  metadata.gz: 1223fa2441b84f33b57c1f826658de489b2d36a4d76de7dd9770832f4a5c12e815aeabbc242d557a76c6f074ab1d344610e1131dd9ea86144ded4c54ac740e23
-  data.tar.gz: 3c6758c8c5efec97b10d02ade2bc25c8fe9f7f4301b01602333c0178bd57804f4db3fbb24c390139a8e12981a88a85de72686d1efc628e1ddd086ca8e4b7952c
+  metadata.gz: f345acb0e18034d923671d42507b3851a9735a41254e9bbd34caf2b6c9f89007e161fdf6b65844bd69528c40488db44ff341894aba73522622beae059d7c56c2
+  data.tar.gz: 847b358731e0a6acaa24964bed4d58849ccc3da6e6440b95ff143396e16f79adeadd58b0a1a00f1cbf7d61ce6ec7eaff231a18653a0693170f671d07d3abaf78

data/README.md

@@ -83,6 +83,42 @@ schema = {
 }
 ```
 
+### Compiled Validators
+
+If you validate many documents against the same schema, you can compile the
+schema into a validator class specialized for it, rather than interpreting
+the schema on every call:
+
+```ruby
+PersonValidator = YAMLSchema::Compiler.compile(schema)
+
+PersonValidator.validate(node)          # raises on error, returns true otherwise
+PersonValidator.invalid?(node)          # returns the error, or false
+PersonValidator.validate(node, aliases: false)
+PersonValidator.new(node_info).validate(node)
+```
+
+Compiled validators raise the same exceptions with the same messages as
+`YAMLSchema::Validator`. The schema itself is validated at compile time.
+
+You can also generate Ruby source and check it into your project:
+
+```ruby
+File.write "person_validator.rb",
+  YAMLSchema::Compiler.to_ruby(schema, class_name: "PersonValidator")
+```
+
+Pass `standalone: true` to generate a validator that doesn't depend on
+yaml-schema at all. Stand-alone validators define their own exception classes
+(`PersonValidator::UnexpectedType`, etc., all subclasses of
+`PersonValidator::Exception`) instead of raising `YAMLSchema::Validator`
+exceptions:
+
+```ruby
+File.write "person_validator.rb",
+  YAMLSchema::Compiler.to_ruby(schema, class_name: "PersonValidator", standalone: true)
+```
+
 ## Error Handling
 
 Validation errors include detailed path information:

data/lib/yaml-schema/compiler.rb

@@ -0,0 +1,538 @@
+# frozen_string_literal: true
+
+module YAMLSchema
+  ##
+  # Base class for validators generated by YAMLSchema::Compiler.  Subclasses
+  # implement a private +_validate_root+ method that returns +nil+ when the
+  # node is valid, or an exception object describing the first error.
+  class CompiledValidator
+    UnexpectedType       = Validator::UnexpectedType
+    UnexpectedProperty   = Validator::UnexpectedProperty
+    UnexpectedTag        = Validator::UnexpectedTag
+    UnexpectedValue      = Validator::UnexpectedValue
+    UnexpectedAlias      = Validator::UnexpectedAlias
+    InvalidString        = Validator::InvalidString
+    InvalidPattern       = Validator::InvalidPattern
+    MissingRequiredField = Validator::MissingRequiredField
+
+    ##
+    # Validate +node+, raising an exception if it is invalid.
+    def self.validate node, aliases: true
+      self::INSTANCE.validate node, aliases: aliases
+    end
+
+    ##
+    # Validate +node+, returning the error if it is invalid, otherwise false.
+    def self.invalid? node, aliases: true
+      self::INSTANCE.invalid? node, aliases: aliases
+    end
+
+    def initialize node_info = Validator::NodeInfo
+      @node_info = node_info
+    end
+
+    ##
+    # Validate +node+, raising an exception if it is invalid.
+    def validate node, aliases: true
+      err = _validate_root(node, {}, [], aliases)
+      raise err if err
+      true
+    end
+
+    ##
+    # Validate +node+, returning the error if it is invalid, otherwise false.
+    def invalid? node, aliases: true
+      _validate_root(node, {}, [], aliases) || false
+    end
+
+    include Runtime
+  end
+
+  ##
+  # Compiles a schema into a Ruby class specialized for validating that
+  # schema.  The generated class behaves like YAMLSchema::Validator, but
+  # doesn't need to interpret the schema at validation time:
+  #
+  #   validator = YAMLSchema::Compiler.compile(schema)
+  #   validator.validate(node)
+  #
+  # The generated source can also be written to a file:
+  #
+  #   File.write "my_validator.rb", YAMLSchema::Compiler.to_ruby(schema, class_name: "MyValidator")
+  class Compiler
+    EMPTY_SCHEMA = {}.freeze # :nodoc:
+
+    ##
+    # Compile +schema+ and return a new validator class.
+    def self.compile schema
+      klass = Class.new(CompiledValidator)
+      klass.class_eval new(schema).body, "(yaml-schema compiled validator)", 1
+      klass
+    end
+
+    ##
+    # Compile +schema+ and return Ruby source code defining a validator
+    # class named +class_name+.
+    #
+    # By default the generated class inherits from
+    # YAMLSchema::CompiledValidator and requires this library at runtime.
+    # Pass <tt>standalone: true</tt> to generate a class with no dependency
+    # on yaml-schema.  Stand-alone validators define their own exception
+    # classes (e.g. <tt>MyValidator::UnexpectedType</tt>) rather than
+    # raising YAMLSchema::Validator exceptions.
+    def self.to_ruby schema, class_name:, standalone: false
+      body = new(schema).body
+
+      if standalone
+        body = standalone_support + "\n" + body
+        header = ""
+        superclass = ""
+      else
+        header = "\nrequire \"yaml-schema\"\n"
+        superclass = " < YAMLSchema::CompiledValidator"
+      end
+
+      <<~RUBY
+        # frozen_string_literal: true
+        # Generated by yaml-schema #{VERSION}. Do not edit.
+        #{header}
+        class #{class_name}#{superclass}
+        #{body.gsub(/^(?=.)/, "  ")}end
+      RUBY
+    end
+
+    STANDALONE_API = <<~'RUBY' # :nodoc:
+      class Exception < StandardError; end
+      class UnexpectedType < Exception; end
+      class UnexpectedProperty < Exception; end
+      class UnexpectedTag < Exception; end
+      class UnexpectedValue < Exception; end
+      class UnexpectedAlias < Exception; end
+      class InvalidString < Exception; end
+      class InvalidPattern < Exception; end
+      class MissingRequiredField < Exception; end
+
+      module NodeInfo
+        def self.read_tag node
+          node.tag
+        end
+      end
+
+      ##
+      # Validate +node+, raising an exception if it is invalid.
+      def self.validate node, aliases: true
+        INSTANCE.validate node, aliases: aliases
+      end
+
+      ##
+      # Validate +node+, returning the error if it is invalid, otherwise false.
+      def self.invalid? node, aliases: true
+        INSTANCE.invalid? node, aliases: aliases
+      end
+
+      def initialize node_info = NodeInfo
+        @node_info = node_info
+      end
+
+      ##
+      # Validate +node+, raising an exception if it is invalid.
+      def validate node, aliases: true
+        err = _validate_root(node, {}, [], aliases)
+        raise err if err
+        true
+      end
+
+      ##
+      # Validate +node+, returning the error if it is invalid, otherwise false.
+      def invalid? node, aliases: true
+        _validate_root(node, {}, [], aliases) || false
+      end
+    RUBY
+
+    # Source for everything a stand-alone validator needs: exception
+    # classes, the public API, and the shared runtime support code.
+    def self.standalone_support # :nodoc:
+      src = File.read(File.join(__dir__, "runtime.rb"))
+      runtime = src[/^[ \t]*# :runtime-begin:\n(.*?)^[ \t]*# :runtime-end:\n/m, 1] or
+        raise "runtime markers not found"
+      width = runtime.scan(/^[ \t]*(?=\S)/).map(&:length).min
+      runtime = runtime.gsub(/^[ \t]{#{width}}/, "")
+
+      STANDALONE_API + "\npublic\n\n" + runtime + "\npublic\n"
+    end
+
+    def initialize schema
+      Validator::INSTANCE.validate_schema!(schema)
+      @schema    = schema
+      @methods   = []
+      @constants = []
+      @names     = {}.compare_by_identity
+      @key_names = {}.compare_by_identity # schemas forced to "string" (property names)
+      @counter   = 0
+    end
+
+    ##
+    # Ruby source for the body of the validator class.
+    def body
+      root = schema_method(@schema, "")
+      src = +""
+      @constants.each { |c| src << c << "\n" }
+      src << "\n" unless @constants.empty?
+      src << "private\n\n"
+      src << "def _validate_root(node, aliases, path, allow_aliases)\n"
+      src << "  #{root}(node, aliases, path, allow_aliases)\n"
+      src << "end\n"
+      @methods.each { |m| src << "\n" << m }
+      src << "\npublic\n\nINSTANCE = new.freeze\n"
+      src
+    end
+
+    private
+
+    def lit str
+      str.dump
+    end
+
+    def next_name prefix
+      @counter += 1
+      "#{prefix}#{@counter}"
+    end
+
+    def indent code, n
+      pad = " " * n
+      code.gsub(/^(?=.)/, pad)
+    end
+
+    # Returns the name of a method that fully validates a node against
+    # +schema+ (alias resolution, tag lookup, and type checks).  Schemas are
+    # memoized by identity so shared sub-schemas share a method.
+    def schema_method schema, path, forced_type = nil
+      memo = forced_type ? @key_names : @names
+      return memo[schema] if memo.key?(schema)
+
+      name = memo[schema] = next_name("_v")
+      type = forced_type || schema["type"]
+
+      src = +""
+      src << "# #{path.empty? ? "/" : path}\n"
+      src << "def #{name}(node, aliases, path, allow_aliases)\n"
+      src << indent(<<~RUBY, 2)
+        if node.anchor
+          if node.alias?
+            raise UnexpectedAlias unless allow_aliases
+            node = aliases[node.anchor]
+          else
+            aliases[node.anchor] = node
+          end
+        end
+
+        tag = @node_info.read_tag(node)
+      RUBY
+
+      if Array === type
+        # Unions return the first success, or the last failure
+        type.each_with_index do |t, i|
+          tname = "#{name}_#{t}"
+          @methods << "def #{tname}(node, tag, aliases, path, allow_aliases)\n" +
+            indent(type_body(t, schema, path), 2) +
+            "end\n"
+          if i == type.length - 1
+            src << "  #{tname}(node, tag, aliases, path, allow_aliases)\n"
+          else
+            src << "  return unless #{tname}(node, tag, aliases, path, allow_aliases)\n"
+          end
+        end
+      else
+        src << indent(type_body(type, schema, path), 2)
+      end
+      src << "end\n"
+
+      @methods << src
+      name
+    end
+
+    # Code for validating +node+ (already alias-resolved, with +tag+ read)
+    # as +type+.  Returns an error with +return+, and evaluates to nil on
+    # success.
+    def type_body type, schema, path
+      src = +tag_check(type, schema)
+
+      case type
+      when "object" then src << object_body(schema, path)
+      when "array"  then src << array_body(schema, path)
+      else               src << scalar_body(type, schema)
+      end
+
+      src << "nil\n"
+    end
+
+    def tag_check type, schema
+      expected = schema["tag"] if type == "object"
+
+      if expected
+        <<~RUBY
+          unless tag == #{lit expected}
+            if node.tag
+              return make_error(UnexpectedTag, #{lit "expected tag #{expected.dump}, but got "} + node.tag.dump, path)
+            else
+              return make_error(UnexpectedTag, #{lit "expected tag #{expected.dump}, but none specified"}, path)
+            end
+          end
+
+        RUBY
+      else
+        <<~RUBY
+          if tag
+            return make_error(UnexpectedTag, "expected no tag, but got " + node.tag.dump, path)
+          end
+
+        RUBY
+      end
+    end
+
+    # Validate a child node, pushing +segment+ on to the path for the
+    # duration of the call.
+    def child_call meth, node_expr, segment_expr
+      <<~RUBY
+        path.push(#{segment_expr})
+        err = #{meth}(#{node_expr}, aliases, path, allow_aliases)
+        path.pop
+        return err if err
+      RUBY
+    end
+
+    def object_body schema, path
+      src = +<<~RUBY
+        unless node.mapping?
+          return make_error(UnexpectedType, "expected Mapping, got " + node.class.name.dump, path)
+        end
+
+        children = node.children
+        len = children.length
+        i = 0
+      RUBY
+
+      if schema["properties"]
+        properties = schema["properties"]
+        key_meth = schema_method(schema["propertyNames"] || EMPTY_SCHEMA, "#{path}/propertyNames", "string")
+
+        unknown = if schema["additionalProperties"]
+          meth = schema_method(schema["additionalProperties"], "#{path}/additionalProperties")
+          child_call(meth, "val", "key.value")
+        else
+          <<~RUBY
+            path.push(key.value)
+            err = make_error(UnexpectedProperty, "unknown property " + key.value.dump, path)
+            path.pop
+            return err
+          RUBY
+        end
+
+        seen = properties.keys.each_with_index.map { |_, idx| "seen_#{idx}" }
+        seen.each { |s| src << "#{s} = false\n" }
+
+        src << <<~RUBY
+          while i < len
+            key = children[i]
+            val = children[i + 1]
+            i += 2
+
+            err = #{key_meth}(key, aliases, path, allow_aliases)
+            return err if err
+
+        RUBY
+
+        if properties.empty?
+          src << indent(unknown, 2)
+        else
+          src << "  case key.value\n"
+          properties.each_with_index do |(name, sub), idx|
+            meth = schema_method(sub, "#{path}/properties/#{name}")
+            src << "  when #{lit name}\n"
+            src << "    if #{seen[idx]}\n"
+            src << indent(unknown, 6)
+            src << "    else\n"
+            src << "      #{seen[idx]} = true\n"
+            src << indent(child_call(meth, "val", lit(name)), 6)
+            src << "    end\n"
+          end
+          src << "  else\n"
+          src << indent(unknown, 4)
+          src << "  end\n"
+        end
+        src << "end\n"
+
+        required = Array(schema["required"])
+        checks = properties.keys.each_with_index.select { |name, _| required.include?(name) }
+        unless checks.empty?
+          src << "\nmissing = nil\n"
+          checks.each do |name, idx|
+            src << "(missing ||= []) << #{lit name.dump} unless #{seen[idx]}\n"
+          end
+          src << <<~RUBY
+            if missing
+              return make_error(MissingRequiredField, "missing fields " + missing.join(" "), path)
+            end
+          RUBY
+        end
+      else
+        key_meth = schema_method(EMPTY_SCHEMA, "#{path}/propertyNames", "string")
+        meth = schema_method(schema["items"], "#{path}/items")
+        src << <<~RUBY
+          while i < len
+            key = children[i]
+            val = children[i + 1]
+            i += 2
+
+            err = #{key_meth}(key, aliases, path, allow_aliases)
+            return err if err
+
+          #{indent(child_call(meth, "val", "key.value"), 2)}end
+        RUBY
+      end
+
+      src
+    end
+
+    def array_body schema, path
+      src = +<<~RUBY
+        unless node.sequence?
+          return make_error(UnexpectedType, "expected Sequence, got " + node.class.name.dump, path)
+        end
+
+        children = node.children
+        len = children.length
+
+      RUBY
+
+      if max = schema["maxItems"]
+        src << <<~RUBY
+          if len > #{max}
+            return make_error(UnexpectedValue, #{lit "expected maximum #{max} items, but found "} + len.to_s, path)
+          end
+
+        RUBY
+      end
+
+      if min = schema["minItems"]
+        src << <<~RUBY
+          if len < #{min}
+            return make_error(UnexpectedValue, #{lit "expected minimum #{min} items, but found "} + len.to_s, path)
+          end
+
+        RUBY
+      end
+
+      if schema["items"]
+        meth = schema_method(schema["items"], "#{path}/items")
+        src << <<~RUBY
+          i = 0
+          while i < len
+          #{indent(child_call(meth, "children[i]", "i"), 2)}  i += 1
+          end
+        RUBY
+      else
+        schema["prefixItems"].each_with_index do |sub, idx|
+          meth = schema_method(sub, "#{path}/prefixItems/#{idx}")
+          src << "if len > #{idx}\n"
+          src << indent(child_call(meth, "children[#{idx}]", idx.to_s), 2)
+          src << "end\n"
+        end
+      end
+
+      src
+    end
+
+    def pattern_constant pattern
+      name = "PATTERN_#{@constants.length}"
+      @constants << "#{name} = Regexp.new(#{lit pattern.source}, #{pattern.options})"
+      name
+    end
+
+    def scalar_body type, schema
+      src = +<<~RUBY
+        unless node.scalar?
+          return make_error(UnexpectedType, "expected Scalar, got " + node.class.name.dump, path)
+        end
+
+        value = node.value
+      RUBY
+
+      pattern = schema["pattern"]
+
+      if type == "string"
+        src << <<~RUBY
+          unless node.quoted || node.tag == "!str"
+            found = extract_type(value)
+            if found != :string
+              return make_error(UnexpectedValue, "expected string, got " + found.to_s, path)
+            end
+          end
+        RUBY
+
+        if max = schema["maxLength"]
+          src << <<~RUBY
+            if value.bytesize > #{max}
+              return make_error(InvalidString, #{lit "expected string length to be <= #{max}"}, path)
+            end
+          RUBY
+        end
+
+        if min = schema["minLength"]
+          src << <<~RUBY
+            if value.bytesize < #{min}
+              return make_error(InvalidString, #{lit "expected string length to be >= #{min}"}, path)
+            end
+          RUBY
+        end
+
+        if pattern
+          src << <<~RUBY
+            unless value.match?(#{pattern_constant(pattern)})
+              return make_error(InvalidPattern, "expected string '" + value.dump + #{lit "' to match #{pattern}"}, path)
+            end
+          RUBY
+        end
+      else
+        src << <<~RUBY
+          if node.quoted
+            return make_error(UnexpectedValue, #{lit "expected #{type}, got string"}, path)
+          end
+        RUBY
+
+        if type == "null"
+          src << <<~RUBY
+            unless value == ""
+              return make_error(UnexpectedValue, "expected empty string, got " + value.dump, path)
+            end
+          RUBY
+        else
+          if pattern
+            src << <<~RUBY
+              unless value.match?(#{pattern_constant(pattern)})
+                return make_error(InvalidPattern, "expected '" + value.dump + #{lit "' to match #{pattern}"}, path)
+              end
+            RUBY
+          end
+
+          if type == "boolean"
+            src << <<~RUBY
+              unless value == "false" || value == "true"
+                return make_error(UnexpectedValue, "expected 'true' or 'false' for boolean", path)
+              end
+            RUBY
+          else
+            src << <<~RUBY
+              found = extract_type(value)
+              unless found == #{type.to_sym.inspect}
+                return make_error(UnexpectedValue, #{lit "expected #{type}, got "} + found.to_s, path)
+              end
+            RUBY
+          end
+        end
+      end
+
+      src
+    end
+  end
+end

data/lib/yaml-schema/runtime.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module YAMLSchema
+  ##
+  # Support code shared by YAMLSchema::Validator and compiled validators.
+  #
+  # The code between the runtime markers is also copied verbatim into
+  # stand-alone validators generated by YAMLSchema::Compiler.to_ruby, so it
+  # must not refer to anything else in this library.
+  module Runtime
+    # :runtime-begin:
+    # Taken from http://yaml.org/type/timestamp.html
+    TIME = /^-?\d{4}-\d{1,2}-\d{1,2}(?:[Tt]|\s+)\d{1,2}:\d\d:\d\d(?:\.\d*)?(?:\s*(?:Z|[-+]\d{1,2}:?(?:\d\d)?))?$/
+
+    # Taken from http://yaml.org/type/float.html
+    # Base 60, [-+]inf and NaN are handled separately
+    FLOAT = /^(?:[-+]?([0-9][0-9_,]*)?\.[0-9]*([eE][-+][0-9]+)?(?# base 10))$/x
+
+    # Taken from http://yaml.org/type/int.html and modified to ensure at least one numerical symbol exists
+    INTEGER_STRICT = /^(?:[-+]?0b[_]*[0-1][0-1_]*             (?# base 2)
+                         |[-+]?0[_]*[0-7][0-7_]*              (?# base 8)
+                         |[-+]?(0|[1-9][0-9_]*)               (?# base 10)
+                         |[-+]?0x[_]*[0-9a-fA-F][0-9a-fA-F_]* (?# base 16))$/x
+
+    private
+
+    # Tokenize +string+ returning the Ruby object
+    def extract_type string
+      return :null if string.empty?
+      # Check for a String type, being careful not to get caught by hash keys, hex values, and
+      # special floats (e.g., -.inf).
+      if string.match?(%r{^[^\d.:-]?[[:alpha:]_\s!@#$%\^&*(){}<>|/\\~;=]+}) || string.match?(/\n/)
+        return :string if string.length > 5
+
+        if string.match?(/^[^ytonf~]/i)
+          :string
+        elsif string == '~' || string.match?(/^null$/i)
+          :null
+        elsif string.match?(/^(yes|true|on)$/i)
+          :boolean
+        elsif string.match?(/^(no|false|off)$/i)
+          :boolean
+        else
+          :string
+        end
+      elsif string.match?(TIME)
+        :time
+      elsif string.match?(/^\d{4}-(?:1[012]|0\d|\d)-(?:[12]\d|3[01]|0\d|\d)$/)
+        :date
+      elsif string.match?(/^\+?\.inf$/i)
+        :float
+      elsif string.match?(/^-\.inf$/i)
+        :float
+      elsif string.match?(/^\.nan$/i)
+        :float
+      elsif string.match?(/^:./)
+        :symbol
+      elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}$/)
+        :sexagesimal
+      elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}\.[0-9_]*$/)
+        :sexagesimal
+      elsif string.match?(FLOAT)
+        if string.match?(/\A[-+]?\.\Z/)
+          :string
+        else
+          :float
+        end
+      elsif string.match?(INTEGER_STRICT)
+        :integer
+      else
+        :string
+      end
+    end
+
+    def make_error klass, msg, path
+      ex = klass.new msg + " path: /#{path.join("/")}"
+      ex.set_backtrace caller
+      ex
+    end
+    # :runtime-end:
+  end
+end

data/lib/yaml-schema.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "yaml-schema/runtime"
+
 module YAMLSchema
-  VERSION = "1.2.1"
+  VERSION = "1.3.0"
 
   class Pointer
     include Enumerable
@@ -63,6 +65,8 @@ module YAMLSchema
   end
 
   class Validator
+    include Runtime
+
     class Exception < StandardError; end
     class UnexpectedType < Exception; end
     class UnexpectedProperty < Exception; end
@@ -95,10 +99,13 @@ module YAMLSchema
 
     INSTANCE = new.freeze
 
+    VALID_TYPES = %w[object array string integer float boolean null date time symbol].freeze
+
     ##
     # Given a particular schema, validate that the node conforms to the
     # schema. Raises an exception if it is invalid
     def validate schema, node, aliases: true
+      validate_schema!(schema)
       val = _validate(schema["type"], schema, node, Valid, {}, [], aliases)
       if val.exception
         raise val
@@ -111,6 +118,7 @@ module YAMLSchema
     # Given a particular schema, validate that the node conforms to the
     # schema. Returns an error object if the node is invalid, otherwise false.
     def invalid? schema, node, aliases: true
+      validate_schema!(schema)
       res = _validate(schema["type"], schema, node, Valid, {}, [], aliases)
       if Valid == res
         false
@@ -119,12 +127,112 @@ module YAMLSchema
       end
     end
 
+    ##
+    # Validates a schema definition, raising InvalidSchema if it is malformed.
+    def validate_schema! schema, path = ""
+      raise InvalidSchema, "schema must be a Hash#{_sp path}" unless Hash === schema
+
+      type = schema["type"]
+      raise InvalidSchema, "schema must have a \"type\" key#{_sp path}" unless type
+
+      types = Array === type ? type : [type]
+      types.each do |t|
+        raise InvalidSchema, "type must be a String, got #{t.class}#{_sp path}" unless String === t
+        raise InvalidSchema, "unknown type #{t.dump}#{_sp path}" unless VALID_TYPES.include?(t)
+      end
+
+      if schema["tag"]
+        raise InvalidSchema, "\"tag\" must be a String#{_sp path}" unless String === schema["tag"]
+      end
+
+      if schema["pattern"]
+        raise InvalidSchema, "\"pattern\" must be a Regexp#{_sp path}" unless Regexp === schema["pattern"]
+      end
+
+      types.each do |t|
+        case t
+        when "object"
+          _validate_object_schema(schema, path)
+        when "array"
+          _validate_array_schema(schema, path)
+        else
+          _validate_scalar_schema(schema, path)
+        end
+      end
+    end
+
     private
 
-    def make_error klass, msg, path
-      ex = klass.new msg + " path: /#{path.join("/")}"
-      ex.set_backtrace caller
-      ex
+    def _sp path
+      path.empty? ? "" : " at #{path}"
+    end
+
+    def _validate_object_schema schema, path
+      if schema["properties"]
+        raise InvalidSchema, "\"properties\" must be a Hash#{_sp path}" unless Hash === schema["properties"]
+        schema["properties"].each do |key, sub|
+          raise InvalidSchema, "property name must be a String#{_sp path}" unless String === key
+          validate_schema!(sub, "#{path}/#{key}")
+        end
+      elsif schema["items"]
+        # items-based object (homogeneous key-value)
+      else
+        raise InvalidSchema, "objects must specify \"items\" or \"properties\"#{_sp path}"
+      end
+
+      if schema["items"] && !schema["properties"]
+        raise InvalidSchema, "\"items\" must be a Hash#{_sp path}" unless Hash === schema["items"]
+        validate_schema!(schema["items"], "#{path}/items")
+      end
+
+      if schema["additionalProperties"]
+        raise InvalidSchema, "\"additionalProperties\" must be a Hash#{_sp path}" unless Hash === schema["additionalProperties"]
+        validate_schema!(schema["additionalProperties"], "#{path}/additionalProperties")
+      end
+
+      if schema["propertyNames"]
+        raise InvalidSchema, "\"propertyNames\" must be a Hash#{_sp path}" unless Hash === schema["propertyNames"]
+        validate_schema!(schema["propertyNames"], "#{path}/propertyNames") if schema["propertyNames"]["type"]
+      end
+
+      if schema["required"]
+        raise InvalidSchema, "\"required\" must be an Array#{_sp path}" unless Array === schema["required"]
+        schema["required"].each do |r|
+          raise InvalidSchema, "\"required\" entries must be Strings#{_sp path}" unless String === r
+        end
+      end
+    end
+
+    def _validate_array_schema schema, path
+      if schema["items"]
+        raise InvalidSchema, "\"items\" must be a Hash#{_sp path}" unless Hash === schema["items"]
+        validate_schema!(schema["items"], "#{path}/items")
+      elsif schema["prefixItems"]
+        raise InvalidSchema, "\"prefixItems\" must be an Array#{_sp path}" unless Array === schema["prefixItems"]
+        schema["prefixItems"].each_with_index do |sub, i|
+          validate_schema!(sub, "#{path}/prefixItems/#{i}")
+        end
+      else
+        raise InvalidSchema, "arrays must specify \"items\" or \"prefixItems\"#{_sp path}"
+      end
+
+      if schema["minItems"]
+        raise InvalidSchema, "\"minItems\" must be an Integer#{_sp path}" unless Integer === schema["minItems"]
+      end
+
+      if schema["maxItems"]
+        raise InvalidSchema, "\"maxItems\" must be an Integer#{_sp path}" unless Integer === schema["maxItems"]
+      end
+    end
+
+    def _validate_scalar_schema schema, path
+      if schema["minLength"]
+        raise InvalidSchema, "\"minLength\" must be an Integer#{_sp path}" unless Integer === schema["minLength"]
+      end
+
+      if schema["maxLength"]
+        raise InvalidSchema, "\"maxLength\" must be an Integer#{_sp path}" unless Integer === schema["maxLength"]
+      end
     end
 
     def _validate type, schema, node, valid, aliases, path, allow_aliases
@@ -235,7 +343,8 @@ module YAMLSchema
             valid = _validate sub_schema["type"], sub_schema, item, valid, aliases, path + [i], allow_aliases
           }
         elsif schema["prefixItems"]
-          node.children.each_with_index { |item, i|
+          # Items beyond the end of prefixItems are not validated
+          node.children.first(schema["prefixItems"].length).each_with_index { |item, i|
             sub_schema = schema["prefixItems"][i]
             valid = _validate sub_schema["type"], sub_schema, item, valid, aliases, path + [i], allow_aliases
           }
@@ -300,66 +409,7 @@ module YAMLSchema
 
       valid
     end
-
-    # Taken from http://yaml.org/type/timestamp.html
-    TIME = /^-?\d{4}-\d{1,2}-\d{1,2}(?:[Tt]|\s+)\d{1,2}:\d\d:\d\d(?:\.\d*)?(?:\s*(?:Z|[-+]\d{1,2}:?(?:\d\d)?))?$/
-
-    # Taken from http://yaml.org/type/float.html
-    # Base 60, [-+]inf and NaN are handled separately
-    FLOAT = /^(?:[-+]?([0-9][0-9_,]*)?\.[0-9]*([eE][-+][0-9]+)?(?# base 10))$/x
-
-    # Taken from http://yaml.org/type/int.html and modified to ensure at least one numerical symbol exists
-    INTEGER_STRICT = /^(?:[-+]?0b[_]*[0-1][0-1_]*             (?# base 2)
-                         |[-+]?0[_]*[0-7][0-7_]*              (?# base 8)
-                         |[-+]?(0|[1-9][0-9_]*)               (?# base 10)
-                         |[-+]?0x[_]*[0-9a-fA-F][0-9a-fA-F_]* (?# base 16))$/x
-
-    # Tokenize +string+ returning the Ruby object
-    def extract_type string
-      return :null if string.empty?
-      # Check for a String type, being careful not to get caught by hash keys, hex values, and
-      # special floats (e.g., -.inf).
-      if string.match?(%r{^[^\d.:-]?[[:alpha:]_\s!@#$%\^&*(){}<>|/\\~;=]+}) || string.match?(/\n/)
-        return :string if string.length > 5
-
-        if string.match?(/^[^ytonf~]/i)
-          :string
-        elsif string == '~' || string.match?(/^null$/i)
-          :null
-        elsif string.match?(/^(yes|true|on)$/i)
-          :boolean
-        elsif string.match?(/^(no|false|off)$/i)
-          :boolean
-        else
-          :string
-        end
-      elsif string.match?(TIME)
-        :time
-      elsif string.match?(/^\d{4}-(?:1[012]|0\d|\d)-(?:[12]\d|3[01]|0\d|\d)$/)
-        :date
-      elsif string.match?(/^\+?\.inf$/i)
-        :float
-      elsif string.match?(/^-\.inf$/i)
-        :float
-      elsif string.match?(/^\.nan$/i)
-        :float
-      elsif string.match?(/^:./)
-        :symbol
-      elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}$/)
-        :sexagesimal
-      elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}\.[0-9_]*$/)
-        :sexagesimal
-      elsif string.match?(FLOAT)
-        if string.match?(/\A[-+]?\.\Z/)
-          :string
-        else
-          :float
-        end
-      elsif string.match?(INTEGER_STRICT)
-        :integer
-      else
-        :string
-      end
-    end
   end
 end
+
+require "yaml-schema/compiler"

data/test/compiler_test.rb

@@ -0,0 +1,210 @@
+require "minitest/autorun"
+require "yaml-schema"
+require "psych"
+require "tmpdir"
+require "open3"
+require "rbconfig"
+
+module YAMLSchema
+  class CompilerTest < Minitest::Test
+    SCHEMAS = [
+      { "type" => "string" },
+      { "type" => "string", "minLength" => 2, "maxLength" => 4, "pattern" => /\A[a-z]+\z/ },
+      { "type" => "integer" },
+      { "type" => "integer", "pattern" => /\A1/ },
+      { "type" => "float" },
+      { "type" => "boolean" },
+      { "type" => "null" },
+      { "type" => "date" },
+      { "type" => "time" },
+      { "type" => "symbol" },
+      { "type" => ["null", "string"] },
+      { "type" => ["integer", "boolean", "string"] },
+      { "type" => "array", "items" => { "type" => "integer" } },
+      { "type" => "array", "items" => { "type" => "string" }, "minItems" => 1, "maxItems" => 2 },
+      { "type" => "array", "prefixItems" => [{ "type" => "string" }, { "type" => "integer" }] },
+      { "type" => "object", "items" => { "type" => "integer" } },
+      { "type" => "object", "tag" => "!thing", "items" => { "type" => "string" } },
+      { "type" => ["null", "object"], "tag" => "!thing", "items" => { "type" => "string" } },
+      {
+        "type" => "object",
+        "properties" => {
+          "name" => { "type" => "string" },
+          "age"  => { "type" => ["null", "integer"] },
+          "tags" => { "type" => "array", "items" => { "type" => "string" } },
+        },
+        "required" => ["name", "age"],
+      },
+      {
+        "type" => "object",
+        "properties" => { "a" => { "type" => "integer" } },
+        "additionalProperties" => { "type" => "boolean" },
+        "propertyNames" => { "pattern" => /\A[a-z]\z/, "maxLength" => 1 },
+      },
+      {
+        "type" => "object",
+        "properties" => {
+          "users" => {
+            "type" => "array",
+            "items" => {
+              "type" => "object",
+              "properties" => {
+                "name" => { "type" => "string" },
+                "meta" => { "type" => "object", "items" => { "type" => ["string", "integer"] } },
+              },
+              "required" => ["name"],
+            },
+          },
+        },
+      },
+    ]
+
+    DOCUMENTS = [
+      "foo", "'foo'", "\"123\"", "123", "0x1f", "1.5", ".inf", "true", "yes",
+      "", "~", "null", "2024-01-02", "2024-01-02 10:11:12", ":sym", "abcdef",
+      "!str 123", "!thing foo", "ab", "a1",
+      "- 1\n- 2", "- foo\n- 1", "- foo\n- bar\n- baz", "[]", "- a\n- 1\n- extra",
+      "a: 1", "a: true\nb: false", "a: 1\na: true", "ab: 1", "1: 1",
+      "!thing\na: b", "!other\na: b", "{}",
+      "name: bob\nage: 1", "name: bob", "name: bob\nage:\ntags:\n- x", "name: bob\nage: 1\nextra: 1",
+      "name: 1\nage: 1", "age: x",
+      "users:\n- name: a\n  meta:\n    x: 1\n    y: z\n- name: b", "users:\n- meta: {}",
+      "users:\n- name: a\n  meta:\n    x: [1]",
+      "a: &x 1\nb: *x", "x: &x\n- 1\ny: *x",
+    ]
+
+    def outcome
+      [:ok, yield]
+    rescue Validator::Exception => e
+      [e.class, e.message]
+    rescue => e
+      [:crash, e.class]
+    end
+
+    # Stand-alone validators define their own exception classes, so compare
+    # exceptions by their unqualified names.
+    def loose_outcome
+      [:ok, yield]
+    rescue => e
+      # An exception raised without a message uses its class name as the message
+      message = e.message == e.class.name ? :default : e.message
+      [e.class.name.split("::").last, message]
+    end
+
+    def standalone_validator schema
+      mod = Module.new
+      mod.module_eval Compiler.to_ruby(schema, class_name: "Validator", standalone: true)
+      mod::Validator
+    end
+
+    def test_compiled_matches_interpreter
+      SCHEMAS.each do |schema|
+        compiled = Compiler.compile(schema)
+        DOCUMENTS.each do |yaml|
+          node = Psych.parse("---\n#{yaml}").children.first
+          [true, false].each do |aliases|
+            expected = outcome { Validator.validate(schema, node, aliases: aliases) }
+            actual   = outcome { compiled.validate(node, aliases: aliases) }
+            assert_equal expected, actual, "schema=#{schema.inspect} yaml=#{yaml.inspect} aliases=#{aliases}"
+
+            expected = outcome { e = Validator.new.invalid?(schema, node, aliases: aliases); e && [e.class, e.message] }
+            actual   = outcome { e = compiled.invalid?(node, aliases: aliases); e && [e.class, e.message] }
+            assert_equal expected, actual, "invalid? schema=#{schema.inspect} yaml=#{yaml.inspect}"
+          end
+        end
+      end
+    end
+
+    def test_standalone_matches_interpreter
+      SCHEMAS.each do |schema|
+        standalone = standalone_validator(schema)
+        refute_operator standalone, :<, CompiledValidator
+
+        DOCUMENTS.each do |yaml|
+          node = Psych.parse("---\n#{yaml}").children.first
+          [true, false].each do |aliases|
+            expected = loose_outcome { Validator.validate(schema, node, aliases: aliases) }
+            actual   = loose_outcome { standalone.validate(node, aliases: aliases) }
+            assert_equal expected, actual, "schema=#{schema.inspect} yaml=#{yaml.inspect} aliases=#{aliases}"
+          end
+        end
+      end
+    end
+
+    def test_standalone_runs_without_yaml_schema
+      schema = { "type" => "object", "properties" => { "age" => { "type" => "integer" } } }
+      script = <<~'RUBY'
+        require "psych"
+        load ARGV.fetch(0)
+        abort "yaml-schema was loaded" if defined?(YAMLSchema)
+        puts AgeValidator.validate(Psych.parse("age: 1").children.first)
+        begin
+          AgeValidator.validate(Psych.parse("age: x").children.first)
+        rescue AgeValidator::UnexpectedValue => e
+          puts e.message
+        end
+      RUBY
+
+      Dir.mktmpdir do |dir|
+        path = File.join(dir, "age_validator.rb")
+        File.write path, Compiler.to_ruby(schema, class_name: "AgeValidator", standalone: true)
+
+        # Clear RUBYOPT so bundler/setup doesn't load the gemspec (which requires yaml-schema)
+        env = { "RUBYOPT" => nil, "RUBYLIB" => nil }
+        out, err, status = Open3.capture3(env, RbConfig.ruby, "--disable-gems", "-e", script, path)
+        assert status.success?, err
+        assert_equal "true\nexpected integer, got string path: /age\n", out
+      end
+    end
+
+    def test_validate_and_invalid?
+      v = Compiler.compile({ "type" => "array", "items" => { "type" => "integer" } })
+      assert v.validate(Psych.parse("- 1").children.first)
+      refute v.invalid?(Psych.parse("- 1").children.first)
+
+      node = Psych.parse("- 1\n- foo").children.first
+      err = v.invalid?(node)
+      assert_kind_of Validator::UnexpectedValue, err
+      assert_match %r{path: /1}, err.message
+      assert_raises(Validator::UnexpectedValue) { v.validate(node) }
+    end
+
+    def test_invalid_schema_raises_at_compile_time
+      assert_raises(Validator::InvalidSchema) { Compiler.compile({ "type" => "nope" }) }
+    end
+
+    def test_custom_node_info
+      info = Object.new
+      def info.read_tag(node); node.tag == "!aaron" ? "test" : node.tag; end
+      v = Compiler.compile({ "type" => "object", "tag" => "test", "properties" => { "foo" => { "type" => "string" } } })
+      node = Psych.parse("--- !aaron\nfoo: bar").children.first
+      assert v.new(info).validate(node)
+      assert_raises(Validator::UnexpectedTag) { v.validate(node) }
+    end
+
+    def test_extra_prefix_items_are_allowed
+      v = Compiler.compile({ "type" => "array", "prefixItems" => [{ "type" => "string" }] })
+      assert v.validate(Psych.parse("- a\n- 1").children.first)
+    end
+
+    def test_to_ruby
+      schema = { "type" => "object", "properties" => { "name" => { "type" => "string", "pattern" => %r{\A/\w+\z}i } } }
+      src = Compiler.to_ruby(schema, class_name: "GeneratedPersonValidator")
+
+      Dir.mktmpdir do |dir|
+        path = File.join(dir, "generated_person_validator.rb")
+        File.write path, src
+        load path
+      end
+
+      assert_operator GeneratedPersonValidator, :<, CompiledValidator
+      assert GeneratedPersonValidator.validate(Psych.parse("name: /Bob").children.first)
+      assert_raises(Validator::InvalidPattern) do
+        GeneratedPersonValidator.validate(Psych.parse("name: bob").children.first)
+      end
+    ensure
+      YAMLSchema.send(:remove_const, :GeneratedPersonValidator) if YAMLSchema.const_defined?(:GeneratedPersonValidator, false)
+      Object.send(:remove_const, :GeneratedPersonValidator) if Object.const_defined?(:GeneratedPersonValidator, false)
+    end
+  end
+end

data/test/validator_test.rb

@@ -322,7 +322,10 @@ module YAMLSchema
         assert_raises UnexpectedTag do
           Validator.validate({
             "type" => "object",
-            "tag" => "aaron"
+            "tag" => "aaron",
+            "properties" => {
+              "foo" => { "type" => "string" }
+            }
           }, ast.children.first)
         end
       end
@@ -332,7 +335,10 @@ module YAMLSchema
         ex = assert_raises UnexpectedTag do
           Validator.validate({
             "type" => "object",
-            "tag" => "aaron"
+            "tag" => "aaron",
+            "properties" => {
+              "foo" => { "type" => "string" }
+            }
           }, ast.children.first)
         end
         assert_match(/lolol/, ex.message)
@@ -351,6 +357,9 @@ module YAMLSchema
         ex = assert_raises UnexpectedType do
           Validator.validate({
             "type" => "object",
+            "properties" => {
+              "foo" => { "type" => "string" }
+            }
           }, ast.children.first)
         end
         assert_match(/Mapping/, ex.message)
@@ -359,6 +368,7 @@ module YAMLSchema
         ex = assert_raises UnexpectedType do
           Validator.validate({
             "type" => "array",
+            "items" => { "type" => "string" }
           }, ast.children.first)
         end
         assert_match(/Sequence/, ex.message)
@@ -468,6 +478,17 @@ module YAMLSchema
         end
       end
 
+      def test_extra_prefix_items_are_allowed
+        ast = Psych.parse("- foo\n- 1\n- extra")
+        assert Validator.validate({
+          "type" => "array",
+          "prefixItems" => [
+            { "type" => "string" },
+            { "type" => "integer" },
+          ]
+        }, ast.children.first)
+      end
+
       def test_invalid_string
         ast = Psych.parse("1")
         assert_raises UnexpectedValue do
@@ -731,5 +752,134 @@ bar: *1
         }, ast.children.first)
       end
     end
+
+    class SchemaValidationTest < Minitest::Test
+      def test_missing_type
+        assert_raises InvalidSchema do
+          Validator.validate({}, Psych.parse("foo").children.first)
+        end
+      end
+
+      def test_invalid_type_value
+        assert_raises InvalidSchema do
+          Validator.validate({ "type" => 42 }, Psych.parse("foo").children.first)
+        end
+      end
+
+      def test_unknown_type
+        assert_raises InvalidSchema do
+          Validator.validate({ "type" => "map" }, Psych.parse("foo").children.first)
+        end
+      end
+
+      def test_object_without_properties_or_items
+        assert_raises InvalidSchema do
+          Validator.validate({
+            "type" => "object",
+          }, Psych.parse("foo: bar").children.first)
+        end
+      end
+
+      def test_array_without_items_or_prefix
+        assert_raises InvalidSchema do
+          Validator.validate({
+            "type" => "array",
+          }, Psych.parse("- foo").children.first)
+        end
+      end
+
+      def test_invalid_required_type
+        assert_raises InvalidSchema do
+          Validator.validate({
+            "type" => "object",
+            "properties" => { "foo" => { "type" => "string" } },
+            "required" => "foo",
+          }, Psych.parse("foo: bar").children.first)
+        end
+      end
+
+      def test_invalid_min_length_type
+        assert_raises InvalidSchema do
+          Validator.validate({
+            "type" => "string",
+            "minLength" => "5",
+          }, Psych.parse("foo").children.first)
+        end
+      end
+
+      def test_invalid_max_items_type
+        assert_raises InvalidSchema do
+          Validator.validate({
+            "type" => "array",
+            "items" => { "type" => "string" },
+            "maxItems" => "2",
+          }, Psych.parse("- foo").children.first)
+        end
+      end
+
+      def test_invalid_pattern_type
+        assert_raises InvalidSchema do
+          Validator.validate({
+            "type" => "string",
+            "pattern" => "foo",
+          }, Psych.parse("foo").children.first)
+        end
+      end
+
+      def test_invalid_tag_type
+        assert_raises InvalidSchema do
+          Validator.validate({
+            "type" => "object",
+            "tag" => 42,
+            "properties" => { "foo" => { "type" => "string" } },
+          }, Psych.parse("foo: bar").children.first)
+        end
+      end
+
+      def test_invalid_nested_schema
+        assert_raises InvalidSchema do
+          Validator.validate({
+            "type" => "object",
+            "properties" => {
+              "foo" => { "type" => "bogus" }
+            }
+          }, Psych.parse("foo: bar").children.first)
+        end
+      end
+
+      def test_invalid_prefix_items_type
+        assert_raises InvalidSchema do
+          Validator.validate({
+            "type" => "array",
+            "prefixItems" => { "type" => "string" },
+          }, Psych.parse("- foo").children.first)
+        end
+      end
+
+      def test_invalid_additional_properties_type
+        assert_raises InvalidSchema do
+          Validator.validate({
+            "type" => "object",
+            "properties" => { "foo" => { "type" => "string" } },
+            "additionalProperties" => "string",
+          }, Psych.parse("foo: bar").children.first)
+        end
+      end
+
+      def test_valid_union_types
+        ast = Psych.parse("foo")
+        assert Validator.validate({
+          "type" => ["null", "string"],
+        }, ast.children.first)
+      end
+
+      def test_invalid_union_type_entry
+        assert_raises InvalidSchema do
+          Validator.validate({
+            "type" => ["string", "bogus"],
+          }, Psych.parse("foo").children.first)
+        end
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yaml-schema
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Aaron Patterson
@@ -65,6 +65,9 @@ files:
 - README.md
 - Rakefile
 - lib/yaml-schema.rb
+- lib/yaml-schema/compiler.rb
+- lib/yaml-schema/runtime.rb
+- test/compiler_test.rb
 - test/pointer_test.rb
 - test/validator_test.rb
 - yaml-schema.gemspec
@@ -86,9 +89,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Validate YAML against a schema
 test_files:
+- test/compiler_test.rb
 - test/pointer_test.rb
 - test/validator_test.rb