json_schema_rails 0.0.1

data/lib/json_schema_rails/railtie.rb

@@ -0,0 +1,25 @@
+require "json_schema_rails/helpers"
+
+module JsonSchemaRails
+  class Railtie < ::Rails::Railtie
+    initializer "json_schema_rails.set_schema_loader" do |app|
+      if schema_file = Dir[app.root.join('app', 'schema.*')].first
+        loader = JsonSchemaRails::Loaders::HyperSchema.new(schema_file)
+      else
+        loader = JsonSchemaRails::Loaders::Directory.new(app.root.join('app', 'schemas').to_path)
+      end
+      loader.cache = false if Rails.env.development?
+      JsonSchemaRails.schema_loader = loader
+    end
+
+    initializer "json_schema_rails.include_helpers" do
+      ActiveSupport.on_load :action_controller do
+        include ::JsonSchemaRails::Helpers
+      end
+    end
+
+    rake_tasks do
+      load File.expand_path("../../tasks/schema_tasks.rake", __FILE__)
+    end
+  end
+end

data/lib/json_schema_rails/schema_validator.rb

@@ -0,0 +1,91 @@
+module JsonSchemaRails
+  class SchemaValidator
+    DEFAULT_SCHEMA_URI = 'http://json-schema.org/draft-04/schema'
+
+    attr_reader :meta_schemas
+
+    def initialize
+      @meta_schemas = MetaSchemas.new
+      @loader = Loader.new
+    end
+
+    def use_core_schemas!(options = {})
+      schemas_dir = File.expand_path('../../../schemas', __FILE__)
+      if options[:loose]
+        add_meta_schema_file Dir[File.join(schemas_dir, '*.json')]
+      else
+        add_meta_schema_file Dir[File.join(schemas_dir, 'strict', '*.json')]
+      end
+    end
+
+    def validate(schema_file)
+      content = @loader.render_schema_content(schema_file)
+
+      meta_schema_uri = content["$schema"] || content[:"$schema"] || DEFAULT_SCHEMA_URI
+      unless meta_schema_uri
+        raise JsonSchemaRails::SchemaNotFound, "No $schema specified"
+      end
+
+      meta_schema = @meta_schemas.lookup!(meta_schema_uri)
+      valid, errors = meta_schema.validate(content)
+      raise ValidationError.from_errors(errors, meta_schema) unless valid
+      true
+    end
+
+    protected
+
+    def add_meta_schema_file(*meta_schema_files)
+      meta_schema_files.flatten.each do |file|
+        @meta_schemas << @loader.load_schema!(file)
+      end
+      self
+    end
+
+    class MetaSchemas
+      include Enumerable
+
+      def initialize
+        @store = JsonSchema::DocumentStore.new
+        @expander = JsonSchema::ReferenceExpander.new
+      end
+
+      def <<(schema)
+        Array(schema).each do |file|
+          schema.expand_references!(store: @store)
+          @store.add_schema(schema)
+        end
+      end
+
+      def [](schema_uri)
+        @store.lookup_schema(schema_uri.sub(/#+$/, ''))
+      end
+
+      def lookup!(schema_uri)
+        self[schema_uri] or
+          raise JsonSchemaRails::SchemaNotFound, "Unknown $schema: #{schema_uri}"
+      end
+
+      def each
+        @store.each { |k, v| yield v }
+      end
+
+      def size
+        reduce(0) { |sum, n| sum + 1 }
+      end
+    end
+
+    class Loader < Loaders::Base
+      def initialize
+        super(cache: false)
+      end
+
+      def load_schema!(schema_path)
+        load_schema_file(schema_path)
+      end
+
+      def render_schema_content(schema_path)
+        load_schema_content(schema_path)
+      end
+    end
+  end
+end

data/lib/json_schema_rails/version.rb

@@ -0,0 +1,3 @@
+module JsonSchemaRails
+  VERSION = "0.0.1"
+end

data/lib/json_schema_rails.rb

@@ -0,0 +1,43 @@
+require "json_schema_rails/version"
+require "json_schema_rails/errors"
+require "json_schema_rails/loaders"
+require "json_schema_rails/schema_validator"
+require "json_schema_rails/railtie" if defined?(Rails)
+
+module JsonSchemaRails
+  def self.schema_loader
+    @schema_loader ||= Loaders::Directory.new('app/schemas')
+  end
+
+  def self.schema_loader=(loader)
+    @schema_loader = loader
+  end
+
+  def self.validate(schema_name, data)
+    schema = lookup_schema!(schema_name)
+    schema.validate(data)
+  end
+
+  def self.validate!(schema_name, data)
+    schema = lookup_schema!(schema_name)
+    valid, errors = schema.validate(data)
+    unless valid
+      raise ValidationError.from_errors(errors, schema, schema_name)
+    end
+    true
+  end
+
+  def self.lookup_schema(schema_name)
+    lookup_schema!(schema_name)
+  rescue SchemaNotFound
+    nil
+  end
+
+  def self.lookup_schema!(schema_name)
+    Array(schema_name).each do |name|
+      schema = schema_loader.load_schema(name)
+      return schema if schema
+    end
+    raise SchemaNotFound
+  end
+end

data/lib/tasks/schema_tasks.rake

@@ -0,0 +1,37 @@
+require "pathname"
+require "json_schema_rails/schema_validator"
+
+namespace :schema do
+  desc "Check syntax of schema files"
+  task :check do
+    validator = JsonSchemaRails::SchemaValidator.new.use_core_schemas!
+
+    find_root = defined?(Rails) ? Rails.root : Pathname.pwd
+    schema_paths = Dir[
+      find_root.join('app', 'schema.*'),
+      find_root.join('app', 'schemas', '**', '*.{json,yml,yaml}')
+    ]
+    if schema_paths.empty?
+      puts "No schema files found"
+      next
+    end
+
+    error_count = 0
+    schema_paths.each do |path|
+      begin
+        validator.validate(path)
+      rescue JsonSchemaRails::Error => e
+        relpath = Pathname.new(path).relative_path_from(find_root)
+        puts "#{relpath}: #{e.message}"
+        error_count += 1
+      end
+    end
+
+    if error_count == 0
+      STDERR.puts "All schema files has passed validation!"
+    else
+      STDERR.puts
+      abort "#{error_count} file(s) have failed for validation"
+    end
+  end
+end

data/schemas/core-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": {}
+}

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/strict/core-schema.json

@@ -0,0 +1,151 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "additionalProperties": false,
+    "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": {}
+}