flash_extensions 0.0.1 → 1.0.0

data/flash_extensions.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Juan Gomez"]
   spec.email         = ["j.gomez@drexed.com"]
   spec.summary       = %q{Commonly used object helpers}
-  spec.description   = %q{Class extensions of of commonly used object helpers.}
+  spec.description   = %q{Class extensions of commonly used object helpers.}
   spec.homepage      = "https://github.com/drexed/flash_extensions"
   spec.license       = "MIT"
 
@@ -21,5 +21,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "coveralls"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 3.0.0.beta"
-end
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+end

data/lib/flash_extensions.rb

@@ -1,6 +1,8 @@
 require 'flash_extensions/version'
 require 'flash_extensions/extensions/array_extension'
+require 'flash_extensions/extensions/enumerable_extension'
 require 'flash_extensions/extensions/hash_extension'
+require 'flash_extensions/extensions/numeric_extension'
 require 'flash_extensions/extensions/object_extension'
 require 'flash_extensions/extensions/string_extension'
 require 'flash_extensions/extensions/time_extension'

data/lib/flash_extensions/extensions/array_extension.rb

@@ -1,15 +1,15 @@
 class Array
 
   def remove_blanks
-    self.reject{ |e| e.blank? }
+    reject { |e| e.blank? }
   end
 
-  def remove_first_element
-    self[1..self.size]
+  def remove_first
+    self[1..-1]
   end
 
-  def remove_last_element
-    self[0..self.size-2]
+  def remove_last
+    self[0...-1]
   end
 
 end

data/lib/flash_extensions/extensions/enumerable_extension.rb

@@ -0,0 +1,91 @@
+module Enumerable
+
+  unless method_defined?(:sum)
+    def sum(identity=0)
+      inject { |s, e| s + e } || identity
+    end
+  end
+
+  def average(identity=0)
+    collection_size = to_a.size
+    collection_size > 0 ? inject(&:+) / collection_size.to_f : identity
+  end
+
+  def drop_last(n)
+    array = to_a
+
+    return array if n > array.size
+    array[0...(array.size - n)]
+  end
+
+  def drop_last_while
+    return to_enum(:drop_last_while) unless block_given?
+
+    result = []
+    dropping = true
+    reverse_each do |obj|
+      result.unshift(obj) unless dropping &&= yield(obj)
+    end
+    result
+  end
+
+  def exactly?(n)
+    found_count = 0
+
+    if block_given?
+      each do |*o|
+        if yield(*o)
+          found_count += 1
+        end
+      end
+    else
+      each do |o|
+        if o
+          found_count += 1
+        end
+      end
+    end
+
+    (found_count > n) ? false : n == found_count
+  end
+
+  def frequencies
+    each_with_object(Hash.new(0)) { |e, a| a[e] += 1 }
+  end
+
+  def several?
+    found_count = 0
+
+    if block_given?
+      each do |*o|
+        if yield(*o)
+          found_count += 1
+        end
+      end
+    else
+      each do |o|
+        if o
+          found_count += 1
+        end
+      end
+    end
+
+    (found_count > 1) ? true : false
+  end
+
+  def take_last(n)
+    array = to_a
+
+    return array if n > array.size
+    array[(array.size - n)..-1]
+  end
+
+  def take_last_while
+    return to_enum(:take_last_while) unless block_given?
+
+    result = []
+    reverse_each { |e| yield(e) ? result.unshift(e) : break  }
+    result
+  end
+
+end

data/lib/flash_extensions/extensions/hash_extension.rb

@@ -1,6 +1,6 @@
 class Hash
 
-  unless method_defined?("stringify_keys")
+  unless method_defined?(:stringify_keys)
     def stringify_keys
       inject({}) do |options, (key, value)|
         options[key.to_s] = value
@@ -9,13 +9,13 @@ class Hash
     end
   end
 
-  unless method_defined?("stringify_keys!")
+  unless method_defined?(:stringify_keys!)
     def stringify_keys!
-      self.replace(self.stringify_keys)
+      replace(stringify_keys)
     end
   end
 
-  unless method_defined?("symbolize_keys")
+  unless method_defined?(:symbolize_keys)
     def symbolize_keys
       inject({}) do |options, (key, value)|
         options[(key.to_sym rescue key) || key] = value
@@ -24,18 +24,34 @@ class Hash
     end
   end
 
-  unless method_defined?("symbolize_keys!")
+  unless method_defined?(:symbolize_keys!)
     def symbolize_keys!
-      self.replace(self.symbolize_keys)
+      replace(symbolize_keys)
     end
   end
 
+  def except(*args)
+    hash = dup
+    args.each {|k| hash.delete(k) }
+    hash
+  end
+
+  def only(*args)
+    hash = {}
+    args.each {|k| hash[k] = self[k] if self.has_key?(k) }
+    hash
+  end
+
   def rename_keys(*args)
     keys = Hash[*args.flatten]
-    keys.each { |k, v| self[v] = self.delete(k) if self[k] }
+    keys.each { |k, v| self[v] = delete(k) if self[k] }
     self
   end
 
+  def rename_keys!(*args)
+    replace(rename_keys(*args))
+  end
+
   def symbolize_and_underscore_keys
     inject({}) do |options, (key, value)|
       options[(key.to_s.underscore.to_sym rescue key) || key] = value
@@ -44,7 +60,7 @@ class Hash
   end
 
   def symbolize_and_underscore_keys!
-    self.replace(self.symbolize_and_underscore_keys)
+    replace(symbolize_and_underscore_keys)
   end
 
 end

data/lib/flash_extensions/extensions/numeric_extension.rb

@@ -0,0 +1,17 @@
+class Numeric
+
+  unless method_defined?(:multiple_of?)
+    def multiple_of?(number)
+      number != 0 ? modulo(number).zero? : zero?
+    end
+  end
+
+  def negative?
+    self < 0
+  end
+
+  def positive?
+    self > 0
+  end
+
+end

data/lib/flash_extensions/extensions/object_extension.rb

@@ -1,29 +1,29 @@
 class Object
 
-  unless method_defined?("blank?")
+  unless method_defined?(:blank?)
     def blank?
       respond_to?(:empty?) ? !!empty? : !self
     end
   end
 
-  unless method_defined?("present?")
+  unless method_defined?(:present?)
     def present?
       !blank?
     end
   end
 
-  unless method_defined?("try")
+  unless method_defined?(:try)
     def try(method)
-      send method if respond_to? method
+      send(method) if respond_to?(method)
     end
   end
 
   def numeric?
-    !self.to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/).nil?
+    !to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/).nil?
   end
 
   def palindrome?
-    self.to_s.reverse == self.to_s
+    to_s.reverse == to_s
   end
 
 end

data/lib/flash_extensions/extensions/string_extension.rb

@@ -1,25 +1,31 @@
 class String
 
-  unless method_defined?("camelize")
+  unless method_defined?(:camelize)
     def camelize(first_letter_in_uppercase = true)
       if first_letter_in_uppercase != :lower
-        self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+        to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
       else
-        self.to_s[0].chr.downcase + camelize(self)[1..-1]
+        to_s[0].chr.downcase + camelize(self)[1..-1]
       end
     end
   end
 
-  unless method_defined?("ends_with?")
+  unless method_defined?(:camelize!)
+    def camelize!(first_letter_in_uppercase = true)
+      replace(camelize(first_letter_in_uppercase))
+    end
+  end
+
+  unless method_defined?(:ends_with?)
     def ends_with?(suffix)
       suffix = suffix.to_s
       self[-suffix.length, suffix.length] == suffix
     end
   end
 
-  unless method_defined?("humanize")
+  unless method_defined?(:humanize)
     def humanize(options = {})
-      self.underscore.
+      underscore.
       gsub(/_id$/, "").
       tr('_', ' ').
       gsub(/([a-z\d]*)/i) { |match| match.downcase }.
@@ -27,24 +33,36 @@ class String
     end
   end
 
-  unless method_defined?("titleize")
+  unless method_defined?(:humanize!)
+    def humanize!(options = {})
+      replace(humanize)
+    end
+  end
+
+  unless method_defined?(:titleize)
     def titleize
-      self.underscore.
+      underscore.
       humanize.
       gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
     end
   end
 
