RABL

RABL (Ruby API Builder Language) एक Rails और Padrino रूबी टेम्पलेटिंग सिस्टम है जो JSON, XML, MessagePack, PList और BSON उत्पन्न करने के लिए है। ActiveRecord की 'to_json' विधि का उपयोग करते समय, मैं API उत्पन्न करने के लिए एक अधिक अभिव्यक्तिशील और शक्तिशाली समाधान चाहता हूँ। यह विशेष रूप से तब सत्य है जब JSON प्रतिनिधित्व जटिल हो या डेटाबेस में परिभाषित सटीक स्कीमा से मेल न खाता हो।

विशेष रूप से, मैं आसानी से निम्नलिखित करना चाहता हूँ:

किसी वस्तु में डेटा को मिलाकर नामित मनमाने नोड बनाएँ
विधियों को तर्क पास करें और परिणाम को चाइल्ड नोड के रूप में संग्रहीत करें
कोड दोहराव को कम करने के लिए आंशिक टेम्पलेट प्रस्तुत करें और विरासत प्राप्त करें
मॉडल से नाम बदलने के लिए विशेषताओं का नाम बदलें या उपनाम दें
चाइल्ड से पैरेंट नोड में विशेषताएँ जोड़ें
केवल तभी नोड शामिल करें जब कोई निश्चित शर्त पूरी हुई हो

जिस किसी ने भी JSON प्रतिक्रिया उत्पन्न करने के लिए ActiveRecord में उपयोग की जाने वाली 'to_json' विधि का प्रयास किया है, उसने इस प्रतिबंधात्मक दृष्टिकोण का दर्द महसूस किया है। RABL एक सामान्य टेम्पलेटिंग सिस्टम है जो API प्रतिक्रिया पीढ़ी को पूरी तरह से नए तरीके से संबोधित करके इन समस्याओं को हल करने के लिए बनाया गया है।

RABL मूल रूप से MVC सिद्धांतों का पालन करने के बारे में है, API डेटा प्रस्तुतियों को आपके एप्लिकेशन के view परत पर स्थानांतरित करके। RABL के बारे में सामान्य गलतफहमियों के विवरण के लिए, कृपया RABL को समझना मार्गदर्शिका देखें, जो इस परियोजना के बारे में किसी भी भ्रम को दूर करने में मदद कर सकती है।

महत्वपूर्ण परिवर्तन

v0.8.0 (14 फरवरी 2013 को जारी) multi_json निर्भरता हटाता है और json पार्सर के रूप में Oj (या JSON) पर निर्भर करता है। कोड को सरल बनाता है, एक निर्भरता हटाता है लेकिन आप MultiJson के किसी भी संदर्भ को हटाना चाह सकते हैं।
v0.6.14 (28 जून 2012 को जारी) टेम्पलेट का परीक्षण करने के लिए RSpec के साथ render_views के उपयोग की आवश्यकता है। अन्यथा, नियंत्रक केवल रेंडर कमांड को पास कर देगा जैसे वह ERB टेम्पलेट्स के साथ करता है।

स्थापना

Install RABL as a gem:``` 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 gem आपकी Gemfile में padrino gem के बाद सूचीबद्ध है, अन्यथा Rabl टेम्पलेट इंजन के रूप में ठीक से पंजीकृत नहीं होगा।

Sinatra, या किसी अन्य टिल्ट-आधारित फ्रेमवर्क के साथ, बस पंजीकृत करें:```ruby Rabl.register!

