json-schema 0.1.1 → 0.1.3

data/README.textile

@@ -36,6 +36,16 @@ data = {
 }
 
 JSON::Validator.validate(schema, data)
+
+data = {
+  "a" => "taco"
+}
+
+begin
+  JSON::Validator.validate2(schema, data)
+rescue ValidationError
+  puts $!.message
+end
 </pre>
   
 
@@ -90,6 +100,5 @@ In addition, the following hyper schema attributes are not implemented at this t
 
 h2. To Do
 
-* Massive re-factoring - the whole validation process needs to be broken down into something a bit more manageable
 * (Much) More testing
-* Better interface to validator to allow for error messages in validation to propogate
+* Adding a persistence option to schemas that enables the validator to only load schemas once across multiple validations

data/lib/json-schema/validator.rb

@@ -4,8 +4,43 @@ require 'pathname'
 require 'bigdecimal'
 
 module JSON
+  
+    class ValidationError < Exception
+      attr_reader :fragments, :schema
+      
+      def initialize(message, fragments, schema)
+        @fragments = fragments
+        @schema = schema
+        super(message)
+      end
+    end
+  
     class Validator
     
+    ValidationMethods = [
+      "type",
+      "disallow",
+      "minimum",
+      "maximum",
+      "minItems",
+      "maxItems",
+      "uniqueItems",
+      "pattern",
+      "minLength",
+      "maxLength",
+      "divisibleBy",
+      "enum",
+      "properties",
+      "patternProperties",
+      "additionalProperties",
+      "items",
+      "additionalItems",
+      "dependencies",
+      "extends",
+      "$ref"
+    ]
+    
+    
     def initialize(schema_data, data)
       @schemas = {}
       @base_schema = initialize_schema(schema_data)
@@ -16,114 +51,279 @@ module JSON
     end  
     
     
+    # Run a simple true/false validation of data against a schema
     def validate()
-      validate_schema(@base_schema, @data)
+      begin
+        validate_schema(@base_schema, @data, [])
+        return true
+      rescue ValidationError
+        return false
+      end
     end
     
     
-    def validate_schema(current_schema, data)
-      valid = true # Actually doing true/false on validation. Return at any point if invalid
+    # Validate data against a schema, returning nil if the data is valid. If the data is invalid, 
+    # a ValidationError will be raised with links to the specific location that the first error
+    # occurred during validation 
+    def validate2()
+      validate_schema(@base_schema, @data, [])
+      nil
+    end
+    
+    
+    # Validate the current schema
+    def validate_schema(current_schema, data, fragments)
       
-      # Check the type
-      if current_schema.schema['type']
-        valid = validate_type(current_schema.schema['type'],data,current_schema)
-      end
-      return valid if !valid
-      if current_schema.schema['disallow']
-        valid = !validate_type(current_schema.schema['disallow'],data,current_schema)
+      ValidationMethods.each do |method|
+        if current_schema.schema[method]
+          self.send(("validate_" + method.sub('$','')).to_sym, current_schema, data, fragments)
+        end
       end
-      return valid if !valid
       
-      # Check the values
-      if current_schema.schema['minimum'] && data.is_a?(Numeric)
-        valid = current_schema.schema['exclusiveMinimum'] ? data > current_schema.schema['minimum'] : data >= current_schema.schema['minimum']
-      end
-      return valid if !valid
+      data
+    end
+    
+    
+    # Validate the type
+    def validate_type(current_schema, data, fragments, disallow=false)
+      union = true
       
-      if current_schema.schema['maximum'] && data.is_a?(Numeric)
-        valid = current_schema.schema['exclusiveMaximum'] ? data < current_schema.schema['maximum'] : data <= current_schema.schema['maximum']
+      if disallow
+        types = current_schema.schema['disallow']
+      else
+        types = current_schema.schema['type']
       end
-      return valid if !valid
       
-      if current_schema.schema['minItems'] && data.is_a?(Array)
-        valid = data.nitems >= current_schema.schema['minItems']
+      if !types.is_a?(Array)
+        types = [types]
+        union = false
       end
-      return valid if !valid
+      valid = false
       
