ActiveObject

Gem Version Build Status

ActiveObject is a collection of commonly used object helpers in a ruby based project.

Highly recommended extensions:

Installation

Add this line to your application's Gemfile:

gem 'active_object'

And then execute:

$ bundle

Or install it yourself as:

$ gem install active_object

Table of Contents

Configuration

rails generate active_object:install will generate the following file: ../config/initalizers/active_object.rb

ActiveObject.configure do |config|
  config.autoload_array = true
  config.autoload_date = true
  config.autoload_enumerable = true
  config.autoload_hash = true
  config.autoload_integer = true
  config.autoload_kernel = true
  config.autoload_numeric = true
  config.autoload_object = true
  config.autoload_range = true
  config.autoload_string = true
  config.autoload_time = true
end

Kernel

caller_name: caller_name returns the name of the method calling it.

def sample_key
  caller_name(0)
end

#=> 'sample_key'

safe_eval: safe_eval try to evalute or return it's self.

'[1,2,3]'.safe_eval  #=> [1,2,3]
'[#1,2,3]'.safe_eval #=> '[#1,2,3]'

try_eval: try_eval try to evalute or return it's nil.

'[1,2,3]'.try_eval  #=> [1,2,3]
'[#1,2,3]'.try_eval #=> nil

Array

After: after returns the value after the given value.

['1', '2', '3'].after('2') #=> '3'
['1', '2', '3'].after('3') #=> '1'
['1', '2', '3'].after('4') #=> nil

Bury: bury updates a deeply nested value.

['1', ['2']].bury(1, '3')    #=> ['1', '3']
['1', ['2']].bury(1, 0, '3') #=> ['1', ['3']]
['1', ['2']].bury(1)         #=> raises ArgumentError: '2 or more arguments required'

Before: before returns the value before the given value.

['1', '2', '3'].before('2') #=> '1'
['1', '2', '3'].before('1') #=> '3'
['1', '2', '3'].before('4') #=> nil

Delete First: delete_first and delete_first! removes the first element from an array. Like Array.shift, but returns the array instead of the removed element.

['1', '2', '3'].delete_first #=> ['2', '3']

Delete Last: delete_last and delete_last! removes the last element from an array. Like Array.pop, but returns the array instead of the removed element.

['1', '2', '3'].delete_last #=> ['1', '2']

Delete Values: delete_values delete multiple values from array.

[1, 2, 3, 4].delete_values(1, 3) #=> [2, 4]

Demote: demote and demote! moves given value to tail of array.

[1, 2, 2, 3].demote(2)  #=> [1, 3, 2, 2]
[1, 2, 2, 3].demote!(4) #=> [1, 2, 2, 3]

Denillify: denillify and denillify! converts nils into a given value.

[nil, 3, 4].denillify  #=> [0, 3, 4]
[nil, 3, 4].denillify!(9) #=> [9, 3, 4]

Dig: dig returns the value of a nested array.

['zero', ['ten', 'eleven', 'twelve'], 'two'].dig(1, 2) #=> 'twelve'

Duplicates: duplicates returns list of duplicate elements.

[1, 1, 2, 2, 2, 3].duplicates    #=> [1, 2]
[1, 1, 2, 2, 2, 3].duplicates(3) #=> [2]

From: from returns the tail of the array from position.

['1', '2', '3'].from(0) #=> ['1', '2', '3']
['1', '2', '3'].from(1) #=> ['2', '3']
['1', '2', '3'].from(-1) #=> ['3']

Fulfill: fulfill returns an array filled to given size.

['1', '2'].fulfill('x', 4) #=> ['1', '2', 'x', 'x']

Groups: groups splits or iterates over the array in number of groups.

%w(1 2 3 4 5 6 7 8 9 10).groups(3) #=> [['1', '2', '3', '4'], ['5', '6', '7'], ['8', '9', '10']]

In Groups: in_groups splits or iterates over the array in number of groups, padding any remaining slots with fill_with unless it is false.

%w(1 2 3 4 5 6 7 8 9 10).in_groups(3)           #=> [['1', '2', '3', '4'], ['5', '6', '7', nil], ['8', '9', '10', nil]]
%w(1 2 3 4 5 6 7 8 9 10).in_groups(3, ' ') #=> [['1', '2', '3', '4'], ['5', '6', '7', ' '], ['8', '9', '10', ' ']]
%w(1 2 3 4 5 6 7 8 9 10).in_groups(3, false)    #=> [['1', '2', '3', '4'], ['5', '6', '7'], ['8', '9', '10']]

In Groups Of: in_groups_of splits or iterates over the array in groups of size number, padding any remaining slots with fill_with unless it is false.

%w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3)           #=> [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['10', nil, nil]]
%w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3, ' ') #=> [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['10', ' ', ' ']]
%w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3, false)    #=> [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['10']]

Indexes: indexes returns all the indexes of the matching value.

[:a, :b, :a, :c].indexes(:a) #=> [0, 2]

Merge: merge concats multiple arrays.

[1, 2].merge([3, 4], [5, 6]) #=> [1, 2, 3, 4, 5, 6]

Nillify: nillify and nillify! converts blank values into nils.

[' ', 3, 4].nillify #=> [nil, 3, 4]
['', 3, 4].nillify! #=> [nil, 3, 4]

Probablity: probability generates a hash mapping each unique element in the array to the relative frequency, i.e. the probability, of it appearance.

[:a, :b, :c, :c].probability #=> { a: 0.25, b: 0.25, c: 0.5 }

Promote: promote and promote! moves given value to head of array.

[1, 2, 2, 3].promote(2)  #=> [2, 2, 1, 3]
[1, 2, 2, 3].promote!(4) #=> [1, 2, 2, 3]

Position: position returns the position of the first matching value.

[:a, :b, :a, :c].position(:a) #=> 1

Positions: positions returns all the positions of the matching value.

[:a, :b, :a, :c].positions(:a) #=> [1, 3]

Reject Values: reject_values delete multiple values from array from a array copy.

[1, 2, 3, 4, 5].reject_values(2,4) #=> [1, 3, 5]

Rposition: rposition returns the position of the last matching value.

[:a, :b, :a, :c].rposition(:a) #=> 3

Sample: sample! deletes a random value and returns that value.

[1, 2, 3, 4, 5].sample! #=> 2

Split: split divides the array into one or more subarrays based on a delimiting value or the result of an optional block.

[1, 2, 3, 4, 5].split(3)              # => [[1, 2], [4, 5]]
(1..10).to_a.split { |i| i % 3 == 0 } # => [[1, 2], [4, 5], [7, 8], [10]]

Strip: strip and strip! removes blank elements from an array.

['this', '', 'that', nil, false].strip  #=> ['this', 'that']
'this    is   a  test'.split(' ').strip #=> ['this', 'is', 'a', 'test']

Swap: swap switches places of two elements.

[1, 2, 3].swap(0, 2) #=> [3, 2, 1]

To: to returns the beginning of the array up to position.

['1', '2', '3'].to(0) #=> ['1']
['1', '2', '3'].to(1) #=> ['1', '2']
['1', '2', '3'].to(-1) #=> ['3']

To Sentence: to_sentence converts the array to a comma-separated sentence where the last element is joined by the connector word.

Options:

  • words_connector: “, ”
  • two_words_connector: “ and ”
  • last_word_connector: “, and ”
