RABL

RABL (Ruby API Builder Language) é um sistema de templating Ruby para Rails e Padrino para gerar JSON, XML, MessagePack, PList e BSON. Ao usar o método 'to_json' do ActiveRecord, encontro-me querendo uma solução mais expressiva e poderosa para gerar APIs. Isso é especialmente verdade quando a representação JSON é complexa ou não corresponde ao esquema exato definido no banco de dados.

Em particular, quero facilmente:

Criar nós arbitrários nomeados com base na combinação de dados em um objeto
Passar argumentos para métodos e armazenar o resultado como um nó filho
Renderizar templates parciais e herdar para reduzir duplicação de código
Renomear ou criar apelidos para atributos para alterar o nome do modelo
Anexar atributos de um filho a um nó pai
Incluir nós apenas se uma determinada condição for atendida

Qualquer pessoa que já tentou o método 'to_json' usado no ActiveRecord para gerar uma resposta JSON sentiu a dor dessa abordagem restritiva. RABL é um sistema de templating geral criado para resolver esses problemas ao abordar a geração de respostas de API de uma maneira inteiramente nova.

RABL no seu núcleo é sobre aderir aos princípios MVC ao delegar as representações dos dados da API para a camada de visão da sua aplicação. Para uma análise de equívocos comuns sobre o RABL, consulte nosso guia para entender o RABL que pode ajudar a esclarecer qualquer confusão sobre este projeto.

Mudanças Críticas

v0.8.0 (lançado em 14 de fevereiro de 2013) remove a dependência multi_json e depende de Oj (ou JSON) como o analisador JSON. Simplifica o código, remove uma dependência, mas você pode querer remover quaisquer referências ao MultiJson.
v0.6.14 (lançado em 28 de junho de 2012) exige o uso de render_views com RSpec para testar templates. Caso contrário, o controlador simplesmente passará o comando render como faz com templates ERB.

Instalação

Instale o RABL como uma gem:``` gem install rabl

ou adicione ao seu Gemfile:```ruby
# Gemfile
gem 'rabl'
# Also add either `oj` or `yajl-ruby` as the JSON parser
gem 'oj'

e execute bundle install para instalar a dependência.

Se você estiver usando Rails 2.3.8 (e superior), Rails 3.X ou Padrino, o RABL funciona sem configuração.

Importante: Com Padrino, certifique-se de que a gem rabl está listada depois da gem padrino no seu Gemfile, caso contrário, o Rabl não se registrará corretamente como um mecanismo de template.

Com Sinatra, ou qualquer outro framework baseado em tilt, simplesmente registre:```ruby Rabl.register!

e o RABL será inicializado e estará pronto para uso. Para uso com Sinatra, consulte o guia [Uso com Sinatra](https://github.com/nesquena/rabl/wiki/Setup-for-Sinatra).

## Visão Geral ##

Você pode usar o RABL para gerar APIs baseadas em JSON e XML a partir de qualquer objeto ruby. Com o RABL, os dados geralmente são derivados principalmente de modelos (independente de ORM) e a representação da saída da API é descrita dentro de um template de visão usando um simples DSL ruby. Isso permite que você mantenha seus dados separados do JSON ou XML que deseja gerar.

Depois de instalar o RABL (explicado acima), você pode construir um template de visão RABL e então renderizar o template a partir de suas aplicações Sinatra, Padrino ou Rails a partir do controlador (ou rota) muito facilmente. Usando [Padrino](http://padrinorb.com) como exemplo, assumindo que você tem um modelo `Post` preenchido com posts de blog, você pode renderizar uma representação de API (tanto JSON quanto XML) criando uma rota:```ruby
# app/app.rb
get "/posts", :provides => [:json, :xml] do
  @user = current_user
  @posts = Post.order("id DESC")
  render "posts/index"
end

Então podemos criar o seguinte modelo RABL para expressar a saída da API de @posts:```ruby

app/views/posts/index.rabl

collection @posts attributes :id, :title, :subject child(:user) { attributes :full_name } node(:read) { |post| post.read_by?(@user) }

O que geraria o seguinte JSON ou XML ao visitar `http://localhost:3000/posts.json````js
[{  "post" :
  {
    "id" : 5, title: "...", subject: "...",
    "user" : { full_name : "..." },
    "read" : true
  }
}]