-      if current_schema.schema['maxItems'] && data.is_a?(Array)
-        valid = data.nitems <= current_schema.schema['maxItems']
+      types.each do |type|
+        if type.is_a?(String)
+          case type
+          when "string"
+            valid = data.is_a?(String)
+          when "number"
+            valid = data.is_a?(Numeric)
+          when "integer"
+            valid = data.is_a?(Integer)
+          when "boolean"
+            valid = (data.is_a?(TrueClass) || data.is_a?(FalseClass))
+          when "object"
+            valid = data.is_a?(Hash)
+          when "array"
+            valid = data.is_a?(Array)
+          when "null"
+            valid = data.is_a?(NilClass)
+          when "any"
+            valid = true
+          else
+            valid = true
+          end
+        elsif type.is_a?(Hash) && union
+          # Validate as a schema
+          schema = JSON::Schema.new(type,current_schema.uri)
+          begin
+            validate_schema(schema,data,fragments)
+            valid = true
+          rescue ValidationError
+            # We don't care that these schemas don't validate - we only care that one validated
+          end
+        end
+
+        break if valid
       end
-      return valid if !valid
       
-      if current_schema.schema['uniqueItems'] && data.is_a?(Array)
+      if (disallow)
+        if valid
+          message = "The property '#{build_fragment(fragments)}' matched one or more of the following types:"
+          types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
+          message.chop!
+          raise ValidationError.new(message, fragments, current_schema)
+        end
+      elsif !valid
+        message = "The property '#{build_fragment(fragments)}' did not match one or more of the following types:"
+        types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
+        message.chop!
+        raise ValidationError.new(message, fragments, current_schema)
+      end
+    end
+    
+    
+    # Validate the disallowed types
+    def validate_disallow(current_schema, data, fragments)
+      validate_type(current_schema, data, fragments, true)
+    end
+    
+    
+    # Validate the minimum value of a number
+    def validate_minimum(current_schema, data, fragments)
+      if data.is_a?(Numeric)
+        if (current_schema.schema['exclusiveMinimum'] ? data <= current_schema.schema['minimum'] : data < current_schema.schema['minimum'])
+          message = "The property '#{build_fragment(fragments)}' did not have a minimum value of #{current_schema.schema['minimum']}, "
+          message += current_schema.schema['exclusiveMinimum'] ? 'exclusively' : 'inclusively'
+          raise ValidationError.new(message, fragments, current_schema)
+        end
+      end
+    end
+    
+    
+    # Validate the maximum value of a number
+    def validate_maximum(current_schema, data, fragments)
+      if data.is_a?(Numeric)
+        if (current_schema.schema['exclusiveMaximum'] ? data >= current_schema.schema['maximum'] : data > current_schema.schema['maximum'])
+          message = "The property '#{build_fragment(fragments)}' did not have a maximum value of #{current_schema.schema['maximum']}, "
+          message += current_schema.schema['exclusiveMaximum'] ? 'exclusively' : 'inclusively'
+          raise ValidationError.new(message, fragments, current_schema)
+        end
+      end
+    end
+    
+    
+    # Validate the minimum number of items in an array
+    def validate_minItems(current_schema, data, fragments)
+      if data.is_a?(Array) && (data.nitems < current_schema.schema['minItems'])
+        message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of items #{current_schema.schema['minItems']}"
+        raise ValidationError.new(message, fragments, current_schema)
+      end
+    end
+    
+    
+    # Validate the maximum number of items in an array
+    def validate_maxItems(current_schema, data, fragments)
+      if data.is_a?(Array) && (data.nitems > current_schema.schema['maxItems'])
+        message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of items #{current_schema.schema['minItems']}"
+        raise ValidationError.new(message, fragments, current_schema)
+      end
+    end
+    
+    
+    # Validate the uniqueness of elements in an array
+    def validate_uniqueItems(current_schema, data, fragments)
+      if data.is_a?(Array)
         d = data.clone
         dupes = d.uniq!
-        valid = dupes.nil?
+        if dupes
+          message = "The property '#{build_fragment(fragments)}' contained duplicated array values"
+          raise ValidationError.new(message, fragments, current_schema)
+        end
       end
