active_object 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b908cec473063ce9371f42ad24f3e2160449288d
-  data.tar.gz: 372517125c14abffe2e4608b087197b7720ae913
+  metadata.gz: 0063e4f4ebe0c179ce2e900b5521e88b210d4263
+  data.tar.gz: 795f415b25307d864f9fe0655028375d3f2a03bc
 SHA512:
-  metadata.gz: 58811199b70a9c498ebb85894461c9ce61b1ff2b414018a3373459908ff5d061d7cd465d9f0825d7b91a8028d361cb1673b85f307e5f44db749e97e32e77708d
-  data.tar.gz: a335da3d616ac49e2fb1da3655db8fa436287fd6ad470b9a916c1618b41867b510322f6174cdb2e83f0e32d5f3198add747e95c18c78dbc8ae03714c2e35fe62
+  metadata.gz: 471c7234bd99b4bb7d860391a2a04faa796dc10d2d5823d9099dc9dd5ec53a5a20a17024cf237cb18f0208d1bde7a941a9a14c452df436715bcbc0a4054b52c4
+  data.tar.gz: 0c80a0a97edb2e6d5e97edd82d0f5fb43727656628f364ea1652b178b2afcdf76eddc2b63bc2f613deb87f99bf548dab0c1d59641f9360a3243180380cc75004

data/README.md

@@ -13,6 +13,7 @@ Highly recommended extensions:
   * **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
+  * **Facets:** Facets - https://github.com/rubyworks/facets
 
 ## Installation
 
@@ -42,6 +43,24 @@ Or install it yourself as:
 
 ## Array
 
+####After:####
+`after` returns the value after the given value.
+
+```ruby
+["1", "2", "3"].after("2") #=> "3"
+["1", "2", "3"].after("3") #=> "1"
+["1", "2", "3"].after("4") #=> nil
+```
+
+####Before:####
+`before` returns the value before the given value.
+
+```ruby
+["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.
 
@@ -56,6 +75,21 @@ Or install it yourself as:
 ["1", "2", "3"].delete_last #=> ["1", "2"]
 ```
 
+####Delete Values:####
+`delete_values` delete multiple values from array.
+
+```ruby
+[1, 2, 3, 4].delete_values(1, 3) #=> [2, 4]
+```
+
+####Duplicates:####
+`duplicates` returns list of duplicate elements.
+
+```ruby
+[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. `Rails Safe`
 
@@ -90,6 +124,27 @@ 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"]]
 ```
 
+####Probablity:####
+`probability` generates a hash mapping each unique element in the array to the relative frequency, i.e. the probablity, of it appearence.
+
+```ruby
+[:a, :b, :c, :c].probability #=> { a: 0.25, b: 0.25, c: 0.5 }
+```
+
+####Reject Values:####
+`reject_values` delete multiple values from array from a array copy.
+
+```ruby
+[1, 2, 3, 4, 5].reject_values(2,4) #=> [1, 3, 5]
+```
+
+####Sample:####
+`sample!` deletes a random value and returns that value.
+
+```ruby
+[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. `Rails Safe`
 
@@ -134,6 +189,13 @@ Or install it yourself as:
 
 ## Enumerable
 
+####Cluster:####
+`cluster` clusters together adjacent elements into a list of sub-arrays.
+
+```ruby
+[2,2,2,3,3,4,2,2,1].cluster { |x| x } #=> [[2, 2, 2], [3, 3], [4], [2, 2], [1]]
+```
+
 ####Difference:####
 `difference` returns the difference of a collection of numbers.
 
@@ -187,6 +249,13 @@ Or install it yourself as:
 [1, 2, 3].exclude?(3) #=> false
 ```
 
+####Expand:####
+`expand` expand all elements of an Enumerable object.
+
+```ruby
+[0, 2..3, 5..7].expand #=> [0,[2, 3],[5,6,7]]
+```
+
 ####Exponential:####
 `exponential` returns the exponential of a collection of numbers.
 
