класс String

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

Обеспечивает более предсказуемую утиную типизацию для классов, похожих на String. См. 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 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

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

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

Поддерживаются пробельные символы Unicode:

"\u00a0".blank? # => true

@return [true, false]

# 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, "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"

См. ActiveSupport::Inflector.camelize.

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

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

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

См. ActiveSupport::Inflector.classify.

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

constantize пытается найти объявленную константу с именем, указанным в строке. Если имя не записано в CamelCase или константа не инициализирована, метод вызывает NameError.

'Module'.constantize  # => Module
'Class'.constantize   # => Class
'blargle'.constantize # => NameError: wrong constant name blargle

См. ActiveSupport::Inflector.constantize.

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

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

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

См. ActiveSupport::Inflector.dasherize.

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

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

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

См. ActiveSupport::Inflector.deconstantize.

См. также demodulize.

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

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

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

См. ActiveSupport::Inflector.demodulize.

См. также deconstantize.

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

Преобразует первый символ в строчный.

'If they enjoyed The Matrix'.downcase_first # => "if they enjoyed The Matrix"
'I'.downcase_first                          # => "i"
''.downcase_first                           # => ""

См. ActiveSupport::Inflector.downcase_first.

# 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 78
def first(limit = 1)
  self[0, limit] || raise(ArgumentError, "negative limit")
end

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

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

Создаёт имя внешнего ключа из имени класса. separate_class_name_and_id_with_underscore задаёт, должен ли метод ставить «_» между именем и «id».

'Message'.foreign_key        # => "message_id"
'Message'.foreign_key(false) # => "messageid"
'Admin::Post'.foreign_key    # => "post_id"

См. ActiveSupport::Inflector.foreign_key.

# File activesupport/lib/active_support/core_ext/string/access.rb, line 46
def from(position)
  self[position, length]
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 232
def html_safe
  ActiveSupport::SafeBuffer.new(self)
end

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

# 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

Преобразует первую букву первого слова в заглавную, заменяет символы подчёркивания пробелами и (по умолчанию) удаляет конечный «_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"

См. ActiveSupport::Inflector.humanize.

# 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

Преобразует String в TimeWithZone для текущего часового пояса, если задан Time.zone или Time.zone_default; в противном случае преобразует String в Time с помощью String#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 13
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 57
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

Возвращает 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 92
def last(limit = 1)
  self[[length - limit, 0].max, limit] || raise(ArgumentError, "negative limit")
end

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

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 37
def mb_chars
  ActiveSupport.deprecator.warn(
    "String#mb_chars is deprecated and will be removed in Rails 8.2. " \
    "Use normal string methods instead."
  )

  if ActiveSupport::Multibyte.proxy_class == ActiveSupport::Multibyte::Chars
    ActiveSupport::Multibyte::Chars.new(self, deprecation: false)
  else
    ActiveSupport::Multibyte.proxy_class.new(self)
  end
end

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

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

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

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

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

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

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

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

name.mb_chars.reverse.length # => 12

Совместимость и настройка

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

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

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

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

Если указан необязательный параметр locale, слово будет преобразовано с учётом правил указанного языка. По умолчанию этот параметр равен nil, и используется настроенная 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>

Чтобы сохранить регистр символов в строке, используйте аргумент 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>

См. ActiveSupport::Inflector.parameterize.

# 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

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

Если указан необязательный параметр 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"

См. ActiveSupport::Inflector.pluralize.

# 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 86
def safe_constantize
  ActiveSupport::Inflector.safe_constantize(self)
end

safe_constantize пытается найти объявленную константу с именем, указанным в строке. Если имя не записано в CamelCase или константа не инициализирована, метод возвращает nil.

'Module'.safe_constantize  # => Module
'Class'.safe_constantize   # => Class
'blargle'.safe_constantize # => nil

См. ActiveSupport::Inflector.safe_constantize.

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 60
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"

См. ActiveSupport::Inflector.singularize.

# 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

Выполняет необратимую нормализацию пробельных символов. См. 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/strip.rb, line 22
def strip_heredoc
  gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "").tap do |stripped|
    stripped.freeze if frozen?
  end
end

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

Например, в

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 227
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"

См. ActiveSupport::Inflector.tableize.

# 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

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

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

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

См. ActiveSupport::Inflector.titleize.

# File activesupport/lib/active_support/core_ext/string/access.rb, line 63
def to(position)
  position += size if position < 0
  self[0, position + 1] || +""
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 47
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 57
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 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

Преобразует строку в значение 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
"1604326192".to_time               # => ArgumentError: argument out of range

# File activesupport/lib/active_support/core_ext/string/filters.rb, line 70
def truncate(truncate_to, options = {})
  return dup unless length > truncate_to

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

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

Обрезает заданное значение text до длины truncate_to, если text длиннее, чем truncate_to:

'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 (по умолчанию — «…»). Общая длина не превысит truncate_to, если только и text, и :omission не длиннее, чем truncate_to:

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

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

# File activesupport/lib/active_support/core_ext/string/filters.rb, line 101
def truncate_bytes(truncate_to, omission: "…")
  omission ||= ""

  case
  when bytesize <= truncate_to
    dup
  when omission.bytesize > truncate_to
    raise ArgumentError, "Omission #{omission.inspect} is #{omission.bytesize}, larger than the truncation length of #{truncate_to} bytes"
  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 <= cut_at
          cut << grapheme
        else
          break
        end
      end

      cut << omission
    end
  end
end

Обрезает text до длины не более truncate_to байт, не нарушая кодировку строки из-за разделения многобайтовых символов и не разбивая графемные кластеры («воспринимаемые символы») при обрезке на комбинирующих символах.

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

В конце обрезанного текста добавляется строка :omission (по умолчанию — «…»); общая длина не превышает truncate_to.

Вызывает ArgumentError, если размер :omission в байтах превышает truncate_to.

# 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((?>.+?#{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 139
def underscore
  ActiveSupport::Inflector.underscore(self)
end

Противоположность camelize. Преобразует выражение в строке в форму нижнего регистра с подчёркиваниями.

underscore также заменяет «::» на «/», чтобы преобразовать пространства имён в пути.

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

См. ActiveSupport::Inflector.underscore.

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 273
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                  # => ""

См. ActiveSupport::Inflector.upcase_first.