jschematic 0.0.1

data/features/properties.feature

@@ -0,0 +1,124 @@
+Feature: Core Schema: properties & additionalProperties
+
+  Scenario: instance property values must conform to schema property definitions
+    When the schema is:
+      """
+      {
+          "properties": {
+              "name": { "type": "string" }
+          }
+      }
+      """
+    Then '{ "name": "Felizberto" }' is valid JSON
+    And '{ "color": "red" }' is valid JSON
+    But '{ "name": 12345" }' is not valid JSON
+
+  Scenario: With extra attribute
+    When the schema is:
+      """
+      {
+          "properties": {
+              "age": { "maximum": 25 }
+          }
+      }
+      """
+    Then '{ "age": 25, "color": "red" }' is valid JSON
+    But '{ "age": 26, "color": "red" }' is not valid JSON
+
+  Scenario: deeply nested
+    When the schema is:
+      """
+      {
+          "properties": {
+              "attributes": { 
+                  "properties": {
+                      "attribute": { 
+                          "type": "string" 
+                      }
+                  }
+              }
+          }
+      }
+      """
+    Then this is valid JSON:
+      """
+      {
+          "attributes": {
+              "attribute": "value"
+          }
+      }
+      """
+    But this is not valid JSON:
+      """
+      {
+          "attributes": {
+              "attribute": 2112
+          }
+      }
+      """
+
+  Scenario: additionalProperties is false
+    When the schema is:
+      """
+      {
+          "properties": {
+              "name": { "type": "string" },
+              "age": { "type": "integer" }
+          }, 
+
+          "additionalProperties": false
+      }
+      """
+    Then this is valid JSON:
+      """
+      {
+          "name": "Felizberto Albi",
+          "age": 24
+      }
+      """
+    But this is not valid JSON:
+      """
+      {
+          "name": "Felizberto Albi",
+          "age": 24,
+          "color": "red"
+      }
+      """
+
+  Scenario: additionalProperties defined by a schema 
+    When the schema is:
+      """
+      {
+          "properties": {
+              "name": { "type": "string" },
+              "age": { "type": "integer" }
+          },
+
+          "additionalProperties": {
+              "type": "string"
+          }
+      }
+      """
+    Then this is valid JSON:
+      """
+      {
+          "name": "Felizberto Albi",
+          "age": 24,
+          "color": "red"
+      }
+      """
+    But this is not valid JSON:
+      """
+      {
+          "name": "Felizberto Albi",
+          "age": 24,
+          "number": 2112
+      }
+      """
+
+  Scenario: when true
+    TODO: duh
+  Scenario: neither boolean nor schema
+    TODO: should fail loudly: move into spec
+  Scenario: empty instance
+    TODO: find out what the behavior here should be

data/features/required.feature

@@ -0,0 +1,42 @@
+Feature: Core schema: required
+  Scenario: default false 
+    When the schema is:
+      """
+      {
+          "properties": {
+              "color": { 
+                  "type": "string"
+              }
+          }
+      }
+      """
+    Then '{}' is valid JSON
+
+    When the schema is:
+      """
+      {
+          "properties": {
+              "color": {
+                  "type": "string",
+                  "required": false
+              }
+          }
+      }
+      """
+    Then '{}' is valid JSON
+
+  Scenario: true
+    When the schema is:
+      """
+      {
+          "properties": {
+              "color": {
+                  "type": "string",
+                  "required": true
+              }
+          }
+      }
+      """
+    Then '{ "color": "red" }' is valid JSON
+    But '{}' is not valid JSON
+    And '{ "age": 24 }' is not valid JSON

data/features/step_definitions/jschematic_steps.rb

