jschematic 0.0.1

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use 1.9.2@jschematic

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    jschematic (0.0.1)
+      addressable
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.4)
+    builder (3.0.0)
+    cucumber (0.10.0)
+      builder (>= 2.1.2)
+      diff-lcs (~> 1.1.2)
+      gherkin (~> 2.3.2)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+    diff-lcs (1.1.2)
+    gherkin (2.3.3)
+      json (~> 1.4.6)
+    json (1.4.6)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    term-ansicolor (1.0.5)
+    yajl-ruby (0.7.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cucumber
+  jschematic!
+  rspec
+  yajl-ruby

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Mike Sassak
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,48 @@
+# Jschematic
+
+Jschematic is a JSON Schema v3 Validator for Ruby.
+
+It is currently incomplete, alpha quality software.
+
+Having said that, most of the core schema definition is supported
+with these exceptions:
+
+ * $ref
+ * $schema
+ * extends
+ * divisibleBy
+ * disallow
+
+In addition to this, only IPv4, IPv6 and URI formats are currently
+implemented.
+
+Please report any bugs you find (and you will find bugs) at the issue
+tracker here: https://github.com/msassak/jschematic/issues.
+
+## Usage
+
+    require 'jschematic'
+    Jschematic.validate(json, schema)  # => true or false
+    Jschematic.validate!(json, schema) # => true or raise Jschematic::ValidationError
+
+`json` and `schema` above must be Ruby data structures, not real JSON.
+
+Jschematic doesn't care how you turn JSON into Ruby (though we use the
+fine yajl-ruby gem for testing).
+
+## Testing
+
+    $ cucumber
+    $ rspec spec
+
+Or `rake` if you want to run both.
+
+## Links
+
+* http://tools.ietf.org/html/draft-zyp-json-schema-03
+* https://github.com/kriszyp/json-schema
+* http://tools.ietf.org/html/rfc3986
+
+## Copyright
+
+Copyright (c) 2011 Mike Sassak. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,10 @@
+desc "Run Cukes and Specs"
+task :default => ["cukes", "spec"]
+
+task :cukes do
+  sh "cucumber"
+end
+
+task :spec do
+  sh "rspec spec"
+end

data/cucumber.yml

@@ -0,0 +1 @@
+default: -q --tags ~@ignore

data/features/default.feature

@@ -0,0 +1,72 @@
+Feature: Core schema: default
+
+  Scenario: validation succeeds because of default
+    When the schema is:
+      """
+      {
+          "properties": {
+              "name": {
+                  "type": "string",
+                  "required": true
+              }
+          },
+
+          "default": {
+              "name": "Gristle Thornbody"
+          }
+      }
+
+      """
+      Then '{ "age": 35 }' is valid JSON
+
+  Scenario: validation fails because of default
+    When the schema is:
+      """
+      {
+          "properties": {
+              "name": {
+                  "type": "string"
+              }
+          },
+
+          "default": {
+              "name": 1999
+          }
+      }
+      """
+    Then '{ "age": 35 }' is not valid JSON
+
+  Scenario: validation of property succeeds because of default
+    When the schema is:
+      """
+      {
+          "properties": {
+              "pi": {
+                  "type": "number",
+                  "required": true,
+                  "default": 3.1415
+              }
+          }
+      }
+      """
+    Then '{ "somethingElse": "foo" }' is valid JSON
+    But '{ "pi": "is delicious" }' is not valid JSON
+
+  Scenario: validation of property fails because of default
+    When the schema is:
+      """
+      {
+          "properties": {
+              "pi": {
+                  "type": "number",
+                  "required": true,
+                  "default": "is delicious"
+              }
+          }
+      }
+      """
+    Then '{ "somethingElse": "foo" }' is not valid JSON
+    But '{ "pi": 3.1415 }' is valid JSON
+
+  Scenario: default for all types
+    TODO: spec

data/features/dependencies.feature

