String.html

---
title: String
layout: default
---
<div class="main">
    <div class="banner">
        
            <span>Ruby on Rails 8.0.0</span><br />
        
        <div class="type">Class</div>
        <h1>
            String
            
                <span class="parent">&lt;
                    
                    <a href="Object.html">Object</a>
                    
                </span>
            
        </h1>
        <ul class="files">
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/object/blank_rb.html">activesupport/lib/active_support/core_ext/object/blank.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/object/json_rb.html">activesupport/lib/active_support/core_ext/object/json.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/access_rb.html">activesupport/lib/active_support/core_ext/string/access.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/behavior_rb.html">activesupport/lib/active_support/core_ext/string/behavior.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/conversions_rb.html">activesupport/lib/active_support/core_ext/string/conversions.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/exclude_rb.html">activesupport/lib/active_support/core_ext/string/exclude.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/filters_rb.html">activesupport/lib/active_support/core_ext/string/filters.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/indent_rb.html">activesupport/lib/active_support/core_ext/string/indent.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/inflections_rb.html">activesupport/lib/active_support/core_ext/string/inflections.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/inquiry_rb.html">activesupport/lib/active_support/core_ext/string/inquiry.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/multibyte_rb.html">activesupport/lib/active_support/core_ext/string/multibyte.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/output_safety_rb.html">activesupport/lib/active_support/core_ext/string/output_safety.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/starts_ends_with_rb.html">activesupport/lib/active_support/core_ext/string/starts_ends_with.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/strip_rb.html">activesupport/lib/active_support/core_ext/string/strip.rb</a></li>
            
            <li><a href="../files/activesupport/lib/active_support/core_ext/string/zones_rb.html">activesupport/lib/active_support/core_ext/string/zones.rb</a></li>
            
        </ul>
    </div>
    <div id="bodyContent">
        <div id="content">
  
    <div class="description">
      
<p><a href="String.html"><code>String</code></a> inflections define new methods on the <a href="String.html"><code>String</code></a> class to transform names for different purposes. For instance, you can figure out the name of a table from the name of a class.</p>

<pre><code>&#39;ScaleScore&#39;.tableize # =&gt; &quot;scale_scores&quot;
</code></pre>

    </div>
  

  

  
  


  

  
    <h2 id="methods">Methods</h2>
    <ul>
      
        <li>
          <a href="#method-i-acts_like_string-3F">acts_like_string?</a>
        </li>
      
        <li>
          <a href="#method-i-at">at</a>
        </li>
      
        <li>
          <a href="#method-i-blank-3F">blank?</a>
        </li>
      
        <li>
          <a href="#method-i-camelcase">camelcase</a>
        </li>
      
        <li>
          <a href="#method-i-camelize">camelize</a>
        </li>
      
        <li>
          <a href="#method-i-classify">classify</a>
        </li>
      
        <li>
          <a href="#method-i-constantize">constantize</a>
        </li>
      
        <li>
          <a href="#method-i-dasherize">dasherize</a>
        </li>
      
        <li>
          <a href="#method-i-deconstantize">deconstantize</a>
        </li>
      
        <li>
          <a href="#method-i-demodulize">demodulize</a>
        </li>
      
        <li>
          <a href="#method-i-downcase_first">downcase_first</a>
        </li>
      
        <li>
          <a href="#method-i-exclude-3F">exclude?</a>
        </li>
      
        <li>
          <a href="#method-i-first">first</a>
        </li>
      
        <li>
          <a href="#method-i-foreign_key">foreign_key</a>
        </li>
      
        <li>
          <a href="#method-i-from">from</a>
        </li>
      
        <li>
          <a href="#method-i-html_safe">html_safe</a>
        </li>
      
        <li>
          <a href="#method-i-humanize">humanize</a>
        </li>
      
        <li>
          <a href="#method-i-in_time_zone">in_time_zone</a>
        </li>
      
        <li>
          <a href="#method-i-indent">indent</a>
        </li>
      
        <li>
          <a href="#method-i-indent-21">indent!</a>
        </li>
      
        <li>
          <a href="#method-i-inquiry">inquiry</a>
        </li>
      
        <li>
          <a href="#method-i-is_utf8-3F">is_utf8?</a>
        </li>
      
        <li>
          <a href="#method-i-last">last</a>
        </li>
      
        <li>
          <a href="#method-i-mb_chars">mb_chars</a>
        </li>
      
        <li>
          <a href="#method-i-parameterize">parameterize</a>
        </li>
      
        <li>
          <a href="#method-i-pluralize">pluralize</a>
        </li>
      
        <li>
          <a href="#method-i-remove">remove</a>
        </li>
      
        <li>
          <a href="#method-i-remove-21">remove!</a>
        </li>
      
        <li>
          <a href="#method-i-safe_constantize">safe_constantize</a>
        </li>
      
        <li>
          <a href="#method-i-singularize">singularize</a>
        </li>
      
        <li>
          <a href="#method-i-squish">squish</a>
        </li>
      
        <li>
          <a href="#method-i-squish-21">squish!</a>
        </li>
      
        <li>
          <a href="#method-i-strip_heredoc">strip_heredoc</a>
        </li>
      
        <li>
          <a href="#method-i-tableize">tableize</a>
        </li>
      
        <li>
          <a href="#method-i-titlecase">titlecase</a>
        </li>
      
        <li>
          <a href="#method-i-titleize">titleize</a>
        </li>
      
        <li>
          <a href="#method-i-to">to</a>
        </li>
      
        <li>
          <a href="#method-i-to_date">to_date</a>
        </li>
      
        <li>
          <a href="#method-i-to_datetime">to_datetime</a>
        </li>
      
        <li>
          <a href="#method-i-to_time">to_time</a>
        </li>
      
        <li>
          <a href="#method-i-truncate">truncate</a>
        </li>
      
        <li>
          <a href="#method-i-truncate_bytes">truncate_bytes</a>
        </li>
      
        <li>
          <a href="#method-i-truncate_words">truncate_words</a>
        </li>
      
        <li>
          <a href="#method-i-underscore">underscore</a>
        </li>
      
        <li>
          <a href="#method-i-upcase_first">upcase_first</a>
        </li>
      
    </ul>
  

  

  
    

    

    
      <!-- Section constants -->
      <h2 id="constants">Constants</h2>
      <table border='0' cellpadding='5'>
        
          <tr valign='top'>
            <td class="attr-name">BLANK_RE</td>
            <td>=</td>
            <td class="attr-value">/\A[[:space:]]*\z/</td>
          </tr>
          
        
          <tr valign='top'>
            <td class="attr-name">ENCODED_BLANKS</td>
            <td>=</td>
            <td class="attr-value">Concurrent::Map.new do |h, enc|
