json_schema 0.0.7 → 0.0.9

data/lib/json_schema/schema.rb

@@ -1,3 +1,5 @@
+require "json"
+
 module JsonSchema
   class Schema
     @@copyable = []
@@ -13,33 +15,116 @@ module JsonSchema
       class_eval("def #{attr} ; !@#{attr}.nil? ? @#{attr} : #{default} ; end")
     end
 
+    def initialize
+      @clones = Set.new
+    end
+
     # Rather than a normal schema, the node may be a JSON Reference. In this
     # case, no other attributes will be filled in except for #parent.
-    attr_copyable :reference
+    attr_accessor :reference
+
+    attr_copyable :expanded
 
-    # the schema keeps a reference to the data it was initialized from for JSON
-    # Pointer resolution
+    # A reference to the data which the Schema was initialized from. Used for
+    # resolving JSON Pointer references.
+    #
+    # Type: Hash
     attr_copyable :data
 
-    # parent and children schemas
+    #
+    # Relations
+    #
+
+    # Parent Schema object. Child may come from any of `definitions`,
+    # `properties`, `anyOf`, etc.
+    #
+    # Type: Schema
     attr_copyable :parent
 
-    # the normalize URI of this schema
+    # Collection of clones of this schema object, meaning all Schemas that were
+    # initialized after the original. Used for JSON Reference expansion. The
+    # only copy not present in this set is the original Schema object.
+    #
+    # Type: Set[Schema]
+    attr_copyable :clones
+
+    # The normalized URI of this schema. Note that child schemas inherit a URI
+    # from their parent unless they have one explicitly defined, so this is
+    # likely not a unique value in any given schema hierarchy.
+    #
+    # Type: String
     attr_copyable :uri
 
-    # basic descriptors
+    #
+    # Metadata
+    #
+
+    # Alters resolution scope. This value is used along with the parent scope's
+    # URI to build a new address for this schema. Relative ID's will append to
+    # the parent, and absolute URI's will replace it.
+    #
+    # Type: String
     attr_copyable :id
+
+    # Short title of the schema.
+    #
+    # Type: String
     attr_copyable :title
+
+    # More detailed description of the schema.
+    #
+    # Type: String
     attr_copyable :description
+
+    # Default JSON value for this particular schema
+    #
+    # Type: [any]
     attr_copyable :default
 
-    # validation: any
+    #
+    # Validation: Any
+    #
+
+    # A collection of subschemas of which data must validate against the full
+    # set of to be valid.
+    #
+    # Type: Array[Schema]
     attr_copyable :all_of
+
+    # A collection of subschemas of which data must validate against any schema
+    # in the set to be be valid.
+    #
+    # Type: Array[Schema]
     attr_copyable :any_of
+
+    # A collection of inlined subschemas. Standard convention is to subschemas
+    # here and reference them from elsewhere.
+    #
+    # Type: Hash[String => Schema]
     attr_copyable :definitions
+
+    # A collection of objects that must include the data for it to be valid.
+    #
+    # Type: Array
     attr_copyable :enum
+
+    # A collection of subschemas of which data must validate against exactly
+    # one of to be valid.
+    #
+    # Type: Array[Schema]
     attr_copyable :one_of
+
+
+    # A subschema which data must not validate against to be valid.
+    #
+    # Type: Schema
     attr_copyable :not
+
+    # An array of types that data is allowed to be. The spec allows this to be
+    # a string as well, but the parser will always normalize this to an array
+    # of strings.
+    #
+    # Type: Array[String]
     attr_copyable :type
 
     # validation: array
@@ -97,7 +182,7 @@ module JsonSchema
 
     # allow booleans to be access with question mark
     alias :additional_items? :additional_items
-    alias :additional_properties? :additional_properties
+    alias :expanded? :expanded
     alias :max_exclusive? :max_exclusive
     alias :min_exclusive? :min_exclusive
     alias :read_only? :read_only
@@ -123,6 +208,53 @@ module JsonSchema
       true
     end
 