@@ -0,0 +1,73 @@
+Feature: Core schema: dependencies
+  Scenario: depending on a single property name
+    When the schema is:
+      """
+      {
+          "dependencies": { "foo": "bar" }
+      }
+      """
+    Then this is valid JSON:
+      """
+      {
+          "foo": "baz",
+          "bar": "qux"
+      }
+      """
+    But this is not valid JSON:
+      """
+      {
+          "foo": "baz",
+          "wibble": "womble"
+      }
+      """
+
+  Scenario: depending on each item in list of property names
+    When the schema is:
+      """
+      {
+          "dependencies": { "foo": ["bar", "baz"] }
+      }
+      """
+    Then this is valid JSON:
+      """
+      {
+          "foo": "qux",
+          "bar": "quux",
+          "baz": "wibble"
+      }
+      """
+    But this is not valid JSON:
+      """
+      {
+          "foo": "qux",
+          "bar": "quux"
+      }
+      """
+      
+  Scenario: depend on schema
+    When the schema is:
+      """
+      {
+          "dependencies": {
+              "foo": {
+                  "properties": {
+                      "favoriteNumber": { "type": "number" }
+                  }
+              }
+          }
+      }
+      """
+    Then this is valid JSON:
+      """
+      {
+          "foo": "bar",
+          "favoriteNumber": 3.1415
+      }
+      """
+    But this is not valid JSON:
+      """
+      {
+          "foo": "bar",
+          "favoriteNumber": "eleventy million"
+      }
+      """

data/features/enum.feature

@@ -0,0 +1,26 @@
+Feature: Core schema: enum
+  Scenario: enum
+    When the schema is:
+      """
+      {
+          "enum": [1, "two", [[], [], []], { "four": 4 }]
+      }
+      """
+    Then these are valid JSON:
+      | 1             |
+      | "two"         |
+      | [[], [], []]  |
+      | { "four": 4 } |
+    But these are not valid JSON:
+      | "one"                  |
+      | 2                      |
+      | [true, false]          |
+      | { "name": "Mariposa" } |
+
+  Scenario: empty enum
+    When the schema is '{ "enum": [] }'
+    Then these are not valid JSON:
+      | ""   |
+      | []   |
+      | {}   |
+      | null |

data/features/format.feature

@@ -0,0 +1,40 @@
+Feature: Core schema: format
+  Scenario: URI
+    When the schema is:
+      """
+      {
+          "type": "string",
+          "format": "uri"
+      }
+      """
+    Then '"http://www.google.com"' is valid JSON
+    But '"http://"' is not valid JSON
+
+  Scenario: IPv4
+    When the schema is:
+      """
+      {
+          "type": "string",
+          "format": "ip-address"
+      }
+      """
+    Then '"127.0.0.1"' is valid JSON
+    But these are not valid JSON:
+      | ""                         |
+      | "fe80::202:b3ff:fe1e:8329" |
+
+  Scenario: IPv6
+    When the schema is:
+      """
+      {
+          "type": "string",
+          "format": "ipv6"
+      }
+      """
+    Then these are valid JSON:
+      | "2001:0db8:85a3:0000:0000:8a2e:0370:7334" |
+      | "fe80:0:0:0:202:b3ff:fe1e:8329"           |
+      | "fe80::202:b3ff:fe1e:8329"                |
+    But these are not valid JSON:
+      | ""          |
+      | "127.0.0.1" |

data/features/id.feature