-      return valid if !valid
-      
-      if current_schema.schema['pattern'] && data.is_a?(String)
+    end
+    
+    
+    # Validate a string matches a regex pattern
+    def validate_pattern(current_schema, data, fragments)
+      if data.is_a?(String)
         r = Regexp.new(current_schema.schema['pattern'])
-        valid = !(r.match(data)).nil?
+        if (r.match(data)).nil?
+          message = "The property '#{build_fragment(fragments)}' did not match the regex '#{current_schema.schema['pattern']}'"
+          raise ValidationError.new(message, fragments, current_schema)
+        end
       end
-      return valid if !valid
-      
-      if current_schema.schema['minLength'] && data.is_a?(String)
-        valid = data.length >= current_schema.schema['minLength']
+    end
+    
+    
+    # Validate a string is at least of a certain length
+    def validate_minLength(current_schema, data, fragments)
+      if data.is_a?(String)
+        if data.length < current_schema.schema['minLength']
+          message = "The property '#{build_fragment(fragments)}' was not of a minimum string length of #{current_schema.schema['minLength']}"
+          raise ValidationError.new(message, fragments, current_schema)
+        end
       end
-      return valid if !valid
-      
-      if current_schema.schema['maxLength'] && data.is_a?(String)
-        valid = data.length <= current_schema.schema['maxLength']
+    end
+    
+    
+    # Validate a string is at maximum of a certain length
+    def validate_maxLength(current_schema, data, fragments)
+      if data.is_a?(String)
+        if data.length > current_schema.schema['maxLength']
+          message = "The property '#{build_fragment(fragments)}' was not of a maximum string length of #{current_schema.schema['maxLength']}"
+          raise ValidationError.new(message, fragments, current_schema)
+        end
       end
-      return valid if !valid
-      
-      if current_schema.schema['divisibleBy'] && data.is_a?(Numeric)
-        if current_schema.schema['divisibleBy'] == 0 || current_schema.schema['divisibleBy'] == 0.0
-          return false
-        else
-          valid = (BigDecimal.new(data.to_s) % BigDecimal.new(current_schema.schema['divisibleBy'].to_s)).to_f == 0
+    end
+    
+    
+    # Validate a numeric is divisible by another numeric
+    def validate_divisibleBy(current_schema, data, fragments)
+      if data.is_a?(Numeric)
+        if current_schema.schema['divisibleBy'] == 0 || 
+           current_schema.schema['divisibleBy'] == 0.0 ||
+           (BigDecimal.new(data.to_s) % BigDecimal.new(current_schema.schema['divisibleBy'].to_s)).to_f != 0
+           message = "The property '#{build_fragment(fragments)}' was not divisible by #{current_schema.schema['divisibleBy']}"
+           raise ValidationError.new(message, fragments, current_schema)
         end
       end
-      return valid if !valid
-      
-      if current_schema.schema['enum']
-        valid = current_schema.schema['enum'].include?(data)
+    end
+    
+    
+    # Validate an item matches at least one of an array of values
+    def validate_enum(current_schema, data, fragments)
+      if !current_schema.schema['enum'].include?(data)
+        message = "The property '#{build_fragment(fragments)}' did not match one of the following values:"
+        current_schema.schema['enum'].each {|val|
+          if val.is_a?(NilClass)
+            message += " null,"
+          elsif val.is_a?(Array)
+            message += " (array),"
+          elsif val.is_a?(Hash)
+            message += " (object),"
+          else
+            message += " #{val.to_s},"
+          end
+        }
+        message.chop!
+        raise ValidationError.new(message, fragments, current_schema)
       end
-      return valid if !valid
-      
-      
-      if current_schema.schema['properties'] && data.is_a?(Hash)
+    end
+    
+    
+    # Validate a set of properties of an object
+    def validate_properties(current_schema, data, fragments)
+      if data.is_a?(Hash)
         current_schema.schema['properties'].each do |property,property_schema|
-          valid = false if (property_schema['required'] && !data.has_key?(property))
+          if (property_schema['required'] && !data.has_key?(property))
+            message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
+            raise ValidationError.new(message, fragments, current_schema)
+          end
           
           if data.has_key?(property)
             schema = JSON::Schema.new(property_schema,current_schema.uri)
