json_schema 0.0.7

data/README.md

@@ -0,0 +1,36 @@
+# json_schema
+
+A JSON Schema V4 and Hyperschema V4 parser and validator.
+
+``` ruby
+require "json"
+require "json_schema"
+
+# parse the schema
+schema_data = JSON.parse(File.read("schema.json"))
+schema = JsonSchema.parse!(schema_data)
+
+# validate some data
+data = JSON.parse(File.read("data.json"))
+schema.validate!(data)
+
+# iterate through hyperschema links
+schema.links.each do |link|
+  puts "#{link.method} #{link.href}"
+end
+```
+
+## Development
+
+Run the test suite with:
+
+```
+rake
+```
+
+Or run specific suites or tests with:
+
+```
+ruby -Ilib -Itest test/json_schema/validator_test.rb
+ruby -Ilib -Itest test/json_schema/validator_test.rb -n /anyOf/
+```

data/lib/json_pointer.rb

@@ -0,0 +1,7 @@
+require_relative "json_pointer/evaluator"
+
+module JsonPointer
+  def self.evaluate(data, path)
+    Evaluator.new(data).evaluate(path)
+  end
+end

data/lib/json_pointer/evaluator.rb

@@ -0,0 +1,75 @@
+module JsonPointer
+  class Evaluator
+    def initialize(data)
+      @data = data
+    end
+
+    def evaluate(original_path)
+      path = original_path
+
+      # the leading # can either be included or not
+      path = path[1..-1] if path[0] == "#"
+
+      # special case on "" or presumably "#"
+      if path.empty?
+        return @data
+      end
+
+      if path[0] != "/"
+        raise %{Path must begin with a leading "/": #{original_path}.}
+      end
+
+      path_parts = split(path)
+      evaluate_segment(@data, path_parts)
+    end
+
+    private
+
+    def evaluate_segment(data, path_parts)
+      if path_parts.empty?
+        data
+      elsif data == nil
+        # spec doesn't define how to handle this, so we'll return `nil`
+        nil
+      else
+        key = transform_key(path_parts.shift)
+        if data.is_a?(Array)
+          unless key =~ /^\d+$/
+            raise %{Key operating on an array must be a digit or "-": #{key}.}
+          end
+          evaluate_segment(data[key.to_i], path_parts)
+        else
+          evaluate_segment(data[key], path_parts)
+        end
+      end
+    end
+
+    # custom split method to account for blank segments
+    def split(path)
+      parts = []
+      last_index = 0
+      while index = path.index("/", last_index)
+        if index == last_index
+          parts << ""
+        else
+          parts << path[last_index...index]
+        end
+        last_index = index + 1
+      end
+      # and also get that last segment
+      parts << path[last_index..-1]
+      # it should begin with a blank segment from the leading "/"; kill that
+      parts.shift
+      parts
+    end
+
+    def transform_key(key)
+      # ~ has special meaning to JSON pointer to allow keys containing "/", so
+      # perform some transformations first as defined by the spec
+      # first as defined by the spec
+      key = key.gsub('~1', '/')
+      key = key.gsub('~0', '~')
+      key
+    end
+  end
+end

data/lib/json_reference.rb

@@ -0,0 +1,39 @@
+require "json_pointer"
+require "uri"
+
+module JsonReference
+  class Reference
+    attr_accessor :pointer
+    attr_accessor :uri
+
+    def initialize(ref)
+      # given a simple fragment without '#', resolve as a JSON Pointer only as
+      # per spec
+      if ref.include?("#")
+        uri, @pointer = ref.split('#')
+        if uri && !uri.empty?
+          @uri = URI.parse(uri)
+        end
+      else
+        @pointer = ref
+      end
+
+      # normalize pointers by prepending "#"
+      @pointer = "#" + @pointer
+    end
+
+    # Given the document addressed by #uri, resolves the JSON Pointer part of
+    # the reference.
+    def resolve_pointer(data)
+      JsonPointer.evaluate(data, @pointer)
+    end
+
+    def to_s
+      if @uri
+        "#{@uri.to_s}#{@pointer}"
+      else
+        @pointer
+      end
+    end
+  end
+end

data/lib/json_schema.rb

@@ -0,0 +1,27 @@
+require_relative "json_schema/parser"
+require_relative "json_schema/reference_expander"
+require_relative "json_schema/schema"
+require_relative "json_schema/schema_error"
+require_relative "json_schema/validator"
+
+module JsonSchema
+  def self.parse(data)
+    parser = Parser.new
+    if schema = parser.parse(data)
+      valid, errors = schema.expand_references
+      if valid
+        [schema, nil]
+      else
+        [nil, errors]
+      end
+    else
+      [nil, parser.errors]
+    end
+  end
+
+  def self.parse!(data)
+    schema = Parser.new.parse!(data)
+    schema.expand_references!
+    schema
+  end
+end

data/lib/json_schema/parser.rb

@@ -0,0 +1,296 @@
+require "json_reference"
+
+module JsonSchema
+  class Parser
+    ALLOWED_TYPES = %w{any array boolean integer number null object string}
+    BOOLEAN = [FalseClass, TrueClass]
+    FRIENDLY_TYPES = {
+      Array      => "array",
+      FalseClass => "boolean",
+      Float      => "number",
+      Hash       => "object",
+      Integer    => "integer",
+      NilClass   => "null",
+      String     => "string",
+      TrueClass  => "boolean",
+    }
+
+    attr_accessor :errors
+
+    # Basic parsing of a schema. May return a malformed schema! (Use `#parse!`
+    # to raise errors instead).
+    def parse(data, parent = nil)
+      # while #parse_data is recursed into for many schemas over the same
+      # object, the @errors array is an instance-wide accumulator
+      @errors = []
+
+      schema = parse_data(data, parent)
+      if @errors.count == 0
+        schema
+      else
+        nil
+      end
+    end
+
+    def parse!(data, parent = nil)
+      schema = parse(data, parent)
+      if !schema
+        raise SchemaError.aggregate(@errors)
+      end
+      schema
+    end
+
+    private
+
+    def build_uri(id, parent_uri)
+      # kill any trailing slashes
+      if id
+        id = id.chomp("/")
+      end
+
+      # if id is missing, it's defined as its parent schema's URI
+      if id.nil?
+        parent_uri
+      # if id is defined as absolute, the schema's URI stays absolute
+      elsif id[0] == "/"
+        id
+      # otherwise build it according to the parent's URI
+      else
+        # make sure we don't end up with duplicate slashes
+        parent_uri = parent_uri.chomp("/")
+        parent_uri + "/" + id
+      end
+    end
+
+    def parse_all_of(schema)
+      if schema.all_of && schema.all_of.is_a?(Array)
+        schema.all_of = schema.all_of.map { |s| parse_data(s, schema) }
+      end
+    end
+
+    def parse_any_of(schema)
+      if schema.any_of && schema.any_of.is_a?(Array)
+        schema.any_of = schema.any_of.map { |s| parse_data(s, schema) }
+      end
+    end
+
+    def parse_one_of(schema)
+      if schema.one_of && schema.one_of.is_a?(Array)
+        schema.one_of = schema.one_of.map { |s| parse_data(s, schema) }
+      end
+    end
+
+    def parse_data(data, parent = nil)
+      schema = Schema.new
+
+      if !data.is_a?(Hash)
+        # it would be nice to make this message more specific/nicer (at best it
+        # points to the wrong schema)
+        message = %{Expected schema; value was: #{data.inspect}.}
+        @errors << SchemaError.new(parent, message)
+      elsif ref = data["$ref"]
+        schema.reference = JsonReference::Reference.new(ref)
+      else
+        schema = parse_schema(data, parent)
+      end
+
+      schema.parent = parent
+      schema
+    end
+
+    def parse_definitions(schema)
+      if schema.definitions && schema.definitions.is_a?(Hash)
+        # leave the original data reference intact
+        schema.definitions = schema.definitions.dup
+        schema.definitions.each do |key, definition|
+          subschema = parse_data(definition, schema)
+          schema.definitions[key] = subschema
+        end
+      end
+    end
+
+    def parse_dependencies(schema)
+      if schema.dependencies && schema.dependencies.is_a?(Hash)
+        # leave the original data reference intact
+        schema.dependencies = schema.dependencies.dup
+        schema.dependencies.each do |k, s|
+          # may be Array, String (simple dependencies), or Hash (schema
+          # dependency)
+          if s.is_a?(Hash)
+            schema.dependencies[k] = parse_data(s, schema)
+          elsif s.is_a?(String)
+            # just normalize all simple dependencies to arrays
+            schema.dependencies[k] = [s]
+          end
+        end
+      end
+    end
+
+    def parse_items(schema)
+      if schema.items
+        # tuple validation: an array of schemas
+        if schema.items.is_a?(Array)
+          schema.items = schema.items.map { |s| parse_data(s, schema) }
+        # list validation: a single schema
+        else
+          schema.items = parse_data(schema.items, schema)
+        end
+      end
+    end
+
+    def parse_links(schema)
+      if schema.links
+        schema.links = schema.links.map { |l|
+          link             = Schema::Link.new
+          link.parent      = schema
+
+          link.description = l["description"]
+          link.href        = l["href"]
+          link.method      = l["method"] ? l["method"].downcase.to_sym : nil
+          link.rel         = l["rel"]
+          link.title       = l["title"]
+
+          if l["schema"]
+            link.schema = parse_data(l["schema"], schema)
+          end
+
+          link
+        }
+      end
+    end
+
+    def parse_media(schema)
+      if data = schema.media
+        schema.media = Schema::Media.new
+        schema.media.binary_encoding = data["binaryEncoding"]
+        schema.media.type            = data["type"]
+      end
+    end
+
+    def parse_not(schema)
+      if schema.not && schema.not.is_a?(Hash)
+        schema.not = parse_data(schema.not, schema)
+      end
+    end
+
+    def parse_pattern_properties(schema)
+      if schema.pattern_properties && schema.pattern_properties.is_a?(Hash)
+        # leave the original data reference intact
+        properties = schema.pattern_properties.dup
+        properties = properties.map do |k, s|
+          [Regexp.new(k), parse_data(s, schema)]
+        end
+        schema.pattern_properties = Hash[*properties.flatten]
+      end
+    end
+
+    def parse_properties(schema)
+      # leave the original data reference intact
+      schema.properties = schema.properties.dup
+      if schema.properties && schema.properties.is_a?(Hash)
+        schema.properties.each do |key, definition|
+          subschema = parse_data(definition, schema)
+          schema.properties[key] = subschema
+        end
+      end
+    end
+
+    def parse_schema(data, parent = nil)
+      schema = Schema.new
+
+      schema.data        = data
+      schema.id          = validate_type(schema, [String], "id")
+
+      # build URI early so we can reference it in errors
+      schema.uri = parent ?  build_uri(schema.id, parent.uri) : "/"
+
+      schema.title       = validate_type(schema, [String], "title")
+      schema.description = validate_type(schema, [String], "description")
+      schema.default     = schema.data["default"]
+
+      # validation: any
+      schema.all_of        = validate_type(schema, [Array], "allOf") || []
+      schema.any_of        = validate_type(schema, [Array], "anyOf") || []
+      schema.definitions   = validate_type(schema, [Hash], "definitions") || {}
+      schema.enum          = validate_type(schema, [Array], "enum")
+      schema.one_of        = validate_type(schema, [Array], "oneOf") || []
+      schema.not           = validate_type(schema, [Hash], "not")
+      schema.type          = validate_type(schema, [Array, String], "type")
+      schema.type          = [schema.type] if schema.type.is_a?(String)
+      validate_known_type!(schema)
+
+      # validation: array
+      schema.additional_items = validate_type(schema, BOOLEAN, "additionalItems")
+      schema.items            = validate_type(schema, [Array, Hash], "items")
+      schema.max_items        = validate_type(schema, [Integer], "maxItems")
+      schema.min_items        = validate_type(schema, [Integer], "minItems")
+      schema.unique_items     = validate_type(schema, BOOLEAN, "uniqueItems")
+
+      # validation: number/integer
+      schema.max           = validate_type(schema, [Float, Integer], "maximum")
+      schema.max_exclusive = validate_type(schema, BOOLEAN, "exclusiveMaximum")
+      schema.min           = validate_type(schema, [Float, Integer], "minimum")
+      schema.min_exclusive = validate_type(schema, BOOLEAN, "exclusiveMinimum")
+      schema.multiple_of   = validate_type(schema, [Float, Integer], "multipleOf")
+
+      # validation: object
+      schema.additional_properties =
+        validate_type(schema, BOOLEAN, "additionalProperties")
+      schema.dependencies       = validate_type(schema, [Hash], "dependencies") || {}
+      schema.max_properties     = validate_type(schema, [Integer], "maxProperties")
+      schema.min_properties     = validate_type(schema, [Integer], "minProperties")
+      schema.pattern_properties = validate_type(schema, [Hash], "patternProperties") || {}
+      schema.properties         = validate_type(schema, [Hash], "properties") || {}
+      schema.required           = validate_type(schema, [Array], "required")
+
+      # validation: string
+      schema.format     = validate_type(schema, [String], "format")
+      schema.max_length = validate_type(schema, [Integer], "maxLength")
+      schema.min_length = validate_type(schema, [Integer], "minLength")
+      schema.pattern    = validate_type(schema, [String], "pattern")
+      schema.pattern    = Regexp.new(schema.pattern) if schema.pattern
+
+      # hyperschema
+      schema.links      = validate_type(schema, [Array], "links")
+      schema.media      = validate_type(schema, [Hash], "media")
+      schema.path_start = validate_type(schema, [String], "pathStart")
+      schema.read_only  = validate_type(schema, BOOLEAN, "readOnly")
+
+      parse_all_of(schema)
+      parse_any_of(schema)
+      parse_one_of(schema)
+      parse_definitions(schema)
+      parse_dependencies(schema)
+      parse_items(schema)
+      parse_links(schema)
+      parse_media(schema)
+      parse_not(schema)
+      parse_pattern_properties(schema)
+      parse_properties(schema)
+
+      schema
+    end
+
+    def validate_known_type!(schema)
+      if schema.type
+        if !(bad_types = schema.type - ALLOWED_TYPES).empty?
+          message = %{Unknown types: #{bad_types.sort.join(", ")}.}
+          @errors << SchemaError.new(schema, message)
+        end
+      end
+    end
+
+    def validate_type(schema, types, field)
+      friendly_types =
+        types.map { |t| FRIENDLY_TYPES[t] || t }.sort.uniq.join("/")
+      value = schema.data[field]
+      if !value.nil? && !types.any? { |t| value.is_a?(t) }
+        message = %{Expected "#{field}" to be of type "#{friendly_types}"; value was: #{value.inspect}.}
+        @errors << SchemaError.new(schema, message)
+        nil
+      else
+        value
+      end
+    end
+  end
+end