модуль ActiveSupport::Inflector

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

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

'active_model'.camelize                # => "ActiveModel"
'active_model'.camelize(:lower)        # => "activeModel"
'active_model/errors'.camelize         # => "ActiveModel::Errors"
'active_model/errors'.camelize(:lower) # => "activeModel::Errors"

Как правило, можно считать, что camelize является обратным underscore, хотя есть случаи, когда это не так:

'SSLError'.underscore.camelize # => "SslError"

# File activesupport/lib/active_support/inflector/methods.rb, line 67
def camelize(term, uppercase_first_letter = true)
  string = term.to_s
  if uppercase_first_letter
    string = string.sub(/^[a-z\d]*/) { inflections.acronyms[$&] || $&.capitalize }
  else
    string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { $&.downcase }
  end
  string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
  string.gsub!('/', '::')
  string
end

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

'egg_and_hams'.classify # => "EggAndHam"
'posts'.classify        # => "Post"

Имена единственного числа обрабатываются некорректно:

'calculus'.classify     # => "Calculu"

# File activesupport/lib/active_support/inflector/methods.rb, line 157
def classify(table_name)
  # strip out any leading schema name
  camelize(singularize(table_name.to_s.sub(/.*\./, '')))
end

Пытается найти константу с именем, указанным в строке аргумента.

'Module'.constantize     # => Module
'Test::Unit'.constantize # => Test::Unit

Имя предполагается как имя константы верхнего уровня, независимо от того, начинается ли оно с «::» или нет. Не учитывается лексический контекст:

C = 'outside'
module M
  C = 'inside'
  C               # => 'inside'
  'C'.constantize # => 'outside', same as ::C
end

Возникает NameError, если имя не в формате CamelCase или константа неизвестна.

# File activesupport/lib/active_support/inflector/methods.rb, line 226
def constantize(camel_cased_word)
  names = camel_cased_word.split('::')

  # Trigger a builtin NameError exception including the ill-formed constant in the message.
  Object.const_get(camel_cased_word) if names.empty?

  # Remove the first blank element in case of '::ClassName' notation.
  names.shift if names.size > 1 && names.first.empty?

  names.inject(Object) do |constant, name|
    if constant == Object
      constant.const_get(name)
    else
      candidate = constant.const_get(name)
      next candidate if constant.const_defined?(name, false)
      next candidate unless Object.const_defined?(name)

      # Go down the ancestors to check it it's owned
      # directly before we reach Object or the end of ancestors.
      constant = constant.ancestors.inject do |const, ancestor|
        break const    if ancestor == Object
        break ancestor if ancestor.const_defined?(name, false)
        const
      end

      # owner is in Object, so raise
      constant.const_get(name, false)
    end
  end
end

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

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

# File activesupport/lib/active_support/inflector/methods.rb, line 165
def dasherize(underscored_word)
  underscored_word.tr('_', '-')
end

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

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

См. также demodulize.

# File activesupport/lib/active_support/inflector/methods.rb, line 193
def deconstantize(path)
  path.to_s[0, path.rindex('::') || 0] # implementation based on the one in facets' Module#spacename
end

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

'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
'Inflections'.demodulize                                       # => "Inflections"

См. также deconstantize.

# File activesupport/lib/active_support/inflector/methods.rb, line 175
def demodulize(path)
  path = path.to_s
  if i = path.rindex('::')
    path[(i+2)..-1]
  else
    path
  end
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/inflector/methods.rb, line 204
def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
  underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
end

Преобразует первое слово в заглавную букву, подчёркивания в пробелы и удаляет окончание '_id', если оно есть. Как и titleize, это предназначено для создания привлекательного вывода.

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

humanize('employee_salary')              # => "Employee salary"
humanize('author_id')                    # => "Author"
humanize('author_id', capitalize: false) # => "author"

# File activesupport/lib/active_support/inflector/methods.rb, line 111
def humanize(lower_case_and_underscored_word, options = {})
  result = lower_case_and_underscored_word.to_s.dup
  inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
  result.gsub!(/_id$/, "")
  result.tr!('_', ' ')
  result.gsub!(/([a-z\d]*)/i) { |match|
    "#{inflections.acronyms[match] || match.downcase}"
  }
  result.gsub!(/^\w/) { |match| match.upcase } if options.fetch(:capitalize, true)
  result
end

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

ActiveSupport::Inflector.inflections(:en) do |inflect|
  inflect.uncountable 'rails'
end

# File activesupport/lib/active_support/inflector/inflections.rb, line 203
def inflections(locale = :en)
  if block_given?
    yield Inflections.instance(locale)
  else
    Inflections.instance(locale)
  end
end

Возвращает суффикс, который следует добавить к числу, чтобы указать позицию в упорядоченной последовательности, например, 1-е, 2-е, 3-е, 4-е.

ordinal(1)     # => "st"
ordinal(2)     # => "nd"
ordinal(1002)  # => "nd"
ordinal(1003)  # => "rd"
ordinal(-11)   # => "th"
ordinal(-1021) # => "st"

# File activesupport/lib/active_support/inflector/methods.rb, line 297
def ordinal(number)
  abs_number = number.to_i.abs

  if (11..13).include?(abs_number % 100)
    "th"
  else
    case abs_number % 10
      when 1; "st"
      when 2; "nd"
      when 3; "rd"
      else    "th"
    end
  end
end

Преобразует число в строку порядкового номера, используемую для обозначения позиции в упорядоченной последовательности, например, 1-е, 2-е, 3-е, 4-е.

ordinalize(1)     # => "1st"
ordinalize(2)     # => "2nd"
ordinalize(1002)  # => "1002nd"
ordinalize(1003)  # => "1003rd"
ordinalize(-11)   # => "-11th"
ordinalize(-1021) # => "-1021st"

