Ruby on Rails 5.2 - ActionView::PartialRenderer

क्लास एक्शन व्यू :: PartialRenderer




ruby

क्लास एक्शन व्यू :: PartialRenderer

जनक:
ActionView :: AbstractRenderer

एक्शन व्यू पार्टिकल्स

वर्तमान नियंत्रक के भीतर उप टेम्प्लेट को प्रस्तुत करने के लिए एक सुविधा विधि भी है जो किसी एकल ऑब्जेक्ट पर निर्भर करती है (हम इस तरह के उप टेम्पलेट्स को भाग के लिए कहते हैं)। यह इस तथ्य पर निर्भर करता है कि भाग को एक अंडरस्कोर के साथ उपसर्ग होने के नामकरण सम्मेलन का पालन करना चाहिए - जैसा कि उन्हें नियमित टेम्पलेट्स से अलग करना है जो उनके दम पर प्रदान किए जा सकते हैं।

विज्ञापनदाता # खाते के लिए एक टेम्पलेट में:

<%= render partial: "account" %>

यह "विज्ञापनदाता / _account.html.erb" प्रस्तुत करेगा।

विज्ञापनदाता # खरीदने के लिए एक अन्य टेम्पलेट में, हम कर सकते हैं:

<%= render partial: "account", locals: { account: @buyer } %>

<% @advertisements.each do |ad| %>
  <%= render partial: "ad", locals: { ad: ad } %>
<% end %>

यह पहले advertiser/_account.html.erb को स्थानीय वेरिएबल account रूप में पास करने वाले advertiser/_account.html.erb साथ प्रस्तुत करेगा, फिर advertiser/_ad.html.erb प्रस्तुत advertiser/_ad.html.erb और प्रदर्शन के लिए टेम्प्लेट में स्थानीय वैरिएबल ad पास करेगा।

: के रूप में और: वस्तु विकल्प

डिफ़ॉल्ट रूप से ActionView::PartialRenderer का कोई स्थानीय चर नहीं है। :object विकल्प का उपयोग आंशिक वस्तु को पास करने के लिए किया जा सकता है। उदाहरण के लिए:

<%= render partial: "account", object: @buyer %>

स्थानीय चर account तहत उपलब्ध आंशिक @buyer वस्तु प्रदान करेगा, और इसके बराबर है:

<%= render partial: "account", locals: { account: @buyer } %>

के साथ :as विकल्प के :as हम स्थानीय चर के लिए एक अलग नाम निर्दिष्ट कर सकते हैं। उदाहरण के लिए, यदि हम चाहते थे कि हम account बजाय user बनें तो हम ऐसा करेंगे:

<%= render partial: "account", object: @buyer, as: 'user' %>

इसके बराबर है

<%= render partial: "account", locals: { user: @buyer } %>

भागमभाग का संग्रह प्रस्तुत करना

आंशिक उपयोग का उदाहरण एक परिचित पैटर्न का वर्णन करता है जहां एक टेम्पलेट को एक सरणी पर पुनरावृत्त करने और प्रत्येक तत्वों के लिए एक उप टेम्पलेट को प्रस्तुत करने की आवश्यकता होती है। इस पैटर्न को एक एकल विधि के रूप में लागू किया गया है जो एक सरणी को स्वीकार करता है और उसी नाम से आंशिक रूप से प्रस्तुत करता है जैसे कि भीतर मौजूद तत्व। इसलिए "भाग का उपयोग करना" में तीन-पंक्ति वाले उदाहरण को एक पंक्ति के साथ फिर से लिखा जा सकता है:

<%= render partial: "ad", collection: @advertisements %>

यह advertiser/_ad.html.erb को प्रस्तुत करेगा और प्रदर्शन के लिए टेम्पलेट में स्थानीय चर ad पास करेगा। प्रपत्र partial_name_iteration नाम के साथ एक पुनरावृत्ति ऑब्जेक्ट स्वचालित रूप से टेम्पलेट को उपलब्ध कराया जाएगा। पुनरावृति वस्तु के बारे में ज्ञान होता है कि संग्रह में वर्तमान वस्तु किस सूचकांक में है और संग्रह का कुल आकार। पुनरावृति ऑब्जेक्ट में दो सुविधा विधियां भी हैं, first? और last? । उपरोक्त उदाहरण के मामले में, टेम्पलेट को ad_iteration खिलाया ad_iteration । पश्चगामी संगतता के लिए partial_name_counter अभी भी मौजूद है और इसे पुनरावृत्ति की index विधि में मैप किया गया है।

