String inflections define new methods on the String class to transform names for different purposes. For instance, you can figure out the name of a table from the name of a class.

'ScaleScore'.tableize # => "scale_scores"

Your patch goes here.

Methods
A
B
C
D
E
F
H
I
L
M
P
R
S
T
U
Constants
BLANK_RE = /\A[[:space:]]*\z/
 
ENCODED_BLANKS = Concurrent::Map.new do |h, enc| h[enc] = Regexp.new(BLANK_RE.source.encode(enc), BLANK_RE.options | Regexp::FIXEDENCODING) end
 
Instance Public methods
acts_like_string?()

Enables more predictable duck-typing on String-like classes. See Object#acts_like?.

  # File activesupport/lib/active_support/core_ext/string/behavior.rb
5 def acts_like_string?
6   true
7 end
at(position)

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 nil 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.

str = "hello"
str.at(0)      # => "h"
str.at(1..3)   # => "ell"
str.at(-2)     # => "l"
str.at(-2..-1) # => "lo"
str.at(5)      # => nil
str.at(5..-1)  # => ""

If a Regexp is given, the matching portion of the string is returned. If a String is given, that given string is returned if it occurs in the string. In both cases, nil is returned if there is no match.

str = "hello"
str.at(/lo/) # => "lo"
str.at(/ol/) # => nil
str.at("lo") # => "lo"
str.at("ol") # => nil
   # File activesupport/lib/active_support/core_ext/string/access.rb
29 def at(position)
30   self[position]
31 end
blank?()

A string is blank if it's empty or contains whitespaces only:

''.blank?       # => true
'   '.blank?    # => true
"\t\n\r".blank? # => true
' blah '.blank? # => false

Unicode whitespace is supported:

"\u00a0".blank? # => true

@return [true, false]

    # File activesupport/lib/active_support/core_ext/object/blank.rb
121 def blank?
122   # The regexp that matches blank strings is expensive. For the case of empty
123   # strings we can speed up this method (~3.5x) with an empty? call. The
124   # penalty for the rest of strings is marginal.
125   empty? ||
126     begin
127       BLANK_RE.match?(self)
128     rescue Encoding::CompatibilityError
129       ENCODED_BLANKS[self.encoding].match?(self)
130     end
131 end
camelcase(first_letter = :upper)
Alias for: camelize
camelize(first_letter = :upper)

By default, camelize converts strings to UpperCamelCase. If the argument to camelize is set to :lower then camelize produces lowerCamelCase.

camelize will also convert '/' to '::' which is useful for converting paths to namespaces.

'active_record'.camelize                # => "ActiveRecord"
'active_record'.camelize(:lower)        # => "activeRecord"
'active_record/errors'.camelize         # => "ActiveRecord::Errors"
'active_record/errors'.camelize(:lower) # => "activeRecord::Errors"
Also aliased as: camelcase
    # File activesupport/lib/active_support/core_ext/string/inflections.rb
 91 def camelize(first_letter = :upper)
 92   case first_letter
 93   when :upper
 94     ActiveSupport::Inflector.camelize(self, true)
 95   when :lower
 96     ActiveSupport::Inflector.camelize(self, false)
 97   else
 98     raise ArgumentError, "Invalid option, use either :upper or :lower."
 99   end
100 end
classify()

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 classify with constantize.)

'ham_and_eggs'.classify # => "HamAndEgg"
'posts'.classify        # => "Post"
    # File activesupport/lib/active_support/core_ext/string/inflections.rb
215 def classify
216   ActiveSupport::Inflector.classify(self)
217 end
constantize()

constantize tries to find a declared constant with the name specified in the string. It raises a NameError when the name is not in CamelCase or is not initialized. See ActiveSupport::Inflector.constantize

'Module'.constantize  # => Module
'Class'.constantize   # => Class
'blargle'.constantize # => NameError: wrong constant name blargle
   # File activesupport/lib/active_support/core_ext/string/inflections.rb
67 def constantize
68   ActiveSupport::Inflector.constantize(self)
69 end
dasherize()

Replaces underscores with dashes in the string.

'puni_puni'.dasherize # => "puni-puni"
    # File activesupport/lib/active_support/core_ext/string/inflections.rb
134 def dasherize
135   ActiveSupport::Inflector.dasherize(self)
136 end
deconstantize()