@@ -204,6 +273,14 @@ Or install it yourself as:
 [1, :symbol, 'string', 3, :symbol, 1].frequencies #=> { 1 => 2, :symbol => 2, 'string' => 1, 3 => 1 }
 ```
 
+####Incase:####
+`incase?` the same as #include? but tested using #=== instead of #==.
+
+```ruby
+[1, 2, "a"].incase?(String) #=> true
+[1, 2, "a"].incase?(3)      #=> false
+```
+
 ####Many:####
 `many?` returns if collection has more than one element while respecting nil and false as an element. `Rails Safe`
 
@@ -407,6 +484,50 @@ h1.deep_merge(h2) #=> { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
 { 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.
+
+```ruby
+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.
+
+```ruby
+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.
+
+```ruby
+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.
+
+```ruby
+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` 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`
@@ -464,6 +585,27 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 
 ## Integer
 
+####Factorial:####
+`factorial` calculate the factorial of an integer.
+
+```ruby
+4.factorial #=> 24
+```
+
+####Of:####
+`of` is like #times but returns a collection of the yield results.
+
+```ruby
+3.of { |i| "#{i+1}" } #=> ["1", "2", "3"]
+```
+
+####Roman:####
+`roman` converts this integer to a roman numeral.
+
+```ruby
+49.roman #=> "XLIX"
+```
+
 ####Time:####
 `time` returns a Time object for the given Integer.
 
@@ -508,6 +650,13 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 3.centuries_in_seconds #=> 9467280000.0
 ```
 
+####Days in Seconds:####
+`day_in_seconds` and `days_in_seconds` returns the amount of seconds in n days.
+
+```ruby
+3.days_in_seconds #=> 259200
+```
+
 ####Decades in Seconds:####
 `decade_in_seconds` and `decades_in_seconds` returns the amount of seconds in n decades.
 
@@ -542,11 +691,12 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 3.decimeters_in_meters #=> 0.3
 ```
 
-####Days in Seconds:####
-`day_in_seconds` and `days_in_seconds` returns the amount of seconds in n days.
+####Distance:####
+`distance` returns the absolute difference between numbers.
 
 ```ruby
-3.days_in_seconds #=> 259200
+5.distance(3) #=> 2
+3.distance(5) #=> 2
 ```
 
 ####Divide:####
@@ -934,6 +1084,13 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 3.weeks_in_seconds #=> 1814400
 ```
 
+####Within:####
+`within?` determines if another number is approximately equal within a given epsilon
+
+```ruby
+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.
 
@@ -994,6 +1151,13 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 
 ## Range
 
+####Combine:####
+`combine` returns two concated ranges.
+
+```ruby
+(1..3).combine(7..9) #=> [1, 2, 3, 7, 8, 9]
+```
+
 ####Include With Range:####
 `include_with_range?` determines if a range includes another range. `Rails Safe`
 
@@ -1011,6 +1175,30 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 (1..5).overlaps?(7..9) # => false
 ```
 
+####Sample:####
+`sample` returns a random element from the range.
+
+```ruby
+(1..5).sample # => 4
+```
+
+####Shuffle:####
+`shuffle` returns a copy of a shuffled range of elements.
+`shuffle!` returns a shuffled range of elements.
+
+```ruby
+(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.
+
+```ruby
+(1..5).within?(2..4) # => true
+(1..5).within?(4..6) # => false
+```
+
 ## String
 
 ####Any:####
@@ -1232,6 +1420,14 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 "this is <b>bold</b> and <em>emphatic</em>".strip_tags #=> "this is bold and emphatic"
 ```
 
+####Sample:####
+`sample` and `sample!` deletes a random value and returns that value.
+
+```ruby
+"this thing that".sample            #=> "thing"
+"this thing that".sample(" thing ") #=> "that"
+```
+
 ####Shift:####
 `shift` and `shift!` removes the first instance of a string.
 