h[enc] = Regexp.new(BLANK_RE.source.encode(enc), BLANK_RE.options | Regexp::FIXEDENCODING)
end</td>
          </tr>
          
        
      </table>
    

    

    <!-- Methods -->
    
    
      <h2 id="instance-public-methods">Instance Public methods</h2>
      
        <div class="method">
          <h3 id="method-i-acts_like_string-3F">
            
              acts_like_string?()
            
          </h3>

          
            <div class="description">
              <p>Enables more predictable duck-typing on String-like classes. See <code>Object#acts_like?</code>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/behavior.rb, line 5
  def acts_like_string?
    true
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/behavior.rb#L5" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-at">
            
              at(position)
            
          </h3>

          
            <div class="description">
              <p>If you pass a single integer, returns a substring of one character at that position. The first character of the string is at position 0, the next at position 1, and so on. If a range is supplied, a substring containing characters at offsets given by the range is returned. In both cases, if an offset is negative, it is counted from the end of the string. Returns <code>nil</code> if the initial offset falls outside the string. Returns an empty string if the beginning of the range is greater than the end of the string.</p>

<pre><code>str = &quot;hello&quot;
str.at(0)      # =&gt; &quot;h&quot;
str.at(1..3)   # =&gt; &quot;ell&quot;
str.at(-2)     # =&gt; &quot;l&quot;
str.at(-2..-1) # =&gt; &quot;lo&quot;
str.at(5)      # =&gt; nil
str.at(5..-1)  # =&gt; &quot;&quot;
</code></pre>

<p>If a <a href="Regexp.html"><code>Regexp</code></a> is given, the matching portion of the string is returned. If a <a href="String.html"><code>String</code></a> is given, that given string is returned if it occurs in the string. In both cases, <code>nil</code> is returned if there is no match.</p>

<pre><code>str = &quot;hello&quot;
str.at(/lo/) # =&gt; &quot;lo&quot;
str.at(/ol/) # =&gt; nil
str.at(&quot;lo&quot;) # =&gt; &quot;lo&quot;
str.at(&quot;ol&quot;) # =&gt; nil
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/access.rb, line 29
  def at(position)
    self[position]
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/access.rb#L29" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-blank-3F">
            
              blank?()
            
          </h3>

          
            <div class="description">
              <p>A string is blank if it’s empty or contains whitespaces only:</p>

<pre><code>&#39;&#39;.blank?       # =&gt; true
&#39;   &#39;.blank?    # =&gt; true
&quot;\t\n\r&quot;.blank? # =&gt; true
&#39; blah &#39;.blank? # =&gt; false
</code></pre>

<p>Unicode whitespace is supported:</p>

<pre><code>&quot;\u00a0&quot;.blank? # =&gt; true
</code></pre>

<p>@return [true, false]</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/object/blank.rb, line 153
  def blank?
    # The regexp that matches blank strings is expensive. For the case of empty
    # strings we can speed up this method (~3.5x) with an empty? call. The
    # penalty for the rest of strings is marginal.
    empty? ||
      begin
        BLANK_RE.match?(self)
      rescue Encoding::CompatibilityError
        ENCODED_BLANKS[self.encoding].match?(self)
      end
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/object/blank.rb#L153" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-camelcase">
            
              camelcase(first_letter = :upper)
            
          </h3>

          
            <div class="description">
              
            </div>
          

          

          
            <div class="aka">
              Alias for: <a href="String.html#method-i-camelize">camelize</a>
            </div>
          

          
          
        </div>
        
        <div class="method">
          <h3 id="method-i-camelize">
            
              camelize(first_letter = :upper)
            
          </h3>

          
            <div class="description">
              <p>By default, <code>camelize</code> converts strings to UpperCamelCase. If the argument to camelize is set to <code>:lower</code> then camelize produces lowerCamelCase.</p>

<p><code>camelize</code> will also convert ‘/’ to ‘::’ which is useful for converting paths to namespaces.</p>

<pre><code>&#39;active_record&#39;.camelize                # =&gt; &quot;ActiveRecord&quot;
&#39;active_record&#39;.camelize(:lower)        # =&gt; &quot;activeRecord&quot;
&#39;active_record/errors&#39;.camelize         # =&gt; &quot;ActiveRecord::Errors&quot;
&#39;active_record/errors&#39;.camelize(:lower) # =&gt; &quot;activeRecord::Errors&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-camelize"><code>ActiveSupport::Inflector.camelize</code></a>.</p>
            </div>
          

          
            <div class="aka">
              Also aliased as: <a href="String.html#method-i-camelcase">camelcase</a>
            </div>
          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 101
  def camelize(first_letter = :upper)
    case first_letter
    when :upper
      ActiveSupport::Inflector.camelize(self, true)
    when :lower
      ActiveSupport::Inflector.camelize(self, false)
    else
      raise ArgumentError, &quot;Invalid option, use either :upper or :lower.&quot;
    end
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L101" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-classify">
            
              classify()
            
          </h3>

          
            <div class="description">
              <p>Creates a class name from a plural table name like Rails does for table names to models. Note that this returns a string and not a class. (To convert to an actual class follow <code>classify</code> with <code>constantize</code>.)</p>

<pre><code>&#39;ham_and_eggs&#39;.classify # =&gt; &quot;HamAndEgg&quot;
&#39;posts&#39;.classify        # =&gt; &quot;Post&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-classify"><code>ActiveSupport::Inflector.classify</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 239
  def classify
    ActiveSupport::Inflector.classify(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L239" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-constantize">
            
              constantize()
            
          </h3>

          
            <div class="description">
              <p><code>constantize</code> tries to find a declared constant with the name specified in the string. It raises a <a href="NameError.html"><code>NameError</code></a> when the name is not in CamelCase or is not initialized.</p>

<pre><code>&#39;Module&#39;.constantize  # =&gt; Module
&#39;Class&#39;.constantize   # =&gt; Class
&#39;blargle&#39;.constantize # =&gt; NameError: wrong constant name blargle
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-constantize"><code>ActiveSupport::Inflector.constantize</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 73
  def constantize
    ActiveSupport::Inflector.constantize(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L73" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-dasherize">
            
              dasherize()
            
          </h3>

          
            <div class="description">
              <p>Replaces underscores with dashes in the string.</p>

<pre><code>&#39;puni_puni&#39;.dasherize # =&gt; &quot;puni-puni&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-dasherize"><code>ActiveSupport::Inflector.dasherize</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 148
  def dasherize
    ActiveSupport::Inflector.dasherize(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L148" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-deconstantize">
            
              deconstantize()
            
          </h3>

          
            <div class="description">
              <p>Removes the rightmost segment from the constant expression in the string.</p>

<pre><code>&#39;Net::HTTP&#39;.deconstantize   # =&gt; &quot;Net&quot;
&#39;::Net::HTTP&#39;.deconstantize # =&gt; &quot;::Net&quot;
&#39;String&#39;.deconstantize      # =&gt; &quot;&quot;
&#39;::String&#39;.deconstantize    # =&gt; &quot;&quot;
&#39;&#39;.deconstantize            # =&gt; &quot;&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-deconstantize"><code>ActiveSupport::Inflector.deconstantize</code></a>.</p>

<p>See also <code>demodulize</code>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 177
  def deconstantize
    ActiveSupport::Inflector.deconstantize(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L177" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-demodulize">
            
              demodulize()
            
          </h3>

          
            <div class="description">
              <p>Removes the module part from the constant expression in the string.</p>

<pre><code>&#39;ActiveSupport::Inflector::Inflections&#39;.demodulize # =&gt; &quot;Inflections&quot;
&#39;Inflections&#39;.demodulize                           # =&gt; &quot;Inflections&quot;
&#39;::Inflections&#39;.demodulize                         # =&gt; &quot;Inflections&quot;
&#39;&#39;.demodulize                                      # =&gt; &#39;&#39;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-demodulize"><code>ActiveSupport::Inflector.demodulize</code></a>.</p>

<p>See also <code>deconstantize</code>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 162
  def demodulize
    ActiveSupport::Inflector.demodulize(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L162" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-downcase_first">
            
              downcase_first()
            
          </h3>

          
            <div class="description">
              <p>Converts the first character to lowercase.</p>

<pre><code>&#39;If they enjoyed The Matrix&#39;.downcase_first # =&gt; &quot;if they enjoyed The Matrix&quot;
&#39;I&#39;.downcase_first                          # =&gt; &quot;i&quot;
&#39;&#39;.downcase_first                           # =&gt; &quot;&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-downcase_first"><code>ActiveSupport::Inflector.downcase_first</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 284
  def downcase_first
    ActiveSupport::Inflector.downcase_first(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L284" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-exclude-3F">
            
              exclude?(string)
            
          </h3>

          
            <div class="description">
              <p>The inverse of <code>String#include?</code>. Returns true if the string does not include the other string.</p>

<pre><code>&quot;hello&quot;.exclude? &quot;lo&quot; # =&gt; false
&quot;hello&quot;.exclude? &quot;ol&quot; # =&gt; true
&quot;hello&quot;.exclude? ?h   # =&gt; false
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/exclude.rb, line 10
  def exclude?(string)
    !include?(string)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/exclude.rb#L10" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-first">
            
              first(limit = 1)
            
          </h3>

          
            <div class="description">
              <p>Returns the first character. If a limit is supplied, returns a substring from the beginning of the string until it reaches the limit value. If the given limit is greater than or equal to the string length, returns a copy of self.</p>

<pre><code>str = &quot;hello&quot;
str.first    # =&gt; &quot;h&quot;
str.first(1) # =&gt; &quot;h&quot;
str.first(2) # =&gt; &quot;he&quot;
str.first(0) # =&gt; &quot;&quot;
str.first(6) # =&gt; &quot;hello&quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/access.rb, line 78
  def first(limit = 1)
    self[0, limit] || raise(ArgumentError, &quot;negative limit&quot;)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/access.rb#L78" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-foreign_key">
            
              foreign_key(separate_class_name_and_id_with_underscore = true)
            
          </h3>

          
            <div class="description">
              <p>Creates a foreign key name from a class name. <code>separate_class_name_and_id_with_underscore</code> sets whether the method should put ‘_’ between the name and ‘id’.</p>

<pre><code>&#39;Message&#39;.foreign_key        # =&gt; &quot;message_id&quot;
&#39;Message&#39;.foreign_key(false) # =&gt; &quot;messageid&quot;
&#39;Admin::Post&#39;.foreign_key    # =&gt; &quot;post_id&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-foreign_key"><code>ActiveSupport::Inflector.foreign_key</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 297
  def foreign_key(separate_class_name_and_id_with_underscore = true)
    ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L297" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-from">
            
              from(position)
            
          </h3>

          
            <div class="description">
              <p>Returns a substring from the given position to the end of the string. If the position is negative, it is counted from the end of the string.</p>

<pre><code>str = &quot;hello&quot;
str.from(0)  # =&gt; &quot;hello&quot;
str.from(3)  # =&gt; &quot;lo&quot;
str.from(-2) # =&gt; &quot;lo&quot;
</code></pre>

<p>You can mix it with <code>to</code> method and do fun things like:</p>

<pre><code>str = &quot;hello&quot;
str.from(0).to(-1) # =&gt; &quot;hello&quot;
str.from(1).to(-2) # =&gt; &quot;ell&quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/access.rb, line 46
  def from(position)
    self[position, length]
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/access.rb#L46" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-html_safe">
            
              html_safe()
            
          </h3>

          
            <div class="description">
              <p>Marks a string as trusted safe. It will be inserted into HTML with no additional escaping performed. It is your responsibility to ensure that the string contains no malicious content. This method is equivalent to the <code>raw</code> helper in views. It is recommended that you use <code>sanitize</code> instead of this method. It should never be called on user input.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/output_safety.rb, line 225
  def html_safe
    ActiveSupport::SafeBuffer.new(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/output_safety.rb#L225" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-humanize">
            
              humanize(capitalize: true, keep_id_suffix: false)
            
          </h3>

          
            <div class="description">
              <p>Capitalizes the first word, turns underscores into spaces, and (by default) strips a trailing ‘_id’ if present. Like <code>titleize</code>, this is meant for creating pretty output.</p>

<p>The capitalization of the first word can be turned off by setting the optional parameter <code>capitalize</code> to false. By default, this parameter is true.</p>

<p>The trailing ‘_id’ can be kept and capitalized by setting the optional parameter <code>keep_id_suffix</code> to true. By default, this parameter is false.</p>

<pre><code>&#39;employee_salary&#39;.humanize                    # =&gt; &quot;Employee salary&quot;
&#39;author_id&#39;.humanize                          # =&gt; &quot;Author&quot;
&#39;author_id&#39;.humanize(capitalize: false)       # =&gt; &quot;author&quot;
&#39;_id&#39;.humanize                                # =&gt; &quot;Id&quot;
&#39;author_id&#39;.humanize(keep_id_suffix: true)    # =&gt; &quot;Author id&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-humanize"><code>ActiveSupport::Inflector.humanize</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 262
  def humanize(capitalize: true, keep_id_suffix: false)
    ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L262" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-in_time_zone">
            
              in_time_zone(zone = ::Time.zone)
            
          </h3>

          
            <div class="description">
              <p>Converts <a href="String.html"><code>String</code></a> to a TimeWithZone in the current zone if <a href="Time.html#method-c-zone"><code>Time.zone</code></a> or <a href="Time.html#attribute-c-zone_default"><code>Time.zone_default</code></a> is set, otherwise converts <a href="String.html"><code>String</code></a> to a <a href="Time.html"><code>Time</code></a> via <a href="String.html#method-i-to_time"><code>String#to_time</code></a></p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/zones.rb, line 9
  def in_time_zone(zone = ::Time.zone)
    if zone
      ::Time.find_zone!(zone).parse(self)
    else
      to_time
    end
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/zones.rb#L9" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-indent">
            
              indent(amount, indent_string = nil, indent_empty_lines = false)
            
          </h3>

          
            <div class="description">
              <p>Indents the lines in the receiver:</p>

<pre><code>&lt;&lt;EOS.indent(2)
def some_method
  some_code
end
EOS
# =&gt;
  def some_method
    some_code
  end
</code></pre>

<p>The second argument, <code>indent_string</code>, specifies which indent string to use. The default is <code>nil</code>, which tells the method to make a guess by peeking at the first indented line, and fall back to a space if there is none.</p>

<pre><code>&quot;  foo&quot;.indent(2)        # =&gt; &quot;    foo&quot;
&quot;foo\n\t\tbar&quot;.indent(2) # =&gt; &quot;\t\tfoo\n\t\t\t\tbar&quot;
&quot;foo&quot;.indent(2, &quot;\t&quot;)    # =&gt; &quot;\t\tfoo&quot;
</code></pre>

<p>While <code>indent_string</code> is typically one space or tab, it may be any string.</p>

<p>The third argument, <code>indent_empty_lines</code>, is a flag that says whether empty lines should be indented. Default is false.</p>

<pre><code>&quot;foo\n\nbar&quot;.indent(2)            # =&gt; &quot;  foo\n\n  bar&quot;
&quot;foo\n\nbar&quot;.indent(2, nil, true) # =&gt; &quot;  foo\n  \n  bar&quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/indent.rb, line 42
  def indent(amount, indent_string = nil, indent_empty_lines = false)
    dup.tap { |_| _.indent!(amount, indent_string, indent_empty_lines) }
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/indent.rb#L42" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-indent-21">
            
              indent!(amount, indent_string = nil, indent_empty_lines = false)
            
          </h3>

          
            <div class="description">
              <p>Same as <code>indent</code>, except it indents the receiver in-place.</p>

<p>Returns the indented string, or <code>nil</code> if there was nothing to indent.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/indent.rb, line 7
  def indent!(amount, indent_string = nil, indent_empty_lines = false)
    indent_string = indent_string || self[/^[ \t]/] || &quot; &quot;
    re = indent_empty_lines ? /^/ : /^(?!$)/
    gsub!(re, indent_string * amount)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/indent.rb#L7" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-inquiry">
            
              inquiry()
            
          </h3>

          
            <div class="description">
              <p>Wraps the current string in the <a href="ActiveSupport/StringInquirer.html"><code>ActiveSupport::StringInquirer</code></a> class, which gives you a prettier way to test for equality.</p>

<pre><code>env = &#39;production&#39;.inquiry
env.production?  # =&gt; true
env.development? # =&gt; false
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inquiry.rb, line 13
  def inquiry
    ActiveSupport::StringInquirer.new(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inquiry.rb#L13" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-is_utf8-3F">
            
              is_utf8?()
            
          </h3>

          
            <div class="description">
              <p>Returns <code>true</code> if string has utf_8 encoding.</p>

<pre><code>utf_8_str = &quot;some string&quot;.encode &quot;UTF-8&quot;
iso_str = &quot;some string&quot;.encode &quot;ISO-8859-1&quot;

utf_8_str.is_utf8? # =&gt; true
iso_str.is_utf8?   # =&gt; false
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/multibyte.rb, line 48
  def is_utf8?
    case encoding
    when Encoding::UTF_8, Encoding::US_ASCII
      valid_encoding?
    when Encoding::ASCII_8BIT
      dup.force_encoding(Encoding::UTF_8).valid_encoding?
    else
      false
    end
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/multibyte.rb#L48" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-last">
            
              last(limit = 1)
            
          </h3>

          
            <div class="description">
              <p>Returns the last character of the string. If a limit is supplied, returns a substring from the end of the string until it reaches the limit value (counting backwards). If the given limit is greater than or equal to the string length, returns a copy of self.</p>

<pre><code>str = &quot;hello&quot;
str.last    # =&gt; &quot;o&quot;
str.last(1) # =&gt; &quot;o&quot;
str.last(2) # =&gt; &quot;lo&quot;
str.last(0) # =&gt; &quot;&quot;
str.last(6) # =&gt; &quot;hello&quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/access.rb, line 92
  def last(limit = 1)
    self[[length - limit, 0].max, limit] || raise(ArgumentError, &quot;negative limit&quot;)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/access.rb#L92" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-mb_chars">
            
              mb_chars()
            
          </h3>

          
            <div class="description">
              <h2 id="method-i-mb_chars-label-Multibyte+proxy">Multibyte proxy</h2>

<p><code>mb_chars</code> is a multibyte safe proxy for string methods.</p>

<p>It creates and returns an instance of the <a href="ActiveSupport/Multibyte/Chars.html"><code>ActiveSupport::Multibyte::Chars</code></a> class which encapsulates the original string. A Unicode safe version of all the <a href="String.html"><code>String</code></a> methods are defined on this proxy class. If the proxy class doesn’t respond to a certain method, it’s forwarded to the encapsulated string.</p>

<pre><code>&gt;&gt; &quot;lj&quot;.mb_chars.upcase.to_s
=&gt; &quot;LJ&quot;
</code></pre>

<p>NOTE: Ruby 2.4 and later support native Unicode case mappings:</p>

<pre><code>&gt;&gt; &quot;lj&quot;.upcase
=&gt; &quot;LJ&quot;
</code></pre>

<h2 id="method-i-mb_chars-label-Method+chaining">Method chaining</h2>

<p>All the methods on the Chars proxy which normally return a string will return a Chars object. This allows method chaining on the result of any of these methods.</p>

<pre><code>name.mb_chars.reverse.length # =&gt; 12
</code></pre>

<h2 id="method-i-mb_chars-label-Interoperability+and+configuration">Interoperability and configuration</h2>

<p>The Chars object tries to be as interchangeable with <a href="String.html"><code>String</code></a> objects as possible: sorting and comparing between <a href="String.html"><code>String</code></a> and Char work like expected. The bang! methods change the internal string representation in the Chars object. Interoperability problems can be resolved easily with a <code>to_s</code> call.</p>

<p>For more information about the methods defined on the Chars proxy see <a href="ActiveSupport/Multibyte/Chars.html"><code>ActiveSupport::Multibyte::Chars</code></a>. For information about how to change the default Multibyte behavior see <a href="ActiveSupport/Multibyte.html"><code>ActiveSupport::Multibyte</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/multibyte.rb, line 37
  def mb_chars
    ActiveSupport::Multibyte.proxy_class.new(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/multibyte.rb#L37" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-parameterize">
            
              parameterize(separator: &quot;-&quot;, preserve_case: false, locale: nil)
            
          </h3>

          
            <div class="description">
              <p>Replaces special characters in a string so that it may be used as part of a ‘pretty’ URL.</p>

<p>If the optional parameter <code>locale</code> is specified, the word will be parameterized as a word of that language. By default, this parameter is set to <code>nil</code> and it will use the configured <code>I18n.locale</code>.</p>

<pre><code>class Person
  def to_param
    &quot;#{id}-#{name.parameterize}&quot;
  end
end

@person = Person.find(1)
# =&gt; #&lt;Person id: 1, name: &quot;Donald E. Knuth&quot;&gt;

&lt;%= link_to(@person.name, person_path) %&gt;
# =&gt; &lt;a href=&quot;/person/1-donald-e-knuth&quot;&gt;Donald E. Knuth&lt;/a&gt;
</code></pre>

<p>To preserve the case of the characters in a string, use the <code>preserve_case</code> argument.</p>

<pre><code>class Person
  def to_param
    &quot;#{id}-#{name.parameterize(preserve_case: true)}&quot;
  end
end

@person = Person.find(1)
# =&gt; #&lt;Person id: 1, name: &quot;Donald E. Knuth&quot;&gt;

&lt;%= link_to(@person.name, person_path) %&gt;
# =&gt; &lt;a href=&quot;/person/1-Donald-E-Knuth&quot;&gt;Donald E. Knuth&lt;/a&gt;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-parameterize"><code>ActiveSupport::Inflector.parameterize</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 215
  def parameterize(separator: &quot;-&quot;, preserve_case: false, locale: nil)
    ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case, locale: locale)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L215" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-pluralize">
            
              pluralize(count = nil, locale = :en)
            
          </h3>

          
            <div class="description">
              <p>Returns the plural form of the word in the string.</p>

<p>If the optional parameter <code>count</code> is specified, the singular form will be returned if <code>count == 1</code>. For any other value of <code>count</code> the plural will be returned.</p>

<p>If the optional parameter <code>locale</code> is specified, the word will be pluralized as a word of that language. By default, this parameter is set to <code>:en</code>. You must define your own inflection rules for languages other than English.</p>

<pre><code>&#39;post&#39;.pluralize             # =&gt; &quot;posts&quot;
&#39;octopus&#39;.pluralize          # =&gt; &quot;octopi&quot;
&#39;sheep&#39;.pluralize            # =&gt; &quot;sheep&quot;
&#39;words&#39;.pluralize            # =&gt; &quot;words&quot;
&#39;the blue mailman&#39;.pluralize # =&gt; &quot;the blue mailmen&quot;
&#39;CamelOctopus&#39;.pluralize     # =&gt; &quot;CamelOctopi&quot;
&#39;apple&#39;.pluralize(1)         # =&gt; &quot;apple&quot;
&#39;apple&#39;.pluralize(2)         # =&gt; &quot;apples&quot;
&#39;ley&#39;.pluralize(:es)         # =&gt; &quot;leyes&quot;
&#39;ley&#39;.pluralize(1, :es)      # =&gt; &quot;ley&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-pluralize"><code>ActiveSupport::Inflector.pluralize</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 35
  def pluralize(count = nil, locale = :en)
    locale = count if count.is_a?(Symbol)
    if count == 1
      dup
    else
      ActiveSupport::Inflector.pluralize(self, locale)
    end
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L35" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-remove">
            
              remove(*patterns)
            
          </h3>

          
            <div class="description">
              <p>Returns a new string with all occurrences of the patterns removed.</p>

<pre><code>str = &quot;foo bar test&quot;
str.remove(&quot; test&quot;)                 # =&gt; &quot;foo bar&quot;
str.remove(&quot; test&quot;, /bar/)          # =&gt; &quot;foo &quot;
str                                 # =&gt; &quot;foo bar test&quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/filters.rb, line 32
  def remove(*patterns)
    dup.remove!(*patterns)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/filters.rb#L32" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-remove-21">
            
              remove!(*patterns)
            
          </h3>

          
            <div class="description">
              <p>Alters the string by removing all occurrences of the patterns.</p>

<pre><code>str = &quot;foo bar test&quot;
str.remove!(&quot; test&quot;, /bar/)         # =&gt; &quot;foo &quot;
str                                 # =&gt; &quot;foo &quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/filters.rb, line 40
  def remove!(*patterns)
    patterns.each do |pattern|
      gsub! pattern, &quot;&quot;
    end

    self
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/filters.rb#L40" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-safe_constantize">
            
              safe_constantize()
            
          </h3>

          
            <div class="description">
              <p><code>safe_constantize</code> tries to find a declared constant with the name specified in the string. It returns <code>nil</code> when the name is not in CamelCase or is not initialized.</p>

<pre><code>&#39;Module&#39;.safe_constantize  # =&gt; Module
&#39;Class&#39;.safe_constantize   # =&gt; Class
&#39;blargle&#39;.safe_constantize # =&gt; nil
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-safe_constantize"><code>ActiveSupport::Inflector.safe_constantize</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 86
  def safe_constantize
    ActiveSupport::Inflector.safe_constantize(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L86" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-singularize">
            
              singularize(locale = :en)
            
          </h3>

          
            <div class="description">
              <p>The reverse of <code>pluralize</code>, returns the singular form of a word in a string.</p>

<p>If the optional parameter <code>locale</code> is specified, the word will be singularized as a word of that language. By default, this parameter is set to <code>:en</code>. You must define your own inflection rules for languages other than English.</p>

<pre><code>&#39;posts&#39;.singularize            # =&gt; &quot;post&quot;
&#39;octopi&#39;.singularize           # =&gt; &quot;octopus&quot;
&#39;sheep&#39;.singularize            # =&gt; &quot;sheep&quot;
&#39;word&#39;.singularize             # =&gt; &quot;word&quot;
&#39;the blue mailmen&#39;.singularize # =&gt; &quot;the blue mailman&quot;
&#39;CamelOctopi&#39;.singularize      # =&gt; &quot;CamelOctopus&quot;
&#39;leyes&#39;.singularize(:es)       # =&gt; &quot;ley&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-singularize"><code>ActiveSupport::Inflector.singularize</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 60
  def singularize(locale = :en)
    ActiveSupport::Inflector.singularize(self, locale)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L60" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-squish">
            
              squish()
            
          </h3>

          
            <div class="description">
              <p>Returns the string, first removing all whitespace on both ends of the string, and then changing remaining consecutive whitespace groups into one space each.</p>

<p>Note that it handles both ASCII and Unicode whitespace.</p>

<pre><code>%{ Multi-line
   string }.squish                   # =&gt; &quot;Multi-line string&quot;
&quot; foo   bar    \n   \t   boo&quot;.squish # =&gt; &quot;foo bar boo&quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/filters.rb, line 13
  def squish
    dup.squish!
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/filters.rb#L13" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-squish-21">
            
              squish!()
            
          </h3>

          
            <div class="description">
              <p>Performs a destructive squish. See <a href="String.html#method-i-squish"><code>String#squish</code></a>.</p>

<pre><code>str = &quot; foo   bar    \n   \t   boo&quot;
str.squish!                         # =&gt; &quot;foo bar boo&quot;
str                                 # =&gt; &quot;foo bar boo&quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/filters.rb, line 21
  def squish!
    gsub!(/[[:space:]]+/, &quot; &quot;)
    strip!
    self
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/filters.rb#L21" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-strip_heredoc">
            
              strip_heredoc()
            
          </h3>

          
            <div class="description">
              <p>Strips indentation in heredocs.</p>

<p>For example in</p>

<pre><code>if options[:usage]
  puts &lt;&lt;-USAGE.strip_heredoc
    This command does such and such.

    Supported options are:
      -h         This message
      ...
  USAGE
end
</code></pre>

<p>the user would see the usage message aligned against the left margin.</p>

<p>Technically, it looks for the least indented non-empty line in the whole string, and removes that amount of leading whitespace.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/strip.rb, line 22
  def strip_heredoc
    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, &quot;&quot;).tap do |stripped|
      stripped.freeze if frozen?
    end
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/strip.rb#L22" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-tableize">
            
              tableize()
            
          </h3>

          
            <div class="description">
              <p>Creates the name of a table like Rails does for models to table names. This method uses the <code>pluralize</code> method on the last word in the string.</p>

<pre><code>&#39;RawScaledScorer&#39;.tableize # =&gt; &quot;raw_scaled_scorers&quot;
&#39;ham_and_egg&#39;.tableize     # =&gt; &quot;ham_and_eggs&quot;
&#39;fancyCategory&#39;.tableize   # =&gt; &quot;fancy_categories&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-tableize"><code>ActiveSupport::Inflector.tableize</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 227
  def tableize
    ActiveSupport::Inflector.tableize(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L227" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-titlecase">
            
              titlecase(keep_id_suffix: false)
            
          </h3>

          
            <div class="description">
              
            </div>
          

          

          
            <div class="aka">
              Alias for: <a href="String.html#method-i-titleize">titleize</a>
            </div>
          

          
          
        </div>
        
        <div class="method">
          <h3 id="method-i-titleize">
            
              titleize(keep_id_suffix: false)
            
          </h3>

          
            <div class="description">
              <p>Capitalizes all the words and replaces some characters in the string to create a nicer looking title. <code>titleize</code> is meant for creating pretty output. It is not used in the Rails internals.</p>

<p>The trailing ‘_id’,‘Id’.. can be kept and capitalized by setting the optional parameter <code>keep_id_suffix</code> to true. By default, this parameter is false.</p>

<pre><code>&#39;man from the boondocks&#39;.titleize                       # =&gt; &quot;Man From The Boondocks&quot;
&#39;x-men: the last stand&#39;.titleize                        # =&gt; &quot;X Men: The Last Stand&quot;
&#39;string_ending_with_id&#39;.titleize(keep_id_suffix: true)  # =&gt; &quot;String Ending With Id&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-titleize"><code>ActiveSupport::Inflector.titleize</code></a>.</p>
            </div>
          

          
            <div class="aka">
              Also aliased as: <a href="String.html#method-i-titlecase">titlecase</a>
            </div>
          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 126
  def titleize(keep_id_suffix: false)
    ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L126" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-to">
            
              to(position)
            
          </h3>

          
            <div class="description">
              <p>Returns a substring from the beginning of the string to the given position. If the position is negative, it is counted from the end of the string.</p>

<pre><code>str = &quot;hello&quot;
str.to(0)  # =&gt; &quot;h&quot;
str.to(3)  # =&gt; &quot;hell&quot;
str.to(-2) # =&gt; &quot;hell&quot;
</code></pre>

<p>You can mix it with <code>from</code> method and do fun things like:</p>

<pre><code>str = &quot;hello&quot;
str.from(0).to(-1) # =&gt; &quot;hello&quot;
str.from(1).to(-2) # =&gt; &quot;ell&quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/access.rb, line 63
  def to(position)
    position += size if position &lt; 0
    self[0, position + 1] || +&quot;&quot;
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/access.rb#L63" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-to_date">
            
              to_date()
            
          </h3>

          
            <div class="description">
              <p>Converts a string to a <a href="Date.html"><code>Date</code></a> value.</p>

<pre><code>&quot;1-1-2012&quot;.to_date   # =&gt; Sun, 01 Jan 2012
&quot;01/01/2012&quot;.to_date # =&gt; Sun, 01 Jan 2012
&quot;2012-12-13&quot;.to_date # =&gt; Thu, 13 Dec 2012
&quot;12/13/2012&quot;.to_date # =&gt; ArgumentError: invalid date
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/conversions.rb, line 47
  def to_date
    ::Date.parse(self, false) unless blank?
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/conversions.rb#L47" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-to_datetime">
            
              to_datetime()
            
          </h3>

          
            <div class="description">
              <p>Converts a string to a <a href="DateTime.html"><code>DateTime</code></a> value.</p>

<pre><code>&quot;1-1-2012&quot;.to_datetime            # =&gt; Sun, 01 Jan 2012 00:00:00 +0000
&quot;01/01/2012 23:59:59&quot;.to_datetime # =&gt; Sun, 01 Jan 2012 23:59:59 +0000
&quot;2012-12-13 12:50&quot;.to_datetime    # =&gt; Thu, 13 Dec 2012 12:50:00 +0000
&quot;12/13/2012&quot;.to_datetime          # =&gt; ArgumentError: invalid date
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/conversions.rb, line 57
  def to_datetime
    ::DateTime.parse(self, false) unless blank?
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/conversions.rb#L57" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-to_time">
            
              to_time(form = :local)
            
          </h3>

          
            <div class="description">
              <p>Converts a string to a <a href="Time.html"><code>Time</code></a> value. The <code>form</code> can be either <code>:utc</code> or <code>:local</code> (default <code>:local</code>).</p>

<p>The time is parsed using Time.parse method. If <code>form</code> is <code>:local</code>, then the time is in the system timezone. If the date part is missing then the current date is used and if the time part is missing then it is assumed to be 00:00:00.</p>

<pre><code>&quot;13-12-2012&quot;.to_time               # =&gt; 2012-12-13 00:00:00 +0100
&quot;06:12&quot;.to_time                    # =&gt; 2012-12-13 06:12:00 +0100
&quot;2012-12-13 06:12&quot;.to_time         # =&gt; 2012-12-13 06:12:00 +0100
&quot;2012-12-13T06:12&quot;.to_time         # =&gt; 2012-12-13 06:12:00 +0100
&quot;2012-12-13T06:12&quot;.to_time(:utc)   # =&gt; 2012-12-13 06:12:00 UTC
&quot;12/13/2012&quot;.to_time               # =&gt; ArgumentError: argument out of range
&quot;1604326192&quot;.to_time               # =&gt; ArgumentError: argument out of range
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/conversions.rb, line 22
  def to_time(form = :local)
    parts = Date._parse(self, false)
    used_keys = %i(year mon mday hour min sec sec_fraction offset)
    return if !parts.keys.intersect?(used_keys)

    now = Time.now
    time = Time.new(
      parts.fetch(:year, now.year),
      parts.fetch(:mon, now.month),
      parts.fetch(:mday, now.day),
      parts.fetch(:hour, 0),
      parts.fetch(:min, 0),
      parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
      parts.fetch(:offset, form == :utc ? 0 : nil)
    )

    form == :utc ? time.utc : time.to_time
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/conversions.rb#L22" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-truncate">
            
              truncate(truncate_to, options = {})
            
          </h3>

          
            <div class="description">
              <p>Truncates a given <code>text</code> to length <code>truncate_to</code> if <code>text</code> is longer than <code>truncate_to</code>:</p>

<pre><code>&#39;Once upon a time in a world far far away&#39;.truncate(27)
# =&gt; &quot;Once upon a time in a wo...&quot;
</code></pre>

<p>Pass a string or regexp <code>:separator</code> to truncate <code>text</code> at a natural break:</p>

<pre><code>&#39;Once upon a time in a world far far away&#39;.truncate(27, separator: &#39; &#39;)
# =&gt; &quot;Once upon a time in a...&quot;

&#39;Once upon a time in a world far far away&#39;.truncate(27, separator: /\s/)
# =&gt; &quot;Once upon a time in a...&quot;
</code></pre>

<p>The last characters will be replaced with the <code>:omission</code> string (defaults to “…”). The total length will not exceed <code>truncate_to</code> unless both <code>text</code> and <code>:omission</code> are longer than <code>truncate_to</code>:</p>

<pre><code>&#39;And they found that many people were sleeping better.&#39;.truncate(25, omission: &#39;... (continued)&#39;)
# =&gt; &quot;And they f... (continued)&quot;

&#39;And they found that many people were sleeping better.&#39;.truncate(4, omission: &#39;... (continued)&#39;)
# =&gt; &quot;... (continued)&quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/filters.rb, line 70
  def truncate(truncate_to, options = {})
    return dup unless length &gt; truncate_to

    omission = options[:omission] || &quot;...&quot;
    length_with_room_for_omission = truncate_to - omission.length
    stop = \
      if options[:separator]
        rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
      else
        length_with_room_for_omission
      end

    +&quot;#{self[0, stop]}#{omission}&quot;
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/filters.rb#L70" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-truncate_bytes">
            
              truncate_bytes(truncate_to, omission: &quot;…&quot;)
            
          </h3>

          
            <div class="description">
              <p>Truncates <code>text</code> to at most <code>truncate_to</code> bytes in length without breaking string encoding by splitting multibyte characters or breaking grapheme clusters (“perceptual characters”) by truncating at combining characters.</p>

<pre><code>&gt;&gt; &quot;🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪&quot;.size
=&gt; 20
&gt;&gt; &quot;🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪&quot;.bytesize
=&gt; 80
&gt;&gt; &quot;🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪&quot;.truncate_bytes(20)
=&gt; &quot;🔪🔪🔪🔪…&quot;
</code></pre>

<p>The truncated text ends with the <code>:omission</code> string, defaulting to “…”, for a total length not exceeding <code>truncate_to</code>.</p>

<p>Raises <code>ArgumentError</code> when the bytesize of <code>:omission</code> exceeds <code>truncate_to</code>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/filters.rb, line 101
  def truncate_bytes(truncate_to, omission: &quot;…&quot;)
    omission ||= &quot;&quot;

    case
    when bytesize &lt;= truncate_to
      dup
    when omission.bytesize &gt; truncate_to
      raise ArgumentError, &quot;Omission #{omission.inspect} is #{omission.bytesize}, larger than the truncation length of #{truncate_to} bytes&quot;
    when omission.bytesize == truncate_to
      omission.dup
    else
      self.class.new.force_encoding(encoding).tap do |cut|
        cut_at = truncate_to - omission.bytesize

        each_grapheme_cluster do |grapheme|
          if cut.bytesize + grapheme.bytesize &lt;= cut_at
            cut &lt;&lt; grapheme
          else
            break
          end
        end

        cut &lt;&lt; omission
      end
    end
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/filters.rb#L101" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-truncate_words">
            
              truncate_words(words_count, options = {})
            
          </h3>

          
            <div class="description">
              <p>Truncates a given <code>text</code> after a given number of words (<code>words_count</code>):</p>

<pre><code>&#39;Once upon a time in a world far far away&#39;.truncate_words(4)
# =&gt; &quot;Once upon a time...&quot;
</code></pre>

<p>Pass a string or regexp <code>:separator</code> to specify a different separator of words:</p>

<pre><code>&#39;Once&lt;br&gt;upon&lt;br&gt;a&lt;br&gt;time&lt;br&gt;in&lt;br&gt;a&lt;br&gt;world&#39;.truncate_words(5, separator: &#39;&lt;br&gt;&#39;)
# =&gt; &quot;Once&lt;br&gt;upon&lt;br&gt;a&lt;br&gt;time&lt;br&gt;in...&quot;
</code></pre>

<p>The last characters will be replaced with the <code>:omission</code> string (defaults to “…”):</p>

<pre><code>&#39;And they found that many people were sleeping better.&#39;.truncate_words(5, omission: &#39;... (continued)&#39;)
# =&gt; &quot;And they found that many... (continued)&quot;
</code></pre>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/filters.rb, line 142
  def truncate_words(words_count, options = {})
    sep = options[:separator] || /\s+/
    sep = Regexp.escape(sep.to_s) unless Regexp === sep
    if self =~ /\A((?&gt;.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
      $1 + (options[:omission] || &quot;...&quot;)
    else
      dup
    end
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/filters.rb#L142" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-underscore">
            
              underscore()
            
          </h3>

          
            <div class="description">
              <p>The reverse of <code>camelize</code>. Makes an underscored, lowercase form from the expression in the string.</p>

<p><code>underscore</code> will also change ‘::’ to ‘/’ to convert namespaces to paths.</p>

<pre><code>&#39;ActiveModel&#39;.underscore         # =&gt; &quot;active_model&quot;
&#39;ActiveModel::Errors&#39;.underscore # =&gt; &quot;active_model/errors&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-underscore"><code>ActiveSupport::Inflector.underscore</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 139
  def underscore
    ActiveSupport::Inflector.underscore(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L139" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
        <div class="method">
          <h3 id="method-i-upcase_first">
            
              upcase_first()
            
          </h3>

          
            <div class="description">
              <p>Converts the first character to uppercase.</p>

<pre><code>&#39;what a Lovely Day&#39;.upcase_first # =&gt; &quot;What a Lovely Day&quot;
&#39;w&#39;.upcase_first                 # =&gt; &quot;W&quot;
&#39;&#39;.upcase_first                  # =&gt; &quot;&quot;
</code></pre>

<p>See <a href="ActiveSupport/Inflector.html#method-i-upcase_first"><code>ActiveSupport::Inflector.upcase_first</code></a>.</p>
            </div>
          

          

          

          
          
            <details class="method__source">
              <summary>
                <span class="label">📝 Source code</span>
              </summary>

              <pre><code class="ruby"># File activesupport/lib/active_support/core_ext/string/inflections.rb, line 273
  def upcase_first
    ActiveSupport::Inflector.upcase_first(self)
  end</code></pre>
              
                <a href="https://github.com/rails/rails/blob/dd8f7185faeca6ee968a6e9367f6d8601a83b8db/activesupport/lib/active_support/core_ext/string/inflections.rb#L273" target="_blank" class="github_url">🔎 See on GitHub</a>
              
            </details>
          
        </div>
        
      
    
  
</div>

    </div>
</div>