Removes the rightmost segment from the constant expression in the string.

'Net::HTTP'.deconstantize   # => "Net"
'::Net::HTTP'.deconstantize # => "::Net"
'String'.deconstantize      # => ""
'::String'.deconstantize    # => ""
''.deconstantize            # => ""

See also demodulize.

    # File activesupport/lib/active_support/core_ext/string/inflections.rb
159 def deconstantize
160   ActiveSupport::Inflector.deconstantize(self)
161 end
demodulize()

Removes the module part from the constant expression in the string.

'ActiveSupport::Inflector::Inflections'.demodulize # => "Inflections"
'Inflections'.demodulize                           # => "Inflections"
'::Inflections'.demodulize                         # => "Inflections"
''.demodulize                                      # => ''

See also deconstantize.

    # File activesupport/lib/active_support/core_ext/string/inflections.rb
146 def demodulize
147   ActiveSupport::Inflector.demodulize(self)
148 end
exclude?(string)

The inverse of String#include?. Returns true if the string does not include the other string.

"hello".exclude? "lo" # => false
"hello".exclude? "ol" # => true
"hello".exclude? ?h   # => false
   # File activesupport/lib/active_support/core_ext/string/exclude.rb
10 def exclude?(string)
11   !include?(string)
12 end
fast_blank?()
   # File guides/bug_report_templates/benchmark.rb
19 def fast_blank?
20   true
21 end
first(limit = 1)

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.

str = "hello"
str.first    # => "h"
str.first(1) # => "h"
str.first(2) # => "he"
str.first(0) # => ""
str.first(6) # => "hello"
   # File activesupport/lib/active_support/core_ext/string/access.rb
77 def first(limit = 1)
78   ActiveSupport::Deprecation.warn(
79     "Calling String#first with a negative integer limit " \
80     "will raise an ArgumentError in Rails 6.1."
81   ) if limit < 0
82   if limit == 0
83     ""
84   elsif limit >= size
85     dup
86   else
87     to(limit - 1)
88   end
89 end
foreign_key(separate_class_name_and_id_with_underscore = true)

Creates a foreign key name from a class name. separate_class_name_and_id_with_underscore sets whether the method should put '_' between the name and 'id'.

'Message'.foreign_key        # => "message_id"
'Message'.foreign_key(false) # => "messageid"
'Admin::Post'.foreign_key    # => "post_id"
    # File activesupport/lib/active_support/core_ext/string/inflections.rb
256 def foreign_key(separate_class_name_and_id_with_underscore = true)
257   ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
258 end
from(position)

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.

str = "hello"
str.from(0)  # => "hello"
str.from(3)  # => "lo"
str.from(-2) # => "lo"

You can mix it with to method and do fun things like:

str = "hello"
str.from(0).to(-1) # => "hello"
str.from(1).to(-2) # => "ell"
   # File activesupport/lib/active_support/core_ext/string/access.rb
46 def from(position)
47   self[position..-1]
48 end
html_safe()

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 raw helper in views. It is recommended that you use sanitize instead of this method. It should never be called on user input.

    # File activesupport/lib/active_support/core_ext/string/output_safety.rb
311 def html_safe
312   ActiveSupport::SafeBuffer.new(self)
313 end
humanize(capitalize: true, keep_id_suffix: false)

Capitalizes the first word, turns underscores into spaces, and (by default)strips a trailing '_id' if present. Like titleize, this is meant for creating pretty output.

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

The trailing '_id' can be kept and capitalized by setting the optional parameter keep_id_suffix to true. By default, this parameter is false.

'employee_salary'.humanize                    # => "Employee salary"
'author_id'.humanize                          # => "Author"
'author_id'.humanize(capitalize: false)       # => "author"
'_id'.humanize                                # => "Id"
'author_id'.humanize(keep_id_suffix: true)    # => "Author Id"
    # File activesupport/lib/active_support/core_ext/string/inflections.rb
236 def humanize(capitalize: true, keep_id_suffix: false)
237   ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix)
238 end
in_time_zone(zone = ::Time.zone)

Converts String to a TimeWithZone in the current zone if Time.zone or Time.zone_default is set, otherwise converts String to a Time via String#to_time

   # File activesupport/lib/active_support/core_ext/string/zones.rb
 9 def in_time_zone(zone = ::Time.zone)