[].to_sentence                                                                                     #=> ''
['one'].to_sentence                                                                                #=> 'one'
['one', 'two'].to_sentence                                                                         #=> 'one and two'
['one', 'two', 'three'].to_sentence                                                                #=> 'one, two, and three'
['one', 'two'].to_sentence(two_words_connector: '-')                                               #=> 'one-two'
['one', 'two', 'three'].to_sentence(words_connector: ' or ', last_word_connector: ' or at least ') #=> 'one or two or at least three'

Enumerable

Critical zscore: critical_zscore returns the critical_zscore of elements of a collection.

[].critical_zscore                              #=> nil
[].critical_zscore(0)                           #=> 0
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10].critical_zscore #=> 2.29

Cluster: cluster clusters together adjacent elements into a list of sub-arrays.

[2,2,2,3,3,4,2,2,1].cluster { |x| x } #=> [[2, 2, 2], [3, 3], [4], [2, 2], [1]]

Defference: difference returns the difference of a collection of numbers. (Renamed from: difference)

[].defference #=> 0
[].defference(nil) #=> nil
[1,2,3].defference #=> -4

Divisible: divisible returns the division of a collection of numbers.

[].divisible       #=> 0
[].divisible(nil)  #=> nil
[16,4,2].divisible #=> 2

Drop Last: drop_last drops the last number of elements of a collection.

[].drop_last(1)      #=> []
[1,2,3].drop_last(1) #=> [1,2]
[1,2,3].drop_last(2) #=> [1]

Drop Last If: drop_last_if drops the last number of elements of a collection while it meets a criteria.

[].drop_last_if(&:odd?)        #=> []
[1,2,3].drop_last_if(&:odd?)   #=> [1,2]
[1,2,3,4].drop_last_if(&:odd?) #=> [1,2,3,4]

Exactly: exactly? returns if there are exactly the number of an element type.

[].exactly?(1)                 #=> false
[1,2,3].exactly?(3)            #=> true
[1,1,3,3].exactly?(2, &:even?) #=> false

Exclude: exclude? returns true if the collection does not include the object.

[1, 2, 3].exclude?(4) #=> true
[1, 2, 3].exclude?(3) #=> false

Expand: expand expand all elements of an Enumerable object.

[0, 2..3, 5..7].expand #=> [0,[2, 3],[5,6,7]]

Exponential: exponential returns the exponential of a collection of numbers.

[].exponential      #=> 0
[].exponential(nil) #=> nil
[2,3,4].exponential #=> 4096

Incase: incase? the same as #include? but tested using #=== instead of #==.

[1, 2, 'a'].incase?(String) #=> true
[1, 2, 'a'].incase?(3)      #=> false

Interpose: interpose returns an enumerator to add seperators.

[1, 2, 'a'].interpose(:sep).to_a #=> [1, :sep, 2, :sep, 'a']

Many: many? returns if collection has more than one element while respecting nil and false as an element.

[].many?                 #=> false
[1,2,3].many?            #=> true
[1, false, nil].many?    #=> true
[1,1,3,3].many?(&:even?) #=> false

Mean: mean and average returns the average of a collection of numbers.

[].mean      #=> 0
[].mean(nil) #=> nil
[1,2,3].mean #=> 2

Median: median returns the middle value of a collection of numbers.

[].median        #=> 0
[].median(nil)   #=> nil
[1,2,6].median   #=> 2
[1,2,3,6].median #=> 2.5

Mode: mode returns the most frequent value of a collection of numbers.

[].mode        #=> 0
[].mode(nil)   #=> nil
[1,2,3].mode   #=> nil
[1,1,2,6].mode #=> 1

Multiple: multiple returns the multiplication of a collection of numbers.

[].multiple      #=> 0
[].multiple(nil) #=> nil
[1,2,3].multiple #=> 6

Occurrences: occurrences returns a hash of the number of times a value in an array appears.

[].occurrences                                    #=> {}
[1, :symbol, 'string', 3, :symbol, 1].occurrences #=> { 1 => 2, :symbol => 2, 'string' => 1, 3 => 1 }

Percentile: percentile returns the percentile value for a given percentage.

[].percentile(50)              # => 2
[].percentile(50, nil)         # => 3
[1, 2, 3, 4].percentile(50)    # => 2.5
[1, 2, 3, 4, 5].percentile(50) # => 3

Range: range returns the difference between the smallest and largest value of a collection of numbers.

[].range      #=> 0
[].range(nil) #=> nil
[1,2,6].range #=> 5

Reject outliers: reject_outliers and reject_outliers! removes the outliers of collection of numbers.

[1, 2, 3, 30].reject_outliers #=> [1, 2, 3]

Select outliers: select_outliers select the outliers of collection of numbers.

[1, 2, 3, 30].select_outliers #=> [30]

Several: several? returns if collection has more than one element while not respecting nil and false as an element.

[].several?                 #=> false
[1,2,3].several?            #=> true
[1, false, nil].several?    #=> false
[1,1,3,3].several?(&:even?) #=> false

Standard Deviation: standard_deviation returns the standard deviation of elements of a collection.

[].standard_deviation      #=> 0
[].standard_deviation(nil) #=> nil
[1,2,6].standard_deviation #=> 2.6457513110645907

Sum: sum returns the sum of a collection of numbers.

[].sum             #=> 0
[1,2,3].sum        #=> 6
['foo', 'bar'].sum #=> 'foobar'

Take Last: take_last returns the last number of elements of a collection.

[].take_last(1)      #=> []
[1,2,3].take_last(1) #=> [3]
[1,2,3].take_last(2) #=> [2,3]

Take Last If: take_last_if returns the last number of elements of a collection while it meets a criteria.

[].take_last_if(&:odd?)        #=> []
[1,2,3].take_last_if(&:odd?)   #=> [3]
[1,2,3,4].take_last_if(&:odd?) #=> []

Variance: variance returns the variance of elements of a collection.

[].variance      #=> 0
[].variance(nil) #=> nil
[1,2,6].variance #=> 7

Zscore: zscore returns the zscore of elements of a collection.

[].zscore(3) #=> 0
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10].zscore(3) #=> 0.8257228238447705

Hash

Assert Valid Keys: assert_valid_keys and assert_valid_keys! raises an error if key is not included in a list of keys.

{}.assert_valid_keys(:foo)                               #=> {}
{}.assert_valid_keys!(:foo)                              #=> raises ArgumentError: 'Empty hash. Valid keys are: :foo'
{ foo: 'bar' }.assert_valid_keys(:foo)                   #=> { foo: 'bar' }
{ foo: 'bar', baz: 'boz' }.assert_valid_keys(:foo, :boo) #=> raises ArgumentError: 'Unknown key: :baz. Valid keys are: :foo, :boo'

Bury: bury updates a deeply nested value.

{ foo: { baz: 'boo' } }.bury(:foo, :moo)       #=> { foo: :moo }
{ foo: { baz: 'boo' } }.bury(:foo, :baz, :moo) #=> { foo: { baz: :moo } }
{ foo: { baz: 'boo' } }.bury(:foo)             #=> raises ArgumentError: '2 or more arguments required'

Collect Keys: collect_keys returns an array with all keys converted using the block operation.

{ foo: 'bar', 'baz' => :boo }.collect_keys                       #=> [:foo, 'baz']
{ foo: 'bar', 'baz' => :boo }.collect_keys { |k| k.to_s.upcase } #=> ['FOO', BAZ']

Collect Values: collect_values returns an array with all values converted using the block operation.

{ foo: 'bar', baz: :boo }.collect_values                       #=> ['bar', :boo]
{ foo: 'bar', baz: :boo }.collect_values { |k| k.to_s.upcase } #=> ['BAR', BOO']

Compact: compact and compact! returns a hash with non nil values.

{}.compact                                   #=> {}
{ foo: nil }.compact                         #=> {}
{ foo: 'bar', baz: false, boo: nil }.compact #=> { foo: 'bar', baz: false }

Deep Merge: deep_merge and deep_merge! returns a new hash with self and other_hash merged recursively.

h1 = { a: true, b: { c: [1, 2, 3] } }
h2 = { a: false, b: { x: [3, 4, 5] } }

h1.deep_merge(h2) #=> { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }

Demote: demote and demote! moves a key value pair to the tail of the hash.

{ a: 0, b: 1, c: 2 }.demote(:b)  #=> { a: 0, c: 2, b: 1 }
{ a: 0, b: 1, c: 2 }.demote!(:d) #=> { a: 0, b: 1, c: 2 }

Denillify: denillify and denillify! converts nils into a given value.

{ abc: nil, xyz: 1 }.denillify     #=> { abc: 0, xyz: 1 }
{ abc: nil, xyz: 1 }.denillify!(9) #=> { abc: 9, xyz: 1 }

Dig: dig returns the value of a nested hash.

h1 = { a: { b: { c: :d } } }

h1.dig(:a, :b)     #=> { c: :d }
h1.dig(:a, :b, :c) #=> :d

Except: except and except! returns a hash that includes everything but the given keys.

{}.except(:foo)                                                    #=> {}
{ foo: 'foo', baz: 'baz', bar: 'bar' }.except(:foo)                #=> { baz: 'baz', bar: 'bar' }
{ :foo => 'foo', :baz => 'baz', :bar => 'bar' }.except(:baz, :bar) #=> { :foo => 'foo' }

Extract: extract! removes and returns the key/value pairs matching the given keys.

{}.extract!(:foo)                                     #=> {}
{ foo: 'foo', baz: 'baz', bar: 'bar' }.extract!(:foo) #=> { foo: 'foo' }

Hmap: hmap and hmap! returns a hash that is transformed in place.

{ a: 1, b: 2, c: 3 }.hmap { |k, v| { k => v + 3 } } #=> { a: 4, b: 5, c: 6 }

Nillify: nillify and nillify! transforms all blank values to nil.

{ a: 1, b: 'test', c: nil, d: false, e: '', f: ' ' }.nillify #=> {a: 1, b: 'test', c: nil, d: nil, e: nil, f: nil}

Only: only and only! returns only key/value pairs matching certain keys.

{}.only(:foo)                                                    #=> {}
{ foo: 'foo', baz: 'baz', bar: 'bar' }.only(:foo)                #=> { foo: 'foo' }
{ :foo => 'foo', :baz => 'baz', :bar => 'bar' }.only(:baz, :bar) #=> { :baz => 'baz', :bar => 'bar' }

Only fill: only_fill and only_fill! returns only key/value pairs matching certain keys and any missing one.

{}.only_fill(:foo)                                          #=> { foo: nil }
{ :foo => 1, baz: 2 }.only_fill(:foo, :bar, placeholder: 0) #=> { foo: 1, bar: 0 }

Pair?: pair? checks if the hash has a key with a matching value.

{ a: 0 }.pair?(:a, 0) #=> true
{ a: 0 }.pair?(:a, 2) #=> false

Promote: promote and promote! moves a key value pair to the head of the hash.

{ a: 0, b: 1, c: 2 }.promote(:b)  #=> { b: 1, a: 0, c: 2 }
{ a: 0, b: 1, c: 2 }.promote!(:d) #=> { a: 0, b: 1, c: 2 }

Rename Keys: rename_keys and rename_keys! rename the keys of a hash.

{ foo: 'foo', baz: 'baz' }.rename_keys(foo: :bar)                      #=> { bar: 'foo', baz: 'baz' }
{ foo: 'foo', 'baz' => 'baz' }.rename_keys(foo: :bar, 'baz' => 'tick') #=> { bar: 'foo', tick: 'baz' }

Reverse Merge: reverse_merge and reverse_merge! merges one hash into other hash.

{}.reverse_merge!(foo: 'bar')                         #=> { foo: 'bar' }
{ foo: 'bar' }.reverse_merge!(baz: 'boo', boo: 'bam') #=> { foo: 'bar', baz: 'boo', boo: 'bam' }

Sample: sample returns a random key-value pair. sample! deletes a random key-value pair and returns that pair.

h = { a: 1, b: 2, c: 3, d: 4 }

h.sample  #=> [:c, 3]
h.sample! #=> [:a, 1]

Sample Key: sample_key returns a random key. sample_key! delete a random key-value pair, returning the key.

h = { a: 1, b: 2, c: 3, d: 4 }

h.sample_key  #=> :b
h.sample_key! #=> :d

Sample Value: sample_value returns a random value. sample_value! delete a random key-value pair, returning the value.

h = { a: 1, b: 2, c: 3, d: 4 }

h.sample_value  #=> 1
h.sample_value! #=> 3

Shuffle: shuffle returns a copy of the hash with values arranged in new random order. shuffle! returns the hash with values arranged in new random order.

h = { a: 1, b: 2, c: 3, d: 4 }

h.shuffle  #=> { b: 2, c: 3, a: 1, d: 4 }
h.shuffle! #=> { d: 4, b: 2, c: 3, a: 1 }

Slice: slice returns a hash to include only the given keys. Returns a hash containing the given keys. slice! replaces the hash with only the given keys. Returns a hash containing the removed key/value pairs.

h = { a: 1, b: 2, c: 3, d: 4 }

h.slice(:a, :b)  #=> { a: 1, b: 2 }
h.slice!(:a, :b) #=> { c: 3, d: 4 }

Stringify Keys: stringify_keys and stringify_keys! converts the hash keys to strings.

{ foo: 'foo', 'bar' => 'bar' }.stringify_keys #=> { 'foo' => 'foo', 'baz' => 'baz' }

Strip: strip and strip! returns a hash with non nil, false, or blank values.

{}.strip                                                      #=> {}
{ foo: nil, baz: false, boo: '', faz: ' ' }.strip             #=> {}
{ foo: 'bar', baz: false, boo: nil, boz: '', faz: ' ' }.strip #=> { foo: 'bar' }

Symbolize Keys: symbolize_keys and symbolize_keys! converts the hash keys to symbols.

{ foo: 'foo', 'bar' => 'bar' }.symbolize_keys #=> { foo: 'foo', baz: 'baz' }

Symbolize and Underscore Keys: symbolize_and_underscore_keys and symbolize_and_underscore_keys! symbolize and underscore hash keys.

{ 'firstName' => 'foo', 'last Name' => 'test' }.symbolize_and_underscore_keys #=> { first_name: 'foo', last_name: 'test' }

To Object: to_o converts an object to have an object like API.

{ foo: { bar: true } }.to_o.foo.bar #=> true

Transform Keys: transform_keys and transform_keys! returns a new hash with all keys converted using the block operation.

{ foo: 'bar', baz: 'boo' }.transform_keys { |k| k.to_s.upcase } #=> { 'FOO' => 'bar', 'BAZ' => 'boo' }

Transform Values: transform_values and transform_values! returns a new hash with all values converted using the block operation.

{ foo: 'bar', baz: 'boo' }.transform_values { |v| v.to_s.upcase } #=> {foo: 'BAR', baz: 'BOO' }

Vacant: vacant? returns where the value of a key is blank?.

{}.vacant?(:foo)             #=> true
{ foo: ' ' }.vacant?(:foo)   #=> true
{ foo: 'bar' }.vacant?(:foo) #=> false

Integer

Factorial: factorial calculates the factorial of an integer.

4.factorial #=> 24

Factors: factors calculates all the factors of an integer.

24.factors #=> [1, 24, 2, 12, 3, 8, 4, 6]

Of: of is like #times but returns a collection of the yield results.

3.of { |i| '#{i+1}' } #=> ['1', '2', '3']

Roman: roman converts this integer to a roman numeral.

49.roman #=> 'XLIX'

Time: time returns a Time object for the given Integer.

3.time #=> '1969-12-31 19:00:03.000000000 -0500'

Numeric

Add: add returns the sum of two numbers.

4.add(2) #=> 6

Bytes in Bytes: byte_in_bytes and bytes_in_bytes returns self.

3.bytes_in_bytes #=> 3

Centigrams in Grams: centigram_in_grams and centigrams_in_grams returns the amount of grams in n centigrams.

3.centigrams_in_grams #=> 0.03

Centimeters in Meters: centimeter_in_meters and centimeters_in_meters returns the amount of meters in n centimeters.

3.centimeters_in_meters #=> 0.03

Centuries_in_seconds: century_in_seconds and centuries_in_seconds returns the amount of seconds in n centuries.

3.centuries_in_seconds #=> 9467280000.0

Clamp: clamp returns a comparable between a lower and upper bound.

1.clamp(3, 6) # => 3
5.clamp(3..6) # => 5
8.clamp(3, 6) # => 6

Days in Seconds: day_in_seconds and days_in_seconds returns the amount of seconds in n days.

3.days_in_seconds #=> 259200

Decades in Seconds: decade_in_seconds and decades_in_seconds returns the amount of seconds in n decades.

3.decades_in_seconds #=> 946728000.0

Decagrams in Grams: decagram_in_grams and decagrams_in_grams returns the amount of grams in n decagrams.

3.decagrams_in_grams #=> 30

Decameters in Meters: decameter_in_meters and decameters_in_meters returns the amount of meters in n decameters.

3.decameters_in_meters #=> 30

Decigrams in Grams: decigram_in_grams and decigrams_in_grams returns the amount of grams in n decigrams.

3.decigrams_in_grams #=> 0.3

Decimeters in Meters: decimeter_in_meters and decimeters_in_meters returns the amount of meters in n decimeters.

3.decimeters_in_meters #=> 0.3

degrees_to_radians: degrees_to_radians returns number of degrees into radians.

90.degrees_to_radians #=> 1.5707963267948966

Distance: distance returns the absolute difference between numbers.

5.distance(3) #=> 2
3.distance(5) #=> 2

Divide: divide returns the division of two numbers.

4.divide(2) #=> 2
0.divide(2) #=> 0
4.divide(0) #=> 0

Exabytes in Bytes: exabyte_in_bytes and exabytes_in_bytes returns the amount of bytes in n exabytes.

3.exabytes_in_bytes #=> 3458764513820540928

Feet in Inches: foot_in_inches and feet_in_inches returns the amount of inches in n feet.

3.feet_in_inches #=> 36

Fractional: fractional returns the numbers after '.' of a float.

1.0.fraction      #=> 0.0
12.2456.fraction  #=> 0.2456
-12.2456.fraction #=> 0.2456

Fraction?: fraction? returns if its a fractional.

1.0.fraction?      #=> false
12.2456.fraction?  #=> true

Gigabytes in Bytes: gigabyte_in_bytes and gigabytes_in_bytes returns the amount of bytes in n gigabytes.

3.gigabytes_in_bytes #=> 3221225472

Grams in Grams: gram_in_grams and grams_in_grams returns self.

3.grams_in_grams #=> 3

Greater Than: greater_than? returns true if self is greater than n.

3.greater_than?(2) #=> true
3.greater_than?(3) #=> false
3.greater_than?(4) #=> false

Greater Than or Equal To: greater_than_or_equal_to? returns true if self is greater than or equal to n.

3.greater_than_or_equal_to?(2) #=> true
3.greater_than_or_equal_to?(3) #=> true
3.greater_than_or_equal_to?(4) #=> false

Hectograms in Grams: hectogram_in_grams and hectograms_in_grams returns the amount of grams in n hectograms.

3.hectograms_in_grams #=> 300

Hectometers in Meters: hectometer_in_meters and hectometers_in_meters returns the amount of meters in n hectometers.

3.hectometers_in_meters #=> 300

Hours in Seconds: hour_in_seconds and hours_in_seconds returns the amount of seconds in n hours.

3.hours_in_seconds #=> 10800

Inches in Inches: inch_in_inches and inches_in_inches returns the amount of inches in n inches.

3.inches_in_inches #=> 3

Inside: inside? returns true if n is greater than start and less than finish. Similar to between but does not return true if equal to self.

3.inside?(1, 5) #=> true
3.inside?(3, 5) #=> false

Kilobytes in Bytes: kilobyte_in_bytes and kilobytes_in_bytes returns the amount of bytes in n kilobytes.

3.kilobytes_in_bytes #=> 3072

Kilograms in Grams: kilogram_in_grams and kilograms_in_grams returns the amount of grams in n kilograms.

3.kilograms_in_grams #=> 3000

Kilometers in Meters: kilometer_in_meters and kilometers_in_meters returns the amount of meters in n kilometers.

3.kilometers_in_meters #=> 3000

Less Than: less_than? returns true if self is less than n.

3.less_than?(2) #=> false
3.less_than?(3) #=> false
3.less_than?(4) #=> true

Less Than or Equal To: less_than_or_equal_to? returns true if self is less than or equal to n.

3.less_than_or_equal_to?(2) #=> false
3.less_than_or_equal_to?(3) #=> true
3.less_than_or_equal_to?(4) #=> true

Metric Ton in Ounces: metric_ton_in_ounces and metric_tons_in_ounces returns the amount of grams in n metric_tons.

3.metric_tons_in_ounces #=> 3000000

Megabytes in Bytes: megabyte_in_bytes and megabytes_in_bytes returns the amount of bytes in n megabytes.

3.megabytes_in_bytes #=> 3145728

Meters in Meters: meter_in_meters and meters_in_meters returns self.

3.meters_in_meters #=> 3

Miles in Inches: mile_in_inches and miles_in_inches returns the amount of inches in n miles.

3.miles_in_inches #=> 190080

Millenniums in Seconds: millennium_in_seconds and millenniums_in_seconds returns the amount of seconds in n millenniums.

3.millenniums_in_seconds #=> 94672800000.0

Milligrams in Grams: milligram_in_grams and milligrams_in_grams returns the amount of grams in n milligrams.

3.milligrams_in_grams #=> 0.003

Millimeters in Meters: millimeter_in_meters and millimeters_in_meters returns the amount of meters in n millimeters.

3.millimeters_in_meters #=> 0.003

Minutes in Seconds: minute_in_seconds and minutes_in_seconds returns the amount of seconds in n minutes.

3.minutes_in_seconds #=> 180

Multiply: multiply returns the multiplication of two numbers.

4.multiply(2) #=> 8

Multiple Of: multiple_of? returns true if a number can be evenly divided by n.

9.multiple_of?(3) #=> true
7.multiple_of?(3) #=> false

Nautical Miles in Inches: nautical_mile_in_inches and nautical_miles_in_inches returns the amount of inches in n nautical miles.

3.nautical_miles_in_inches #=> 218740.26239999998

Negative: negative? returns true if a number is less than zero.

-1.negative? #=> true
1.negative? #=> false

Ordinal: ordinal returns the suffix that should be added to a number to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.

'1'.ordinal  #=> 'th'
'2'.ordinal  #=> 'nd'
'3'.ordinal  #=> 'rd'
'11'.ordinal #=> 'th'

Ordinalize: ordinalize transforms a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.

'1'.ordinalize  #=> '1th'
'2'.ordinalize  #=> '2nd'
'3'.ordinalize  #=> '3rd'
'11'.ordinalize #=> '4th'

Ounces in Ounces: ounce_in_ounces and ounces_in_ounces returns self.

3.ounces_in_ounces #=> 48

Outside: outside? returns true if n is less than start or greater than finish.

3.outside?(4, 5) #=> true
3.outside?(3, 5) #=> false

Pad: pad returns a string representation of the number padded with pad_num to a specified length.

3.pad                #=> '003'
3.pad(pad_number: 1) #=> '113'
3.pad(precision: 4)  #=> '0003'

Pad Precision: pad_precision returns a string of padded after the '.' to n amount.

Options

  • pad_number: 0
  • precision: 2
  • separator: '...'
3.pad_precision                #=> '3.00'
3.5.pad_precision              #=> '3.50'
3.pad_precision(pad_number: 1) #=> '3.11'

Percentage Of: percentage_of returns the percentage of a number in relation to another number.

0.percentage_of(4) #=> 0
2.percentage_of(0) #=> 0
2.percentage_of(4) #=> 50.0

Petabytes in Bytes: petabyte_in_bytes and pegabytes_in_bytes returns the amount of bytes in n petabytes.

3.petabytes_in_bytes #=> 3377699720527872

Positive: positive? returns true if a number is greater than zero.

1.positive? #=> true
-1.positive? #=> false

Pounds in Ounces: pound_in_ounces and pounds_in_ounces returns the amount of ounces in n pounds.

3.pounds_in_ounces #=> 48

Power: power returns the nth power of a number.

4.power(2) #=> 16

Root: root returns the nth root of a number.

4.root(2) #=> 2

Seconds in Seconds: second_in_seconds and seconds_in_seconds returns self.

3.seconds #=> 3

Stones in Ounces: stone_in_ounces and stone_in_ounces returns the amount of ounces in n stones.

3.stones_in_ounces #=> 672

Subtract: subtract returns the difference of two numbers.

4.subtract(2) #=> 2

Terabytes in Bytes: terabyte_in_bytes and terabytes_in_bytes returns the amount of bytes in n terabytes.

3.terabytes_in_bytes #=> 3298534883328

To Byte: to_byte_in_bytes converts a byte size from one unit to another unit.

1.to_byte(:byte, :byte)          #=> 1 #B
5120.to_byte(:byte, :kilobyte)   #=> 5 #MB
1.to_byte(:megabyte, :kilobyte)  #=> 1024 #KB
80.to_byte(:megabyte, :gigabyte) #=> 0.078125 #GB

To Currency: to_currency converts a number to currency string.

Options

  • precision: 2
  • unit: '$'
3.to_currency            #=> '$3.00'
3.1.to_currency          #=> '$3.10'
3.11.to_currency         #=> '$3.11'
3.11111.to_currency      #=> '$3.11'
3.to_currency(unit: '@') #=> '@3.00'

To Length: to_length converts a length from one unit to another unit.

12.to_length(:inches, :feet)         #=> 12 #IN
3000.to_length(:meters, :kilometers) #=> 3 #KM
1.to_length(:feet, :centimeters)     #=> 30.479999999999997 #CM
1.to_length(:kilometer, :yards)      #=> 1093.6138888888888 #YDS

To Mass: to_mass converts a mass from one unit to another unit.

16.to_mass(:ounces, :pounds)        #=> 1 #LB
1.to_mass(:centigrams, :milligrams) #=> 10 #MG
3.to_mass(:pound, :kilogram)        #=> 1.360776 #KG
1.to_mass(:kilograms, :pounds)      #=> 2.204625 #LB

To Nearest Value: to_nearest value return the value in values that is nearest to the number.

5.to_nearest_value([1, 3, 6, 9])           #=> 6
3.5.to_nearest_value([3.0, 3.3, 3.6, 3.9]) #=> 3.6

To Percantage: to_percentage converts a number to percentage string.

Options

  • precision: 2
  • unit: '%'
3.to_percentage            #=> '3.00%'
3.1.to_percentage          #=> '3.10%'
3.11.to_percentage         #=> '3.11%'
3.11111.to_percentage      #=> '3.11%'
3.to_percentage(unit: '@') #=> '[email protected]'

To Temperature: to_temperature converts a temperature from one unit to another unit.

100.to_temperature(:celsius, :fahrenheit) #=> 212 #F
212.to_temperature(:fahrenheit, :celsius) #=> 100 #C
212.to_temperature(:fahrenheit, :kelvin)  #=> 373.15 #K

To Time: to_time converts a time unit from one unit to another unit.

120.to_time(:seconds, :minutes) #=> 2 #MIN
3.to_time(:hours, :days)        #=> 3 #DAY
2.to_time(:days, :seconds)      #=> 172800 #SEC
1825.to_time(:days, :years)     #=> 4.996577686516085 #YR

Tons in Ounces: ton_in_ounces and ton_in_ounces returns the amount of ounces in n tons.

3.tons_in_ounces #=> 96000

Weeks in Seconds: week_in_seconds and weeks_in_seconds returns the amount of seconds in n weeks.

3.weeks_in_seconds #=> 1814400

Within: within? determines if another number is approximately equal within a given epsilon

10.006.within?(10, 0.1) #=>  true

Yards in Inches: yard_in_inches and yards_in_inches returns the amount of inches in n yards.

3.yards_in_inches #=> 108

Years in Seconds: year_in_seconds and years_in_seconds returns the amount of seconds in n years.

3.years_in_seconds #=> 94672800.0

Object

Array: array? determines if an object is an array.

[].array?              #=> true
'Awesome Sting'.array? #=> false

Blank: blank? determines if an object is empty or nil.

''.blank?              #=> true
'Awesome Sting'.blank? #=> false

Bool: bool? determines if an object is a true or false class.

true.bool?    #=> true
1.bool?       #=> false
'false'.bool? #=> false

Boolean: boolean? determines if an object is an boolean.

true.boolean?    #=> true
1.boolean?       #=> true
'false'.boolean? #=> true
'foo'.boolean?   #=> false

Date: date? determines if an object is a date.

Date.today.date? #=> true
'foo'.date?      #=> false

False: false? determines if an object is false.

false.false? #=> true
true.false?  #=> false

Falsey: falsey? determines if an object is false, nil, or 0.

false.falsey? #=> true
true.falsey?  #=> false
0.falsey?     #=> true

Float: float? determines if an object is a float.

1.0.float? #=> true
1.float?   #=> false

Hash: hash? determines if an object is a hash.

{}.hash? #=> true
[].hash? #=> false

Integer: integer? determines if an object is a integer.