@@ -0,0 +1,75 @@
+Feature: Core schema: id
+  Scenario: absolute URI, single schema
+    When the schema is:
+      """
+      {
+          "title": "Test Schema",
+          "id": "http://www.example.com/schemas/json"
+      }
+      """
+    Then the id of "Test Schema" is "http://www.example.com/schemas/json"
+
+  Scenario: relative URI, single schema
+    I-D says: "If this schema is not contained in any parent schema, the 
+    current URI of the parent schema is held to be the URI under which 
+    this schema was addressed."
+
+    I think this means that the id of the root schema is taken to be the 
+    URI from which the schema was retrieved, i.e. schema validators are
+    supposed to include an HTTP client, which seems a bit bonkers to me,
+    or the client passes in the URI from where the schema was retrieved, 
+    which is weird, but more palatable. The current implementation does
+    neither of these, but I don't think it's too important at this point. 
+
+    When the schema is:
+      """
+      {
+          "title": "Test Schema",
+          "id": "/schemas/json"
+      }
+      """
+    Then the id of "Test Schema" is "/schemas/json"
+
+  Scenario: absolute URI at root, absolute in child
+    When the schema is:
+      """
+      {
+          "title": "Root Schema",
+          "id": "http://www.example.com/schemas/root",
+          "properties": {
+              "child": {
+                  "title": "Child Schema",
+                  "id": "http://www.example.org/schemas/child"
+              }
+          }
+      }
+      """
+    Then the id of "Root Schema" is "http://www.example.com/schemas/root"
+    And the id of "Child Schema" is "http://www.example.org/schemas/child"
+
+  Scenario: absolute URI at root, relative in child
+    When the schema is:
+      """
+      {
+          "title": "Root Schema",
+          "id": "http://www.example.com/schemas/root/",
+          "properties": {
+              "relchild": {
+                  "title": "Relative Path Child Schema",
+                  "id": "child"
+              },
+              "fragchild": {
+                  "title": "Fragment Child Schema",
+                  "id": "#child"
+              },
+              "abspathchild": {
+                  "title": "Absolute Path Child Schema",
+                  "id": "/child"
+              }
+          }
+      }
+      """
+    Then the id of "Root Schema" is "http://www.example.com/schemas/root/"
+    And the id of "Fragment Child Schema" is "http://www.example.com/schemas/root/#child"
+    And the id of "Absolute Path Child Schema" is "http://www.example.com/child"
+    And the id of "Relative Path Child Schema" is "http://www.example.com/schemas/root/child"

data/features/items.feature

@@ -0,0 +1,90 @@
+Feature: Core schema: items, additionalItems, minItems, maxItems & uniqueItems
+  Scenario: single schema
+    When the schema is:
+      """
+      {
+          "items": {
+              "type": "string"
+          }
+      }
+      """
+    Then '["Felizberto", "Lil Wayne", "Albi"]' is valid JSON
+    And '[]' is valid JSON
+    But '["Felizberto", 2112, "Albi"]' is not valid JSON
+
+  Scenario: tuple typing with an array of schemas
+    When the schema is:
+      """
+      {
+          "items": [
+              { "type": "string" },
+              { "type": "integer" }
+          ]
+      }
+      """
+    Then '["Felizberto", 2112]' is valid JSON
+    And '["Felizberto", 2112, "Albi"]' is valid JSON
+    But '[2112, "Felizberto"]' is not valid JSON
+    And '["Felizberto", "Lil Wayne"]' is not valid JSON
+
+  Scenario: tuple typing when additional items is false
+    When the schema is:
+      """
+      {
+          "items": [ { "type": "string" } ],
+          "additionalItems": false 
+      }
+      """
+    Then '["Feliberto"]' is valid JSON
+    But '["Felizberto", "Albi"]' is not valid JSON
+
+  Scenario: tuple typing with additional items schema
+    When the schema is:
+      """
+      {
+          "items": [ { "type": "string" } ],
+          "additionalItems": { "type": "object" }
+      }
+      """
+    Then '["Albi", { "age": 24 }]' is valid JSON
+    But '["Albi", 24]' is not valid JSON
+
+  Scenario: instance JSON is not an array
+
+  Scenario: minItems
+    When the schema is '{ "minItems": 2 }'
+    Then '["apple", "orange", "pear"]' is valid JSON
+    And '["cucumber", "sativus"]' is valid JSON
+    But '["pomegranate"]' is not valid JSON
+
+  Scenario: maxItems
+    When the schema is '{ "maxItems": 2 }'
+    Then '["pomegranate"]' is valid JSON
+    And '["cucumber", "sativus"]' is valid JSON
+    But '["apple", "orange", "pear"]' is not valid JSON
+
+  Scenario: min and max together
+    When the schema is:
+      """
+      {
+          "minItems": 1,
+          "maxItems": 2
+      }
+      """
+    Then '["pomegranate"]' is valid JSON
+    And  '["cucumber", "sativus"]' is valid JSON
+    But '["apple", "orange", "pear"]' is not valid JSON
+    And '[]' is not valid JSON
+
+  Scenario: uniqueItems
+    When the schema is '{ "uniqueItems": true }'
+    Then these are valid JSON:
+      | [1,2]                    |
+      | ["a", "b"]               |
+      | [true, false]            |
+      | [{"foo": 1}, {"foo": 2}] |
+    But these are not valid JSON:
+      | [1,1]                    |
+      | ["a", "a"]               |
+      | [true, true]             |
+      | [{"foo": 1}, {"foo": 1}] |

data/features/min_length_max_length.feature

@@ -0,0 +1,20 @@
+Feature: Core schema: minLength & maxLength
+
+  Scenario: minLength
+    When the schema is '{ "minLength": 3 }'
+    Then '"foo"' is valid JSON
+    And '"quux"' is valid JSON
+    But '"aa"' is not valid JSON
+
+  Scenario: maxLength
+    When the schema is '{ "maxLength": 3 }'
+    Then '"aa"' is valid JSON
+    And '"foo"' is valid JSON
+    But '"quux"' is not valid JSON
+
+  Scenario: together
+    When the schema is '{ "minLength": 1, "maxLength": 2 }'
+    Then '"a"' is valid JSON
+    And '"aa"' is valid JSON
+    But '"aaa"' is not valid JSON
+    And '""' is not valid JSON

data/features/minimum_maximum.feature

@@ -0,0 +1,29 @@
+Feature: Core Schema: minimum, exclusiveMinimum, maximum & exclusiveMaximum
+
+  Scenario: minimum
+    When the schema is '{ "minimum": 25 }'
+    Then '26.1' is valid JSON
+    And '25' is valid JSON
+    But '24' is not valid JSON
+
+  Scenario: exclusiveMinimum
+    When the schema is:
+      """
+      { "minimum": 25, "exclusiveMinimum": true }
+      """
+    Then '26' is valid JSON
+    But '25' is not valid JSON
+
+  Scenario: maximum
+    When the schema is '{ "maximum": 25 }'
+    Then '25' is valid JSON
+    And '24.9' is valid JSON
+    But '25.1' is not valid JSON
+
+  Scenario: exclusiveMaximum
+    When the schema is:
+      """
+      { "maximum": 25, "exclusiveMaximum": true }
+      """
+    Then '24.9' is valid JSON
+    But '25' is not valid JSON

data/features/pattern.feature

@@ -0,0 +1,6 @@
+Feature: Core schema: pattern
+  Scenario: pattern
+    When the schema is '{ "pattern": "^wibble$" }'
+    Then '"wibble"' is valid JSON
+    But '"rewibble"' is not valid JSON
+    And '"wibbler"' is not valid JSON

data/features/pattern_properties.feature

@@ -0,0 +1,18 @@
+Feature: Core schema: patternProperties
+
+  Scenario: one pattern
+    When the schema is:
+      """
+      {
+          "patternProperties": {
+              "[Nn]ame$": { "type": "string" }
+          }
+      }
+      """
+    Then these are valid JSON:
+      | { "name": "Felizberto" }        |
+      | { "firstName": "Fitzheraldo" }  |
+      | { "fullName": "Inigo Montoya" } |
+    But these are not valid JSON:
+      | { "name": 2112 }      |
+      | { "named": "Werner" } |