Ruby on Rails 5.2 - ActionView::Helpers::UrlHelper

मॉड्यूल ActionView :: सहायक :: UrlHelper




ruby

मॉड्यूल ActionView :: सहायक :: UrlHelper

शामिल मॉड्यूल:
ActionView::Helpers::TagHelper

लिंक बनाने और यूआरएल प्राप्त करने के लिए तरीकों का एक सेट प्रदान करता है जो राउटिंग सबसिस्टम पर निर्भर करता है (देखें ActionDispatch::Routing )। यह आपको विचारों और नियंत्रकों में लिंक के लिए एक ही प्रारूप का उपयोग करने की अनुमति देता है।

स्थिरांक

BUTTON_TAG_METHOD_VERBS

इस सहायक को किसी भी वर्ग में शामिल किया जा सकता है, जिसमें मार्गों के URL हेल्पर (मार्गों.url_helpers) शामिल हैं। यहाँ प्रदान की गई कुछ विधियाँ केवल एक अनुरोध (link_to_unless_current, उदाहरण के लिए) के संदर्भ में काम करेंगी, जिसे संदर्भ में अनुरोध नामक विधि के रूप में प्रदान किया जाना चाहिए।

STRINGIFIED_COMMON_METHODS

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

button_to (नाम = nil, विकल्प = nil, html_options = nil, और ब्लॉक) दिखाएँ स्रोत
# File actionview/lib/action_view/helpers/url_helper.rb, line 300
def button_to(name = nil, options = nil, html_options = nil, &block)
  html_options, options = options, name if block_given?
  options      ||= {}
  html_options ||= {}
  html_options = html_options.stringify_keys

  url    = options.is_a?(String) ? options : url_for(options)
  remote = html_options.delete("remote")
  params = html_options.delete("params")

  method     = html_options.delete("method").to_s
  method_tag = BUTTON_TAG_METHOD_VERBS.include?(method) ? method_tag(method) : "".freeze.html_safe

  form_method  = method == "get" ? "get" : "post"
  form_options = html_options.delete("form") || {}
  form_options[:class] ||= html_options.delete("form_class") || "button_to"
  form_options[:method] = form_method
  form_options[:action] = url
  form_options[:'data-remote'] = true if remote

  request_token_tag = if form_method == "post"
    request_method = method.empty? ? "post" : method
    token_tag(nil, form_options: { action: url, method: request_method })
  else
    "".freeze
  end

  html_options = convert_options_to_data_attributes(options, html_options)
  html_options["type"] = "submit"

  button = if block_given?
    content_tag("button", html_options, &block)
  else
    html_options["value"] = name || url
    tag("input", html_options)
  end

  inner_tags = method_tag.safe_concat(button).safe_concat(request_token_tag)
  if params
    to_form_params(params).each do |param|
      inner_tags.safe_concat tag(:input, type: "hidden", name: param[:name], value: param[:value])
    end
  end
  content_tag("form", inner_tags, form_options)
end

एकल बटन वाला एक फॉर्म जनरेट करता है जो options के समूह द्वारा बनाए गए URL के लिए प्रस्तुत होता है। यह यह सुनिश्चित करने की सबसे सुरक्षित विधि है कि खोज बॉट या त्वरक द्वारा आपके डेटा में परिवर्तन का कारण नहीं बनता है। यदि HTML बटन आपके लेआउट के साथ काम नहीं करता है, तो आप link_to पद्धति का भी उपयोग कर सकते हैं :method link_to प्रलेखन में वर्णित :method संशोधक।

डिफ़ॉल्ट रूप से, जनरेट किए गए फॉर्म एलिमेंट में button_to का एक वर्ग का नाम होता है, जो फॉर्म और उसके बच्चों की स्टाइल की अनुमति देता है। :form_class भीतर :form_class संशोधक का उपयोग करके इसे बदला जा सकता है। आप html_options का उपयोग करके फ़ॉर्म सबमिशन और इनपुट तत्व व्यवहार को नियंत्रित कर सकते हैं। इस पद्धति को स्वीकार करता है :method link_to प्रलेखन में वर्णित :method संशोधक। यदि नहीं :method संशोधक दिया जाता है, तो यह POST ऑपरेशन करने के लिए डिफ़ॉल्ट होगा। आप निष्क्रिय होकर बटन को अक्षम भी कर सकते हैं disabled: true html_options में html_options । यदि आप Restful मार्गों का उपयोग कर रहे हैं, तो आप फॉर्म सबमिट करने के लिए उपयोग की जाने वाली HTTP क्रिया को बदलने के लिए :method पास कर सकते हैं।

