compositor 0.1.1 → 0.1.3

data/.pairs

@@ -7,6 +7,7 @@ pairs:
   es: Eric Saxby; sax
   cc: Cihan Cimen; cihan
   sc: Server Cimen; server
+  rm: Richard Millan; richardiux
 email:
   prefix: pair
   domain: wanelo.com

data/README.md

@@ -24,30 +24,40 @@ Or install it yourself as:
 
 ## Usage
 
-For each model that needs a hash/json representation you need to create a ruby class that subclasses Composite::Leaf,
-adds some custom state that's important for rendering that object, and implements #to_hash method:
+For each model that needs a hash/json representation you need to create a ruby class that subclasses ```Composite::Leaf```,
+adds some custom state that's important for rendering that object in addition to ```view_context```, and implement the ```#to_hash```
+method.
+
+The ```view_context``` variable is a reference to an object holding necessary helpers for generating JSON, for example
+view_context is automatically available inside Rails controllers, and contains helper methods necessary to generate application URLs.
+Outside of Rails application, ```view_context``` can be any other object holding application helpers or state.  All
+subclasses of ```Compositor::Leaf``` inherit view_context reference, and can use it to construct Hash representations.
+
+We recommend you place your Compositor classes in eg ```app/compositors/*``` directory, that has one compositor
+class per model class you will be rendering. Example below would be ```app/compositors/user.rb```, a compositor class
+wrapping ```User``` model.
 
 ```ruby
-module Compositor
-  class Leaf::User < ::Compositor::Leaf
-    attr_accessor :user
-
-    def initialize(view_context, user, attrs = {})
-      super(view_context, {user: user}.merge!(attrs))
-    end
-
-    def to_hash
-       with_root_element do
-          {
-              id: user.id,
-              username: user.username,
-              location: user.location,
-              bio: user.bio,
-              url: user.url
-          }
-        end
-      end
-    end
+# The actual class name "User" is converted into a DSL method named "user", shown later.
+
+class UserCompositor < Compositor::Leaf
+  attr_accessor :user
+
+  def initialize(context, user, attrs = {})
+    super(context, attrs)
+    self.user = user
+  end
+
+  def to_hash
+    {
+        id: user.id,
+        username: user.username,
+        location: user.location,
+        bio: user.bio,
+        url: user.url,
+        image_url: context.image_path(user.avatar),
+        ...
+    }
   end
 end
 ```
@@ -56,30 +66,34 @@ This small class automatically registers "user" DSL method, which receives a use
 important attributes.
 
 Then this class can be merged with other similar "leaf" classes, or another "composite" class, such as
-Composite::Hash or Composite::List to create a complex nested Hash or JSON data structure.
+Composite::Map or Composite::List to create a Hash or an Array as the top-level JSON data structure.
 
 Once the tree of composite objects has been setup, calling #to_hash on the top level object quickly
 generates hash by walking the tree and merging everything together.
 
+In the example below, application defines also ```StoreCompositor```, ```ProductCompositor``` classes
+that similar to ```UserCompositor``` return hash representations of each model object.
+
 ```ruby
 
-   composite = Composite.create(view_context) do
-     hash do
-       store store, root: :store
-       user current_user, root: :user
-       list collection: products, root: :products do |p|
+   compositor = Compositor::DSL.create(context) do
+     map do
+       store @store, root: :store
+       user @user, root: :user
+       list collection: @products, root: :products do |p|
          product p
        end
      end
    end
 
-   puts composite.to_hash # =>
+   puts compositor.to_hash # =>
 
    {
       :store => {
          id: 12354,
          name: "amazon.com",
          url: "http://www.amazon.com",
+
          ..
       },
       :user => {
@@ -87,7 +101,8 @@ generates hash by walking the tree and merging everything together.
          username: "kigster",
          location: "San Francisco",
          bio: "",
-         url: ""
+         url: "",
+         image_url: "http://cdn-app.domain.com/kigster/avatar/200.jpg"
       },
       :products => {
            [ id: 1234, :name => "Awesome Product", ... ],
@@ -96,6 +111,10 @@ generates hash by walking the tree and merging everything together.
    }
 ```
 
+The context is an object that can contain helpers, instance variables, or anything that can be used
+within leaves. For example, you can pass in the view_context from the controller to get access to any
+Rails routes or helpers.
+
 ## Contributing
 
 1. Fork it

