render 0.0.4 → 0.0.5

data/lib/render/graph.rb

@@ -1,12 +1,6 @@
-# The Graph is the top-level model that defines a Schema and correlating Graphs.
-# It also includes particular metadata:
-#  - Endpoint to query for its schema's data
-#  - Config for this endpoint, e.g. an access token
-#  - Relationships between it and a Graph that includes it
-
 require "render/schema"
 require "render/errors"
-require "render/dottable_hash"
+require "render/extensions/dottable_hash"
 
 module Render
   class Graph
@@ -25,31 +19,17 @@ module Render
       self.schema = determine_schema(schema_or_definition)
       self.relationships = (options.delete(:relationships) || {})
       self.graphs = (options.delete(:graphs) || [])
-      self.raw_endpoint = options.delete(:endpoint).to_s
+      self.raw_endpoint = (options.delete(:endpoint) || schema.definition[:endpoint]).to_s
       self.config = options
 
       self.inherited_data = {}
     end
 
-    def endpoint
-      uri = URI(raw_endpoint)
-
-      uri.path.gsub!(PARAMS) do |param|
-        key = param_key(param)
-        param.gsub(PARAM, param_value(key))
-      end
-
-      if uri.query
-        uri.query.gsub!(PARAMS) do |param|
-          key = param_key(param)
-          "#{key}=#{param_value(key)}&"
-        end.chop!
-      end
-
-      uri.to_s
+    def title
+      schema.universal_title || schema.title
     end
 
-    def render(inherited_properties = nil)
+    def render!(inherited_properties = nil)
       self.inherited_data = inherited_properties
       if (schema.type == Array)
         explicit_data = inherited_data
@@ -58,16 +38,16 @@ module Render
         explicit_data = explicit_data.merge!(relationship_data_from_parent)
       end
 
-      graph_data = DottableHash.new
+      graph_data = Extensions::DottableHash.new
 
       rendered_data = schema.render!(explicit_data, endpoint) do |parent_data|
         loop_with_configured_threading(graphs) do |graph|
           if parent_data.is_a?(Array)
             graph_data[graph.title] = parent_data.inject([]) do |nested_data, element|
-              nested_data << graph.render(element)[graph.title]
+              nested_data << graph.render!(element)[graph.title]
             end
           else
-            nested_data = graph.render(parent_data)
+            nested_data = graph.render!(parent_data)
             graph_data.merge!(nested_data)
           end
         end
@@ -76,6 +56,27 @@ module Render
       self.rendered_data = graph_data.merge!(rendered_data)
     end
 
+    private
+
+    def endpoint
+      raw_endpoint.gsub!(":host", config.fetch(:host)) if raw_endpoint.match(":host")
+      uri = URI(raw_endpoint)
+
+      uri.path.gsub!(PARAMS) do |param|
+        key = param_key(param)
+        param.gsub(PARAM, param_value(key).to_s)
+      end
+
+      if uri.query
+        uri.query.gsub!(PARAMS) do |param|
+          key = param_key(param)
+          "#{key}=#{param_value(key)}&"
+        end.chop!
+      end
+
+      uri.to_s
+    end
+
     def loop_with_configured_threading(elements)
       if Render.threading?
         threads = []
@@ -92,12 +93,6 @@ module Render
       end
     end
 
-    def title
-      schema.universal_title || schema.title
-    end
-
-    private
-
     def determine_schema(schema_or_definition)
       if schema_or_definition.is_a?(Schema)
         schema_or_definition

data/lib/render/schema.rb

@@ -1,13 +1,9 @@
-# The Schema defines a collection of properties.
-# It is responsible for returning its properties' values back to its Graph.
-
 require "net/http"
 require "json"
 require "render"
-require "render/attribute"
-require "render/array_attribute"
-require "render/hash_attribute"
-require "render/dottable_hash"
+require "render/attributes/array_attribute"
+require "render/attributes/hash_attribute"
+require "render/extensions/dottable_hash"
 
 module Render
   class Schema
@@ -23,14 +19,13 @@ module Render
       :serialized_data,
       :rendered_data
 
-    # TODO When given { ids: [1,2] }, parental_mapping { ids: id } means to make 2 calls
     def initialize(definition_or_title)
       Render.logger.debug("Loading #{definition_or_title}")
 
       self.definition = determine_definition(definition_or_title)
       title_or_default = definition.fetch(:title, DEFAULT_TITLE)
       self.title = title_or_default.to_sym
-      self.type = Render.parse_type(definition[:type])
+      self.type = Type.parse!(definition[:type])
       self.universal_title = definition.fetch(:universal_title, nil)
 
       if definition.keys.include?(:items)
@@ -61,7 +56,7 @@ module Render
       self.raw_data = Render.live ? request(endpoint) : explicit_data
       serialize!(raw_data)
       yield serialized_data if block_given?
-      self.rendered_data = DottableHash.new(hash_with_title_prefixes(serialized_data))
+      self.rendered_data = Extensions::DottableHash.new(hash_with_title_prefixes(serialized_data))
     end
 
     private
@@ -70,7 +65,7 @@ module Render
       if (definition_or_title.is_a?(Hash) && !definition_or_title.empty?)
         definition_or_title
       else
-        Render.definition(definition_or_title)
+        Definition.find(definition_or_title)
       end
     end
 
@@ -89,7 +84,12 @@ module Render
     def default_request(endpoint)
       response = Net::HTTP.get_response(URI(endpoint))
       if response.kind_of?(Net::HTTPSuccess)
-        JSON.parse(response.body).recursive_symbolize_keys!
+        response = JSON.parse(response.body.to_s)
+        if response.is_a?(Array)
+          Extensions::SymbolizableArray.new(response).recursively_symbolize_keys!
+        else
+          Extensions::DottableHash.new(response).recursively_symbolize_keys!
+        end
       else
         raise Errors::Schema::RequestError.new(endpoint, response)
       end

data/lib/render/type.rb

@@ -0,0 +1,63 @@
+# Types define classes of data being interpreted. This is especially important in modeling fake data.
+# Add additional types for your specific needs, along with a generator to create fake data for it.
+
+require "uuid"
+
+module Render
+  module Type
+    @instances = {}
+
+    class Enum; end
+    class Boolean; end
+
+    class << self
+      attr_accessor :instances
+
+      def add!(name, klass)
+        self.instances.merge!({ formatted_name(name) => klass })
+      end
+
+      def find(name)
+        class_for_name(name) || class_for_name(render_name(name))
+      end
+
+      def parse(name, raise_error = false)
+        return name unless name.is_a?(String)
+        Render::Type.find(name) || Object.const_get(name.capitalize)
+      rescue NameError => error
+        raise Errors::InvalidType.new(name) if raise_error
+      end
+
+      def parse!(name)
+        parse(name, true)
+      end
+
+      private
+
+      def class_for_name(name)
+        instances.each do |(instance_name, instance_class)|
+          return instance_class if name.to_s.match(/#{instance_name}/i)
+        end
+        nil
+      end
+
+      def formatted_name(name)
+        name.to_s.downcase.to_sym
+      end
+
+      def render_name(name)
+        formatted_name("render_#{name}")
+      end
+
+      def add_render_specific_type!(name)
+        add!(render_name(name), Type.const_get(name))
+      end
+    end
+
+    add!(:uuid, UUID)
+    add!(:number, Float)
+    add!(:time, Time)
+    add_render_specific_type!(:Boolean)
+    add_render_specific_type!(:Enum)
+  end
+end

data/lib/render/version.rb

@@ -1,3 +1,3 @@
 module Render
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/rakefile.rb

@@ -1,10 +1,10 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-task default: :spec
+task default: %w(render:spec)
 
-module RSpec::Core
-  RakeTask.new(:spec) do |config|
+namespace :render do
+  RSpec::Core::RakeTask.new(:spec) do |config|
     config.verbose = false
     config.rspec_opts = ["--order rand"]
   end

data/readme.md

@@ -1,55 +1,34 @@
 # Render
 
-Create and test API requests simply with schemas.
+Render improves the way you work with APIs.
 
-```ruby
-Render.load_schemas!("spec/schemas") # JSON schema directory
-Render::Graph.new(:film, { endpoint: "http://films.local/films" }).render
-# or stub out schema-specific data
-Render.live = false
-Render::Graph.new(:film).render
-```
+* [Generate type-specific, dynamic API response data for testing](spec/integration/render/schema_spec.rb) with just a schema (JSON or Ruby)
+* [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)
 
-*Use with caution* (Render is under initial development) by updating your Gemfile:
+## Setup
 
-    gem "render"
+Update your Gemfile:
 
-## Caveats
-
-- Render will modify ::Hash and ::Enumerable to provide symbolize/stringify keys methods.
+      gem "render"
 
 ## Usage
 
-*Autoload schemas*
-
-```ruby
-Render.load_schemas!("path/to/json/schemas")
-Render::Graph.new(:schema_title, { endpoint: "http://films.local/films" }).render
-```
+Check out examples as part of the [integration tests](spec/integration/render).
 
-*Variable interpolation*
-
-```ruby
-api_endpoint = "http://films.local/films/:id?:client_token"
-env_specific_client_token = "token"
-
-graph = Render::Graph.new(:schema_title, { endpoint: api_endpoint, client_token: env_specific_client_token })
-graph.render({ id: "an-id" }) # makes request to "http://films.local/films/an-id?client_token=token"
-```
+## Caveats
 
-Check out the examples in [integration tests](spec/integration/).
+- Render is under initial development
 
 ## 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
+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
 
 ## Contributing
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+* Bugs and questions welcomed. If you know (or kind of know) what's going on:
+  * Write a failing test, kudos for solving it
+  * Put up a [pull request](https://help.github.com/articles/using-pull-requests)

data/render.gemspec

@@ -19,12 +19,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-
+  spec.add_development_dependency "rake", "~> 10.1"
   spec.add_runtime_dependency "uuid", "2.3.7"
-
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "debugger"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "debugger", "~> 1.6"
+  spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "webmock", "~> 1.17"
+  spec.add_development_dependency "yard", "~> 0.8"
 end

data/spec/functional/{representation → render}/attribute_spec.rb

@@ -2,18 +2,17 @@ module Render
   describe Attribute do
     context "generators" do
       before(:each) do
-        @original_generators = Render.generators.dup
+        @original_generators = Generator.instances.dup
         Render.stub({ live: false })
       end
 
       after(:each) do
-        Render.generators = @original_generators
+        Generator.instances = @original_generators
       end
 
       it "uses matching generator for #faux_value" do
         name = "Canada Dry"
-        generator = Generator.new({ type: String, matcher: %r{.*name.*}, algorithm: proc { name } })
-        Render.generators << generator
+        Generator.create!(String, %r{.*name.*}, proc { name })
 
         HashAttribute.new({ name: { type: String } }).default_value.should == name
       end

data/spec/functional/{representation → render}/graph_spec.rb

@@ -28,7 +28,7 @@ module Render
 
         it "generates random number of array elements" do
           graph = Graph.new(@array_definition)
-          generated_book_sizes = 5.times.collect { graph.render.books.size }
+          generated_book_sizes = 5.times.collect { graph.render!.books.size }
           generated_book_sizes.compact.size.should > 1
         end
 
@@ -36,28 +36,28 @@ module Render
           it "uses explicit data for hashes" do
             graph = Render::Graph.new(@hash_definition)
             green_eggs_and_ham = "Green Eggs and Ham"
-            data = graph.render({ title: green_eggs_and_ham })
+            data = graph.render!({ title: green_eggs_and_ham })
             data.book.title.should == green_eggs_and_ham
           end
 
           it "uses explicit nil data for hashes" do
             graph = Render::Graph.new(@hash_definition)
-            data = graph.render({ title: nil })
+            data = graph.render!({ title: nil })
             data.book.title.should == nil
           end
 
           it "uses explicit data for arrays" do
             graph = Render::Graph.new(@array_definition)
             id = UUID.generate
-            graph.render([id]).books.should == [id]
-            graph.render([]).books.should == []
+            graph.render!([id]).books.should == [id]
+            graph.render!([]).books.should == []
           end
 
           it "uses explicit data for nested data" do
             @array_definition[:items] = @hash_definition
             nested_graph = Graph.new(@array_definition)
             tell_tale_heart = "The Tell-Tale Heart"
-            data = nested_graph.render([{ title: tell_tale_heart }])
+            data = nested_graph.render!([{ title: tell_tale_heart }])
             data.books.size.should == 1
             data.books.first.title.should == tell_tale_heart
           end

data/spec/integration/render/graph_spec.rb

@@ -0,0 +1,119 @@
+require "render"
+
+module Render
+  describe Graph do
+    before(:each) do
+      @schema = {
+        title: :films,
+        type: Array,
+        items: {
+          id: { type: "number" }
+        }
+      }
+    end
+
+    it "requests data from an endpoint" do
+      stub_request(:get, "http://films.local").to_return({ body: [{ id: 1 }].to_json })
+
+      response = Render::Graph.new(@schema, { endpoint: "http://films.local" }).render!
+      response.should == { films: [{ id: 1 }] }
+    end
+
+    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" })
+
+      response = Render::Graph.new(@schema, { id: 1 }).render!
+      director_1s_films_request.should have_been_made.once
+    end
+
+    it "requests data from an endpoint specified in schema" do
+      stub_request(:get, "http://films.local").to_return({ body: [{ id: 1 }].to_json })
+      @schema.merge!({ endpoint: "http://films.local" })
+
+      response = Render::Graph.new(@schema).render!
+      response.should == { films: [{ id: 1 }] }
+    end
+
+    it "interpolates variables into endpoint" do
+      stub_request(:get, "http://films.local").to_return({ body: [{ id: 1 }].to_json })
+      @schema.merge!({ endpoint: "http://:host" })
+
+      response = Render::Graph.new(@schema, { host: "films.local" }).render!
+      response.should == { films: [{ id: 1 }] }
+    end
+
+    describe "testing" do
+      before(:each) do
+        @original_live = Render.live
+        Render.live = false
+      end
+
+      after(:each) do
+        Render.live = @original_live
+      end
+
+      it "creates fake data for testing" do
+        schema = {
+          title: :film,
+          type: Object,
+          properties: {
+            id: { type: UUID },
+            title: { type: String },
+            director: {
+              type: Object,
+              properties: {
+                name: { type: String },
+                rating: { type: Float }
+              }
+            },
+            genre: {
+              enum: ["horror", "action", "sci-fi"]
+            },
+            tags: {
+              type: Array,
+              required: true,
+              items: {
+                type: Object,
+                properties: {
+                  name: { type: String },
+                  id: { type: Integer }
+                }
+              }
+            }
+          }
+        }
+
+        response = Render::Graph.new(schema).render!
+        UUID.validate(response.film.id).should be_true
+        response.film.title.should be_a(String)
+        response.film.director.name.should be_a(String)
+        response.film.director.rating.should be_a(Float)
+        %w(horror action sci-fi).should include(response.film.genre)
+        response.film.tags.first.name.should be_a(String)
+        response.film.tags.first.id.should be_a(Integer)
+      end
+
+      it "allows overwriting fake data values" do
+        schema = {
+          title: :film,
+          type: Object,
+          properties: {
+            id: { type: UUID },
+            director: {
+              type: Object,
+              properties: {
+                name: { type: String }
+              }
+            }
+          }
+        }
+
+        her_name = "Kathryn Bigelow"
+        response = Render::Graph.new(schema).render!({ director: { name: her_name } })
+        response.film.director.name.should == her_name
+      end
+    end
+
+  end
+end