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
O
P
S
T
U
Instance Public methods
acts_like_string?()
Enable more predictable duck-typing on String-like classes. SeeObject#acts_like?.
Source: show
def acts_like_string? true end
as_json(options = nil)
Source: show
def as_json(options = nil) self end
at(position)
Returns the character at the position treating the string as an array (where 0 is the first character).
Examples:
"hello".at(0)
"hello".at(4)
"hello".at(10)
Source: show
def at(position) mb_chars[position, 1].to_s end
blank?()
A string is blank if it’s empty or contains whitespaces only:
"".blank?
" ".blank?
" something here ".blank?
Source: show
def blank? self !~ /\S/ end
camelcase(first_letter = :upper)
camelize(first_letter = :upper)
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)
Source: show
def camelize(first_letter = :upper) case first_letter when :upper then ActiveSupport::Inflector.camelize(self, true) when :lower then ActiveSupport::Inflector.camelize(self, false) end end
classify()
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 followclassify with constantize.)
"egg_and_hams".classify "posts".classify
Singular names are not handled correctly.
"business".classify
Source: show
def classify ActiveSupport::Inflector.classify(self) end
constantize()
constantize tries to find a declared constant with the name specified in the string. It raises a NameErrorwhen the name is not in CamelCase or is not initialized.
Examples
"Module".constantize "Class".constantize
Source: show
def constantize ActiveSupport::Inflector.constantize(self) end
dasherize()
Replaces underscores with dashes in the string.
"puni_puni"
Source: show
def dasherize ActiveSupport::Inflector.dasherize(self) end
demodulize()
Removes the module part from the constant expression in the string.
"ActiveRecord::CoreExtensions::String::Inflections".demodulize "Inflections".demodulize
Source: show
def demodulize ActiveSupport::Inflector.demodulize(self) end
encode_json(encoder)
Source: show
def encode_json(encoder) encoder.escape(self) end
encoding_aware?()
Source: show
def encoding_aware? true end
exclude?(string)
The inverse of String#include?. Returns true if the string does not include the other string.
Source: show
def exclude?(string) !include?(string) end
first(limit = 1)
Returns the first character of the string or the first limitcharacters.
Examples:
"hello".first
"hello".first(2)
"hello".first(10)
Source: show
def first(limit = 1) if limit == 0 '' elsif limit >= size self else mb_chars[0...limit].to_s end end
foreign_key(separate_class_name_and_id_with_underscore = true)
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’.
Examples
"Message".foreign_key
"Message".foreign_key(false)
"Admin::Post".foreign_key
Source: show
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)
Returns the remaining of the string from the position treating the string as an array (where 0 is the first character).
Examples:
"hello".from(0)
"hello".from(2)
"hello".from(10)
Source: show
def from(position) mb_chars[position..-1].to_s end
html_safe()
Source: show
def html_safe ActiveSupport::SafeBuffer.new(self) end
humanize()
Capitalizes the first word, turns underscores into spaces, and strips ‘_id’. Like titleize, this is meant for creating pretty output.
"employee_salary" "author_id"
Source: show
def humanize ActiveSupport::Inflector.humanize(self) end
inquiry()
Wraps the current string in the ActiveSupport::StringInquirerclass, which gives you a prettier way to test for equality. Example:
env = "production".inquiry
env.production?
env.development?
Source: show
def inquiry ActiveSupport::StringInquirer.new(self) end
is_utf8?()
Source: show
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)
Returns the last character of the string or the last limitcharacters.
Examples:
"hello".last
"hello".last(2)
"hello".last(10)
Source: show
def last(limit = 1) if limit == 0 '' elsif limit >= size self else mb_chars[(-limit)..-1].to_s end end
mb_chars()
Multibyte proxy
mb_chars is a multibyte safe proxy for string methods.
In Ruby 1.8 and older it creates and returns an instance of the ActiveSupport::Multibyte::Charsclass 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 name.length
name.mb_chars.reverse.to_s name.mb_chars.length
In Ruby 1.9 and newer mb_chars returns selfbecause String is (mostly) encoding aware. This means that it becomes easy to run one version of your code on multiple Ruby versions.
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 ato_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
def mb_chars if ActiveSupport::Multibyte.proxy_class.consumes?(self) ActiveSupport::Multibyte.proxy_class.new(self) else self end end
ord()
Returns the codepoint of the first character of the string, assuming a single-byte character encoding:
"a".ord "à".ord
This method is defined in Ruby 1.8 for Ruby 1.9 forward compatibility on these character encodings.
ActiveSupport::Multibyte::Chars#ord is forward compatible with Ruby 1.9 on UTF8 strings:
"a".mb_chars.ord "à".mb_chars.ord
Note that the 224 is different in both examples. In ISO-8859-1 “à” is represented as a single byte, 224. In UTF8 it is represented with two bytes, namely 195 and 160, but its Unicode codepoint is 224. If we callord on the UTF8 string “à” the return value will be 195. That is not an error, because UTF8 is unsupported, the call itself would be bogus.
parameterize(sep = '-')
Replaces special characters in a string so that it may be used as part of a ‘pretty’ URL.
Examples
class Person def to_param "#{id}-#{name.parameterize}" end end
@person = Person.find(1)
<%Q link_to(@person.name, person_path %>
=> Donald E. Knuth
Source: show
def parameterize(sep = '-') ActiveSupport::Inflector.parameterize(self, sep) end
pluralize()
Returns the plural form of the word in the string.
"post".pluralize
"octopus".pluralize
"sheep".pluralize
"words".pluralize
"the blue mailman".pluralize
"CamelOctopus".pluralize
Source: show
def pluralize ActiveSupport::Inflector.pluralize(self) end
singularize()
The reverse of pluralize, returns the singular form of a word in a string.
"posts".singularize
"octopi".singularize
"sheep".singularize
"word".singularize
"the blue mailmen".singularize
"CamelOctopi".singularize
Source: show
def singularize ActiveSupport::Inflector.singularize(self) end
squish()
Returns the string, first removing all whitespace on both ends of the string, and then changing remaining consecutive whitespace groups into one space each.
Examples:
%Q{ Multi-line
string }.squish
" foo bar \n \t boo".squish
Source: show
def squish dup.squish! end
squish!()
Performs a destructive squish. See #squish.
Source: show
def squish! strip! gsub!(/\s+/, ' ') self end
strip_heredoc()
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.
Source: show
def strip_heredoc indent = scan(/^[ \t]*(?=\S)/).min.try(:size) || 0 gsub(/^[ \t]{#{indent}}/, '') end
tableize()
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
"egg_and_ham".tableize
"fancyCategory".tableize
Source: show
def tableize ActiveSupport::Inflector.tableize(self) end
titleize()
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 Railsinternals.
titleize is also aliased as titlecase.
"man from the boondocks".titleize "x-men: the last stand".titleize
Source: show
def titleize ActiveSupport::Inflector.titleize(self) end
to(position)
Returns the beginning of the string up to the positiontreating the string as an array (where 0 is the first character).
Examples:
"hello".to(0)
"hello".to(2)
"hello".to(10)
Source: show
def to(position) mb_chars[0..position].to_s end
to_date()
Source: show
def to_date return nil if self.blank? ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday)) end
to_datetime()
Source: show
def to_datetime return nil if self.blank? d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :zone, :sec_fraction).map { |arg| arg || 0 } d[5] += d.pop ::DateTime.civil(*d) end
to_time(form = :utc)
Form can be either :utc (default) or :local.
Source: show
def to_time(form = :utc) return nil if self.blank? d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction).map { |arg| arg || 0 } d[6] *= 1000000 ::Time.send("#{form}_time", *d) end
truncate(length, options = {})
Truncates a given text after a given length iftext is longer than length:
"Once upon a time in a world far far away".truncate(27)
Pass a :separator to truncate text at a natural break:
"Once upon a time in a world far far away".truncate(27, :separator => ' ')
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)")
Source: show
def truncate(length, options = {}) text = self.dup options[:omission] ||= "..."
length_with_room_for_omission = length - options[:omission].mb_chars.length chars = text.mb_chars stop = options[:separator] ? (chars.rindex(options[:separator].mb_chars, length_with_room_for_omission) || length_with_room_for_omission) : length_with_room_for_omission
(chars.length > length ? chars[0...stop] + options[:omission] : text).to_s end
underscore()
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.
"ActiveRecord".underscore
"ActiveRecord::Errors".underscore
Source: show
def underscore ActiveSupport::Inflector.underscore(self) end