@@ -1240,6 +1436,14 @@ h.slice!(:a, :b) #=> { c: 3, d: 4 }
 "this thing that thing".shift("this", "that") #=> " thing  thing"
 ```
 
+####Shuffle:####
+`shuffle` and `shuffle!` randomizes the characters in a string.
+
+```ruby
+"ruby rules".sample  #=> "e lybrsuur"
+"ruby rules".sample! #=> "rblse syru"
+```
+
 ####Slugify:####
 `slugify` and `slugify!` generates a permalink-style string, with odd characters removed.
 
@@ -1375,8 +1579,8 @@ Time.now.format("month_name day, year hour:minute ampm") #=> "January 09, 2014 0
 | 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.
+####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.**
 

data/lib/active_object/array.rb

@@ -1,5 +1,17 @@
 class Array
 
+  def after(value)
+    return(nil) unless include?(value)
+
+    self[(index(value).to_i + 1) % size]
+  end
+
+  def before(value)
+    return(nil) unless include?(value)
+
+    self[(index(value).to_i - 1) % size]
+  end
+
   def delete_first
     self[1..-1]
   end
@@ -16,6 +28,19 @@ class Array
     replace(delete_last)
   end
 
+  def delete_values(*args)
+    result = []
+    args.each { |v| result << delete(v) }
+    return(result)
+  end
+
+  def duplicates(minimum=2)
+    hash = Hash.new(0)
+
+    each { |i| hash[i] += 1 }
+    hash.delete_if { |k, v| v < minimum }.keys
+  end
+
   unless defined?(Rails)
     def from(position)
       self[position, size] || []
@@ -66,6 +91,27 @@ class Array
     end
   end
 
+  def probability
+    hash   = Hash.new(0.0)
+    differ = 0.0
+
+    each do |e|
+      hash[e] += 1.0
+      differ  += 1.0
+    end
+
+    hash.keys.each { |e| hash[e] /= differ }
+    hash
+  end
+
+  def reject_values(*args)
+    reject { |x| args.include?(x) }
+  end
+
+  def sample!
+    delete_at(Random.rand(size - 1))
+  end
+
   unless defined?(Rails)
     def split(number=nil)
       if block_given?

data/lib/active_object/enumerable.rb

@@ -1,5 +1,19 @@
 module Enumerable
 
+  def cluster(&block)
+    result = []
+
+    each do |element|
+      if result.last && (yield(result.last.last) == yield(element))
+        result.last << element
+      else
+        result << [element]
+      end
+    end
+
+    result
+  end
+
   def difference(identity=0, &block)
     if block_given?
       map(&block).difference(identity)
@@ -45,6 +59,10 @@ module Enumerable
     end
   end
 
+  def expand
+    map { |n| n.is_a?(Enumerable) ? n.expand : n }
+  end
+
   def exponential(identity=0, &block)
     if block_given?
       map(&block).exponential(identity)
@@ -57,6 +75,10 @@ module Enumerable
     each_with_object(Hash.new(0)) { |e, a| a[e] += 1 }
   end
 
+  def incase?(object)
+    any? { |x| object === x }
+  end
+
   unless defined?(Rails)
     def many?
       found_count = 0

data/lib/active_object/hash.rb

@@ -102,6 +102,46 @@ class Hash
     end
   end
 
+  def sample
+    key = sample_key
+    [key, fetch(key)]
+  end
+
+  def sample!
+    key, value = sample
+    delete(key)
+    [key, value]
+  end
+
+  def sample_key
+    hash_keys = keys
+    hash_keys.at(Random.rand(hash_keys.size - 1))
+  end
+
+  def sample_key!
+    key, value = sample
+    delete(key)
+    key
+  end
+
+  def sample_value
+    fetch(sample_key)
+  end
+
+  def sample_value!
+    key, value = sample
+    delete(key)
+    value
+  end
+
+  def shuffle
+    Hash[to_a.sample(size)]
+  end
+
+  def shuffle!
+    replace(shuffle)
+  end
+
   unless defined?(Rails)
     def slice(*keys)
       keys.flatten.each_with_object(self.class.new) { |k, h| h[k] = self[k] if has_key?(k) }

data/lib/active_object/integer.rb

@@ -1,5 +1,39 @@
 class Integer
 
+  ROMAN_VALUES = {
+    "M"  => 1000,
+    "CM" => 900,
+    "D"  => 500,
+    "CD" => 400,
+    "C"  => 100,
+    "XC" => 90,
+    "L"  => 50,
+    "XL" => 40,
+    "X"  => 10,
+    "IX" => 9,
+    "V"  => 5,
+    "IV" => 4,
+    "I"  => 1
+  }
+
+  def factorial
+    return(1) if zero?
+    2.upto(self).inject(1) { |product, n| product * n }
+  end
+
+  def of(&block)
+    Array.new(self, &block)
+  end
+
+  def roman
+    return("") if zero?
+    return("-#{(-self).roman}") if self < 0
+
+    ROMAN_VALUES.each do |key, value|
+      return(key + (self - value).roman) if value <= self
+    end
+  end
+
   def time
     Time.at(self)
   end

data/lib/active_object/numeric.rb

@@ -99,6 +99,10 @@ class Numeric
 
   alias_method :decimeter_in_meters, :decimeters_in_meters
 
+  def distance(n)
+    (self - n).abs
+  end
+
   def divide(n)
     self / n
   end
@@ -508,6 +512,14 @@ class Numeric
 
   alias_method :week_in_seconds, :weeks_in_seconds
 
+  def within?(number, epsilon=0.01)
+    return(self == number) if epsilon.zero?
+
+    a, b = to_f, number.to_f
+
+    (a.zero? || b.zero?) ? (a - b).abs < epsilon : (a / b - 1).abs < epsilon
+  end
+
   def yards_in_inches
     self * YARD
   end

data/lib/active_object/range.rb

@@ -1,12 +1,16 @@
 class Range
 
+  def combine(other)
+    to_a.concat(other.to_a)
+  end
+
   unless defined?(Rails)
-    def include_with_range?(value)
-      if value.is_a?(::Range)
-        operator = exclude_end? && !value.exclude_end? ? :< : :<=
-        include?(value.first) && value.last.send(operator, last)
+    def include_with_range?(other)
+      if other.is_a?(::Range)
+        operator = exclude_end? && !other.exclude_end? ? :< : :<=
+        include?(other.first) && other.last.send(operator, last)
       else
-        include?(value)
+        include?(other)
       end
     end
   end
@@ -17,4 +21,16 @@ class Range
     end
   end
 
+  def sample
+    to_a.sample
+  end
+
+  def shuffle
+    to_a.shuffle
+  end
+
+  def within?(other)
+    cover?(other.first) && cover?(other.last)
+  end
+
 end

data/lib/active_object/string.rb

@@ -223,6 +223,14 @@ class String
     replace(remove_tags)
   end
 
+  def sample(separator=' ')
+    split(separator).sample
+  end
+
+  def sample!(separator=' ')
+    replace(sample(separator))
+  end
+
   def shift(*patterns)
     string = dup
     patterns.flatten.each do |pattern|
@@ -235,6 +243,14 @@ class String
     replace(shift(*patterns))
   end
 
+  def shuffle(separator='')
+    split(separator).shuffle.join
+  end
+
+  def shuffle!(separator='')
+    replace(shuffle(separator))
+  end
+
   def slugify
     gsub(/[^\x00-\x7F]+/, '').
     gsub(/[^\w_ \-]+/i,   '').

data/lib/active_object/time.rb

@@ -147,4 +147,6 @@ class Time
     strftime(format_units.fetch(key))
   end
 
+  alias_method :stamp, :to_format
+
 end

data/lib/active_object/version.rb

@@ -1,3 +1,3 @@
 module ActiveObject
-  VERSION = "1.4.0"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_object
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Juan Gomez
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-08-11 00:00:00.000000000 Z
+date: 2015-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler