active_object 2.5.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c942e7c9f4e256ef473d9d863b922fea1e9a82b
-  data.tar.gz: a12aec596189223192933d250f08a1dc37da5923
+  metadata.gz: 489fe05da332fe9dafa7760f80a0b37c26e17319
+  data.tar.gz: ed2487b328b96c6445b9145513216efbe57d6fdb
 SHA512:
-  metadata.gz: 63e2b4785300b6fe06f1d6fb74b4f3596de62e23ca93159c82213e4189e4d9242108036013a6bda7f1d9b763939bd3a5ea33defbe3a955a087fc2d9a7844d655
-  data.tar.gz: 6002927f1bcbad6f64cab9ec696b7b5df5e413484d01e5111cccd7fe5f273b94c2ba07a03d9ac2e6c69c1c8a002ffc31d62307161cc145e329267bda7b80ade5
+  metadata.gz: 83a3c429d839edc2c86fd50e76c95b77e4b7aa78834626a68addffced3f297909a0804678e5eb7556d259025a11fdb6aee8a674d701a8b4fbf584c71dcddb83a
+  data.tar.gz: 0f4d65fd9dcdf9c957d2495c372b665c3a28029e02725bcf45b033f07fc0412401d0d06323c3a305339d4abbd213ed45107caa488264f134c024b0756e807fb8

data/Gemfile

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

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Juan Gomez
+Copyright (c) 2016 Drexed
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ 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.
+THE SOFTWARE.

data/README.md

