gorillib 0.0.8 → 0.1.0

data/lib/gorillib/hashlike/compact.rb

@@ -0,0 +1,60 @@
+require 'gorillib/object/blank'
+module Gorillib
+  module Hashlike
+    module Compact
+
+      # returns a compact!ed copy (contains no key/value pairs having nil? values)
+      #
+      # @example
+      #     hsh = { :a => 100, :b => nil, :c => false, :d => "" }
+      #     hsh.compact # => { :a => 100, :c => false, :d => "" }
+      #     hsh         # => { :a => 100, :b => nil, :c => false, :d => "" }
+      #
+      # @return [Hashlike]
+      #
+      def compact
+        reject{|key,val| val.nil? }
+      end
+
+      # Removes all key/value pairs having nil? values
+      #
+      # @example
+      #     hsh = { :a => 100, :b => nil, :c => false, :d => "" }
+      #     hsh.compact # => { :a => 100, :c => false, :d => "" }
+      #     hsh         # => { :a => 100, :c => false, :d => "" }
+      #
+      # @return [Hashlike]
+      #
+      def compact!
+        delete_if{|key,val| val.nil? }
+      end
+
+      # returns a compact!ed copy (contains no key/value pairs having blank? values)
+      #
+      # @example
+      #     hsh = { :a => 100, :b => nil, :c => false, :d => "" }
+      #     hsh.compact # => { :a => 100 }
+      #     hsh         # => { :a => 100, :b => nil, :c => false, :d => "" }
+      #
+      # @return [Hashlike]
+      #
+      def compact_blank
+        reject{|key,val| val.blank? }
+      end
+
+      # Removes all key/value pairs having blank? values
+      #
+      # @example
+      #     hsh = { :a => 100, :b => nil, :c => false, :d => "" }
+      #     hsh.compact # => { :a => 100 }
+      #     hsh         # => { :a => 100 }
+      #
+      # @return [Hashlike]
+      #
+      def compact_blank!
+        delete_if{|key,val| val.blank? }
+      end
+
+    end
+  end
+end

data/lib/gorillib/hashlike/deep_compact.rb

@@ -0,0 +1,18 @@
+require 'gorillib/object/blank'
+module Gorillib
+  module Hashlike
+    module DeepCompact
+
+      #
+      # deep_compact! removes all keys with 'blank?' values in the hash, in place, recursively
+      #
+      def deep_compact!
+        self.each do |key, val|
+          val.deep_compact! if val.respond_to?(:deep_compact!)
+          self.delete(key) if val.blank?
+        end
+        self
+      end
+    end
+  end
+end

data/lib/gorillib/hashlike/deep_dup.rb

@@ -0,0 +1,15 @@
+module Gorillib
+  module Hashlike
+    module DeepDup
+      # Returns a deep copy of hash.
+      def deep_dup
+        duplicate = self.dup
+        duplicate.each_pair do |k,v|
+          tv = duplicate[k]
+          duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_dup : v
+        end
+        duplicate
+      end
+    end
+  end
+end

data/lib/gorillib/hashlike/deep_merge.rb

@@ -0,0 +1,20 @@
+module Gorillib
+  module Hashlike
+    module DeepMerge
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      def deep_merge(other_hash)
+        dup.deep_merge!(other_hash)
+      end unless method_defined?(:deep_merge)
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      # Modifies the receiver in place.
+      def deep_merge!(other_hash)
+        other_hash.each_pair do |k,v|
+          tv = self[k]
+          self[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v
+        end
+        self
+      end unless method_defined?(:deep_merge!)
+    end
+  end
+end

data/lib/gorillib/hashlike/hashlike_via_accessors.rb

@@ -0,0 +1,169 @@
+require 'enumerator'
+module Gorillib
+  module Hashlike
+    #
+    # Makes a Receiver thingie behave mostly like a hash.
+    #
+    # By default, the hashlike methods iterate over the receiver attributes:
+    # instance #keys delegates to self.class.keys which calls
+    # receiver_attr_names. If you want to filter our add to the keys list, you
+    # can just override the class-level keys method (and call super, or not):
+    #
+    #     def self.keys
+    #       super + [:firstname, :lastname] - [:fullname]
+    #     end
+    #
+    # in addition to the below, by including Enumerable, this also adds
+    #
+    #     :each_cons, :each_entry, :each_slice, :each_with_index, :each_with_object,
+    #     :map, :collect, :collect_concat, :entries, :to_a, :flat_map, :inject, :reduce,
+    #     :group_by, :chunk, :cycle, :partition, :reverse_each, :slice_before, :drop,
+    #     :drop_while, :take, :take_while, :detect, :find, :find_all, :find_index, :grep,
+    #     :all?, :any?, :none?, :one?, :first, :count, :zip :max, :max_by, :min, :min_by,
+    #     :minmax, :minmax_by, :sort, :sort_by
+    #
+    # As opposed to hash, does *not* define
+    #
+    #   default, default=, default_proc, default_proc=, shift, flatten, compare_by_identity
+    #   compare_by_identity? rehash
+    #
+    module HashlikeViaAccessors
+
+      # Hashlike#[]
+      #
+      # Element Reference -- Retrieves the value stored for +key+.
+      #
+      # In a normal hash, a default value can be set; none is provided here.
+      #
+      # Delegates to self.send(key)
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200 }
+      #     hsh[:a] # => 100
+      #     hsh[:c] # => nil
+      #
+      # @param  key [Object] key to retrieve
+      # @return [Object] the value stored for key, nil if missing
+      #
+      def [](key)
+        key = convert_key(key)
+        self.send(key)
+      end
+
+      # Hashlike#[]=
+      # Hashlike#store
+      #
+      # Element Assignment -- Associates the value given by +val+ with the key
+      # given by +key+.
+      #
+      # key should not have its value changed while it is in use as a key. In a
+      # normal hash, a String passed as a key will be duplicated and frozen. No such
+      # guarantee is provided here
+      #
+      # Delegates to self.send("key=", val)
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200 }
+      #     hsh[:a] = 9
+      #     hsh[:c] = 4
+      #     hsh    # => { :a => 9, :b => 200, :c => 4 }
+      #
+      #     hsh[key] = val                         -> val
+      #     hsh.store(key, val)                    -> val
+      #
+      # @param  key [Object] key to associate
+      # @param  val [Object] value to associate it with
+      # @return [Object]
+      #
+      def []=(key, val)
+        key = convert_key(key)
+        self.send("#{key}=", val)
+      end
+
+      # Hashlike#delete
+      #
+      # Deletes and returns the value from +hsh+ whose key is equal to +key+. If the
+      # optional code block is given and the key is not found, pass in the key and
+      # return the result of +block+.
+      #
+      # In a normal hash, a default value can be set; none is provided here.
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200 }
+      #     hsh.delete(:a)                            # => 100
+      #     hsh.delete(:z)                            # => nil
+      #     hsh.delete(:z){|el| "#{el} not found" }   # => "z not found"
+      #
+      # @overload hsh.delete(key)                  -> val
+      #   @param  key [Object] key to remove
+      #   @return [Object, Nil] the removed object, nil if missing
+      #
+      # @overload hsh.delete(key){|key| block }    -> val
+      #   @param  key [Object] key to remove
+      #   @yield  [Object] called (with key) if key is missing
+      #   @yieldparam key
+      #   @return [Object, Nil] the removed object, or if missing, the return value
+      #     of the block
+      #
+      def delete(key, &block)
+        key = convert_key(key)
+        if has_key?(key)
+          val = self[key]
+          self.send(:remove_instance_variable, "@#{key}")
+          val
+        elsif block_given?
+          block.call(key)
+        else
+          nil
+        end
+      end
+
+      # # Hashlike#==
+      # #
+      # # Equality -- Two hashes are equal if they contain the same number of keys,
+      # # and the value corresponding to each key in the first hash is equal (using
+      # # <tt>==</tt>) to the value for the same key in the second. If +obj+ is not a
+      # # Hashlike, attempt to convert it using +to_hash+ and return <tt>obj ==
+      # # hsh</tt>.
+      # #
+      # # Does not take a default value comparion into account.
+      # #
+      # # @example
+      # #     h1 = { :a => 1, :c => 2 }
+      # #     h2 = { 7 => 35, :c => 2, :a => 1 }
+      # #     h3 = { :a => 1, :c => 2, 7 => 35 }
+      # #     h4 = { :a => 1, :d => 2, :f => 35 }
+      # #     h1 == h2 # => false
+      # #     h2 == h3 # => true
+      # #     h3 == h4 # => false
+      # #
+      # def ==(other_hash)
+      #   (length == other_hash.length) &&
+      #     all?{|k,v| v == other_hash[k] }
+      # end
+
+      # Hashlike#keys
+      #
+      # Returns a new array populated with the keys from this hashlike.
+      #
+      # @see Hashlike#values.
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200, :c => 300, :d => 400 }
+      #     hsh.keys   # => [:a, :b, :c, :d]
+      #
+      # @return [Array] list of keys
+      #
+      def keys
+        instance_variables.map{|s| convert_key(s[1..-1]) }
+      end
+
+    protected
+      def convert_key(key)
+        raise ArgumentError, "Keys for #{self.class} must be symbols, strings or respond to #to_sym" unless key.respond_to?(:to_sym)
+        key.to_sym
+      end
+
+    end
+  end
+end

data/lib/gorillib/hashlike/keys.rb

@@ -0,0 +1,59 @@
+module Gorillib
+  module Hashlike
+    module Keys
+      # Return a new hash with all keys converted to strings.
+      def stringify_keys
+        dup.stringify_keys!
+      end unless method_defined?(:stringify_keys)
+
+      # Destructively convert all keys to strings.
+      def stringify_keys!
+        keys.each do |key|
+          self[key.to_s] = delete(key)
+        end
+        self
+      end unless method_defined?(:stringify_keys!)
+
+      # Return a new hash with all keys converted to symbols, as long as
+      # they respond to +to_sym+.
+      def symbolize_keys
+        dup.symbolize_keys!
+      end unless method_defined?(:symbolize_keys)
+
+      # Destructively convert all keys to symbols, as long as they respond
+      # to +to_sym+.
+      def symbolize_keys!
+        keys.each do |key|
+          self[(key.to_sym rescue key) || key] = delete(key)
+        end
+        self
+      end unless method_defined?(:symbolize_keys!)
+
+      # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+      # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+      # as keys, this will fail.
+      #
+      # ==== Examples
+      #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
+      #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): name, age"
+      #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+      def assert_valid_keys(*valid_keys)
+        unknown_keys = keys - [valid_keys].flatten
+        raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+      end unless method_defined?(:assert_valid_keys)
+    end
+    # # @return [Hash] the object as a Hash with symbolized keys.
+    # def symbolize_keys() to_hash ; end
+    # # @return [Hash] the object as a Hash with string keys.
+    # def stringify_keys() to_hash.stringify_keys ; end
+    #
+    # # Used to provide the same interface as Hash.
+    # # @return This object unchanged.
+    # def symbolize_keys!; self end
+    #
+    # # Used to provide the same interface as Hash.
+    # # @return This object unchanged.
+    # def stringify_keys!; self end
+    #
+  end
+end

data/lib/gorillib/hashlike/reverse_merge.rb