data/compositor.gemspec

@@ -15,6 +15,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = %w(lib)
   gem.version       = Compositor::VERSION
 
+  gem.add_dependency 'oj'
+
   gem.add_development_dependency 'rspec'
 
   gem.add_development_dependency 'guard-rspec'

data/lib/compositor.rb

@@ -3,22 +3,28 @@ require 'compositor/version'
 module Compositor
 end
 
-class String
-  def constantize
-    camel_cased_word = self
-    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
-      raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
-    end
+unless "".respond_to?(:constantize)
+  class String
+    def constantize
+      camel_cased_word = self
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+        raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+      end
 
-    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
   end
+end
 
-  def underscore
-    self.gsub(/::/, '/').
+unless "".respond_to?(:underscore)
+  class String
+    def underscore
+      self.gsub(/::/, '/').
         gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
         gsub(/([a-z\d])([A-Z])/, '\1_\2').
         tr("-", "_").
         downcase
+    end
   end
 end
 

data/lib/compositor/base.rb

@@ -1,11 +1,11 @@
 module Compositor
   class Base
     attr_reader :attrs
-    attr_accessor :root, :view_context
+    attr_accessor :root, :context
 
     def initialize(view_context, attrs = {})
       @attrs = attrs
-      self.view_context = view_context
+      self.context = view_context
       attrs.each_pair do |key, value|
         self.send("#{key}=", value)
       end
@@ -23,10 +23,6 @@ module Compositor
       to_hash
     end
 
-    def collection_to_generator(klazz, collection)
-      collection.map { |o| klazz.new(view_context) }
-    end
-
     def to_json(options = {})
       Oj.dump(to_hash)
     end
@@ -40,13 +36,29 @@ module Compositor
     end
 
     def self.root_class_name(klazz)
-      klazz.name.gsub(/.*::/, '').underscore
+      klazz.name.gsub(/(.*::)|(Compositor$)/, '').underscore
+    end
+
+    def self.inherited(subclass)
+      method_name = root_class_name(subclass)
+      unless method_name.eql?("base") # check if it's already defined
+        Compositor::DSL.send(:define_method, method_name) do |*args, &block|
+          subclass.
+            new(@context, *args).
+            dsl(self, &block)
+        end
+      end
+    end
+
+    def dsl
+      raise "Implement in subclasses"
     end
   end
 end
 
-require_relative 'leaf'
-require_relative 'composite'
 require_relative 'dsl'
+require_relative 'composite'
+require_relative 'leaf'
+require_relative 'literal'
 require_relative 'list'
-require_relative 'hash'
+require_relative 'map'

data/lib/compositor/composite.rb

@@ -2,8 +2,9 @@ module Compositor
   class Composite < Compositor::Base
     attr_accessor :collection, :renderer
 
-    def initialize(view_context, *args)
+    def initialize(view_context, args = {})
       super
+      @collection_set = true if args.has_key?(:collection)
       self.collection ||= []
     end
 
@@ -13,41 +14,29 @@ module Compositor
       end
     end
 
-    def map_collection
-      self.collection = self.collection.map do |item|
-        yield item
-      end
-    end
-
     def composite?
       true
     end
 
-    def self.inherited(subclass)
-      method_name = subclass.name.gsub(/.*::/, '').underscore
-      unless method_name.eql?("base")
-        Compositor::DSL.send(:define_method, method_name) do |args = {}, &block|
-          original_generator = self.generator
-          composite = subclass.new(self.view_context, args)
-
-          self.generator = composite
-
-          if args[:collection] && block
-            # reset collection, we'll be mapping it via a block
-            composite.collection = []
-            args[:collection].each do |object|
-              self.instance_exec(object, &block)
-            end
-          elsif block
-            self.instance_eval &block
-          end
-
-          if original_generator
-            self.generator = original_generator
-            self.generator.collection << composite
-          end
+    def dsl(dsl, &block)
+      original_generator = dsl.generator
+
+      dsl.generator = self
+
+      if self.collection && @collection_set && block
+        # reset collection, we'll be mapping it via a block
+        unmapped_collection = collection
+        self.collection = []
+        unmapped_collection.each do |object|
+          dsl.instance_exec(object, &block)
         end
+      elsif block
+        dsl.instance_eval &block
       end
