класс String

# File activesupport/lib/active_support/core_ext/string/behavior.rb, line 5
def acts_like_string?
  true
end

Включает более предсказуемую типизацию по утку для классов, подобных строкам. См. Object#acts_like?.

# File activesupport/lib/active_support/core_ext/string/access.rb, line 29
def at(position)
  self[position]
end

Если вы передаёте одно целое число, возвращает подстроку длиной в один символ в указанной позиции. Первый символ строки находится в позиции 0, следующий — в позиции 1 и так далее. Если передаётся диапазон, возвращается подстрока, содержащая символы в указанных позициях диапазона. В обоих случаях, если смещение отрицательное, оно вычисляется от конца строки. Возвращает nil, если начальное смещение выходит за пределы строки. Возвращает пустую строку, если начало диапазона больше конца строки.

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)  # => ""

Если передан объект Regexp, возвращается соответствующая часть строки. Если передан объект String, возвращается переданная строка, если она встречается в текущей строке. В обоих случаях, nil возвращается, если совпадения нет.

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/object/blank.rb, line 122
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

Строка считается пустой, если она пустая или содержит только пробелы:

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

Поддерживаются пробелы Юникода:

"\u00a0".blank? # => true

@return [true, false]

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 91
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, "Invalid option, use either :upper or :lower."
  end
end

По умолчанию, camelize преобразует строки в UpperCamelCase. Если аргумент для camelize установлен в :lower, то camelize генерирует lowerCamelCase.

camelize также преобразует '/' в '::', что полезно для преобразования путей в пространства имён.

'active_record'.camelize                # => "ActiveRecord"
'active_record'.camelize(:lower)        # => "activeRecord"
'active_record/errors'.camelize         # => "ActiveRecord::Errors"
'active_record/errors'.camelize(:lower) # => "activeRecord::Errors"

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 210
def classify
  ActiveSupport::Inflector.classify(self)
end

Создаёт имя класса из множественного имени таблицы, как это делает Rails для имён таблиц в модели. Обратите внимание, что это возвращает строку, а не класс. (Для преобразования в фактический класс следуйте classify с constantize.)

'ham_and_eggs'.classify # => "HamAndEgg"
'posts'.classify        # => "Post"

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 67
def constantize
  ActiveSupport::Inflector.constantize(self)
end

constantize пытается найти объявленную константу с именем, указанным в строке. Вызывает исключение NameError, когда имя не в CamelCase или не инициализировано. См. 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, line 134
def dasherize
  ActiveSupport::Inflector.dasherize(self)
end

Заменяет подчёркивания дефисами в строке.

'puni_puni'.dasherize # => "puni-puni"

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

Удаляет самый правый сегмент из выражения константы в строке.

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

См. также demodulize.

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 146
def demodulize
  ActiveSupport::Inflector.demodulize(self)
end

Удаляет часть модуля из выражения константы в строке.

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

См. также deconstantize.

# File activesupport/lib/active_support/core_ext/string/exclude.rb, line 10
def exclude?(string)
  !include?(string)
end

Обратное String#include?. Возвращает true, если строка не содержит другую строку.

"hello".exclude? "lo" # => false
"hello".exclude? "ol" # => true
"hello".exclude? ?h   # => false

# File activesupport/lib/active_support/core_ext/string/access.rb, line 77
def first(limit = 1)
  if limit == 0
    ""
  elsif limit >= size
    dup
  else
    to(limit - 1)
  end
end

Возвращает первый символ. Если передан лимит, возвращает подстроку с начала строки до достижения значения лимита. Если переданный лимит больше или равен длине строки, возвращает копию 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/inflections.rb, line 251
def foreign_key(separate_class_name_and_id_with_underscore = true)
  ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
end

Создаёт имя внешнего ключа из имени класса. separate_class_name_and_id_with_underscore устанавливает, должен ли метод вставлять '_' между именем и '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/access.rb, line 46
def from(position)
  self[position..-1]
end

Возвращает подстроку от указанной позиции до конца строки. Если позиция отрицательная, она вычисляется от конца строки.

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

Вы можете комбинировать её с методом to и выполнять интересные действия, например:

str = "hello"
str.from(0).to(-1) # => "hello"
str.from(1).to(-2) # => "ell"

# File activesupport/lib/active_support/core_ext/string/output_safety.rb, line 255
def html_safe
  ActiveSupport::SafeBuffer.new(self)
end

Помечает строку как надёжно безопасную. Она будет вставлена в HTML без дополнительной обработки экранирования. Вам необходимо убедиться, что строка не содержит вредоносных данных. Этот метод эквивалентен helper-методу raw в представлениях. Рекомендуется использовать sanitize вместо этого метода. Его никогда не следует вызывать для входных данных пользователя.

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 231
def humanize(capitalize: true, keep_id_suffix: false)
  ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix)
end

Выводит первое слово с большой буквы, заменяет подчёркивания пробелами и (по умолчанию) удаляет постфикс '_id', если он присутствует. Как и titleize, этот метод предназначен для создания красивого вывода.

Регистр первой буквы можно отключить, установив необязательный параметр capitalize в false. По умолчанию этот параметр равен true.