-            valid = validate_schema(schema, data[property])
+            fragments << property
+            validate_schema(schema, data[property], fragments)
+            fragments.pop
           end
-          return valid if !valid
         end
       end
-      return valid if !valid
-      
-      if current_schema.schema['patternProperties'] && data.is_a?(Hash)
-        current_schema.schema['properties'].each do |property,property_schema|
-          
+    end
+    
+    
+    # Validate properties of an object against a schema when the property name matches a specific regex
+    def validate_patternProperties(current_schema, data, fragments)
+      if data.is_a?(Hash)
+        current_schema.schema['patternProperties'].each do |property,property_schema|
           r = Regexp.new(property)
           
           # Check each key in the data hash to see if it matches the regex
           data.each do |key,value|
             if r.match(key)
               schema = JSON::Schema.new(property_schema,current_schema.uri)
-              valid = validate_schema(schema, data[key])
+              fragments << key
+              validate_schema(schema, data[key], fragments)
+              fragments.pop
             end
-            return valid if !valid
           end
         end
       end
-      return valid if !valid
-      
-      if current_schema.schema['additionalProperties'] && data.is_a?(Hash)
+    end
+    
+    
+    # Validate properties of an object that are not defined in the schema at least validate against a set of rules
+    def validate_additionalProperties(current_schema, data, fragments)
+      if data.is_a?(Hash)
         extra_properties = data.keys
         
         if current_schema.schema['properties']
@@ -142,162 +342,145 @@ module JSON
           end
         end
         
-        if current_schema.schema['additionalProperties'] == false
-          valid = extra_properties.empty?
+        if current_schema.schema['additionalProperties'] == false && !extra_properties.empty?
+          message = "The property '#{build_fragment(fragments)}' contains additional properties outside of the schema when none are allowed"
+          raise ValidationError.new(message, fragments, current_schema)
         elsif current_schema.schema['additionalProperties'].is_a?(Hash)
           data.each do |key,value|
             schema = JSON::Schema.new(current_schema.schema['additionalProperties'],current_schema.uri)
-            valid = validate_schema(schema,value)
-            return valid if !valid
+            fragments << key
+            validate_schema(schema, value, fragments)
+            fragments.pop
           end
         end
       end
-      return valid if !valid
-      
-      if current_schema.schema['items'] && data.is_a?(Array)
-        if current_schema.schema['items'].is_a?(Hash)
-          data.each do |item|
-            schema = JSON::Schema.new(current_schema.schema['items'],current_schema.uri)
-            valid = validate_schema(schema,item)
-            return valid if !valid
-          end
-        elsif current_schema.schema['items'].is_a?(Array)
-          current_schema.schema['items'].each_with_index do |item_schema,i|
-            schema = JSON::Schema.new(item_schema,current_schema.uri)
-            valid = validate_schema(schema,data[i])
-            return valid if !valid
-          end
-        end
+    end
+    
+    
+    # Validate items in an array match a schema or a set of schemas
+    def validate_items(current_schema, data, fragments)
+      if data.is_a?(Array)
+         if current_schema.schema['items'].is_a?(Hash)
+           data.each_with_index do |item,i|
+             schema = JSON::Schema.new(current_schema.schema['items'],current_schema.uri)
+             fragments << i.to_s
+             validate_schema(schema,item,fragments)
+             fragments.pop
+           end
+         elsif current_schema.schema['items'].is_a?(Array)
+           current_schema.schema['items'].each_with_index do |item_schema,i|
+             schema = JSON::Schema.new(item_schema,current_schema.uri)
+             fragments << i.to_s
+             validate_schema(schema,data[i],fragments)
+             fragments.pop
+           end
+         end
       end
-      return valid if !valid
-      
-      if current_schema.schema['additionalItems'] && data.is_a?(Array) && current_schema.schema['items'].is_a?(array)
-        if current_schema.schema['additionalItems'] == false
-          return current_schema.schema['additionalItems'].length == data.length
+    end
+    
+    
+    # Validate items in an array that are not part of the schema at least match a set of rules
+    def validate_additionalItems(current_schema, data, fragments)
+      if data.is_a?(Array) && current_schema.schema['items'].is_a?(Array)
+        if current_schema.schema['additionalItems'] == false && current_schema.schema['items'].length != data.length
+          message = "The property '#{build_fragment(fragments)}' contains additional array elements outside of the schema when none are allowed"
+          raise ValidationError.new(message, fragments, current_schema)
         elsif current_schema.schema['additionaItems'].is_a?(Hash)