और RABL आरंभ होकर उपयोग के लिए तैयार होगा। Sinatra के साथ उपयोग के लिए, [Sinatra Usage](https://github.com/nesquena/rabl/wiki/Setup-for-Sinatra) गाइड देखें।

## अवलोकन ##

आप RABL का उपयोग किसी भी रूबी ऑब्जेक्ट से JSON और XML आधारित API उत्पन्न करने के लिए कर सकते हैं।
RABL के साथ, डेटा आमतौर पर मुख्य रूप से मॉडल (ORM-agnostic) से लिया जाता है और API आउटपुट का प्रतिनिधित्व एक साधारण रूबी 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

फिर हम @posts के API आउटपुट को व्यक्त करने के लिए निम्नलिखित RABL टेम्पलेट बना सकते हैं:```ruby

app/views/posts/index.rabl

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

जो `http://localhost:3000/posts.json` पर जाने पर निम्नलिखित JSON या XML आउटपुट करेगा```js
[{  "post" :
  {
    "id" : 5, title: "...", subject: "...",
    "user" : { full_name : "..." },
    "read" : true
  }
}]

यह एक बुनियादी अवलोकन है लेकिन देखने के लिए बहुत कुछ है जैसे कि partials, inheritance, custom nodes, आदि। नीचे 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` इनकमिंग अनुरोध में 'callback' पैरामीटर होने पर 'jsonp' शैली कॉलबैक आउटपुट के लिए समर्थन सक्षम करता है।

यदि `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 के भीतर की कोई भी चीज़ भी अलग से कैश की जाएगी। केवल एकल टेम्पलेट को कैश करने के लिए, नीचे 'Caching' शीर्षक वाला अनुभाग देखें।

यदि `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` पर सेट किया जाता है, तो जब भी Rabl किसी ऐसी विशेषता को रेंडर करने का प्रयास करता है जो मौजूद नहीं है, तो एक RuntimeError उठाया जाएगा। अन्यथा, विशेषता को केवल छोड़ दिया जाएगा। विकास के दौरान इसे true पर सेट करने से आपके कोड की मजबूती बढ़ाने में मदद मिल सकती है, लेकिन उत्पादन कोड में `true` का उपयोग करने की अनुशंसा नहीं की जाती है।

यदि `replace_nil_values_with_empty_strings` को `true` पर सेट किया जाता है, तो सभी मान जो `nil` हैं और सामान्यतः प्रतिक्रिया में `null` के रूप में प्रदर्शित होंगे, खाली स्ट्रिंग में परिवर्तित हो जाते हैं।

यदि आप प्राथमिक JSON एन्कोडिंग इंजन के रूप में [oj](https://github.com/ohler55/oj) का उपयोग करना चाहते हैं तो बस उसे अपने Gemfile में जोड़ें:```ruby
# Gemfile
gem 'oj'

और RABL आपके JSON प्रतिक्रियाओं को एनकोड करने के लिए स्वचालित रूप से उस इंजन का उपयोग करेगा। अपना स्वयं का कस्टम json_engine सेट करें जो ruby डेटा से JSON में रूपांतरण के लिए dump या encode विधि को परिभाषित करता है:```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' पर सेट किया जा सकता है और नोड्स को स्वतंत्र रूप में बनाया जा सकता है।

Attributes

टेम्पलेटर का मूल उपयोग प्रतिक्रिया के लिए कुछ सरल विशेषताएँ परिभाषित करने के लिए:```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

आप child node के लिए object root को भी disable कर सकते हैं:```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? }

कस्टम नोड्स

यह node ब्लॉक के परिणाम के आधार पर एक json प्रतिक्रिया उत्पन्न करेगा:```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

या कोई नाम पास न करें और node block को response में विलय कर दें:```ruby node do |u| { :full_name => u.first_name + " " + u.last_name }

=> { full_name : "Bob Johnson" }

end

आप अपने मॉडल के सभी डेटा का उपयोग करके एक मान का लचीला प्रतिनिधित्व बनाने के लिए इस प्रकार के कस्टम नोड्स का उपयोग कर सकते हैं।

### आंशिक ###

अक्सर आपको अधिक जटिल संबंधों में कस्टम नोड्स बनाने के लिए अन्य डेटा ऑब्जेक्ट्स तक पहुंचने की आवश्यकता होती है। आप एक RABL आंशिक रेंडर करके किसी अन्य डेटा ऑब्जेक्ट के rabl प्रतिनिधित्व तक पहुंच प्राप्त कर सकते हैं:```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 टेम्पलेट्स परिभाषित होने चाहिए
जिनके लिए आप इस तरह से प्रतिनिधित्व बनाना चाहते हैं।

### Inheritance ###

कई टेम्पलेट बिल्डरों की एक और सामान्य समस्या अनावश्यक कोड पुनरावृत्ति है। आमतौर पर कई एंडपॉइंट्स पर एक वस्तु के कई प्रतिनिधित्व सामान्य विशेषताओं या नोड्स को साझा करते हैं। 'post' ऑब्जेक्ट के नोड्स संभवतः विभिन्न एंडपॉइंट्स में अधिकांश संदर्भों में समान या समान होते हैं।

RABL में अन्य "base" 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 templates का भी विस्तार कर सकते हैं:```ruby

app/views/users/show.json.rabl

child @address do extends "address/item" end

आंशिक टेम्पलेट्स और इनहेरिटेंस का उपयोग करके आप अपने टेम्पलेट्स में कोड डुप्लिकेशन को काफी हद तक कम कर सकते हैं।

आप [Reusing Templates wiki page](https://github.com/nesquena/rabl/wiki/Reusing-templates) पर और उदाहरण देख सकते हैं।

### आंशिक में स्थानीय चर (Locals) पास करना ###

आप आंशिक टेम्पलेट्स को रेंडर करते समय या टेम्पलेट्स का विस्तार करते समय स्थानीय चर (locals) का एक मनमाना सेट पास कर सकते हैं।
उदाहरण के लिए, यदि हम `posts/:id.json` पर किसी विशेष पोस्ट और संबंधित टिप्पणियों के बारे में कोई जानकारी दिखाना चाहते हैं लेकिन अन्य मामलों में हम उन टिप्पणियों को छिपाना चाहते हैं। हम ऐसा करने के लिए स्थानीय चर (locals) का उपयोग कर सकते हैं:```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 })}

