render 0.0.8 → 0.0.9

data/lib/render/type.rb

@@ -1,16 +1,15 @@
-# Types define classes of data being interpreted. This is especially important in modeling fake data.
+# Render::Type defines classes for JSON Types and Formats.
 # Add additional types for your specific needs, along with a generator to create fake data for it.
 
 require "uuid"
+require "date"
+require "ipaddr"
+require "uri"
 
 module Render
   module Type
     @instances = {}
 
-    class Enum; end
-    class Boolean; end
-    class Date; end
-
     class << self
       attr_accessor :instances
 
@@ -23,7 +22,9 @@ module Render
       end
 
       def parse(name, raise_error = false)
-        return name unless name.is_a?(String)
+        return nil if (name.nil?)
+        return name unless name.is_a?(String) || name.is_a?(Symbol)
+
         Render::Type.find(name) || Object.const_get(name.capitalize)
       rescue NameError
         raise Errors::InvalidType.new(name) if raise_error
@@ -33,6 +34,27 @@ module Render
         parse(name, true)
       end
 
+      def to(classes, value, enums = nil)
+        return nil if (value.nil? || classes.any?(&:nil?))
+        return value if classes.any? { |klass| value.is_a?(klass) }
+
+        case(classes.first.name)
+        when Float.name
+          value.to_f
+        when Integer.name
+          value.to_i
+        when String.name
+          value.to_s
+        when Boolean.name
+          return true if (value == true || value == "true")
+          return false if (value == false || value == "false")
+        when Enum.name
+          (enums & [value]).first
+        else
+          value
+        end
+      end
+
       private
 
       def class_for_name(name)
@@ -55,11 +77,31 @@ module Render
       end
     end
 
-    add!(:uuid, UUID)
+    class Enum; end
+    class Boolean; end
+    class Date; end
+    class Hostname < String; end
+    class Email < String; end
+    class IPv4 < IPAddr; end
+    class IPv6 < IPAddr; end
+
+    # Standard types
     add!(:number, Float)
-    add!(:time, Time)
-    add_render_specific_type!(:Boolean)
+    add!(:null, NilClass)
     add_render_specific_type!(:Enum)
+    add_render_specific_type!(:Boolean)
+
+    # Standard formats
+    add!(:uri, URI)
+    add!("date-time".to_sym, DateTime)
+    add_render_specific_type!(:IPv4)
+    add_render_specific_type!(:IPv6)
+    add_render_specific_type!(:Email)
+    add_render_specific_type!(:Hostname)
+
+    # Extended
+    add!(:uuid, UUID)
     add_render_specific_type!(:Date)
+
   end
 end

data/lib/render/version.rb

@@ -1,3 +1,3 @@
 module Render
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/readme.md

@@ -1,10 +1,10 @@
 # Render
 