10   if zone
11     ::Time.find_zone!(zone).parse(self)
12   else
13     to_time
14   end
15 end
indent(amount, indent_string = nil, indent_empty_lines = false)

Indents the lines in the receiver:

<<EOS.indent(2)
def some_method
  some_code
end
EOS
# =>
  def some_method
    some_code
  end

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

"  foo".indent(2)        # => "    foo"
"foo\n\t\tbar".indent(2) # => "\t\tfoo\n\t\t\t\tbar"
"foo".indent(2, "\t")    # => "\t\tfoo"

While indent_string is typically one space or tab, it may be any string.

The third argument, indent_empty_lines, is a flag that says whether empty lines should be indented. Default is false.

"foo\n\nbar".indent(2)            # => "  foo\n\n  bar"
"foo\n\nbar".indent(2, nil, true) # => "  foo\n  \n  bar"
   # File activesupport/lib/active_support/core_ext/string/indent.rb
42 def indent(amount, indent_string = nil, indent_empty_lines = false)
43   dup.tap { |_| _.indent!(amount, indent_string, indent_empty_lines) }
44 end
indent!(amount, indent_string = nil, indent_empty_lines = false)

Same as indent, except it indents the receiver in-place.

Returns the indented string, or nil if there was nothing to indent.

   # File activesupport/lib/active_support/core_ext/string/indent.rb
 7 def indent!(amount, indent_string = nil, indent_empty_lines = false)
 8   indent_string = indent_string || self[/^[ \t]/] || " "
 9   re = indent_empty_lines ? /^/ : /^(?!$)/
10   gsub!(re, indent_string * amount)
11 end
inquiry()

Wraps the current string in the ActiveSupport::StringInquirer class, which gives you a prettier way to test for equality.

env = 'production'.inquiry
env.production?  # => true
env.development? # => false
   # File activesupport/lib/active_support/core_ext/string/inquiry.rb
12 def inquiry
13   ActiveSupport::StringInquirer.new(self)
14 end
is_utf8?()

Returns true if string has utf_8 encoding.

utf_8_str = "some string".encode "UTF-8"
iso_str = "some string".encode "ISO-8859-1"

utf_8_str.is_utf8? # => true
iso_str.is_utf8?   # => false
   # File activesupport/lib/active_support/core_ext/string/multibyte.rb
48 def is_utf8?
49   case encoding
50   when Encoding::UTF_8
51     valid_encoding?
52   when Encoding::ASCII_8BIT, Encoding::US_ASCII
53     dup.force_encoding(Encoding::UTF_8).valid_encoding?
54   else
55     false
56   end
57 end
last(limit = 1)

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.

str = "hello"
str.last    # => "o"
str.last(1) # => "o"
str.last(2) # => "lo"
str.last(0) # => ""
str.last(6) # => "hello"
    # File activesupport/lib/active_support/core_ext/string/access.rb
101 def last(limit = 1)
102   ActiveSupport::Deprecation.warn(
103     "Calling String#last with a negative integer limit " \
104     "will raise an ArgumentError in Rails 6.1."
105   ) if limit < 0
106   if limit == 0
107     ""
108   elsif limit >= size
109     dup
110   else
111     from(-limit)
112   end
113 end
mb_chars()

Multibyte proxy

mb_chars is a multibyte safe proxy for string methods.

It creates and returns an instance of the ActiveSupport::Multibyte::Chars class which encapsulates the original string. A Unicode safe version of all the String 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.

>> "lj".mb_chars.upcase.to_s
=> "LJ"

NOTE: Ruby 2.4 and later support native Unicode case mappings:

>> "lj".upcase
=> "LJ"

Method chaining

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.

name.mb_chars.reverse.length # => 12

Interoperability and configuration

The Chars object tries to be as interchangeable with String objects as possible: sorting and comparing between String 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 to_s call.

For more information about the methods defined on the Chars proxy see ActiveSupport::Multibyte::Chars. For information about how to change the default Multibyte behavior see ActiveSupport::Multibyte.

   # File activesupport/lib/active_support/core_ext/string/multibyte.rb
37 def mb_chars
38   ActiveSupport::Multibyte.proxy_class.new(self)
39 end
parameterize(separator: "-", preserve_case: false, locale: nil)

Replaces special characters in a string so that it may be used as part of a 'pretty' URL.

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

