Class String
In: lib/core/facets/roman.rb
lib/core/facets/kernel/blank.rb
lib/core/facets/comparable/cmp.rb
lib/core/facets/boolean.rb
lib/core/facets/string/indent.rb
lib/core/facets/string/op_div.rb
lib/core/facets/string/mscan.rb
lib/core/facets/string/remove.rb
lib/core/facets/string/acronym.rb
lib/core/facets/string/divide.rb
lib/core/facets/string/each_word.rb
lib/core/facets/string/random.rb
lib/core/facets/string/modulize.rb
lib/core/facets/string/pathize.rb
lib/core/facets/string/camelcase.rb
lib/core/facets/string/indexable.rb
lib/core/facets/string/store.rb
lib/core/facets/string/word_wrap.rb
lib/core/facets/string/to_re.rb
lib/core/facets/string/interpolate.rb
lib/core/facets/string/variablize.rb
lib/core/facets/string/xor.rb
lib/core/facets/string/trim.rb
lib/core/facets/string/cleave.rb
lib/core/facets/string/shatter.rb
lib/core/facets/string/newlines.rb
lib/core/facets/string/nchar.rb
lib/core/facets/string/squish.rb
lib/core/facets/string/exclude.rb
lib/core/facets/string/characters.rb
lib/core/facets/string/margin.rb
lib/core/facets/string/snakecase.rb
lib/core/facets/string/words.rb
lib/core/facets/string/rewrite.rb
lib/core/facets/string/line_wrap.rb
lib/core/facets/string/quote.rb
lib/core/facets/string/crypt.rb
lib/core/facets/string/number.rb
lib/core/facets/string/rotate.rb
lib/core/facets/string/lchomp.rb
lib/core/facets/string/cleanlines.rb
lib/core/facets/string/unfold.rb
lib/core/facets/string/bracket.rb
lib/core/facets/string/range.rb
lib/core/facets/string/ascii_only.rb
lib/core/facets/string/natcmp.rb
lib/core/facets/string/edit_distance.rb
lib/core/facets/string/compress_lines.rb
lib/core/facets/string/splice.rb
lib/core/facets/string/linear.rb
lib/core/facets/string/uppercase.rb
lib/core/facets/string/starts_with.rb
lib/core/facets/string/titlecase.rb
lib/core/facets/string/file.rb
lib/core/facets/string/fold.rb
lib/core/facets/string/align.rb
lib/core/facets/string/similarity.rb
lib/core/facets/string/methodize.rb
lib/core/facets/string/capitalized.rb
lib/core/facets/string/index_all.rb
lib/core/facets/string/expand_tab.rb
lib/core/facets/object/object_state.rb
lib/standard/facets/random.rb
lib/standard/facets/tuple.rb
lib/standard/facets/date.rb
Parent: Object

Methods

Included Modules

Indexable Random::StringExtensions

Constants

ROMAN = /^M*(D?C{0,3}|C[DM])(L?X{0,3}|X[LC])(V?I{0,3}|I[VX])$/i unless const_defined?(:ROMAN)   Taken from O‘Reilly‘s Perl Cookbook 6.23. Regular Expression Grabbag.
ROMAN_VALUES = Integer::ROMAN_VALUES.inject({}) do |h,(r,a)| h[r] = a;
BRA2KET = { '['=>']', '('=>')', '{'=>'}', '<'=>'>' }

External Aliases

[]= -> store
  Alias for []=.
crypt -> _crypt
start_with? -> starts_with?
end_with? -> ends_with?

Public Class methods

Interpolate provides a means of externally using Ruby string interpolation mechinism.

  try = "hello"
  str = "\#{try}!!!"
  String.interpolate{ str }    #=> "hello!!!"

Note this uses eval under the hood. We do not recommend that it serve in place of a good templating system. But, it can be useful for simple cases.

The block is neccessary in order to get then binding of the caller.

CREDIT: Trans

Create a random String of given length, using given character set

Character set is an Array which can contain Ranges, Arrays, Characters