-          data.each do |item|
-            schema = JSON::Schema.new(current_schema.schema['additionalItems'],current_schema.uri)
-            valid = validate_schema(schema, item)
-            return valid if !valid
+          schema = JSON::Schema.new(current_schema.schema['additionalItems'],current_schema.uri)
+          data.each_with_index do |item,i|
+            if i >= current_schema.schema['items'].length
+              fragments << i.to_s
+              validate_schema(schema, item, fragments)
+              fragments.pop
+            end
           end
         end
       end
-      return valid if !valid
-      
-      if current_schema.schema['dependences'] && data.is_a?(Hash)
+    end
+    
+    
+    # Validate the dependencies of a property
+    def validate_dependencies(current_schema, data, fragments)
+      if data.is_a?(Hash)
         current_schema.schema['dependencies'].each do |property,dependency_value|
           if data.has_key?(property)
-            if dependency_value.is_a?(String)
-              valid = data.has_key?(dependency_value)
+            if dependency_value.is_a?(String) && !data.has_key?(dependency_value)
+              message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{dependency_value}'"
+              raise ValidationError.new(message, fragments, current_schema)
             elsif dependency_value.is_a?(Array)
               dependency_value.each do |value|
-                valid = data.has_key?(value)
-                break if !valid
+                if !data.has_key?(value)
+                  message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{value}'"
+                  raise ValidationError.new(message, fragments, current_schema)
+                end
               end
             else
               schema = JSON::Schema.new(dependency_value,current_schema.uri)
-              valid = validate_schema(schema, data)
-            end
-            return valid if !valid
-          end
-        end
-      end
-      return valid if !valid
-      
-      # We're referencing another schema
-      if current_schema.schema['$ref']
-        temp_uri = URI.parse(current_schema.schema['$ref'])
-        if temp_uri.relative?
-          temp_uri = current_schema.uri.clone
-          # Check for absolute path
-          path = current_schema.schema['$ref'].split("#")[0]
-          if path[0,1] == "/"
-            temp_uri.path = Pathname.new(path).cleanpath
-          else
-            temp_uri.path = (Pathname.new(current_schema.uri.path).parent + path).cleanpath
-          end
-          temp_uri.fragment = current_schema.schema['$ref'].split("#")[1]
-        end
-        temp_uri.fragment = "" if temp_uri.fragment.nil?
-        
-        # Grab the parent schema from the schema list
-        schema_key = temp_uri.to_s.split("#")[0]
-        ref_schema = @schemas[schema_key]
-        
-        if ref_schema
-          # Perform fragment resolution to retrieve the appropriate level for the schema
-          target_schema = ref_schema.schema
-          fragments = temp_uri.fragment.split("/")
-          fragments.each do |fragment|
-            if fragment && fragment != ''
-              if target_schema.is_a?(Array)
-                target_schema = target_schema[fragment.to_i]
-              else
-                target_schema = target_schema[fragment]
-              end
+              validate_schema(schema, data, fragments)
             end
           end
-          
-          # We have the schema finally, build it and validate!
-          schema = JSON::Schema.new(target_schema,temp_uri)
-          valid = validate_schema(schema, data)
-        end 
-      end
-      
-      if current_schema.schema['extends']
-        schemas = current_schema.schema['extends']
-        schemas = [schemas] if !schema.is_a?(Array)
-        schemas.each do |s|
-          schema = JSON::Schema.new(s,current_schema.uri)
-          valid = validate_schema(schema, item)
-          return valid if !valid
         end
       end
-      
-      valid
     end
     
     
-    def validate_type(types, data,current_schema)
-      union = true
-      if !types.is_a?(Array)
-        types = [types]
-        union = true
+    # Validate extensions of other schemas
+    def validate_extends(current_schema, data, fragments)
+      schemas = current_schema.schema['extends']
+      schemas = [schemas] if !schemas.is_a?(Array)
+      schemas.each do |s|
+        schema = JSON::Schema.new(s,current_schema.uri)
+        validate_schema(schema, data, fragments)
       end
