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

मॉड्यूल एक्शन व्यू :: हेल्पर्स :: टेक्स्ट हेल्पर




ruby

मॉड्यूल एक्शन व्यू :: हेल्पर्स :: टेक्स्ट हेल्पर

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

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

स्वच्छता

HTML आउटपुट उत्पन्न करने वाले अधिकांश पाठ सहायक डिफ़ॉल्ट रूप से दिए गए इनपुट को सुरक्षित करते हैं, लेकिन इससे बचते नहीं हैं। इसका अर्थ है कि पृष्ठ में HTML टैग दिखाई देंगे लेकिन सभी दुर्भावनापूर्ण कोड हटा दिए जाएंगे। आइए simple_format पद्धति का उपयोग करते हुए कुछ उदाहरण देखें:

simple_format('<a href="http://example.com/">Example</a>')
# => "<p><a href=\"http://example.com/\">Example</a></p>"

simple_format('<a href="javascript:alert(\'no!\')">Example</a>')
# => "<p><a>Example</a></p>"

यदि आप सभी सामग्री से बचना चाहते हैं, तो आपको पाठ सहायक को कॉल करने से पहले h विधि को लागू करना चाहिए।

simple_format h('<a href="http://example.com/">Example</a>')
# => "<p>&lt;a href=\"http://example.com/\"&gt;Example&lt;/a&gt;</p>"

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

# File actionview/lib/action_view/helpers/text_helper.rb, line 54
def concat(string)
  output_buffer << string
end

आपके विचारों में पाठ के आउटपुट का पसंदीदा तरीका <% = "पाठ"%> eRuby सिंटैक्स का उपयोग करना है। ईआरबी कोड ब्लॉक में अपेक्षा के अनुसार नियमित पुट और प्रिंट विधि संचालित नहीं होती है। यदि आप बिल्कुल नॉन-आउटपुट कोड ब्लॉक (यानी <%%>) के भीतर पाठ को आउटपुट करना चाहते हैं, तो आप कॉनैट विधि का उपयोग कर सकते हैं।

<%
    concat "hello"
    # is the equivalent of <%= "hello" %>

    if logged_in
      concat "Logged in!"
    else
      concat link_to('login', action: :login)
    end
    # will either display "Logged in!" or a login link
%>
current_cycle (नाम = "डिफ़ॉल्ट") स्रोत दिखाएं
# File actionview/lib/action_view/helpers/text_helper.rb, line 378
def current_cycle(name = "default")
  cycle = get_cycle(name)
  cycle.current_value if cycle
end

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

# Alternate background colors
@items = [1,2,3,4]
<% @items.each do |item| %>
  <div style="background-color:<%= cycle("red","white","blue") %>">
    <span style="background-color:<%= current_cycle %>"><%= item %></span>
  </div>
<% end %>
चक्र (First_value, * मान) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/text_helper.rb, line 354
def cycle(first_value, *values)
  options = values.extract_options!
  name = options.fetch(:name, "default")

  values.unshift(*first_value)

  cycle = get_cycle(name)
  unless cycle && cycle.values == values
    cycle = set_cycle(name, Cycle.new(*values))
  end
  cycle.to_s
end

एक चक्र वस्तु बनाता है जिसका to_s विधि किसी सरणी के तत्वों के माध्यम से हर बार इसे कहा जाता है। इसका उपयोग उदाहरण के लिए, तालिका पंक्तियों के लिए वैकल्पिक कक्षाओं के लिए किया जा सकता है। आप छोरों में घोंसले के शिकार करने के लिए नामित चक्रों का उपयोग कर सकते हैं। एक Hash कुंजी को अंतिम पैरामीटर के रूप में पास करना :name कुंजी एक नाम चक्र बनाएगी। बिना नाम के एक चक्र के लिए डिफ़ॉल्ट नाम "default" । आप मैन्युअल रूप से #reset_cycle को कॉल #reset_cycle और चक्र का नाम पास करके एक चक्र को रीसेट कर सकते हैं। वर्तमान चक्र स्ट्रिंग को #current_cycle विधि का उपयोग करके कभी भी प्राप्त किया जा सकता है।

 # Alternate CSS classes for even and odd numbers...
 @items = [1,2,3,4]
 <table>
 <% @items.each do |item| %>
   <tr class="<%= cycle("odd", "even") -%>">
     <td><%= item %></td>
   </tr>
 <% end %>
 </table>

 # Cycle CSS classes for rows, and text colors for values within each row
 @items = x = [{first: 'Robert', middle: 'Daniel', last: 'James'},
              {first: 'Emily', middle: 'Shannon', maiden: 'Pike', last: 'Hicks'},
             {first: 'June', middle: 'Dae', last: 'Jones'}]
 <% @items.each do |item| %>
   <tr class="<%= cycle("odd", "even", name: "row_class") -%>">
     <td>
       <% item.values.each do |value| %>
         <%# Create a named cycle "colors" %>
         <span style="color:<%= cycle("red", "green", "blue", name: "colors") -%>">
           <%= value %>
         </span>
       <% end %>
       <% reset_cycle("colors") %>
     </td>
  </tr>
<% end %>
अंश (पाठ, वाक्यांश, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/text_helper.rb, line 175
def excerpt(text, phrase, options = {})
  return unless text && phrase

  separator = options.fetch(:separator, nil) || ""
  case phrase
  when Regexp
    regex = phrase
  else
    regex = /#{Regexp.escape(phrase)}/i
  end

  return unless matches = text.match(regex)
  phrase = matches[0]

  unless separator.empty?
    text.split(separator).each do |value|
      if value.match(regex)
        phrase = value
        break
      end
    end
  end

  first_part, second_part = text.split(phrase, 2)

  prefix, first_part   = cut_excerpt_part(:first, first_part, separator, options)
  postfix, second_part = cut_excerpt_part(:second, second_part, separator, options)

  affix = [first_part, separator, phrase, separator, second_part].join.strip
  [prefix, affix, postfix].join
end

text एक अंश निकालता है जो phrase के पहले उदाहरण से मेल खाता है। :radius विकल्प phrase की पहली घटना के प्रत्येक पक्ष में अंश का विस्तार करता है :radius परिभाषित वर्णों की संख्या :radius (जो 100 में चूक करता है)। यदि अंश त्रिज्या text की शुरुआत या अंत को ओवरफ्लो करता है, तो :omission विकल्प (जो “…” के लिए चूक करता है) तदनुसार प्रस्तुत / जोड़ा जाएगा। परिसीमन का चयन करने के लिए :separator विकल्प का उपयोग करें। परिणामस्वरूप स्ट्रिंग किसी भी मामले में छीन ली जाएगी। यदि phrase नहीं मिला है, तो nil वापस आ गया है।

excerpt('This is an example', 'an', radius: 5)
# => ...s is an exam...

excerpt('This is an example', 'is', radius: 5)
# => This is a...

excerpt('This is an example', 'is')
# => This is an example

excerpt('This next thing is an example', 'ex', radius: 2)
# => ...next...

excerpt('This is also an example', 'an', radius: 8, omission: '<chop> ')
# => <chop> is also an example

excerpt('This is a very beautiful morning', 'very', separator: ' ', radius: 1)
# => ...a very beautiful...
हाइलाइट (पाठ, वाक्यांश, विकल्प = {}) {| पाया | ...} स्रोत दिखाएं
# File actionview/lib/action_view/helpers/text_helper.rb, line 132
def highlight(text, phrases, options = {})
  text = sanitize(text) if options.fetch(:sanitize, true)

  if text.blank? || phrases.blank?
    text || ""
  else
    match = Array(phrases).map do |p|
      Regexp === p ? p.to_s : Regexp.escape(p)
    end.join("|")

    if block_given?
      text.gsub(/(#{match})(?![^<]*?>)/i) { |found| yield found }
    else
      highlighter = options.fetch(:highlighter, '<mark>\1</mark>')
      text.gsub(/(#{match})(?![^<]*?>)/i, highlighter)
    end
  end.html_safe
end

text में हर जगह एक या एक से अधिक phrases हाइलाइट करता है :highlighter स्ट्रिंग है। हाइलाइटर को पास करके विशेष किया जा सकता है :highlighter सिंगल-कोटेड स्ट्रिंग के रूप में \1 साथ जहां वाक्यांश डाला जाना है (डिफॉल्ट्स टू '<मार्क> 1 </ मार्क>') या प्रत्येक मिलान शब्द प्राप्त करने वाले ब्लॉक को पास करना। डिफ़ॉल्ट text से संभव XSS हमलों को रोकने के लिए स्वच्छता है। यदि इनपुट भरोसेमंद है, तो इसके लिए गलत तरीके से गुजरना :sanitize को बंद करना होगा।

highlight('You searched for: rails', 'rails')
# => You searched for: <mark>rails</mark>

highlight('You searched for: rails', /for|rails/)
# => You searched <mark>for</mark>: <mark>rails</mark>

highlight('You searched for: ruby, rails, dhh', 'actionpack')
# => You searched for: ruby, rails, dhh

highlight('You searched for: rails', ['for', 'rails'], highlighter: '<em>\1</em>')
# => You searched <em>for</em>: <em>rails</em>

highlight('You searched for: rails', 'rails', highlighter: '<a href="search?q=\1">\1</a>')
# => You searched for: <a href="search?q=rails">rails</a>

highlight('You searched for: rails', 'rails') { |match| link_to(search_path(q: match, match)) }
# => You searched for: <a href="search?q=rails">rails</a>

highlight('<a href="javascript:alert(\'no!\')">ruby</a> on rails', 'rails', sanitize: false)
# => <a href="javascript:alert('no!')">ruby</a> on <mark>rails</mark>
बहुवचन (गणना, एकवचन, बहुवचन = शून्य, बहुवचन: बहुवचन_गीत, स्थान: I18n.locale) दिखाएँ स्रोत
# File actionview/lib/action_view/helpers/text_helper.rb, line 230
def pluralize(count, singular, plural_arg = nil, plural: plural_arg, locale: I18n.locale)
  word = if (count == 1 || count =~ /^1(\.0+)?$/)
    singular
  else
    plural || singular.pluralize(locale)
  end

  "#{count || 0} #{word}"
end

जब तक count है, तब तक singular शब्द का बहुवचन करने का प्रयास किया जाता है। 1. यदि plural की आपूर्ति की जाती है, तो इसका उपयोग उस समय होगा जब गिनती> 1 है, अन्यथा यह दिए गए स्थान के लिए बहुवचन रूप को निर्धारित करने के लिए Inflector का उपयोग करेगा, जो I18n.locale को चूकता है

शब्द को लोकेल के लिए परिभाषित नियमों का उपयोग करते हुए बहुवचन दिया जाएगा (आपको अंग्रेजी के अलावा अन्य भाषाओं के लिए अपने स्वयं के विभक्ति नियमों को परिभाषित करना होगा)। ActiveSupport::Inflector#pluralize देखें ActiveSupport::Inflector#pluralize

pluralize(1, 'person')
# => 1 person

pluralize(2, 'person')
# => 2 people

pluralize(3, 'person', plural: 'users')
# => 3 users

pluralize(0, 'person')
# => 0 people

pluralize(2, 'Person', locale: :de)
# => 2 Personen
reset_cycle (नाम = "डिफ़ॉल्ट") स्रोत दिखाएं
# File actionview/lib/action_view/helpers/text_helper.rb, line 401
def reset_cycle(name = "default")
  cycle = get_cycle(name)
  cycle.reset if cycle
end

एक चक्र को रीसेट करता है ताकि यह पहली बार शुरू होने वाले तत्व से शुरू हो। एक नाम चक्र को रीसेट करने के लिए name में पास करें।

# Alternate CSS classes for even and odd numbers...
@items = [[1,2,3,4], [5,6,3], [3,4,5,6,7,4]]
<table>
<% @items.each do |item| %>
  <tr class="<%= cycle("even", "odd") -%>">
      <% item.each do |value| %>
        <span style="color:<%= cycle("#333", "#666", "#999", name: "colors") -%>">
          <%= value %>
        </span>
      <% end %>

      <% reset_cycle("colors") %>
  </tr>
<% end %>
</table>
# File actionview/lib/action_view/helpers/text_helper.rb, line 58
def safe_concat(string)
  output_buffer.respond_to?(:safe_concat) ? output_buffer.safe_concat(string) : concat(string)
end
simple_format (टेक्स्ट, html_options = {}, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/text_helper.rb, line 302
def simple_format(text, html_options = {}, options = {})
  wrapper_tag = options.fetch(:wrapper_tag, :p)

  text = sanitize(text) if options.fetch(:sanitize, true)
  paragraphs = split_paragraphs(text)

  if paragraphs.empty?
    content_tag(wrapper_tag, nil, html_options)
  else
    paragraphs.map! { |paragraph|
      content_tag(wrapper_tag, raw(paragraph), html_options)
    }.join("\n\n").html_safe
  end
end

साधारण स्वरूपण नियमों का उपयोग करके text HTML में बदल जाता है। दो या अधिक लगातार newlines ( \n\n या \r\n\r\n ) को एक पैराग्राफ माना जाता है और <p> टैग में लपेटा जाता है। एक न्यूलाइन ( \n या \r\n ) को एक लाइनब्रेक माना जाता है और एक <br /> टैग जोड़ा जाता है। यह विधि text से नईलाइन्स नहीं निकालती है।

आप html_options में किसी भी HTML विशेषताओं को पारित कर सकते हैं। ये सभी बनाए गए पैराग्राफ में जोड़े जाएंगे।

विकल्प

  • :sanitize - यदि false , तो text पवित्र नहीं करता है।

  • :wrapper_tag - रैपर टैग का प्रतिनिधित्व करते हुए String , "p" लिए डिफॉल्ट करता है

उदाहरण

my_text = "Here is some basic text...\n...with a line break."

simple_format(my_text)
# => "<p>Here is some basic text...\n<br />...with a line break.</p>"

simple_format(my_text, {}, wrapper_tag: "div")
# => "<div>Here is some basic text...\n<br />...with a line break.</div>"

more_text = "We want to put a paragraph...\n\n...right there."

simple_format(more_text)
# => "<p>We want to put a paragraph...</p>\n\n<p>...right there.</p>"

simple_format("Look ma! A class!", class: 'description')
# => "<p class='description'>Look ma! A class!</p>"

simple_format("<blink>Unblinkable.</blink>")
# => "<p>Unblinkable.</p>"

simple_format("<blink>Blinkable!</blink> It's true.", {}, sanitize: false)
# => "<p><blink>Blinkable!</blink> It's true.</p>"
truncate (टेक्स्ट, विकल्प = {}, और ब्लॉक) दिखाएँ स्रोत
# File actionview/lib/action_view/helpers/text_helper.rb, line 94
def truncate(text, options = {}, &block)
  if text
    length  = options.fetch(:length, 30)

    content = text.truncate(length, options)
    content = options[:escape] == false ? content.html_safe : ERB::Util.html_escape(content)
    content << capture(&block) if block_given? && text.length > length
    content
  end
end

दिए गए text बाद दिए गए text को काटता है :length यदि text अधिक लंबा है :length (30 की चूक)। पिछले पात्रों को कुल लंबाई से अधिक नहीं :length लिए :omission (चूक "से" ... ") के साथ बदल दिया जाएगा।

पास :separator एक प्राकृतिक विराम पर text को अलग करने के लिए :separator

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

परिणाम को HTML- सुरक्षित के रूप में चिह्नित किया गया है, लेकिन यह डिफ़ॉल्ट रूप से बच जाता है, जब तक :escape false । यदि text में HTML टैग या इकाइयां हैं, तो देखभाल की जानी चाहिए, क्योंकि ट्रंकेशन अमान्य HTML (जैसे असंतुलित या अपूर्ण टैग) उत्पन्न कर सकता है।

truncate("Once upon a time in a world far far away")
# => "Once upon a time in a world..."

truncate("Once upon a time in a world far far away", length: 17)
# => "Once upon a ti..."

truncate("Once upon a time in a world far far away", length: 17, separator: ' ')
# => "Once upon a..."

truncate("And they found that many people were sleeping better.", length: 25, omission: '... (continued)')
# => "And they f... (continued)"

truncate("<p>Once upon a time in a world far far away</p>")
# => "&lt;p&gt;Once upon a time in a wo..."

truncate("<p>Once upon a time in a world far far away</p>", escape: false)
# => "<p>Once upon a time in a wo..."

truncate("Once upon a time in a world far far away") { link_to "Continue", "#" }
# => "Once upon a time in a wo...<a href="#">Continue</a>"
word_wrap (टेक्स्ट, लाइन_ एक्सपोज़र: 80, ब्रेक_ परिणाम: "\ n") स्रोत दिखाएं
# File actionview/lib/action_view/helpers/text_helper.rb, line 260
def word_wrap(text, line_width: 80, break_sequence: "\n")
  text.split("\n").collect! do |line|
    line.length > line_width ? line.gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1#{break_sequence}").strip : line
  end * break_sequence
end

text को पंक्तियों में लपेटता है जो अब line_width चौड़ाई से अधिक नहीं है। यह विधि पहले line_width चरित्र पर line_width जो line_width से अधिक नहीं है (जो डिफ़ॉल्ट रूप से 80 है)।

word_wrap('Once upon a time')
# => Once upon a time

word_wrap('Once upon a time, in a kingdom called Far Far Away, a king fell ill, and finding a successor to the throne turned out to be more trouble than anyone could have imagined...')
# => Once upon a time, in a kingdom called Far Far Away, a king fell ill, and finding\na successor to the throne turned out to be more trouble than anyone could have\nimagined...

word_wrap('Once upon a time', line_width: 8)
# => Once\nupon a\ntime

word_wrap('Once upon a time', line_width: 1)
# => Once\nupon\na\ntime

You can also specify a custom +break_sequence+ ("\n" by default)

word_wrap('Once upon a time', line_width: 1, break_sequence: "\r\n")
# => Once\r\nupon\r\na\r\ntime