class Person
  def to_param
    "#{id}-#{name.parameterize}"
  end
end

@person = Person.find(1)
# => #<Person id: 1, name: "Donald E. Knuth">

<%= link_to(@person.name, person_path) %>
# => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>

To preserve the case of the characters in a string, use the preserve_case argument.

class Person
  def to_param
    "#{id}-#{name.parameterize(preserve_case: true)}"
  end
end

@person = Person.find(1)
# => #<Person id: 1, name: "Donald E. Knuth">

<%= link_to(@person.name, person_path) %>
# => <a href="/person/1-Donald-E-Knuth">Donald E. Knuth</a>
    # File activesupport/lib/active_support/core_ext/string/inflections.rb
195 def parameterize(separator: "-", preserve_case: false, locale: nil)
196   ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case, locale: locale)
197 end
pluralize(count = nil, locale = :en)

Returns the plural form of the word in the string.

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

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

'post'.pluralize             # => "posts"
'octopus'.pluralize          # => "octopi"
'sheep'.pluralize            # => "sheep"
'words'.pluralize            # => "words"
'the blue mailman'.pluralize # => "the blue mailmen"
'CamelOctopus'.pluralize     # => "CamelOctopi"
'apple'.pluralize(1)         # => "apple"
'apple'.pluralize(2)         # => "apples"
'ley'.pluralize(:es)         # => "leyes"
'ley'.pluralize(1, :es)      # => "ley"
   # File activesupport/lib/active_support/core_ext/string/inflections.rb
33 def pluralize(count = nil, locale = :en)
34   locale = count if count.is_a?(Symbol)
35   if count == 1
36     dup
37   else
38     ActiveSupport::Inflector.pluralize(self, locale)
39   end
40 end
remove(*patterns)

Returns a new string with all occurrences of the patterns removed.

str = "foo bar test"
str.remove(" test")                 # => "foo bar"
str.remove(" test", /bar/)          # => "foo "
str                                 # => "foo bar test"
   # File activesupport/lib/active_support/core_ext/string/filters.rb
32 def remove(*patterns)
33   dup.remove!(*patterns)
34 end
remove!(*patterns)

Alters the string by removing all occurrences of the patterns.

str = "foo bar test"
str.remove!(" test", /bar/)         # => "foo "
str                                 # => "foo "
   # File activesupport/lib/active_support/core_ext/string/filters.rb
40 def remove!(*patterns)
41   patterns.each do |pattern|
42     gsub! pattern, ""
43   end
44 
45   self
46 end
safe_constantize()

safe_constantize tries to find a declared constant with the name specified in the string. It returns nil when the name is not in CamelCase or is not initialized. See ActiveSupport::Inflector.safe_constantize

'Module'.safe_constantize  # => Module
'Class'.safe_constantize   # => Class
'blargle'.safe_constantize # => nil
   # File activesupport/lib/active_support/core_ext/string/inflections.rb
78 def safe_constantize
79   ActiveSupport::Inflector.safe_constantize(self)
80 end
singularize(locale = :en)

The reverse of pluralize, returns the singular form of a word in a string.

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

'posts'.singularize            # => "post"
'octopi'.singularize           # => "octopus"
'sheep'.singularize            # => "sheep"
'word'.singularize             # => "word"
'the blue mailmen'.singularize # => "the blue mailman"
'CamelOctopi'.singularize      # => "CamelOctopus"
'leyes'.singularize(:es)       # => "ley"
   # File activesupport/lib/active_support/core_ext/string/inflections.rb
56 def singularize(locale = :en)
57   ActiveSupport::Inflector.singularize(self, locale)
58 end
squish()

Returns the string, first removing all whitespace on both ends of the string, and then changing remaining consecutive whitespace groups into one space each.

Note that it handles both ASCII and Unicode whitespace.

%{ Multi-line
   string }.squish                   # => "Multi-line string"
" foo   bar    \n   \t   boo".squish # => "foo bar boo"
   # File activesupport/lib/active_support/core_ext/string/filters.rb
13 def squish
14   dup.squish!
15 end
squish!()

Performs a destructive squish. See String#squish.

str = " foo   bar    \n   \t   boo"
str.squish!                         # => "foo bar boo"
str                                 # => "foo bar boo"
   # File activesupport/lib/active_support/core_ext/string/filters.rb
