bldr 0.6.0 → 0.7.0

data/.travis.yml

@@ -1,5 +1,4 @@
 rvm:
   - 1.9.3
-  - ree
   - ruby-head
-  - rbx
+  - rbx-19mode

data/Gemfile

@@ -6,4 +6,5 @@ gem "rake"
 
 group :test do
   gem "rspec", ">= 2.6.0"
+  gem 'debugger', :platform => :mri_19
 end

data/HISTORY.md

@@ -1,3 +1,13 @@
+## 0.7.0 (2013-xx-xx)
+* Support for inherited instance variables
+* Breaking change: Node#attribute block syntax no longer inherits
+  context from current_object. See 941608e7 for more
+* Breaking change: Drop ruby 1.8 support
+
+## 0.6.1 (2013-02-18) -- yanked
+* Feature: Add the ability to access instance variables set in sinatra
+  actions in bldr templates.
+
 ## 0.6.0 (2012-xx-xx)
 * Feature: Add the ability to pass-through objects directly to `object` and
   `collection` DSL methods
@@ -21,4 +31,4 @@
 * Add new `attribute` inferred object syntax (@ihunter)
 
 ## 0.1.2 (2011-09-08)
-* Return an empty collection when a nil value is passed to `collection` method
+* Return an empty collection when a nil value is passed to `collection` method

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2012 Alex Sharp
+Copyright (c) 2011-2013 Alex Sharp
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,4 +1,4 @@
-[![Build Status](http://travis-ci.org/ajsharp/bldr.png)](http://travis-ci.org/ajsharp/bldr)
+[![Build Status](https://travis-ci.org/ajsharp/bldr.png)](https://travis-ci.org/ajsharp/bldr)
 
 
 # Bldr
@@ -52,6 +52,75 @@ end
 
 See the [Documentation & Examples](https://github.com/ajsharp/bldr/wiki/Documentation-&-Examples) page on the wiki.
 
+## Deprecations & Breaking Changes
+
+### 0.7.0: current_object deprecation
+
+The use of `current_object` is now deprecated. Instead of referencing `current_object` in bldr templates
+use block variables in `object` and `collection` methods:
+
+```ruby
+# OLD (deprecated)
+collection :people => people do
+  attribute(:name) { current_object.name }
+end
+
+# NEW
+collection :people => people do |person|
+  attribute(:name) { person.name }
+end
+```
+
+Make use of block variables the same way for the `object` method:
+
+```ruby
+# OLD (deprecated)
+object :person => person do
+  attributes :name, :age
+
+  person = current_object
+  object :address => person.address do
+    # current_object here would be assigned to person.address
+    attribute(:zip) { current_object.zip_code }
+    attribute(:address_title) { person.display_name }
+  end
+end
+
+# NEW
+object :person => person do |person|
+  attributes :name, :age
+
+  object :adress => person.address do |address|
+    attribute(:zip) { address.zip_code }
+    attribute(:address_title) { person.display_name }
+  end
+end
+```
+
+### 0.7.0: attribute method breaking change
+
+One of the forms of the `attribute` method has changed in the 0.7.0 release.
+Previously, using the dynamic block form of `attribute`, if you did not pass
+in a block variable, the block would be eval'd in context of the `current_object`.
+This behavior fails the "principle of least surprise" test.
+
+0.7.0 changes this behavior by simply executing the block in context of `Bldr::Node`, which provides
+access to instance variables and locals available in that context.
+
+```ruby
+# OLD
+object :person => person do
+  attribute(:name) { display_name } # equivalent to doing attribute(:name) { |person| person.display_name }
+end
+
+# NEW
+object :person => @person do
+  attribute(:name) { @person.display_name }
+end
+```
+
+See [941608e](https://github.com/ajsharp/bldr/commit/d0bfbd8) and [d0bfbd8](https://github.com/ajsharp/bldr/commit/d0bfbd8) for more info.
+
 ## Editor Syntax Support
 
 To get proper syntax highlighting in vim, add this line to your .vimrc:
@@ -75,8 +144,9 @@ au BufRead,BufNewFile *.bldr set filetype=ruby
 
 * Ian Hunter (@ihunter)
 * Justin Smestad (@jsmestad)
+* Adam LaFave (@lafave)
 
 ## Copyright
 
-Copyright (c) 2011-2012 Alex Sharp. See the MIT-LICENSE file for full
+Copyright (c) 2011-2013 Alex Sharp. See the MIT-LICENSE file for full
 copyright information.

data/bldr.gemspec

@@ -22,8 +22,8 @@ Gem::Specification.new do |s|
   s.add_dependency 'multi_json'
 
   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 'sinatra'
+  s.add_development_dependency 'tilt'
   s.add_development_dependency 'yajl-ruby', '>= 1.0'
-  s.add_development_dependency 'actionpack', '~> 3.0.7'
+  s.add_development_dependency 'actionpack'
 end

data/lib/bldr/node.rb

@@ -3,6 +3,8 @@ module Bldr
 
   class Node
 
+    PROTECTED_IVARS = [:@current_object, :@result, :@parent, :@opts, :@views, :@locals]
+
     attr_reader :current_object, :result, :parent, :opts, :views, :locals
 
     # Initialize a new Node instance.
@@ -17,6 +19,8 @@ module Bldr
     #
     #
     # @param [Object] value an object to serialize.
+    # @param [Hash] opts
+    # @option [Object] opts :parent used to copy instance variables into self
     def initialize(value = nil, opts = {}, &block)
       @current_object = value
       @opts           = opts
@@ -24,11 +28,24 @@ module Bldr
       @views          = opts[:views]
       @locals         = opts[:locals]
       # Storage hash for all descendant nodes
-      @result  = {}
+      @result         = {}
+
+      copy_instance_variables_from(opts[:parent]) if opts[:parent]
 
-      instance_eval(&block) if block_given?
+      if block_given?
+        if value && block.arity > 0
+          instance_exec(value, &block)
+        else
+          instance_eval(&block)
+        end
+      end
     end
-    
+
+    def current_object
+      warn "[DEPRECATION] `current_object` is deprecated. Please use object or collection block varibles instead."
+      @current_object
+    end
+
     # Create and render a node.
     #
     # @example A keyed object
@@ -182,15 +199,15 @@ module Bldr
     #
     # @return [Nil]
     def attributes(*args, &block)
-      if current_object.nil?
+      if @current_object.nil?
         raise(ArgumentError, "No current_object to apply #attributes to.")
       end
 
       args.each do |arg|
         if arg.is_a?(Hash)
-          merge_result!(arg.keys.first, current_object.send(arg.values.first))
+          merge_result!(arg.keys.first, @current_object.send(arg.values.first))
         else
-          merge_result!(arg, current_object.send(arg))
+          merge_result!(arg, @current_object.send(arg))
         end
       end
       self
@@ -199,16 +216,20 @@ module Bldr
     def attribute(*args,&block)
       if block_given?
         raise(ArgumentError, "You may only pass one argument to #attribute when using the block syntax.") if args.size > 1
-        raise(ArgumentError, "You cannot use a block of arity > 0 if current_object is not present.") if block.arity > 0 and current_object.nil?
-        merge_result!(args.first, (block.arity == 1) ? block.call(current_object) : current_object.instance_eval(&block))
+        raise(ArgumentError, "You cannot use a block of arity > 0 if current_object is not present.") if block.arity > 0 and @current_object.nil?
+        if block.arity > 0
+          merge_result! args.first, block.call(@current_object)
+        else
+          merge_result! args.first, block.call
+        end
       else
         case args.size
         when 1 # inferred object
-          raise(ArgumentError, "#attribute can't be used when there is no current_object.") if current_object.nil?
+          raise(ArgumentError, "#attribute can't be used when there is no current_object.") if @current_object.nil?
           if args[0].is_a?(Hash)
-            merge_result!(args[0].keys.first, current_object.send(args[0].values.first))
+            merge_result!(args[0].keys.first, @current_object.send(args[0].values.first))
           else
-            merge_result!(args[0], current_object.send(args[0]))
+            merge_result!(args[0], @current_object.send(args[0]))
           end
         when 2 # static property
           merge_result!(args[0], args[1])
@@ -244,6 +265,17 @@ module Bldr
 
     private
 
+    # Retrieves all instance variables from an object and sets them in the
+    #   current scope.
+    #
+    # @param [Object] object The object to copy instance variables from.
+    def copy_instance_variables_from(object)
+      ivar_names = (object.instance_variables - PROTECTED_IVARS).map(&:to_s)
+      ivar_names.map do |name|
+        instance_variable_set(name, object.instance_variable_get(name))
+      end
+    end
+
     # Determines if an object was passed in with a key pointing to it, or if
     # it was passed in as the "root" of the current object. Essentially, this
     # checks if `obj` quacks like a hash.

data/lib/bldr/template.rb

@@ -2,6 +2,7 @@ require 'tilt'
 
 module Bldr
 
+  # This class is required for Tilt compatibility
   class Template < Tilt::Template
 
     self.default_mime_type = 'application/json'
@@ -14,6 +15,8 @@ module Bldr
       defined? ::Bldr
     end
 
+    # Called at the end of Tilt::Template#initialize.
+    # Use this method to access or mutate any state available to Tilt::Template
     def prepare
       # We get NotImplementedError by Tilt when we don't have this method
     end

data/lib/bldr/version.rb

@@ -1,4 +1,4 @@
 
 module Bldr
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/lib/sinatra/bldr.rb

@@ -4,7 +4,6 @@ module Sinatra
 
   module Bldr
     module Helpers
-
       # Wrapper for Tilt's `render` method
       #
       # We use this to properly set the scope the template gets rendered
@@ -24,10 +23,13 @@ module Sinatra
       # @param [Hash] opts a hash of options
       # @option opts [Hash] :locals a hash of local variables to be used in the template
       def bldr(template, opts = {}, &block)
+        opts[:parent] = self
         opts[:scope] = ::Bldr::Node.new(nil, opts.merge(:views => (settings.views || "./views")))
-        locals       = opts.delete(:locals)
-        MultiJson.encode render(:bldr, template, opts, locals, &block).result    
+
+        locals = opts.delete(:locals) || {}
+
         # @todo add support for alternate formats, like plist
+        MultiJson.encode render(:bldr, template, opts, locals, &block).result
       end
     end
 

data/spec/fixtures/ivar.bldr

@@ -0,0 +1,3 @@
+object :person => @person do
+  attributes :name, :age
+end

data/spec/fixtures/nested_ivars.bldr

@@ -0,0 +1,5 @@
+object nil do
+  object :person => @person do
+    attributes :name, :age
+  end
+end

data/spec/fixtures/nested_objects.json.bldr

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

data/spec/functional/tilt_template_spec.rb

@@ -1,75 +1,172 @@
 require 'spec_helper'
 
-describe "evaluating a tilt template" do
-  it "registers with Tilt" do
-    Tilt['test.bldr'].should == Bldr::Template
+module Bldr
+  describe 'local variable access' do
+    it 'provides access to locals in nested object blocks' do
+      Template.new do
+          <<-RUBY
+            object :person => person do
+              attribute(:name) { person.name }
+              object :address => Object.new do |address|
+                attribute(:display_name) { person.name }
+              end
+            end
+          RUBY
+      end.render(Node.new(nil), {person: Person.new('alex')})
+      .result
+      .should == {:person => {:name => 'alex', :address => {:display_name => 'alex'}}}
+    end
   end
 
-  it "renders a template" do
-    alex = Person.new
-    alex.name = 'alex'
+  describe "instance variables" do
+    let(:ctx) { Object.new }
+
+    describe "collection blocks" do
+      it 'has access to instance variables' do
+        ctx.instance_variable_set(:@person, Person.new("John Denver"))
+
+        Template.new do
+          <<-RUBY
+            collection :artists => [@person] do
+              attribute(:name) { @person.name }
+            end
+          RUBY
+        end.render(Node.new(nil, :parent => ctx))
+        .result
+        .should == {:artists => [{:name => 'John Denver'}]}
+      end
+    end
+
+    it 'has access to instance variables in included template partials' do
+      ctx.instance_variable_set(:@person, Person.new('john denver'))
+
+      Template.new {
+        <<-RUBY
+         template('spec/fixtures/ivar.bldr')
+        RUBY
+      }.render(Node.new(nil, :parent => ctx))
+      .result
+      .should == {:person => {:name => 'john denver', :age => nil}}
+    end
 
-    tpl = Bldr::Template.new { "object(:person => alex) { attribute(:name) }" }
-    tpl.render(Bldr::Node.new, :alex => alex).result.should == {:person => {:name => 'alex'}}
+    it 'has access to ivars in attribute blocks with no arity' do
+      ctx.instance_variable_set(:@person, Person.new('john denver'))
+
+      Template.new {
+        <<-RUBY
+         object :person do
+           attribute(:name) { @person.name }
+         end
+        RUBY
+      }.render(Node.new(nil, :parent => ctx))
+      .result
+      .should == {:person => {:name => 'john denver'}}
+    end
+
+    it 'has access to ivars in attribute blocks with arity of 1' do
+      ctx.instance_variable_set(:@denver, Person.new('john denver'))
+      ctx.instance_variable_set(:@rich, Person.new('charlie rich'))
+      Template.new {
+        <<-RUBY
+         object :person => @denver do
+           attribute(:name) { |p| @rich.name }
+         end
+        RUBY
+      }.render(Node.new(nil, :parent => ctx))
+      .result
+      .should == {:person => {:name => 'charlie rich'}}
+    end
+
+    it 'has access to ivars in nested object blocks' do
+      ctx.instance_variable_set(:@batman, Person.new('batman'))
+      ctx.instance_variable_set(:@bane, Person.new('bane'))
+      Template.new {
+        <<-RUBY
+         object :hero => @batman do
+           attribute(:name) { @batman.name }
+           object :nemesis do
+             attribute(:name) { @bane.name }
+             attribute(:nemesis_name) { @batman.name }
+           end
+         end
+        RUBY
+      }.render(Node.new(nil, :parent => ctx))
+      .result
+      .should == {hero: {name: 'batman', nemesis: {name: 'bane', nemesis_name: 'batman'}}}
+    end
   end
 
-  it "allows attribute to be used at the root-level" do
-    tpl = Bldr::Template.new {
+
+  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).result.should == {:person => {:name => 'alex'}}
+    end
+
+    it "allows attribute to be used at the root-level" do
+      tpl = Bldr::Template.new {
       <<-RUBY
         attribute(:foo) { "bar" }
       RUBY
-    }
-    tpl.render(Bldr::Node.new(nil)).result.should == {:foo => 'bar'}
-  end
+      }
+      tpl.render(Bldr::Node.new(nil)).result.should == {:foo => 'bar'}
+    end
 
-  it "works when render two top-level objects" do
-    alex = Person.new('alex')
-    john = Person.new('john')
+    it "works when render two top-level objects" do
+      alex = Person.new('alex')
+      john = Person.new('john')
 
-    tpl = Bldr::Template.new {
+      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
-    result.should == {
-      :person_1 => {:name => 'alex'},
-      :person_2 => {:name => 'john'}
-    }
-  end
+      result = tpl.render(Bldr::Node.new, :alex => alex, :john => john).result
+      result.should == {
+                        :person_1 => {:name => 'alex'},
+                        :person_2 => {:name => 'john'}
+                       }
+    end
 
-  it "renders nil -> null correctly" do
-    alex = Person.new('alex')
-    tpl = Bldr::Template.new {
+    it "renders nil -> null correctly" do
+      alex = Person.new('alex')
+      tpl = Bldr::Template.new {
       <<-RUBY
         object(:person_1 => alex) { attributes(:age) }
       RUBY
-    }
-    result = tpl.render(Bldr::Node.new, :alex => alex).result
-    result.should == {:person_1 => {:age => nil}}
-  end
+      }
+      result = tpl.render(Bldr::Node.new, :alex => alex).result
+      result.should == {:person_1 => {:age => nil}}
+    end
 
-  describe "root Object nodes" do
+    describe "root Object nodes" do
 
-    let(:alex) { Person.new('alex', 25) }
-    let(:ian) { Person.new('ian', 32) }
+      let(:alex) { Person.new('alex', 25) }
+      let(:ian) { Person.new('ian', 32) }
 
-    it "returns json for a root object" do
-      tpl = Bldr::Template.new {
+      it "returns json for a root object" do
+        tpl = Bldr::Template.new {
         <<-RUBY
           object :person => alex do
             attributes :name, :age
           end
         RUBY
-      }
-      result = tpl.render(Bldr::Node.new, :alex => alex, :ian => ian).result
-      result.should == {:person => {:name => 'alex', :age => 25}}
-    end
+        }
+        result = tpl.render(Bldr::Node.new, :alex => alex, :ian => ian).result
+        result.should == {:person => {:name => 'alex', :age => 25}}
+      end
 
-    it "returns json for root object templates with nested collections" do
-      tpl = Bldr::Template.new {
+      it "returns json for root object templates with nested collections" do
+        tpl = Bldr::Template.new {
         <<-RUBY
           object :person => alex do
             attributes :name, :age
@@ -79,78 +176,79 @@ describe "evaluating a tilt template" do
             end
           end
         RUBY
-      }
-      result = tpl.render(Bldr::Node.new, :alex => alex, :friends => [ian]).result
-      result.should == {
-        :person=> {:name => 'alex', :age => 25, :friends => [{:name => 'ian', :age => 32}]}
-      }
-    end
-
-    it "renders nil -> null correctly" do
-      alex = Person.new('alex')
-      tpl = Bldr::Template.new {
+        }
+        result = tpl.render(Bldr::Node.new, :alex => alex, :friends => [ian]).result
+        result.should == {
+                          :person=> {:name => 'alex', :age => 25, :friends => [{:name => 'ian', :age => 32}]}
+                         }
+      end
+
+      it "renders nil -> null correctly" do
+        alex = Person.new('alex')
+        tpl = Bldr::Template.new {
         <<-RUBY
           object :person_1 => alex do
             attributes(:age)
           end
         RUBY
-      }
-      result = tpl.render(Bldr::Node.new, :alex => alex).result
-      result.should == {:person_1 => {:age => nil}}
-    end
+        }
+        result = tpl.render(Bldr::Node.new, :alex => alex).result
+        result.should == {:person_1 => {:age => nil}}
+      end
 
-  end
+    end
 
-  describe "root Collection nodes" do
+    describe "root Collection nodes" do
 
-    let(:alex) { Person.new('alex', 25, [Person.new('bo',33)]) }
-    let(:ian) { Person.new('ian', 32, [Person.new('eric',34)]) }
+      let(:alex) { Person.new('alex', 25, [Person.new('bo',33)]) }
+      let(:ian) { Person.new('ian', 32, [Person.new('eric',34)]) }
 
-    it "returns json for a root collection template" do
-      tpl = Bldr::Template.new {
+      it "returns json for a root collection template" do
+        tpl = Bldr::Template.new {
         <<-RUBY
           collection :people => people do
             attributes :name, :age
           end
         RUBY
-      }
-      result = tpl.render(Bldr::Node.new, :people => [alex,ian]).result
-      result.should == {
-        :people => [{:name => 'alex', :age => 25}, {:name => 'ian', :age => 32}]
-      }
-    end
-
-    it "returns json for a root collection with embedded collection template" do
-      tpl = Bldr::Template.new {
+        }
+        result = tpl.render(Bldr::Node.new, :people => [alex,ian]).result
+        result.should == {
+                          :people => [{:name => 'alex', :age => 25}, {:name => 'ian', :age => 32}]
+                         }
+      end
+
+      it "returns json for a root collection with embedded collection template" do
+        tpl = Bldr::Template.new {
         <<-RUBY
-          collection :people => people do
+          collection :people => people do |person|
             attributes :name, :age
-            collection :friends => current_object.friends do
+            collection :friends => person.friends do
               attributes :name, :age
             end
           end
         RUBY
-      }
-      result = tpl.render(Bldr::Node.new, :people => [alex,ian]).result
-      result.should == {
-        :people=> [{
-          :name => 'alex',
-          :age => 25,
-          :friends => [{:name => 'bo', :age => 33}]
-        },{
-          :name => 'ian',
-          :age => 32,
-          :friends => [{:name => 'eric', :age => 34}]
-        }]
-      }
-    end
+        }
+        result = tpl.render(Bldr::Node.new, :people => [alex,ian]).result
+        result.should == {
+                          :people=> [{
+                                      :name => 'alex',
+                                      :age => 25,
+                                      :friends => [{:name => 'bo', :age => 33}]
+                                     },{
+                                        :name => 'ian',
+                                        :age => 32,
+                                        :friends => [{:name => 'eric', :age => 34}]
+                                       }]
+                         }
+      end
 
+    end
   end
-end
 
-describe "using a partial template at the root of another template" do
-  it "works as expected" do
-    template = Bldr::Template.new('./spec/fixtures/root_partial.bldr')
-    template.render(Bldr::Node.new(nil, :views => './spec')).result.should == {:foo => 'bar'}
+  describe "using a partial template at the root of another template" do
+    it "works as expected" do
+      template = Bldr::Template.new('./spec/fixtures/root_partial.bldr')
+      template.render(Bldr::Node.new(nil, :views => './spec')).result.should == {:foo => 'bar'}
+    end
   end
-end
+end