1.integer?   #=> true
1.0.integer? #=> false

Numeric: numeric? determines if an object is numeric.

1.numeric?     #=> true
1.0.numeric?   #=> true
'1.0'.numeric? #=> false

Numeral: numeral? determines if an object's string value is numeral.

'-32.50'.numeral? #=> true
'$2.55'.numeral?  #=> false

Palindrome: palindrome? determines if an object is equal when reversed.

'racecar'.palindrome? #=> true
12321.palindrome?     #=> true
'example'.palindrome? #=> false
12345.palindrome?     #=> false

Present: present? determines if an object is not empty or nil.

'Awesome Sting'.present? #=> true
''.present?              #=> false

Range: range? determines if an object is a range.

(1..2).range? #=> true
1.range?      #=> false

Safe Call: safe_call execute caller to an object and rescues with self.

callr = ->(x) { 3 * x }

3.safe_call        #=> 3
callr.safe_call(3) #=> 9
callr.safe_call    #=> raises ArgumentError: wrong number of arguments

Safe Send: safe_send execute object method and rescues with self.

3.safe_send(:fake) #=> 3
3.safe_send(:to_s) #=> '3'
3.safe_send(:+, 2) #=> 5

Safe Try: safe_try similar to the try method but returns self instead of nil.

'example'.safe_try(:upcase)      #=> 'EXAMPLE'
'example'.safe_try(:fake_method) #=> 'example'

Salvage: salvage returns a placeholder if object is blank?.

' '.salvage        #=> '---'
nil.salvage('bar') #=> 'bar'
123.salvage        #=> 123

Send Chain: send_chain chains multiple callers to an object.

3.send_chain(:factorial)            #=> 6
3.send_chain([:add, 4])             #=> 7
3.send_chain(:factorial, [:add, 4]) #=> 10

Send Chain If: send_chain_if chains multiple callers to an object if it responds to it.

3.send_chain_if(:test)                        #=> 3
3.send_chain_if(:factorial)                   #=> 6
3.send_chain_if([:add, 4])                    #=> 7
3.send_chain_if(:factorial, [:add, 4], :test) #=> 10

Send If: send_if sends a caller to an object if it responds to it.

3.send_if(:test)      #=> 3
3.send_if(:factorial) #=> 6
3.send_if(:add, 4)    #=> 7

String: string? determines if an object is a string.

'foo'.string? #=> true
1.string?     #=> false

Symbol: symbol? determines if an object is a symbol.

:foo.time?  #=> true
'foo'.time? #=> false

Time: time? determines if an object is a time.

Time.now.time? #=> true
'foo'.time?    #=> false

True: true? determines if an object is true.

true.true?  #=> true
false.true? #=> false

Truthy: truthy? determines if an object is true or 1.

true.truthy?  #=> true
false.truthy? #=> false
1.truthy?     #=> true

Try: try and try! invokes the public method whose name goes as first argument just like public_send does, except that if the receiver does not respond to it the call returns nil rather than raising an exception.

'example'.try(:upcase)      #=> 'EXAMPLE'
'example'.try(:fake_method) #=> nil

Try Call: try_call execute caller to an object and rescues with nil.

callr = ->(x) { 3 * x }

3.try_call        #=> nil
callr.try_call(3) #=> 9
callr.try_call    #=> raises ArgumentError: wrong number of arguments

Try Send: try_send execute object method and rescues with nil.

3.try_send(:fake) #=> 3
3.try_send(:to_s) #=> '3'
3.try_send(:+, 2) #=> 5

Range

Combine: combine returns two concated ranges.

(1..3).combine(7..9) #=> [1, 2, 3, 7, 8, 9]

Include With Range: include_with_range? determines if a range includes another range.

(1..5).include?(1..5) # => true
(1..5).include?(2..3) # => true
(1..5).include?(2..6) # => false

Overlaps: overlaps? determines if two ranges overlap each other.

(1..5).overlaps?(4..6) # => true
(1..5).overlaps?(7..9) # => false

Sample: sample returns a random element from the range.

(1..5).sample # => 4

Shuffle: shuffle returns a copy of a shuffled range of elements. shuffle! returns a shuffled range of elements.

(1..5).shuffle  # => [2, 5, 1, 4, 3]
(1..5).shuffle! # => [3, 4, 5, 2, 1]

Within: within? determines if one range is within another.

(1..5).within?(2..4) # => true
(1..5).within?(4..6) # => false

String

Any: any? determines if a string includes a set of string(s).

'example string'.any?('foo')           #=> false
'example string'.any?('foo', 'string') #=> true

At: at returns the characters at index position, matching string, or regex.

'example_string'.at(0)     #=> 'e'
'example_string'.at(-2)    #=> 'n'
'example_string'.at(1..3)  #=> 'xam'
'example_string'.at('e_s') #=> 'e_s'
'example_string'.at(/ple/) #=> 'ple'
'example_string'.at(99)    #=> nil

Camelize: camelize and camelize! transforms a string to camelcase.

'example_string'.camelize         #=> 'ExampleString'
'example_String'.camecase         #=> 'ExampleString'
'example_string'.camelize(:lower) #=> 'exampleString'
'example_String'.camecase(:lower) #=> 'exampleString'

Classify: classify and classify! creates a class name from a string like Rails does for table names to models.

'example_string'.classify      #=> 'ExampleString'
'example_string/test'.classify #=> 'ExampleString::Test'
'example_string.test'.classify #=> 'Test'

Constantize: constantize converts a string in an object.

'Example::String'.constantize #=> Class Object

Dasherize: dasherize and dasherize! replaces underscores with dashes in the string.

'example_string'.dasherize #=> 'example-string'

Deconstantize: deconstantize and deconstantize! removes the rightmost segment from the constant expression in the string.

'Example::String'.deconstantize   # => 'Example'
'::Example::String'.deconstantize # => '::Example'
'String'.deconstantize            # => ''
'::String'.deconstantize          # => ''
''.deconstantize                  # => ''

Demodulize: demodulize and demodulize! removes the module part from the expression in the string.

'Example::String'.demodulize #=> 'String'
'String'.demodulize          #=> 'String'

Domain: domain extracts the domain name from a URL.

'http://www.example.com/fake-page'.domain #=> 'www.example.com'
'example string'.domain                   #=> 'example string'

Downcase: downcase? returns true if all characters are lowercase.

'example'.downcase? #=> true
'Example'.downcase? #=> false
'EXAMPLE'.downcase? #=> false

Ellipsize: ellipsize truncate a string in the middle.

Options

  • offset: 4
  • separator: '...'
'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'.ellipsize(30)                   #=> '0123...WXYZ'
'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'.ellipsize(50)                   #=> '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'.ellipsize(30, offset: 2)        #=> '01...YZ'
'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'.ellipsize(30, separator: '+++') #=> '0123+++WXYZ'

Exclude: exclude? returns true if the string does not include the other string.

'example_string'.exclude?('exa') #=> false
'example_string'.exclude?('xxx') #=> true

First: first 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.

'example'.first    #=> 'e'
'example'.first(0) #=> ''
'example'.first(3) #=> 'exa'

Format: format returns an interpolated string that allows for options.

'example %s'.format('string')                              #=> 'example string'
'test %{one} %{two}'.format(one: 'example', two: 'string') #=> 'test example string'
'%d + %d'.format([1, 2])                                   #=> '1 + 2'

From: from 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.