21 def squish!
22   gsub!(/[[:space:]]+/, " ")
23   strip!
24   self
25 end
strip_heredoc()

Strips indentation in heredocs.

For example in

if options[:usage]
  puts <<-USAGE.strip_heredoc
    This command does such and such.

    Supported options are:
      -h         This message
      ...
  USAGE
end

the user would see the usage message aligned against the left margin.

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

   # File activesupport/lib/active_support/core_ext/string/strip.rb
22 def strip_heredoc
23   gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "").tap do |stripped|
24     stripped.freeze if frozen?
25   end
26 end
tableize()

Creates the name of a table like Rails does for models to table names. This method uses the pluralize method on the last word in the string.

'RawScaledScorer'.tableize # => "raw_scaled_scorers"
'ham_and_egg'.tableize     # => "ham_and_eggs"
'fancyCategory'.tableize   # => "fancy_categories"
    # File activesupport/lib/active_support/core_ext/string/inflections.rb
205 def tableize
206   ActiveSupport::Inflector.tableize(self)
207 end
titlecase(keep_id_suffix: false)
Alias for: titleize
titleize(keep_id_suffix: false)

Capitalizes all the words and replaces some characters in the string to create a nicer looking title. titleize is meant for creating pretty output. It is not used in the Rails internals.

The trailing '_id','Id'.. can be kept and capitalized by setting the optional parameter keep_id_suffix to true. By default, this parameter is false.

titleize is also aliased as titlecase.

'man from the boondocks'.titleize                       # => "Man From The Boondocks"
'x-men: the last stand'.titleize                        # => "X Men: The Last Stand"
'string_ending_with_id'.titleize(keep_id_suffix: true)  # => "String Ending With Id"
Also aliased as: titlecase
    # File activesupport/lib/active_support/core_ext/string/inflections.rb
116 def titleize(keep_id_suffix: false)
117   ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix)
118 end
to(position)

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.

str = "hello"
str.to(0)  # => "h"
str.to(3)  # => "hell"
str.to(-2) # => "hell"

You can mix it with from method and do fun things like:

str = "hello"
str.from(0).to(-1) # => "hello"
str.from(1).to(-2) # => "ell"
   # File activesupport/lib/active_support/core_ext/string/access.rb
63 def to(position)
64   self[0..position]
65 end
to_date()

Converts a string to a Date value.

"1-1-2012".to_date   # => Sun, 01 Jan 2012
"01/01/2012".to_date # => Sun, 01 Jan 2012
"2012-12-13".to_date # => Thu, 13 Dec 2012
"12/13/2012".to_date # => ArgumentError: invalid date
   # File activesupport/lib/active_support/core_ext/string/conversions.rb
46 def to_date
47   ::Date.parse(self, false) unless blank?
48 end
to_datetime()

Converts a string to a DateTime value.

"1-1-2012".to_datetime            # => Sun, 01 Jan 2012 00:00:00 +0000
"01/01/2012 23:59:59".to_datetime # => Sun, 01 Jan 2012 23:59:59 +0000
"2012-12-13 12:50".to_datetime    # => Thu, 13 Dec 2012 12:50:00 +0000
"12/13/2012".to_datetime          # => ArgumentError: invalid date
   # File activesupport/lib/active_support/core_ext/string/conversions.rb
56 def to_datetime
57   ::DateTime.parse(self, false) unless blank?
58 end
to_time(form = :local)

Converts a string to a Time value. The form can be either :utc or :local (default :local).

The time is parsed using Time.parse method. If form is :local, 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.

"13-12-2012".to_time               # => 2012-12-13 00:00:00 +0100
"06:12".to_time                    # => 2012-12-13 06:12:00 +0100
"2012-12-13 06:12".to_time         # => 2012-12-13 06:12:00 +0100
"2012-12-13T06:12".to_time         # => 2012-12-13 06:12:00 +0100
"2012-12-13T06:12".to_time(:utc)   # => 2012-12-13 06:12:00 UTC
"12/13/2012".to_time               # => ArgumentError: argument out of range
   # File activesupport/lib/active_support/core_ext/string/conversions.rb