:as विकल्प के :as उपयोग किया जा सकता है जब विभाजन प्रदान करते हैं।

आप :spacer_template विकल्प के माध्यम से तत्वों के बीच प्रदान की जाने वाली एक आंशिक निर्दिष्ट कर सकते हैं। निम्न उदाहरण प्रत्येक विज्ञापन आंशिक के बीच advertiser/_ad_divider.html.erb को प्रस्तुत करेगा:

<%= render partial: "ad", collection: @advertisements, spacer_template: "ad_divider" %>

यदि दिया गया :collection nil या खाली है, तो render nil वापस आ जाएगा। यह आपको एक पाठ निर्दिष्ट करने की अनुमति देगा जो इस फ़ॉर्म का उपयोग करके प्रदर्शित किया जाएगा:

<%= render(partial: "ad", collection: @advertisements) || "There's no ad to be displayed" %>

नोट: पश्चगामी संगतता चिंताओं के कारण, संग्रह हैश में से एक नहीं हो सकता है। आम तौर पर आप भी डोमेन ऑब्जेक्ट्स को सक्रिय अभिलेखों की तरह रखेंगे, वहां।

साझा किए जाने वाले भाग का प्रतिपादन

दो नियंत्रकों में एक सेट को साझा करना और उन्हें इस तरह प्रस्तुत करना है:

<%= render partial: "advertisement/ad", locals: { ad: @advertisement } %>

यह आंशिक advertisement/_ad.html.erb प्रस्तुत करेगा, इस advertisement/_ad.html.erb परवाह किए बिना कि यह किस नियंत्रक से कहा जा रहा है।

रेंडरिंग ऑब्जेक्ट्स जो to_partial_path प्रतिक्रिया to_partial_path

आंशिक रूप से स्थान का नामकरण करने के बजाय, आप ActionView::PartialRenderer को काम करने दे सकते हैं और to_partial_path विधि की जाँच करके उचित पथ चुन सकते हैं।

# @account.to_partial_path returns 'accounts/account', so it can be used to replace:
# <%= render partial: "accounts/account", locals: { account: @account} %>
<%= render partial: @account %>

# @posts is an array of Post instances, so every post record returns 'posts/post' on +to_partial_path+,
# that's why we can replace:
# <%= render partial: "posts/post", collection: @posts %>
<%= render partial: @posts %>

डिफ़ॉल्ट मामले का प्रतिपादन

यदि आप संग्रह या लेआउट जैसे किसी भी विकल्प का उपयोग नहीं करने जा रहे हैं, तो आप आंशिक रेंडर करने के लिए रेंडर के शॉर्ट-हैंड डिफॉल्ट का भी उपयोग कर सकते हैं। उदाहरण:

# Instead of <%= render partial: "account" %>
<%= render "account" %>

# Instead of <%= render partial: "account", locals: { account: @buyer } %>
<%= render "account", account: @buyer %>

# @account.to_partial_path returns 'accounts/account', so it can be used to replace:
# <%= render partial: "accounts/account", locals: { account: @account} %>
<%= render @account %>

# @posts is an array of Post instances, so every post record returns 'posts/post' on +to_partial_path+,
# that's why we can replace:
# <%= render partial: "posts/post", collection: @posts %>
<%= render @posts %>

लेआउट के साथ भाग देना

धारावाहिकों के लिए उनके स्वयं के लेआउट लागू हो सकते हैं। ये लेआउट पूरी कार्रवाई के लिए वैश्विक स्तर पर निर्दिष्ट लोगों की तुलना में अलग हैं, लेकिन वे इसी तरह से काम करते हैं। दो प्रकार के उपयोगकर्ताओं के साथ एक सूची की कल्पना करें:

<%# app/views/users/index.html.erb %>
Here's the administrator:
<%= render partial: "user", layout: "administrator", locals: { user: administrator } %>

Here's the editor:
<%= render partial: "user", layout: "editor", locals: { user: editor } %>

<%# app/views/users/_user.html.erb %>
Name: <%= user.name %>

<%# app/views/users/_administrator.html.erb %>
<div id="administrator">
  Budget: $<%= user.budget %>
  <%= yield %>
</div>

<%# app/views/users/_editor.html.erb %>
<div id="editor">
  Deadline: <%= user.deadline %>
  <%= yield %>
</div>

... यह लौटेगा:

Here's the administrator:
<div id="administrator">
  Budget: $<%= user.budget %>
  Name: <%= user.name %>
</div>

Here's the editor:
<div id="editor">
  Deadline: <%= user.deadline %>
  Name: <%= user.name %>
</div>

यदि एक संग्रह दिया जाता है, तो संग्रह में प्रत्येक आइटम के लिए एक बार लेआउट प्रदान किया जाएगा। उदाहरण के लिए, इन दो स्निपेट का एक ही आउटपुट है:

<%# app/views/users/_user.html.erb %>
Name: <%= user.name %>

<%# app/views/users/index.html.erb %>
<%# This does not use layouts %>
<ul>
  <% users.each do |user| -%>
    <li>
      <%= render partial: "user", locals: { user: user } %>
    </li>
  <% end -%>
</ul>

<%# app/views/users/_li_layout.html.erb %>
<li>
  <%= yield %>
</li>

<%# app/views/users/index.html.erb %>
<ul>
  <%= render partial: "user", layout: "li_layout", collection: users %>
</ul>

दो उपयोगकर्ताओं को, जिनके नाम एलिस और बॉब हैं, इन स्निपेट्स को वापस लौटाते हैं:

<ul>
  <li>
    Name: Alice
  </li>
  <li>
    Name: Bob
  </li>
</ul>

वर्तमान वस्तु का प्रतिपादन किया जा रहा है, साथ ही object_counter, लेआउट के अंदर स्थानीय चर के रूप में उपलब्ध होगा, जो आंशिक रूप में उपलब्ध समान नामों के तहत है।

आप किसी भी टेम्प्लेट में किसी ब्लॉक में एक लेआउट लागू कर सकते हैं:

<%# app/views/users/_chief.html.erb %>
<%= render(layout: "administrator", locals: { user: chief }) do %>
  Title: <%= chief.title %>
<% end %>

... यह लौटेगा:

<div id="administrator">
  Budget: $<%= user.budget %>
  Title: <%= chief.name %>
</div>

जैसा कि आप देख सकते हैं :locals हैश को आंशिक और उसके लेआउट दोनों के बीच साझा किया गया है।

यदि आप "उपज" के लिए तर्क पारित करते हैं तो यह ब्लॉक में पारित किया जाएगा। इसका उपयोग करने का एक तरीका यह है कि किसी सरणी को लेआउट के लिए पास किया जाए और इसे एक गणना योग्य माना जाए।

<%# app/views/users/_user.html.erb %>
<div class="user">
  Budget: $<%= user.budget %>
  <%= yield user %>
</div>

<%# app/views/users/index.html.erb %>
<%= render layout: @users do |user| %>
  Title: <%= user.title %>
<% end %>

यह प्रत्येक उपयोगकर्ता के लिए लेआउट को प्रस्तुत करेगा और प्रत्येक बार, उपयोगकर्ता को पास करने के लिए ब्लॉक को देगा।

आप एक लेआउट में कई बार उपज दे सकते हैं और खंडों को अलग करने के लिए ब्लॉक तर्क का उपयोग कर सकते हैं।

<%# app/views/users/_user.html.erb %>
<div class="user">
  <%= yield user, :header %>
  Budget: $<%= user.budget %>
  <%= yield user, :footer %>
</div>

<%# app/views/users/index.html.erb %>
<%= render layout: @users do |user, section| %>
  <%- case section when :header -%>
    Title: <%= user.title %>
  <%- when :footer -%>
    Deadline: <%= user.deadline %>
  <%- end -%>
<% end %>

स्थिरांक

IDENTIFIER_ERROR_MESSAGE
OPTION_AS_ERROR_MESSAGE
PREFIXED_PARTIAL_NAMES

पब्लिक क्लास के तरीके

# File actionview/lib/action_view/renderer/partial_renderer.rb, line 292
def initialize(*)
  super
  @context_prefix = @lookup_context.prefixes.first
end
सुपरक्लास विधि कहता है

सार्वजनिक प्रवृत्ति के तरीके

रेंडर (संदर्भ, विकल्प, ब्लॉक) स्रोत दिखाएं
# File actionview/lib/action_view/renderer/partial_renderer.rb, line 297
def render(context, options, block)
  setup(context, options, block)
  @template = find_partial

  @lookup_context.rendered_format ||= begin
    if @template && @template.formats.present?
      @template.formats.first
    else
      formats.first
    end
  end

  if @collection
    render_collection
  else
    render_partial
  end
end