@@ -2,12 +2,10 @@
 
 [![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)
+[![Coverage Status](https://coveralls.io/repos/github/drexed/active_object/badge.svg?branch=master)](https://coveralls.io/github/drexed/active_object?branch=master)
 
 ActiveObject is a collection of commonly used object helpers in a ruby based project.
 
-`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
@@ -31,6 +29,7 @@ Or install it yourself as:
 
 ## Table of Contents
 
+* [Configuration](#configuration)
 * [Array](#array)
 * [Enumerable](#enumerable)
 * [Hash](#hash)
@@ -41,6 +40,29 @@ Or install it yourself as:
 * [String](#string)
 * [Time](#time)
 
+## Configuration
+
+`rails g active_object:install` will generate the following `active_object.rb` file:
+
+```ruby
+# config/initalizers/active_object.rb
+
+ActiveObject.configure do |config|
+  # option = default
+
+  config.autoload_array = true
+  config.autoload_date = true
+  config.autoload_enumerable = true
+  config.autoload_hash = true
+  config.autoload_integer = true
+  config.autoload_numeric = true
+  config.autoload_object = true
+  config.autoload_range = true
+  config.autoload_string = true
+  config.autoload_time = true
+end
+```
+
 ## Array
 
 ####After:####
@@ -82,6 +104,13 @@ Or install it yourself as:
 [1, 2, 3, 4].delete_values(1, 3) #=> [2, 4]
 ```
 
+####Dig:####
+`dig` returns the value of a nested array.
+
+```ruby
+["zero", ["ten", "eleven", "twelve"], "two"].dig(1, 2) #=> "twelve"
+```
+
 ####Duplicates:####
 `duplicates` returns list of duplicate elements.
 
@@ -91,7 +120,7 @@ Or install it yourself as:
 ```
 
 ####From:####
-`from` returns the tail of the array from position. `Rails Safe`
+`from` returns the tail of the array from position.
 
 ```ruby
 ["1", "2", "3"].from(0) #=> ["1", "2", "3"]
@@ -107,7 +136,7 @@ Or install it yourself as:
 ```
 
 ####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`
+`in_groups` splits or iterates over the array in number of groups, padding any remaining slots with fill_with unless it is false.
 
 ```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]]
@@ -116,7 +145,7 @@ Or install it yourself as:
 ```
 
 ####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`
+`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.
 
 ```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]]
@@ -124,6 +153,15 @@ Or install it yourself as:
 %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"]]
 ```
 
+####Percentile:####
+`percentile` returns the percentile value for a given percentage.
+
+```ruby
+[1, 2, 3, 4].percentile(49)    # => 2
+[1, 2, 3, 4].percentile(50)    # => 3
+[1, 2, 3, 4, 5].percentile(50) # => 3
+```
+
 ####Probablity:####
 `probability` generates a hash mapping each unique element in the array to the relative frequency, i.e. the probablity, of it appearence.
 
@@ -146,7 +184,7 @@ Or install it yourself as:
 ```
 
 ####Split:####
-`split` divides the array into one or more subarrays based on a delimiting value or the result of an optional block. `Rails Safe`
+`split` divides the array into one or more subarrays based on a delimiting value or the result of an optional block.
 
 ```ruby
 [1, 2, 3, 4, 5].split(3)              # => [[1, 2], [4, 5]]
@@ -162,7 +200,7 @@ Or install it yourself as:
 ```
 
 ####To:####
-`to` returns the beginning of the array up to position. `Rails Safe`
+`to` returns the beginning of the array up to position.
 
 ```ruby
 ["1", "2", "3"].to(0) #=> ["1"]
@@ -171,7 +209,7 @@ Or install it yourself as:
 ```
 
 ####To Sentence:####
-`to_sentence` converts the array to a comma-separated sentence where the last element is joined by the connector word. `Rails Safe`
+`to_sentence` converts the array to a comma-separated sentence where the last element is joined by the connector word.
 
 **Options:**
  * words_connector:     “, ”
@@ -242,7 +280,7 @@ Or install it yourself as:
 ```
 
 ####Exclude:####
-`exclude?` returns true if the collection does not include the object. `Rails Safe`
+`exclude?` returns true if the collection does not include the object.
 
 ```ruby
 [1, 2, 3].exclude?(4) #=> true
@@ -282,7 +320,7 @@ Or install it yourself as:
 ```
 
 ####Many:####
-`many?` returns if collection has more than one element while respecting nil and false as an element. `Rails Safe`
+`many?` returns if collection has more than one element while respecting nil and false as an element.
 
 ```ruby
 [].many?                 #=> false
@@ -311,7 +349,7 @@ Or install it yourself as:
 ```
 
 ####Mean:####
-`mean` returns the average of a collection of numbers.
+`mean` and `average` returns the average of a collection of numbers.
 
 ```ruby
 [].mean      #=> 0
@@ -377,7 +415,7 @@ Or install it yourself as:
 ```
 
 ####Sum:####
-`sum` returns the sum of a collection of numbers. `Rails Safe`
+`sum` returns the sum of a collection of numbers.
 
 ```ruby
 [].sum             #=> 0
@@ -416,7 +454,7 @@ Or install it yourself as:
 ## Hash
 
 ####Assert Valid Keys:####
-`assert_valid_keys` raises an error if key is not included in a list of keys. `Rails Safe`
+`assert_valid_keys` raises an error if key is not included in a list of keys.
 
 ```ruby
 {}.assert_valid_keys(:foo)                               #=> {}
@@ -425,7 +463,7 @@ Or install it yourself as:
 ```
 
 ####Compact:####
-`compact` and `compact!` returns a hash with non nil values. `Rails Safe`
+`compact` and `compact!` returns a hash with non nil values.
 
 ```ruby
 {}.compact                                   #=> {}
@@ -434,7 +472,7 @@ Or install it yourself as:
 ```
 
 ####Deep Merge:####
-`deep_merge` and `deep_merge!` returns a new hash with self and other_hash merged recursively. `Rails Safe`
+`deep_merge` and `deep_merge!` returns a new hash with self and other_hash merged recursively.
 
 ```ruby
 h1 = { a: true, b: { c: [1, 2, 3] } }
@@ -443,6 +481,16 @@ h2 = { a: false, b: { x: [3, 4, 5] } }
 h1.deep_merge(h2) #=> { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
 ```
 
+####Dig:####
+`dig` returns the value of a nested hash.
+
+```ruby
+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.
 
@@ -484,7 +532,7 @@ h1.deep_merge(h2) #=> { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
 ```
 
 ####Reverse Merge:####
-`reverse_merge` and `reverse_merge!` merges one hash into other hash. `Rails Safe`
+`reverse_merge` and `reverse_merge!` merges one hash into other hash.
 
 ```ruby
 {}.reverse_merge!(foo: "bar")                         #=> { foo: "bar" }
@@ -536,8 +584,8 @@ h.shuffle! #=> { d: 4, b: 2, c: 3, a: 1 }
 ```
 
 ####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`
+`slice` 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.
 
 ```ruby
 h = { a: 1, b: 2, c: 3, d: 4 }
@@ -547,7 +595,7 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 ```
 
 ####Stringify Keys:####
-`stringify_keys` and `stringify_keys!` converts the hash keys to strings. `Rails Safe`
+`stringify_keys` and `stringify_keys!` converts the hash keys to strings.
 
 ```ruby
 { foo: "foo", "bar" => 'bar' }.stringify_keys #=> { "foo" => "foo", "baz" => "baz" }
@@ -563,7 +611,7 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 ```
 
 ####Symbolize Keys:####
-`symbolize_keys` and `symbolize_keys!` converts the hash keys to symbols. `Rails Safe`
+`symbolize_keys` and `symbolize_keys!` converts the hash keys to symbols.
 
 ```ruby
 { foo: "foo", "bar" => "bar" }.symbolize_keys #=> { foo: "foo", baz: "baz" }
@@ -577,14 +625,14 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 ```
 
 ####Transform Keys:####
-`transform_keys` and `transform_keys!` a new hash with all keys converted using the block operation. `Rails Safe`
+`transform_keys` and `transform_keys!` a new hash with all keys converted using the block operation.
 
 ```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`
+`transform_values` and `transform_values!` a new hash with all values converted using the block operation.
 
 ```ruby
 { foo: "bar", baz: "boo" }.transform_values { |v| v.to_s.upcase } #=> {foo: "BAR", baz: "BOO" }
@@ -657,6 +705,15 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 3.centuries_in_seconds #=> 9467280000.0
 ```
 
+####Clamp:####
+`clamp` returns a comparable between a lower and upper bound.
+
+```ruby
+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.
 
@@ -698,6 +755,13 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 3.decimeters_in_meters #=> 0.3
 ```
 
+####degrees_to_radians:####
+`degrees_to_radians` returns number of degrees into radians.
+
+```ruby
+90.degrees_to_radians #=> 1.5707963267948966
+```
+
 ####Distance:####
 `distance` returns the absolute difference between numbers.
 
@@ -898,7 +962,7 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 ```
 
 ####Multiple Of:####
-`multiple_of?` returns true if a number can be evenly divided by n. `Rails Safe`
+`multiple_of?` returns true if a number can be evenly divided by n.
 
 ```ruby
 9.multiple_of?(3) #=> true
@@ -921,7 +985,7 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 ```
 
 ####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`
+`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.
 
 ```ruby
 "1".ordinal  #=> "th"
@@ -931,7 +995,7 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 ```
 
 ####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`
+`ordinalize` transforms a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
 
 ```ruby
 "1".ordinalize  #=> "1th"
@@ -1175,7 +1239,7 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 ```
 
 ####Blank:####
-`blank?` determines if an object is empty or nil. `Rails Safe`
+`blank?` determines if an object is empty or nil.
 
 ```ruby
 "".blank?              #=> true
@@ -1260,7 +1324,7 @@ true.falsey?  #=> false
 ```
 
 ####Present:####
-`present?` determines if an object is not empty or nil. `Rails Safe`
+`present?` determines if an object is not empty or nil.
 
 ```ruby
 "Awesome Sting".present? #=> true
@@ -1318,7 +1382,7 @@ false.truthy? #=> 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`
+`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.
 
 ```ruby
 "example".try(:upcase)      #=> "EXAMPLE"
@@ -1335,7 +1399,7 @@ false.truthy? #=> false
 ```
 
 ####Include With Range:####
-`include_with_range?` determines if a range includes another range. `Rails Safe`
+`include_with_range?` determines if a range includes another range.
 
 ```ruby
 (1..5).include?(1..5) # => true
@@ -1344,7 +1408,7 @@ false.truthy? #=> false
 ```
 
 ####Overlaps:####
-`overlaps?` determines if two ranges overlap each other. `Rails Safe`
+`overlaps?` determines if two ranges overlap each other.
 
 ```ruby
 (1..5).overlaps?(4..6) # => true
@@ -1386,7 +1450,7 @@ false.truthy? #=> false
 ```
 
 ####At:####
-`at` returns the characters at index position, matching string, or regex. `Rails Safe`
+`at` returns the characters at index position, matching string, or regex.
 
 ```ruby
 "example_string".at(0)     #=> "e"
@@ -1398,7 +1462,7 @@ false.truthy? #=> false
 ```
 
 ####Camelize:####
-`camelize` and `camelize!` transfroms a string to camelcase. `Rails Safe`
+`camelize` and `camelize!` transfroms a string to camelcase.
 
 ```ruby
 "example_string".camelize         #=> "ExampleString"
@@ -1408,7 +1472,7 @@ false.truthy? #=> false
 ```
 
 ####Classify:####
-`classify` and `classify!` creates a class name from a string like Rails does for table names to models. `Rails Safe`
+`classify` and `classify!` creates a class name from a string like Rails does for table names to models.
 
 ```ruby
 "example_string".classify      #=> "ExampleString"
@@ -1417,21 +1481,21 @@ false.truthy? #=> false
 ```
 
 ####Constantize:####
-`constantize` converts a string in an object. `Rails Safe`
+`constantize` converts a string in an object.
 
 ```ruby
 "Example::String".constantize #=> Class Object
 ```
 
 ####Dasherize:####
-`dasherize` and `dasherize!` replaces underscores with dashes in the string. `Rails Safe`
+`dasherize` and `dasherize!` replaces underscores with dashes in the string.
 
 ```ruby
 "example_string".dasherize #=> "example-string"
 ```
 
 ####Deconstantize:####
-`deconstantize` and `deconstantize!` removes the rightmost segment from the constant expression in the string. `Rails Safe`
+`deconstantize` and `deconstantize!` removes the rightmost segment from the constant expression in the string.
 
 ```ruby
 "Example::String".deconstantize   # => "Example"
@@ -1442,7 +1506,7 @@ false.truthy? #=> false
 ```
 
 ####Demodulize:####
-`demodulize` and `demodulize!` removes the module part from the expression in the string. `Rails Safe`
+`demodulize` and `demodulize!` removes the module part from the expression in the string.
 
 ```ruby
 "Example::String".demodulize #=> "String"
@@ -1481,7 +1545,7 @@ false.truthy? #=> false
 ```
 
 ####Exclude:####
-`exclude?` returns true if the string does not include the other string. `Rails Safe`
+`exclude?` returns true if the string does not include the other string.
 
 ```ruby
 "example_string".exclude?("exa") #=> false
@@ -1489,7 +1553,7 @@ false.truthy? #=> false
 ```
 
 ####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`
+`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.
 
 ```ruby
 "example".first    #=> "e"
@@ -1497,8 +1561,17 @@ false.truthy? #=> false
 "example".first(3) #=> "exa"
 ```
 
+####Format:####
+`format` returns an interpolated string that allows for options.
+
+```ruby
+"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. `Rails Safe`
+`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.
 
 ```ruby
 "example".from(0) #=> "example"
@@ -1506,7 +1579,7 @@ false.truthy? #=> false
 ```
 
 ####Humanize:####
-`humanize` and `humanize!` transforms a string to a human readable string. `Rails Safe`
+`humanize` and `humanize!` transforms a string to a human readable string.
 
 **Options**
  *  capitalize: true
@@ -1518,7 +1591,7 @@ false.truthy? #=> false
 ```
 
 ####Indent:####
-`indent` and `indent!` indents the lines in the receiver. `Rails Safe`
+`indent` and `indent!` indents the lines in the receiver.
 
 ```ruby
 "example".indent(2)       #=> "  example"
@@ -1544,7 +1617,7 @@ false.truthy? #=> false
 ```
 
 ####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`
+`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.
 
 ```ruby
 "example".last     #=> "e"
@@ -1562,7 +1635,7 @@ false.truthy? #=> 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`
+`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.
 
 ```ruby
 "1".ordinal  #=> "th"
@@ -1572,7 +1645,7 @@ false.truthy? #=> false
 ```
 
 ####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`
+`ordinalize` transforms a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
 
 ```ruby
 "1".ordinalize  #=> "1th"
@@ -1582,7 +1655,7 @@ false.truthy? #=> false
 ```
 
 ####Parameterize:####
-`parameterize` and `parameterize!` makes string suitable for a dashed url parameter string. `Rails Safe`
+`parameterize` and `parameterize!` makes string suitable for a dashed url parameter string.
 
 ```ruby
 "example_string".parameterize      #=> "example-string"
@@ -1681,7 +1754,7 @@ false.truthy? #=> false
 ```
 
 ####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`
+`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.
 
 ```ruby
 "example    string".squish        #=> "example string"
@@ -1690,7 +1763,7 @@ false.truthy? #=> false
 ```
 
 ####Titleize:####
-`titleize` and `titleize!` capitalizes each word in a string. `Rails Safe`
+`titleize` and `titleize!` capitalizes each word in a string.
 
 ```ruby
 "example string".titleize     #=> "Example String"
@@ -1699,7 +1772,7 @@ false.truthy? #=> false
 ```
 
 ####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`
+`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.
 
 ```ruby
 "example".to(0)  #=> "example"
@@ -1708,7 +1781,7 @@ false.truthy? #=> false
 ```
 
 ####Truncate:####
-`truncate` a given text after a given length if text is longer than length. `Rails Safe`
+`truncate` a given text after a given length if text is longer than length.
 
 **Options**
  *  omission: "..."
@@ -1723,7 +1796,7 @@ false.truthy? #=> false
 ```
 
 ####Truncate Words:####
-`truncate_words` truncates a given text after a given number of words. `Rails Safe`
+`truncate_words` truncates a given text after a given number of words.
 
 **Options**
  *  omission: "..."
@@ -1736,7 +1809,7 @@ false.truthy? #=> false
 ```
 
 ####Underscore:####
-`underscore` and `underscore!` transforms a string to snakecase. `Rails Safe`
+`underscore` and `underscore!` transforms a string to snakecase.
 
 ```ruby
 "ExampleString".underscore       #=> "example_string"
@@ -1887,7 +1960,7 @@ Time.now.stamp(:datetime) #=> "January 09, 2014 02:31 pm"
 
 ## Contributing
 
-1. Fork it ( http://github.com/<my-github-username>/active_object/fork )
+1. Fork it ( http://github.com/drexed/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`)