@@ -0,0 +1,62 @@
+When /^the schema is '(.+)'$/ do |schema|
+  @schema = parse(schema)
+end
+
+When "the schema is:" do |schema|
+  @schema = parse(schema)
+end
+
+Then /^'(.+)' is valid JSON$/ do |json|
+  assert_valid(parse(json), @schema)
+end
+
+Then /^'(.+)' is not valid JSON$/ do |json|
+  assert_invalid(parse(json), @schema)
+end
+
+Then "this is valid JSON:" do |json|
+  assert_valid(parse(json), @schema)
+end
+
+Then "this is not valid JSON:" do |json|
+  assert_invalid(parse(json), @schema)
+end
+
+Then "these are valid JSON:" do |instances|
+  instances.raw.each do |row|
+    assert_valid(parse(row[0]), @schema)
+  end
+end
+
+Then "these are not valid JSON:" do |instances|
+  instances.raw.each do |row|
+    assert_invalid(parse(row[0]), @schema)
+  end
+end
+
+Then /^the id of "(.+)" is "(.+)"$/ do |title, uri|
+  schema = build_schema.find{ |el| el.title == title }
+  [schema.title, schema.id.to_s].should == [title, uri]
+end
+
+module JschematicWorld
+  def parse(json)
+    Yajl::Parser.parse(json)
+  rescue Yajl::ParseError => e
+    raise "Parsing '#{json}' failed with #{e.to_s}"
+  end
+
+  def assert_valid(json, raw_schema)
+    Jschematic.validate(json, raw_schema).should be_true
+  end
+
+  def assert_invalid(json, raw_schema)
+    Jschematic.validate(json, raw_schema).should be_false
+  end
+
+  def build_schema
+    @_schema ||= Jschematic::Schema.new(@schema)
+  end
+end
+
+World(JschematicWorld)

data/features/support/env.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__) + "/../../lib"))
+
+require 'rspec/expectations'
+require 'yajl'
+
+require 'jschematic'

data/features/type.feature

@@ -0,0 +1,76 @@
+Feature: Core Schema: type
+
+  Scenario: string
+    When the schema is '{ "type": "string" }'
+    Then '"hello, world"' is valid JSON
+
+  Scenario: number
+    When the schema is '{ "type": "number" }'
+    Then '3.14159' is valid JSON
+    And '-123.41235' is valid JSON
+    And '2112' is valid JSON
+    But '"1234"' is not valid JSON
+
+  Scenario: integer
+    When the schema is '{ "type": "integer" }'
+    Then '2112' is valid JSON
+    And '-12' is valid JSON
+    But '3.14159' is not valid JSON
+
+  Scenario: boolean
+    When the schema is '{ "type": "boolean" }'
+    Then 'true' is valid JSON
+    And 'false' is valid JSON
+
+  Scenario: object
+    When the schema is '{ "type": "object" }'
+    Then this is valid JSON:
+      """
+      { "person": "felizberto" }
+      """
+
+  Scenario: array
+    When the schema is '{ "type": "array" }'
+    Then this is valid JSON:
+      """
+      ["foo", "bar", "baz"]
+      """
+
+  Scenario: null
+    When the schema is '{ "type": "null" }'
+    Then 'null' is valid JSON
+
+  Scenario: any
+    When the schema is '{ "type": "any" }'
+    Then these are valid JSON:
+      | "Felizberto"   |
+      | 3.1415         |
+      | 2112           |
+      | true           |
+      | { "age": 24 }  |
+      | ["foo", "bar"] |
+      | null           |
+
+  Scenario: union
+    When the schema is '{ "type": ["string", "number"] }'
+    Then '"Felizberto"' is valid JSON
+    And '2112' is valid JSON
+    But 'true' is not valid JSON
+
+  Scenario: union allowing null values
+    When the schema is '{ "type": ["string", "null"] }'
+    Then 'null' is valid JSON
+
+  Scenario: union with schema element 
+    When the schema is:
+      """
+      {
+          "type": [
+              "string", 
+              { "type": "integer", "maximum": 2112 }
+          ]
+      }
+      """
+    Then '"Felizberto"' is valid JSON
+    And '2112' is valid JSON
+    But '2113' is not valid JSON

