gorillib 0.0.8 → 0.1.0

data/CHANGELOG.textile

@@ -1,3 +1,9 @@
+h3. Version 0.1.0: Hashlike refactor, Receiver arrives
+
+v0.1.0 brings
+* Receiver module
+* refeactoring of hash decorations into a new hashlike class
+* ability to inject hashlike behavior into Struct
 
 h3. Version 0.0.7: full test coverage!
 

data/README.textile

@@ -1,15 +1,23 @@
+
 h2. Gorillib: infochimps' lightweight subset of ruby convenience methods
 
-* No creep: include only what you need
-* No dependencies unless audaciously advertised.
-* Compatibile with active_record and extlib
+We love the conveniences provided by active_support and extlib, we just don't love them at the same time and on top of each other. active_support is slow to load, has many dependencies, and is all intertwingled. We had too many collisions between active_support 2.x and 3.x and extlib. 
 
+What gorillib gives you is clarity over what features are brought in. If you want to *just* get <code>Object#blank?</code>, just <code>require 'gorillib/object/blank'</code>. No dependencies, no codependents.
 
-h3. TODO:
+* No creep: include only what you need
+* No dependencies unless audaciously advertised.
+* Upwards compatible with active_record and extlib
+  - the active_support components have significantly more robust internationalization, and some functions have rich option sets in active_support vs. basic functionality in gorillib.  So the rule is if you were happy with gorillib you'll be happy with active_support, but not vice-versa.
 
-* Gorillib.demands(:cattr_accessor) -- raises if not included and recommends what to include
+h3. require 'gorillib/receiver'
 
+Gorillib has at least one powerful addition to the canon: the receiver mixin.
 
+* lightweight
+* gives you weak type safety but doesn't jack around with setters/getters.
+* object/hash semantics
+  
 h3. require 'gorillib'
 
 * require 'gorrillib/base'
@@ -19,28 +27,30 @@ h3. require 'gorillib/base'
 requires the following libraries:
 
 * gorillib/object/blank
-* gorillib/array/extract_options
 * gorillib/hash/reverse_merge
 * gorillib/hash/compact
-* gorillib/array/compact
+* gorillib/array/compact_blank
+* gorillib/object/try
 
 h3. require 'gorillib/some'
 
 requires @gorillib/base@ and the following additional libraries:
 
+* gorillib/logger/log.rb
 * set
 * time
 * date
+* gorillib/array/extract_options
 * gorillib/enumerable/sum
 * gorillib/datetime/flat
-* gorillib/datetime/parse_safely
+* gorillib/datetime/parse
 * gorillib/hash/zip
 * gorillib/hash/slice
 * gorillib/hash/keys
-* gorillib/metaprogramming/singleton_class
-* gorillib/metaprogramming/remove_method
 * gorillib/metaprogramming/class_attribute
 * gorillib/metaprogramming/cattr_accessor
+* gorillib/metaprogramming/singleton_class
+* gorillib/metaprogramming/remove_method
 
 ---------------------------------------------------------------------------
 
@@ -51,13 +61,15 @@ h3. gorillib/array
   - Hash        extractable_options? (helper method)
 * *gorrillib/array/compact_blank*
   - Array       compact_blank, compact_blank!
+* *gorrillib/array/deep_compact*
+  - Array       deep_compact, deep_compact!
 
 h3. gorillib/datetime
 
 * *gorillib/datetime/flat*
   - Date, Time	to_flat
 * *gorillib/datetime/parse*
-  - Date, Time  parse_safely
+  - Time        parse_safely
 
 h3. gorillib/enumerable
 
@@ -68,6 +80,8 @@ h3. gorillib/hash
 
 * *gorillib/hash/compact*
   - Hash        compact, compact!, compact_blank, compact_blank!
+* *gorrilib/hash/deep_compact*
+  - Hash        deep_compact, deep_compact!
 * *gorrilib/hash/deep_merge*
   - Hash        deep_merge, deep_merge!
 * *gorillib/hash/keys*
@@ -102,10 +116,19 @@ h3. gorillib/metaprogramming
 * *gorillib/metaprogramming/delegation*
   - Module#     delegate
 
+h3. gorillib/numeric
+
+* *gorillib/numeric/clamp*
+  - Numeric     clamp -- coerce a number to lie within a certain min/max
+
 h3. gorillib/object
 
 * *gorillib/object/blank*
   - Object      blank?, present?  (and specialized for all other classes)
+* *gorillib/object/try*
+  - Object      try
+* *gorillib/object/try_dup*
+  - Object      try_dup
 
 h3. gorillib/string
 

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.1.0