+
+      dsl.generator = original_generator if original_generator
+
+      dsl.generator.collection << self if dsl.generator != self
     end
   end
 end

data/lib/compositor/dsl.rb

@@ -1,26 +1,23 @@
 module Compositor
   class DSL
-    attr_reader :view_context
-    attr_accessor :result, :generator
+    attr_reader :context
+    attr_accessor :generator
 
-    def initialize(view_context)
-      @view_context = view_context
+    def initialize(context)
+      @context = context
     end
 
-    def self.create(view_context, &block)
-      dsl = new(view_context)
+    def self.create(context, &block)
+      dsl = new(context)
+      context.instance_variables.each do |variable|
+        dsl.instance_variable_set(variable, context.instance_variable_get(variable))
+      end
       dsl.instance_eval &block if block
       dsl
     end
 
-    def paginate collection, params
-      paginator collection: collection,
-                pagination_url: params[:pagination_url],
-                params: params[:api_params]
-    end
-
-    def to_json
-      generator.to_json
+    def to_json(options = {})
+      generator.to_json(options)
     end
 
     def to_hash

data/lib/compositor/leaf.rb

@@ -1,14 +1,5 @@
 module Compositor
   class Leaf < Compositor::Base
-    attr_accessor :object
-
-    def initialize(view_context, object = {}, args = {})
-      if object.is_a?(::Hash)
-        super(view_context, object)
-      else
-        super(view_context, {object: object}.merge!(args))
-      end
-    end
 
     def root
       if @root.is_a?(Symbol)
@@ -24,19 +15,12 @@ module Compositor
       false
     end
 
-    def self.inherited(subclass)
-      method_name = root_class_name(subclass)
-      unless method_name.eql?("base")
-        Compositor::DSL.send(:define_method, method_name) do |*args|
-          leaf = subclass.new(@view_context, *args)
-          if self.generator
-            raise "Leaves should be called within composite" unless self.generator.composite?
-            self.generator.collection << leaf
-          else
-            self.generator = leaf
-          end
-          leaf
-        end
+    def dsl(dsl)
+      if dsl.generator
+        raise "Leaves should be called within composite" unless dsl.generator.composite?
+        dsl.generator.collection << self
+      else
+        dsl.generator = self
       end
     end
   end

data/lib/compositor/literal.rb

@@ -0,0 +1,14 @@
+module Compositor
+  class Literal < Compositor::Leaf
+    attr_accessor :object
+
+    def initialize(view_context, object = {}, args = {})
+      super(view_context, args)
+      self.object = object
+    end
+
+    def to_hash
+      object
+    end
+  end
+end

data/lib/compositor/{hash.rb → map.rb}

@@ -1,5 +1,5 @@
 module Compositor
-  class Hash < ::Compositor::Composite
+  class Map < ::Compositor::Composite
     def renderer
       @renderer ||= Compositor::Renderer::Merged
     end

data/lib/compositor/version.rb

@@ -1,3 +1,3 @@
 module Compositor
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/spec/compositor/base_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Compositor::Base do
+  describe "#root_class_name" do
+    it "returns the underscored class name" do
+      Compositor::Base.root_class_name(Object).should == "object"
+    end
+
+    it "returns the underscored class name with compositor stripped out" do
+      Compositor::Base.root_class_name(DslStringCompositor).should == "dsl_string"
+    end
+  end
+end

data/spec/compositor/dsl_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Compositor::DSL do
+
+  let(:context) { Object.new }
+
+  describe '#empty' do
+    it 'returns the default type' do
+      dsl = Compositor::DSL.create(context) do
+      end
+
+      nil.should == dsl.to_hash
+    end
+  end
+
+  describe 'instance variables' do
+    it 'allows instance variables from the view context to be accessed in the dsl evaluation' do
+      context.instance_eval do
+        @blah = 1
+      end
+
+      Compositor::DSL.create(context) do
+        raise "Instance variable should be available in DSL" unless @blah == 1
+      end
+    end
+  end
+end

