rabl 0.2.1 → 0.2.5

data/README.md

@@ -17,12 +17,16 @@ Anyone who has tried the 'to_json' method used in ActiveRecord for generating a
 
 Install RABL as a gem:
 
-    gem install rabl
+```
+gem install rabl
+```
 
 or add to your Gemfile:
 
-    # Gemfile
-    gem 'rabl'
+```ruby
+# Gemfile
+gem 'rabl'
+```
 
 and run `bundle install` to install the dependency.
 
@@ -78,13 +82,15 @@ That's the basic overview but there is a lot more (partials, inheritance, custom
 
 RABL is intended to require little to no configuration to get working. This is the case in most scenarios, but depending on your needs you may want to set the following global configurations in your application (this block is completely optional):
 
-    # config/initializers/rabl_init.rb
-    Rabl.configure do |config|
-      # Commented as these are the defaults
-      # config.include_json_root = true
-      # config.include_xml_root  = false
-      # config.enable_json_callbacks = false
-    end
+```ruby
+# config/initializers/rabl_init.rb
+Rabl.configure do |config|
+  # Commented as these are the defaults
+  # config.include_json_root = true
+  # config.include_xml_root  = false
+  # config.enable_json_callbacks = false
+end
+```
 
 Each option specifies behavior related to RABL's output. If `include_json_root` is disabled that removes the root node for each child in the output, and `enable_json_callbacks` enables support for 'jsonp' style callback output if the incoming request has a 'callback' parameter.
 
@@ -94,31 +100,41 @@ Each option specifies behavior related to RABL's output. If `include_json_root`
 
 To declare the data object for use in the template:
 
-     # app/views/users/show.json.rabl
-     object @user
+```ruby
+# app/views/users/show.json.rabl
+object @user
+```
 
 or specify an alias for the object:
 
-    object @user => :person
-    # => { "person" : { ... } }
+```ruby
+object @user => :person
+# => { "person" : { ... } }
+```
 
 or pass a collection of objects:
 
-     collection @users
-     # => [ { "user" : { ... } } ]
+```ruby
+collection @users
+# => [ { "user" : { ... } } ]
+```
 
 or even specify a root node label for the collection:
 
-    collection @users => :people
-    # => { "people" : [ { "person" : { ... } } ] }
+```ruby
+collection @users => :people
+# => { "people" : [ { "person" : { ... } } ] }
+```
 
 and this will be used as the default data for the rendering.
 
 There can also be odd cases where the root-level of the response doesn't map directly to any object:
 
-    object false
-    code(:some_count) { |m| @user.posts.count }
-    child(@user) { attribute :name }
+```ruby
+object false
+code(:some_count) { |m| @user.posts.count }
+child(@user) { attribute :name }
+```
 
 In those cases, object can be assigned to 'false' and child nodes can be constructed independently.
 
@@ -126,50 +142,64 @@ In those cases, object can be assigned to 'false' and child nodes can be constru
 
 Basic usage of the templater to define a few simple attributes for the response:
 
-    # app/views/users/show.json.rabl
-    attributes :id, :foo, :bar
+```ruby
+# app/views/users/show.json.rabl
+attributes :id, :foo, :bar
+```
 
 or use with aliased attributes:
 
-    # Take the value of model attribute `foo` and name the node `bar`
-    attribute :foo => :bar
-    # => { bar : 5 }
+```ruby
+# Take the value of model attribute `foo` and name the node `bar`
+attribute :foo => :bar
+# => { bar : 5 }
+```
 
 or even multiple aliased attributes:
 
-    attributes :bar => :baz, :dog => :animal
-    # => # { baz : <bar value>, animal : <dog value> }
+```ruby
+attributes :bar => :baz, :dog => :animal
+# => # { baz : <bar value>, animal : <dog value> }
+```
 
 ### Child Nodes ###
 
 Often a response requires including nested information from data associated with the parent model:
 
-    child :address do
-      attributes :street, :city, :zip, :state
-    end
+```ruby
+child :address do
+  attributes :street, :city, :zip, :state
+end
+```
 
 You can also add child nodes from an arbitrary data source:
 
-    child @posts => :foobar do
-      attributes :id, :title
-    end
+```ruby
+child @posts => :foobar do
+  attributes :id, :title
+end
+```
 
 or use model associations with an alias:
 
-    # Renders all the 'posts' association
-    # from the model into a node called 'foobar'
-    child :posts => :foobar do
-      attributes :id, :title
-    end
+```ruby
+# Renders all the 'posts' association
+# from the model into a node called 'foobar'
+child :posts => :foobar do
+  attributes :id, :title
+end
+```
 
 ### Gluing Attributes ###
 
 You can also append child attributes back to the root node:
 
-    # Appends post_id and post_name to parent json object
-    glue @post do
-      attributes :id => :post_id, :name => :post_name
-    end
+```ruby
+# Appends post_id and post_name to parent json object
+glue @post do
+  attributes :id => :post_id, :name => :post_name
+end
+```
 
 Use glue to add additional attributes to the parent object.
 
@@ -177,17 +207,21 @@ Use glue to add additional attributes to the parent object.
 
 This will generate a json response based on the result of the code block:
 
-    # app/views/users/show.json.rabl
-    code :full_name do |u|
-      u.first_name + " " + u.last_name
-    end
+```ruby
+# app/views/users/show.json.rabl
+code :full_name do |u|
+  u.first_name + " " + u.last_name
+end
+```
 
 or a custom node that exists only if a condition is true:
 
-    # m is the object being rendered, also supports :unless
-    code(:foo, :if => lambda { |m| m.has_foo? }) do |m|
-      m.foo
-    end
+```ruby
+# m is the object being rendered, also supports :unless
+code(:foo, :if => lambda { |m| m.has_foo? }) do |m|
+  m.foo
+end
+```
 
 You can use custom "code" nodes to create flexible representations of a value utilizing all the data from the model.
 
@@ -195,15 +229,19 @@ You can use custom "code" nodes to create flexible representations of a value ut
 
 Often you need to access sub-objects in order to construct your own custom nodes for more complex associations. You can get access to the rabl representation of another object with:
 
-    code :location do
-      { :city => @city, :address => partial("web/users/address", :object => @address) }
-    end
+```ruby
+code :location do
+  { :city => @city, :address => partial("web/users/address", :object => @address) }
+end
+```
 
 or an object associated to the parent model:
 
-    code :location do |m|
-      { :city => m.city, :address => partial("web/users/address", :object => m.address) }
-    end
+```ruby
+code :location do |m|
+  { :city => m.city, :address => partial("web/users/address", :object => m.address) }
+end
+```
 
 You can use this method to construct arbitrarily complex nodes for your APIs.
 
@@ -213,19 +251,23 @@ Another common issue of many template builders is unnecessary code redundancy. T
 
 RABL has the ability to extend other "base" rabl templates and additional attributes:
 
-    # app/views/users/advanced.json.rabl
-    extends "users/base" # another RABL template in "app/views/users/base.json.rabl"
+```ruby
+# app/views/users/advanced.json.rabl
+extends "users/base" # another RABL template in "app/views/users/base.json.rabl"
 
-    code :can_drink do |m|
-      m.age > 21
-    end
+code :can_drink do |m|
+  m.age > 21
+end
+```
 
 You can also extend other rabl templates while constructing child nodes to reduce duplication:
 
-    # app/views/users/show.json.rabl
-    child @address do
-      extends "address/item"
-    end
+```ruby
+# app/views/users/show.json.rabl
+child @address do
+  extends "address/item"
+end
+```
 
 Using partials and inheritance can significantly reduce code duplication in your templates.
 
@@ -234,20 +276,38 @@ Using partials and inheritance can significantly reduce code duplication in your
 In APIs, you can often need to construct 2nd or 3rd level nodes. Let's suppose we have a 'quiz' model that has many 'questions'
 and then each question has many 'answers'. We can display this hierarchy in RABL quite easily:
 
-    # app/views/quizzes/show.json.rabl
-    object @quiz
-    attribute :title
-    child :questions do
-      attribute :caption
-      child :answers do
-        # Use inheritance to reduce duplication
-        extends "answers/item"
-      end
-    end
+```ruby
+# app/views/quizzes/show.json.rabl
+object @quiz
+attribute :title
+child :questions do
+  attribute :caption
+  child :answers do
+    # Use inheritance to reduce duplication
+    extends "answers/item"
+  end
+end
+```
 
 This will display the quiz object with nested questions and answers as you would expect with a quiz node, and embedded questions and answers.
 Note that RABL can be nested arbitrarily deep within child nodes to allow for these representations to be defined.
 
+## Template Scope ##
+
+In RABL, you have access to everything you need to build an API response. Each RABL template has full access to the controllers
+instance variables as well as all view helpers and routing urls.
+
+```ruby
+# app/some/template.rabl
+object @post
+# Access instance variables
+child(@user => :user) { ... }
+# or Rails helpers
+code(:formatted_body) { |post| simple_format(post.body) }
+```
+
+There should be no problem fetching the appropriate data to construct a response.
+
 ## Issues ##
 
 Check out the [Issues](https://github.com/nesquena/rabl/issues) tab for a full list:

data/lib/rabl/engine.rb

@@ -133,6 +133,9 @@ module Rabl
     # default_format => "xml"
     def default_format
       format = self.request_params.has_key?(:format) ? @_scope.params[:format] : nil
+      if request = @_scope.respond_to?(:request) && @_scope.request
+        format ||= request.format.to_sym.to_s if request.respond_to?(:format)
+      end
       format || "json"
     end
 
@@ -148,5 +151,15 @@ module Rabl
       use_callback = Rabl.configuration.enable_json_callbacks && request_params[:callback].present?
       use_callback ? "#{request_params[:callback]}(#{json_output})" : json_output
     end
+
+    # Augments respond to supporting scope methods
+    def respond_to?(name, include_private=false)
+      @_scope.respond_to?(name, include_private) ? true : super
+    end
+
+    # Supports calling helpers defined for the template scope using method_missing hook
+    def method_missing(name, *args, &block)
+      @_scope.respond_to?(name) ? @_scope.send(name, *args, &block) : super
+    end
   end
 end

data/lib/rabl/version.rb

@@ -1,3 +1,3 @@
 module Rabl
-  VERSION = "0.2.1"
+  VERSION = "0.2.5"
 end

metadata

@@ -2,7 +2,7 @@
 name: rabl
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.1
+  version: 0.2.5
 platform: ruby
 authors: 
 - Nathan Esquenazi
@@ -10,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-16 00:00:00 -07:00
-default_executable: 
+date: 2011-05-19 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: riot
@@ -90,7 +89,6 @@ files:
 - test/models/user.rb
 - test/template_test.rb
 - test/teststrap.rb
-has_rdoc: true
 homepage: https://github.com/nesquena/rabl
 licenses: []
 
@@ -114,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rabl
-rubygems_version: 1.6.2
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: General ruby templating for json or xml