विकल्प

options हैश url_for के समान विकल्पों को स्वीकार करता है।

कुछ विशेष html_options :

  • :method - HTTP क्रिया का Symbol । समर्थित क्रियाएं हैं :post :get :delete :patch , और :put । डिफ़ॉल्ट रूप से यह होगा :post

  • :disabled - यदि यह सच है, तो यह एक अक्षम बटन उत्पन्न करेगा।

  • :data - इस विकल्प का उपयोग कस्टम डेटा विशेषताओं को जोड़ने के लिए किया जा सकता है।

  • :remote - यदि सही पर सेट है, तो विनीत जावास्क्रिप्ट ड्राइवरों को सबमिट व्यवहार को नियंत्रित करने की अनुमति देगा। डिफ़ॉल्ट रूप से यह व्यवहार एक अजाक्स सबमिट है।

  • :form - यह हैश फॉर्म की विशेषताएं होंगी

  • :form_class - यह उस फॉर्म के वर्ग को नियंत्रित करता है जिसके भीतर सबमिट बटन रखा जाएगा

  • :params - प्रपत्र के भीतर छिपे हुए क्षेत्रों के रूप में प्रदान किए जाने वाले मापदंडों के Hash

डेटा विशेषताएँ

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

  • :disable_with - इस पैरामीटर के मूल्य को फॉर्म सबमिट करने पर सबमिट बटन के अक्षम संस्करण के मूल्य के रूप में उपयोग किया जाएगा। यह सुविधा विनीत जावास्क्रिप्ट चालक द्वारा दी गई है।

उदाहरण

<%= button_to "New", action: "new" %>
# => "<form method="post" action="/controller/new" class="button_to">
#      <input value="New" type="submit" />
#    </form>"

<%= button_to "New", new_articles_path %>
# => "<form method="post" action="/articles/new" class="button_to">
#      <input value="New" type="submit" />
#    </form>"

<%= button_to [:make_happy, @user] do %>
  Make happy <strong><%= @user.name %></strong>
<% end %>
# => "<form method="post" action="/users/1/make_happy" class="button_to">
#      <button type="submit">
#        Make happy <strong><%= @user.name %></strong>
#      </button>
#    </form>"

<%= button_to "New", { action: "new" }, form_class: "new-thing" %>
# => "<form method="post" action="/controller/new" class="new-thing">
#      <input value="New" type="submit" />
#    </form>"

<%= button_to "Create", { action: "create" }, remote: true, form: { "data-type" => "json" } %>
# => "<form method="post" action="/images/create" class="button_to" data-remote="true" data-type="json">
#      <input value="Create" type="submit" />
#      <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6"/>
#    </form>"

<%= button_to "Delete Image", { action: "delete", id: @image.id },
                                method: :delete, data: { confirm: "Are you sure?" } %>
# => "<form method="post" action="/images/delete/1" class="button_to">
#      <input type="hidden" name="_method" value="delete" />
#      <input data-confirm='Are you sure?' value="Delete Image" type="submit" />
#      <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6"/>
#    </form>"

<%= button_to('Destroy', 'http://www.example.com',
          method: "delete", remote: true, data: { confirm: 'Are you sure?', disable_with: 'loading...' }) %>