data/spec/compositor/hash_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Compositor::Map do
+  let(:context) { Object.new }
+
+  it 'returns the generated map' do
+    expected = {
+      tests: {
+        num1: {number: 1},
+        num2: {number: 2},
+        num3: {number: 3}
+      }
+    }
+
+    dsl = Compositor::DSL.create(context)
+    dsl.map root: :tests do
+      dsl.dsl_int 1, root: :num1
+      dsl.dsl_int 2, root: :num2
+      dsl.dsl_int 3, root: :num3
+    end
+
+    expected.should == dsl.to_hash
+  end
+
+  it 'returns the generated deeply nested map without explicit receiver' do
+    expected = {
+      tests: {
+        num1: {number: 1},
+        num2: {number: 2},
+        num3: {number: 3},
+        stuff: [
+          {number: 10},
+          {number: 11}
+        ]
+      }
+    }
+
+    dsl = Compositor::DSL.create(context)
+    dsl.map root: :tests do
+      dsl_int 1, root: :num1
+      dsl_int 2, root: :num2
+      dsl_int 3, root: :num3
+      list :root => :stuff do
+        dsl_int 10
+        dsl_int 11
+      end
+    end
+
+    expected.should == dsl.to_hash
+  end
+
+  describe '#empty' do
+    it 'returns the default type' do
+      dsl = Compositor::DSL.create(context) do
+        map collection: [], root: false
+      end
+
+      {}.should == dsl.to_hash
+    end
+  end
+end

data/spec/compositor/leaf_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Compositor::Leaf do
+  let(:context) { Object.new }
+
+  describe '#create' do
+    it "defines #dsl_string method on the DSL class" do
+      dsl = Compositor::DSL.create(context)
+      dsl.should respond_to(:dsl_string)
+    end
+
+    it "allows calling defined methods via a block" do
+      block_ran = false
+      Compositor::DSL.create(context) do |dsl|
+        dsl.dsl_string
+        block_ran = true
+      end
+      block_ran.should be_true
+    end
+
+    it "returns last generator called via block" do
+      dsl = Compositor::DSL.create(context) do |dsl|
+        dsl.dsl_string
+      end
+
+      {a: "b"}.should == dsl.to_hash
+    end
+
+    it "returns an instance of subclass" do
+      dsl = Compositor::DSL.create(context).dsl_string
+      dsl.should be_kind_of(DslStringCompositor)
+    end
+  end
+end

data/spec/compositor/list_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Compositor::List do
+  let(:context) { Object.new }
+
+  it 'returns the generated array with the explicit receiver' do
+    integers = [1, 2, 3]
+    expected = {
+      tests: [
+        {number: 1},
+        {number: 2},
+        {number: 3}
+      ]
+    }
+
+    dsl = Compositor::DSL.create(context)
+    dsl.list root: :tests, collection: integers do |item|
+      dsl.dsl_int item
+    end
+
+    dsl.to_hash.should == expected
+  end
+
+  it 'returns the generated array with explicit receiver' do
+    integers = [1, 2, 3]
+    expected = {
+      tests: [
+        {number: 1},
+        {number: 2},
+        {number: 3}
+      ]
+    }
+
+    dsl = Compositor::DSL.create(context)
+    dsl.list root: :tests, collection: integers do |item|
+      dsl_int item
+    end
+
+    expected.should == dsl.to_hash
+  end
+
+  describe '#empty' do
+    it 'returns the default type' do
+      dsl = Compositor::DSL.create(context) do
+        list collection: [], root: false
+      end
+
+      [].should == dsl.to_hash
+    end
+
+    it 'doesnt execute the block if an empty collection is passed' do
+      dsl = Compositor::DSL.create(context) do
+        list collection: [], root: false do |p|
+          raise "Shouldnt be a DSL" if p.instance_of?(Compositor::DSL)
+        end
+      end
+
+      [].should == dsl.to_hash
+    end
+  end
+end

data/spec/compositor/literal_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Compositor::Literal do
+
+  let(:context) { Object.new }
+
+  it 'returns the hash its given' do
+    actual = { test: 123 }
+
+    Compositor::Literal.new(context, actual).to_hash.should == actual
+  end
+end

data/spec/compositor/performance_spec.rb

@@ -1,8 +1,8 @@
-require_relative '../spec_helper'
+require 'spec_helper'
 
 describe 'Performance' do
 
-  let(:view_context) { Object.new }
+  let(:context) { Object.new }
   let(:permitted_dsl_performance_penalty) { 60 } # 60% slower is allowed, any slower is not.)
 
   describe 'generating DSL' do
@@ -15,9 +15,9 @@ describe 'Performance' do
       dsl = nil
       output = Benchmark.measure do
         10000.times do
-          dsl = Compositor::DSL.create(view_context) do |dsl|
-            hash do
-              dsl_string "hello"
+          dsl = Compositor::DSL.create(context) do |dsl|
+            map do
+              dsl_string string: "hello"
               dsl_int 3
               list collection: [1, 2, 3], root: :numbers do |number|
                 dsl_int number
@@ -30,15 +30,14 @@ describe 'Performance' do
 
       @timing[:dsl] = output.to_s.to_f
 
-      cmp = nil
       output = Benchmark.measure do
         10000.times do
-          string = Compositor::Leaf::DslString.new(view_context)
-          int = Compositor::Leaf::DslInt.new(view_context, 3)
-          list = Compositor::List.new(view_context,
+          string = DslStringCompositor.new(context)
+          int = DslIntCompositor.new(context, 3)
+          list = Compositor::List.new(context,
                                       root: :numbers,
-                                      collection: [1, 2, 3].map! { |n| Compositor::Leaf::DslInt.new(view_context, n) })
-          cmp = Compositor::Hash.new(view_context, collection: [string, int, list])
+                                      collection: [1, 2, 3].map! { |n| DslIntCompositor.new(context, n) })
+          cmp = Compositor::Map.new(context, collection: [string, int, list])
           cmp.to_hash.should == {:a => "b", :number => 3, :numbers => [{:number => 1}, {:number => 2}, {:number => 3}]}
         end
       end

data/spec/support/sample_dsl.rb

@@ -1,33 +1,35 @@
-module Compositor
-  class Leaf::DslString < Compositor::Leaf
-    def to_hash
-      {
-          a: "b"
-      }
-    end
-  end
+class DslStringCompositor < Compositor::Leaf
+  attr_accessor :string
 
-  class Leaf::DslInt < Compositor::Leaf
-    attr_accessor :number
+  def to_hash
+    {
+        a: "b"
+    }
+  end
+end
 
-    def initialize(view_context, number, attrs = {})
-      super(view_context, {number: number}.merge!(attrs))
-    end
+class DslIntCompositor < Compositor::Leaf
+  attr_accessor :number
 
-    def to_hash
-      with_root_element do
-        {
-            number: @number
-        }
-      end
-    end
+  def initialize(view_context, number, attrs = {})
+    super(view_context, {number: number}.merge!(attrs))
   end
 
-  class Leaf::DslObject < Compositor::Leaf
-    def to_hash
+  def to_hash
+    with_root_element do
       {
-          a: object
+          number: @number
       }
     end
   end
 end
+
+class DslObjectCompositor < Compositor::Leaf
+  attr_accessor :object
+
+  def to_hash
+    {
+        a: object
+    }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: compositor
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -10,8 +10,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-29 00:00:00.000000000 Z
+date: 2013-05-31 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -83,14 +99,20 @@ files:
 - lib/compositor/base.rb
 - lib/compositor/composite.rb
 - lib/compositor/dsl.rb
-- lib/compositor/hash.rb
 - lib/compositor/leaf.rb
 - lib/compositor/list.rb
+- lib/compositor/literal.rb
+- lib/compositor/map.rb
 - lib/compositor/renderer/base.rb
 - lib/compositor/renderer/iterator.rb
 - lib/compositor/renderer/merged.rb
 - lib/compositor/version.rb
-- spec/compositor/compositor_spec.rb
+- spec/compositor/base_spec.rb
+- spec/compositor/dsl_spec.rb
+- spec/compositor/hash_spec.rb
+- spec/compositor/leaf_spec.rb
+- spec/compositor/list_spec.rb
+- spec/compositor/literal_spec.rb
 - spec/compositor/performance_spec.rb
 - spec/spec_helper.rb
 - spec/support/sample_dsl.rb
@@ -114,14 +136,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Composite design pattern with a convenient DSL for building JSON/Hashes of
   complex objects
 test_files:
-- spec/compositor/compositor_spec.rb
+- spec/compositor/base_spec.rb
+- spec/compositor/dsl_spec.rb
+- spec/compositor/hash_spec.rb
+- spec/compositor/leaf_spec.rb
+- spec/compositor/list_spec.rb
+- spec/compositor/literal_spec.rb
 - spec/compositor/performance_spec.rb
 - spec/spec_helper.rb
 - spec/support/sample_dsl.rb
-has_rdoc: 

data/spec/compositor/compositor_spec.rb

