render 0.0.8 → 0.0.9

data/.ruby-version

@@ -1 +1 @@
-ruby-1.9.3
+1.9.3-p484

data/lib/json/draft-04/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/lib/json/draft-04/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/lib/render.rb

@@ -28,3 +28,5 @@ module Render
 
   end
 end
+
+# require "render/json_schema"

data/lib/render/attributes/array_attribute.rb

@@ -3,48 +3,54 @@ require "render/attributes/attribute"
 module Render
   class ArrayAttribute < Attribute
     FAUX_DATA_UPPER_LIMIT = 5.freeze
+    DEFAULT_NAME = :render_array_attribute_untitled
 
-    attr_accessor :archetype
+    attr_accessor :simple,
+      :min_items,
+      :max_items,
+      :unique
 
     def initialize(options = {})
       super
 
-      self.name = options.fetch(:title, :render_array_attribute_untitled).to_sym
-      self.required = options.fetch(:required, nil)
+      self.name = options.fetch(:title, DEFAULT_NAME).to_sym
+      self.min_items = options[:minItems] || 0
+      self.max_items = options[:maxItems]
+      self.unique = !!options[:uniqueItems]
+
       options = options.fetch(:items)
-      process_type!(options)
+      process_options!(options)
 
       if options.keys.include?(:properties)
         self.schema = Schema.new(options)
       else
-        self.archetype = true
+        self.simple = true
       end
     end
 
     def serialize(explicit_values = nil)
       explicit_values = faux_array_data if (Render.live == false && explicit_values.nil?)
-      if archetype
+      values = if simple
         explicit_values.collect do |value|
-          value || default_value
+          value = (value || default_value)
+          Type.to(types, value)
         end
       else
         explicit_values.collect do |value|
           schema.serialize!(value)
         end
       end
+
+      unique ? values.uniq : values
     end
 
     private
 
     def faux_array_data
-      rand(lower_limit..FAUX_DATA_UPPER_LIMIT).times.collect do
-        archetype ? nil : {}
+      faux_max = max_items || FAUX_DATA_UPPER_LIMIT
+      rand(min_items..faux_max).times.collect do
+        simple ? nil : {}
       end
     end
-
-    def lower_limit
-      required ? 1 : 0
-    end
-
   end
 end

data/lib/render/attributes/attribute.rb

@@ -5,23 +5,30 @@ module Render
     SCHEMA_IDENTIFIERS = [:properties, :items].freeze
 
     attr_accessor :name,
-      :type,
+      :types,
       :schema,
       :enums,
       :format,
-      :required
+      :min_length,
+      :max_length,
+      :multiple_of,
+      :minimum,
+      :maximum,
+      :exclusive_minimum,
+      :exclusive_maximum
+
+    attr_writer :default
 
     def initialize(options = {})
       Render.logger.debug("Initializing attribute #{options}")
-      self.required = false
     end
 
     def bias_type
-      format || type
+      format || types.first
     end
 
     def default_value
-      Render.live ? nil : faux_value
+      @default || (Render.live ? nil : faux_value)
     end
 
     def nested_schema?(options = {})
@@ -30,14 +37,23 @@ module Render
 
     private
 
-    def process_type!(options)
-      self.type = Type.parse!(options[:type])
+    def process_options!(options)
+      self.types = [Type.parse!(options[:type])].flatten
       self.format = Type.parse(options[:format])
 
       if (options[:enum])
         self.enums = options[:enum]
         self.format = Type::Enum
       end
+
+      @default = options[:default]
+      self.min_length = options[:minLength]
+      self.max_length = options[:maxLength]
+      self.multiple_of = options[:multipleOf]
+      self.minimum = options[:minimum]
+      self.maximum = options[:maximum]
+      self.exclusive_minimum = !!options[:exclusiveMinimum]
+      self.exclusive_maximum = !!options[:exclusiveMaximum]
     end
 
     def faux_value