# File activesupport/lib/active_support/inflector/methods.rb, line 321
def ordinalize(number)
  "#{number}#{ordinal(number)}"
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(@person)) %>
# => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>

# File activesupport/lib/active_support/inflector/transliterate.rb, line 80
def parameterize(string, sep = '-')
  # replace accented chars with their ascii equivalents
  parameterized_string = transliterate(string)
  # Turn unwanted chars into the separator
  parameterized_string.gsub!(/[^a-z0-9\-_]+/i, sep)
  unless sep.nil? || sep.empty?
    re_sep = Regexp.escape(sep)
    # No more than one of the separator in a row.
    parameterized_string.gsub!(/#{re_sep}{2,}/, sep)
    # Remove leading/trailing separator.
    parameterized_string.gsub!(/^#{re_sep}|#{re_sep}$/i, '')
  end
  parameterized_string.downcase
end

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

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

'post'.pluralize             # => "posts"
'octopus'.pluralize          # => "octopi"
'sheep'.pluralize            # => "sheep"
'words'.pluralize            # => "words"
'CamelOctopus'.pluralize     # => "CamelOctopi"
'ley'.pluralize(:es)         # => "leyes"

# File activesupport/lib/active_support/inflector/methods.rb, line 30
def pluralize(word, locale = :en)
  apply_inflections(word, inflections(locale).plurals)
end

Пытается найти константу с именем, указанным в строке аргумента.

'Module'.safe_constantize     # => Module
'Test::Unit'.safe_constantize # => Test::Unit

Имя предполагается как имя константы верхнего уровня, независимо от того, начинается ли оно с «::» или нет. Не учитывается лексический контекст:

C = 'outside'
module M
  C = 'inside'
  C                    # => 'inside'
  'C'.safe_constantize # => 'outside', same as ::C
end

Возвращается nil, если имя не в формате CamelCase или константа (или её часть) неизвестна.

'blargle'.safe_constantize  # => nil
'UnknownModule'.safe_constantize  # => nil
'UnknownModule::Foo::Bar'.safe_constantize  # => nil

# File activesupport/lib/active_support/inflector/methods.rb, line 279
def safe_constantize(camel_cased_word)
  constantize(camel_cased_word)
rescue NameError => e
  raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
    e.name.to_s == camel_cased_word.to_s)
rescue ArgumentError => e
  raise unless e.message =~ /not missing constant #{const_regexp(camel_cased_word)}\!$/
end

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

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

'posts'.singularize            # => "post"
'octopi'.singularize           # => "octopus"
'sheep'.singularize            # => "sheep"
'word'.singularize             # => "word"
'CamelOctopi'.singularize      # => "CamelOctopus"
'leyes'.singularize(:es)       # => "ley"

# File activesupport/lib/active_support/inflector/methods.rb, line 47
def singularize(word, locale = :en)
  apply_inflections(word, inflections(locale).singulars)
end

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

'RawScaledScorer'.tableize # => "raw_scaled_scorers"
'egg_and_ham'.tableize     # => "egg_and_hams"
'fancyCategory'.tableize   # => "fancy_categories"

# File activesupport/lib/active_support/inflector/methods.rb, line 143
def tableize(class_name)
  pluralize(underscore(class_name))
end

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

titleize также псевдоним как titlecase.

'man from the boondocks'.titleize   # => "Man From The Boondocks"
'x-men: the last stand'.titleize    # => "X Men: The Last Stand"
'TheManWithoutAPast'.titleize       # => "The Man Without A Past"
'raiders_of_the_lost_ark'.titleize  # => "Raiders Of The Lost Ark"

# File activesupport/lib/active_support/inflector/methods.rb, line 133
def titleize(word)
  humanize(underscore(word)).gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
end

Заменяет не-ASCII символы приближенными ASCII-символами или, если таковых нет, символом-заменителем по умолчанию — «?».

transliterate('Ærøskøbing')
# => "AEroskobing"

Предварительно заданы приближения для символов западного/латинского алфавита, например, «ø», «ñ», «é», «ß» и т. д.

Этот метод учитывает I18n, поэтому вы можете настроить пользовательские приближения для локали. Это может быть полезно, например, для транслитерации немецких «ü» и «ö» в «ue» и «oe» или для добавления поддержки транслитерации русского языка в ASCII.

Чтобы ваши пользовательские транслитерации стали доступны, вы должны задать их в качестве ключа i18n:

Значение для i18n.transliterate.rule может быть простым списком, сопоставляющим символы с их приближениями в ASCII, как показано выше, или, для более сложных требований, процедурой:

I18n.backend.store_translations(:de, i18n: {
  transliterate: {
    rule: ->(string) { MyTransliterator.transliterate(string) }
  }
})

Теперь вы можете иметь разные транслитерации для каждой локали:

I18n.locale = :en
transliterate('Jürgen')
# => "Jurgen"

I18n.locale = :de
transliterate('Jürgen')
# => "Juergen"

# File activesupport/lib/active_support/inflector/transliterate.rb, line 60
def transliterate(string, replacement = "?")
  I18n.transliterate(ActiveSupport::Multibyte::Unicode.normalize(
    ActiveSupport::Multibyte::Unicode.tidy_bytes(string), :c),
      :replacement => replacement)
end

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

Заменяет «::» на «/» для преобразования имён пространств в пути.

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

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

'SSLError'.underscore.camelize # => "SslError"

# File activesupport/lib/active_support/inflector/methods.rb, line 90
def underscore(camel_cased_word)
  word = camel_cased_word.to_s.gsub('::', '/')
  word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
  word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
  word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
  word.tr!("-", "_")
  word.downcase!
  word
end