bldr 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+.rspec
+Gemfile.lock

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.8.7
+  - 1.9.1
+  - 1.9.2
+  - ree
+  - ruby-head
+  - rbx

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gemspec
+
+gem "rake"
+
+group :test do
+  gem 'autotest'
+  gem "rspec", ">= 2.6.0"
+end

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011 Alex Sharp
+
+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,281 @@
+[![Build Status](http://travis-ci.org/ajsharp/bldr.png)](http://travis-ci.org/ajsharp/bldr)
+
+
+# Bldr
+
+Bldr is a minimalist templating library that provides a simple DSL for generating
+json documents from ruby objects. It currently supports Sinatra out of
+the box -- Rails 3 support is planned for the near future.
+
+If you would like to contribute, pull requests with specs are warmly accepted :)
+
+## Features
+
+* Simple json templating DSL
+* Uses Tilt's built-in rendering and template caching for better
+  performance
+
+## Installation
+
+There are two ways to use Bldr in your Sinatra app, depending on whether
+you are using Sinatra's classic or module application style:
+
+```ruby
+
+# Method 1: Classic style
+
+require 'sinatra/bldr'
+
+get '/hello' do
+  bldr :hello
+end
+
+
+# Method 2: Modular style
+
+require 'sinatra/bldr'
+
+class MyApp < Sinatra::Base
+  register Sinatra::Bldr
+end
+```
+
+## Usage
+
+In your sinatra endpoints/actions, use the `bldr` helper method to
+render templates.
+
+```ruby
+get "/posts" do
+  # ...
+  posts = Post.all
+  bldr :'template.json', {}, {:posts => posts}
+end
+
+# views/template.json.bldr
+collection :posts => posts do
+  attributes :title
+  attribute :comment_count { |post| post.comments.count }
+
+  collection :comments => current_object.comments do
+    attributes :body, :author, :email
+  end
+end
+```
+
+## Examples
+
+### Rendering a simple list of attributes
+
+```ruby
+object :post => post do
+  attributes :title, :body
+end
+```
+
+Output:
+
+```javascript
+{
+  "post": {
+    "title": "my title",
+      "body": "..."
+  }
+}
+```
+
+### Dynamic attributes
+
+```ruby
+object :post => post do
+  attribute :comment_count do |post|
+    post.comments.count
+  end
+end
+```
+
+Output:
+
+```javascript
+{
+  "post": {
+    "comment_count": 1
+  }
+}
+
+```
+
+### Attribute aliases
+
+```ruby
+object :post => post do
+  attributes :title, :body
+
+  object :author => post.author do
+    attribute :surname => :last_name
+  end
+end
+```
+
+Output:
+
+```javascript
+{
+  "post": {
+    "title": "my title",
+    "body": "...",
+    "author": {
+      "surname": "Doe"
+    }
+  }
+}
+```
+
+### Nested objects
+
+```ruby
+object :post => post do
+  attributes :title, :body
+
+  object :author => post.author do
+    attributes :first_name, :last_name, :email
+
+    attribute(:full_name) { |author| "#{author.first_name} #{author.last_name}" }
+  end
+end
+```
+
+Output:
+
+```javascript
+{
+  "post": {
+    "title": "my title",
+    "body": "...",
+    "author": {
+      "first_name": "John",
+      "last_name": "Doe",
+      "email": "john@doe.com",
+      "full_name": "John Doe"
+    }
+  }
+}
+```
+
+### Root-level attributes
+
+```ruby
+get '/redirector' do
+  url = params['redirect_url']
+  bldr :'redirect.json', :locals => {:url => url}
+end
+
+# views/redirect.json.bldr
+object do
+  attribute(:redirect_to) { url }
+end
+```
+
+Output:
+
+```javascript
+{"redirect_to": "http://example.org"}
+```
+
+### Collections
+
+All the examples above can be used inside a collection block. Here we
+assume a Post model which has many Comments. You might use the below
+code to render an action which returns a collection of posts, where
+each post has a collection of comments.
+
+```ruby
+collection :posts => posts do
+  attributes :title
+  attribute :comment_count { |post| post.comments.count }
+
+  # current_object
+  collection :comments => current_object.comments do
+    attributes :body, :author_name, :author_email
+  end
+end
+```
+
+Output:
+
+```javascript
+{
+  "posts": [
+    {
+      "title": "my title",
+        "comment_count": 2,
+        "comments": [
+          {
+            "body": "...",
+            "author_name": "Comment Troll",
+            "email": "troll@trolling.edu"
+          },
+          {
+            "body": "...",
+            "author_name": "Uber Troll",
+            "email": "uber.troll@earthlink.net"
+          }
+        ]
+    }
+  ]
+}
+```
+
+When inside of a collection block, you can use the `current_object`
+method to access the member of the collection currently being iterated
+over. This allows you to do nested collections, as in the example above.
+
+### Templates
+
+It is recommended to name your templates with the content type extension before
+the .bldr extension. For example: `my_template.json.bldr`.
+
+The templates themselves are just plain ruby code. They are evaluated in the context of a
+`Bldr::Node` instance, which provides the bldr DSL. The DSL is comprised
+primarily of 3 simple methods:
+
++ `object` - Creates an object
++ `collection` - Iterates over a collection of objects
++ `attributes` - Add attributes to the current object.
+
+### Local Variables
+
+You may pass local variables from your sinatra actions to bldr templates
+by passing the `bldr` method a `:locals` hash, like so:
+
+```ruby
+get '/posts' do
+  posts = Post.all.recent
+
+  bldr :'posts/index.json', :locals => {:posts => posts}
+end
+```
+
+## Editor Syntax Support
+
+To get proper syntax highlighting in vim, add this line to your .vimrc:
+
+```
+au BufRead,BufNewFile *.bldr set filetype=ruby
+```
+
+## TODO
+
+* Rails 3 support
+* Replace current_object with a block param for collection methods
+* XML support
+
+## Acknowledgements
+
+* [RABL](http://github.com/nesquena/rabl) - Inspiration
+* [Tilt](https://github.com/rtomayko/tilt) - Mega awesome goodness
+
+## Copyright
+
+Copyright (c) 2011 Alex Sharp. See the MIT-LICENSE file for full
+copyright information.

data/Rakefile

@@ -0,0 +1,7 @@
+# require 'bundler'
+# Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bldr.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "bldr/version"
+
+Gem::Specification.new do |s|
+  s.name        = "bldr"
+  s.version     = Bldr::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Alex Sharp"]
+  s.email       = ["ajsharp@gmail.com"]
+  s.homepage    = "https://github.com/ajsharp/bldr"
+  s.summary     = %q{Templating library with a simple, minimalist DSL.}
+  s.description = %q{Provides a simple and intuitive templating DSL for serializing objects to JSON.}
+
+  s.rubyforge_project = "bldr"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'multi_json', '~> 1.0.3'
+
+  s.add_development_dependency 'json_pure'
+  s.add_development_dependency 'sinatra',   '~>1.2.6'
+  s.add_development_dependency 'tilt',      '~>1.3.2'
+  s.add_development_dependency 'yajl-ruby'
+end

data/lib/bldr/engine.rb

@@ -0,0 +1,14 @@
+
+module Bldr
+
+  class Engine
+    attr_reader :template, :options, :result
+
+    def initialize(template, options = {})
+      @template, @options = template, options
+      @result   = {}
+    end
+
+  end
+
+end

data/lib/bldr/node.rb

@@ -0,0 +1,171 @@
+
+module Bldr
+
+  class Node
+
+    attr_reader :current_object, :result, :parent
+
+    # Initialize a new Node instance.
+    #
+    # @example Building a simple node
+    #   node = Node.new do
+    #     Node.new(:person => Person.new("alex")) do
+    #       attributes(:name)
+    #     end
+    #   end
+    #   node.to_json # => {"person": {"name": "alex"}}
+    #
+    #
+    # @param [Object] value an object to serialize.
+    def initialize(value = nil, opts = {}, &block)
+      @current_object = value
+      @parent         = opts[:parent]
+
+      # Storage hash for all descendant nodes
+      @result  = {}
+
+      instance_eval(&block) if block_given?
+    end
+
+    # Merge the local results into the ancestor result hash.
+    #
+    # @return [Hash]
+    def render!
+      result
+    end
+
+    # Return the json-encoded result hash.
+    #
+    # @return [String] the json-encoded result hash
+    def to_json
+      MultiJson.encode(result)
+    end
+
+    # Create and render a node.
+    #
+    # @example A keyed object
+    #   get '/users/:id' do
+    #     user = User.find(params['id'])
+    #
+    #     bldr :'users/show.json', :locals => {:user => user}
+    #   end
+    #
+    #   # views/users/show.json.bldr
+    #   object :user => user do
+    #     attributes :name, :email
+    #
+    #     attribute(:id) { |person| person.id.to_s }
+    #   end
+    #
+    # @example Root-level object with no key
+    #   get '/' do
+    #     url = "http://google.com"
+    #
+    #     bldr :'template.json', :locals => {:url => url}
+    #   end
+    #
+    #   # views/template.json.bldr
+    #   object do
+    #     attributes(:url) { url }
+    #   end
+    #
+    # @param [Hash, Nil] hash a key/value pair indicating the output key name
+    #   and the object to serialize.
+    # @param [Proc] block the code block to evaluate
+    #
+    # @return [String] returns a json-encoded string of itself and all
+    #   descendant nodes.
+    def object(hash = nil, &block)
+      if hash
+        key   = hash.keys.first
+        value = hash.values.first
+      end
+
+      node  = Node.new(value, :parent => self, &block)
+      merge_result!(key, node.render!)
+      node.parent.to_json
+    end
+
+    def collection(items, &block)
+      key   = items.keys.first
+      items = items.values.first
+
+      merge_result!(key, [])
+      items.each do |item|
+        node = Node.new(item, :parent => self, &block)
+        append_result!(key, node.render!)
+      end
+    end
+
+    # Add attributes to the result hash in a variety of ways
+    #
+    # @example Simple list of attributes
+    #   object :person => dude do
+    #     attributes :name, :age
+    #   end
+    #
+    # @example Attribute aliasing
+    #   object :person => dude do
+    #     attributes :surname => :last_name
+    #   end
+    #
+    # @example Dynamic attributes (explicit object context)
+    #   object :person => employee do
+    #     collection :colleagues => employee.colleagues do |colleague|
+    #       attribute :isBoss do |colleague|
+    #         employee.works_with?(colleague) && colleague.admin?
+    #       end
+    #     end
+    #   end
+    #
+    # @example Dynamic attributes (implicit object context)
+    #   object :person => dude do
+    #     collection :colleagues => employee.colleagues do |colleague|
+    #       attribute :rank do
+    #         # method called on colleague
+    #         if admin? && superior_to?(employee)
+    #           "High Up"
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    # @return [Nil]
+    def attributes(*args, &block)
+      if block_given?
+        if args.size > 1
+          raise(ArgumentError, "You may only pass one argument to #attribute when using the block syntax.")
+        end
+
+        merge_result!(args.first, (block.arity == 1) ? block.call(current_object) : current_object.instance_eval(&block))
+        return nil
+      end
+
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          merge_result!(arg.keys.first, current_object.send(arg.values.first))
+        else
+          merge_result!(arg, current_object.send(arg))
+        end
+      end
+      nil
+    end
+    alias :attribute :attributes
+
+    private
+
+    # Merges values into the "local" result hash.
+    def merge_result!(key, val)
+      if key
+        result[key] = val
+      else
+        result.merge!(val)
+      end
+    end
+
+    def append_result!(key, val)
+      result[key] << val
+    end
+
+  end
+end

data/lib/bldr/template.rb

@@ -0,0 +1,28 @@
+require 'tilt'
+
+module Bldr
+
+  class Template < Tilt::Template
+    # attr_reader :engine
+    # self.default_mime_type = 'application/json'
+
+    def initialize_engine
+      require_template_library 'bldr'
+    end
+
+    def self.engine_initialized?
+      defined? ::Bldr
+    end
+
+    def prepare
+      @engine = Bldr::Engine.new(data, options)
+    end
+
+    def precompiled_template(locals)
+      data.to_s
+    end
+
+  end
+
+  Tilt.register 'bldr', Bldr::Template
+end

data/lib/bldr/version.rb

@@ -0,0 +1,4 @@
+
+module Bldr
+  VERSION = '0.1.0'
+end

data/lib/bldr.rb

@@ -0,0 +1,15 @@
+
+$:.unshift(File.dirname(File.expand_path(__FILE__)))
+
+require 'multi_json'
+require 'bldr/engine'
+require 'bldr/template'
+require 'bldr/node'
+
+module Bldr
+  class << self
+    def json_encoder=(encoder)
+      MultiJson.engine = encoder
+    end
+  end
+end

data/lib/sinatra/bldr.rb

@@ -0,0 +1,29 @@
+require 'sinatra/base'
+
+module Sinatra
+
+  module Bldr
+    module Helpers
+
+      # @param [String, Symbol] template the template to render
+      #   Can be a relative file location or a string template.
+      #   The template may also be passed in as the block argument
+      #   to this method, in which case, template argument is nil.
+      #
+      # @param [Hash] opts a hash of options
+      # @option opts [Hash] :locals a hash of local variables to be used in the template
+      # @option
+      def bldr(template, opts = {}, &block)
+        opts[:scope] = ::Bldr::Node.new
+        locals = opts.delete(:locals)
+        render(:bldr, template, opts, locals, &block)
+      end
+    end
+
+    def self.registered(app)
+      app.helpers Helpers
+    end
+  end
+
+  register Bldr
+end

data/spec/fixtures/nested_objects.json.bldr

@@ -0,0 +1,11 @@
+
+object :person => bert do
+  attributes :name, :age
+  attribute :name_age do
+    "#{name} #{age}"
+  end
+
+  object :friend => ernie do
+    attributes :name, :age
+  end
+end

data/spec/fixtures/root_template.json.bldr

@@ -0,0 +1,5 @@
+
+object do
+  attribute(:name) { name }
+  attribute(:age)  { age }
+end

data/spec/functional/tilt_template_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe "evaluating a tilt template" do
+  it "registers with Tilt" do
+    Tilt['test.bldr'].should == Bldr::Template
+  end
+
+  it "renders a template" do
+    alex = Person.new
+    alex.name = 'alex'
+
+    tpl = Bldr::Template.new { "object(:person => alex) { attribute(:name) }" }
+    tpl.render(Bldr::Node.new, :alex => alex).should == jsonify({:person => {:name => 'alex'}})
+  end
+
+  it "works when render two top-level objects" do
+    alex = Person.new('alex')
+    john = Person.new('john')
+
+    tpl = Bldr::Template.new {
+      <<-RUBY
+        object(:person_1 => alex) { attribute(:name) }
+        object(:person_2 => john) { attribute(:name) }
+      RUBY
+    }
+
+    result = tpl.render(Bldr::Node.new, :alex => alex, :john => john)
+    result.should == jsonify({
+      :person_1 => {:name => 'alex'},
+      :person_2 => {:name => 'john'}
+    })
+  end
+end

data/spec/integration/sinatra_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+
+describe "Using Bldr with a sinatra app" do
+  require 'sinatra/bldr'
+
+  class TestApp < Sinatra::Base
+    register Sinatra::Bldr
+
+    set :views, File.expand_path(__FILE__ + '/../..')
+
+    get '/' do
+      alex =  Person.new("alex", 25)
+      tpl = <<-RUBY
+        object(:dude => alex) do
+          attributes :name, :age
+        end
+      RUBY
+
+      status(200)
+      bldr tpl, :locals => {:alex => alex}
+    end
+
+    get '/collections' do
+      alex = Person.new('alex', 25)
+
+      tpl = <<-RUBY
+        object :person => alex do
+          attributes :name, :age
+
+          collection :friends => [Person.new("john", 24)] do
+            attributes :name, :age
+          end
+        end
+      RUBY
+
+      bldr tpl, :locals => {:alex => alex}
+    end
+
+    get '/template' do
+      bert  = Person.new('bert', 25)
+      ernie = Person.new('ernie', 26)
+      bldr :'fixtures/nested_objects.json', :locals => {:bert => bert, :ernie => ernie}
+    end
+
+    get '/root_template' do
+      name = "john doe"
+      age  = 26
+
+      bldr :'fixtures/root_template.json', :locals => {:name => name, :age => age}
+    end
+  end
+
+  it "returns json for a simple single-level template" do
+    request = Rack::MockRequest.new(TestApp)
+    response = request.get '/'
+    response.status.should == 200
+    parse_json(response.body).should == {'dude' => {'name' => 'alex', 'age' => 25}}
+  end
+
+  it "properly serializes templates with collections" do
+    request = Rack::MockRequest.new(TestApp)
+    response = request.get '/collections'
+
+    response.status.should == 200
+    parse_json(response.body).should == {
+      'person'=> {'name' => 'alex', 'age' => 25, 'friends' => [{'name' => 'john', 'age' => 24}]}
+    }
+  end
+
+  it "works with template files" do
+    request = Rack::MockRequest.new(TestApp)
+    response = request.get '/template'
+
+    parse_json(response.body).should == {
+      'person' => {'name' => 'bert', 'age' => 25, 'name_age' => "bert 25",
+        'friend' => {'name' => 'ernie', 'age' => 26}
+      }
+    }
+  end
+
+  it "allows using root-level attributes" do
+    request = Rack::MockRequest.new(TestApp)
+    response = request.get '/root_template'
+
+    parse_json(response.body).should == {'name' => 'john doe', 'age' => 26}
+  end
+end

data/spec/models/comment.rb

@@ -0,0 +1,8 @@
+
+class Comment
+  attr_accessor :body, :name, :email
+
+  def initialize(body = nil, name = nil, email = nil)
+    @body, @name, @email = body, name, email
+  end
+end

data/spec/models/person.rb

@@ -0,0 +1,9 @@
+
+class Person
+
+  attr_accessor :name, :age
+
+  def initialize(name = nil, age = nil)
+    @name, @age = name, age
+  end
+end

data/spec/models/post.rb

@@ -0,0 +1,10 @@
+
+class Post
+  attr_accessor :title, :body, :comments
+
+  def initialize(title = nil, body = nil)
+    @title, @body = title, body
+    @comments = []
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rspec'
+
+require 'yajl'
+require 'tilt'
+
+$:.unshift(File.dirname(File.expand_path(__FILE__)))
+
+require File.join(File.dirname(File.expand_path(__FILE__)), "..", "lib", "bldr")
+
+Dir['spec/models/*'].each { |f| require File.expand_path(f) }
+
+RSpec.configure do |c|
+  def node_wrap(*args, &block)
+    Bldr::Node.new(*args, &block)
+  end
+
+  # Parse some json and return a ruby object
+  def parse_json(str)
+    Yajl::Parser.parse(str)
+  end
+
+  # Jsonify a ruby object
+  def jsonify(hash)
+    Yajl::Encoder.encode(hash)
+  end
+end

data/spec/unit/bldr_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe "the json encoding library" do
+  it "uses yajl by default" do
+    MultiJson.engine.should == MultiJson::Engines::Yajl
+  end
+
+  it "allows changing the json encoder to json pure" do
+    Bldr.json_encoder = :json_pure
+    MultiJson.engine.should == MultiJson::Engines::JsonPure
+  end
+
+  it "allows changing the json encoder to the json gem" do
+    Bldr.json_encoder = :json_gem
+    MultiJson.engine.should == MultiJson::Engines::JsonGem
+  end
+end

data/spec/unit/node_spec.rb

@@ -0,0 +1,275 @@
+require 'spec_helper'
+
+describe "Node#attributes" do
+  def wrap(&block)
+    alex = Person.new('alex').tap { |p| p.age = 25; p }
+    Bldr::Node.new do
+      object(:person => alex, &block)
+    end
+  end
+
+  it "adds attributes of the person to the result hash" do
+    node = wrap { attributes(:name, :age) }
+    node.render!.should == {:person => {:name => 'alex', :age => 25}}
+  end
+
+  it "supports dynamic block attributes with explicit object context" do
+    node = wrap do
+      attribute(:oldness) do |person|
+        "#{person.age} years"
+      end
+    end
+
+    node.render!.should == {:person => {:oldness => "25 years"}}
+  end
+
+  it "supports dynamic block attributes with implicit object context" do
+    node = wrap do
+      attribute(:oldness) do
+        "#{age} years"
+      end
+    end
+
+    node.render!.should == {:person => {:oldness => "25 years"}}
+  end
+
+  it "raises an error when you use the block syntax with more than one attribute" do
+    expect {
+      node_wrap {
+        attributes(:one, :two) do |person|
+          "..."
+        end
+      }
+    }.to raise_error(ArgumentError, "You may only pass one argument to #attribute when using the block syntax.")
+  end
+
+  it "returns nil attributes in the result" do
+    node = node_wrap do
+      object :person => Person.new('alex') do
+        attributes :name, :age
+      end
+    end
+
+    node.render!.should == {:person => {:name => 'alex', :age => nil}}
+  end
+
+end
+
+describe "Node#render!" do
+  it "returns an empty hash when not passed an object" do
+    Bldr::Node.new.render!.should == {}
+  end
+
+  it "a document with a single node with no nesting" do
+    node = node_wrap do
+      object :person => Person.new('alex') do
+        attributes :name
+      end
+    end
+
+    node.render!.should == {:person => {:name => 'alex'}}
+  end
+
+  it "works for multiple top-level objects" do
+    alex, john = Person.new("alex"), Person.new("john")
+
+    node = node_wrap do
+      object(:alex => alex) do
+        attributes :name
+      end
+
+      object(:john => john) do
+        attributes :name
+      end
+    end
+
+    node.render!.should == {:alex => {:name => 'alex'}, :john => {:name => 'john'}}
+  end
+
+  it "recursively renders nested objects" do
+    node = node_wrap do
+      object :alex => Person.new("alex") do
+        attributes :name
+
+        object :friend => Person.new("john") do
+          attributes :name
+        end
+      end
+    end
+
+    node.render!.should == {
+      :alex => {
+        :name => 'alex',
+        :friend => {:name => 'john'}
+      }
+    }
+  end
+
+  describe "#attributes syntax" do
+    it "allows a hash to be sent where the keys are the result keys" do
+      alex = Person.new("alex").tap do |p|
+        p.age = 25
+        p
+      end
+
+      node = node_wrap do
+        object(:person => alex) do
+          attributes({:surname => :name}, :age)
+        end
+      end
+
+      node.render!.should == {:person => {:surname => 'alex', :age => 25}}
+    end
+  end
+end
+
+describe "Node#object" do
+  it "evaluates the block and returns json" do
+    node = Bldr::Node.new
+    result = node.object(:dude => Person.new("alex")) do
+      attributes :name
+
+      object(:bro => Person.new("john")) do
+        attributes :name
+      end
+    end
+
+    result.should == jsonify({
+      :dude => {:name => 'alex', :bro => {:name => 'john'}}
+    })
+  end
+end
+
+describe "Node#to_json" do
+  it "recursively returns the result json" do
+    node = node_wrap do
+      object :person => Person.new("alex") do
+        attributes :name
+
+        object :friend => Person.new("pete", 30) do
+          attributes :name, :age
+        end
+      end
+    end
+
+    node.to_json.should == jsonify({
+      :person => {
+        :name => 'alex',
+        :friend => {:name => 'pete', :age => 30}
+      }
+    })
+  end
+
+  it "returns null values for nil attributes" do
+    node = node_wrap do
+      object :person => Person.new('alex') do
+        attributes :name, :age
+      end
+    end
+
+    parse_json(node.to_json)['person'].should have_key('age')
+    parse_json(node.to_json)['person']['age'].should be_nil
+  end
+end
+
+describe "Node#collection" do
+  it "iterates through the collection and renders them as nodes" do
+    node = node_wrap do
+      object :person => Person.new('alex', 26) do
+        attributes :name, :age
+
+        collection :friends => [Person.new('john', 24), Person.new('jeff', 25)] do
+          attributes :name, :age
+        end
+      end
+    end
+
+    node.render!.should == {
+      :person => {
+        :name => 'alex', :age => 26,
+        :friends => [{:name => 'john', :age => 24}, {:name => 'jeff', :age => 25}]
+      }
+    }
+  end
+
+  it "renders properly when a collection is the root node" do
+    nodes = node_wrap do
+      collection :people => [Person.new('bert'), Person.new('ernie')] do
+        attributes :name
+      end
+    end
+
+    nodes.render!.should == {:people => [{:name => 'bert'}, {:name => 'ernie'}]}
+  end
+
+  it "renders nested collections properly" do
+    post = Post.new("my post")
+    post.comments << Comment.new('my comment')
+
+    nodes = node_wrap do
+      collection :posts => [post] do
+        attributes :title
+        attribute(:comment_count) { |post| post.comments.count }
+
+        collection :comments => current_object.comments do
+          attributes :body
+        end
+      end
+    end
+
+    nodes.render!.should == {
+      :posts => [
+        {:title => 'my post', :comment_count => 1, :comments => [{:body => 'my comment'}]}
+      ]
+    }
+  end
+
+  it "renders nested collections with dynamic property values correctly" do
+    post1 = Post.new("post 1")
+    post2 = Post.new("post 2")
+    post1.comments << Comment.new('post 1 comment')
+    post2.comments << Comment.new('post 2 first comment')
+    post2.comments << Comment.new('post 2 second comment')
+
+    nodes = node_wrap do
+      collection :posts => [post1, post2] do
+        attributes :title
+        attribute(:comment_count) { |post| post.comments.count }
+
+        collection :comments => current_object.comments do
+          attributes :body
+        end
+      end
+    end
+
+    nodes.render!.should == {
+      :posts => [
+        {
+          :title => 'post 1',
+          :comment_count => 1,
+          :comments => [{:body => 'post 1 comment'}]
+        },
+        {
+          :title => 'post 2',
+          :comment_count => 2,
+          :comments => [{:body => 'post 2 first comment'}, {:body => 'post 2 second comment'}]
+        }
+      ]
+    }
+  end
+
+  it "allows root level attributes using local variables" do
+    node = node_wrap do
+      name = "john doe"
+      age  = 25
+
+      object do
+        attribute(:name) { name }
+        attribute(:age) { age }
+      end
+    end
+
+    node.render!.should == {:name => 'john doe', :age => 25}
+  end
+
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification 
+name: bldr
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Alex Sharp
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-04 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: multi_json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json_pure
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.2.6
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: tilt
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.3.2
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Provides a simple and intuitive templating DSL for serializing objects to JSON.
+email: 
+- ajsharp@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- .travis.yml
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bldr.gemspec
+- lib/bldr.rb
+- lib/bldr/engine.rb
+- lib/bldr/node.rb
+- lib/bldr/template.rb
+- lib/bldr/version.rb
+- lib/sinatra/bldr.rb
+- spec/fixtures/nested_objects.json.bldr
+- spec/fixtures/root_template.json.bldr
+- spec/functional/tilt_template_spec.rb
+- spec/integration/sinatra_spec.rb
+- spec/models/comment.rb
+- spec/models/person.rb
+- spec/models/post.rb
+- spec/spec_helper.rb
+- spec/unit/bldr_spec.rb
+- spec/unit/node_spec.rb
+has_rdoc: true
+homepage: https://github.com/ajsharp/bldr
+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: bldr
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Templating library with a simple, minimalist DSL.
+test_files: 
+- spec/fixtures/nested_objects.json.bldr
+- spec/fixtures/root_template.json.bldr
+- spec/functional/tilt_template_spec.rb
+- spec/integration/sinatra_spec.rb
+- spec/models/comment.rb
+- spec/models/person.rb
+- spec/models/post.rb
+- spec/spec_helper.rb
+- spec/unit/bldr_spec.rb
+- spec/unit/node_spec.rb