@@ -1,168 +0,0 @@
-require_relative '../spec_helper'
-
-describe Compositor::DSL do
-
-  let(:view_context) { Object.new }
-
-  describe '#create' do
-    it "defines #dsl_string method on the DSL class" do
-      dsl = Compositor::DSL.create(view_context)
-      dsl.should respond_to(:dsl_string)
-    end
-
-    it "allows calling defined methods via a block" do
-      block_ran = false
-      Compositor::DSL.create(view_context) do |dsl|
-        dsl.dsl_string
-        block_ran = true
-      end
-      block_ran.should be_true
-    end
-
-    it "returns last generator called via block" do
-      dsl = Compositor::DSL.create(view_context) do |dsl|
-        dsl.dsl_string
-      end
-
-      {a: "b"}.should == dsl.to_hash
-    end
-
-    it "returns an instance of subclass" do
-      dsl = Compositor::DSL.create(view_context).dsl_string
-      dsl.should be_kind_of(Compositor::Leaf::DslString)
-    end
-  end
-
-  describe '#composite' do
-    it 'returns the generated array with the explicit receiver' do
-      integers = [1, 2, 3]
-      expected = {
-          tests: [
-              {number: 1},
-              {number: 2},
-              {number: 3}
-          ]
-      }
-
-      dsl = Compositor::DSL.create(view_context)
-      dsl.list root: :tests, collection: integers do |item|
-        dsl.dsl_int item
-      end
-
-      dsl.to_hash.should == expected
-    end
-
-    it 'returns the generated hash' do
-      expected = {
-          tests: {
-              num1: {number: 1},
-              num2: {number: 2},
-              num3: {number: 3}
-          }
-      }
-
-      dsl = Compositor::DSL.create(view_context)
-      dsl.hash root: :tests do
-        dsl.dsl_int 1, root: :num1
-        dsl.dsl_int 2, root: :num2
-        dsl.dsl_int 3, root: :num3
-      end
-
-      expected.should == dsl.to_hash
-    end
-
-    it 'returns the generated deeply nested hash' do
-      expected = {
-          tests: {
-              num1: {number: 1},
-              num2: {number: 2},
-              num3: {number: 3},
-              stuff: [
-                  {number: 10},
-                  {number: 11}
-              ]
-          }
-      }
-
-      dsl = Compositor::DSL.create(view_context)
-      dsl.hash root: :tests do
-        dsl.dsl_int 1, root: :num1
-        dsl.dsl_int 2, root: :num2
-        dsl.dsl_int 3, root: :num3
-        dsl.list :root => :stuff do
-          dsl.dsl_int 10
-          dsl.dsl_int 11
-        end
-      end
-
-      expected.should == dsl.to_hash
-    end
-
-    it 'returns the generated deeply nested hash without explicit receiver' do
-      expected = {
-          tests: {
-              num1: {number: 1},
-              num2: {number: 2},
-              num3: {number: 3},
-              stuff: [
-                  {number: 10},
-                  {number: 11}
-              ]
-          }
-      }
-
-      dsl = Compositor::DSL.create(view_context)
-      dsl.hash root: :tests do
-        dsl_int 1, root: :num1
-        dsl_int 2, root: :num2
-        dsl_int 3, root: :num3
-        list :root => :stuff do
-          dsl_int 10
-          dsl_int 11
-        end
-      end
-
-      expected.should == dsl.to_hash
-    end
-
-    it 'returns the generated array with explicit receiver' do
-      integers = [1, 2, 3]
-      expected = {
-          tests: [
-              {number: 1},
-              {number: 2},
-              {number: 3}
-          ]
-      }
-
-      dsl = Compositor::DSL.create(view_context)
-      dsl.list root: :tests, collection: integers do |item|
-        dsl_int item
-      end
-
-      expected.should == dsl.to_hash
-    end
-  end
-
-  describe '#empty' do
-    it 'returns the default type' do
-      dsl = Compositor::DSL.create(view_context) do
-      end
-
-      nil.should == dsl.to_hash
-
-      dsl = Compositor::DSL.create(view_context) do
-        hash collection: [], root: false
-      end
-
-      {}.should == dsl.to_hash
-
-      dsl = Compositor::DSL.create(view_context) do
-        list collection: [], root: false
-      end
-
-      [].should == dsl.to_hash
-
-    end
-  end
-end