RABL

RABL (Ruby API Builder Language) — это система шаблонов на Ruby для Rails и Padrino, предназначенная для генерации JSON, XML, MessagePack, PList и BSON. При использовании метода ActiveRecord 'to_json' мне часто хочется получить более выразительное и мощное решение для генерации API. Это особенно актуально, когда JSON-представление сложное или не соответствует точной схеме, определённой в базе данных.

В частности, я хочу легко:

Создавать произвольные узлы, имена которых основаны на объединении данных из объекта
Передавать аргументы методам и сохранять результат как дочерний узел
Рендерить частичные шаблоны и наследовать их для уменьшения дублирования кода
Переименовывать или создавать псевдонимы атрибутов, чтобы изменить имя по сравнению с моделью
Добавлять атрибуты дочернего узла в родительский узел
Включать узлы только при выполнении определённого условия

Любой, кто пробовал метод 'to_json', используемый в ActiveRecord для генерации JSON-ответа, ощущал боль этого ограничительного подхода. RABL — это общая система шаблонов, созданная для решения этих проблем путём совершенно нового подхода к генерации ответов API.

В основе RABL лежит следование принципам MVC путём переноса представления данных API в представление (view) вашего приложения. Чтобы разобраться с распространёнными заблуждениями о RABL, пожалуйста, ознакомьтесь с нашим руководством по пониманию RABL, которое поможет прояснить любую путаницу, связанную с этим проектом.

Критические изменения

v0.8.0 (выпущена 14 февраля 2013 г.) удаляет зависимость от multi_json и полагается на Oj (или JSON) в качестве парсера JSON. Упрощает код, удаляет зависимость, но вам, возможно, потребуется удалить все ссылки на MultiJson.
v0.6.14 (выпущена 28 июня 2012 г.) требует использования render_views с RSpec для тестирования шаблонов. В противном случае контроллер просто передаст команду render, как это делается с шаблонами ERB.

Установка

Установите RABL как гем:``` gem install rabl

или добавьте в ваш Gemfile:```ruby
# Gemfile
gem 'rabl'
# Also add either `oj` or `yajl-ruby` as the JSON parser
gem 'oj'

и выполните bundle install для установки зависимости.

Если вы используете Rails 2.3.8 (и выше), Rails 3.X или Padrino, RABL работает без настройки.

Важно: В Padrino убедитесь, что гем rabl указан после гема padrino в вашем Gemfile, иначе Rabl не зарегистрируется должным образом как шаблонизатор.

Для Sinatra или любого другого фреймворка на основе tilt, просто зарегистрируйте:```ruby Rabl.register!

и RABL будет инициализирован и готов к использованию. Для использования с Sinatra ознакомьтесь с руководством [Sinatra Usage](https://github.com/nesquena/rabl/wiki/Setup-for-Sinatra).

## Обзор ##

Вы можете использовать RABL для генерации API на основе JSON и XML из любого объекта Ruby. С помощью RABL данные обычно извлекаются преимущественно из моделей (независимо от ORM), а представление вывода API описывается внутри шаблона представления с помощью простого Ruby DSL. Это позволяет отделить данные от JSON или XML, которые вы хотите вывести.

После установки RABL (описано выше) вы можете создать шаблон представления RABL и затем легко отрисовать его из приложений Sinatra, Padrino или Rails из контроллера (или маршрута). Используя [Padrino](http://padrinorb.com) в качестве примера, предположим, что у вас есть модель `Post`, заполненная записями блога, вы можете отрисовать представление API (как JSON, так и XML) создав маршрут:```ruby
# app/app.rb
get "/posts", :provides => [:json, :xml] do
  @user = current_user
  @posts = Post.order("id DESC")
  render "posts/index"
end

Затем мы можем создать следующий шаблон RABL для вывода API из @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) }

Что выведет следующий JSON или XML при посещении `http://localhost:3000/posts.json````js
[{  "post" :
  {
    "id" : 5, title: "...", subject: "...",
    "user" : { full_name : "..." },
    "read" : true
  }
}]

Это базовый обзор, но есть гораздо больше, например, партиалы, наследование, пользовательские узлы и т.д. Полные детали RABL читайте ниже.

Конфигурация

RABL предназначен для работы с минимальной или нулевой настройкой. Это верно для большинства сценариев, но в зависимости от ваших потребностей вы можете задать следующие глобальные конфигурации в вашем приложении (этот блок полностью опционален):```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

Каждый параметр определяет поведение вывода RABL. Если `include_json_root` отключён, это удаляет корневой узел для каждого корневого объекта в выводе, а `enable_json_callbacks` включает поддержку 'jsonp'-подобного стиля обратного вызова, если входящий запрос содержит параметр 'callback'.

Если `include_child_root` установлен в false, дочерние объекты в ответе по умолчанию не будут включать корневой узел. Это позволяет дополнительно точно настроить желаемую структуру ответа.

Если задан `cache_engine`, ему следует присвоить класс с методом `fetch`. Смотрите [стандартный движок](https://github.com/nesquena/rabl/blob/master/lib/rabl/cache_engine.rb) в качестве примера.

Если `perform_caching` установлен в `true`, будет выполняться кеширование. Вы можете игнорировать этот параметр, если используете Rails, он аналогичен параметру Rails `config.action_controller.perform_caching`.

Если `cache_sources` установлен в `true`, поиск шаблонов будет кешироваться для повышения производительности. Кеш можно сбросить вручную, выполнив `Rabl.reset_source_cache!` в вашем приложении.

Если `cache_all_output` установлен в `true`, каждый шаблон, включая каждый отдельный шаблон, используемый как часть коллекции, будет кешироваться отдельно. Кроме того, всё внутри child, glue и partial также будет кешироваться отдельно. Чтобы кешировать только один шаблон, смотрите раздел «Кеширование» ниже.

Если `escape_all_output` установлен в `true` и ActiveSupport доступен, вывод атрибутов будет экранироваться с помощью [ERB::Util.html_escape](http://corelib.rubyonrails.org/classes/ERB/Util.html). Пользовательские узлы не будут экранироваться, используйте `ERB::Util.h(value)`.

Если `view_paths` установлен в путь, этот путь к представлению будет проверяться для каждого шаблона rabl в вашем приложении. Добавляйте его к этому пути, особенно при включении Rabl в движок и использовании путей представлений в другом приложении Rails.

Если `raise_on_missing_attribute` установлен в `true`, будет вызвано RuntimeError всякий раз, когда Rabl пытается отобразить атрибут, который не существует. В противном случае атрибут будет просто пропущен. Установка этого значения в `true` во время разработки может помочь повысить надёжность вашего кода, но использование `true` в рабочем коде не рекомендуется.

Если `replace_nil_values_with_empty_strings` установлен в `true`, все значения, которые равны `nil` и обычно отображаются как `null` в ответе, преобразуются в пустые строки.

Если вы хотите использовать [oj](https://github.com/ohler55/oj) в качестве основного движка кодирования JSON, просто добавьте его в ваш Gemfile:```ruby
# Gemfile
gem 'oj'

и RABL будет автоматически использовать этот движок для кодирования ваших JSON-ответов. Установите свой собственный json_engine, который определяет метод dump или encode для преобразования в JSON из данных Ruby:```ruby config.json_engine = ActiveSupport::JSON

### Конфигурация форматов ###

RABL поддерживает конфигурацию для MessagePack, BSON и Plist. Подробнее см. на странице [Конфигурация форматов](https://github.com/nesquena/rabl/wiki/Configuring-Formats).

## Использование ##

### Назначение объекта ###

Чтобы объявить объект данных для использования в шаблоне:```ruby
# app/views/users/show.json.rabl
object @user

или укажите псевдоним для объекта:```ruby object @user => :person

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

или передайте коллекцию объектов:```ruby
collection @users
# => [ { "user" : { ... } } ]

или укажите метку корневого узла для коллекции:```ruby collection @users => :people

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

или даже укажите метки как дочернего, так и корневого элемента для коллекции:```ruby
collection @users, :root => "people", :object_root => "user"
# => { "people" : [ { "user" : { ... } } ] }

и это будет использоваться как данные по умолчанию для рендеринга, или явно отключить корень объекта:```ruby collection @users, :root => "people", :object_root => false

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

Также могут быть необычные случаи, когда корневой уровень ответа не сопоставляется напрямую ни с каким объектом:```ruby
object false
node(:some_count) { |m| @user.posts.count }
child(@user) { attribute :name }

В таких случаях объекту можно присвоить 'false', а узлы можно создавать в произвольной форме.

Атрибуты

Базовое использование templater для определения нескольких простых атрибутов ответа:```ruby

app/views/users/show.json.rabl

attributes :id, :foo, :bar

или используйте с псевдонимированными атрибутами:```ruby
# Take the value of model attribute `foo` and name the node `bar`
attribute :foo => :bar
# => { bar : 5 }

или даже несколько атрибутов с псевдонимами:```ruby attributes :bar => :baz, :dog => :animal

=> # { baz : , animal : }

или показывать атрибуты только если условие истинно:```ruby
# m is the object being rendered, also supports :unless
attributes :foo, :bar, :if => lambda { |m| m.condition? }

Именованные атрибуты и атрибуты с псевдонимами не могут быть объединены в одной строке. В настоящее время это не работает:```ruby attributes :foo, :bar => :baz # throws exception

### Дочерние узлы ###

Часто ответ требует включения вложенной информации из данных, связанных с родительской моделью:```ruby
child :address do
  attributes :street, :city, :zip, :state
end

Вы также можете отключить корневой объект для дочернего узла:```ruby child :posts, :object_root => false do attributes :id, :title end

Вы также можете добавлять дочерние узлы из произвольного источника данных:```ruby
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

Вы также можете передать текущий объект:```ruby
object @user
child :posts do |user|
  attribute :title unless user.suspended?
end

Склеивание атрибутов

Вы также можете добавлять дочерние атрибуты обратно к корневому узлу:```ruby

Appends post_id and post_name to parent json object

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

Используйте glue для добавления дополнительных атрибутов к родительскому объекту.

Вы также можете передать текущий объект:```ruby
object @user
glue(@post) {|user| attribute :title if user.active? }

Пользовательские узлы

Это сгенерирует json ответ на основе результата блока node:```ruby

app/views/users/show.json.rabl

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

или пользовательский узел, который существует только если условие истинно:```ruby
# m is the object being rendered, also supports :unless
node(:foo, :if => lambda { |m| m.has_foo? }) do |m|
  m.foo
end

или не передавайте имя, и блок узла объединяется в ответ:```ruby node do |u| { :full_name => u.first_name + " " + u.last_name }

=> { full_name : "Bob Johnson" }

end

### Частичные представления ###

Часто вам нужно обращаться к другим объектам данных, чтобы создавать пользовательские узлы в более сложных ассоциациях. Вы можете получить доступ к представлению rabl другого объекта данных, отрисовав RABL partial:```ruby
node :location do
  { :city => @city, :address => partial("users/address", :object => @address) }
end

или даже получить доступ к объекту, связанному с родительской моделью:```ruby node :location do |m| { :city => m.city, :address => partial("users/address", :object => m.address) } end

Вы можете использовать этот метод для создания произвольно сложных узлов для ваших API. Обратите внимание, что вам необходимо иметь шаблоны RABL, определенные для каждого из объектов, для которых вы хотите таким образом построить представления.

### Наследование ###

Еще одна распространенная проблема многих конструкторов шаблонов — избыточность кода. Обычно представления объекта в разных конечных точках имеют общие атрибуты или узлы. Узлы для объекта 'post', вероятно, одинаковы или похожи в большинстве ссылок на различные конечные точки.

RABL имеет возможность расширять другие "базовые" шаблоны rabl и дополнительные атрибуты:```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

Вы также можете расширять другие шаблоны rabl при построении дочерних узлов, чтобы уменьшить дублирование:```ruby

app/views/users/show.json.rabl

child @address do extends "address/item" end

Использование партиалов и наследования может значительно сократить дублирование кода в ваших шаблонах.

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

### Передача локальных переменных в партиалы ###

Вы можете передавать произвольный набор локальных переменных при рендеринге партиалов или расширении шаблонов.
Например, если мы хотим показывать в `posts/:id.json` любую информацию о конкретном посте и связанных комментариях,
но в других случаях скрывать эти комментарии. Мы можем использовать локальные переменные для этого:```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 })}

и затем получить доступ к локальным переменным в подшаблоне:```ruby

app/views/posts/show.json.rabl

object @post

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

Это может быть полезно как продвинутый инструмент при расширении или рендеринге партиалов.

### Область видимости шаблона ###

В RABL у вас есть доступ ко всему, что нужно для построения API-ответа. Каждый шаблон RABL имеет полный доступ к переменным экземпляра контроллеров, а также ко всем хелперам представлений и URL-адресам маршрутизации.```ruby
# app/some/template.rabl
object @post
# Access instance variables
child(@user => :user) { ... }
# or Rails helpers
node(:formatted_body) { |post| simple_format(post.body) }

Не должно быть проблем с получением соответствующих данных для построения ответа.

Глубокое вложение

В API часто возникает необходимость построения узлов 2-го или 3-го уровня. Предположим, у нас есть модель 'викторина', которая имеет много 'вопросов', и каждый вопрос имеет много 'ответов'. Мы можем отобразить эту иерархию в RABL довольно легко:```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

Это отобразит объект викторины с вложенными вопросами и ответами, как и ожидается для узла викторины, а также встроенные вопросы и ответы.
Обратите внимание, что RABL может быть вложен произвольно глубоко в дочерние узлы, чтобы позволить определить такие представления.

### Кэширование ###

RABL имеет встроенную поддержку кэширования для шаблонов, использующую стратегии фрагментарного кэширования. Обратите внимание, что кэширование в настоящее время **доступно только** для Rails, но поддержка других фреймворков планируется в будущем релизе. Простейшее использование кэширования:```ruby
# app/views/users/show.json.rabl
object @quiz
cache @quiz # key = rabl/quiz/[cache_key]
attribute :title

Кэширование может значительно ускорить рендеринг шаблонов RABL в продакшене и настоятельно рекомендуется, когда это возможно. Для более подробного ознакомления с кэшированием обратитесь к руководству Caching на вики.

Рендеринг шаблонов напрямую

Существуют ситуации, когда приложению требуется рендерить шаблоны RABL вне традиционного контекста представления. Например, для рендеринга RABL в задаче Rake или для создания полезной нагрузки очереди сообщений. В этом случае можно использовать Rabl.render, как показано ниже:```ruby Rabl.render(object, template, :view_path => 'app/views', :format => :json) #=> "{...json...}"

Вы также можете использовать вспомогательные методы на `Rabl::Renderer` для рендеринга объектов:```ruby
Rabl::Renderer.json(@post, 'posts/show')
Rabl::Renderer.xml(@post, 'posts/show')

Эти методы позволяют использовать RABL для произвольных преобразований объекта в нужный формат.```ruby Rabl::Renderer.new('posts/show', @post, :view_path => 'app/views', :format => 'hash').render

Вы также можете передавать другие переменные экземпляра для использования в вашем шаблоне как:```ruby
Rabl::Renderer.new('posts/show', @post, :locals => { :custom_title => "Hello world!" })

Затем, в вашем шаблоне, вы можете использовать @custom_title как:``` attribute :content node(:title) { @custom_title }

### Заголовки типа контента ###

В настоящее время в RABL тип контента вашего ответа не устанавливается автоматически. Это связано с тем, что RABL предназначен для работы с любым фреймворком на основе Rack и максимально независим от формата.
Ознакомьтесь с [этим вопросом](https://github.com/nesquena/rabl/issues/185#issuecomment-4501232) для получения дополнительной информации, и если у вас есть идеи или патчи, пожалуйста, сообщите мне.

Тем временем, не забудьте установить правильные типы контента при необходимости. Обычно это довольно просто как в Rails, так и в Padrino. Я рекомендую использовать before_filter в этом контроллере или указывать непосредственно в действии.

## Ресурсы ##

Существует множество ресурсов, связанных с RABL, включая [RABL Wiki](https://github.com/nesquena/rabl/wiki), а также множество учебных пособий и руководств, описанных ниже.
Вы также можете посетить [Сайт RABL](http://nesquena.github.com/rabl).

### Продвинутое использование ###

Ссылки на ресурсы для продвинутого использования:

 * [Управление сложностью](https://github.com/nesquena/rabl/wiki/Managing-complexity-with-presenters)
 * [Оптимизация для продакшена](https://github.com/nesquena/rabl/wiki/Rabl-In-Production)
 * [Интеграция с Grape](https://github.com/nesquena/rabl/wiki/Using-Rabl-with-Grape)
 * [Рендеринг JSON для древовидной структуры с помощью RABL](https://github.com/nesquena/rabl/issues/70)
 * [Макеты (erb, haml и rabl) в RABL](https://github.com/nesquena/rabl/wiki/Using-Layouts)
 * [Интеграция с Backbone или Ember.js](https://github.com/nesquena/rabl/wiki/Backbone-Integration)
 * [RABL с Rails Engines](https://github.com/nesquena/rabl/wiki/Setup-rabl-with-rails-engines)

Пожалуйста, добавляйте свои собственные варианты использования и сообщите мне, чтобы мы могли добавить их сюда! Также обязательно ознакомьтесь с [RABL Wiki](https://github.com/nesquena/rabl/wiki) для других примеров.

### Учебные пособия ###

Учебные пособия могут быть полезны для начала работы:

 * [Railscasts #322](http://railscasts.com/episodes/322-rabl) - Райан Бейтс объясняет RABL
 * [BackboneRails](http://www.backbonerails.com/) - Отличные скринкасты от Брайана Манна
 * [Создание API с RABL и 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

Дайте знать, если есть какие-либо другие полезные ресурсы, не перечисленные здесь.

### Связанные библиотеки ###

Существуют другие библиотеки, которые могут дополнить или расширить функциональность RABL:

 * [versioncake](https://github.com/bwillis/versioncake) - Отличная библиотека для легкого версионирования ваших RABL API
 * [gon](https://github.com/gazay/gon) - Предоставляет ваши переменные Rails в JavaScript со встроенной поддержкой RABL.
 * [rabl-rails](https://github.com/ccocchi/rabl-rails) - Реализация для RABL и Rails,
   [ориентированная на скорость](https://github.com/ccocchi/rabl-benchmark/blob/master/BENCHMARK).

Сообщите мне, если есть какие-либо другие связанные библиотеки, не перечисленные здесь.

### Устранение неполадок ###

 * [Избыточные вызовы для коллекции](https://github.com/nesquena/rabl/issues/142#issuecomment-2969107)
 * [Тестирование представлений RABL](https://github.com/nesquena/rabl/issues/130#issuecomment-4179285)

### Примеры ###

Смотрите директорию [examples](https://github.com/nesquena/rabl/tree/master/examples).

## Проблемы ##

Ознакомьтесь с вкладкой [Issues](https://github.com/nesquena/rabl/issues) для полного списка:

 * Тщательное бенчмаркинг и оптимизация производительности

## Авторы и участники ##

Спасибо [Miso](http://gomiso.com) за то, что позволили мне создать это для наших приложений и выпустить этот проект!

* [Nathan Esquenazi](https://github.com/nesquena) - Создатель проекта
* [Arthur Chiu](https://github.com/achiu) - Основной сопровождающий, гуру тестирования Riot
* [Tim Lee](https://github.com/timothy1ee) - RABL было отличным названием, выбранным CTO Miso.
* [David Sommers](https://github.com/databyte) - Разрешение шаблонов, поддержка кэширования и многое другое
* [Rick Thomas](https://github.com/rickthomasjr) - Добавил опции для extends и тестирование Sinatra
* [Benjamin Yu](https://github.com/byu) - Добавил поддержку формата msgpack
* [Chris Kimpton](https://github.com/kimptoc) - Помощь с документацией и вики
* [Marjun](https://github.com/mpagalan) - Добавил конфигурации параметров XML
* [Anton Orel](https://github.com/skyeagle) - Добавил совместимость с Rails 3.1
* [Sasha Koss](https://github.com/kossnocorp) - Добавил поддержку multi_json
* [Matthew Schulkind](https://github.com/mschulkind) - Очистка конфигурации и тестов
* [Luke van der Hoeven](https://github.com/plukevdh) - Поддержка не-ORM объектов в шаблонах
* [Andrey Voronkov](https://github.com/Antiarchitect) - Добавил поддержку формата BSON
* [Alli Witheford](https://github.com/alzeih) - Добавил поддержку формата Plist
* [Ryan Bigg](https://github.com/radar) - Улучшенный код разрешения шаблонов
* [Ivan Vanderbyl](https://github.com/ivanvanderbyl) - Добавил универсальный рендерер
* [Cyril Mougel](https://github.com/shingara) - Добавил подключаемую поддержку cache_engine и доработки рендерера
* [Teng Siong Ong](https://github.com/siong1987) - Улучшенный интерфейс рендерера
* [Brad Dunbar](https://github.com/braddunbar) - Передача текущего объекта в блоки

и многие другие участники, перечисленные в [CHANGELOG](https://github.com/nesquena/rabl/blob/master/CHANGELOG.md).

Хотите внести поддержку другого формата?
Ознакомьтесь с патчами для [msgpack](https://github.com/nesquena/rabl/pull/69), [plist](https://github.com/nesquena/rabl/pull/153) и
[BSON](https://github.com/nesquena/rabl/pull/163) для справки.

Пожалуйста, форкайте и участвуйте, любая помощь в улучшении этого проекта приветствуется!

Этот проект является членом [OSS Manifesto](http://ossmanifesto.org).

## Вдохновение ##

Несколько отличных библиотек помогли вдохновить RABL, и они перечислены ниже:

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

Спасибо еще раз за все эти отличные проекты.

## Авторские права ##

Copyright © 2011-2012 Nathan Esquenazi. Подробности см. в [MIT-LICENSE](https://github.com/nesquena/rabl/blob/master/MIT-LICENSE).

rabl-old

Популярное