compositor 0.1.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.idea
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.pairs

@@ -0,0 +1,12 @@
+pairs:
+  ag: Atasay Gokkaya; atasay
+  km: Kaan Meralan; kaan
+  kg: Konstantin Gredeskoul; kig
+  ph: Paul Henry; paul
+  sf: Sean Flannagan; sean
+  es: Eric Saxby; sax
+  cc: Cihan Cimen; cihan
+  sc: Server Cimen; server
+email:
+  prefix: pair
+  domain: wanelo.com

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+script: "bundle exec rspec"
+notifications:
+  email: false

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in spanx.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+#^syntax detection
+
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^compositor\.gemspec}) { "spec"}
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Wanelo, Inc
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,111 @@
+Compositor
+=====
+
+[![Build status](https://secure.travis-ci.org/wanelo/compositor.png)](http://travis-ci.org/wanelo/compositor)
+
+Composite pattern with a neat DSL for constructing trees of objects in order to render them as a Hash, and subsequently
+JSON.  Used by Wanelo to generate all JSON API responses by compositing multiple objects together, converting to
+a hash and then JSON.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'compositor'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install compositor
+
+## 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:
+
+```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
+  end
+end
+```
+
+This small class automatically registers "user" DSL method, which receives a user object and any other
+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.
+
+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.
+
+```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|
+         product p
+       end
+     end
+   end
+
+   puts composite.to_hash # =>
+
+   {
+      :store => {
+         id: 12354,
+         name: "amazon.com",
+         url: "http://www.amazon.com",
+         ..
+      },
+      :user => {
+         id: 1234,
+         username: "kigster",
+         location: "San Francisco",
+         bio: "",
+         url: ""
+      },
+      :products => {
+           [ id: 1234, :name => "Awesome Product", ... ],
+           [ id: 4325, :name => "Another Awesome Product", ... ]
+      }
+   }
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Maintainers
+
+Konstantin Gredeskoul (@kigster) and Paul Henry (@letuboy)
+
+(c) 2013, All rights reserved, distributed under MIT license.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/compositor.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/compositor/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Konstantin Gredeskoul","Paul Henry"]
+  gem.email         = %w(kigster@gmail.com  paul@wanelo.com)
+  gem.description   = %q{Composite design pattern with a convenient DSL for building JSON/Hashes of complex objects}
+  gem.summary       = %q{Composite design pattern with a convenient DSL for building JSON/Hashes of complex objects}
+  gem.homepage      = "https://github.com/wanelo/compositor"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "compositor"
+  gem.require_paths = %w(lib)
+  gem.version       = Compositor::VERSION
+
+  gem.add_development_dependency 'rspec'
+
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'rb-fsevent'
+end

data/lib/compositor.rb

@@ -0,0 +1,26 @@
+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
+
+    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+  end
+
+  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
+
+require_relative 'compositor/base'
+require_relative 'compositor/renderer/base'

data/lib/compositor/base.rb

@@ -0,0 +1,52 @@
+module Compositor
+  class Base
+    attr_reader :attrs
+    attr_accessor :root, :view_context
+
+    def initialize(view_context, attrs = {})
+      @attrs = attrs
+      self.view_context = view_context
+      attrs.each_pair do |key, value|
+        self.send("#{key}=", value)
+      end
+    end
+
+    def to_hash
+      raise NotImplementedError.new("Abstract method, should be implemented by subclasses")
+    end
+
+    def with_root_element
+      include_root? ? {root => yield} : yield
+    end
+
+    def to_h
+      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
+
+    def include_root?
+      self.root ? true : false
+    end
+
+    def root_class_name
+      self.class.root_class_name(self.class)
+    end
+
+    def self.root_class_name(klazz)
+      klazz.name.gsub(/.*::/, '').underscore
+    end
+  end
+end
+
+require_relative 'leaf'
+require_relative 'composite'
+require_relative 'dsl'
+require_relative 'list'
+require_relative 'hash'

data/lib/compositor/composite.rb

@@ -0,0 +1,53 @@
+module Compositor
+  class Composite < Compositor::Base
+    attr_accessor :collection, :renderer
+
+    def initialize(view_context, *args)
+      super
+      self.collection ||= []
+    end
+
+    def to_hash
+      with_root_element do
+        renderer.new(self, collection).render
+      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
+        end
+      end
+    end
+  end
+end

data/lib/compositor/dsl.rb

@@ -0,0 +1,35 @@
+module Compositor
+  class DSL
+    attr_reader :view_context
+    attr_accessor :result, :generator
+
+    def initialize(view_context)
+      @view_context = view_context
+    end
+
+    def self.create(view_context, &block)
+      dsl = new(view_context)
+      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
+    end
+
+    def to_hash
+      if generator
+        generator.to_hash
+      else
+        nil
+      end
+    end
+  end
+end
+

data/lib/compositor/hash.rb

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

data/lib/compositor/leaf.rb

@@ -0,0 +1,43 @@
+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)
+        super
+      elsif @root
+        root_class_name.to_sym
+      else
+        nil
+      end
+    end
+
+    def composite?
+      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
+      end
+    end
+  end
+end

data/lib/compositor/list.rb

@@ -0,0 +1,7 @@
+module Compositor
+  class List < Compositor::Composite
+    def renderer
+      @renderer ||= Compositor::Renderer::Iterator
+    end
+  end
+end

data/lib/compositor/renderer/base.rb

@@ -0,0 +1,19 @@
+module Compositor
+  module Renderer
+    class Base
+      attr_reader :composite, :collection
+
+      def initialize(composite, collection)
+        @composite = composite
+        @collection = collection
+      end
+
+      def render
+        raise NoMethodError.new "Define render() method in subclasses!"
+      end
+    end
+  end
+end
+
+require_relative 'iterator'
+require_relative 'merged'

data/lib/compositor/renderer/iterator.rb

@@ -0,0 +1,9 @@
+module Compositor
+  module Renderer
+    class Iterator < Base
+      def render
+        collection.inject([]) { |memo, item| memo << item.to_hash; memo }
+      end
+    end
+  end
+end

data/lib/compositor/renderer/merged.rb

@@ -0,0 +1,13 @@
+module Compositor
+  module Renderer
+    class Merged < Base
+      def render
+        return {} if collection.nil? or collection.size == 0
+        return collection.first.to_hash if collection.length == 1
+        collection.inject({}) do |result, hash|
+          result.merge!(hash.to_hash)
+        end
+      end
+    end
+  end
+end

data/lib/compositor/version.rb

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

data/spec/compositor/compositor_spec.rb

@@ -0,0 +1,168 @@
+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

data/spec/compositor/performance_spec.rb

@@ -0,0 +1,52 @@
+require_relative '../spec_helper'
+
+describe 'Performance' do
+
+  let(:view_context) { Object.new }
+  let(:permitted_dsl_performance_penalty) { 60 } # 60% slower is allowed, any slower is not.)
+
+  describe 'generating DSL' do
+    before do
+      require 'benchmark'
+      @timing = { }
+    end
+
+    it "is no more than 60% slower than non-DSL" do
+      dsl = nil
+      output = Benchmark.measure do
+        10000.times do
+          dsl = Compositor::DSL.create(view_context) do |dsl|
+            hash do
+              dsl_string "hello"
+              dsl_int 3
+              list collection: [1, 2, 3], root: :numbers do |number|
+                dsl_int number
+              end
+            end
+          end
+          dsl.to_hash.should == {:a => "b", :number => 3, :numbers => [{:number => 1}, {:number => 2}, {:number => 3}]}
+        end
+      end
+
+      @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,
+                                      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])
+          cmp.to_hash.should == {:a => "b", :number => 3, :numbers => [{:number => 1}, {:number => 2}, {:number => 3}]}
+        end
+      end
+
+      @timing[:nodsl] = output.to_s.to_f
+
+      difference = (100 * (@timing[:dsl] - @timing[:nodsl]) / @timing[:nodsl])
+      difference.should be < permitted_dsl_performance_penalty, "DSL generation was more than #{permitted_dsl_performance_penalty}% slower than non-DSL"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+require 'rubygems'
+require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
+require 'compositor'
+
+Dir['spec/support/**/*.rb'].each { |filename| require_relative "../#{filename}" }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end

data/spec/support/sample_dsl.rb

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

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: compositor
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Konstantin Gredeskoul
+- Paul Henry
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Composite design pattern with a convenient DSL for building JSON/Hashes
+  of complex objects
+email:
+- kigster@gmail.com
+- paul@wanelo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .pairs
+- .rspec
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- compositor.gemspec
+- lib/compositor.rb
+- 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/renderer/base.rb
+- lib/compositor/renderer/iterator.rb
+- lib/compositor/renderer/merged.rb
+- lib/compositor/version.rb
+- spec/compositor/compositor_spec.rb
+- spec/compositor/performance_spec.rb
+- spec/spec_helper.rb
+- spec/support/sample_dsl.rb
+homepage: https://github.com/wanelo/compositor
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+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/performance_spec.rb
+- spec/spec_helper.rb
+- spec/support/sample_dsl.rb
+has_rdoc: