dato_json_schema 0.20.8

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": {}
+}

data/test/bin_test.rb

@@ -0,0 +1,19 @@
+require "test_helper"
+
+#
+# The purpose of this sets of tests is just to test our Ruby executables
+# where possible so that we can get very basic sanity checks on their syntax.
+#
+# We can do this without actually executing them with a "ruby -c" call.
+#
+
+describe "executables in bin/" do
+  before do
+    @bin_dir = File.expand_path("../../bin", __FILE__)
+  end
+
+  it "has roughly valid Ruby structure for validate-schema" do
+    IO.popen(["ruby", "-c", File.join(@bin_dir, "validate-schema")]) { |io| io.read }
+    assert_equal $?.exitstatus, 0, "Ruby syntax check failed; see error above"
+  end
+end

data/test/commands/validate_schema_test.rb

@@ -0,0 +1,121 @@
+require "test_helper"
+
+require "commands/validate_schema"
+require "tempfile"
+
+describe Commands::ValidateSchema do
+  before do
+    @command = Commands::ValidateSchema.new
+  end
+
+  it "shows usage with no arguments" do
+    success = @command.run([])
+    assert_equal [], @command.errors
+    assert_equal [], @command.messages
+    refute success
+  end
+
+  it "runs successfully in fail fast mode" do
+    temp_file(basic_schema) do |path|
+      @command.fail_fast = true
+      success = @command.run([schema_path, path])
+      assert_equal [], @command.errors
+      assert_equal ["#{path} is valid."], @command.messages
+      assert success
+    end
+  end
+
+  it "runs successfully in detect mode" do
+    temp_file(basic_schema) do |path|
+      @command.extra_schemas << schema_path
+      @command.detect = true
+      success = @command.run([path])
+      assert_equal [], @command.errors
+      assert_equal ["#{path} is valid."], @command.messages
+      assert success
+    end
+  end
+
+  it "runs successfully out of detect mode" do
+    temp_file(basic_schema) do |path|
+      @command.detect = false
+      success = @command.run([schema_path, path])
+      assert_equal [], @command.errors
+      assert_equal ["#{path} is valid."], @command.messages
+      assert success
+    end
+  end
+
+  it "takes extra schemas" do
+    temp_file(basic_hyper_schema) do |path|
+      @command.detect = false
+      @command.extra_schemas << schema_path
+      success = @command.run([hyper_schema_path, path])
+      assert_equal [], @command.errors
+      assert_equal ["#{path} is valid."], @command.messages
+      assert success
+    end
+  end
+
+  it "requires at least one argument in detect mode" do
+    @command.detect = true
+    success = @command.run([])
+    assert_equal [], @command.errors
+    assert_equal [], @command.messages
+    refute success
+  end
+
+  it "requires at least two arguments out of detect mode" do
+    @command.detect = false
+    success = @command.run([hyper_schema_path])
+    assert_equal [], @command.errors
+    assert_equal [], @command.messages
+    refute success
+  end
+
+  it "errors on invalid files" do
+    @command.detect = false
+    success = @command.run(["dne-1", "dne-2"])
+    assert_equal ["dne-1: No such file or directory."], @command.errors
+    assert_equal [], @command.messages
+    refute success
+  end
+
+  it "errors on empty files" do
+    temp_file("") do |path|
+      success = @command.run([hyper_schema_path, path])
+      assert_equal ["#{path}: File is empty."], @command.errors
+      refute success
+    end
+  end
+
+  def basic_hyper_schema
+    <<-eos
+      { "$schema": "http://json-schema.org/draft-04/hyper-schema" }
+    eos
+  end
+
+  def basic_schema
+    <<-eos
+      { "$schema": "http://json-schema.org/draft-04/schema" }
+    eos
+  end
+
+  def hyper_schema_path
+    File.expand_path("schema.json", "#{__FILE__}/../../../schemas")
+  end
+
+  def schema_path
+    File.expand_path("schema.json", "#{__FILE__}/../../../schemas")
+  end
+
+  def temp_file(contents)
+    file = Tempfile.new("schema")
+    file.write(contents)
+    file.size() # flush
+    yield(file.path)
+  ensure
+    file.close
+    file.unlink
+  end
+end