+    def inspect
+      str = inspect_schema
+      str = JSON.pretty_generate(str).gsub(/\\?"/, '') if str.is_a?(Hash)
+      "\#<JsonSchema::Schema #{str}>"
+    end
+
+    def inspect_schema
+      if reference
+        str = reference.to_s
+        str += " [EXPANDED]" if expanded?
+        str += " [CLONE]" if !original?
+        str
+      else
+        hash = {}
+        @@copyable.each do |copyable|
+          next if [:@clones, :@data, :@parent, :@uri].include?(copyable)
+          if value = instance_variable_get(copyable)
+            if value.is_a?(Array)
+              if !value.empty?
+                hash[copyable] = value.map { |v| inspect_value(v) }
+              end
+            elsif value.is_a?(Hash)
+              if !value.empty?
+                hash[copyable] =
+                  Hash[*value.map { |k, v| [k, inspect_value(v)] }.flatten]
+              end
+            else
+              hash[copyable] = inspect_value(value)
+            end
+          end
+        end
+        hash
+      end
+    end
+
+    def inspect_value(value)
+      if value.is_a?(Schema)
+        value.inspect_schema
+      else
+        value.inspect
+      end
+    end
+
+    def original?
+      !clones.include?(self)
+    end
+
     def validate(data)
       validator = Validator.new(self)
       valid = validator.validate(data)

data/lib/json_schema/validator.rb

@@ -86,13 +86,25 @@ module JsonSchema
     end
 
     def validate_additional_properties(schema, data, errors)
-      return true if schema.additional_properties?
-      if (extra = data.keys - schema.properties.keys).empty?
-        true
+      return true if schema.additional_properties == true
+
+      extra = data.keys - schema.properties.keys
+
+      # schema indicates that all properties not in `properties` should be
+      # validated according to subschema
+      if schema.additional_properties.is_a?(Schema)
+        extra.each do |key|
+          validate_data(schema.additional_properties, data[key], errors)
+        end
+      # boolean indicates whether additional properties are allowed
       else
-        message = %{Extra keys in object: #{extra.sort.join(", ")}.}
-        errors << SchemaError.new(schema, message)
-        false
+        if extra.empty?
+          true
+        else
+          message = %{Extra keys in object: #{extra.sort.join(", ")}.}
+          errors << SchemaError.new(schema, message)
+          false
+        end
       end
     end
 
@@ -143,8 +155,10 @@ module JsonSchema
         data =~ IPV4_PATTERN
       when "ipv6"
         data =~ IPV6_PATTERN
+      when "regex"
+        Regexp.new(data) rescue false
       when "uri"
-        data =~ URI.regexp
+        URI.parse(data) rescue false
       when "uuid"
         data =~ UUID_PATTERN
       end
@@ -347,6 +361,7 @@ module JsonSchema
       return true if schema.properties.empty?
       valid = true
       schema.properties.each do |key, subschema|
+
         if value = data[key]
           valid = strict_and valid, validate_data(subschema, value, errors)
         end

data/schemas/hyper-schema.json

@@ -0,0 +1,168 @@
+{
+    "$schema": "http://json-schema.org/draft-04/hyper-schema#",
+    "id": "http://json-schema.org/draft-04/hyper-schema#",
+    "title": "JSON Hyper-Schema",
+    "allOf": [
+        {
+            "$ref": "http://json-schema.org/draft-04/schema#"
+        }
+    ],
+    "properties": {
+        "additionalItems": {
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "$ref": "#"
+                }
+            ]
+        },
+        "additionalProperties": {
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "$ref": "#"
+                }
+            ]
+        },
+        "dependencies": {
+            "additionalProperties": {
+                "anyOf": [
+                    {
+                        "$ref": "#"
+                    },
+                    {
+                        "type": "array"
+                    }
+                ]
+            }
+        },
+        "items": {
+            "anyOf": [
+                {
+                    "$ref": "#"
+                },
+                {
+                    "$ref": "#/definitions/schemaArray"
+                }
+            ]
+        },
+        "definitions": {
+            "additionalProperties": {
+                "$ref": "#"
+            }
+        },
+        "patternProperties": {
+            "additionalProperties": {
+                "$ref": "#"
+            }
+        },
+        "properties": {
+            "additionalProperties": {
+                "$ref": "#"
+            }
+        },
+        "allOf": {
+            "$ref": "#/definitions/schemaArray"
+        },
+        "anyOf": {
+            "$ref": "#/definitions/schemaArray"
+        },
+        "oneOf": {
+            "$ref": "#/definitions/schemaArray"
+        },
+        "not": {
+            "$ref": "#"
+        },
+
+        "links": {
+            "type": "array",
+            "items": {
+                "$ref": "#/definitions/linkDescription"
+            }
+        },
+        "fragmentResolution": {
+            "type": "string"
+        },
+        "media": {
+            "type": "object",
+            "properties": {
+                "type": {
+                    "description": "A media type, as described in RFC 2046",
+                    "type": "string"
+                },
+                "binaryEncoding": {
+                    "description": "A content encoding scheme, as described in RFC 2045",
+                    "type": "string"
+                }
+            }
+        },
+        "pathStart": {
+            "description": "Instances' URIs must start with this value for this schema to apply to them",
+            "type": "string",
+            "format": "uri"
+        }
+    },
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "items": {
+                "$ref": "#"
+            }
+        },
+        "linkDescription": {
+            "title": "Link Description Object",
+            "type": "object",
+            "required": [ "href", "rel" ],
+            "properties": {
+                "href": {
+                    "description": "a URI template, as defined by RFC 6570, with the addition of the $, ( and ) characters for pre-processing",
+                    "type": "string"
+                },
+                "rel": {
+                    "description": "relation to the target resource of the link",
+                    "type": "string"
+                },
+                "title": {
+                    "description": "a title for the link",
+                    "type": "string"
+                },
+                "targetSchema": {
+                    "description": "JSON Schema describing the link target",
+                    "$ref": "#"
+                },
+                "mediaType": {
+                    "description": "media type (as defined by RFC 2046) describing the link target",
+                    "type": "string"
+                },
+                "method": {
+                    "description": "method for requesting the target of the link (e.g. for HTTP this might be \"GET\" or \"DELETE\")",
+                    "type": "string"
+                },
+                "encType": {
+                    "description": "The media type in which to submit data along with the request",
+                    "type": "string",
+                    "default": "application/json"
+                },
+                "schema": {
+                    "description": "Schema describing the data to submit along with the request",
+                    "$ref": "#"
+                }
+            }
+        }
+    },
+    "links": [
+        {
+            "rel": "self",
+            "href": "{+id}"
+        },
+        {
+            "rel": "full",
+            "href": "{+($ref)}"
+        }
+    ]
+}
+

data/schemas/schema.json

@@ -0,0 +1,150 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}