active_object 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e96a453245ef6274f0070ee0d457422545066a47
+  data.tar.gz: 68e653784fb298f7aa5a01580b82ca50f3bbd702
+SHA512:
+  metadata.gz: 85e2b171390a237569eac7564ae034a71c1d66f09eae85fefcbc82ec2487a0a605f55028216f500f9d501451996a7f050482c4fce65068716e91341a34653881
+  data.tar.gz: 1a137f2100d5cc3fd5e4cf9d821864ec1fd081de1307248737fde159696be859e86be9f1fe227a8ee0337016fa081fa2ba7a7d606b1722d3eed3daeb06325805

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,4 @@
+--order random
+--colour
+--backtrace
+--format progress

data/.travis.yml

@@ -0,0 +1,13 @@
+before_install:
+  - sudo apt-get install libxml2-dev
+cache: bundler
+language: ruby
+notifications:
+  email:
+    recipients:
+      - j.gomez@drexed.com
+    on_failure: change
+    on_success: never
+rvm:
+  - ruby-head
+script: 'bundle exec rake'

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_object.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Juan Gomez
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,1361 @@
+# ActiveObject
+
+[![Gem Version](https://badge.fury.io/rb/active_object.svg)](http://badge.fury.io/rb/active_object)
+[![Build Status](https://travis-ci.org/drexed/active_object.svg?branch=master)](https://travis-ci.org/drexed/active_object)
+[![Coverage Status](https://coveralls.io/repos/drexed/active_object/badge.png)](https://coveralls.io/r/drexed/active_object)
+
+ActiveObject is a collection of commonly used object helpers in a ruby based project. It currently includes extensions for: arrays, enumerables, hashes, integers, numerics, objects, strings, and time.
+
+`Rails Safe` = methods extracted from rails but that do not override that rails method.
+
+Highly recommended extensions:
+  * **Hash:** Hashie - https://github.com/intridea/hashie
+  * **String:** Escape Utils - https://github.com/brianmario/escape_utils
+  * **String:** Fast Blank - https://github.com/SamSaffron/fast_blank
+  * **Translation:** Fast Gettext - https://github.com/grosser/fast_gettext
+
+## 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
+
+## Usage
+
+### Array
+
+####Delete First:####
+`delete_first` removes the first element from an array. Like Array.shift, but returns the array instead of the removed element.
+
+```ruby
+["1", "2", "3"].delete_first #=> ["2", "3"]
+```
+
+####Delete Last:####
+`delete_last` removes the last element from an array. Like Array.pop, but returns the array instead of the removed element.
+
+```ruby
+["1", "2", "3"].delete_last #=> ["1", "2"]
+```
+
+####From:####
+`from` returns the tail of the array from position. `Rails Safe`
+
+```ruby
+["1", "2", "3"].from(0) #=> ["1", "2", "3"]
+["1", "2", "3"].from(1) #=> ["2", "3"]
+["1", "2", "3"].from(-1) #=> ["3"]
+```
+
+####Groups:####
+`groups` splits or iterates over the array in number of groups.
+
+```ruby
+%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. `Rails Safe`
+
+```ruby
+%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. `Rails Safe`
+
+```ruby
+%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"]]
+```
+
+####Split:####
+`split` divides the array into one or more subarrays based on a delimiting value or the result of an optional block. `Rails Safe`
+
+```ruby
+[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` removes blank elements from an array.
+
+```ruby
+["this", "", "that", nil, false].strip  #=> ["this", "that"]
+"this    is   a  test".split(" ").strip #=> ["this", "is", "a", "test"]
+```
+
+####To:####
+`to` returns the beginning of the array up to position. `Rails Safe`
+
+```ruby
+["1", "2", "3"].from(0) #=> ["1"]
+["1", "2", "3"].from(1) #=> ["1", "2"]
+["1", "2", "3"].from(-1) #=> ["3"]
+```
+
+####To Sentence:####
+`to_sentence` converts the array to a comma-separated sentence where the last element is joined by the connector word. `Rails Safe`
+
+**Options:**
+ * words_connector:     “, ”
+ * two_words_connector: “ and ”
+ * last_word_connector: “, and ”
+
+```ruby
+[].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
+
+####Difference:####
+`difference` returns the difference of a collection of numbers.
+
+```ruby
+[].difference #=> 0
+[].difference(nil) #=> nil
+[1,2,3].difference #=> -4
+```
+
+####Divisible:####
+`divisible` returns the division of a collection of numbers.
+
+```ruby
+[].divisible       #=> 0
+[].divisible(nil)  #=> nil
+[16,4,2].divisible #=> 2
+```
+
+####Drop Last:####
+`drop_last` drops the last number of elements of a collection.
+
+```ruby
+[].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.
+
+```ruby
+[].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.
+
+```ruby
+[].exactly?(1)                 #=> false
+[1,2,3].excatly?(3)            #=> true
+[1,1,3,3].exactly?(2, &:even?) #=> false
+```
+
+####Exclude:####
+`exclude?` returns true if the collection does not include the object. `Rails Safe`
+
+```ruby
+[1, 2, 3].exclude?(4) #=> true
+[1, 2, 3].exclude?(3) #=> false
+```
+
+####Exponential:####
+`exponential` returns the exponential of a collection of numbers.
+
+```ruby
+[].exponential      #=> 0
+[].exponential(nil) #=> nil
+[2,3,4].exponential #=> 4096
+```
+
+####Frequencies:####
+`frequencies` returns a hash of the number of times a value in an array appears.
+
+```ruby
+[].frequencies                                    #=> {}
+[1, :symbol, 'string', 3, :symbol, 1].frequencies #=> { 1 => 2, :symbol => 2, 'string' => 1, 3 => 1 }
+```
+
+####Many:####
+`many?` returns if collection has more than one element while respecting nil and false as an element. `Rails Safe`
+
+```ruby
+[].many?                 #=> false
+[1,2,3].many?            #=> true
+[1, false, nil].many?    #=> true
+[1,1,3,3].many?(&:even?) #=> false
+
+```
+
+####Max:####
+`max` returns the largest value of a collection of numbers.
+
+```ruby
+[].max      #=> 0
+[].max(nil) #=> nil
+[1,2,3].max #=> 3
+```
+
+####Min:####
+`min` returns the smallest value of a collection of numbers.
+
+```ruby
+[].min      #=> 0
+[].min(nil) #=> nil
+[1,2,3].min #=> 1
+```
+
+####Mean:####
+`mean` returns the average of a collection of numbers.
+
+```ruby
+[].mean      #=> 0
+[].mean(nil) #=> nil
+[1,2,3].mean #=> 2
+```
+
+####Median:####
+`median` returns the middle value of a collection of numbers.
+
+```ruby
+[].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.
+
+```ruby
+[].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.
+
+```ruby
+[].multiple      #=> 0
+[].multiple(nil) #=> nil
+[1,2,3].multiple #=> 6
+```
+
+####Range:####
+`range` returns the difference between the smallest and largest value of a collection of numbers.
+
+```ruby
+[].range      #=> 0
+[].range(nil) #=> nil
+[1,2,6].range #=> 5
+```
+
+####Several:####
+`several?` returns if collection has more than one element while not respecting nil and false as an element.
+
+```ruby
+[].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.
+
+```ruby
+[].standard_deviation      #=> 0
+[].standard_deviation(nil) #=> nil
+[1,2,6].standard_deviation #=> 2.6457513110645907
+```
+
+####Sum:####
+`sum` returns the sum of a collection of numbers. `Rails Safe`
+
+```ruby
+[].sum             #=> 0
+[].sum(nil)        #=> nil
+[1,2,3].sum        #=> 6
+["foo", "bar"].sum #=> "foobar"
+```
+
+####Take Last:####
+`take_last` returns the last number of elements of a collection.
+
+```ruby
+[].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.
+
+```ruby
+[].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.
+
+```ruby
+[].variance      #=> 0
+[].variance(nil) #=> nil
+[1,2,6].variance #=> 7
+```
+
+### Hash
+
+####Assert Valid Keys:####
+`assert_valid_keys` raises an error if key is not included in a list of keys. `Rails Safe`
+
+```ruby
+{}.assert_valid_keys(: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"
+```
+
+####Compact:####
+`compact` and `compact!` returns a hash with non nil values. `Rails Safe`
+
+```ruby
+{}.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. `Rails Safe`
+
+```ruby
+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] } }
+```
+
+####Except:####
+`except` and `except!` returns a hash that includes everything but the given keys. `Rails Safe`
+
+```ruby
+{}.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' }
+```
+
+####Nillify:####
+`nillify` and `nillify!` transforms all blank values to nil.
+
+```ruby
+{ 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. `Rails Safe`
+
+```ruby
+{}.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' }
+```
+
+####Rename Keys:####
+`rename_keys` and `rename_keys!` rename the keys of a hash.
+
+```ruby
+{ 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. `Rails Safe`
+
+```ruby
+{}.reverse_merge!(foo: "bar")                         #=> { foo: "bar" }
+{ foo: "bar" }.reverse_merge!(baz: "boo", boo: "bam") #=> { foo: "bar", baz: "boo", boo: "bam" }
+```
+
+####Slice:####
+`slice` a hash to include only the given keys. Returns a hash containing the given keys. `Rails Safe`
+`slice!` replaces the hash with only the given keys. Returns a hash containing the removed key/value pairs. `Rails Safe`
+
+```ruby
+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. `Rails Safe`
+
+```ruby
+{ foo: "foo", "bar" => 'bar' }.stringify_keys #=> { "foo" => "foo", "baz" => "baz" }
+```
+
+####Strip:####
+`strip` and `strip!` returns a hash with non nil, false, or blank values.
+
+```ruby
+{}.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. `Rails Safe`
+
+```ruby
+{ 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.
+
+```ruby
+{ "firstName" => "foo", "last Name" => "test" }.symbolize_and_underscore_keys #=> { first_name: "foo", last_name: "test" }
+```
+
+####Transform Keys:####
+`transform_keys` and `transform_keys!` a new hash with all keys converted using the block operation. `Rails Safe`
+
+```ruby
+{ foo: "bar", baz: "boo" }.transform_keys { |k| k.to_s.upcase } #=> { "FOO" => "bar", "BAZ" => "boo" }
+```
+
+####Transform Values:####
+`transform_values` and `transform_values!` a new hash with all values converted using the block operation. `Rails Safe`
+
+```ruby
+{ foo: "bar", baz: "boo" }.transform_values { |v| v.to_s.upcase } #=> {foo: "BAR", baz: "BOO" }
+```
+
+### Integer
+
+####Time:####
+`time` returns a Time object for the given Integer.
+
+```ruby
+3.time #=> "1969-12-31 19:00:03.000000000 -0500"
+```
+
+### Numeric
+
+####Add:####
+`add` returns the sum of two numbers.
+
+```ruby
+4.add(2) #=> 6
+```
+
+####Bytes:####
+`byte` and `bytes` returns self.
+
+```ruby
+3.bytes #=> 3
+```
+
+####Centigrams:####
+`centigram` and `centigrams` returns the amount of grams in n centigrams.
+
+```ruby
+3.centigrams #=> 0.03
+```
+
+####Centimeters:####
+`centimeter` and `centimeters` returns the amount of meters in n centimeters.
+
+```ruby
+3.centimeters #=> 0.03
+```
+
+####Centuries:####
+`century` and `centuries` returns the amount of seconds in n centuries.
+
+```ruby
+3.centuries #=> 9467280000.0
+```
+
+####Decades:####
+`decade` and `decades` returns the amount of seconds in n decades.
+
+```ruby
+3.decades #=> 946728000.0
+```
+####Decagrams:####
+`decagram` and `decagrams` returns the amount of grams in n decagrams.
+
+```ruby
+3.decagrams #=> 30
+```
+
+####Decameters:####
+`decameter` and `decameters` returns the amount of meters in n decameters.
+
+```ruby
+3.decameters #=> 30
+```
+
+####Decigrams:####
+`decigram` and `decigrams` returns the amount of grams in n decigrams.
+
+```ruby
+3.decigrams #=> 0.3
+```
+
+####Decimeters:####
+`decimeter` and `decimeters` returns the amount of meters in n decimeters.
+
+```ruby
+3.decimeters #=> 0.3
+```
+
+####Days:####
+`day` and `days` returns the amount of seconds in n days.
+
+```ruby
+3.days #=> 259200
+```
+
+####Divide:####
+`divide` returns the division of two numbers.
+
+```ruby
+4.divide(2) #=> 2
+```
+
+####Exabytes:####
+`exabyte` and `exabytes` returns the amount of bytes in n exabytes.
+
+```ruby
+3.exabytes #=> 3458764513820540928
+```
+
+####Feet:####
+`foot` and `feet` returns the amount of inches in n feet.
+
+```ruby
+3.feet #=> 36
+```
+
+####Gigabytes:####
+`gigabyte` and `gigabytes` returns the amount of bytes in n gigabytes.
+
+```ruby
+3.gigabytes #=> 3221225472
+```
+
+####Grams:####
+`gram` and `grams` returns self.
+
+```ruby
+3.grams #=> 3
+```
+
+####Hectograms:####
+`hectogram` and `hectograms` returns the amount of grams in n hectograms.
+
+```ruby
+3.hectograms #=> 300
+```
+
+####Hectometers:####
+`hectometer` and `hectometers` returns the amount of meters in n hectometers.
+
+```ruby
+3.hectometers #=> 300
+```
+
+####Hours:####
+`hour` and `hours` returns the amount of seconds in n hours.
+
+```ruby
+3.hours #=> 10800
+```
+
+####Inches:####
+`inch` and `inches` returns the amount of inches in n inches.
+
+```ruby
+3.inches #=> 3
+```
+
+####Kilobytes:####
+`kilobyte` and `kilobytes` returns the amount of bytes in n kilobytes.
+
+```ruby
+3.kilobytes #=> 3072
+```
+
+####Kilograms:####
+`kilogram` and `kilograms` returns the amount of grams in n kilograms.
+
+```ruby
+3.kilograms #=> 3000
+```
+
+####Kilometers:####
+`kilometer` and `kilometers` returns the amount of meters in n kilometers.
+
+```ruby
+3.kilometers #=> 3000
+```
+
+####Metric Ton:####
+`metric_ton` and `metric_tons` returns the amount of grams in n metric_tons.
+
+```ruby
+3.metric_tons #=> 3000000
+```
+
+####Megabytes:####
+`megabyte` and `megabytes` returns the amount of bytes in n megabytes.
+
+```ruby
+3.megabytes #=> 3145728
+```
+
+####Meters:####
+`meter` and `meters` returns self.
+
+```ruby
+3.meters #=> 3
+```
+
+####Miles:####
+`mile` and `miles` returns the amount of inches in n miles.
+
+```ruby
+3.miles #=> 190080
+```
+
+####Millennium:####
+`millennium` and `millenniums` returns the amount of seconds in n millenniums.
+
+```ruby
+3.millenniums #=> 94672800000.0
+```
+
+####Milligram:####
+`milligram` and `milligrams` returns the amount of grams in n milligrams.
+
+```ruby
+3.milligrams #=> 0.003
+```
+
+####Millimeters:####
+`millimeter` and `millimeters` returns the amount of meters in n millimeters.
+
+```ruby
+3.millimeters #=> 0.003
+```
+
+####Minutes:####
+`minute` and `minutes` returns the amount of seconds in n minutes.
+
+```ruby
+3.minutes #=> 180
+```
+
+####Multiply:####
+`multiply` returns the multiplication of two numbers.
+
+```ruby
+4.multiply(2) #=> 8
+```
+
+####Multiple Of:####
+`multiple_of?` returns true if a number can be evenly divided by n. `Rails Safe`
+
+```ruby
+9.multiple_of?(3) #=> true
+7.multiple_of?(3) #=> false
+```
+
+####Nautical Miles:####
+`nautical_mile` and `nautical_miles` returns the amount of inches in n nautical miles.
+
+```ruby
+3.nautical_miles #=> 218740.26239999998
+```
+
+####Negative:####
+`negative?` returns true if a number is less than zero.
+
+```ruby
+-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. `Rails Safe`
+
+```ruby
+"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. `Rails Safe`
+
+```ruby
+"1".ordinalize  #=> "1th"
+"2".ordinalize  #=> "2nd"
+"3".ordinalize  #=> "3rd"
+"11".ordinalize #=> "4th"
+```
+
+####Ounces:####
+`ounce` and `ounces` returns self.
+
+```ruby
+3.ounces #=> 48
+```
+
+####Pad:####
+`pad` returns a string reprensentation of the number padded with pad_num to a specified length.
+
+```ruby
+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: "..."
+
+```ruby
+3.pad_precision                #=> "3.00"
+3.5.pad_precision              #=> "3.50"
+3.pad_precision(pad_number: 1) #=> "3.11"
+```
+
+####Petabytes:####
+`petabyte` and `pegabytes` returns the amount of bytes in n petabytes.
+
+```ruby
+3.petabytes #=> 3377699720527872
+```
+
+####Positive:####
+`positive?` returns true if a number is greater than zero.
+
+```ruby
+1.positive? #=> true
+-1.positive? #=> false
+```
+
+####Pounds:####
+`pounds` and `pounds` returns the amount of ounces in n pounds.
+
+```ruby
+3.pounds #=> 48
+```
+
+####Power:####
+`power` returns the nth power of a number.
+
+```ruby
+4.power(2) #=> 16
+```
+
+####Root:####
+`root` returns the nth root of a number.
+
+```ruby
+4.root(2) #=> 2
+```
+
+####Seconds:####
+`second` and `seconds` returns self.
+
+```ruby
+3.seconds #=> 3
+```
+
+####Stones:####
+`stone` and `stone` returns the amount of ounces in n stones.
+
+```ruby
+3.stones #=> 672
+```
+
+####Subtract:####
+`subtract` returns the difference of two numbers.
+
+```ruby
+4.subtract(2) #=> 2
+```
+
+####Terabytes:####
+`terabyte` and `terabytes` returns the amount of bytes in n terabytes.
+
+```ruby
+3.terabytes #=> 3298534883328
+```
+
+####To Byte:####
+`to_byte` converts a byte size from one unit to another unit.
+
+```ruby
+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 Length:####
+`to_length` converts a length from one unit to another unit.
+
+```ruby
+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.
+
+```ruby
+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.
+
+```ruby
+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 Temperature:####
+`to_temperature` converts a temperature from one unit to another unit.
+
+```ruby
+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.
+
+```ruby
+120.to_time(:seconds, :mintues) #=> 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:####
+`ton` and `ton` returns the amount of ounces in n tons.
+
+```ruby
+3.tons #=> 96000
+```
+
+####Weeks:####
+`week` and `weeks` returns the amount of seconds in n weeks.
+
+```ruby
+3.weeks #=> 1814400
+```
+
+####Yards:####
+`yard` and `yards` returns the amount of inches in n yards.
+
+```ruby
+3.yards #=> 108
+```
+
+####Years:####
+`year` and `years` returns the amount of seconds in n years.
+
+```ruby
+3.years #=> 94672800.0
+```
+
+### Object
+
+####Blank:####
+`blank?` determines if an object is empty or nil. `Rails Safe`
+
+```ruby
+"".blank?              #=> true
+"Awesome Sting".blank? #=> false
+```
+
+####Numeric:####
+`numeric?` determines if an object's string value is numeric.
+
+```ruby
+"-32.50".numeric? #=> true
+"$2.55".numeric?  #=> false
+```
+
+####Palindrome:####
+`palindrome?` determines if an object is equal when reversed.
+
+```ruby
+"racecar".palindrome? #=> true
+12321.palindrome?     #=> true
+"example".palindrome? #=> false
+12345.palindrome?     #=> false
+```
+
+####Present:####
+`present?` determines if an object is not empty or nil. `Rails Safe`
+
+```ruby
+"Awesome Sting".blank? #=> true
+"".present?            #=> false
+```
+
+####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. `Rails Safe`
+
+```ruby
+"example".try(:upcase)      #=> "EXAMPLE"
+"example".try(:fake_method) #=> nil
+```
+
+### String
+
+####At:####
+`at` returns the characters at index position, matching string, or regex. `Rails Safe`
+
+```ruby
+"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!` transfroms a string to camelcase. `Rails Safe`
+
+```ruby
+"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. `Rails Safe`
+
+```ruby
+"example_string".classify      #=> "ExampleString"
+"example_string/test".classify #=> "ExampleString::Test"
+"example_string.test".classify #=> "Test"
+```
+
+####Dasherize:####
+`dasherize` and `dasherize!` replaces underscores with dashes in the string. `Rails Safe`
+
+```ruby
+"example_string".dasherize #=> "example-string"
+```
+
+####Demodulize:####
+`demodulize` and `demodulize!` removes the module part from the expression in the string. `Rails Safe`
+
+```ruby
+"Example::String".demodulize #=> "String"
+"String".demodulize          #=> "String"
+```
+
+####Domain:####
+`domain` extracts the domain name from a URL.
+
+```ruby
+"http://www.example.com/fake-page".domain #=> "www.example.com"
+"example string".domain                   #=> "example string"
+```
+
+####Downcase:####
+`downcase?` returns true if all characters are lowercase.
+
+```ruby
+"example".downcase? #=> true
+"Example".downcase? #=> false
+"EXAMPLE".downcase? #=> false
+```
+
+####Ellipsize:####
+`ellipsize` truncate a string in the middle.
+
+**Options**
+ *  offset: 4
+ *  separator: "..."
+
+```ruby
+"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. `Rails Safe`
+
+```ruby
+"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. `Rails Safe`
+
+```ruby
+"example".first    #=> "e"
+"example".first(0) #=> ""
+"example".first(3) #=> "exa"
+```
+
+####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. `Rails Safe`
+
+```ruby
+"example".from(0) #=> "example"
+"example".from(3) #=> "mple"
+```
+
+####Humanize:####
+`humanize` and `humanize!` transforms a string to a human readable string. `Rails Safe`
+
+**Options**
+ *  capitalize: true
+
+```ruby
+"ExampleString".humanize                     #=> "Example string"
+"example_string".humanize                    #=> "Example string"
+"example_string".humanize(capitalize: false) #=> "example string"
+```
+
+####Indent:####
+`indent` and `indent!` indents the lines in the receiver. `Rails Safe`
+
+```ruby
+"example".indent(2)       #=> "  example"
+"example".indent(2, "\t") #=> "\t\texample"
+```
+
+####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. `Rails Safe`
+
+```ruby
+"example".last     #=> "e"
+"example".last(0)  #=> ""
+"example".first(3) #=> "ple"
+```
+
+####Mixcase:####
+`mixcase?` returns true if characters are mixedcase.
+
+```ruby
+"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. `Rails Safe`
+
+```ruby
+"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. `Rails Safe`
+
+```ruby
+"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. `Rails Safe`
+
+```ruby
+"example_string".parameterize      #=> "example-string"
+"example_string".parameterize("?") #=> "example?string"
+```
+
+####Pollute:####
+`pollute` pollutes the space between every letter in a string, so it will be exempt from any impending string searches.
+
+```ruby
+"test".pollute      #=> "t^--^--^e^--^--^s^--^--^t^--^--^"
+"test".pollute("-") #=> "t-e-s-t-"
+```
+
+####Remove:####
+`remove` and `remove!` removes every instance of a string.
+
+```ruby
+"this thing that thing".remove("thing")        #=> "this  that "
+"this thing that them".remove("thing", "them") #=> "this  that "
+```
+
+####Remove Tags:####
+`remove_tags` and `remove_tags!` removes HTML tags from a string.
+
+```ruby
+"example".strip_tags                                   #=> "example"
+"<a href='http://example.com'>click</a>".strip_tags    #=> "click"
+"this is <b>bold</b> and <em>emphatic</em>".strip_tags #=> "this is bold and emphatic"
+```
+
+####Shift:####
+`shift` and `shift!` removes the first instance of a string.
+
+```ruby
+"this thing that thing".remove("thing")        #=> "this  that thing"
+"this thing that thing".remove("this", "that") #=> " thing  thing"
+```
+
+####Slugify:####
+`slugify` and `slugify!` generates a permalink-style string, with odd characters removed.
+
+```ruby
+"example".slugify                  #=> "example"
+"example string".slugify           #=> "example-string"
+"Example string @@@ test!".slugify #=> "example-string-test"
+```
+
+####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. `Rails Safe`
+
+```ruby
+"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. `Rails Safe`
+
+```ruby
+"example string".titleize #=> "Example String"
+"example_string".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. `Rails Safe`
+
+```ruby
+"example".to(0)  #=> "example"
+"example".to(3)  #=> "exam"
+"example".to(-2) #=> "exampl"
+```
+
+####Truncate:####
+`truncate` a given text after a given length if text is longer than length. `Rails Safe`
+
+**Options**
+ *  omission: "..."
+ *  separator: " "
+
+```ruby
+"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. `Rails Safe`
+
+**Options**
+ *  omission: "..."
+ *  separator: " "
+
+```ruby
+"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. `Rails Safe`
+
+```ruby
+"ExampleString".underscore       #=> "example_string"
+"exampleString".underscore       #=> "example_string"
+"ExampleString::Test".underscore #=> "example_string/test"
+```
+
+####Unpollute:####
+`unpollute` removes the default or custom pollution character. Can also be used to remove an unwanted character.
+
+```ruby
+"t^--^--^e^--^--^s^--^--^t^--^--^".unpollute #=> "test"
+"t-e-s-t-".unpollute                         #=> "test"
+```
+
+####Upcase:####
+`upcase?` returns true if all characters are uppercase.
+
+```ruby
+"EXAMPLE".upcase? #=> true
+"example".upcase? #=> false
+"Example".upcase? #=> false
+```
+
+### Time
+
+####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
+
+```ruby
+Time.now.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_zero` | %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_zero` | %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 - starting monday | `wwwww` or `week` | %M | (00..53) |
+| Week - starting sunday | `wwwwww` or `weekday_offset` | %M | (00..53) |
+| Weekday - starting monday | `w` or `weekday` | %M | (1..7) |
+| Weekday - starting sunday | `ww` or `weekday` | %M | (0..6) |
+| Weekday - name | `www` or `weekday_name` | %M | Sunday |
+| Weekday - name abbreviated | `wwww` or `weekday_name_abbr` | %M | 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_zero` | %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_zero` | %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 |
+
+####To Format:####
+`to_format` converts a Date or Time object to a predefined format.
+
+**For a full list check out the time extention file.**
+
+```ruby
+Time.now.to_format(:year)     #=> "2014"
+Time.now.to_format(:datetime) #=> "January 09, 2014 02:31 pm"
+```
+
+| Name | Key | Equivalent `strftime` | Result |
+| --- | --- | --- | --- |
+| Month - digits zero-padded | `:month` or `:month_zero` | %A | (01..12) |
+| Month - digits unpadded | `:month_unpadded` | %a | (1..12) |
+| Month - digits blank-padded | `:month_blank` | %a | ( 1..12) |
+| Month - name | `:month_name` | %A | January |
+| Month - name abbreviated | `:month_name_abbr` | %a | Jan |
+| Weekday - digits zero-padded | `:weekday_zero` | %A | (01..31) |
+| Weekday - digits unpadded | `:weekday_unpadded` | %a | (1..31) |
+| Weekday - digits blank-padded | `:weekday_blank` | %a | ( 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 |
+| Hour - digits zero-padded | `:hour` or `:hour_zero` | %H | (00..23) |
+| Hour - digits blank-padded | `:hour_blank` | %k | ( 0..23) |
+| Hour - digits zero-padded imperical | `:hour_imperical_zero` | %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 |
+| 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_zero` | %H:%M | 00:31 |
+| Time - blank-padded | `:time_blank` | %k:%M %z | 0: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
+
+1. Fork it ( http://github.com/<my-github-username>/active_object/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request