Class: String

Inherits:
Object show all
Defined in:
lib/active_support/core_ext/string/inflections.rb,
lib/active_support/core_ext/object/json.rb,
lib/active_support/core_ext/object/blank.rb,
lib/active_support/core_ext/string/strip.rb,
lib/active_support/core_ext/string/zones.rb,
lib/active_support/core_ext/string/access.rb,
lib/active_support/core_ext/string/indent.rb,
lib/active_support/core_ext/string/exclude.rb,
lib/active_support/core_ext/string/filters.rb,
lib/active_support/core_ext/string/inquiry.rb,
lib/active_support/core_ext/string/behavior.rb,
lib/active_support/core_ext/string/multibyte.rb,
lib/active_support/core_ext/string/conversions.rb,
lib/active_support/core_ext/string/output_safety.rb,
lib/active_support/core_ext/string/starts_ends_with.rb

Overview

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"

Constant Summary collapse

BLANK_RE = 
/\A[[:space:]]*\z/

Instance Method Summary collapse

Instance Method Details

#acts_like_string? ⇒ Boolean

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

Returns:

  • (Boolean) 


3
4
5
 
# File 'lib/active_support/core_ext/string/behavior.rb', line 3

def acts_like_string?
  true
end

#as_json(options = nil) ⇒ Object

:nodoc:



80
81
82
 
# File 'lib/active_support/core_ext/object/json.rb', line 80

def as_json(options = nil) #:nodoc:
  self
end

#at(position) ⇒ Object

If you pass a single Fixnum, 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



27
28
29
 
# File 'lib/active_support/core_ext/string/access.rb', line 27

def at(position)
  self[position]
end

#blank? ⇒ true, false

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

Returns:

  • (true, false) 


116
117
118
 
# File 'lib/active_support/core_ext/object/blank.rb', line 116

def blank?
  BLANK_RE === self
end

#camelize(first_letter = :upper) ⇒ Object Also known as: camelcase

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"



89
90
91
92
93
94
95
96
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 89

def camelize(first_letter = :upper)
  case first_letter
  when :upper
    ActiveSupport::Inflector.camelize(self, true)
  when :lower
    ActiveSupport::Inflector.camelize(self, false)
  end
end

#classify ⇒ Object

Create 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.)

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



185
186
187
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 185

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

#constantize ⇒ Object

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



65
66
67
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 65

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

#dasherize ⇒ Object

Replaces underscores with dashes in the string.

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



125
126
127
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 125

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

#deconstantize ⇒ Object

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.



148
149
150
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 148

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

#demodulize ⇒ Object

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

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

See also deconstantize.



135
136
137
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 135

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

#exclude?(string) ⇒ Boolean

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

Returns:

  • (Boolean) 


8
9
10
 
# File 'lib/active_support/core_ext/string/exclude.rb', line 8

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

#first(limit = 1) ⇒ Object

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

str = "hello"
str.first    # => "h"
str.first(1) # => "h"
str.first(2) # => "he"
str.first(0) # => ""
str.first(6) # => "hello"



75
76
77
78
79
80
81
82
83
 
# File 'lib/active_support/core_ext/string/access.rb', line 75

def first(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self
  else
    to(limit - 1)
  end
end

#foreign_key(separate_class_name_and_id_with_underscore = true) ⇒ Object

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"



211
212
213
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 211

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

#from(position) ⇒ Object

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"



44
45
46
 
# File 'lib/active_support/core_ext/string/access.rb', line 44

def from(position)
  self[position..-1]
end

#html_safe ⇒ Object 



236
237
238
 
# File 'lib/active_support/core_ext/string/output_safety.rb', line 236

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

#humanize(options = {}) ⇒ Object

Capitalizes the first word, turns underscores into spaces, and 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.

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



200
201
202
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 200

def humanize(options = {})
  ActiveSupport::Inflector.humanize(self, options)
end

#in_time_zone(zone = ::Time.zone) ⇒ Object

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



7
8
9
10
11
12
13
 
# File 'lib/active_support/core_ext/string/zones.rb', line 7

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) ⇒ Object

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"



40
41
42
 
# File 'lib/active_support/core_ext/string/indent.rb', line 40

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) ⇒ Object

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

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



5
6
7
8
9
 
# File 'lib/active_support/core_ext/string/indent.rb', line 5

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

#inquiry ⇒ Object

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



10
11
12
 
# File 'lib/active_support/core_ext/string/inquiry.rb', line 10

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

#is_utf8? ⇒ Boolean

Returns:

  • (Boolean) 


39
40
41
42
43
44
45
46
47
48
 