Examples

    String.random
    => "D9DxFIaqR3dr8Ct1AfmFxHxqGsmA4Oz3"

    String.random(10)
    => "t8BIna341S"

    String.random(10, ['a'..'z'])
    => "nstpvixfri"

    String.random(10, ['0'..'9'] )
    => "0982541042"

    String.random(10, ['0'..'9','A'..'F'] )
    => "3EBF48AD3D"

    BASE64_CHAR_SET =  ["A".."Z", "a".."z", "0".."9", '_', '-']
    String.random(10, BASE64_CHAR_SET)
    => "xM_1t3qcNn"

    SPECIAL_CHARS = ["!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "_", "=", "+", "|", "/", "?", ".", ",", ";", ":", "~", "`", "[", "]", "{", "}", "<", ">"]
    BASE91_CHAR_SET =  ["A".."Z", "a".."z", "0".."9", SPECIAL_CHARS]
    String.random(10, BASE91_CHAR_SET)
     => "S(Z]z,J{v;"

CREDIT: Tilo Sloboda

SEE: gist.github.com/tilo/3ee8d94871d30416feba

TODO: Move to random.rb in standard library?

Public Instance methods

Removes occurances of a string or regexp. This is an operator form for the remove method.

  ("HELLO HELLO" - "LL")    #=> "HEO HEO"
  ("HELLO PERL" - /L\S/)    #=> "HEO PERL"

Returns a new [String] with all pattern matches removed.

CREDIT: Benjamin David Oakes

Treats self and path as representations of pathnames, joining thme together as a single path.

  ('home' / 'trans')  #=> 'home/trans'

Binary XOR of two strings.

  a = "\000\000\001\001" ^ "\000\001\000\001"
  b = "\003\003\003" ^ "\000\001\002"

  a  #=> "\000\001\001\000"
  b  #=> "\003\002\001"

Transform a string into an acronym.

CREDIT: Robert Fey

Alignment method dispatches to align_right, align_left or align_center, accorging to the first direction parameter.

  s = <<-EOS
  This is a test
    and
    so on
  EOS

  s.align(:right, 14)

produces

  This is a test
             and
           so on

Returns a String aligned right, left or center.

Centers each line of a string.

The default alignment separation is a new line ("\n"). This can be changed as can be the padding string which defaults to a single space (’ ’).

  s = <<-EOS
    This is a test
    and
    so on
  EOS

  s.align_center(14)

produces

  This is a test
       and
      so on

CREDIT: Trans

Align a string to the left.

The default alignment separation is a new line ("\n"). This can be changed as can be the padding string which defaults to a single space (’ ’).

  s = <<-EOS
  This is a test
    and
    so on
  EOS

  s.align_left(20, "\n", '.')

produces

  This is a test......
  and.................
  so on...............

CREDIT: Trans

Align a string to the right.

The default alignment separation is a new line ("\n"). This can be changed as can be the padding string which defaults to a single space (’ ’).

  s = <<-EOS
  This is a test
    and
    so on
  EOS

  s.align_right(14)

produces

  This is a test
             and
           so on

CREDIT: Trans

Get a new string with non-ASCII characters removed.

alt - String to replace non-ASCII characters with.

      Defaults to a blank string (`''`).

Examples

  'abc'.ascii_only     #=> 'abc'
  '中文123'.ascii_only  #=> '123'

Returns a copy of [String] with ASCII characters only.

CREDIT: Nathan Long

SEE: stackoverflow.com/questions/1268289

Modify string keeping only ASCII characters.

alt - String to replace non-ASCII characters with.

      Defaults to a blank string (`''`).

Examples

  'abc'.ascii_only!     #=> 'abc'
  '中文123'.ascii_only!  #=> '123'

Returns [String]

CREDIT: Nathan Long

SEE: stackoverflow.com/questions/1268289

Is this string just whitespace?

  "abc".blank?  #=> false
  "   ".blank?  #=> true

Return a new string embraced by given brackets. If only one bracket char is given it will be placed on either side.

  "wrap me".bracket('{')        #=> "{wrap me}"
  "wrap me".bracket('--','!')   #=> "--wrap me!"

CREDIT: Trans

Inplace version of bracket.

CREDIT: Trans

Transform a string into a sentence like form.

  "This Is A String".briefcase
  #=> "This is a string"

Converts a string to camelcase. This method leaves the first character as given. This allows other methods to be used first, such as uppercase and lowercase.

  "camel_case".camelcase          #=> "camelCase"
  "Camel_case".camelcase          #=> "CamelCase"

Custom separators can be used to specify the patterns used to determine where capitalization should occur. By default these are underscores (`_`) and space characters (`\s`).

  "camel/case".camelcase('/')     #=> "camelCase"

If the first separator is a symbol, either `:lower` or `:upper`, then the first characters of the string will be downcased or upcased respectively.

  "camel_case".camelcase(:upper)  #=> "CamelCase"

Note that this implementation is different from ActiveSupport‘s. If that is what you are looking for you may want {modulize}.

Return true if the string is capitalized, otherwise false.

  "This".capitalized?  #=> true
  "THIS".capitalized?  #=> false
  "this".capitalized?  #=> false

Note Ruby‘s strange concept of capitalized. See capitalcase for the more command conception.

CREDIT: Phil Tomson

Returns an array of characters.

  "abc".characters.to_a  #=> ["a","b","c"]

TODO: Probably should make this an enumerator. With scan?

Returns an Enumerator for iterating over each line of the string, stripped of whitespace on either side.

  "this\nthat\nother\n".cleanlines.to_a  #=> ['this', 'that', 'other']

Cleave a string. Break a string in two parts at the nearest whitespace.

CREDIT: Trans

Compare method that takes length into account. Unlike #<=>, this is compatible with succ.

  "abc".cmp("abc")   #=>  0
  "abcd".cmp("abc")  #=>  1
  "abc".cmp("abcd")  #=> -1
  "xyz".cmp("abc")   #=>  1

CREDIT: Peter Vanbroekhoven

TODO: Move String#cmp to string/ directory.

Matches any whitespace (including newline) and replaces with a single space

  string = <<-QUERY.compress_lines
    SELECT name
    FROM users
  QUERY

  string  #=> "SELECT name FROM users"

Common Unix cryptography method. This adds a default salt to the built-in crypt method.

NOTE: This method is not a common core extension and is not loaded automatically when using require ‘facets‘.

@uncommon

  require 'facets/string/crypt'

Breaks a string up into an array based on a regular expression. Similar to scan, but includes the matches.

  s = "<p>This<b>is</b>a test.</p>"
  s.divide( /\<.*?\>/ )
  #=> ["<p>This", "<b>is", "</b>a test.", "</p>"]

CREDIT: Trans

Return true if the string is lowercase (downcase), otherwise false.

  "THIS".downcase?  #=> false
  "This".downcase?  #=> false
  "this".downcase?  #=> true

CREDIT: Phil Tomson

each_match(re)

Alias for mscan

Iterate through each word of a string.

  a = []

  "list of words".each_word { |word| a << word }

  a  #=> ['list', 'of', 'words']

Levenshtein distance algorithm implementation for Ruby, with UTF-8 support.

The Levenshtein distance is a measure of how similar two strings s and t are, calculated as the number of deletions/insertions/substitutions needed to transform s into t. The greater the distance, the more the strings differ.

The Levenshtein distance is also sometimes referred to as the easier-to-pronounce-and-spell ‘edit distance’.

Calculate the Levenshtein distance between two strings self and +str2+. self and +str2+ should be ASCII, UTF-8, or a one-byte-per character encoding such as ISO-8859-*.

The strings will be treated as UTF-8 if $KCODE is set appropriately (i.e. ‘u’). Otherwise, the comparison will be performed byte-by-byte. There is no specific support for Shift-JIS or EUC strings.

When using Unicode text, be aware that this algorithm does not perform normalisation. If there is a possibility of different normalised forms being used, normalisation should be performed beforehand.

CREDIT: Paul Battley

Levenshtein distance algorithm implementation for Ruby, with UTF-8 support.

The Levenshtein distance is a measure of how similar two strings s and t are, calculated as the number of deletions/insertions/substitutions needed to transform s into t. The greater the distance, the more the strings differ.

The Levenshtein distance is also sometimes referred to as the easier-to-pronounce-and-spell ‘edit distance’.

Calculate the Levenshtein distance between two strings self and +str2+. self and +str2+ should be ASCII, UTF-8, or a one-byte-per character encoding such as ISO-8859-*.

The strings will be treated as UTF-8 if $KCODE is set appropriately (i.e. ‘u’). Otherwise, the comparison will be performed byte-by-byte. There is no specific support for Shift-JIS or EUC strings.

When using Unicode text, be aware that this algorithm does not perform normalisation. If there is a possibility of different normalised forms being used, normalisation should be performed beforehand.

CREDIT: Paul Battley

The inverse of include?.

expand_tab(n=8)

Alias for expand_tabs

Expands tabs to n spaces. Non-destructive. If n is 0, then tabs are simply removed. Raises an exception if n is negative.

  "\t\tHey".expand_tabs(2)  #=> "    Hey"

Thanks to GGaramuno for a more efficient algorithm. Very nice.

CREDIT: Gavin Sinclair, Noah Gibbs, GGaramuno

TODO: Don‘t much care for the name String#expand_tabs. What about a more concise name like detab?

Use fluent notation for making file directives.

For instance, if we had a file ‘foo.txt’,

   'foo.txt'.file.mtime

Returns a new string with all new lines removed from adjacent lines of text.

    s = "This is\na test.\n\nIt clumps\nlines of text."
    s.fold

produces

    "This is a test.\n\nIt clumps lines of text. "

TODO: One arguable flaw with this that might need a fix: if the given string ends in a newline, it is replaced with a single space.

CREDIT: Trans

Indent left or right by `n` spaces, or `n` number of `c` string.

n - The number of spaces to indent. [Integer] c - Character to use, if other then space. [String]

Returns a new string with the indention. [String]

Credit: Gavin Sinclair Credit: Trans Credit: Tyler Rick

Equivalent to String#indent, but modifies the receiver in place.

n - The number of spaces to indent. [Integer] c - Character to use, if other then space. [String]

Returns this string with the indention. [String]

Like index but returns an array of all index locations. The reuse flag allows the trailing portion of a match to be reused for subsquent matches.

  "abcabcabc".index_all('a')  #=> [0,3,6]

  "bbb".index_all('bb', false)  #=> [0]
  "bbb".index_all('bb', true)   #=> [0,1]

TODO: Culd probably be defined for Indexable in general too.

Left chomp.

  "help".lchomp("h")  #=> "elp"
  "help".lchomp("k")  #=> "help"

CREDIT: Trans

In-place left chomp.

  "help".lchomp("h")  #=> "elp"
  "help".lchomp("k")  #=> "help"

CREDIT: Trans

Line wrap at width.

  s = "1234567890".line_wrap(5)

  s  #=> "12345\n67890\n"

CREDIT: Trans

Like `newlines` but returns a Functor instead.

  "a \n b \n c".linear.strip   #=> "a\nb\nc"

Same as +camelcase+ but converts first letter to lowercase.

  "camel_case".lower_camelcase   #=> "camelCase"
  "Camel_case".lower_camelcase   #=> "camelCase"

@deprecated

  Use `#camelcase(:lower)` instead.

Downcase first letter.

Preserve relative tabbing such that the line with the least amount of white space ends up with the given number of spaces before non-space and all other lines move relative to it.

Because of the nature of this method, leading tab characters (`\t`) must be converted to spaces. The size of a tab can be set via the `:tab` option. The default size is 2.

If the `:lead` option is set, then the relative margin is determined by the first non-blank line, instead of the minimum white-space for all lines.

Arguments

  num   - The size of the desired margin. [Integer]
  opts  - Margin options. [Hash]

Options

  :tab  - Size of tab character in spaces. [Integer]
  :lead - Use first non-blank line as relative marker. [Boolean]

Returns a new String with adjusted margin. [String]

Author: Gavin Sinclair Author: Trans

Translate a class or module name to a suitable method name.

  "My::CoolClass".methodize  #=> "my__cool_class"

Converts a string to module name representation.

This is essentially camelcase, but it also converts ’/’ to ’::’ which is useful for converting paths to namespaces.

Examples

  "method_name".modulize    #=> "MethodName"
  "method/name".modulize    #=> "Method::Name"

Like scan but returns MatchData ($~) rather then matched string ($&).

CREDIT: Trans

‘Natural order’ comparison of strings, e.g. …

  "my_prog_v1.1.0" < "my_prog_v1.2.0" < "my_prog_v1.10.0"

which does not follow alphabetically. A secondary parameter, if set to true, makes the comparison case insensitive.

  "Hello.1".natcmp("Hello.10")  #=> -1

TODO: Invert case flag?

@author Alan Davies @author Martin Pool

Returns n characters of the string. If n is positive the characters are from the beginning of the string. If n is negative from the end of the string.

   str = "this is text"

   str.nchar(4)            #=> "this"
   str.nchar(-4)           #=> "text"

Alternatively a replacement string can be given, which will replace the n characters.

   str.nchar(4, 'that')    #=> "that is text"

The original string remains unaffected.

   str  #=> "this is text"

Returns an Enumerator for iterating over each line of the string, void of the termining newline character, in contrast to lines which retains it.

  "a\nb\nc".newlines.class.assert == Enumerator
  "a\nb\nc".newlines.to_a.assert == %w{a b c}

  a = []
  "a\nb\nc".newlines{|nl| a << nl}
  a.assert == %w{a b c}

Returns true if it‘s a decimal digits.

  "123_456_789_123_456_789.123_456_000_111".number?  # => true
  "1.23".number?  # => true
  "1.23a".number? # => false

CREDIT: u2

Transforms a namespace, i.e. a class or module name, into a viable file path.

  "ExamplePathize".pathize           #=> "example_pathize"
  "ExamplePathize::Example".pathize  #=> "example_pathize/example"

Compare this method to {String#modulize) and {String#methodize).

Return a new string embraced by given type and count of quotes. The arguments can be given in any order.

If no type is given, double quotes are assumed.

  "quote me".quote     #=> '"quote me"'

If no type but a count is given then :mixed is assumed.

  "quote me".quote(1)  #=> %q{'quote me'}
  "quote me".quote(2)  #=> %q{"quote me"}
  "quote me".quote(3)  #=> %q{'"quote me"'}

Symbols can be used to describe the type.

  "quote me".quote(:single)    #=> %q{'quote me'}
  "quote me".quote(:double)    #=> %q{"quote me"}
  "quote me".quote(:back)      #=> %q{`quote me`}
  "quote me".quote(:bracket)   #=> %q{`quote me'}

Or the character itself.

  "quote me".quote("'")     #=> %q{'quote me'}
  "quote me".quote('"')     #=> %q{"quote me"}
  "quote me".quote("`")     #=> %q{`quote me`}
  "quote me".quote("`'")    #=> %q{`quote me'}

CREDIT: Trans

Like index but returns a Range.

  "This is a test!".range('test')  #=> (10..13)

CREDIT: Trans

Like index_all but returns an array of Ranges.

  "abc123abc123".range_all('abc')  #=> [0..2, 6..8]

TODO: Add offset ?

CREDIT: Trans

Returns an array of ranges mapping the characters per line.

  "this\nis\na\ntest".range_of_line
  #=> [0..4, 5..7, 8..9, 10..13]

CREDIT: Trans

Removes all occurrences of a pattern in a string.

Returns a new [String] with all occurrences of the pattern removed.

Removes all occurrences of a pattern in a string.

Returns the [String] with all occurrences of the pattern removed.

Apply a set of rules in the form of regular expression matches to the string.

  • rules - The array containing rule-pairs (match, write).

Keep in mind that the order of rules is significant.

Returns the rewritten String.

CREDIT: George Moschovitis

Rotate string to the left with count. Specifying negative number indicates rotation to the right.

  'abcdefgh'.rotate(2)  #=> 'cdefghab'
  'abcdefgh'.rotate(-2) #=> 'ghabcdef'

CREDIT: T. Yamada

Destructive version of String#rotate

  s='abcdefgh'
  s.rotate!(2)
  s.should eq 'cdefghab'

CREDIT: T. Yamada

Breaks a string up into an array based on a regular expression. Similar to scan, but includes the matches.

  s = "<p>This<b>is</b>a test.</p>"
  s.shatter( /\<.*?\>/ )

produces

  ["<p>", "This", "<b>", "is", "</b>", "a test.", "</p>"]

CREDIT: Trans

A fuzzy matching mechanism. Returns a score from 0-1, based on the number of shared edges. To be effective, the strings must be of length 2 or greater.

    "Alexsander".similarity("Aleksander")  #=> 0.9

The way it works:

  1. Converts each string into a "graph like" object, with edges …
        "alexsander" -> [ alexsander, alexsand, alexsan ... lexsand ... san ... an, etc ]
        "aleksander" -> [ aleksander, aleksand ... etc. ]
    
  2. Perform match, then remove any subsets from this matched set (i.e. a hit

on "san" is a subset of a hit on "sander") …

       Above example, once reduced -> [ ale, sander ]
  1. See‘s how many of the matches remain, and calculates a score based

on how many matches, their length, and compare to the length of the larger of the two words.

Still a bit rough. Any suggestions for improvement are welcome.

CREDIT: Derek Lewis

Underscore a string such that camelcase, dashes and spaces are replaced by underscores. This is the reverse of {camelcase}, albeit not an exact inverse.

  "SnakeCase".snakecase         #=> "snake_case"
  "Snake-Case".snakecase        #=> "snake_case"
  "Snake Case".snakecase        #=> "snake_case"
  "Snake  -  Case".snakecase    #=> "snake_case"

Note, this method no longer converts `::` to `/`, in that case use the {pathize} method instead.

String#slice is essentially the same as store.

  a = "HELLO"
  a.splice(1, "X")
  a                #=> "HXLLO"

But it acts like slice! when given a single argument.

  a = "HELLO"
  a.splice(1)    #=> "E"
  a              #=> "HLLO"

CREDIT: Trans

Returns the string, first removing all whitespace on both ends of the string, and then changing remaining consecutive whitespace groups into one space each.

  %{ Multi-line
     string }.squish                   # => "Multi-line string"

  " foo   bar    \n   \t   boo".squish # => "foo bar boo"

Performs a destructive squish. See String#squish.

Transform a string into a form that makes for an acceptable title.

  "this is a string".titlecase
  #=> "This Is A String"

@author Eliazar Parra @author Angelo Lakra (apostrophe fix)

Interpret common affirmative string meanings as true, otherwise nil or false. Blank space and case are ignored. The following strings that will return true …

  true
  yes
  on
  t
  1
  y
  ==

The following strings will return nil …

  nil
  null

All other strings return false.

Here are some exmamples.

  "true".to_b   #=> true
  "yes".to_b    #=> true
  "no".to_b     #=> false
  "123".to_b    #=> false

Parse data from string.

Convert string to DateTime.

Turns a string into a regular expression.

  "a?".to_re  #=> /a?/

CREDIT: Trans

Turns a string into a regular expression. By default it will escape all characters. Use false argument to turn off escaping.

  "[".to_rx  #=> /\[/

CREDIT: Trans

Translates a string in the form on a set of numerical and/or alphanumerical characters separated by non-word characters (eg \W+) into a Tuple. The values of the tuple will be converted to integers if they are purely numerical.

  '1.2.3a'.to_t  #=> [1,2,"3a"]

It you would like to control the interpretation of each value as it is added to the tuple you can supply a block.

  '1.2.3a'.to_t { |v| v.upcase }  #=> ["1","2","3A"]

This method calls Tuple.cast_from_string.

Control the margin of a string using a trim character.

The first character of the second line of the string is used as the trim character. This method is useful when literal multi-line strings are needed in code.

num - Number of extra spaces with which to replace the

      trim character. [Integer]

Examples

    x = %Q{
          | This
          |   is
          |    trim!
          }.trim

Returns string with the margin trimed-off.

Note: This this method used to be called `margin` prior to Facets 3.0.

Since: 3.0.0 Author: Trans

Return a new string with the given brackets removed. If only one bracket char is given it will be removed from either side.

  "{unwrap me}".unbracket('{')        #=> "unwrap me"
  "--unwrap me!".unbracket('--','!')  #=> "unwrap me"

CREDIT: Trans

Inplace version of unbracket.

CREDIT: Trans

underscore()

Alias for snakecase

Unfold paragraphs such that new lines are removed from between sentences of the same paragraph.

Note that rstrip is called on the final result, but this may change in the future.

FIXME: Sometimes adds one too many blank lines, which is why we are

        using rstrip. Fix and probably remove the rstrip.

Remove excessive indentation. Useful for multi-line strings embeded in already indented code.

size - The number of spaces to indent. [Integer]

Examples

    <<-END.unindent
        ohaie
          wurld
    END
    #=> "ohaie\n  wurld"

Returns a new unindented string. [String]

Credit: Noah Gibbs Credit: mynyml

Equivalent to String#unindent, but modifies the receiver in place.

Returns this string unindented. [String]

Credit: mynyml

Remove quotes from string.

  "'hi'".unquote    #=> "hi"

CREDIT: Trans

Is the string upcase/uppercase?

  "THIS".upcase?  #=> true
  "This".upcase?  #=> false
  "this".upcase?  #=> false

CREDIT: Phil Tomson

Same as +camelcase+ but converts first letter to uppercase.

  "camel_case".upper_camelcase   #=> "CamelCase"
  "Camel_case".upper_camelcase   #=> "CamelCase"

@deprecated

  Use `#camelcase(:upper)` instead.

Upcase first letter.

NOTE: One might argue that this method should behave the same as +upcase+ and rather this behavior should be in place of +captialize+. Probably so, but since Matz has already defined +captialize+ the way it is, this name seems most fitting to the missing behavior.

Prepend an "@" to the beginning of a string to make a instance variable name. This also replaces non-valid characters with underscores.

Word wrap a string not exceeding max width.

  "this is a test".word_wrap(4)

produces

  this
  is a
  test

This is basic implementation of word wrap, but smart enough to suffice for most use cases.

CREDIT: Gavin Kistner, Dayne Broderson

As with word_wrap, but modifies the string in place.

CREDIT: Gavin Kistner, Dayne Broderson

Returns an array of characters.

  "abc 123".words  #=> ["abc","123"]

[Validate]