'example'.from(0) #=> 'example'
'example'.from(3) #=> 'mple'

Headerize: headerize and headerize! capitalizes each word.

' example test-sample '.headerize #=> 'Example Test-sample'

Humanize: humanize and humanize! transforms a string to a human readable string.

Options

  • capitalize: true
'ExampleString'.humanize                     #=> 'Example string'
'_example_string_id'.humanize                #=> 'Example string'
'example_string'.humanize(capitalize: false) #=> 'example string'

Indent: indent and indent! indents the lines in the receiver.

'example'.indent(2)       #=> '  example'
'example'.indent(2, '\t') #=> '\t\texample'

Index all: index_all returns the index values of matching patterns.

'012324507654301243'.index_all(0)                           #=> [0,7,13]
'the apple is the best fruit in the world'.index_all('the') #=> [0,13,31]
'asdfasdfasdf'.index_all(/sd/)                              #=> [1,5,9]

Labelize: labelize and labelize! transforms a string to a human readable string.

'example string'.labelize     #=> 'Example string'
'_example_string_id'.labelize #=> 'Example string ID'
'ExampleString'.labelize      #=> 'Example string'

Last: last 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.

'example'.last     #=> 'e'
'example'.last(0)  #=> ''
'example'.first(3) #=> 'ple'

Mixcase: mixcase? returns true if characters are mixedcase.

'Example'.mixedcase? #=> true
'EXAMPLE'.mixedcase? #=> false
'example'.mixedcase? #=> false

Ordinal: ordinal returns the suffix that should be added to a number to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.

'1'.ordinal  #=> 'th'
'2'.ordinal  #=> 'nd'
'3'.ordinal  #=> 'rd'
'11'.ordinal #=> 'th'

Ordinalize: ordinalize transforms a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.

'1'.ordinalize  #=> '1th'
'2'.ordinalize  #=> '2nd'
'3'.ordinalize  #=> '3rd'
'11'.ordinalize #=> '4th'

Parameterize: parameterize and parameterize! makes string suitable for a dashed url parameter string.

'example_string'.parameterize                 #=> 'example-string'
'example_string'.parameterize(separator: '?') #=> 'example?string'

Pollute: pollute and pollute! pollutes the space between every letter in a string, so it will be exempt from any impending string searches.

'test'.pollute      #=> 't^--^--^e^--^--^s^--^--^t^--^--^'
'test'.pollute('-') #=> 't-e-s-t-'

Pop: pop returns the last character of a string.

'test'.pop #=> 't'

Push: push concats string to self.

'test'.push('er') #=> 'tester'

Remove: remove and remove! removes every instance of a string.

'this thing that thing'.remove('thing')        #=> 'this  that '
'this thing that thing'.remove(1..3)           #=> 't thing that thing'
'this thing that them'.remove('thing', 'them') #=> 'this  that '
'this thing that them'.remove('thing', 1..3)   #=> 't  that them'

Remove Tags: remove_tags and remove_tags! removes HTML tags from a string.

'example'.remove_tags                                   #=> 'example'
'<a href='http://example.com'>click</a>'.remove_tags    #=> 'click'
'this is <b>bold</b> and <em>emphatic</em>'.remove_tags #=> 'this is bold and emphatic'

Sample: sample and sample! deletes a random value and returns that value.

'this thing that'.sample            #=> 'thing'
'this thing that'.sample(' thing ') #=> 'that'

Shift: shift and shift! removes the first instance of a string.

'this thing that thing'.shift                 #=> 't'
'this thing that thing'.shift('thing')        #=> 'this  that thing'
'this thing that thing'.shift('this', 'that') #=> ' thing  thing'

Shuffle: shuffle and shuffle! randomizes the characters in a string.

'ruby rules'.sample  #=> 'e lybrsuur'
'ruby rules'.sample! #=> 'rblse syru'

Sift: sift and sift! returns a string matching any character in a pattern.

'qa2ws3ed4rf5tg6yh7uj8ik9ol'.sift('0123456789')          #=> '23456789'
'qa2ws3ed4rf5tg6yh7uj8ik9ol'.sift(0..9)                  #=> '23456789'
'qa2ws3ed4rf5tg6yh7uj8ik9ol'.sift([0,1,2,3,4,5,6,7,8,9]) #=> '23456789'

Slugify: slugify and slugify! generates a permalink-style string, with odd characters removed.

'example'.slugify                  #=> 'example'
'example string'.slugify           #=> 'example-string'
'Example string @@@ test!'.slugify #=> 'example-string-test'

Sort: sort and sort! sorts a string.

'adbec'.sort #=> 'abcde'

Squish: squish and 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.

'example    string'.squish        #=> 'example string'
'example  \n   \t  string'.squish #=> 'example string'
'   example    string   '.squish  #=> 'example string'

Titleize: titleize and titleize! capitalizes each word in a string.

'example string'.titleize     #=> 'Example String'
'_example_string_id'.titleize #=> 'Example String'
'ExampleString'.titleize      #=> 'Example String'

To: to 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.

'example'.to(0)  #=> 'example'
'example'.to(3)  #=> 'exam'
'example'.to(-2) #=> 'exampl'

Transliterize: transliterize and transliterize! returns a string with swapped special characters.

'źåöé'.transliterize #=> 'zaoe'

Truncate: truncate a given text after a given length if text is longer than length.

Options

  • omission: '...'
  • separator: ' '
'example string'.truncate(3)                          #=> '...'
'example string'.truncate(6)                          #=> 'exa...'
'example string'.truncate(12, separator: ' ')         #=> 'example...'
'example string'.truncate(13, omission: '... (more)') #=> 'exa... (more)'
'example string'.truncate(15)                         #=> 'example string'

Truncate Words: truncate_words truncates a given text after a given number of words.

Options

  • omission: '...'
  • separator: ' '
'example string test'.truncate_words(1)                                                                #=> 'example...'
'Once<br>upon<br>a<br>time<br>in<br>a<br>world'.truncate_words(5, separator: '<br>')                   #=> 'Once<br>upon<br>a<br>time<br>in...'
'And they found that many people were sleeping better.'.truncate_words(5, omission: '... (continued)') #=> 'And they found that many... (continued)'

Underscore: underscore and underscore! transforms a string to snakecase.

'ExampleString'.underscore       #=> 'example_string'
'exampleString'.underscore       #=> 'example_string'
'ExampleString::Test'.underscore #=> 'example_string/test'

Unpollute: unpollute and unpollute! removes the default or custom pollution character. Can also be used to remove an unwanted character.

't^--^--^e^--^--^s^--^--^t^--^--^'.unpollute #=> 'test'
't-e-s-t-'.unpollute                         #=> 'test'

Upcase: upcase? returns true if all characters are uppercase.

'EXAMPLE'.upcase? #=> true
'example'.upcase? #=> false
'Example'.upcase? #=> false

Unshift: unshift and unshift! prepends string(s) to self.

'this thing that thing'.unshift('thing ')         #=> 'thing this thing that thing'
'this thing that thing'.unshift('this ', 'that ') #=> 'this that this thing that thing'

DateTime

Note: also works with Date class.

Format: format converts a Date or Time object to format it using a human readable string.

Rules

  • Characters: a-z 0-9 _
  • Characters can only be used to generate a format part