Trata-se de uma visão geral básica, mas há muito mais para ver, como parciais, herança, nós personalizados, etc. Leia os detalhes completos do RABL abaixo.

Configuração

O RABL foi projetado para exigir pouca ou nenhuma configuração para funcionar. Esse é o caso na maioria dos cenários, mas dependendo das suas necessidades, você pode querer definir as seguintes configurações globais na sua aplicação (este bloco é completamente opcional):```ruby

config/initializers/rabl_init.rb

require 'rabl' Rabl.configure do |config|

Commented as these are defaults

config.cache_all_output = false

config.cache_sources = Rails.env != 'development' # Defaults to false

config.cache_engine = Rabl::CacheEngine.new # Defaults to Rails cache

config.perform_caching = false

config.escape_all_output = false

config.json_engine = nil # Class with #dump class method (defaults JSON)

config.msgpack_engine = nil # Defaults to ::MessagePack

config.bson_engine = nil # Defaults to ::BSON

config.plist_engine = nil # Defaults to ::Plist::Emit

config.include_json_root = true

config.include_msgpack_root = true

config.include_bson_root = true

config.include_plist_root = true

config.include_xml_root = false

config.include_child_root = true

config.enable_json_callbacks = false

config.xml_options = { :dasherize => true, :skip_types => false }

config.view_paths = []

config.raise_on_missing_attribute = true # Defaults to false

config.replace_nil_values_with_empty_strings = true # Defaults to false

end

Cada opção especifica um comportamento relacionado à saída do RABL. Se `include_json_root` estiver desabilitado, isso remove o nó raiz para cada objeto raiz na saída, e `enable_json_callbacks` habilita suporte para saída de callback estilo 'jsonp' se a requisição recebida tiver um parâmetro 'callback'.

Se `include_child_root` for definido como falso, os objetos filhos na resposta não incluirão um nó raiz por padrão. Isso permite ajustar ainda mais a estrutura de resposta desejada.

Se `cache_engine` for definido, você deve atribuí-lo a uma classe com um método `fetch`. Veja o [mecanismo padrão](https://github.com/nesquena/rabl/blob/master/lib/rabl/cache_engine.rb) para um exemplo.

Se `perform_caching` for definido como `true`, então ele realizará o cache. Você pode ignorar esta opção se estiver usando Rails, é o mesmo que `config.action_controller.perform_caching` do Rails.

Se `cache_sources` for definido como `true`, as buscas de templates serão armazenadas em cache para melhor desempenho. O cache pode ser redefinido manualmente executando `Rabl.reset_source_cache!` dentro da sua aplicação.

Se `cache_all_output` for definido como `true`, todo template, incluindo cada template individual usado como parte de uma coleção, será armazenado em cache separadamente. Além disso, qualquer coisa dentro de child, glue e partial também será armazenada em cache separadamente. Para armazenar em cache apenas um único template, veja a seção intitulada 'Caching' abaixo.

Se `escape_all_output` for definido como `true` e o ActiveSupport estiver disponível, a saída de atributos será escapada usando [ERB::Util.html_escape](http://corelib.rubyonrails.org/classes/ERB/Util.html). Nós personalizados não serão escapados, use `ERB::Util.h(value)`.

Se `view_paths` for definido como um caminho, este caminho de visualização será verificado para cada template rabl dentro da sua aplicação. Adicione a este caminho especialmente ao incluir Rabl em um engine e usar caminhos de visualização dentro de outra aplicação Rails.

Se `raise_on_missing_attribute` for definido como `true`, um RuntimeError será levantado sempre que Rabl tentar renderizar um atributo que não existe. Caso contrário, o atributo será simplesmente omitido. Definir isso como true durante o desenvolvimento pode ajudar a aumentar a robustez do seu código, mas usar `true` em código de produção não é recomendado.

Se `replace_nil_values_with_empty_strings` for definido como `true`, todos os valores que são `nil` e que normalmente seriam exibidos como `null` na resposta são convertidos para strings vazias.

Se você deseja usar [oj](https://github.com/ohler55/oj) como o principal mecanismo de codificação JSON, basta adicioná-lo ao seu Gemfile:```ruby
# Gemfile
gem 'oj'

e o RABL usará esse mecanismo automaticamente para codificar suas respostas JSON. Defina seu próprio json_engine personalizado que define um método dump ou encode para converter para JSON a partir de dados ruby:```ruby config.json_engine = ActiveSupport::JSON

### Configuração de Formato ###

O RABL suporta configuração para MessagePack, BSON e Plist. Consulte a página [Configuração de Formato](https://github.com/nesquena/rabl/wiki/Configuring-Formats) para mais detalhes.

## Uso ##

### Atribuição de Objeto ###

Para declarar o objeto de dados para uso no template:```ruby
# app/views/users/show.json.rabl
object @user

ou especificar um alias para o objeto:```ruby object @user => :person

=> { "person" : { ... } }

ou passe uma coleção de objetos:```ruby
collection @users
# => [ { "user" : { ... } } ]

ou especifique um rótulo de nó raiz para a coleção:```ruby collection @users => :people

=> { "people" : [ { "person" : { ... } } ] }

ou até mesmo especificar ambos os rótulos filho e raiz para uma coleção:```ruby
collection @users, :root => "people", :object_root => "user"
# => { "people" : [ { "user" : { ... } } ] }

e isso será usado como os dados padrão para a renderização, ou desabilite explicitamente a raiz do objeto:```ruby collection @users, :root => "people", :object_root => false

=> { "people" : [ { ... }, { ... } ] }

Também pode haver casos estranhos onde o nível raiz da resposta não mapeia diretamente para nenhum objeto:```ruby
object false
node(:some_count) { |m| @user.posts.count }
child(@user) { attribute :name }

Nesses casos, o objeto pode ser atribuído a 'false' e os nós podem ser construídos de forma livre.

Atributos

Uso básico do templater para definir alguns atributos simples para a resposta:```ruby

app/views/users/show.json.rabl

attributes :id, :foo, :bar

ou use com atributos de alias:```ruby
# Take the value of model attribute `foo` and name the node `bar`
attribute :foo => :bar
# => { bar : 5 }

ou até mesmo atributos com múltiplos aliases:```ruby attributes :bar => :baz, :dog => :animal

=> # { baz : , animal : }

ou mostrar atributos apenas se uma condição for verdadeira:```ruby
# m is the object being rendered, also supports :unless
attributes :foo, :bar, :if => lambda { |m| m.condition? }

Atributos nomeados e com alias não podem ser combinados na mesma linha. Isso atualmente não funciona:```ruby attributes :foo, :bar => :baz # throws exception

### Child Nodes ###

Frequentemente, uma resposta requer a inclusão de informações aninhadas de dados associados ao modelo pai:```ruby
child :address do
  attributes :street, :city, :zip, :state
end

Você também pode desabilitar a raiz do objeto para o nó filho:```ruby child :posts, :object_root => false do attributes :id, :title end

Você também pode adicionar nós filhos de uma fonte de dados arbitrária:```ruby
child @posts => :foobar do
  attributes :id, :title
end

ou use associações de modelo com um alias:```ruby

Renders all the 'posts' association

from the model into a node called 'foobar'

child :posts => :foobar do attributes :id, :title end

Você também pode passar o objeto atual:```ruby
object @user
child :posts do |user|
  attribute :title unless user.suspended?
end

Atributos de Colagem

Você também pode anexar atributos filhos de volta ao nó raiz:```ruby

Appends post_id and post_name to parent json object

glue @post do attributes :id => :post_id, :name => :post_name end

Use glue para adicionar atributos adicionais ao objeto pai.

Você também pode passar o objeto atual:```ruby
object @user
glue(@post) {|user| attribute :title if user.active? }

Nós Personalizados

Isto irá gerar uma resposta json baseada no resultado do bloco node:```ruby

app/views/users/show.json.rabl

node :full_name do |u| u.first_name + " " + u.last_name end

ou um nó personalizado que existe apenas se uma condição for verdadeira:```ruby
# m is the object being rendered, also supports :unless
node(:foo, :if => lambda { |m| m.has_foo? }) do |m|
  m.foo
end

ou não informe um nome e o bloco de nó será mesclado na resposta:```ruby node do |u| { :full_name => u.first_name + " " + u.last_name }

=> { full_name : "Bob Johnson" }

end

### Parciais ###

Frequentemente, você precisa acessar outros objetos de dados para construir nós personalizados em associações mais complexas. Você pode obter acesso à representação rabl de outro objeto de dados renderizando um parcial RABL:

    ```ruby
    # app/views/posts/index.rabl
    collection @posts
    attributes :id, :title
    child :author do
      extends "users/show"   # get the rabl partial for @author
    end```ruby
node :location do
  { :city => @city, :address => partial("users/address", :object => @address) }
end

ou mesmo acessar um objeto associado ao modelo pai:```ruby node :location do |m| { :city => m.city, :address => partial("users/address", :object => m.address) } end

Você pode usar esse método para construir nós arbitrariamente complexos para suas APIs. Note que você precisa ter templates RABL definidos
para cada um dos objetos para os quais deseja construir representações dessa forma.

### Herança ###

Outro problema comum de muitos construtores de templates é a redundância desnecessária de código. Tipicamente, muitas representações de um objeto em vários endpoints compartilham atributos ou nós comuns. Os nós para um objeto 'post' são provavelmente os mesmos ou similares na maioria das referências ao longo dos vários endpoints.

RABL tem a capacidade de estender outros templates RABL "base" e atributos adicionais:```ruby
# app/views/users/advanced.json.rabl
extends "users/base" # another RABL template in "app/views/users/base.json.rabl"

node :can_drink do |m|
  m.age > 21
end

Você também pode estender outros rabl templates enquanto constrói nós filhos para reduzir duplicação:```ruby

app/views/users/show.json.rabl

child @address do extends "address/item" end

Usar parciais e herança pode reduzir significativamente a duplicação de código em seus templates.

You can see more examples on the [Reusing Templates wiki page](https://github.com/nesquena/rabl/wiki/Reusing-templates).

### Passando Locals em Parciais ###

Você pode passar um conjunto arbitrário de locals ao renderizar parciais ou estender templates.
Por exemplo, se quisermos mostrar em `posts/:id.json` qualquer informação sobre um post específico e comentários associados
mas em outros casos quisermos esconder esses comentários. Podemos usar locals para fazer isso:```ruby
# app/views/posts/index.json.rabl
collection @posts

extends('posts/show', :locals => { :hide_comments => true })
# or using partial instead of extends
# node(false) { |post| partial('posts/show', :object => :post, :locals => { :hide_comments => true })}

e então acessar os locals no sub-template:```ruby

app/views/posts/show.json.rabl

object @post

attributes :id, :title, :body, :created_at node(:comments) { |post| post.comments } unless locals[:hide_comments]

Isto pode ser útil como uma ferramenta avançada ao estender ou renderizar parciais.

### Escopo do Template ###

No RABL, você tem acesso a tudo que precisa para construir uma resposta de API. Cada template RABL tem acesso total às variáveis de instância dos controladores
bem como a todos os helpers de visualização e URLs de roteamento.```ruby
# app/some/template.rabl
object @post
# Access instance variables
child(@user => :user) { ... }
# or Rails helpers
node(:formatted_body) { |post| simple_format(post.body) }

Não deve haver problema em buscar os dados apropriados para construir uma resposta.

Aninhamento Profundo

Em APIs, muitas vezes é necessário construir nós de 2º ou 3º nível. Suponhamos que temos um modelo 'quiz' que tem muitas 'perguntas' e cada pergunta tem muitas 'respostas'. Podemos exibir essa hierarquia no RABL de forma bastante simples:```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

Isto exibirá o objeto quiz com perguntas e respostas aninhadas, como seria de esperar com um nó quiz, e perguntas e respostas incorporadas.
Note que o RABL pode ser aninhado arbitrariamente em profundidade dentro de nós filhos para permitir que essas representações sejam definidas.

### Caching ###

O RABL possui suporte integrado de cache para templates utilizando estratégias de cache de fragmentos. Note que o cache está atualmente **apenas disponível** para Rails, mas suporte para outros frameworks está planejado para uma versão futura. O uso mais simples de cache é:```ruby
# app/views/users/show.json.rabl
object @quiz
cache @quiz # key = rabl/quiz/[cache_key]
attribute :title

O cache pode acelerar significativamente a renderização de templates RABL em produção e é fortemente recomendado quando possível. Para uma análise mais detalhada sobre cache, consulte o guia Caching na wiki.

Renderizando Templates Diretamente

Existem situações em que uma aplicação requer que templates RABL sejam renderizados fora de um contexto de visão tradicional. Por exemplo, para renderizar RABL dentro de uma tarefa Rake ou para criar payloads de fila de mensagens. Para este caso, Rabl.render pode ser usado conforme mostrado abaixo:```ruby Rabl.render(object, template, :view_path => 'app/views', :format => :json) #=> "{...json...}"

Você pode usar métodos de conveniência em `Rabl::Renderer` para renderizar os objetos também:```ruby
Rabl::Renderer.json(@post, 'posts/show')
Rabl::Renderer.xml(@post, 'posts/show')

Estes métodos permitem que o RABL seja usado para conversões arbitrárias de um objeto para um formato desejado.```ruby Rabl::Renderer.new('posts/show', @post, :view_path => 'app/views', :format => 'hash').render

Você também pode passar outras variáveis de instância para serem usadas em seu template como:```ruby
Rabl::Renderer.new('posts/show', @post, :locals => { :custom_title => "Hello world!" })

Então, no seu template, você pode usar @custom_title como:``` attribute :content node(:title) { @custom_title }

### Cabeçalhos de Tipo de Conteúdo ###

Atualmente no RABL, o tipo de conteúdo da sua resposta não é definido automaticamente. Isso ocorre porque o RABL foi projetado
para funcionar com qualquer framework baseado em Rack e ser o mais agnóstico possível em relação ao formato.
Consulte [esta issue](https://github.com/nesquena/rabl/issues/185#issuecomment-4501232) para mais
detalhes, e se você tiver ideias ou patches, por favor, me avise.

Enquanto isso, lembre-se de definir os tipos de conteúdo adequados, se necessário. Isso geralmente é bem simples tanto no
Rails quanto no Padrino. Recomendo um before_filter no controlador ou especificá-lo diretamente em uma ação.

## Recursos ##

Há muitos recursos disponíveis relacionados ao RABL, incluindo a [Wiki do RABL](https://github.com/nesquena/rabl/wiki),
e diversos tutoriais e guias detalhados abaixo.
Você também pode conferir o [Site do RABL](http://nesquena.github.com/rabl).

### Uso Avançado ###

Links para recursos de uso avançado:

 * [Gerenciando Complexidade](https://github.com/nesquena/rabl/wiki/Managing-complexity-with-presenters)
 * [Otimizações de Produção](https://github.com/nesquena/rabl/wiki/Rabl-In-Production)
 * [Integração com Grape](https://github.com/nesquena/rabl/wiki/Using-Rabl-with-Grape)
 * [Renderizando JSON para uma estrutura em árvore usando RABL](https://github.com/nesquena/rabl/issues/70)
 * [Layouts (erb, haml e rabl) no RABL](https://github.com/nesquena/rabl/wiki/Using-Layouts)
 * [Integração com Backbone ou Ember.js](https://github.com/nesquena/rabl/wiki/Backbone-Integration)
 * [RABL com Rails Engines](https://github.com/nesquena/rabl/wiki/Setup-rabl-with-rails-engines)

Por favor, adicione seus próprios usos e me avise para que possamos incluí-los aqui! Não deixe de conferir também
a [Wiki do RABL](https://github.com/nesquena/rabl/wiki) para outros usos.

### Tutoriais ###

Tutoriais podem ser sempre úteis quando se está começando:

 * [Railscasts #322](http://railscasts.com/episodes/322-rabl) - Ryan Bates explica o RABL
 * [BackboneRails](http://www.backbonerails.com/) - Ótimos screencasts por Brian Mann
 * [Criando uma API com RABL e Padrino](http://blog.crowdint.com/2012/10/22/rabl-with-padrino.html)
 * http://blog.joshsoftware.com/2011/12/23/designing-rails-api-using-rabl-and-devise/
 * http://engineering.gomiso.com/2011/06/27/building-a-platform-api-on-rails/
 * http://blog.lawrencenorton.com/better-json-requests-with-rabl
 * http://www.rodrigoalvesvieira.com/developing-json-api-rails-rabl/
 * http://tech.favoritemedium.com/2011/06/using-rabl-in-rails-json-web-api.html
 * http://seesparkbox.com/foundry/better_rails_apis_with_rabl
 * http://blog.dcxn.com/2011/06/22/rails-json-templates-through-rabl
 * http://teohm.github.com/blog/2011/05/31/using-rabl-in-rails-json-web-api

Avise-me se houver algum outro recurso útil não listado aqui.

### Bibliotecas Relacionadas ###

Existem outras bibliotecas que podem complementar ou estender a funcionalidade do RABL:

 * [versioncake](https://github.com/bwillis/versioncake) - Excelente biblioteca para versionar facilmente suas APIs RABL
 * [gon](https://github.com/gazay/gon) - Expõe suas variáveis do Rails no JS com suporte integrado ao RABL.
 * [rabl-rails](https://github.com/ccocchi/rabl-rails) - Reimplementação do RABL para Rails
   [focada em velocidade](https://github.com/ccocchi/rabl-benchmark/blob/master/BENCHMARK).

Avise-me se houver alguma outra biblioteca relacionada não listada aqui.

### Solução de Problemas ###

 * [Chamadas redundantes para uma coleção](https://github.com/nesquena/rabl/issues/142#issuecomment-2969107)
 * [Testando Views do RABL](https://github.com/nesquena/rabl/issues/130#issuecomment-4179285)

### Exemplos ###

Veja o diretório [examples](https://github.com/nesquena/rabl/tree/master/examples).

## Issues ##

Confira a aba [Issues](https://github.com/nesquena/rabl/issues) para uma lista completa:

 * Benchmarks rigorosos e otimizações de desempenho

## Autores e Contribuidores ##

Agradecimentos à [Miso](http://gomiso.com) por me permitir criar isso para nossos aplicativos e lançar este projeto!

* [Nathan Esquenazi](https://github.com/nesquena) - Criador do projeto
* [Arthur Chiu](https://github.com/achiu) - Mantenedor Principal, Guru de Testes Riot
* [Tim Lee](https://github.com/timothy1ee) - RABL foi um ótimo nome escolhido pelo CTO da Miso.
* [David Sommers](https://github.com/databyte) - Resolução de templates, suporte a cache e muito mais
* [Rick Thomas](https://github.com/rickthomasjr) - Adicionou opções para extends e testes em Sinatra
* [Benjamin Yu](https://github.com/byu) - Adicionou suporte ao formato msgpack
* [Chris Kimpton](https://github.com/kimptoc) - Ajuda com documentação e wiki
* [Marjun](https://github.com/mpagalan) - Adicionou configurações de opções xml
* [Anton Orel](https://github.com/skyeagle) - Adicionou compatibilidade com Rails 3.1
* [Sasha Koss](https://github.com/kossnocorp) - Adicionou suporte a multi_json
* [Matthew Schulkind](https://github.com/mschulkind) - Limpeza de configuração e testes
* [Luke van der Hoeven](https://github.com/plukevdh) - Suporte a objetos não-ORM em templates
* [Andrey Voronkov](https://github.com/Antiarchitect) - Adicionou suporte ao formato BSON
* [Alli Witheford](https://github.com/alzeih) - Adicionou suporte ao formato Plist
* [Ryan Bigg](https://github.com/radar) - Código de resolução de templates melhorado
* [Ivan Vanderbyl](https://github.com/ivanvanderbyl) - Adicionou renderizador de propósito geral
* [Cyril Mougel](https://github.com/shingara) - Adicionou suporte a cache_engine plugável e ajustes no renderizador
* [Teng Siong Ong](https://github.com/siong1987) - Interface do renderizador melhorada
* [Brad Dunbar](https://github.com/braddunbar) - Passa o objeto atual para os blocos

e muitos outros contribuidores listados no [CHANGELOG](https://github.com/nesquena/rabl/blob/master/CHANGELOG.md).

Quer contribuir com suporte para outro formato?
Confira os patches para [suporte a msgpack](https://github.com/nesquena/rabl/pull/69), [suporte a plist](https://github.com/nesquena/rabl/pull/153) e
[suporte a BSON](https://github.com/nesquena/rabl/pull/163) como referência.

Por favor, fork e contribua, qualquer ajuda para melhorar este projeto é bem-vinda!

Este projeto é membro do [OSS Manifesto](http://ossmanifesto.org).

## Inspirações ##

Algumas bibliotecas excelentes ajudaram a inspirar o RABL e estão listadas abaixo:

 * [Tequila](https://github.com/inem/tequila)
 * [JSON Builder](https://github.com/dewski/json_builder)
 * [Argonaut](https://github.com/jbr/argonaut)

Agradeço novamente a todos esses grandes projetos.

## Copyright ##

Copyright © 2011-2012 Nathan Esquenazi. Consulte [MIT-LICENSE](https://github.com/nesquena/rabl/blob/master/MIT-LICENSE) para obter detalhes.

rabl-old

Mais Populares