# => "<form class='button_to' method='post' action='http://www.example.com' data-remote='true'>
#       <input name='_method' value='delete' type='hidden' />
#       <input value='Destroy' type='submit' data-disable-with='loading...' data-confirm='Are you sure?' />
#       <input name="authenticity_token" type="hidden" value="10f2163b45388899ad4d5ae948988266befcb6c3d1b2451cf657a0c293d605a6"/>
#     </form>"
#
वर्तमान पृष्ठ? (विकल्प, check_parameters: false) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/url_helper.rb, line 543
def current_page?(options, check_parameters: false)
  unless request
    raise "You cannot use helpers that need to determine the current " \
          "page unless your view context provides a Request object " \
          "in a #request method"
  end

  return false unless request.get? || request.head?

  check_parameters ||= options.is_a?(Hash) && options.delete(:check_parameters)
  url_string = URI.parser.unescape(url_for(options)).force_encoding(Encoding::BINARY)

  # We ignore any extra parameters in the request_uri if the
  # submitted url doesn't have any either. This lets the function
  # work with things like ?order=asc
  # the behaviour can be disabled with check_parameters: true
  request_uri = url_string.index("?") || check_parameters ? request.fullpath : request.path
  request_uri = URI.parser.unescape(request_uri).force_encoding(Encoding::BINARY)

  if url_string.start_with?("/") && url_string != "/"
    url_string.chomp!("/")
    request_uri.chomp!("/")
  end

  if %r{^\w+://}.match?(url_string)
    url_string == "#{request.protocol}#{request.host_with_port}#{request_uri}"
  else
    url_string == request_uri
  end
end

सही है यदि वर्तमान अनुरोध URI दिए गए options द्वारा उत्पन्न किया गया था।

उदाहरण

मान लीजिए कि हम http://www.example.com/shop/checkout?order=desc&page=1 एक्शन में हैं।

current_page?(action: 'process')
# => false

current_page?(action: 'checkout')
# => true

current_page?(controller: 'library', action: 'checkout')
# => false

current_page?(controller: 'shop', action: 'checkout')
# => true

current_page?(controller: 'shop', action: 'checkout', order: 'asc')
# => false

current_page?(controller: 'shop', action: 'checkout', order: 'desc', page: '1')
# => true

current_page?(controller: 'shop', action: 'checkout', order: 'desc', page: '2')
# => false

current_page?('http://www.example.com/shop/checkout')
# => true

current_page?('http://www.example.com/shop/checkout', check_parameters: true)
# => false

current_page?('/shop/checkout')
# => true

current_page?('http://www.example.com/shop/checkout?order=desc&page=1')
# => true

मान लें कि हम अमान्य उत्पाद के मामले में विधि POST के साथ http://www.example.com/products कार्रवाई में हैं।

current_page?(controller: 'product', action: 'index')
# => false

हम तार के बजाय प्रतीक तर्कों में भी पारित कर सकते हैं।

options के सेट द्वारा बनाए गए URL का उपयोग करके दिए गए name का एक एंकर तत्व बनाता है। दस्तावेज़ में मान्य विकल्प url_for । विकल्प हैश के बजाय String को पास करना भी संभव है, जो एक एंकर तत्व उत्पन्न करता है जो लिंक के लिए String के मूल्य का उपयोग करता है। विकल्प हैश के बदले एक :back Symbol का उपयोग करने से रेफ़रर को एक लिंक उत्पन्न होगा (यदि कोई मौजूद नहीं है तो रेफ़र के स्थान पर जावास्क्रिप्ट बैक लिंक का उपयोग किया जाएगा)। यदि नाम के रूप में nil को पारित किया जाता है तो लिंक का मूल्य ही नाम बन जाएगा।

link_to(body, url, html_options = {})
  # url is a String; you can use URL helpers like
  # posts_path

link_to(body, url_options = {}, html_options = {})
  # url_options, except :method, is passed to url_for

link_to(options = {}, html_options = {}) do
  # name
end

link_to(url, html_options = {}) do
  # name
end
  • :data - इस विकल्प का उपयोग कस्टम डेटा विशेषताओं को जोड़ने के लिए किया जा सकता है।

  • method: symbol of HTTP verb - यह संशोधक गतिशील रूप से एक HTML फॉर्म तैयार करेगा और तुरंत निर्दिष्ट HTTP क्रिया का उपयोग करके प्रोसेसिंग के लिए फॉर्म सबमिट करेगा। लिंक को हटाने के लिए उपयोगी एक रिकॉर्ड को हटाने जैसे खतरनाक कार्यों में एक POST ऑपरेशन करते हैं (जो खोज बॉट आपकी साइट को रोकते समय अनुसरण कर सकते हैं)। समर्थित क्रियाएं हैं :post , :delete :patch , और :put । ध्यान दें कि यदि उपयोगकर्ता के पास जावास्क्रिप्ट अक्षम है, तो अनुरोध GET का उपयोग करके वापस आ जाएगा। यदि href: '#' का उपयोग किया जाता है और उपयोगकर्ता के पास जावास्क्रिप्ट अक्षम है तो लिंक पर क्लिक करने से कोई प्रभाव नहीं पड़ेगा। यदि आप POST व्यवहार पर भरोसा कर रहे हैं, तो आपको पोस्ट के लिए अनुरोध ऑब्जेक्ट के तरीकों का उपयोग करके अपने नियंत्रक की कार्रवाई में इसकी जांच करनी चाहिए post? , delete? , patch? , या put?

  • remote: true - यह विनीत जावास्क्रिप्ट ड्राइवर को लिंक का अनुसरण करने के बजाय सवाल में URL के लिए एक अजाक्स अनुरोध करने की अनुमति देगा। ड्राइवर प्रत्येक अजाक्स अनुरोध को पूरा करने और एक बार पूरा होने पर जावास्क्रिप्ट संचालन करने के लिए तंत्र प्रदान करते हैं

  • confirm: 'question?' - यह विनीत जावास्क्रिप्ट चालक को निर्दिष्ट प्रश्न के साथ संकेत करने की अनुमति देगा (इस मामले में, परिणामस्वरूप पाठ question? होगा question? यदि उपयोगकर्ता स्वीकार करता है, तो लिंक सामान्य रूप से संसाधित किया जाता है, अन्यथा कोई कार्रवाई नहीं की जाती है।

  • :disable_with - इस पैरामीटर का मान लिंक के अक्षम संस्करण के लिए नाम के रूप में उपयोग किया जाएगा। यह सुविधा विनीत जावास्क्रिप्ट चालक द्वारा दी गई है।

क्योंकि यह url_for पर निर्भर करता है, url_for पुराने शैली नियंत्रक / कार्रवाई / आईडी तर्क और नए RESTful मार्गों दोनों का समर्थन करता है। वर्तमान रेल शैली जब भी संभव हो, तब अनुकूल मार्गों की पक्षधर है, इसलिए संसाधनों और उपयोग पर अपने आवेदन को आधार बनाएं

link_to "Profile", profile_path(@profile)
# => <a href="/profiles/1">Profile</a>

या यहां तक ​​कि पिथियर

link_to "Profile", @profile
# => <a href="/profiles/1">Profile</a>

पुराने अधिक क्रिया के स्थान पर, गैर-संसाधन-उन्मुख

link_to "Profile", controller: "profiles", action: "show", id: @profile
# => <a href="/profiles/show/1">Profile</a>

इसी तरह,

link_to "Profiles", profiles_path
# => <a href="/profiles">Profiles</a>

से बेहतर है

link_to "Profiles", controller: "profiles"
# => <a href="/profiles">Profiles</a>

जब नाम nil तो इसके बजाय href प्रस्तुत किया जाता है

link_to nil, "http://example.com"
# => <a href="http://www.example.com">http://www.example.com</a>

यदि आप अपने लिंक लक्ष्य को नाम पैरामीटर में फिट करना कठिन है, तो आप एक ब्लॉक का उपयोग कर सकते हैं। ERB उदाहरण:

<%= link_to(@profile) do %>
  <strong><%= @profile.name %></strong> -- <span>Check it out!</span>
<% end %>
# => <a href="/profiles/1">
       <strong>David</strong> -- <span>Check it out!</span>
     </a>

सीएसएस के लिए कक्षाएं और आईडी का उत्पादन करना आसान है:

link_to "Articles", articles_path, id: "news", class: "article"
# => <a href="/articles" class="article" id="news">Articles</a>

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

link_to "Articles", { controller: "articles" }, id: "news", class: "article"
# => <a href="/articles" class="article" id="news">Articles</a>

हैश को छोड़ना गलत लिंक देता है:

link_to "WRONG!", controller: "articles", id: "news", class: "article"
# => <a href="/articles/index/news?class=article">WRONG!</a>

link_to भी लंगर या क्वेरी तार के साथ लिंक का उत्पादन कर सकते हैं:

link_to "Comment wall", profile_path(@profile, anchor: "wall")
# => <a href="/profiles/1#wall">Comment wall</a>

link_to "Ruby on Rails search", controller: "searches", query: "ruby on rails"
# => <a href="/searches?query=ruby+on+rails">Ruby on Rails search</a>

link_to "Nonsense search", searches_path(foo: "bar", baz: "quux")
# => <a href="/searches?foo=bar&amp;baz=quux">Nonsense search</a>

link_to ( :method ) के लिए विशिष्ट एकमात्र विकल्प निम्नानुसार उपयोग किया जाता है:

link_to("Destroy", "http://www.example.com", method: :delete)
# => <a href='http://www.example.com' rel="nofollow" data-method="delete">Destroy</a>

आप :data विकल्प का उपयोग करके कस्टम डेटा विशेषताओं का भी उपयोग कर सकते हैं:

link_to "Visit Other Site", "http://www.rubyonrails.org/", data: { confirm: "Are you sure?" }
# => <a href="http://www.rubyonrails.org/" data-confirm="Are you sure?">Visit Other Site</a>

इसके अलावा आप target , rel , type जैसी कोई भी लिंक विशेषताएँ सेट कर सकते हैं:

link_to "External link", "http://www.rubyonrails.org/", target: "_blank", rel: "nofollow"
# => <a href="http://www.rubyonrails.org/" target="_blank" rel="nofollow">External link</a>

यदि condition सत्य है, तो options के सेट द्वारा बनाए गए URL का उपयोग करके दिए गए name का लिंक टैग बनाता है, अन्यथा केवल नाम वापस किया जाता है। डिफ़ॉल्ट व्यवहार के विशेषज्ञ के लिए, आप एक ब्लॉक पास कर सकते हैं जो link_to_unless लिए नाम या पूर्ण तर्क सूची को स्वीकार करता है ( link_to_unless में उदाहरण देखें)।

<%= link_to_if(@current_user.nil?, "Login", { controller: "sessions", action: "new" }) %>
# If the user isn't logged in...
# => <a href="/sessions/new/">Login</a>

<%=
   link_to_if(@current_user.nil?, "Login", { controller: "sessions", action: "new" }) do
     link_to(@current_user.login, { controller: "accounts", action: "show", id: @current_user })
   end
%>
# If the user isn't logged in...
# => <a href="/sessions/new/">Login</a>
# If they are logged in...
# => <a href="/accounts/show/3">my_username</a>

options के सेट द्वारा बनाए गए URL का उपयोग करके दिए गए name का लिंक टैग तब तक बनाता है जब तक कि condition सत्य न हो, उस स्थिति में केवल नाम वापस कर दिया जाता है। डिफ़ॉल्ट व्यवहार के विशेषज्ञ (यानी, केवल प्लेनटेक्स्ट लिंक टेक्स्ट के बजाय एक लॉगिन लिंक दिखाएं), आप एक ब्लॉक पास कर सकते हैं जो link_to_unless लिए नाम या पूर्ण तर्क सूची को स्वीकार करता है।

<%= link_to_unless(@current_user.nil?, "Reply", { action: "reply" }) %>
# If the user is logged in...
# => <a href="/controller/reply/">Reply</a>

<%=
   link_to_unless(@current_user.nil?, "Reply", { action: "reply" }) do |name|
     link_to(name, { controller: "accounts", action: "signup" })
   end
%>
# If the user is logged in...
# => <a href="/controller/reply/">Reply</a>
# If not...
# => <a href="/accounts/signup">Reply</a>

किसी options के सेट द्वारा बनाए गए URL का उपयोग करके दिए गए name का लिंक टैग तब तक बनाता है जब तक कि वर्तमान अनुरोध URI लिंक के समान नहीं होता है, उस स्थिति में केवल नाम वापस कर दिया जाता है (या दिए गए ब्लॉक का उत्पादन होता है, यदि कोई मौजूद है)। आप link_to_unless_current एक ब्लॉक दे सकते हैं जो डिफ़ॉल्ट व्यवहार के विशेषज्ञ होंगे (उदाहरण के लिए, लिंक के पाठ के बजाय "यहां प्रारंभ करें" लिंक दिखाएं)।

मान लीजिए कि आपके पास एक नेविगेशन मेनू है ...

<ul id="navbar">
  <li><%= link_to_unless_current("Home", { action: "index" }) %></li>
  <li><%= link_to_unless_current("About Us", { action: "about" }) %></li>
</ul>

यदि "के बारे में" कार्रवाई में, यह प्रस्तुत करना होगा ...

<ul id="navbar">
  <li><a href="/controller/index">Home</a></li>
  <li>About Us</li>
</ul>

... लेकिन अगर "सूचकांक" कार्रवाई में, यह प्रस्तुत करना होगा:

<ul id="navbar">
  <li>Home</li>
  <li><a href="/controller/about">About Us</a></li>
</ul>

यदि वर्तमान क्रिया दी गई कार्रवाई है, तो link_to_unless_current को दिए गए निहित ब्लॉक का मूल्यांकन किया जाता है। इसलिए, अगर हमारे पास एक टिप्पणी पृष्ठ था और टिप्पणी पृष्ठ के लिंक के बजाय "गो बैक" लिंक प्रदान करना चाहता था, तो हम इसके लिए कुछ कर सकते थे ...

<%=
    link_to_unless_current("Comment", { controller: "comments", action: "new" }) do
       link_to("Go back", { controller: "posts", action: "index" })
    end
 %>
mail_to (email_address, name = nil, html_options = {}, और ब्लॉक) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/url_helper.rb, line 482
def mail_to(email_address, name = nil, html_options = {}, &block)
  html_options, name = name, nil if block_given?
  html_options = (html_options || {}).stringify_keys

  extras = %w{ cc bcc body subject reply_to }.map! { |item|
    option = html_options.delete(item).presence || next
    "#{item.dasherize}=#{ERB::Util.url_encode(option)}"
  }.compact
  extras = extras.empty? ? "".freeze : "?" + extras.join("&")

  encoded_email_address = ERB::Util.url_encode(email_address).gsub("%40", "@")
  html_options["href"] = "mailto:#{encoded_email_address}#{extras}"

  content_tag("a".freeze, name || email_address, html_options, &block)
end

एक mailto लिंक टैग निर्दिष्ट email_address लिए बनाता है, जिसका उपयोग लिंक के नाम के रूप में भी किया जाता है जब तक कि name निर्दिष्ट नहीं किया जाता है। लिंक के लिए अतिरिक्त HTML विशेषताएँ html_options में पारित की जा सकती हैं।

mail_to पास mail_to लिए विशेष कुंजी पारित करके ईमेल को अनुकूलित करने के कई तरीके हैं।

विकल्प

  • :subject - ईमेल की विषय पंक्ति पूर्व निर्धारित करें।

  • :body - ईमेल का बॉडी प्रीसेट करें।

  • :cc - कार्बन ईमेल पर अतिरिक्त प्राप्तकर्ताओं की प्रतिलिपि बनाएँ।

  • :bcc - ब्लाइंड कार्बन ईमेल पर अतिरिक्त प्राप्तकर्ताओं को कॉपी करें।

  • :reply_to - ईमेल के उत्तर-प्रति क्षेत्र को निर्धारित करें।

कहानियो

रेल 4.0 से पहले, mail_to ईमेल हार्वेस्टर में बाधा डालने के लिए पता एन्कोडिंग के लिए विकल्प प्रदान करता है। इन विकल्पों का लाभ उठाने के लिए, actionview-encoded_mail_to मणि स्थापित करें।

उदाहरण

mail_to "[email protected]"
# => <a href="mailto:[email protected]">[email protected]</a>

mail_to "[email protected]", "My email"
# => <a href="mailto:[email protected]">My email</a>

mail_to "[email protected]", "My email", cc: "[email protected]",
         subject: "This is an example email"
# => <a href="mailto:[email protected][email protected]&subject=This%20is%20an%20example%20email">My email</a>

यदि आप अपने लिंक लक्ष्य को नाम पैरामीटर में फिट करना कठिन है, तो आप एक ब्लॉक का उपयोग कर सकते हैं। ERB उदाहरण:

<%= mail_to "[email protected]" do %>
  <strong>Email me:</strong> <span>[email protected]</span>
<% end %>
# => <a href="mailto:[email protected]">
       <strong>Email me:</strong> <span>[email protected]</span>
     </a>