Date.today.format('year')                                #=> '2014'
Time.now.format('month_name day, year hour:minute ampm') #=> 'January 09, 2014 02:31 pm'
Name Key Equivalent strftime Result
Month - digits zero-padded m or month or month_padded %m (01..12)
Month - digits unpadded mm or Month or month_unpadded %-m (1..12)
Month - digits blank-padded mmm or MONTH or day_blank %_m ( 1..12)
Month - name mmmm or month_name %B January
Month - name abbreviated mmmmm or month_name_abbr %b Jan
Day - digits zero-padded d or day or day_padded %d (01..31)
Day - digits unpadded dd or Day or day_unpadded %-d (1..31)
Day - digits blank-padded ddd or DAY or day_blank %_d ( 1..31)
Day - digits of the year dddd or day_of_the_year %j (001..366)
Week - iso we or week %V (00..53)
Week - starting sunday swe or sunday_week %U (00..53)
Week - starting monday mwe or monday_week %W (00..53)
Weekday - starting monday w or weekday %u (1..7)
Weekday - starting sunday ww or weekday_offset %w (0..6)
Weekday - name www or weekday_name %A Sunday
Weekday - name abbreviated wwww or weekday_name_abbr %a Sun
Year - digits two yy or yr %y (00..99)
Year - digits four yyyy or year %Y 1999
Hour - digits zero-padded h or hour or hour_padded %H (00..23)
Hour - digits blank-padded hh or HOUR or hour_blank %k ( 0..23)
Hour - digits zero-padded hhh or hour_imperical or hour_imperical_padded %I (01..12)
Hour - digits blank-padded hhhh or HOUR_IMPERICAL or hour_imperical_blank %l ( 1..12)
Minute - minute n or minute %M (00..59)
Second - second s or second %S (00..60)
Meridian - lowercase ampm or meridian %p am..pm
Meridian - uppercase AMPM or MERIDIAN %P AM..PM
Time Zone - time zone z or time_zone %z +0900
Time Zone - hour and minute offset zz or time_zone_offset %:z +09:00
Time Zone - hour, minute and second offset zzz or time_zone_offset_full %::z +09:00:00
Time Zone - time zone name zzzz or time_zone_name %Z UTC

To Format / Stamp: to_format and stamp converts a Date or Time object to a predefined format.

For a full list check out the time extention file.

Time.now.to_format(:year) #=> '2014'
Time.now.stamp(:datetime) #=> 'January 09, 2014 02:31 pm'
Name Key Equivalent strftime Result
Month - digits zero-padded :month or :month_padded %m (01..12)
Month - digits unpadded :month_unpadded %-m (1..12)
Month - digits blank-padded :month_blank %_m ( 1..12)
Month - name :month_name %B January
Month - name abbreviated :month_name_abbr %b Jan
Month - digits zero-padded :month_year or :month_padded_year %m %Y (01..12) 2015
Month - digits unpadded :month_unpadded_year %-m %Y (1..12) 2015
Month - digits blank-padded :month_blank_year %_m %Y ( 1..12) 2015
Month - name :month_name_year %B %Y January 2015
Month - name abbreviated :month_name_abbr_year %b %Y Jan 2015
Week - iso :week_iso %V (00..53)
Week - sunday week :sunday_week %U (00..53)
Week - monday week :monday_week %W (00..53)
Week - week year iso :week_year_iso %V-%G 04-2014
Weekday - digits zero-padded :weekday_padded %d (01..31)
Weekday - digits unpadded :weekday_unpadded %-d (1..31)
Weekday - digits blank-padded :weekday_blank %_d ( 1..31)
Weekday - name :weekday_name %A Sunday
Weekday - name abbreviated :weekday_name_abbr %a Sun
Year - digits two :yr %y (00..99)
Year - digits four :year %Y 1999
Year - day :year_day %Y-%m-%d 1999-01-21
Year - week :year_week %G-%V 1999-52
Year - month :year_month %Y-%m 1999-01
Hour - digits zero-padded :hour or :hour_padded %H (00..23)
Hour - digits blank-padded :hour_blank %k ( 0..23)
Hour - digits zero-padded imperical :hour_imperical_padded %I (01..12)
Hour - digits blank-padded imperical :hour_imperical_blank %l ( 1..12)
Minute - minute :minute %M (00..59)
Second - second :second %S (00..60)
Time Zone - time zone :time_zone %z +0900
Time Zone - hour and minute offset :time_zone_offset %:z +09:00
Time Zone - hour, minute and second offset :time_zone_offset_full %::z +09:00:00
Time Zone - time zone name :time_zone_name %Z UTC
Date - name :date %B %-d, %Y January 9, 2014
Date - name abbreviated :date_abbr %b %-d, %Y Jan 9, 2014
Date - iso :date_iso %Y-%m-%d 2014-01-09
Datetime - name :datetime %B %-d, %Y %H:%M January 9, 2014 00:31
Datetime - name abbreviated :datetime_abbr %b %-d, %Y %H:%M Jan 9, 2014 00:31
Datetime - iso :datetime_iso %Y-%m-%d %H:%M 2014-01-09 00:31
Datetime - name imperical :datetime_imperical %B %-d, %Y %H:%M January 9, 2014 12:31 am
Datetime - name abbreviated imperical :datetime_imperical_abbr %b %-d, %Y %H:%M Jan 9, 2014 12:31 am
Datetime - iso imperical :datetime_imperical_iso %Y-%m-%d %H:%M 2014-01-09 12:31 am
Datetime - name time zone :datetime_tzn %B %-d, %Y %H:%M %Z January 9, 2014 00:31 UTC
Datetime - name abbreviated time zone :datetime_abbr_tzn %b %-d, %Y %H:%M %Z Jan 9, 2014 00:31 UTC
Datetime - iso time zone :datetime_iso_tzn %Y-%m-%d %H:%M %z 2014-01-09 00:31 +0000
Datetime - name imperical time zone :datetime_imperical_tzn %B %-d, %Y %H:%M %Z January 9, 2014 12:31 am UTC
Datetime - name abbreviated imperical time zone :datetime_imperical_abbr_tzn %b %-d, %Y %H:%M %Z Jan 9, 2014 12:31 am UTC
Datetime - iso imperical time zone :datetime_imperical_iso_tzn %Y-%m-%d %H:%M %z 2014-01-09 12:31 am +0000
Day - name :day %B %-d January 9
Day - name abbreviated :day_abbr %b %-d Jan 9
Day - iso :day_iso %m-%d 01-09
Daytime - name :daytime %B %-d %H:%M January 9 00:31
Daytime - name abbreviated :daytime_abbr %b %-d %H:%M Jan 9 00:31
Daytime - iso :daytime_iso %m-%d %H:%M 01-09 00:31
Daytime - name imperical :daytime_imperical %B %-d %H:%M January 9 12:31 am
Daytime - name abbreviated imperical :daytime_imperical_abbr %b %-d %H:%M Jan 9 12:31 am
Daytime - iso imperical :daytime_imperical_iso %m-%d %H:%M 01-09 12:31 am
Time - zero-padded :time or :time_padded %H:%M 00:31
Time - blank-padded :time_blank %k:%M %z 0:31
Time - zero-padded imperical :time_imperical or :time_imperical_padded %I:%M %P 07:31
Time - blank-padded imperical :time_imperical_blank %l:%M %P 7:31
Time - with time zone :time_tz %H:%M %z 00:31 +0000
Time - with time zone name :time_tzn %H:%M %Z 00:31 UTC

Contributing

Your contribution is welcome.

  1. Fork it
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Added some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create new Pull Request