yaml-schema 1.2.0 → 1.3.0

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.0"
+  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
@@ -79,27 +83,30 @@ module YAMLSchema
     ##
     # Given a particular schema, validate that the node conforms to the
     # schema. Raises an exception if it is invalid
-    def self.validate(schema, node, aliases: true)
+    def self.validate schema, node, aliases: true
       INSTANCE.validate schema, node, aliases: aliases
     end
 
     module NodeInfo # :nodoc:
-      def self.read_tag(node)
+      def self.read_tag node
         node.tag
       end
     end
 
-    def initialize(node_info = NodeInfo)
+    def initialize node_info = NodeInfo
       @node_info = node_info
     end
 
     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)
-      val = _validate(schema["type"], schema, node, Valid, {}, ["root"], aliases)
+    def validate schema, node, aliases: true
+      validate_schema!(schema)
+      val = _validate(schema["type"], schema, node, Valid, {}, [], aliases)
       if val.exception
         raise val
       else
@@ -110,8 +117,9 @@ 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)
-      res = _validate(schema["type"], schema, node, Valid, {}, ["root"], aliases)
+    def invalid? schema, node, aliases: true
+      validate_schema!(schema)
+      res = _validate(schema["type"], schema, node, Valid, {}, [], aliases)
       if Valid == res
         false
       else
@@ -119,15 +127,115 @@ 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(type, schema, node, valid, aliases, path, allow_aliases)
+    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
       return valid if valid.exception
 
       if node.anchor
@@ -188,7 +296,7 @@ module YAMLSchema
               if schema["additionalProperties"]
                 schema["additionalProperties"]
               else
-                return make_error UnexpectedProperty, "unknown property #{key.value.dump}", path
+                return make_error UnexpectedProperty, "unknown property #{key.value.dump}", path + [key.value]
               end
             }
 
@@ -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
           }
@@ -289,7 +398,7 @@ module YAMLSchema
             when "integer", "float", "time", "date", "symbol"
               found_type = extract_type(node.value)
               unless found_type == type.to_sym
-                return make_error UnexpectedValue, "expected #{type}, got #{type}", path
+                return make_error UnexpectedValue, "expected #{type}, got #{found_type}", path
               end
             else
               raise "unknown type #{schema["type"]}"
@@ -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