-Render improves the way you work with APIs.
+Render improves the way you work with APIs by dynamically modeling/requesting from [JSON Schemas](http://json-schema.org/) or Ruby equivalents thereof.
 
-* [Generate type-specific, dynamic API response data for testing](spec/integration/render/schema_spec.rb) with just a schema (JSON or Ruby)
+* [Generate type-specific, dynamic API response data for testing](spec/integration/render/schema_spec.rb) with just a schema
 * [Make API requests](spec/integration/render/graph_spec.rb) with a URL and a schema
-* Build graphs that [interpret data from one endpoint to call others](spec/integration/render/nested_graph_spec.rb)
+* Build Graphs that [interpret data from one endpoint to call others](spec/integration/render/nested_graph_spec.rb)
 
 ## Setup
 
@@ -16,16 +16,73 @@ Update your Gemfile:
 
 Check out examples as part of the [integration tests](spec/integration/render).
 
-## Caveats
+```ruby
+# Make requests
+Render::Definition.load_from_directory!("/path/to/json/schema/dir")
+Render::Graph.new("loaded-schema-id", { host: "films.local" }).render!
 
-- Render is under initial development
+# Or mock data
+Render.live = false
+planned_schema = {
+  definitions: {
+    address: {
+      type: Object,
+      properties: {
+        number: { type: Integer },
+        street: { type: String }
+      }
+    }
+  },
+
+  type: Object,
+  properties: {
+    name: { type: String, minLength: 1 },
+    email: { type: String, format: :email },
+    sex: { type: String, enum: %w(MALE FEMALE) },
+    address: { :$ref => "#/definitions/address" },
+    nicknames: {
+      type: Array,
+      minItems: 1,
+      maxItems: 1,
+      items: { type: String }
+    }
+  }
+}
+
+mock_data = Render::Schema.new(planned_schema).render!
+# {
+#   :name => "name (generated)",
+#   :email => "you@localhost",
+#   :sex => "FEMALE",
+#   :address => {
+#     :number => 513948,
+#     :street => "street (generated)"
+#   },
+#   :nicknames => ["nicknames (generated)"]
+# }
+```
+
+## Caveats/Notes/Assumptions
+
+Render is not meant to be a validator and ignores:
+
+  - Keywords that do not additively define schemas: `not`, `minProperties`, `maxProperties`, `dependencies`
+  - Divergent responses, e.g. no errors will be raised if "abc" is returned for String with { "minLength": 4 }
+
+It will help out, though, and defensively type response values based on definition (so you don't run into issues like `"2" > 1`).
 
 ## Roadmap
 
-1. Custom headers (e.g. { pragma: "no-cache", host: "dont_redirect_to_www.site.com" })
-2. Enhance Attribute metadata (e.g. minlength)
-3. Enhance Graph to Graph relationships
-4. Custom request strategy
+- `links` implementation as opposed to `endpoint`
+- Expanded keyword implementations:
+  - additionalProperties, anyOf, allOf, oneOf
+  - pattern/patternProperties
+  - Tuples of varying types, e.g. [3, { name: "bob" }]
+- Relating to requests
+  - Custom options, e.g. headers, timeouts
+  - Drop-in custom requesting
+- Enhanced relationship calculation between nested Graphs
+- Enhanced $ref implementation
 
 ## Contributing
 

data/render.gemspec

@@ -18,11 +18,12 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake", "~> 10.1"
   spec.add_runtime_dependency "uuid", "2.3.7"
+  spec.add_runtime_dependency "addressable", "2.3.5"
   spec.add_runtime_dependency "macaddr", "1.6.1" # required by UUID, 1.6.2 is bad github.com/ahoward/macaddr/issues/18
-  spec.add_development_dependency "debugger", "~> 1.6"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.1"
+  spec.add_development_dependency "debugger", "1.6.6"
   spec.add_development_dependency "rspec", "~> 2.14"
   spec.add_development_dependency "webmock", "~> 1.17"
   spec.add_development_dependency "yard", "~> 0.8"

data/spec/functional/render/attribute_spec.rb

@@ -10,16 +10,74 @@ module Render
         Generator.instances = @original_generators
       end
 
-      it "uses matching generator for #faux_value" do
-        name = "Canada Dry"
-        Generator.create!(String, %r{.*name.*}, proc { name })
+      describe "#default_value" do
+        it "returns default value defined by schema" do
+          schema_default = "foo"
+          attribute = HashAttribute.new({ name: { type: String, default: schema_default } })
 
-        HashAttribute.new({ name: { type: String } }).default_value.should == name
-      end
+          Render.stub({ live: false })
+          attribute.default_value.should == schema_default
+          Render.stub({ live: true })
+          attribute.default_value.should == schema_default
+        end
+
+        it "returns fake data from matching generator" do
+          name = "Canada Dry"
+          Generator.create!(String, %r{.*name.*}, proc { name })
+
+          HashAttribute.new({ name: { type: String } }).default_value.should == name
+        end
+
+        it "generates fake data for all standard JSON types" do
+          # Objects' and Arrays' fake data comes from their attributes.
+
+          string_attribute = HashAttribute.new({ name: { type: "string" } })
+          string_attribute.default_value.should be_a(String)
+
+          number_attribute = HashAttribute.new({ name: { type: "number" } })
+          number_attribute.default_value.should be_a(Float)
+
+          boolean_attribute = HashAttribute.new({ name: { type: "boolean" } })
+          [true, false].should include(boolean_attribute.default_value)
+
+          Render.logger.should_not_receive(:warn)
+          null_attribute = HashAttribute.new({ name: { type: "null" } })
+          null_attribute.default_value.should == nil
+        end
+
+        it "generates fake data for all standard JSON formats" do
+          hostname_attribute = HashAttribute.new({ name: { format: "hostname" } })
+          hostname_attribute.default_value.should eq("localhost")
+
+          ipv4_attribute = HashAttribute.new({ name: { format: "ipv4" } })
+          ipv4_attribute.default_value.should eq("127.0.0.1")
+
+          ipv6_attribute = HashAttribute.new({ name: { format: "ipv6" } })
+          ipv6_attribute.default_value.should eq("::1")
+
+          date_time = DateTime.now
+          DateTime.stub({ now: date_time })
+          date_time_attribute = HashAttribute.new({ name: { format: "date-time" } })
+          date_time_attribute.default_value.should eq(date_time.to_s)
+
+          email_attribute = HashAttribute.new({ name: { format: "email" } })
+          email_attribute.default_value.should eq("you@localhost")
+
+          email_attribute = HashAttribute.new({ name: { format: "uri" } })
+          email_attribute.default_value.should eq("http://localhost")
+        end
+
+        it "generates fake data for enums" do
+          enum_values = ["foo", "bar"]
+          enum_attribute = HashAttribute.new({ name: { enum: enum_values } })
+          enum_values.should include(enum_attribute.default_value)
+        end
+
+        it "biases format's generator to type's generator" do
+          ipv6_attribute = HashAttribute.new({ name: { type: String, format: "ipv6" } })
+          ipv6_attribute.default_value.should eq("::1")
+        end
 
-      it "uses bare-boned type if no generator is found" do
-        bare_boned_string = "the_attribute_name (generated)"
-        HashAttribute.new({ the_attribute_name: { type: String } }).default_value.should == bare_boned_string
       end
     end
   end

data/spec/functional/render/nested_schemas_spec.rb

@@ -8,7 +8,6 @@ module Render
 
     it "parses nested schemas" do
       schema = {
-        title: "person",
         type: Object,
         properties: {
           contact: {
@@ -33,29 +32,23 @@ module Render
       }
 
       Schema.new(schema).render!(data).should == {
-        person: {
-          contact: {
-            name: contact_name,
-            phone: contact_phone
-          }
+        contact: {
+          name: contact_name,
+          phone: contact_phone
         }
       }
     end
 
     it "parses nested arrays" do
       schema = {
-        title: "people",
         type: Array,
         items: {
-          title: :person,
           type: Object,
           properties: {
             name: { type: String },
             nicknames: {
-              title: "nicknames",
               type: Array,
               items: {
-                title: :formalized_name,
                 type: Object,
                 properties: {
                   name: { type: String },
@@ -82,22 +75,21 @@ module Render
       }
       people = [zissou, ned]
 
-      Schema.new(schema).render!(people).should == {
-        people: [{
-            name: "Steve Zissou",
-            nicknames: [
-              { name: "Stevezies", age: 2 },
-              { name: "Papa Steve", age: 1 }
-            ]
-          },
-          {
-            name: "Ned Plimpton",
-            nicknames: [
-              { name: "Kinsley", age: 4 }
-            ]
-          }
-        ]
-      }
+      Schema.new(schema).render!(people).should == [
+        {
+          name: "Steve Zissou",
+          nicknames: [
+            { name: "Stevezies", age: 2 },
+            { name: "Papa Steve", age: 1 }
+          ]
+        },
+        {
+          name: "Ned Plimpton",
+          nicknames: [
+            { name: "Kinsley", age: 4 }
+          ]
+        }
+      ]
     end
   end
 end

data/spec/functional/render/schema_spec.rb

@@ -53,5 +53,33 @@ module Render
         schema.serialize!(films).should == films
       end
     end
+
+    describe "required" do
+      # Not defined in spec, but should have been
+      it "is set with HashAttribute-level keyword" do
+        schema = Schema.new({
+          type: Object,
+          properties: {
+            name: { type: String, required: true },
+          }
+        })
+
+        schema.hash_attributes.first.required.should be
+      end
+
+      it "is set on schema-level keyword" do
+        schema = Schema.new({
+          type: Object,
+          properties: {
+            name: { type: String },
+            address: { type: String },
+          },
+          required: [:address]
+        })
+
+        schema.attributes[0].required.should_not be
+        schema.attributes[1].required.should be
+      end
+    end
   end
 end

data/spec/integration/render/graph_spec.rb

@@ -24,7 +24,7 @@ module Render
 
     it "request data from endpoint with explicit values" do
       director_1s_films_request = stub_request(:get, "http://films.local/directors/1/films").to_return({ body: "{}" })
-      @schema.merge!({ endpoint: "http://films.local/directors/:id/films" })
+      @schema.merge!({ endpoint: "http://films.local/directors/{id}/films" })
 
       response = Render::Graph.new(@schema, { id: 1 }).render!
       director_1s_films_request.should have_been_made.once
@@ -40,7 +40,7 @@ module Render
 
     it "interpolates variables into endpoint" do
       stub_request(:get, "http://films.local").to_return({ body: [{ id: 1 }].to_json })
-      @schema.merge!({ endpoint: "http://:host" })
+      @schema.merge!({ endpoint: "http://{host}" })
 
       response = Render::Graph.new(@schema, { host: "films.local" }).render!
       response.should == { films: [{ id: 1 }] }
@@ -76,7 +76,7 @@ module Render
             },
             tags: {
               type: Array,
-              required: true,
+              minItems: 1,
               items: {
                 type: Object,
                 properties: {

data/spec/integration/render/nested_graph_spec.rb

@@ -21,44 +21,42 @@ module Render
       stub_request(:get, "http://films.local/films/#{@aquatic_id}").to_return({ body: { name: @aquatic_name }.to_json })
       stub_request(:get, "http://films.local/films/#{@darjeeling_id}").to_return({ body: { name: @darjeeling_name }.to_json })
 
-      graph = Render::Graph.new(:films_index, { host: "films.local" })
-      graph.graphs << Render::Graph.new(:films_show, { host: "films.local", relationships: { id: :id } })
+      graph = Render::Graph.new("films_index", { host: "films.local" })
+      graph.graphs << Render::Graph.new("films_show", { host: "films.local", relationships: { id: :id } })
       response = graph.render!
 
       response.should == {
-        films_index: {
-          films: [{ id: @aquatic_id }, { id: @darjeeling_id }]
-        },
+        films_index: [{ id: @aquatic_id }, { id: @darjeeling_id }],
         films_show: [
-          { film: { name: @aquatic_name, year: nil } },
-          { film: { name: @darjeeling_name, year: nil } }
+          { name: @aquatic_name, year: nil },
+          { name: @darjeeling_name, year: nil }
         ]
       }
     end
 
-    it "makes subsequent calls from archetype array data" do
+    it "makes subsequent calls from simple array data" do
       stub_request(:get, "http://films.local").to_return({ body: [@aquatic_id, @darjeeling_id].to_json })
       stub_request(:get, "http://films.local/films/#{@aquatic_id}").to_return({ body: { name: @aquatic_name }.to_json })
       stub_request(:get, "http://films.local/films/#{@darjeeling_id}").to_return({ body: { name: @darjeeling_name }.to_json })
 
       schema = Render::Schema.new({
-        title: :films_as_array_of_archetypes,
+        title: :films_as_array_of_ids,
         type: Array,
-        endpoint: "http://:host",
+        endpoint: "http://{host}",
         items: {
           type: UUID
         }
       })
 
       graph = Render::Graph.new(schema, { host: "films.local" })
-      graph.graphs << Render::Graph.new(:films_show, { host: "films.local", relationships: { id: :id } })
+      graph.graphs << Render::Graph.new("films_show", { host: "films.local", relationships: { id: :id } })
       response = graph.render!
 
       response.should == {
-        films_as_array_of_archetypes: [@aquatic_id, @darjeeling_id],
+        films_as_array_of_ids: [@aquatic_id, @darjeeling_id],
         films_show: [
-          { film: { name: @aquatic_name, year: nil } },
-          { film: { name: @darjeeling_name, year: nil } }
+          { name: @aquatic_name, year: nil },
+          { name: @darjeeling_name, year: nil }
         ]
       }
     end