Постфикс '_id' можно сохранить и вывести с большой буквы, установив необязательный параметр keep_id_suffix в true. По умолчанию этот параметр равен 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/zones.rb, line 9
def in_time_zone(zone = ::Time.zone)
  if zone
    ::Time.find_zone!(zone).parse(self)
  else
    to_time
  end
end

Преобразует строку в TimeWithZone в текущей зоне, если Time.zone или Time.zone_default установлены, иначе преобразует строку в Time с помощью #to_time

# 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

Отступает строки в получателе:

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

Второй аргумент, indent_string, задаёт используемую строку отступа. По умолчанию используется nil, что позволяет методу сделать предположение, просматривая первую отстучаенную строку, и использовать пробел в качестве альтернативы, если таковой нет.

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

Хотя indent_string обычно представляет собой один пробел или табуляцию, это может быть любая строка.

Третий аргумент, indent_empty_lines, — это флаг, указывающий, нужно ли отступать пустые строки. По умолчанию значение 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, line 7
def indent!(amount, indent_string = nil, indent_empty_lines = false)
  indent_string = indent_string || self[/^[ \t]/] || " "
  re = indent_empty_lines ? /^/ : /^(?!$)/
  gsub!(re, indent_string * amount)
end

То же, что и indent, но отступы применяются к получателю непосредственно.

Возвращает отформатированную строку или nil, если отступы применить было не к чему.

# File activesupport/lib/active_support/core_ext/string/inquiry.rb, line 12
def inquiry
  ActiveSupport::StringInquirer.new(self)
end

Оборачивает текущую строку в класс ActiveSupport::StringInquirer, что предоставляет более удобный способ проверки на равенство.

env = 'production'.inquiry
env.production?  # => true
env.development? # => false

# File activesupport/lib/active_support/core_ext/string/multibyte.rb, line 47
def is_utf8?
  case encoding
  when Encoding::UTF_8
    valid_encoding?
  when Encoding::ASCII_8BIT, Encoding::US_ASCII
    dup.force_encoding(Encoding::UTF_8).valid_encoding?
  else
    false
  end
end

Возвращает true, если строка имеет кодировку utf_8.

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/access.rb, line 97
def last(limit = 1)
  if limit == 0
    ""
  elsif limit >= size
    dup
  else
    from(-limit)
  end
end

Возвращает последний символ строки. Если задан предел, возвращает подстроку от конца строки до значения предела (считая с конца). Если заданный предел больше или равен длине строки, возвращает копию 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/multibyte.rb, line 36
def mb_chars
  ActiveSupport::Multibyte.proxy_class.new(self)
end

Многобайтовый прокси

mb_chars — многобайтовый безопасный прокси для методов строк.

Создаёт и возвращает экземпляр класса ActiveSupport::Multibyte::Chars, который инкапсулирует исходную строку. В этом классе определены безопасные версии всех методов класса String для работы с Юникодом. Если прокси-классу не отвечает определённый метод, запрос перенаправляется инкапсулированной строке.

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

ПРИМЕЧАНИЕ: Приведённый выше пример полезен для версий Ruby до 2.4. В Ruby 2.4 поддерживаются преобразования регистра Unicode.

Цепочки методов

Все методы прокси Chars, которые обычно возвращают строку, будут возвращать объект Chars. Это позволяет создавать цепочки методов на результатах выполнения любых из этих методов.

name.mb_chars.reverse.length # => 12

Взаимодействие и настройка

Объект Chars старается максимально взаимодействовать с объектами String: сортировка и сравнение между String и Char работают как ожидается. Методы с суффиксом bang! изменяют внутреннее представление строки в объекте Chars. Проблемы взаимодействия легко решаются с помощью вызова to_s.

Дополнительную информацию о методах, определённых в прокси Chars, см. в ActiveSupport::Multibyte::Chars. Дополнительную информацию о способах изменения стандартного многобайтового поведения см. в ActiveSupport::Multibyte.

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 190
def parameterize(separator: "-", preserve_case: false)
  ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case)
end

Заменяет специальные символы в строке, чтобы её можно было использовать в качестве части «красивого» URL.

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>

Чтобы сохранить регистр символов в строке, используйте аргумент preserve_case.

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, line 33
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

Возвращает множественное число слова в строке.

Если указан необязательный параметр count, возвращается единственное число, если count == 1. Для любого другого значения count возвращается множественное число.

Если указан необязательный параметр locale, слово будет склонено по правилам языка. По умолчанию этот параметр установлен в :en. Для языков, отличных от английского, необходимо определить собственные правила склонения.

'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/filters.rb, line 32
def remove(*patterns)
  dup.remove!(*patterns)
end

Возвращает новую строку со всеми вхождениями шаблонов, удалёнными.

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, line 40
def remove!(*patterns)
  patterns.each do |pattern|
    gsub! pattern, ""
  end

  self
end

Изменяет строку, удаляя все вхождения шаблонов.

str = "foo bar test"
str.remove!(" test", /bar/)         # => "foo "
str                                 # => "foo "

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 78
def safe_constantize
  ActiveSupport::Inflector.safe_constantize(self)
end

safe_constantize пытается найти объявленную константу с именем, указанным в строке. Возвращает nil, если имя не соответствует правилам CamelCase или не инициализировано. См. 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, line 56
def singularize(locale = :en)
  ActiveSupport::Inflector.singularize(self, locale)
end

Обратное pluralize, возвращает единственное число слова в строке.

Если указан необязательный параметр locale, слово будет приведено к единственному числу по правилам языка. По умолчанию этот параметр установлен в :en. Для языков, отличных от английского, необходимо определить собственные правила склонения.

'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/filters.rb, line 13
def squish
  dup.squish!
end

Возвращает строку, сначала удаляя все пробелы в начале и конце строки, а затем заменяя оставшиеся группы пробелов на один пробел.

Обратите внимание, что он обрабатывает как ASCII, так и Unicode пробелы.

%{ 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, line 21
def squish!
  gsub!(/[[:space:]]+/, " ")
  strip!
  self
end

Производит деструктивное сжатие. См. #squish.

str = " foo   bar    \n   \t   boo"
str.squish!                         # => "foo bar boo"
str                                 # => "foo bar boo"

# File activesupport/lib/active_support/core_ext/string/strip.rb, line 22
def strip_heredoc
  gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "".freeze)
end

Удаляет отступы в heredocs.

Например, в

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

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

пользователь увидит сообщение об использовании, выровненное по левому краю.

Технически, ищется самая левая непустая строка в строке и удаляется соответствующее количество начальных пробелов.

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 200
def tableize
  ActiveSupport::Inflector.tableize(self)
end

Создаёт имя таблицы, как это делает Rails для моделей и имён таблиц. Этот метод использует метод pluralize для последнего слова в строке.

'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, line 116
def titleize(keep_id_suffix: false)
  ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix)
end

Преобразует все слова в заглавные и заменяет некоторые символы в строке, чтобы создать более удобный заголовок. titleize предназначен для создания красивого вывода. Он не используется в внутренних механизмах Rails.

При необходимости можно сохранить и привести к верхнему регистру суффиксы «_id», «Id» и т.п. установив необязательный параметр keep_id_suffix в значение true. По умолчанию этот параметр равен false.

titleize также является псевдонимом для 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"

# File activesupport/lib/active_support/core_ext/string/access.rb, line 63
def to(position)
  self[0..position]
end

Возвращает подстроку, начиная с начала строки до заданной позиции. Если позиция отрицательная, она отсчитывается с конца строки.

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

Можно комбинировать его с методом from и делать интересные вещи, например:

str = "hello"
str.from(0).to(-1) # => "hello"
str.from(1).to(-2) # => "ell"

# File activesupport/lib/active_support/core_ext/string/conversions.rb, line 46
def to_date
  ::Date.parse(self, false) unless blank?
end

Преобразует строку в значение типа Date.

"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, line 56
def to_datetime
  ::DateTime.parse(self, false) unless blank?
end

Преобразует строку в значение типа DateTime.

"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, line 21
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 & used_keys).empty?

  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

Преобразует строку в значение типа Time. Параметр form может быть либо :utc, либо :local (по умолчанию :local).

Время разбирается с помощью метода Time.parse. Если form равен :local, то время находится в часовом поясе системы. Если часть даты отсутствует, используется текущая дата; если часть времени отсутствует, предполагается значение 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/filters.rb, line 66
def truncate(truncate_at, options = {})
  return dup unless length > truncate_at

  omission = options[:omission] || "..."
  length_with_room_for_omission = truncate_at - 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

  "#{self[0, stop]}#{omission}"
end

Усекает заданную text после заданной length, если text длиннее length:

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

Передайте строку или регулярное выражение :separator, чтобы усечь text на естественном разрыве:

'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..."

Последние символы будут заменены строкой :omission (по умолчанию «…») для общей длины, не превышающей 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, line 95
def truncate_words(words_count, options = {})
  sep = options[:separator] || /\s+/
  sep = Regexp.escape(sep.to_s) unless Regexp === sep
  if self =~ /\A((?>.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
    $1 + (options[:omission] || "...")
  else
    dup
  end
end

Усекает заданную text после заданного количества слов (words_count):

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

Передайте строку или регулярное выражение :separator, чтобы указать другой разделитель слов:

'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..."

Последние символы будут заменены строкой :omission (по умолчанию «…») :

'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/inflections.rb, line 127
def underscore
  ActiveSupport::Inflector.underscore(self)
end

Обратная операция к camelize. Создаёт нижний регистр с символами подчёркивания из выражения в строке.

underscore также заменит '::' на '/' для преобразования пространств имён в пути.

'ActiveModel'.underscore         # => "active_model"
'ActiveModel::Errors'.underscore # => "active_model/errors"

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 240
def upcase_first
  ActiveSupport::Inflector.upcase_first(self)
end

Преобразует только первый символ в верхний регистр.

'what a Lovely Day'.upcase_first # => "What a Lovely Day"
'w'.upcase_first                 # => "W"
''.upcase_first                  # => ""