json_schema 0.0.7

data/lib/json_schema/reference_expander.rb

@@ -0,0 +1,156 @@
+require "json_schema/parser"
+require "set"
+
+module JsonSchema
+  class ReferenceExpander
+    attr_accessor :errors
+
+    def expand(schema)
+      @errors = []
+      @schema = schema
+      @store = {}
+      @unresolved_refs = Set.new
+      last_num_unresolved_refs = 0
+
+      loop do
+        traverse_schema(schema)
+
+        # nothing left unresolved, we're done!
+        if @unresolved_refs.count == 0
+          break
+        end
+
+        # a new traversal pass still hasn't managed to resolved anymore
+        # references; we're out of luck
+        if @unresolved_refs.count == last_num_unresolved_refs
+          refs = @unresolved_refs.to_a.join(", ")
+          message = %{Couldn't resolve references (possible circular dependency): #{refs}.}
+          @errors << SchemaError.new(schema, message)
+          break
+        end
+
+        last_num_unresolved_refs = @unresolved_refs.count
+      end
+
+      @errors.count == 0
+    end
+
+    def expand!(schema)
+      if !expand(schema)
+        raise SchemaError.aggregate(@errors)
+      end
+      true
+    end
+
+    private
+
+    def dereference(schema)
+      ref = schema.reference
+      uri = ref.uri
+
+      if uri && uri.host
+        scheme = uri.scheme || "http"
+        message = %{Reference resolution over #{scheme} is not currently supported.}
+        @errors << SchemaError.new(schema, message)
+      # absolute
+      elsif uri && uri.path[0] == "/"
+        resolve(schema, uri.path, ref)
+      # relative
+      elsif uri
+        # build an absolute path using the URI of the current schema
+        schema_uri = schema.uri.chomp("/")
+        resolve(schema, schema_uri + "/" + uri.path, ref)
+      # just a JSON Pointer -- resolve against schema root
+      else
+        evaluate(schema, @schema, ref)
+      end
+    end
+
+    def evaluate(schema, schema_context, ref)
+      data = JsonPointer.evaluate(schema_context.data, ref.pointer)
+
+      # couldn't resolve pointer within known schema; that's an error
+      if data.nil?
+        message = %{Couldn't resolve pointer "#{ref.pointer}".}
+        @errors << SchemaError.new(schema_context, message)
+        return
+      end
+
+      # this counts as a resolution
+      @unresolved_refs.delete(ref.to_s)
+
+      # parse a new schema and use the same parent node
+      new_schema = Parser.new.parse(data, schema.parent)
+
+      # mark a new unresolved reference if the schema we got back is also a
+      # reference
+      if new_schema.reference
+        @unresolved_refs.add(new_schema.reference.to_s)
+      end
+
+      # copy new schema into existing one while preserving parent
+      parent = schema.parent
+      schema.copy_from(new_schema)
+      schema.parent = parent
+
+      new_schema
+    end
+
+    def resolve(schema, uri, ref)
+      if schema_context = @store[uri]
+        evaluate(schema, schema_context, ref)
+      else
+        # couldn't resolve, return original reference
+        @unresolved_refs.add(ref.to_s)
+        schema
+      end
+    end
+
+    def schema_children(schema)
+      Enumerator.new do |yielder|
+        schema.all_of.each { |s| yielder << s }
+        schema.any_of.each { |s| yielder << s }
+        schema.one_of.each { |s| yielder << s }
+        schema.definitions.each { |_, s| yielder << s }
+        schema.links.map { |l| l.schema }.compact.each { |s| yielder << s }
+        schema.pattern_properties.each { |_, s| yielder << s }
+        schema.properties.each { |_, s| yielder << s }
+
+        if schema.not
+          yielder << schema.not
+        end
+
+        # can either be a single schema (list validation) or multiple (tuple
+        # validation)
+        if schema.items
+          if schema.items.is_a?(Array)
+            schema.items.each { |s| yielder << s }
+          else
+            yielder << schema.items
+          end
+        end
+
+        # dependencies can either be simple or "schema"; only replace the
+        # latter
+        schema.dependencies.values.
+          select { |s| s.is_a?(Schema) }.
+          each { |s| yielder << s }
+      end
+    end
+
+    def traverse_schema(schema)
+      # Children without an ID keep the same URI as their parents. So since we
+      # traverse trees from top to bottom, just keep the first reference.
+      if !@store.key?(schema.uri)
+        @store[schema.uri] = schema
+      end
+
+      schema_children(schema).each do |subschema|
+        if subschema.reference
+          dereference(subschema)
+        end
+        traverse_schema(subschema)
+      end
+    end
+  end
+end

data/lib/json_schema/schema.rb

@@ -0,0 +1,155 @@
+module JsonSchema
+  class Schema
+    @@copyable = []
+
+    # identical to attr_accessible, but allows us to copy in values from a
+    # target schema to help preserve our hierarchy during reference expansion
+    def self.attr_copyable(attr)
+      attr_accessor(attr)
+      @@copyable << "@#{attr}".to_sym
+    end
+
+    def self.attr_reader_default(attr, default)
+      class_eval("def #{attr} ; !@#{attr}.nil? ? @#{attr} : #{default} ; end")
+    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
+
+    # the schema keeps a reference to the data it was initialized from for JSON
+    # Pointer resolution
+    attr_copyable :data
+
+    # parent and children schemas
+    attr_copyable :parent
+
+    # the normalize URI of this schema
+    attr_copyable :uri
+
+    # basic descriptors
+    attr_copyable :id
+    attr_copyable :title
+    attr_copyable :description
+    attr_copyable :default
+
+    # validation: any
+    attr_copyable :all_of
+    attr_copyable :any_of
+    attr_copyable :definitions
+    attr_copyable :enum
+    attr_copyable :one_of
+    attr_copyable :not
+    attr_copyable :type
+
+    # validation: array
+    attr_copyable :additional_items
+    attr_copyable :items
+    attr_copyable :max_items
+    attr_copyable :min_items
+    attr_copyable :unique_items
+
+    # validation: number/integer
+    attr_copyable :max
+    attr_copyable :max_exclusive
+    attr_copyable :min
+    attr_copyable :min_exclusive
+    attr_copyable :multiple_of
+
+    # validation: object
+    attr_copyable :additional_properties
+    attr_copyable :dependencies
+    attr_copyable :max_properties
+    attr_copyable :min_properties
+    attr_copyable :pattern_properties
+    attr_copyable :properties
+    attr_copyable :required
+
+    # validation: string
+    attr_copyable :format
+    attr_copyable :max_length
+    attr_copyable :min_length
+    attr_copyable :pattern
+
+    # hyperschema
+    attr_copyable :links
+    attr_copyable :media
+    attr_copyable :path_start
+    attr_copyable :read_only
+
+    # Give these properties reader defaults for particular behavior so that we
+    # can preserve the `nil` nature of their instance variables. Knowing that
+    # these were `nil` when we read them allows us to properly reflect the
+    # parsed schema back to JSON.
+    attr_reader_default :additional_items, true
+    attr_reader_default :additional_properties, true
+    attr_reader_default :all_of, []
+    attr_reader_default :any_of, []
+    attr_reader_default :definitions, {}
+    attr_reader_default :dependencies, {}
+    attr_reader_default :links, []
+    attr_reader_default :one_of, []
+    attr_reader_default :max_exclusive, false
+    attr_reader_default :min_exclusive, false
+    attr_reader_default :pattern_properties, {}
+    attr_reader_default :properties, {}
+    attr_reader_default :type, []
+
+    # allow booleans to be access with question mark
+    alias :additional_items? :additional_items
+    alias :additional_properties? :additional_properties
+    alias :max_exclusive? :max_exclusive
+    alias :min_exclusive? :min_exclusive
+    alias :read_only? :read_only
+    alias :unique_items? :unique_items
+
+    def copy_from(schema)
+      @@copyable.each do |copyable|
+        instance_variable_set(copyable, schema.instance_variable_get(copyable))
+      end
+    end
+
+    def expand_references
+      expander = ReferenceExpander.new
+      if expander.expand(self)
+        [true, nil]
+      else
+        [false, expander.errors]
+      end
+    end
+
+    def expand_references!
+      ReferenceExpander.new.expand!(self)
+      true
+    end
+
+    def validate(data)
+      validator = Validator.new(self)
+      valid = validator.validate(data)
+      [valid, validator.errors]
+    end
+
+    def validate!(data)
+      Validator.new(self).validate!(data)
+    end
+
+    # Link subobject for a hyperschema.
+    class Link
+      attr_accessor :parent
+
+      # schema attributes
+      attr_accessor :description
+      attr_accessor :href
+      attr_accessor :method
+      attr_accessor :rel
+      attr_accessor :schema
+      attr_accessor :title
+    end
+
+    # Media type subobject for a hyperschema.
+    class Media
+      attr_accessor :binary_encoding
+      attr_accessor :type
+    end
+  end
+end

data/lib/json_schema/schema_error.rb

@@ -0,0 +1,25 @@
+module JsonSchema
+  class SchemaError
+    attr_accessor :message
+    attr_accessor :schema
+
+    def self.aggregate(errors)
+      # May want to eventually use a JSON Pointer instead to help user narrow
+      # down the location of the error. It's slightly tricky to ascend the
+      # schema hierarchy to raise build one though, so I'm punting on that
+      # for now.
+      errors.map { |e|
+        if e.schema
+          %{At "#{e.schema.uri}": #{e.message}}
+        else
+          e.message
+        end
+      }.join(" ")
+    end
+
+    def initialize(schema, message)
+      @schema = schema
+      @message = message
+    end
+  end
+end

data/lib/json_schema/validator.rb

@@ -0,0 +1,405 @@
+require "uri"
+
+module JsonSchema
+  class Validator
+    TYPE_MAP = {
+      "array"   => Array,
+      "boolean" => [FalseClass, TrueClass],
+      "integer" => Integer,
+      "number"  => [Integer, Float],
+      "null"    => NilClass,
+      "object"  => Hash,
+      "string"  => String,
+    }
+
+    attr_accessor :errors
+
+    def initialize(schema)
+      @schema = schema
+    end
+
+    def validate(data)
+      @errors = []
+      validate_data(@schema, data, @errors)
+      @errors.size == 0
+    end
+
+    def validate!(data)
+      if !validate(data)
+        raise SchemaError.aggregate(@errors)
+      end
+    end
+
+    private
+
+    # works around &&'s "lazy" behavior
+    def strict_and(valid_old, valid_new)
+      valid_old && valid_new
+    end
+
+    def validate_data(schema, data, errors)
+      valid = true
+
+      # validation: any
+      valid = strict_and valid, validate_all_of(schema, data, errors)
+      valid = strict_and valid, validate_any_of(schema, data, errors)
+      valid = strict_and valid, validate_enum(schema, data, errors)
+      valid = strict_and valid, validate_one_of(schema, data, errors)
+      valid = strict_and valid, validate_not(schema, data, errors)
+      valid = strict_and valid, validate_type(schema, data, errors)
+
+      # validation: array
+      if data.is_a?(Array)
+        valid = strict_and valid, validate_items(schema, data, errors)
+        valid = strict_and valid, validate_max_items(schema, data, errors)
+        valid = strict_and valid, validate_min_items(schema, data, errors)
+        valid = strict_and valid, validate_unique_items(schema, data, errors)
+      end
+
+      # validation: integer/number
+      if data.is_a?(Float) || data.is_a?(Integer)
+        valid = strict_and valid, validate_max(schema, data, errors)
+        valid = strict_and valid, validate_min(schema, data, errors)
+        valid = strict_and valid, validate_multiple_of(schema, data, errors)
+      end
+
+      # validation: object
+      if data.is_a?(Hash)
+        valid = strict_and valid, validate_additional_properties(schema, data, errors)
+        valid = strict_and valid, validate_dependencies(schema, data, errors)
+        valid = strict_and valid, validate_max_properties(schema, data, errors)
+        valid = strict_and valid, validate_min_properties(schema, data, errors)
+        valid = strict_and valid, validate_pattern_properties(schema, data, errors)
+        valid = strict_and valid, validate_properties(schema, data, errors)
+        valid = strict_and valid, validate_required(schema, data, errors, schema.required)
+      end
+
+      # validation: string
+      if data.is_a?(String)
+        valid = strict_and valid, validate_format(schema, data, errors)
+        valid = strict_and valid, validate_max_length(schema, data, errors)
+        valid = strict_and valid, validate_min_length(schema, data, errors)
+        valid = strict_and valid, validate_pattern(schema, data, errors)
+      end
+
+      valid
+    end
+
+    def validate_additional_properties(schema, data, errors)
+      return true if schema.additional_properties?
+      if (extra = data.keys - schema.properties.keys).empty?
+        true
+      else
+        message = %{Extra keys in object: #{extra.sort.join(", ")}.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_all_of(schema, data, errors)
+      return true if schema.all_of.empty?
+      valid = schema.all_of.all? do |subschema|
+        validate_data(subschema, data, errors)
+      end
+      message = %{Data did not match all subschemas of "allOf" condition.}
+      errors << SchemaError.new(schema, message) if !valid
+      valid
+    end
+
+    def validate_any_of(schema, data, errors)
+      return true if schema.any_of.empty?
+      valid = schema.any_of.any? do |subschema|
+        validate_data(subschema, data, [])
+      end
+      message = %{Data did not match any subschema of "anyOf" condition.}
+      errors << SchemaError.new(schema, message) if !valid
+      valid
+    end
+
+    def validate_dependencies(schema, data, errors)
+      return true if schema.dependencies.empty?
+      schema.dependencies.each do |key, obj|
+        # if the key is not present, the dependency is fulfilled by definition
+        next unless data[key]
+        if obj.is_a?(Schema)
+          validate_data(obj, data, errors)
+        else
+          # if not a schema, value is an array of required fields
+          validate_required(schema, data, errors, obj)
+        end
+      end
+    end
+
+    def validate_format(schema, data, errors)
+      return true unless schema.format
+      valid = case schema.format
+      when "date-time"
+        data =~ DATE_TIME_PATTERN
+      when "email"
+        data =~ EMAIL_PATTERN
+      when "hostname"
+        data =~ HOSTNAME_PATTERN
+      when "ipv4"
+        data =~ IPV4_PATTERN
+      when "ipv6"
+        data =~ IPV6_PATTERN
+      when "uri"
+        data =~ URI.regexp
+      when "uuid"
+        data =~ UUID_PATTERN
+      end
+      if valid
+        true
+      else
+        message = %{Expected data to match "#{schema.format}" format, value was: #{data}.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_enum(schema, data, errors)
+      return true unless schema.enum
+      if schema.enum.include?(data)
+        true
+      else
+        message = %{Expected data to be a member of enum #{schema.enum}, value was: #{data}.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_items(schema, data, error)
+      return true unless schema.items
+      if schema.items.is_a?(Array)
+        if data.size < schema.items.count
+          message = %{Expected array to have at least #{schema.items.count} item(s), had #{data.size} item(s).}
+          errors << SchemaError.new(schema, message)
+          false
+        elsif data.size > schema.items.count && !schema.additional_items?
+          message = %{Expected array to have no more than #{schema.items.count} item(s), had #{data.size} item(s).}
+          errors << SchemaError.new(schema, message)
+          false
+        else
+          valid = true
+          schema.items.each_with_index do |subschema, i|
+            valid = strict_and valid,
+              validate_data(subschema, data[i], errors)
+          end
+          valid
+        end
+      else
+        valid = true
+        data.each do |value|
+          valid = strict_and valid, validate_data(schema.items, value, errors)
+        end
+        valid
+      end
+    end
+
+    def validate_max(schema, data, error)
+      return true unless schema.max
+      if schema.max_exclusive? && data < schema.max
+        true
+      elsif !schema.max_exclusive? && data <= schema.max
+        true
+      else
+        message = %{Expected data to be smaller than maximum #{schema.max} (exclusive: #{schema.max_exclusive?}), value was: #{data}.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_max_items(schema, data, error)
+      return true unless schema.max_items
+      if data.size <= schema.max_items
+        true
+      else
+        message = %{Expected array to have no more than #{schema.max_items} item(s), had #{data.size} item(s).}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_max_length(schema, data, error)
+      return true unless schema.max_length
+      if data.length <= schema.max_length
+        true
+      else
+        message = %{Expected string to have a maximum length of #{schema.max_length}, was #{data.length} character(s) long.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_max_properties(schema, data, error)
+      return true unless schema.max_properties
+      if data.keys.size <= schema.max_properties
+        true
+      else
+        message = %{Expected object to have a maximum of #{schema.max_properties} property/ies; it had #{data.keys.size}.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_min(schema, data, error)
+      return true unless schema.min
+      if schema.min_exclusive? && data > schema.min
+        true
+      elsif !schema.min_exclusive? && data >= schema.min
+        true
+      else
+        message = %{Expected data to be larger than minimum #{schema.min} (exclusive: #{schema.min_exclusive?}), value was: #{data}.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_min_items(schema, data, error)
+      return true unless schema.min_items
+      if data.size >= schema.min_items
+        true
+      else
+        message = %{Expected array to have at least #{schema.min_items} item(s), had #{data.size} item(s).}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_min_length(schema, data, error)
+      return true unless schema.min_length
+      if data.length >= schema.min_length
+        true
+      else
+        message = %{Expected string to have a minimum length of #{schema.min_length}, was #{data.length} character(s) long.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_min_properties(schema, data, error)
+      return true unless schema.min_properties
+      if data.keys.size >= schema.min_properties
+        true
+      else
+        message = %{Expected object to have a minimum of #{schema.min_properties} property/ies; it had #{data.keys.size}.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_multiple_of(schema, data, errors)
+      return true unless schema.multiple_of
+      if data % schema.multiple_of == 0
+        true
+      else
+        message = %{Expected data to be a multiple of #{schema.multiple_of}, value was: #{data}.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_one_of(schema, data, errors)
+      return true if schema.one_of.empty?
+      num_valid = schema.one_of.count do |subschema|
+        validate_data(subschema, data, [])
+      end
+      message = %{Data did not match exactly one subschema of "oneOf" condition.}
+      errors << SchemaError.new(schema, message) if num_valid != 1
+      num_valid == 1
+    end
+
+    def validate_not(schema, data, errors)
+      return true unless schema.not
+      # don't bother accumulating these errors, they'll all be worded
+      # incorrectly for the inverse condition
+      valid = !validate_data(schema.not, data, [])
+      message = %{Data matched subschema of "not" condition.}
+      errors << SchemaError.new(schema, message) if !valid
+      valid
+    end
+
+    def validate_pattern(schema, data, error)
+      return true unless schema.pattern
+      if data =~ schema.pattern
+        true
+      else
+        message = %{Expected string to match pattern "#{schema.pattern.inspect}", value was: #{data}.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_pattern_properties(schema, data, errors)
+      return true if schema.pattern_properties.empty?
+      valid = true
+      schema.pattern_properties.each do |pattern, subschema|
+        data.each do |key, value|
+          if key =~ pattern
+            valid = strict_and valid, validate_data(subschema, value, errors)
+          end
+        end
+      end
+      valid
+    end
+
+    def validate_properties(schema, data, errors)
+      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
+      end
+      valid
+    end
+
+    def validate_required(schema, data, errors, required)
+      return true if !required || required.empty?
+      if (missing = required - data.keys).empty?
+        true
+      else
+        message = %{Missing required keys in object: #{missing.sort.join(", ")}.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_type(schema, data, errors)
+      return true if schema.type.empty?
+      valid_types = schema.type.map { |t| TYPE_MAP[t] }.flatten.compact
+      if valid_types.any? { |t| data.is_a?(t) }
+        true
+      else
+        message = %{Expected data to be of type "#{schema.type.join("/")}"; value was: #{data.inspect}.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    def validate_unique_items(schema, data, error)
+      return true unless schema.unique_items?
+      if data.size == data.uniq.size
+        true
+      else
+        message = %{Expected array items to be unique, but duplicate items were found.}
+        errors << SchemaError.new(schema, message)
+        false
+      end
+    end
+
+    EMAIL_PATTERN = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i
+
+    HOSTNAME_PATTERN = /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?)*\.?$/
+
+    DATE_TIME_PATTERN = /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-2][0-9]:[0-5][0-9]:[0-5][0-9](Z|[\-+][0-9]{2}:[0-5][0-9])$/
+
+    # from: http://stackoverflow.com/a/17871737
+    IPV4_PATTERN = /^((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])$/
+
+    # from: http://stackoverflow.com/a/17871737
+    IPV6_PATTERN = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]).){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:)$/
+
+    UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
+  end
+end