String (original) (raw)

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

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

Instance Public methods

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

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)
str.at(1..3)
str.at(-2)
str.at(-2..-1) str.at(5)
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/) str.at(/ol/) str.at("lo") str.at("ol")

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

''.blank?
' '.blank?
"\t\n\r".blank? ' blah '.blank?

Unicode whitespace is supported:

"\u00a0".blank?

@return [true, false]

Source: show | on GitHub

def blank?

empty? || begin BLANK_RE.match?(self) rescue Encoding::CompatibilityError ENCODED_BLANKS[self.encoding].match?(self) end end

camelcase(first_letter = :upper)Link

camelize(first_letter = :upper)Link

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
'active_record'.camelize(:lower)
'active_record/errors'.camelize
'active_record/errors'.camelize(:lower)

See ActiveSupport::Inflector.camelize.

Source: show | on GitHub

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

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 'posts'.classify

See ActiveSupport::Inflector.classify.

Source: show | on GitHub

def classify ActiveSupport::Inflector.classify(self) end

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.

'Module'.constantize
'Class'.constantize
'blargle'.constantize

See ActiveSupport::Inflector.constantize.

Source: show | on GitHub

def constantize ActiveSupport::Inflector.constantize(self) end

Source: show | on GitHub

def dasherize ActiveSupport::Inflector.dasherize(self) end

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

'Net::HTTP'.deconstantize
'::Net::HTTP'.deconstantize 'String'.deconstantize
'::String'.deconstantize
''.deconstantize

See ActiveSupport::Inflector.deconstantize.

See also demodulize.

Source: show | on GitHub

def deconstantize ActiveSupport::Inflector.deconstantize(self) end

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

'ActiveSupport::Inflector::Inflections'.demodulize 'Inflections'.demodulize
'::Inflections'.demodulize
''.demodulize

See ActiveSupport::Inflector.demodulize.

See also deconstantize.

Source: show | on GitHub

def demodulize ActiveSupport::Inflector.demodulize(self) end

Source: show | on GitHub

def downcase_first ActiveSupport::Inflector.downcase_first(self) end

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

"hello".exclude? "lo" "hello".exclude? "ol" "hello".exclude? ?h

Source: show | on GitHub

def exclude?(string) !include?(string) end

first(limit = 1)Link

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
str.first(1) str.first(2) str.first(0) str.first(6)

Source: show | on GitHub

def first(limit = 1) self[0, limit] || raise(ArgumentError, "negative limit") end

foreign_key(separate_class_name_and_id_with_underscore = true)Link

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'.foreign_key(false) 'Admin::Post'.foreign_key

See ActiveSupport::Inflector.foreign_key.

Source: show | on GitHub

def foreign_key(separate_class_name_and_id_with_underscore = true) ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore) end

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)
str.from(3)
str.from(-2)

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

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

Source: show | on GitHub

def from(position) self[position, length] end

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.

Source: show | on GitHub

def html_safe ActiveSupport::SafeBuffer.new(self) end

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
'author_id'.humanize
'author_id'.humanize(capitalize: false)
'_id'.humanize
'author_id'.humanize(keep_id_suffix: true)

See ActiveSupport::Inflector.humanize.

Source: show | on GitHub

def humanize(capitalize: true, keep_id_suffix: false) ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix) end

in_time_zone(zone = ::Time.zone)Link

Source: show | on GitHub

def in_time_zone(zone = ::Time.zone) if zone ::Time.find_zone!(zone).parse(self) else to_time end end

indent(amount, indent_string = nil, indent_empty_lines = false)Link

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 fall back to a space if there is none.

" foo".indent(2)
"foo\n\t\tbar".indent(2) "foo".indent(2, "\t")

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\nbar".indent(2, nil, true)

Source: show | on GitHub

def indent(amount, indent_string = nil, indent_empty_lines = false) dup.tap { |_| _.indent!(amount, indent_string, indent_empty_lines) } end

indent!(amount, indent_string = nil, indent_empty_lines = false)Link

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

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

Source: show | on GitHub

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

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

env = 'production'.inquiry env.production?
env.development?

Source: show | on GitHub

def inquiry ActiveSupport::StringInquirer.new(self) end

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? iso_str.is_utf8?

Source: show | on GitHub

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

last(limit = 1)Link

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
str.last(1) str.last(2) str.last(0) str.last(6)

Source: show | on GitHub

def last(limit = 1) self[[length - limit, 0].max, limit] || raise(ArgumentError, "negative limit") end

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

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.

Source: show | on GitHub

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

parameterize(separator: "-", preserve_case: false, locale: nil)Link

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

=> Donald E. Knuth

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

=> Donald E. Knuth

See ActiveSupport::Inflector.parameterize.

Source: show | on GitHub

def parameterize(separator: "-", preserve_case: false, locale: nil) ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case, locale: locale) end

pluralize(count = nil, locale = :en)Link

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
'octopus'.pluralize
'sheep'.pluralize
'words'.pluralize
'the blue mailman'.pluralize 'CamelOctopus'.pluralize
'apple'.pluralize(1)
'apple'.pluralize(2)
'ley'.pluralize(:es)
'ley'.pluralize(1, :es)

See ActiveSupport::Inflector.pluralize.

Source: show | on GitHub

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

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

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

Source: show | on GitHub

def remove(*patterns) dup.remove!(*patterns) end

Alters the string by removing all occurrences of the patterns.

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

Source: show | on GitHub

def remove!(*patterns) patterns.each do |pattern| gsub! pattern, "" end

self end

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.

'Module'.safe_constantize
'Class'.safe_constantize
'blargle'.safe_constantize

See ActiveSupport::Inflector.safe_constantize.

Source: show | on GitHub

def safe_constantize ActiveSupport::Inflector.safe_constantize(self) end

singularize(locale = :en)Link

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
'octopi'.singularize
'sheep'.singularize
'word'.singularize
'the blue mailmen'.singularize 'CamelOctopi'.singularize
'leyes'.singularize(:es)

See ActiveSupport::Inflector.singularize.

Source: show | on GitHub

def singularize(locale = :en) ActiveSupport::Inflector.singularize(self, locale) end

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
" foo bar \n \t boo".squish

Performs a destructive squish. See String#squish.

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

Source: show | on GitHub

def squish! gsub!(/[[:space:]]+/, " ") strip! self end

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.

Source: show | on GitHub

def strip_heredoc gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "").tap do |stripped| stripped.freeze if frozen? end end

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 'ham_and_egg'.tableize
'fancyCategory'.tableize

See ActiveSupport::Inflector.tableize.

Source: show | on GitHub

def tableize ActiveSupport::Inflector.tableize(self) end

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.

'man from the boondocks'.titleize
'x-men: the last stand'.titleize
'string_ending_with_id'.titleize(keep_id_suffix: true)

See ActiveSupport::Inflector.titleize.

Source: show | on GitHub

def titleize(keep_id_suffix: false) ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix) end

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)
str.to(3)
str.to(-2)

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

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

Source: show | on GitHub

def to(position) position += size if position < 0 self[0, position + 1] || +"" end

Converts a string to a Date value.

"1-1-2012".to_date
"01/01/2012".to_date "2012-12-13".to_date "12/13/2012".to_date

Source: show | on GitHub

def to_date ::Date.parse(self, false) unless blank? end

Converts a string to a DateTime value.

"1-1-2012".to_datetime
"01/01/2012 23:59:59".to_datetime "2012-12-13 12:50".to_datetime
"12/13/2012".to_datetime

Source: show | on GitHub

def to_datetime ::DateTime.parse(self, false) unless blank? end

to_time(form = :local)Link

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
"06:12".to_time
"2012-12-13 06:12".to_time
"2012-12-13T06:12".to_time
"2012-12-13T06:12".to_time(:utc)
"12/13/2012".to_time
"1604326192".to_time

Source: show | on GitHub

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

truncate(truncate_to, options = {})Link

Truncates a given text to length truncate_to if text is longer than truncate_to:

'Once upon a time in a world far far away'.truncate(27)

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 world far far away'.truncate(27, separator: /\s/)

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

'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')

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

Source: show | on GitHub

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

Truncates text to at most truncate_to 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 truncate_to.

Raises ArgumentError when the bytesize of :omission exceeds truncate_to.

Source: show | on GitHub

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

truncate_words(words_count, options = {})Link

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)

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

'Once
upon
a
time
in
a
world'.truncate_words(5, separator: '
')

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

Source: show | on GitHub

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

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
'ActiveModel::Errors'.underscore

See ActiveSupport::Inflector.underscore.

Source: show | on GitHub

def underscore ActiveSupport::Inflector.underscore(self) end

Source: show | on GitHub

def upcase_first ActiveSupport::Inflector.upcase_first(self) end