21 def to_time(form = :local)
22   parts = Date._parse(self, false)
23   used_keys = %i(year mon mday hour min sec sec_fraction offset)
24   return if (parts.keys & used_keys).empty?
25 
26   now = Time.now
27   time = Time.new(
28     parts.fetch(:year, now.year),
29     parts.fetch(:mon, now.month),
30     parts.fetch(:mday, now.day),
31     parts.fetch(:hour, 0),
32     parts.fetch(:min, 0),
33     parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
34     parts.fetch(:offset, form == :utc ? 0 : nil)
35   )
36 
37   form == :utc ? time.utc : time.to_time
38 end
truncate(truncate_at, options = {})

Truncates a given text after a given length if text is longer than length:

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

Pass a string or regexp :separator to truncate text at a natural break:

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

'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
# => "Once upon a time in a..."

The last characters will be replaced with the :omission string (defaults to “…”) for a total length not exceeding length:

'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')
# => "And they f... (continued)"
   # File activesupport/lib/active_support/core_ext/string/filters.rb
66 def truncate(truncate_at, options = {})
67   return dup unless length > truncate_at
68 
69   omission = options[:omission] || "..."
70   length_with_room_for_omission = truncate_at - omission.length
71   stop = \
72     if options[:separator]
73       rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
74     else
75       length_with_room_for_omission
76     end
77 
78   +"#{self[0, stop]}#{omission}"
79 end
truncate_bytes(truncate_at, omission: "…")

Truncates text to at most bytesize bytes in length without breaking string encoding by splitting multibyte characters or breaking grapheme clusters (“perceptual characters”) by truncating at combining characters.

>> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".size
=> 20
>> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".bytesize
=> 80
>> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".truncate_bytes(20)
=> "🔪🔪🔪🔪…"

The truncated text ends with the :omission string, defaulting to “…”, for a total length not exceeding bytesize.

    # File activesupport/lib/active_support/core_ext/string/filters.rb
 95 def truncate_bytes(truncate_at, omission: "…")
 96   omission ||= ""
 97 
 98   case
 99   when bytesize <= truncate_at
100     dup
101   when omission.bytesize > truncate_at
102     raise ArgumentError, "Omission #{omission.inspect} is #{omission.bytesize}, larger than the truncation length of #{truncate_at} bytes"
103   when omission.bytesize == truncate_at
104     omission.dup
105   else
106     self.class.new.tap do |cut|
107       cut_at = truncate_at - omission.bytesize
108 
109       scan(/\X/) do |grapheme|
110         if cut.bytesize + grapheme.bytesize <= cut_at
111           cut << grapheme
112         else
113           break
114         end
115       end
116 
117       cut << omission
118     end
119   end
120 end
truncate_words(words_count, options = {})

Truncates a given text after a given number of words (words_count):

'Once upon a time in a world far far away'.truncate_words(4)
# => "Once upon a time..."

Pass a string or regexp :separator to specify a different separator of words:

'Once<br>upon<br>a<br>time<br>in<br>a<br>world'.truncate_words(5, separator: '<br>')
# => "Once<br>upon<br>a<br>time<br>in..."

The last characters will be replaced with the :omission string (defaults to “…”):

'And they found that many people were sleeping better.'.truncate_words(5, omission: '... (continued)')
# => "And they found that many... (continued)"
    # File activesupport/lib/active_support/core_ext/string/filters.rb
136 def truncate_words(words_count, options = {})
137   sep = options[:separator] || /\s+/
138   sep = Regexp.escape(sep.to_s) unless Regexp === sep
139   if self =~ /\A((?>.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
140     $1 + (options[:omission] || "...")
141   else
142     dup
143   end
144 end
underscore()

The reverse of camelize. Makes an underscored, lowercase form from the expression in the string.

underscore will also change '::' to '/' to convert namespaces to paths.

'ActiveModel'.underscore         # => "active_model"
'ActiveModel::Errors'.underscore # => "active_model/errors"
    # File activesupport/lib/active_support/core_ext/string/inflections.rb
127 def underscore
128   ActiveSupport::Inflector.underscore(self)
129 end
upcase_first()

Converts just the first character to uppercase.

'what a Lovely Day'.upcase_first # => "What a Lovely Day"
'w'.upcase_first                 # => "W"
''.upcase_first                  # => ""
    # File activesupport/lib/active_support/core_ext/string/inflections.rb
245 def upcase_first
246   ActiveSupport::Inflector.upcase_first(self)
247 end