-      valid = false
-      
-      types.each do |type|
-        if type.is_a?(String)
-          case type
-          when "string"
-            valid = data.is_a?(String)
-          when "number"
-            valid = data.is_a?(Numeric)
-          when "integer"
-            valid = data.is_a?(Integer)
-          when "boolean"
-            valid = (data.is_a?(TrueClass) || data.is_a?(FalseClass))
-          when "object"
-            valid = data.is_a?(Hash)
-          when "array"
-            valid = data.is_a?(Array)
-          when "null"
-            valid = data.is_a?(NilClass)
-          else
-            valid = true
+    end
+    
+    
+    # Validate schema references
+    def validate_ref(current_schema, data, fragments)
+      temp_uri = URI.parse(current_schema.schema['$ref'])
+      if temp_uri.relative?
+        temp_uri = current_schema.uri.clone
+        # Check for absolute path
+        path = current_schema.schema['$ref'].split("#")[0]
+        if path[0,1] == "/"
+          temp_uri.path = Pathname.new(path).cleanpath
+        else
+          temp_uri.path = (Pathname.new(current_schema.uri.path).parent + path).cleanpath
+        end
+        temp_uri.fragment = current_schema.schema['$ref'].split("#")[1]
+      end
+      temp_uri.fragment = "" if temp_uri.fragment.nil?
+      
+      # Grab the parent schema from the schema list
+      schema_key = temp_uri.to_s.split("#")[0]
+      ref_schema = @schemas[schema_key]
+      
+      if ref_schema
+        # Perform fragment resolution to retrieve the appropriate level for the schema
+        target_schema = ref_schema.schema
+        fragments = temp_uri.fragment.split("/")
+        fragments.each do |fragment|
+          if fragment && fragment != ''
+            if target_schema.is_a?(Array)
+              target_schema = target_schema[fragment.to_i]
+            else
+              target_schema = target_schema[fragment]
+            end
           end
-        elsif type.is_a?(Hash) && union
-          # Validate as a schema
-          schema = JSON::Schema.new(type,current_schema.uri)
-          valid = validate_schema(schema,data)
         end
-      
-        return valid if valid
+        
+        # We have the schema finally, build it and validate!
+        schema = JSON::Schema.new(target_schema,temp_uri)
+        validate_schema(schema, data, fragments)
       end
-      
-      valid
     end
     
+
+    def build_fragment(fragments)
+      "#/#{fragments.join('/')}"
+    end
+
+    
     def load_ref_schema(parent_schema,ref)
       uri = URI.parse(ref)
       if uri.relative?
@@ -315,7 +498,6 @@ module JSON
       if @schemas[uri.to_s].nil?
         begin
           schema = JSON::Schema.new(JSON.parse(open(uri.to_s).read), uri)
-          @schemas[uri.to_s] = schema
           build_schemas(schema)
         rescue
           # Failures will occur when this URI cannot be referenced yet. Don't worry about it,
@@ -436,6 +618,19 @@ module JSON
           build_schemas(schema)
         end
       end
+      
+      if parent_schema.schema["extends"].is_a?(Hash)
+        if parent_schema.schema["extends"]['$ref']
+          load_ref_schema(parent_schema, parent_schema.schema["extends"]['$ref'])
+        else
+          schema_uri = parent_schema.uri.clone
+          schema = JSON::Schema.new(parent_schema.schema["extends"],schema_uri)
+          if parent_schema.schema["extends"]['id']
+            @schemas[schema.uri.to_s] = schema
+          end
+          build_schemas(schema)
+        end
+      end
     end
         
     
@@ -444,7 +639,13 @@ module JSON
         validator = JSON::Validator.new(schema, data)
         validator.validate
       end
+    
+      def validate2(schema, data)
+        validator = JSON::Validator.new(schema, data)
+        validator.validate2
+      end
     end
+  
     
     
     private

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: json-schema
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Kenny Hoxworth
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-29 00:00:00 -05:00
+date: 2010-11-30 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency