render 0.0.1 → 0.0.2

data/initialize.rb

@@ -2,6 +2,4 @@
   $: << path
 end
 
-Dir.glob("extensions/*").sort.each { |file| require file }
-
 require "render"

data/{extensions → lib/extensions}/boolean.rb

@@ -1,3 +1,2 @@
 class Boolean
 end
-

data/lib/extensions/enumerable.rb

@@ -0,0 +1,16 @@
+::Enumerable.module_eval do
+  # This is named the same as its Hash counterpart for a reason. I'm not
+  # going to tell you why, consider it my riddle for you.
+  def recursive_symbolize_keys!
+    each do |item|
+      item.recursive_symbolize_keys! if item.respond_to?(:recursive_symbolize_keys!)
+    end
+    self
+  end
+
+  def recursive_stringify_keys!
+    each do |item|
+      item.recursive_stringify_keys! if item.respond_to?(:recursive_stringify_keys!)
+    end
+  end
+end

data/{extensions → lib/extensions}/hash.rb

@@ -36,17 +36,4 @@ class ::Hash
   def symbolize_keys
     dup.symbolize_keys!
   end
-
-  def hardcode(other_hash)
-    dup.hardcode!(other_hash)
-  end
-
-  def hardcode!(other_hash)
-    other_hash.each_pair do |k,v|
-      tv = self[k]
-      self[k] = tv.respond_to?(:hardcode) && v.respond_to?(:hardcode) ? tv.hardcode(v) : v
-    end
-    self
-  end
-
 end

data/lib/render.rb

@@ -3,6 +3,10 @@
 #  - Query its endpoint to construct a hash for its Schema
 #  - Add nested Graphs by interpreting/sending data they need
 
+require "extensions/enumerable"
+require "extensions/boolean"
+require "extensions/hash"
+
 require "render/version"
 require "render/graph"
 require "render/generator"

data/lib/render/dottable_hash.rb

@@ -0,0 +1,114 @@
+module Render
+  class DottableHash < Hash
+    class << self
+      def new(element_to_hash = {})
+        hash = super().merge!(element_to_hash.symbolize_keys)
+        hash.each do |key, value|
+          hash[key] = initialize_element(value)
+        end
+        hash
+      end
+
+      def initialize_element(value)
+        case value
+        when Hash
+          new(value)
+        when Array
+          value.collect { |v| initialize_element(v) }
+        else
+          value
+        end
+      end
+    end
+
+    def []=(key, value)
+      key = key.to_sym
+      value = self.class.initialize_element(value)
+      super
+    end
+
+    def [](key)
+      key = key.to_sym
+      super
+    end
+
+    def delete(key)
+      key = key.to_sym
+      super
+    end
+
+    def has_key?(key)
+      super(key.to_sym)
+    end
+
+    def merge!(other_hash)
+      super(other_hash.symbolize_keys)
+    end
+
+    def merge(other_hash)
+      super(other_hash.symbolize_keys)
+    end
+
+    def method_missing(method, *arguments)
+      if method.match(/\=$/)
+        self[method.to_s.chop] = arguments.first
+      elsif has_key?(method)
+        self[method]
+      else
+        super
+      end
+    end
+
+    def fetch(key)
+      key = key.to_sym
+      raise KeyError.new("Invalid key: #{key}") unless has_key?(key)
+      super
+    end
+
+    def fetch_path(full_path)
+      begin
+        fetch_path!(full_path)
+      rescue KeyError
+        nil
+      end
+    end
+
+    def fetch_path!(full_path)
+      full_path.split(".").inject(self) do |hash, path|
+        raise(KeyError) unless hash.is_a?(Hash)
+
+        hash.fetch(path)
+      end
+    end
+
+    def set_path(full_path, value)
+      self.dup.set_path!(full_path, value)
+    end
+
+    def set_path!(full_path, value)
+      built_hash_for_value = full_path.split(".").reverse.inject({}) do |cumulative, path_to_source|
+        if cumulative.empty?
+          { path_to_source.to_sym => value }
+        else
+          { path_to_source.to_sym => cumulative }
+        end
+      end
+
+      deep_merge!(built_hash_for_value)
+    end
+
+    protected
+
+    def deep_merge(other_hash)
+      merge(other_hash) do |key, oldval, newval|
+        oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
+        newval = newval.to_hash if newval.respond_to?(:to_hash)
+        oldval.is_a?(Hash) && newval.is_a?(Hash) ? self.class.new(oldval).deep_merge(newval) : self.class.new(newval)
+      end
+    end
+
+    def deep_merge!(other_hash)
+      replace(deep_merge(other_hash))
+    end
+  end
+end

data/lib/render/graph.rb

@@ -6,6 +6,7 @@
 
 require "render/schema"
 require "render/errors"
+require "render/dottable_hash"
 
 module Render
   class Graph
@@ -54,11 +55,11 @@ module Render
       uri.to_s
     end
 
-    def pull(inherited_attributes = {})
+    def render(inherited_attributes = {})
       calculate_parental_params!(inherited_attributes)
-      graph_attributes = schema.pull(inherited_attributes.merge(parental_params.merge({ endpoint: endpoint })))
+      graph_attributes = schema.render(inherited_attributes.merge(parental_params.merge({ endpoint: endpoint })))
 
-      graphs.inject(graph_attributes) do |attributes, nested_graph|
+      graph = graphs.inject(graph_attributes) do |attributes, nested_graph|
         threads = []
         # TODO threading should be configured so people may also think about Thread.abort_on_transaction!
         threads << Thread.new do
@@ -66,18 +67,19 @@ module Render
           parent_data = attributes[title]
           nested_graph_data = if parent_data.is_a?(Array)
             data = parent_data.collect do |element|
-              nested_graph.pull(element)
+              nested_graph.render(element)
             end
             key = data.first.keys.first
             attributes[title] = data.collect { |d| d[key] }
           else
-            data = nested_graph.pull(parent_data)
+            data = nested_graph.render(parent_data)
             parent_data.merge!(data)
           end
         end
         threads.collect(&:join)
-        DottableHash.new(attributes)
+        attributes
       end
+      DottableHash.new(graph)
     end
 
     private

data/lib/render/schema.rb

@@ -39,7 +39,7 @@ module Render
       definition.keys.include?(:attributes)
     end
 
-    def pull(options = {})
+    def render(options = {})
       endpoint = options.delete(:endpoint)
       data = Render.live ? request(endpoint) : options
       { title.to_sym => serialize(data) }

data/lib/render/version.rb

@@ -1,3 +1,3 @@
 module Render
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/readme.md

@@ -3,84 +3,43 @@
 Create and test API requests simply with schemas.
 
 ```ruby
-Representation.load_schemas!("spec/schemas") # JSON schema directory
-Representation::Graph.new(:film, { endpoint: "http://films.local/films" }).pull
+Render.load_schemas!("spec/schemas") # JSON schema directory
+Render::Graph.new(:film, { endpoint: "http://films.local/films" }).render
 # or stub out schema-specific data
-Representation.live = false
-Representation::Graph.new(:film).pull
+Render.live = false
+Render::Graph.new(:film).render
 ```
 
-*Use with caution* (Representation is under initial development) by updating your Gemfile:
+*Use with caution* (Render is under initial development) by updating your Gemfile:
 
-    gem "representation"
+    gem "render"
 
-## Usage
-
-Try out examples with `Representation.live = false`.
-
-*Simple*
+## Caveats
 
-```ruby
-schema = Representation::Schema.new({
-  title: :film,
-  type: Object,
-  attributes: {
-    id: { type: UUID },
-    title: { type: String }
-  }
-})
-
-options = {
-  endpoint: "http://films.local/films/:id"
-}
-
-Representation::Graph.new(schema, options).pull({ id: "4cb6b490-d706-0130-2a93-7c6d628f9b06" })
-```
+- Render will modify ::Hash and ::Enumerable to provide symbolize/stringify keys methods.
 
-*Nested*
+## Usage
 
-```ruby
-film_schema = Representation::Schema.new({
-  title: :film,
-  type: Object,
-  attributes: {
-    id: { type: UUID },
-    title: { type: String }
-  }
-})
-
-films_schema = Representation::Schema.new({
-  title: :films,
-  type: Array,
-  elements: {
-    title: :film,
-    type: Object,
-    attributes: {
-      id: { type: UUID }
-    }
-  }
-})
-
-films_graph = Representation::Graph.new(films_schema, { endpoint: "http://films.local/films" })
-film_graph = Representation::Graph.new(film_schema, { endpoint: "http://films.local/films/:id", relationships: { id: :id } })
-films_graph.graphs << film_graph
-films_graph.pull
-```
 *Autoload schemas*
 
 ```ruby
-Representation.load_schemas!("path/to/json/schemas")
-Representation::Graph.new(:schema_title, { endpoint: "http://films.local/films" }).pull
+Render.load_schemas!("path/to/json/schemas")
+Render::Graph.new(:schema_title, { endpoint: "http://films.local/films" }).render
 ```
 
 *Variable interpolation*
 
 ```ruby
-options = { endpoint: "http://films.local/films/:id?:client_token", client_token: "token" }
-graph = Representation::Graph.new(:schema_title, options)
-graph.pull({ id: "an-id" })
+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"
 ```
 
+Check out the examples in [integration tests](spec/integration/).
+
+
 ## Contributing
 
 1. Fork it

data/spec/functional/representation/nested_schemas_spec.rb

@@ -32,7 +32,7 @@ module Render
         }
       }
 
-      Schema.new(schema).pull(data).should == {
+      Schema.new(schema).render(data).should == {
         person: {
           contact: {
             name: contact_name,
@@ -82,7 +82,7 @@ module Render
       }
       people = [zissou, ned]
 
-      Schema.new(schema).pull(people).should == {
+      Schema.new(schema).render(people).should == {
         people: [{
             name: "Steve Zissou",
             nicknames: [

data/spec/functional/representation/schema_spec.rb

@@ -18,7 +18,7 @@ module Render
       brand_name = "Sony"
       response = { brand: brand_name }
 
-      schema.pull(response).should == {
+      schema.render(response).should == {
         television: { brand: brand_name }
       }
     end
@@ -34,7 +34,7 @@ module Render
 
       television_ids = rand(10).times.collect { UUID.generate }
 
-      schema.pull(television_ids).should == {
+      schema.render(television_ids).should == {
         televisions: television_ids
       }
     end
@@ -55,7 +55,7 @@ module Render
       brand_1, brand_2 = *%w(Sony Samsung)
       response = [{ brand: brand_1 }, { brand: brand_2 }]
 
-      schema.pull(response).should == {
+      schema.render(response).should == {
         televisions: [{ brand: brand_1 }, { brand: brand_2 }]
       }
     end
@@ -78,7 +78,7 @@ module Render
       brand_name = "Sony"
       response = { brand: { name: brand_name } }
 
-      schema.pull(response).should == {
+      schema.render(response).should == {
         television: { brand: { name: brand_name } }
       }
     end

data/spec/integration/nested_graph_spec.rb

@@ -33,7 +33,7 @@ describe Render do
         endpoint: @films_endpoint
       }
       graph = Render::Graph.new(:films, options)
-      graph.pull.should == {
+      graph.render.should == {
         films: [
           { name: aquatic_name, year: nil },
           { name: darjeeling_name, year: nil }
@@ -70,7 +70,7 @@ describe Render do
 
       films = Representation::Graph.new(films, { endpoint: @films_endpoint })
       films.graphs << Representation::Graph.new(film, { endpoint: @film_endpoint, relationships: { films: :id } })
-      films.pull.should == {}
+      films.render.should == {}
     end
 
   end

data/spec/integration/single_graph_spec.rb

@@ -25,7 +25,7 @@ describe Render do
       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.pull.should == { films: [{ id: @film_id }] }
+      graph.render.should == { films: [{ id: @film_id }] }
     end
 
     it "returns structured data for specific resources" do
@@ -34,7 +34,7 @@ describe Render do
       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.pull.should == { film: { name: @film_name, year: nil } }
+      graph.render.should == { film: { name: @film_name, year: nil } }
     end
   end
 
@@ -44,7 +44,7 @@ describe Render do
     end
 
     it "use meaningful values" do
-      response = Render::Graph.new(:film).pull({ name: @film_name })
+      response = Render::Graph.new(:film).render({ name: @film_name })
 
       stub_request(:post, "http://films.local/create").to_return({ body: response.to_json })
       response = post_film(:anything)["film"]
@@ -54,7 +54,7 @@ describe Render do
     end
 
     it "allows users to specify specific values" do
-      response = Render::Graph.new(:film).pull({ name: @film_name })
+      response = Render::Graph.new(:film).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 })

data/spec/unit/render/dottable_hash_spec.rb

@@ -0,0 +1,234 @@
+require "render/dottable_hash"
+
+module Render
+  describe DottableHash do
+    before(:each) do
+      @dottable_hash = DottableHash.new
+    end
+
+    describe "new" do
+      it "creates from a hash" do
+        dottable_hash = DottableHash.new({ "foo" => "bar" })
+        dottable_hash.should == { :foo => "bar" }
+      end
+
+      it "initializes new hashes as dottable_hashes" do
+        dottable_hash = DottableHash.new({ :foo => { :bar => "baz" } })
+        dottable_hash[:foo].class.should == DottableHash
+      end
+
+      it "converts all keys to symbols" do
+        dottable_hash = DottableHash.new({ "foo" => { "bar" => "baz" } })
+        dottable_hash.keys.include?(:foo).should be_true
+      end
+    end
+
+    describe "#[]" do
+      it "converts keys to strings" do
+        @dottable_hash[:foo] = "bar"
+        @dottable_hash.keys.include?(:foo).should be_true
+      end
+
+      it "converts hash values to dottable_hashs" do
+        @dottable_hash[:foo] = { bar: { baz: "baz" } }
+        @dottable_hash.foo.bar.class.should == DottableHash
+      end
+
+      it "retrieves values by stringified keys" do
+        @dottable_hash["foo"] = "bar"
+        @dottable_hash[:foo].should == "bar"
+      end
+
+      it "converts hashes in arrays to dottable hashes" do
+        pallet = DottableHash.new
+        pallet.foo = [{ bar: "baz" }]
+        pallet.foo.first.class.should == DottableHash
+      end
+    end
+
+    describe "#delete" do
+      it "symbolizes keys" do
+        @dottable_hash["foo"] = { "bar" => "bar", "baz" => "baz" }
+        @dottable_hash.foo.delete(:bar)
+        @dottable_hash.should == { :foo => { :baz => "baz" } }
+      end
+    end
+
+    describe ".has_key?" do
+      it "converts symbols to strings" do
+        DottableHash.new({ foo: "bar" }).has_key?(:foo).should == true
+      end
+    end
+
+    describe "#method_missing" do
+      it "returns value for key when it exists" do
+        @dottable_hash[:foo] = "bar"
+        @dottable_hash.foo.should == "bar"
+      end
+
+      it "raises an error when no key exists" do
+        lambda {
+          @dottable_hash.foo
+        }.should raise_error(NoMethodError)
+      end
+
+      it "returns the same object as in the hash" do
+        @dottable_hash[:foo] = { bar: "baz" }
+        dottable_hash_object_id = @dottable_hash.foo.object_id
+        @dottable_hash.foo.object_id.should == dottable_hash_object_id
+      end
+
+      it "sets values" do
+        @dottable_hash.foo = "bar"
+        @dottable_hash.foo.should == "bar"
+      end
+    end
+
+    describe "dot access" do
+      it "provides acess to keys as methods" do
+        dottable_hash = DottableHash.new({ "foo" => "bar" })
+        dottable_hash.foo.should == "bar"
+      end
+
+      it "provides acess to nested keys as methods" do
+        dottable_hash = DottableHash.new({ "foo" => {"bar" => {"baz" => "bat"}}})
+        dottable_hash.foo.bar.baz.should == "bat"
+      end
+
+      it "provides indifferent accesss" do
+        dottable_hash = DottableHash.new({ :foo => {:bar => {"baz" => "bat"}}})
+        dottable_hash.foo.bar.baz.should == "bat"
+      end
+
+      it "provides acess to keys with nil values" do
+        dottable_hash = DottableHash.new({ "foo" => {"bar" => nil} })
+        dottable_hash.foo.bar.should == nil
+      end
+
+      it "raises key error when it doesn't exist" do
+        dottable_hash = DottableHash.new({ "foo" => "bar" })
+        expect { dottable_hash.fu }.to raise_error(NoMethodError)
+      end
+
+      it "provides the dot access to a hash inside of an array" do
+        dottable_hash = DottableHash.new({ "foo" => [{"bar" => "baz"}]})
+        dottable_hash.foo.first.bar.should == "baz"
+      end
+
+      it "provides the dot access to to a list of strings inside an array" do
+        dottable_hash = DottableHash.new({ "foo" => ["bar", "baz"]})
+        dottable_hash.foo.should == ["bar", "baz"]
+      end
+
+      it "initializes hashes in nested arrays as dottable_hashs" do
+        dottable_hash = DottableHash.new({ foo: [{ bar: [{ baz: "one" }] }] })
+        dottable_hash.foo.first.bar.first.class.should == DottableHash
+      end
+    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
+      end
+
+      it "returns value of corresponding key object" do
+        @dottable_hash["foo"] = "bar"
+        @dottable_hash.fetch("foo").should == "bar"
+      end
+
+    end
+
+    describe "#fetch_path[!]" do
+      it "returns value of corresponding key object" do
+        @dottable_hash["foo"] = "bar"
+        @dottable_hash.fetch_path("foo").should == "bar"
+      end
+
+      it "returns value of expanded key object" do
+        @dottable_hash["foo"] = { "bar" => "baz" }
+        @dottable_hash.fetch_path("foo.bar").should == "baz"
+      end
+
+      it "raises key errors for nonexistent hashes" do
+        expect {
+          @dottable_hash.fetch_path!("foo")
+        }.to raise_error(KeyError)
+      end
+
+      it "raises key errors when searching into a string" do
+        @dottable_hash["foo"] = "bar"
+        expect {
+          @dottable_hash.fetch_path!("foo.bar")
+        }.to raise_error(KeyError)
+      end
+
+      it "does not raise errors for dottable_hashs with suppressed key errors" do
+        expect {
+          @dottable_hash.fetch_path("foo")
+        }.not_to raise_error
+
+        @dottable_hash["foo"] = "bar"
+        expect {
+          @dottable_hash.fetch_path("foo.bar")
+        }.not_to raise_error
+      end
+    end
+
+    describe "#set_path!" do
+      it "sets key's corresponding value" do
+        @dottable_hash.set_path!("foo", "bar")
+        @dottable_hash[:foo].should == "bar"
+      end
+
+      it "sets values for nested paths" do
+        @dottable_hash.set_path!("foo.bar.baz", "i'm really in here!")
+        {
+          :foo => {
+            :bar => {
+              :baz => "i'm really in here!"
+            }
+          }
+        }.should == @dottable_hash
+      end
+
+      it "does not overwrite the root key" do
+        @dottable_hash.set_path!("foo.bar", "bar")
+        @dottable_hash.set_path!("foo.baz.one", "baz1")
+        @dottable_hash.set_path!("foo.baz.two", "baz2")
+        {
+          :foo => {
+            :bar => "bar",
+            :baz => {
+              :one => "baz1",
+              :two => "baz2"
+            }
+          }
+        }.should == @dottable_hash
+      end
+    end
+
+    describe "#merge!" do
+      it "works with merged keys as symbols" do
+        dottable_hash = DottableHash.new({ stuff: {} })
+        dottable_hash.stuff.merge!({ things: "widgets" })
+        dottable_hash.stuff.things.should == "widgets"
+      end
+    end
+
+    describe "#merge" do
+      it "works with merged keys as symbols" do
+        dottable_hash = DottableHash.new({ stuff: {} })
+        stuff_dottable_hash = dottable_hash.stuff.merge({ things: "widgets" })
+        stuff_dottable_hash.things.should == "widgets"
+      end
+    end
+
+  end
+end

data/spec/unit/render/graph_spec.rb

@@ -123,13 +123,21 @@ module Render
       end
     end
 
-    describe ".pull" do
+    describe "#render" do
       it "returns its schema's data" do
         pull = { film: { id: UUID.generate } }
-        @schema.stub({ pull: pull })
+        @schema.stub({ render: pull })
 
         graph = Graph.new(@schema)
-        graph.pull.should == pull
+        graph.render.should == pull
+      end
+
+      it "returns a dottable hash" do
+        pull = { film: { id: UUID.generate } }
+        @schema.stub({ render: pull })
+
+        graph = Graph.new(@schema)
+        graph.render.should be_a(DottableHash)
       end
 
       it "sends interpolated endpoint to its schema" do
@@ -137,8 +145,9 @@ module Render
         client_id = UUID.generate
         graph = Graph.new(@schema, { endpoint: endpoint, client_id: client_id })
 
-        @schema.should_receive(:pull).with({ endpoint: graph.endpoint }).and_return(@pull)
-        graph.pull.should == @pull
+        pull = { foo: "bar" }
+        @schema.should_receive(:render).with({ endpoint: graph.endpoint }).and_return(pull)
+        graph.render.should == pull
       end
 
       context "with nested graphs" do
@@ -162,19 +171,19 @@ module Render
 
         it "merges nested graphs" do
           pulled_data = { a: "attribute" }
-          @director_schema.stub({ pull: pulled_data })
+          @director_schema.stub({ render: pulled_data })
 
           director = Graph.new(@director_schema)
           film = Graph.new(@film_schema, { graphs: [director]})
 
-          film_graph = film.pull[@film_schema.title.to_sym]
+          film_graph = film.render[@film_schema.title.to_sym]
           film_graph.should include(pulled_data)
         end
 
         it "uses parent data to calculate endpoint" do
           director_id = UUID.generate
           film = Graph.new(@film_schema)
-          film.schema.stub({ pull: { film: { director_id: director_id } } })
+          film.schema.stub({ render: { film: { director_id: director_id } } })
 
           endpoint = "http://endpoint.local/directors/:id"
           interpolated_endpoint = "http://endpoint.local/directors/#{director_id}"
@@ -182,11 +191,11 @@ module Render
           director = Graph.new(@director_schema, { endpoint: endpoint, relationships: relationships })
 
           film.graphs << director
-          director.schema.should_receive(:pull).with do |args|
+          director.schema.should_receive(:render).with do |args|
             args[:endpoint].should == interpolated_endpoint
           end.and_return({})
 
-          film.pull
+          film.render
         end
 
         context "offline" do
@@ -195,7 +204,7 @@ module Render
             director = Graph.new(@director_schema, { relationships: relationships })
             film = Graph.new(@film_schema, { graphs: [director]})
 
-            film_graph = film.pull[@film_schema.title.to_sym]
+            film_graph = film.render[@film_schema.title.to_sym]
             film_graph[@director_schema.title.to_sym][:id].should == film_graph[:director_id]
           end
         end

data/spec/unit/render/schema_spec.rb

@@ -156,7 +156,7 @@ module Render
           stub_request(:get, endpoint).to_return(response)
 
           film = Schema.new(@film_schema)
-          film.pull({ endpoint: endpoint }).should == response_body
+          film.render({ endpoint: endpoint }).should == response_body
         end
 
         it "raises error if response is not 2xx" do
@@ -166,7 +166,7 @@ module Render
 
           expect {
             film = Schema.new(@film_schema)
-            film.pull({ endpoint: endpoint })
+            film.render({ endpoint: endpoint })
           }.to raise_error(Errors::Schema::RequestError)
         end
 
@@ -175,7 +175,7 @@ module Render
           stub_request(:get, endpoint).to_return({ body: "Server Error: 500" })
 
           expect {
-            Schema.new(@film_schema).pull({ endpoint: endpoint })
+            Schema.new(@film_schema).render({ endpoint: endpoint })
           }.to raise_error(Errors::Schema::InvalidResponse)
         end
       end
@@ -187,7 +187,7 @@ module Render
 
         it "returns schema with fake values" do
           film = Schema.new(@film_schema)
-          film = film.pull[:film]
+          film = film.render[:film]
           film[:name].should be_a(String)
           film[:genre].should be_a(String)
         end
@@ -200,7 +200,7 @@ module Render
         stub_request(:get, endpoint).to_return(response)
 
         film = Schema.new(@film_schema)
-        film.pull({ endpoint: endpoint }).should == { film: response_body }
+        film.render({ endpoint: endpoint }).should == { film: response_body }
       end
 
       it "handles Array responses" do
@@ -217,7 +217,7 @@ module Render
         stub_request(:get, endpoint).to_return(response)
 
         film = Schema.new(@films_schema)
-        film.pull({ endpoint: endpoint }).should == { films: response_body }
+        film.render({ endpoint: endpoint }).should == { films: response_body }
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: render
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -137,13 +137,13 @@ files:
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
-- extensions/boolean.rb
-- extensions/dottable_hash.rb
-- extensions/enumerable.rb
-- extensions/hash.rb
 - initialize.rb
+- lib/extensions/boolean.rb
+- lib/extensions/enumerable.rb
+- lib/extensions/hash.rb
 - lib/render.rb
 - lib/render/attribute.rb
+- lib/render/dottable_hash.rb
 - lib/render/errors.rb
 - lib/render/generator.rb
 - lib/render/graph.rb
@@ -163,6 +163,7 @@ files:
 - spec/support/helpers.rb
 - spec/unit/extensions/boolean_spec.rb
 - spec/unit/render/attribute_spec.rb
+- spec/unit/render/dottable_hash_spec.rb
 - spec/unit/render/generator_spec.rb
 - spec/unit/render/graph_spec.rb
 - spec/unit/render/schema_spec.rb
@@ -182,7 +183,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4037297994786414252
+      hash: 1123791212905751399
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -191,7 +192,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4037297994786414252
+      hash: 1123791212905751399
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -211,6 +212,7 @@ test_files:
 - spec/support/helpers.rb
 - spec/unit/extensions/boolean_spec.rb
 - spec/unit/render/attribute_spec.rb
+- spec/unit/render/dottable_hash_spec.rb
 - spec/unit/render/generator_spec.rb
 - spec/unit/render/graph_spec.rb
 - spec/unit/render/schema_spec.rb

data/extensions/dottable_hash.rb

@@ -1,113 +0,0 @@
-class DottableHash < Hash
-  class << self
-    def new(element_to_hash = {})
-      hash = super().merge!(element_to_hash.symbolize_keys)
-      hash.each do |key, value|
-        hash[key] = initialize_element(value)
-      end
-      hash
-    end
-
-    def initialize_element(value)
-      case value
-      when Hash
-        new(value)
-      when Array
-        value.collect { |v| initialize_element(v) }
-      else
-        value
-      end
-    end
-  end
-
-  def []=(key, value)
-    key = key.to_sym
-    value = self.class.initialize_element(value)
-    super
-  end
-
-  def [](key)
-    key = key.to_sym
-    super
-  end
-
-  def delete(key)
-    key = key.to_sym
-    super
-  end
-
-  def has_key?(key)
-    super(key.to_sym)
-  end
-
-  def merge!(other_hash)
-    super(other_hash.symbolize_keys)
-  end
-
-  def merge(other_hash)
-    super(other_hash.symbolize_keys)
-    self
-  end
-
-  def method_missing(method, *arguments)
-    if method.match(/\=$/)
-      self[method.to_sym.chop] = arguments.first
-    elsif has_key?(method)
-      self[method]
-    else
-      super
-    end
-  end
-
-  def fetch(key)
-    key = key.to_sym
-    raise KeyError.new("Invalid key: #{key}") unless has_key?(key)
-    super
-  end
-
-  def fetch_path(full_path)
-    begin
-      fetch_path!(full_path)
-    rescue KeyError
-      nil
-    end
-  end
-
-  def fetch_path!(full_path)
-    full_path.split(".").inject(self) do |hash, path|
-      raise(KeyError) unless hash.is_a?(Hash)
-
-      hash.fetch(path)
-    end
-  end
-
-  def set_path(full_path, value)
-    self.dup.set_path!(full_path, value)
-  end
-
-  def set_path!(full_path, value)
-    built_hash_for_value = full_path.split(".").reverse.inject({}) do |cumulative, path_to_symource|
-      if cumulative.empty?
-        { path_to_symource.to_sym => value }
-      else
-        { path_to_symource.to_sym => cumulative }
-      end
-    end
-
-    deep_merge!(built_hash_for_value)
-  end
-
-  protected
-
-  def deep_merge(other_hash)
-    merge(other_hash) do |key, oldval, newval|
-      oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
-      newval = newval.to_hash if newval.respond_to?(:to_hash)
-      oldval.is_a?(Hash) && newval.is_a?(Hash) ? self.class.new(oldval).deep_merge(newval) : self.class.new(newval)
-    end
-  end
-
-  def deep_merge!(other_hash)
-    replace(deep_merge(other_hash))
-  end
-end

data/extensions/enumerable.rb

@@ -1,36 +0,0 @@
-::Enumerable.module_eval do
-  # This is named the same as its Hash counterpart for a reason. I'm not
-  # going to tell you why, consider it my riddle for you.
-  def recursive_symbolize_keys!
-    each do |item|
-      item.recursive_symbolize_keys! if item.respond_to?(:recursive_symbolize_keys!)
-    end
-    self
-  end
-
-  def recursive_stringify_keys!
-    each do |item|
-      item.recursive_stringify_keys! if item.respond_to?(:recursive_stringify_keys!)
-    end
-  end
-
-  def hardcode(enumerable)
-    dup.hardcode!(enumerable)
-  end
-
-  def hardcode!(enumerable)
-    if self.empty? && enumerable.any?
-      enumerable
-    else
-      each_with_index do |a, index|
-        if a.is_a?(Hash)
-          self[index] = a.hardcode(enumerable[index]) if enumerable[index]
-        elsif a.is_a?(Enumerable)
-          self[index] = a.collect { |v| a.hardcode(enumerable[index]) }
-        else
-          self[index] = enumerable[index] if enumerable[index]
-        end
-      end
-    end
-  end
-end