render 0.0.2 → 0.0.3

data/lib/render.rb

@@ -10,36 +10,58 @@ require "extensions/hash"
 require "render/version"
 require "render/graph"
 require "render/generator"
+require "logger"
+require "date"
 
 module Render
   @live = true
-  @schemas = {}
+  @definitions = {}
   @generators = []
+  @logger = ::Logger.new($stdout)
+  @threading = true
 
   class << self
-    attr_accessor :live, :schemas, :generators
-
-    def load_schemas!(directory)
-      Dir.glob("#{directory}/**/*.json").each do |schema_file|
-        parsed_schema = parse_schema(File.read(schema_file))
-        schema_title = parsed_schema[:title].to_sym
-        # TODO Throw an error in the event of conflicts?
-        self.schemas[schema_title] = parsed_schema
+    attr_accessor :live,
+      :definitions,
+      :generators,
+      :logger,
+      :threading
+
+    def threading?
+      threading == true
+    end
+
+    def load_definitions!(directory)
+      Dir.glob("#{directory}/**/*.json").each do |definition_file|
+        logger.info("Reading #{definition_file} definition")
+        definition_string = File.read(definition_file)
+        parsed_definition = JSON.parse(definition_string).recursive_symbolize_keys!
+        load_definition!(parsed_definition)
       end
     end
 
-    def parse_schema(json)
-      JSON.parse(json).recursive_symbolize_keys!
+    def load_definition!(definition)
+      title = definition.fetch(:universal_title, definition.fetch(:title)).to_sym
+      self.definitions[title] = definition
     end
 
+    def definition(title)
+      definitions.fetch(title.to_sym)
+    rescue KeyError => error
+      raise Errors::DefinitionNotFound.new(title)
+    end
+
+    # TODO better type parsing
     def parse_type(type)
-      if type.is_a?(String)
-        return UUID if type == "uuid"
-        return Boolean if type == "boolean"
-        Object.const_get(type.capitalize) # TODO better type parsing
-      else
-        type
-      end
+      return type unless type.is_a?(String)
+
+      return UUID if type.match(/uuid/i)
+      return Boolean if type.match(/boolean/i)
+      return Float if type.match(/number/i)
+      return Time if type.match(/date.*time/i)
+      Object.const_get(type.capitalize)
+    rescue NameError => error
+      raise Errors::InvalidType.new(type)
     end
   end
 

data/readme.md

@@ -39,6 +39,12 @@ graph.render({ id: "an-id" }) # makes request to "http://films.local/films/an-id
 
 Check out the examples in [integration tests](spec/integration/).
 
+## Roadmap
+
+1. Custom HTTP headers (e.g. { pragma: "no-cache", host: "dont_redirect_to_www.site.com" })
+2. Enhanced Attribute metadata (e.g. minlength)
+3. Parental params from root-level array
+4. Deep merge in #render for faux values
 
 ## Contributing
 

data/spec/functional/representation/attribute_spec.rb

@@ -17,12 +17,12 @@ module Render
         generator = Generator.new({ type: String, matcher: %r{.*name.*}, algorithm: proc { name } })
         Render.generators << generator
 
-        Attribute.new({ name: { type: String } }).default_value.should == name
+        HashAttribute.new({ name: { type: String } }).default_value.should == name
       end
 
       it "uses really bare-boned type if no generator is found" do
         bare_boned_string = "A String"
-        Attribute.new({ foo: { type: String } }).default_value.should == bare_boned_string
+        HashAttribute.new({ foo: { type: String } }).default_value.should == bare_boned_string
       end
     end
   end

data/spec/functional/representation/graph_spec.rb

@@ -0,0 +1,9 @@
+require "render/graph"
+
+module Render
+  describe Graph do
+    describe "relationships" do
+      #
+    end
+  end
+end

data/spec/functional/representation/nested_schemas_spec.rb