data/gorillib.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gorillib}
-  s.version = "0.0.8"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Infochimps"]
-  s.date = %q{2011-05-20}
+  s.date = %q{2011-06-07}
   s.description = %q{Gorillib: infochimps lightweight subset of ruby convenience methods}
   s.email = %q{coders@infochimps.org}
   s.extra_rdoc_files = [
@@ -32,17 +32,29 @@ Gem::Specification.new do |s|
     "lib/gorillib/array/deep_compact.rb",
     "lib/gorillib/array/extract_options.rb",
     "lib/gorillib/base.rb",
-    "lib/gorillib/datetime/#flat.rb#",
     "lib/gorillib/datetime/flat.rb",
     "lib/gorillib/datetime/parse.rb",
     "lib/gorillib/enumerable/sum.rb",
     "lib/gorillib/hash/compact.rb",
     "lib/gorillib/hash/deep_compact.rb",
+    "lib/gorillib/hash/deep_dup.rb",
     "lib/gorillib/hash/deep_merge.rb",
+    "lib/gorillib/hash/indifferent_access.rb",
     "lib/gorillib/hash/keys.rb",
     "lib/gorillib/hash/reverse_merge.rb",
     "lib/gorillib/hash/slice.rb",
+    "lib/gorillib/hash/tree_merge.rb",
     "lib/gorillib/hash/zip.rb",
+    "lib/gorillib/hashlike.rb",
+    "lib/gorillib/hashlike/compact.rb",
+    "lib/gorillib/hashlike/deep_compact.rb",
+    "lib/gorillib/hashlike/deep_dup.rb",
+    "lib/gorillib/hashlike/deep_merge.rb",
+    "lib/gorillib/hashlike/hashlike_via_accessors.rb",
+    "lib/gorillib/hashlike/keys.rb",
+    "lib/gorillib/hashlike/reverse_merge.rb",
+    "lib/gorillib/hashlike/slice.rb",
+    "lib/gorillib/hashlike/tree_merge.rb",
     "lib/gorillib/logger/log.rb",
     "lib/gorillib/metaprogramming/aliasing.rb",
     "lib/gorillib/metaprogramming/cattr_accessor.rb",
@@ -55,11 +67,21 @@ Gem::Specification.new do |s|
     "lib/gorillib/object/blank.rb",
     "lib/gorillib/object/try.rb",
     "lib/gorillib/object/try_dup.rb",
+    "lib/gorillib/receiver.rb",
+    "lib/gorillib/receiver/active_model_shim.rb",
+    "lib/gorillib/receiver/acts_as_hash.rb",
+    "lib/gorillib/receiver/acts_as_loadable.rb",
+    "lib/gorillib/receiver/tree_diff.rb",
+    "lib/gorillib/receiver/validations.rb",
     "lib/gorillib/some.rb",
     "lib/gorillib/string/constantize.rb",
     "lib/gorillib/string/human.rb",
     "lib/gorillib/string/inflections.rb",
     "lib/gorillib/string/truncate.rb",
+    "lib/gorillib/struct/acts_as_hash.rb",
+    "lib/gorillib/struct/hashlike_iteration.rb",
+    "notes/fancy_hashes_and_receivers.textile",
+    "notes/hash_rdocs.textile",
     "spec/array/compact_blank_spec.rb",
     "spec/array/extract_options_spec.rb",
     "spec/datetime/flat_spec.rb",
@@ -68,10 +90,16 @@ Gem::Specification.new do |s|
     "spec/hash/compact_spec.rb",
     "spec/hash/deep_compact_spec.rb",
     "spec/hash/deep_merge_spec.rb",
+    "spec/hash/indifferent_access_spec.rb",
     "spec/hash/keys_spec.rb",
     "spec/hash/reverse_merge_spec.rb",
     "spec/hash/slice_spec.rb",
     "spec/hash/zip_spec.rb",
+    "spec/hashlike/behave_same_as_hash_spec.rb",
+    "spec/hashlike/hashlike_behavior_spec.rb",
+    "spec/hashlike/hashlike_via_accessors_fuzzing_spec.rb",
+    "spec/hashlike/hashlike_via_accessors_spec.rb",
+    "spec/hashlike_spec.rb",
     "spec/logger/log_spec.rb",
     "spec/metaprogramming/aliasing_spec.rb",
     "spec/metaprogramming/cattr_accessor_spec.rb",
@@ -83,13 +111,25 @@ Gem::Specification.new do |s|
     "spec/object/blank_spec.rb",
     "spec/object/try_dup_spec.rb",
     "spec/object/try_spec.rb",
+    "spec/receiver/acts_as_hash_spec.rb",
+    "spec/receiver_spec.rb",
     "spec/spec_helper.rb",
     "spec/string/constantize_spec.rb",
     "spec/string/human_spec.rb",
     "spec/string/inflections_spec.rb",
     "spec/string/inflector_test_cases.rb",
     "spec/string/truncate_spec.rb",
-    "spec/support/kcode_test_helper.rb"
+    "spec/struct/acts_as_hash_fuzz_spec.rb",
+    "spec/struct/acts_as_hash_spec.rb",
+    "spec/support/hashlike_fuzzing_helper.rb",
+    "spec/support/hashlike_helper.rb",
+    "spec/support/hashlike_struct_helper.rb",
+    "spec/support/hashlike_via_delegation.rb",
+    "spec/support/kcode_test_helper.rb",
+    "spec/support/matchers/be_array_eql.rb",
+    "spec/support/matchers/be_hash_eql.rb",
+    "spec/support/matchers/enumerate_method.rb",
+    "spec/support/matchers/evaluate_to_true.rb"
   ]
   s.homepage = %q{http://infochimps.com/labs}
   s.licenses = ["MIT"]
@@ -105,10 +145,16 @@ Gem::Specification.new do |s|
     "spec/hash/compact_spec.rb",
     "spec/hash/deep_compact_spec.rb",
     "spec/hash/deep_merge_spec.rb",
+    "spec/hash/indifferent_access_spec.rb",
     "spec/hash/keys_spec.rb",
     "spec/hash/reverse_merge_spec.rb",
     "spec/hash/slice_spec.rb",
     "spec/hash/zip_spec.rb",
+    "spec/hashlike/behave_same_as_hash_spec.rb",
+    "spec/hashlike/hashlike_behavior_spec.rb",
+    "spec/hashlike/hashlike_via_accessors_fuzzing_spec.rb",
+    "spec/hashlike/hashlike_via_accessors_spec.rb",
+    "spec/hashlike_spec.rb",
     "spec/logger/log_spec.rb",
     "spec/metaprogramming/aliasing_spec.rb",
     "spec/metaprogramming/cattr_accessor_spec.rb",
@@ -120,13 +166,25 @@ Gem::Specification.new do |s|
     "spec/object/blank_spec.rb",
     "spec/object/try_dup_spec.rb",
     "spec/object/try_spec.rb",
+    "spec/receiver/acts_as_hash_spec.rb",
+    "spec/receiver_spec.rb",
     "spec/spec_helper.rb",
     "spec/string/constantize_spec.rb",
     "spec/string/human_spec.rb",
     "spec/string/inflections_spec.rb",
     "spec/string/inflector_test_cases.rb",
     "spec/string/truncate_spec.rb",
-    "spec/support/kcode_test_helper.rb"
+    "spec/struct/acts_as_hash_fuzz_spec.rb",
+    "spec/struct/acts_as_hash_spec.rb",
+    "spec/support/hashlike_fuzzing_helper.rb",
+    "spec/support/hashlike_helper.rb",
+    "spec/support/hashlike_struct_helper.rb",
+    "spec/support/hashlike_via_delegation.rb",
+    "spec/support/kcode_test_helper.rb",
+    "spec/support/matchers/be_array_eql.rb",
+    "spec/support/matchers/be_hash_eql.rb",
+    "spec/support/matchers/enumerate_method.rb",
+    "spec/support/matchers/evaluate_to_true.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/gorillib/enumerable/sum.rb

@@ -25,7 +25,7 @@ unless Enumerable.method_defined?(:sum)
       else
         inject { |sum, element| sum + element } || identity
       end
-    end
+    end unless method_defined?(:sum)
   end
 
   class Range #:nodoc:
@@ -35,6 +35,6 @@ unless Enumerable.method_defined?(:sum)
       return super if block_given? || !(first.instance_of?(Integer) && last.instance_of?(Integer))
       actual_last = exclude_end? ? (last - 1) : last
       (actual_last - first + 1) * (actual_last + first) / 2
-    end
+    end unless method_defined?(:sum)
   end
 end

data/lib/gorillib/hash/compact.rb

@@ -1,31 +1,4 @@
-require 'gorillib/object/blank'
-
+require 'gorillib/hashlike/compact'
 class Hash
-  #
-  # remove all key-value pairs where the value is nil
-  #
-  def compact
-    reject{|key,val| val.nil? }
-  end unless method_defined?(:compact)
-
-  #
-  # Replace the hash with its compacted self
-  #
-  def compact!
-    replace(compact)
-  end unless method_defined?(:compact!)
-
-  #
-  # remove all key-value pairs where the value is blank
-  #
-  def compact_blank
-    reject{|key,val| val.blank? }
-  end unless method_defined?(:compact_blank)
-
-  #
-  # Replace the hash with its compact_blank'ed self
-  #
-  def compact_blank!
-    replace(compact_blank)
-  end unless method_defined?(:compact_blank!)
+  include Gorillib::Hashlike::Compact
 end

data/lib/gorillib/hash/deep_compact.rb

@@ -1,14 +1,4 @@
-require 'gorillib/object/blank'
-
-#
-# deep_compact! removes all keys with 'blank?' values in the hash, in place, recursively
-#
+require 'gorillib/hashlike/deep_compact'
 class Hash
-  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
+  include Gorillib::Hashlike::DeepCompact
 end

data/lib/gorillib/hash/deep_dup.rb

@@ -0,0 +1,4 @@
+require 'gorillib/hashlike/deep_dup'
+class Hash
+  include Gorillib::Hashlike::DeepDup
+end

data/lib/gorillib/hash/deep_merge.rb

@@ -1,16 +1,4 @@
+require 'gorillib/hashlike/deep_merge'
 class Hash
-  # 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!)
+  include Gorillib::Hashlike::DeepMerge
 end

data/lib/gorillib/hash/indifferent_access.rb

@@ -0,0 +1,207 @@
+require 'gorillib/hash/keys'
+
+# This class has dubious semantics and we only have it so that
+# people can write <tt>params[:key]</tt> instead of <tt>params['key']</tt>
+# and they get the same value for both keys.
+
+module Gorillib
+  class HashWithIndifferentAccess < Hash
+    def extractable_options?
+      true
+    end
+
+    def with_indifferent_access
+      dup
+    end
+
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if include?(converted = convert_key(key))
+        self[converted]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+      end
+    end
+
+    alias_method(:regular_writer, :[]=)    unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    alias_method :store, :[]=
+
+    # Updates the instantized hash with values from the second:
+    #
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    #
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    def update(other_hash)
+      raise TypeError, "can't convert #{other_hash.nil? ? 'nil' : other_hash.class} into Hash" unless other_hash.respond_to?(:each_pair)
+      if other_hash.is_a? HashWithIndifferentAccess
+        super(other_hash)
+      else
+        other_hash.each_pair{|key, value| regular_writer(convert_key(key), convert_value(value)) }
+        self
+      end
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      self.class.new(self).tap do |new_hash|
+        new_hash.default = default
+      end
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a <tt>HashWithDifferentAccess</tt>.
+    def reverse_merge(other_hash)
+      super self.class.new_from_hash_copying_default(other_hash)
+    end
+
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def stringify_keys; dup end
+    undef_method :symbolize_keys! if method_defined?(:symbolize_keys!)
+    def symbolize_keys; to_hash.symbolize_keys end
+    def to_options!; self end
+
+    # Convert to a Hash with String keys.
+    def to_hash
+      Hash.new(default).merge!(self)
+    end
+
+    def assoc key
+      key = convert_key(key)
+      return unless has_key?(key)
+      [key, self[key]]
+    end
+
+    def rassoc val
+      key = key(val) or return
+      [key, self[key]]
+    end
+
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      if value.is_a? Hash
+        value.nested_under_indifferent_access
+      elsif value.is_a?(Array)
+        value.dup.replace(value.map{|e| convert_value(e) })
+      else
+        value
+      end
+    end
+  end
+
+end
+
+module Gorillib
+  class HashWithIndifferentSymbolKeys < Gorillib::HashWithIndifferentAccess
+
+    def convert_key key
+      return key if key.is_a?(Fixnum)
+      key.respond_to?(:to_sym) ? key.to_sym : key
+    end
+  end
+end
+
+class Hash
+
+  # Returns an +ActiveSupport::HashWithIndifferentAccess+ out of its receiver:
+  #
+  #   {:a => 1}.with_indifferent_access["a"] # => 1
+  #
+  def with_indifferent_access
+    Gorillib::HashWithIndifferentAccess.new_from_hash_copying_default(self)
+  end
+
+  # Called when object is nested under an object that receives
+  # #with_indifferent_access. This method with be called on the current object
+  # by the enclosing object and is aliased to #with_indifferent_access by
+  # default. Subclasses of Hash may overwrite this method to return +self+ if
+  # converting to an +ActiveSupport::HashWithIndifferentAccess+ would not be
+  # desirable.
+  #
+  #   b = {:b => 1}
+  #   {:a => b}.with_indifferent_access["a"] # calls b.nested_under_indifferent_access
+  #
+  alias nested_under_indifferent_access with_indifferent_access
+end
+