-  unless method_defined?("starts_with?")
+  unless method_defined?(:titleize!)
+    def titleize!
+      replace(titleize)
+    end
+  end
+
+  unless method_defined?(:starts_with?)
     def starts_with?(prefix)
       prefix = prefix.to_s
       self[0, prefix.length] == prefix
     end
   end
 
-  unless method_defined?("underscore")
+  unless method_defined?(:underscore)
     def underscore
-      self.gsub(/::/, '/').
+      gsub(/::/, '/').
       gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
       gsub(/([a-z\d])([A-Z])/,'\1_\2').
       tr("-", "_").
@@ -52,25 +70,35 @@ class String
     end
   end
 
+  unless method_defined?(:underscore!)
+    def underscore!
+      replace(underscore)
+    end
+  end
+
   def domain(options={})
-    url = self.dup
+    url = dup
     url =~ (/^(?:\w+:\/\/)?([^\/?]+)(?:\/|\?|$)/) ? $1 : url
   end
 
   def downcase?
-    self.downcase == self
+    downcase == self
   end
 
   def ellipsize(options={})
-     length = options[:length] || 30
+     length    = options[:length]    || 30
      separator = options[:separator] || '...'
-     return self if self.size <= length
-     offset = options[:offset] || 4
+     return self if size <= length
+     offset    = options[:offset]    || 4
      self[0,offset] + separator + self[-offset,offset]
   end
 
   def gnix(string)
-    self.gsub(string, "")
+    gsub(string, "")
+  end
+
+  def gnix!(string)
+    gsub!(string, "")
   end
 
   def mixedcase?
@@ -78,41 +106,65 @@ class String
   end
 
   def nix(string)
-    self.sub(string, "")
+    sub(string, "")
+  end
+
+  def nix!(string)
+    sub!(string, "")
   end
 
   def pollute(delimiter="^--^--^")
-    self.split('').map{ |letter| "#{letter}#{delimiter}" }.join
+    split('').map{ |letter| "#{letter}#{delimiter}" }.join
   end
 
   def slugify
-    self.gsub(/[^\x00-\x7F]+/, ''). # Remove anything non-ASCII entirely (e.g. diacritics).
-    gsub(/[^\w_ \-]+/i,   '').      # Remove unwanted chars.
-    gsub(/[ \-]+/i,      '-').      # No more than one of the separator in a row.
-    gsub(/^\-|\-$/i,      '').      # Remove leading/trailing separator.
+    gsub(/[^\x00-\x7F]+/, '').    # Remove anything non-ASCII entirely (e.g. diacritics).
+    gsub(/[^\w_ \-]+/i,   '').    # Remove unwanted chars.
+    gsub(/[ \-]+/i,      '-').    # No more than one of the separator in a row.
+    gsub(/^\-|\-$/i,      '').    # Remove leading/trailing separator.
     downcase
   end
 
+  def slugify!
+    replace(slugify)
+  end
+
+  def squish
+    strip.gsub(/\s+/, ' ')
+  end
+
+  def squish!
+    replace(squish)
+  end
+
   def strip_tags
-    self.gsub(/<\/?[^>]*>/, "")
+    gsub(/<\/?[^>]*>/, "")
+  end
+
+  def strip_tags!
+    replace(strip_tags)
   end
 
   def strip_whitespace
-    self.gnix("\t").split(" ").remove_blanks.join(" ")
+    gnix("\t").split(" ").remove_blanks.join(" ")
+  end
+
+  def strip_whitespace!
+    replace(strip_whitespace)
   end
 
   def truncate_preserving_words(options={})
     separator = options[:separator] || '...'
     max_words = options[:max_words] || nil
     if max_words
-      words = self.split()
+      words = split
       return self if words.size < max_words
       words = words[0..(max_words-1)]
       words << separator
       words.join(" ")
     else
       max_chars = options[:max_chars] || 30
-      return self if self.size < max_chars
+      return self if size < max_chars
       out = self[0..(max_chars-1)].split(" ")
       out.pop
       out << separator
@@ -121,11 +173,11 @@ class String
   end
 
   def unpollute(delimiter="^--^--^")
-    self.gsub(delimiter, "")
+    gsub(delimiter, "")
   end
 
   def upcase?
-    self.upcase == self
+    upcase == self
   end
 
 end