और फिर उप-टेम्पलेट में locals को एक्सेस करें:```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) }

प्रतिक्रिया बनाने के लिए उपयुक्त डेटा प्राप्त करने में कोई समस्या नहीं होनी चाहिए।

गहरी नेस्टिंग

एपीआई में, अक्सर आपको दूसरे या तीसरे स्तर के नोड बनाने की आवश्यकता हो सकती है। मान लीजिए हमारे पास एक 'quiz' मॉडल है जिसमें कई 'questions' हैं और फिर प्रत्येक प्रश्न में कई 'answers' हैं। हम इस पदानुक्रम को 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 टेम्पलेट्स के रेंडरिंग को काफी तेज कर सकती है और जब संभव हो तो इसकी दृढ़ता से अनुशंसा की जाती है। कैशिंग के बारे में अधिक विस्तृत जानकारी के लिए, विकी पर कैशिंग गाइड देखें।

टेम्पलेट्स को सीधे रेंडर करना

ऐसी स्थितियाँ होती हैं जहाँ किसी एप्लिकेशन को पारंपरिक व्यू संदर्भ के बाहर RABL टेम्पलेट्स को रेंडर करने की आवश्यकता होती है। उदाहरण के लिए, Rake कार्य के भीतर RABL को रेंडर करना या संदेश कतार (message queue) पेलोड बनाना। ऐसे मामले में, 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 में, आपकी प्रतिक्रिया का content-type स्वचालित रूप से सेट नहीं होता है। ऐसा इसलिए है क्योंकि RABL किसी भी Rack-आधारित ढांचे के लिए काम करने और प्रारूप के प्रति यथासंभव अज्ञेय होने का इरादा रखता है। अधिक विवरण के लिए [इस मुद्दे](https://github.com/nesquena/rabl/issues/185#issuecomment-4501232) की जाँच करें, और यदि आपके पास कोई विचार या पैच हैं तो कृपया मुझे बताएं।

इस बीच, यदि आवश्यक हो तो उचित content-types सेट करना सुनिश्चित करें। यह आमतौर पर Rails और Padrino दोनों में काफी सरल है। मैं उस कंट्रोलर पर before_filter या सीधे किसी एक्शन में निर्दिष्ट करने की सलाह देता हूं।

## संसाधन ##

RABL से संबंधित कई संसाधन उपलब्ध हैं, जिनमें [RABL Wiki](https://github.com/nesquena/rabl/wiki) और नीचे विस्तृत कई ट्यूटोरियल और गाइड शामिल हैं। आप [RABL Site](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)
 * [RABL का उपयोग करके ट्री संरचना के लिए JSON रेंडर करना](https://github.com/nesquena/rabl/issues/70)
 * [RABL में लेआउट (erb, haml और rabl)](https://github.com/nesquena/rabl/wiki/Using-Layouts)
 * [Backbone या Ember.js एकीकरण](https://github.com/nesquena/rabl/wiki/Backbone-Integration)
 * [Rails Engines के साथ RABL](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) - Ryan Bates RABL समझाते हैं
 * [BackboneRails](http://www.backbonerails.com/) - Brian Mann द्वारा बेहतरीन स्क्रीनकास्ट
 * [RABL और Padrino के साथ API बनाना](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 APIs को आसानी से वर्शन करने के लिए उत्कृष्ट लाइब्रेरी
 * [gon](https://github.com/gazay/gon) - RABL समर्थन के साथ आपके Rails वेरिएबल्स को JS में उजागर करता है।
 * [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)

### उदाहरण ###

[उदाहरण](https://github.com/nesquena/rabl/tree/master/examples) निर्देशिका देखें।

## मुद्दे ##

पूरी सूची के लिए [मुद्दे](https://github.com/nesquena/rabl/issues) टैब देखें:

 * कठोर बेंचमार्किंग और प्रदर्शन अनुकूलन

## लेखक और योगदानकर्ता ##

[Miso](http://gomiso.com) का धन्यवाद जिसने मुझे हमारे अनुप्रयोगों के लिए इसे बनाने और इस परियोजना को जारी करने की अनुमति दी!

* [Nathan Esquenazi](https://github.com/nesquena) - परियोजना के निर्माता
* [Arthur Chiu](https://github.com/achiu) - मुख्य अनुरक्षक, Riot Testing गुरु
* [Tim Lee](https://github.com/timothy1ee) - RABL एक महान नाम था जिसे Miso CTO ने चुना।
* [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 support](https://github.com/nesquena/rabl/pull/69), [plist support](https://github.com/nesquena/rabl/pull/153) और [BSON support](https://github.com/nesquena/rabl/pull/163) के पैच देखें।

कृपया fork करें और योगदान दें, इस परियोजना को बेहतर बनाने में कोई भी मदद सराहनीय है!

यह परियोजना [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)

इन सभी महान परियोजनाओं के लिए फिर से धन्यवाद।

## कॉपीराइट ##

कॉपीराइट © 2011-2012 Nathan Esquenazi। विवरण के लिए [MIT-LICENSE](https://github.com/nesquena/rabl/blob/master/MIT-LICENSE) देखें।

rabl-old

सबसे लोकप्रिय