@@ -0,0 +1,31 @@
+module Gorillib
+  module Hashlike
+    module ReverseMerge
+      # Allows for reverse merging two hashes where the keys in the calling hash take precedence over those
+      # in the <tt>other_hash</tt>. This is particularly useful for initializing an option hash with default values:
+      #
+      #   def setup(options = {})
+      #     options.reverse_merge! :size => 25, :velocity => 10
+      #   end
+      #
+      # Using <tt>merge</tt>, the above example would look as follows:
+      #
+      #   def setup(options = {})
+      #     { :size => 25, :velocity => 10 }.merge(options)
+      #   end
+      #
+      # The default <tt>:size</tt> and <tt>:velocity</tt> are only set if the +options+ hash passed in doesn't already
+      # have the respective key.
+      def reverse_merge(other_hash)
+        other_hash.merge(self)
+      end unless method_defined?(:reverse_merge)
+
+      # Performs the opposite of <tt>merge</tt>, with the keys and values from the first hash taking precedence over the second.
+      # Modifies the receiver in place.
+      def reverse_merge!(other_hash)
+        merge!( other_hash ){|k,o,n| o }
+      end unless method_defined?(:reverse_merge!)
+    end
+  end
+end
+

data/lib/gorillib/hashlike/slice.rb

@@ -0,0 +1,67 @@
+module Gorillib
+  module Hashlike
+    module Slice
+      # Slice a hash to include only the given allowed_keys. This is useful for
+      # limiting an options hash to valid keys before passing to a method:
+      #
+      #   def search(criteria = {})
+      #     assert_valid_keys(:mass, :velocity, :time)
+      #   end
+      #
+      #   search(options.slice(:mass, :velocity, :time))
+      #
+      # If you have an array of keys you want to limit to, you should splat them:
+      #
+      #   valid_keys = [:mass, :velocity, :time]
+      #   search(options.slice(*valid_keys))
+      def slice(*allowed_keys)
+        allowed_keys = allowed_keys.map!{|key| convert_key(key) } if respond_to?(:convert_key)
+        hash = self.class.new
+        allowed_keys.each{|k| hash[k] = self[k] if has_key?(k) }
+        hash
+      end unless method_defined?(:slice)
+
+      # Replaces the hash with only the given allowed_keys.
+      # Returns a hash containing the removed key/value pairs
+      # @example
+      #   hsh = {:a => 1, :b => 2, :c => 3, :d => 4}
+      #   hsh.slice!(:a, :b)
+      #   # => {:c => 3, :d =>4}
+      #   hsh
+      #   # => {:a => 1, :b => 2}
+      def slice!(*allowed_keys)
+        allowed_keys = allowed_keys.map!{|key| convert_key(key) } if respond_to?(:convert_key)
+        omit = slice(*self.keys - allowed_keys)
+        hash = slice(*allowed_keys)
+        replace(hash)
+        omit
+      end unless method_defined?(:slice!)
+
+      # This also works, and doesn't require #replace method, but is uglier and
+      # wasn't written by Railsians.  I'm not sure that slice! is interesting if
+      # you're a duck-typed Hash but not is_a?(Hash), so we'll just leave it at the
+      # active_record implementation.
+      #
+      # def slice!(*allowed_keys)
+      #   allowed_keys = allowed_keys.map!{|key| convert_key(key) } if respond_to?(:convert_key)
+      #   omit_keys = self.keys - allowed_keys
+      #   omit = slice(*omit_keys)
+      #   omit_keys.each{|k| delete(k) }
+      #   omit
+      # end
+
+      # Removes the given allowed_keys from the hash
+      # Returns a hash containing the removed key/value pairs
+      #
+      # @example
+      #   hsh = {:a => 1, :b => 2, :c => 3, :d => 4}
+      #   hsh.extract!(:a, :b)
+      #   # => {:a => 1, :b => 2}
+      #   hsh
+      #   # => {:c => 3, :d =>4}
+      def extract!(*allowed_keys)
+        slice!(*self.keys - allowed_keys)
+      end unless method_defined?(:extract!)
+    end
+  end
+end