BRA2KET | = | { '['=>']', '('=>')', '{'=>'}', '<'=>'>' } | ||
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; |
[]= | -> | store |
Alias for []=. | ||
crypt | -> | _crypt |
Interpolate. Provides a means of extenally using Ruby string interpolation mechinism.
try = "hello" str = "\#{try}!!!" String.interpolate{ str } #=> "hello!!!"
NOTE: The block neccessary in order to get then binding of the caller.
CREDIT: Trans
Removes occurances of a string or regexp.
("HELLO HELLO" - "LL") #=> "HEO HEO"
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"
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
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
Upacks string into bytes.
Note, this is not 100% compatible with 1.8.7+ which returns an enumerator instead of an array.
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']
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.
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
Yields a single-character string for each character in the string. When $KCODE = ‘UTF8’, multi-byte characters are yielded appropriately.
a = '' "HELLO".each_char{ |c| a << "#{c.downcase}" } a #=> 'hello'
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
Does a string end with the given suffix?
"hello".end_with?("lo") #=> true "hello".end_with?("to") #=> false
Note: This definition is better than standard Ruby‘s becuase it handles regular expressions.
CREDIT: Juris Galang
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?
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. "
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
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.
Provides a margin controlled string.
x = %Q{ | This | is | margin controlled! }.margin
NOTE: This may still need a bit of tweaking.
TODO: describe its limits and caveats and edge cases
CREDIT: 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. 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?
CREDIT: Alan Davies, 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}
Converts a camelcase name (e.g. class or module name) to a unix path.
"ExamplePathize".pathize #=> "example_pathize" "ExamplePathize::Example".pathize #=> "example_pathize/example"
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_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
Apply a set of rules in the form of regular expression matches to the string.
Keep in mind that the order of rules is significant.
Returns the rewritten String.
CREDIT: George Moschovitis
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:
"alexsander" -> [ alexsander, alexsand, alexsan ... lexsand ... san ... an, etc ] "aleksander" -> [ aleksander, aleksand ... etc. ]
on "san" is a subset of a hit on "sander") …
Above example, once reduced -> [ ale, sander ]
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.
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"
Does a string start with the given prefix?
"hello".start_with?("he") #=> true "hello".start_with?("to") #=> false
Note: This definition is better than standard Ruby‘s becuase it handles regular expressions.
CREDIT: Juris Galang
Preserves relative tabbing. The first non-empty line ends up with n spaces before nonspace.
CREDIT: Gavin Sinclair
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
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.
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
Remove excessive indentation. Useful for multi-line strings embeded in already indented code.
<<-END.unindent ohaie wurld END
Outputs …
ohaie wurld
Instead of …
ohaie wurld
CREDIT: Noah Gibbs, mynyml
Is the string upcase/uppercase?
"THIS".upcase? #=> true "This".upcase? #=> false "this".upcase? #=> false
CREDIT: Phil Tomson
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