@@ -10,10 +10,10 @@ module Render
       schema = {
         title: "person",
         type: Object,
-        attributes: {
+        properties: {
           contact: {
             type: Object,
-            attributes: {
+            properties: {
               name: { type: String },
               phone: { type: String }
             }
@@ -32,7 +32,7 @@ module Render
         }
       }
 
-      Schema.new(schema).render(data).should == {
+      Schema.new(schema).render!(data).should == {
         person: {
           contact: {
             name: contact_name,
@@ -46,18 +46,18 @@ module Render
       schema = {
         title: "people",
         type: Array,
-        elements: {
+        items: {
           title: :person,
           type: Object,
-          attributes: {
+          properties: {
             name: { type: String },
             nicknames: {
               title: "nicknames",
               type: Array,
-              elements: {
+              items: {
                 title: :formalized_name,
                 type: Object,
-                attributes: {
+                properties: {
                   name: { type: String },
                   age: { type: Integer }
                 }
@@ -82,7 +82,7 @@ module Render
       }
       people = [zissou, ned]
 
-      Schema.new(schema).render(people).should == {
+      Schema.new(schema).render!(people).should == {
         people: [{
             name: "Steve Zissou",
             nicknames: [

data/spec/functional/representation/schema_spec.rb

@@ -6,81 +6,52 @@ module Render
       Render.stub({ live: false })
     end
 
-    it "parses hash data" do
-      schema = Schema.new({
-        title: "television",
-        type: Object,
-        attributes: {
-          brand: { type: String }
-        }
-      })
-
-      brand_name = "Sony"
-      response = { brand: brand_name }
-
-      schema.render(response).should == {
-        television: { brand: brand_name }
-      }
-    end
-
-    it "parses simple arrays" do
-      schema = Schema.new({
-        title: "televisions",
-        type: Array,
-        elements: {
-          type: UUID
-        }
-      })
-
-      television_ids = rand(10).times.collect { UUID.generate }
-
-      schema.render(television_ids).should == {
-        televisions: television_ids
-      }
-    end
-
-    it "parses arrays of objects" do
-      schema = Schema.new({
-        title: :televisions,
-        type: Array,
-        elements: {
-          title: :television,
+    describe "#serialize!" do
+      it "returns data from hashes" do
+        definition = {
+          title: "film",
           type: Object,
-          attributes: {
-            brand: { type: String }
+          properties: {
+            title: {
+              type: String
+            }
           }
         }
-      })
-
-      brand_1, brand_2 = *%w(Sony Samsung)
-      response = [{ brand: brand_1 }, { brand: brand_2 }]
+        data = { title: "a name" }
+        Schema.new(definition).serialize!(data).should == data
+      end
 
-      schema.render(response).should == {
-        televisions: [{ brand: brand_1 }, { brand: brand_2 }]
-      }
-    end
 
-    it "parses nested object data" do
-      schema = Schema.new({
-        title: :television,
-        type: Object,
-        attributes: {
-          brand: {
-            title: :brand,
+      it "returns data from arrays" do
+        definition = {
+          title: "names",
+          type: Array,
+          items: {
+            type: String
+          }
+        }
+        schema = Schema.new(definition)
+        names = ["bob", "bill"]
+        schema.serialize!(names).should == names
+      end
+
+      it "returns data from arrays of schemas" do
+        definition = {
+          title: "films",
+          type: Array,
+          items: {
             type: Object,
-            attributes: {
-              name: { type: String }
+            properties: {
+              id: { type: UUID }
             }
           }
         }
-      })
-
-      brand_name = "Sony"
-      response = { brand: { name: brand_name } }
 
-      schema.render(response).should == {
-        television: { brand: { name: brand_name } }
-      }
+        the_id = UUID.generate
+        films = [{ id: the_id }]
+        schema = Schema.new(definition)
+        schema.serialize!(films).should == films
+      end
     end
   end
 end

data/spec/integration/nested_graph_spec.rb

@@ -2,11 +2,11 @@ require "render"
 
 describe Render do
   before(:all) do
-    Render.load_schemas!(Helpers::SCHEMA_DIRECTORY)
+    Render.load_definitions!(Helpers::SCHEMA_DIRECTORY)
   end
 
   after(:all) do
-    Render.schemas = {}
+    Render.definitions = {}
   end
 
   describe "request" do
@@ -15,10 +15,13 @@ describe Render do
       @film_endpoint = "http://films.local/films/:id"
       @aquatic_id = UUID.generate
       @darjeeling_id = UUID.generate
+      @aquatic_name = "The Life Aquatic with Steve Zissou"
+      @darjeeling_name = "The Darjeeling Limited"
     end
 
     it "returns structured data for nested queries" do
-      stub_request(:get, @films_endpoint).to_return({ body: [{ id: @aquatic_id }, { id: @darjeeling_id }].to_json })
+      films_index_response = [{ id: @aquatic_id }, { id: @darjeeling_id }]
+      stub_request(:get, @films_endpoint).to_return({ body: films_index_response.to_json })
 
       aquatic_name = "The Life Aquatic with Steve Zissou"
       aquatic_uri = @film_endpoint.gsub(":id", @aquatic_id)
@@ -29,48 +32,53 @@ describe Render do
       stub_request(:get, darjeeling_uri).to_return({ body: { name: darjeeling_name }.to_json })
 
       options = {
-        graphs: [Render::Graph.new(:film, { endpoint: @film_endpoint, relationships: { id: :id }})],
+        graphs: [Render::Graph.new(:films_show, { endpoint: @film_endpoint, relationships: { id: :id }})],
         endpoint: @films_endpoint
       }
-      graph = Render::Graph.new(:films, options)
+      graph = Render::Graph.new(:films_index, options)
       graph.render.should == {
-        films: [
-          { name: aquatic_name, year: nil },
-          { name: darjeeling_name, year: nil }
+        films_index: {
+          films: films_index_response
+        },
+        films_show: [
+          { film: { name: aquatic_name, year: nil } },
+          { film: { name: darjeeling_name, year: nil } }
         ]
       }
+      graph.rendered_data.films_show.first.film.name.should == aquatic_name
     end
 
     it "makes subsequent calls from archetype array data" do
-      pending "Simple arrays need to be able to make multiple calls"
-
       stub_request(:get, @films_endpoint).to_return({ body: [@aquatic_id, @darjeeling_id].to_json })
 
-      aquatic = @film_endpoint.gsub("id", @aquatic_id)
+      aquatic = @film_endpoint.gsub(":id", @aquatic_id)
       stub_request(:get, aquatic).to_return({ body: { name: @aquatic_name }.to_json })
 
-      darjeeling = @film_endpoint.gsub("id", @darjeeling_id)
+      darjeeling = @film_endpoint.gsub(":id", @darjeeling_id)
       stub_request(:get, darjeeling).to_return({ body: { name: @darjeeling_name }.to_json })
 
-      films = Representation::Schema.new({
+      films = Render::Schema.new({
         title: :films,
         type: Array,
-        elements: {
+        items: {
           type: UUID
         }
       })
 
-      film = Representation::Schema.new({
+      film = Render::Schema.new({
         title: :film,
         type: Object,
-        attributes: {
-          title: { type: String }
+        properties: {
+          name: { type: String }
         }
       })
 
-      films = Representation::Graph.new(films, { endpoint: @films_endpoint })
-      films.graphs << Representation::Graph.new(film, { endpoint: @film_endpoint, relationships: { films: :id } })
-      films.render.should == {}
+      films = Render::Graph.new(films, { endpoint: @films_endpoint })
+      films.graphs << Render::Graph.new(film, { endpoint: @film_endpoint, relationships: { id: :id } })
+      films.render.film.should =~ [
+        { name: @aquatic_name },
+        { name: @darjeeling_name }
+      ]
     end
 
   end

data/spec/integration/single_graph_spec.rb

@@ -2,11 +2,11 @@ require "render"
 
 describe Render do
   before(:all) do
-    Render.load_schemas!(Helpers::SCHEMA_DIRECTORY)
+    Render.load_definitions!(Helpers::SCHEMA_DIRECTORY)
   end
 
   after(:all) do
-    Render.schemas = {}
+    Render.definitions = {}
   end
 
   before(:each) do
@@ -24,8 +24,8 @@ describe Render do
       aquatic_uri = @films_endpoint.gsub(":secret_code", "secret_code=#{@secret_code}")
       stub_request(:get, aquatic_uri).to_return({ body: [{ id: @film_id }].to_json })
 
-      graph = Render::Graph.new(:films, { endpoint: @films_endpoint, secret_code: @secret_code })
-      graph.render.should == { films: [{ id: @film_id }] }
+      graph = Render::Graph.new(:films_index, { endpoint: @films_endpoint, secret_code: @secret_code })
+      graph.render.should == { films_index: { films: [{ id: @film_id }] } }
     end
 
     it "returns structured data for specific resources" do
@@ -33,8 +33,8 @@ describe Render do
       aquatic_uri = @film_endpoint.gsub(":id", id).gsub(":secret_code", "secret_code=#{@secret_code}")
       stub_request(:get, aquatic_uri).to_return({ body: { name: @film_name }.to_json })
 
-      graph = Render::Graph.new(:film, { id: id, endpoint: @film_endpoint, secret_code: @secret_code })
-      graph.render.should == { film: { name: @film_name, year: nil } }
+      graph = Render::Graph.new(:films_show, { id: id, endpoint: @film_endpoint, secret_code: @secret_code })
+      graph.render.should == { films_show: { film: { name: @film_name, year: nil } } }
     end
   end
 
@@ -44,22 +44,23 @@ describe Render do
     end
 
     it "use meaningful values" do
-      response = Render::Graph.new(:film).render({ name: @film_name })
+      response = Render::Graph.new(:films_show).render({ name: @film_name })
 
       stub_request(:post, "http://films.local/create").to_return({ body: response.to_json })
-      response = post_film(:anything)["film"]
+      response = post_film(:anything)["films_show"]["film"]
 
       response["name"].should be_a(String)
       response["year"].should be_a(Integer)
     end
 
     it "allows users to specify specific values" do
-      response = Render::Graph.new(:film).render({ name: @film_name })
+      response = Render::Schema.new(:films_show).render!({ name: @film_name })
 
       data = { name: @film_name }.to_json
-      stub_request(:post, "http://films.local/create").with({ body: data }).to_return({ body: response.to_json })
-      response = post_film(data)["film"]
+      request = stub_request(:post, "http://films.local/create").with({ body: data }).to_return({ body: response.to_json })
 
+      response = post_film(data)["films_show"]["film"]
+      request.should have_been_made
       response["name"].should == @film_name
     end
   end

data/spec/schemas/film.json

@@ -1,7 +1,8 @@
 {
+  "universal_title": "films_show",
   "title": "film",
   "type": "object",
-  "attributes": {
+  "properties": {
     "name": { "type": "string" },
     "year": { "type": "integer" }
   }

data/spec/schemas/films.json

@@ -1,10 +1,11 @@
 {
+  "universal_title": "films_index",
   "title": "films",
   "type": "array",
-  "elements": {
+  "items": {
     "title": "film",
     "type" : "object",
-    "attributes" : {
+    "properties" : {
       "id" : {
         "type": "uuid"
       }

data/spec/support.rb

@@ -2,6 +2,9 @@ require File.expand_path("../../initialize", __FILE__)
 require "webmock/rspec"
 require "support/helpers"
 
+Render.logger = Logger.new("/dev/null")
+Render.threading = false
+
 RSpec.configure do |config|
   #
 end

data/spec/unit/array_attribute_spec.rb

@@ -0,0 +1,48 @@
+require "render/array_attribute"
+
+module Render
+  describe ArrayAttribute do
+    describe "#initialize" do
+      it "sets name to title for faux_value generators to match" do
+        ArrayAttribute.new({ title: "ids", items: { type: UUID } }).name.should == :ids
+      end
+
+      describe "#format" do
+        it "is set from options" do
+          ArrayAttribute.new({ items: { type: String, format: UUID } }).format.should == UUID
+        end
+
+        it "is nil for indeterminable types" do
+          ArrayAttribute.new({ items: { type: String, format: "random-iso-format" } }).format.should == nil
+        end
+      end
+    end
+
+    describe "archetype" do
+      it "returns only a value" do
+        id = UUID.generate
+        attribute = ArrayAttribute.new({ items: { format: UUID } })
+        attribute.serialize([id]).should == [id]
+      end
+    end
+
+    describe "#faux_data" do
+      before(:each) do
+        Render.stub({ live: false })
+        @attribute = ArrayAttribute.new({ items: { type: Float, required: true } })
+      end
+
+      it "uses explicit value for faux data" do
+        explicit_data = [rand(10.0)]
+        @attribute.serialize(explicit_data).should == explicit_data
+      end
+
+      it "generates fake number of elements" do
+        faux_data = @attribute.serialize
+        faux_data.size.should be_between(0, ArrayAttribute::FAUX_DATA_UPPER_LIMIT)
+        faux_data.sample.class.should == Float
+      end
+    end
+
+  end
+end

data/spec/unit/render/dottable_hash_spec.rb

@@ -127,12 +127,6 @@ module Render
     end
 
     describe "#fetch" do
-      it "raises KeyErrors" do
-        lambda {
-          DottableHash.new.fetch("non_existent_key")
-        }.should raise_error
-      end
-
       it "returns dottable_hashs in lieu of hashes" do
         @dottable_hash["nested_hash"] = { "foo" => "bar" }
         @dottable_hash.fetch("nested_hash").class.should == DottableHash
@@ -143,6 +137,9 @@ module Render
         @dottable_hash.fetch("foo").should == "bar"
       end
 
+      it "accepts default value" do
+        DottableHash.new({ baz: "buz" }).fetch(:foo, :bar).should == :bar
+      end
     end
 
     describe "#fetch_path[!]" do

data/spec/unit/render/generator_spec.rb

@@ -6,7 +6,7 @@ module Render
       expect { Generator }.to_not raise_error
     end
 
-    describe "attributes" do
+    describe "properties" do
       before(:each) do
         @mandatory_options = { algorithm: proc {} }
       end
@@ -15,7 +15,7 @@ module Render
         Generator.new(@mandatory_options.merge({ type: String })).type.should == String
       end
 
-      it "has a matcher to only be used on specific attributes" do
+      it "has a matcher to only be used on specific properties" do
         matcher = %r{.*name.*}
         Generator.new(@mandatory_options.merge({ matcher: matcher })).matcher.should == matcher
       end