data/jschematic.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name        = 'jschematic'
+  s.version     = '0.0.1'
+  s.authors     = ["Mike Sassak"]
+  s.description = "JSON Schema v3 Validator"
+  s.summary     = "jschematic #{s.version}"
+  s.email       = "msassak@gmail.com"
+  s.homepage    = "https://github.com/msassak/jschematic"
+
+  s.add_dependency 'addressable'
+
+  s.add_development_dependency 'cucumber'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'yajl-ruby'
+
+  s.rubygems_version   = "1.3.7"
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {spec,features}/*`.split("\n")
+  s.extra_rdoc_files = ["LICENSE", "README.md"]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = "lib"
+end

data/lib/jschematic/attributes/additional_items.rb

@@ -0,0 +1,35 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class AdditionalItems
+      include Jschematic::Element
+
+      def initialize(allowed, &block)
+        case items = block.call("items")
+        when Array
+          @allowed = allowed
+          @tuple_types_count = items.length
+        else
+          # TODO spec: additionalItems applies only with tuple-typing, so
+          # even if it is set to false we allow anything... should probably raise
+          # but the I-D is silent on the proper behavior in that case.
+          @allowed = true
+        end
+      end
+
+      def accepts?(instance)
+        return true if TrueClass === @allowed
+
+        case @allowed
+        when FalseClass
+          (instance.length == @tuple_types_count) || fail_validation!("#{@tuple_types_count} items", "#{instance.length} items")
+        when Hash
+          schema = Schema.new(@allowed)
+          additional = instance[@tuple_types_count..-1]
+          additional.all?{ |item| schema.accepts?(item) }
+        end
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/additional_properties.rb

@@ -0,0 +1,28 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class AdditionalProperties
+      include Jschematic::Element
+
+      # TODO: rename value to allowed
+      def initialize(value, &block)
+        @value = value
+        @properties = block.call("properties").keys
+      end
+
+      def accepts?(instance)
+        case @value
+        when FalseClass
+          (@properties == instance.keys) || fail_validation!(@properties, instance.keys)
+        when Hash
+          schema = Schema.new(@value)
+          additional = instance.select{ |attribute, value| !@properties.include?(attribute) }
+          additional.all? do |attribute, value|
+            schema.accepts?(value)
+          end || fail_validation!(@value, instance)
+        end
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/dependencies.rb

@@ -0,0 +1,26 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class Dependencies
+      include Jschematic::Element
+
+      def initialize(dependencies)
+        @dependencies = dependencies
+      end
+
+      def accepts?(instance)
+        instance.keys.all? do |property|
+          case deps = @dependencies[property]
+          when String, Array
+            [deps].flatten.all?{ |req| instance.keys.include?(req) }
+          when Hash
+            Schema.new(deps).accepts?(instance)
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/enum.rb

@@ -0,0 +1,18 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class Enum
+      include Jschematic::Element
+
+      def initialize(enum)
+        raise "Enum requires an Array of possible values" unless Array === enum
+        @enum = enum
+      end
+
+      def accepts?(instance)
+        @enum.any?{ |e| e == instance } || fail_validation!("one of #{@enum}", instance)
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/exclusive_maximum.rb

@@ -0,0 +1,21 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class ExclusiveMaximum
+      include Jschematic::Element
+
+      def initialize(enabled, &block)
+        @enabled = enabled
+        @maximum = block.call("maximum") if block_given?
+        raise "'exclusiveMaximum' depends on 'maximum'" unless @maximum
+      end
+
+      def accepts?(actual)
+        if @enabled
+          (actual < @maximum) || fail_validation!("< #{@maximum}", actual)
+        end
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/exclusive_minimum.rb

@@ -0,0 +1,21 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class ExclusiveMinimum
+      include Jschematic::Element
+
+      def initialize(enabled, &block)
+        @enabled = enabled
+        @minimum = block.call("minimum") if block_given?
+        raise "'exclusiveMinimum' depends on 'minimum'" unless @minimum
+      end
+
+      def accepts?(actual)
+        if @enabled
+          (actual > @minimum) || fail_validation!("> #{@minimum}", actual)
+        end
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/format.rb

@@ -0,0 +1,56 @@
+require 'ipaddr'
+require 'addressable/uri'
+
+module Jschematic
+  module Attributes
+    module Format
+      def self.new(format)
+        case format
+        when "uri"
+          Uri.new
+        when "ip-address", "ipv6"
+          Ip.new(format)
+        else
+          NullFormat.new
+        end
+      end
+
+      class Uri
+        include Jschematic::Element
+
+        def accepts?(uri)
+          Addressable::URI.parse(uri)
+        rescue Addressable::URI::InvalidURIError
+          false
+        end
+      end
+
+      class Ip
+        include Jschematic::Element
+
+        def initialize(version)
+          @method = case version
+          when "ip-address"
+            :ipv4?
+          when "ipv6"
+            :ipv6?
+          end
+        end
+
+        def accepts?(addr)
+          IPAddr.new(addr).send(@method)
+        rescue ArgumentError
+          false
+        end
+      end
+
+      class NullFormat
+        include Jschematic::Element
+
+        def accepts?(instance)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/items.rb

@@ -0,0 +1,24 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class Items
+      include Jschematic::Element
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def accepts?(instance)
+        case @schema
+        when Hash
+          instance.all?{ |item| Schema.new(@schema).accepts?(item) }
+        when Array
+          @schema.zip(instance).all?{ |schema, item| Schema.new(schema).accepts?(item) }
+            # TODO: There is a bug here similar to the one in the Union type;
+            #       the error reported does not mention the failure is w/i an item attribute
+        end || fail_validation!(@schema, instance) 
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/max_items.rb

@@ -0,0 +1,18 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class MaxItems
+      include Jschematic::Element
+
+      def initialize(max_items)
+        @max_items = max_items
+      end
+
+      def accepts?(instance)
+        return true unless Array === instance
+        (instance.length <= @max_items) || fail_validation!("at most #{@max_items}", instance.length)
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/max_length.rb

@@ -0,0 +1,18 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class MinLength
+      include Jschematic::Element
+
+      def initialize(length)
+        @length = length
+      end
+
+      def accepts?(instance)
+        return true unless String === instance
+        (instance.length >= @length) || fail_validation!("minimum length of #{@length}", instance.length)
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/maximum.rb

@@ -0,0 +1,22 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class Maximum
+      include Jschematic::Element
+
+      attr_reader :maximum
+
+      def initialize(maximum)
+        @maximum = maximum
+      end
+      
+      def accepts?(number)
+        return true unless maximum
+        return true unless (number.kind_of?(Integer) || number.kind_of?(Float))
+
+        (number <= maximum) || fail_validation!("<= #{@maximum}", number)
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/min_items.rb

@@ -0,0 +1,18 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class MinItems
+      include Jschematic::Element
+
+      def initialize(min_items)
+        @min_items = min_items
+      end
+
+      def accepts?(instance)
+        return true unless Array === instance
+        (instance.length >= @min_items) || fail_validation!("at least #{@min_items}", instance.length)
+      end
+    end
+  end
+end

data/lib/jschematic/attributes/min_length.rb

@@ -0,0 +1,18 @@
+require 'jschematic/element'
+
+module Jschematic
+  module Attributes
+    class MaxLength
+      include Jschematic::Element
+
+      def initialize(length)
+        @length = length
+      end
+
+      def accepts?(instance)
+        return true unless String === instance
+        (instance.length <= @length) || fail_validation!("maximum length of #{@length}", instance.length)
+      end
+    end
+  end
+end