# File 'lib/active_support/core_ext/string/multibyte.rb', line 39

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

#last(limit = 1) ⇒ Object

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

str = "hello"
str.last    # => "o"
str.last(1) # => "o"
str.last(2) # => "lo"
str.last(0) # => ""
str.last(6) # => "hello"



95
96
97
98
99
100
101
102
103
 
# File 'lib/active_support/core_ext/string/access.rb', line 95

def last(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self
  else
    from(-limit)
  end
end

#mb_chars ⇒ Object

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.

name = 'Claus Müller'
name.reverse # => "rell??M sualC"
name.length  # => 13

name.mb_chars.reverse.to_s # => "rellüM sualC"
name.mb_chars.length       # => 12

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.



35
36
37
 
# File 'lib/active_support/core_ext/string/multibyte.rb', line 35

def mb_chars
  ActiveSupport::Multibyte.proxy_class.new(self)
end

#parameterize(sep = '-') ⇒ Object

Replaces special characters in a string so that it may be used as part of a ‘pretty’ 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>



165
166
167
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 165

def parameterize(sep = '-')
  ActiveSupport::Inflector.parameterize(self, sep)
end

#pluralize(count = nil, locale = :en) ⇒ Object

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"



31
32
33
34
35
36
37
38
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 31

def pluralize(count = nil, locale = :en)
  locale = count if count.is_a?(Symbol)
  if count == 1
    self
  else
    ActiveSupport::Inflector.pluralize(self, locale)
  end
end

#remove(pattern) ⇒ Object

Returns a new string with all occurrences of the pattern removed. Short-hand for String#gsub(pattern, ”).



24
25
26
 
# File 'lib/active_support/core_ext/string/filters.rb', line 24

def remove(pattern)
  gsub pattern, ''
end

#remove!(pattern) ⇒ Object

Alters the string by removing all occurrences of the pattern. Short-hand for String#gsub!(pattern, ”).



29
30
31
 
# File 'lib/active_support/core_ext/string/filters.rb', line 29

def remove!(pattern)
  gsub! pattern, ''
end

#safe_constantize ⇒ Object

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



76
77
78
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 76

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

#singularize(locale = :en) ⇒ Object

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"



54
55
56
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 54

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

#squish ⇒ Object

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 like mongolian vowel separator (U+180E).

%{ Multi-line
   string }.squish                   # => "Multi-line string"
" foo   bar    \n   \t   boo".squish # => "foo bar boo"



11
12
13
 
# File 'lib/active_support/core_ext/string/filters.rb', line 11

def squish
  dup.squish!
end

#squish! ⇒ Object

Performs a destructive squish. See String#squish.



16
17
18
19
20
21
 
# File 'lib/active_support/core_ext/string/filters.rb', line 16

def squish!
  gsub!(/\A[[:space:]]+/, '')
  gsub!(/[[:space:]]+\z/, '')
  gsub!(/[[:space:]]+/, ' ')
  self
end

#strip_heredoc ⇒ Object

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 line in the whole string, and removes that amount of leading whitespace.



22
23
24
25
 
# File 'lib/active_support/core_ext/string/strip.rb', line 22

def strip_heredoc
  indent = scan(/^[ \t]*(?=\S)/).min.try(:size) || 0
  gsub(/^[ \t]{#{indent}}/, '')
end

#tableize ⇒ Object

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"
'egg_and_ham'.tableize     # => "egg_and_hams"
'fancyCategory'.tableize   # => "fancy_categories"



175
176
177
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 175

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

#titleize ⇒ Object Also known as: titlecase

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.

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"



107
108
109
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 107

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

#to(position) ⇒ Object

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"



61
62
63
 
# File 'lib/active_support/core_ext/string/access.rb', line 61

def to(position)
  self[0..position]
end

#to_date ⇒ Object

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



43
44
45
 
# File 'lib/active_support/core_ext/string/conversions.rb', line 43

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

#to_datetime ⇒ Object

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



53
54
55
 
# File 'lib/active_support/core_ext/string/conversions.rb', line 53

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

#to_time(form = :local) ⇒ Object

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 05:12:00 UTC
"12/13/2012".to_time               # => ArgumentError: argument out of range



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/active_support/core_ext/string/conversions.rb', line 19

def to_time(form = :local)
  parts = Date._parse(self, false)
  return if parts.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.getlocal
end

#truncate(truncate_at, options = {}) ⇒ Object

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



51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/active_support/core_ext/string/filters.rb', line 51

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

#underscore ⇒ Object

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"



118
119
120
 
# File 'lib/active_support/core_ext/string/inflections.rb', line 118

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