gorillib 0.0.8 → 0.1.0

data/lib/gorillib/receiver/acts_as_loadable.rb

@@ -0,0 +1,42 @@
+module Receiver
+  #
+  # adds methods to load and store from json, yaml or magic
+  #
+  # This will require 'json' UNLESS you have already included something (so if
+  # you want to say require 'yajl' then do that first).
+  #
+  module ActsAsLoadable
+
+    module ClassMethods
+      def receive_json stream
+        receive(JSON.load(stream))
+      end
+
+      def receive_yaml stream
+        receive(YAML.load(stream))
+      end
+
+      #
+      # The file is loaded with
+      # * YAML if the filename ends in .yaml or .yml
+      # * JSON otherwise
+      #
+      def receive_from_file filename
+        stream = File.open(filename)
+        (filename =~ /.ya?ml$/) ? receive_yaml(stream) : receive_json(stream)
+      end
+    end
+
+    def merge_from_file! filename
+      other_obj = self.class.receive_from_file(filename)
+      tree_merge! other_obj
+    end
+
+    # put all the things in ClassMethods at class level
+    def self.included base
+      require 'yaml'
+      require 'json' unless defined?(JSON)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/gorillib/receiver/tree_diff.rb

@@ -0,0 +1,74 @@
+module Receiver
+  def tree_diff(other)
+    diff_hsh = {}
+    other = other.symbolize_keys if other.respond_to?(:symbolize_keys)
+    each do |k, v|
+      case
+      when v.is_a?(Array) && other[k].is_a?(Array)
+        val = v.tree_diff(other[k])
+        diff_hsh[k] = val unless val.blank?
+      when v.respond_to?(:tree_diff) && other[k].respond_to?(:to_hash)
+        val = v.tree_diff(other[k])
+        diff_hsh[k] = val unless val.blank?
+      else
+        diff_hsh[k] = v unless v == other[k]
+      end
+    end
+    other_hsh = other.dup.delete_if{|k, v| has_key?(k) }
+    diff_hsh.merge!(other_hsh)
+  end
+
+  module ActsAsHash
+    def <=>(other)
+      return 1 if other.blank?
+      each_key do |k|
+        if has_key?(k) && other.has_key?(k)
+          cmp = self[k] <=> other[k]
+          return cmp unless cmp == 0
+        end
+      end
+      0
+    end
+  end
+end
+
+class Array
+  def tree_diff(other)
+    arr = dup
+    if other.length > arr.length then arr = arr + ([nil] * (other.length - arr.length)) end
+    diff_ary = arr.zip(other).map do |arr_el, other_el|
+      if arr_el.respond_to?(:tree_diff)  && other_el.respond_to?(:to_hash)
+        arr_el.tree_diff(other_el)
+      else
+        (arr_el == other_el) ? nil : [arr_el, other_el]
+      end
+    end.reject(&:blank?)
+  end
+end
+
+class Hash
+  # Returns a hash that represents the difference between two hashes.
+  #
+  # Examples:
+  #
+  #   {1 => 2}.tree_diff(1 => 2)         # => {}
+  #   {1 => 2}.tree_diff(1 => 3)         # => {1 => 2}
+  #   {}.tree_diff(1 => 2)               # => {1 => 2}
+  #   {1 => 2, 3 => 4}.tree_diff(1 => 2) # => {3 => 4}
+  def tree_diff(other)
+    diff_hsh = self.dup
+    each do |k, v|
+      case
+      when v.is_a?(Array) && other[k].is_a?(Array)
+        diff_hsh[k] = v.tree_diff(other[k])
+        diff_hsh.delete(k) if diff_hsh[k].blank?
+      when v.respond_to?(:tree_diff)  && other[k].respond_to?(:to_hash)
+        diff_hsh[k] = v.tree_diff(other[k])
+        diff_hsh.delete(k) if diff_hsh[k].blank?
+      else diff_hsh.delete(k) if v == other[k]
+      end
+    end
+    other_hsh = other.dup.delete_if{|k, v| has_key?(k) || has_key?(k.to_s) }
+    diff_hsh.merge!(other_hsh)
+  end
+end

data/lib/gorillib/receiver/validations.rb

@@ -0,0 +1,30 @@
+module Receiver
+
+  # An array of strings describing any ways this fails validation
+  def validation_errors
+    errors = []
+    if (ma = missing_attrs).present?
+      errors << "Missing values for {#{ma.join(",")}}"
+    end
+    errors
+  end
+
+  # returns a list of required but missing attributes
+  def missing_attrs
+    missing = []
+    self.class.required_rcvrs.each do |name, info|
+      missing << name if (not attr_set?(name))
+    end
+    missing
+  end
+
+  # methods become class-level
+  module ClassMethods
+
+    # class method gives info for all receiver attributes with required => true
+    def required_rcvrs
+      receiver_attrs.select{|name, info|  info[:required] }
+    end
+  end
+
+end

data/lib/gorillib/struct/acts_as_hash.rb

@@ -0,0 +1,108 @@
+module Gorillib
+  module Struct
+    #
+    # Make a Struct 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
+    #
+    # @example
+    #   StructUsingHashlike = Struct.new(:a, :b, :c, :z) do
+    #     include Gorillib::Struct::ActsAsHash
+    #     include Gorillib::Hashlike
+    #   end
+    #   foo = StructUsingHashlike.new(1,2,3)
+    #   foo.to_hash  # => { :a => 1, :b => 2, :c => 3, :z => nil }
+    #
+    module ActsAsHash
+
+      # 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)
+        if has_key?(key)
+          val = self[key]
+          self[key] = nil
+          self.send(:remove_instance_variable, "@#{key}") if instance_variables.include?("@#{key}")
+          val
+        elsif block_given?
+          block.call(key)
+        else
+          nil
+        end
+      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
+        @keys ||= members.map{|key| convert_key(key) }
+      end
+
+      def empty?
+        keys.select{|key| not self[key].nil? }.empty?
+      end
+
+      def convert_key(key)
+        return key if key.is_a?(Fixnum)
+        key.respond_to?(:to_sym) ? key.to_sym : key
+      end
+
+      def size
+        length
+      end
+
+    end
+  end
+end

data/notes/fancy_hashes_and_receivers.textile

@@ -0,0 +1,120 @@
+
+* gorillib/hashlike
+* gorillib/hashlike/slice
+* gorillib/hashlike/deep_dup
+* gorillib/hashlike/
+* gorillib/hashlike/hashlike_via_accessors
+* gorillib/struct/acts_as_hash
+* gorillib/struct/iterates_as_hash
+
+
+
+h4. acts_as_hash
+
+* []=           associates key with value
+* []            retrieves value associated with given key
+* delete        removes that key and its association
+* keys          enumeration of all keys having associations.
+
+
+* check for compatibility/semantics of Enumerable
+* has_key?      true if an association exists for the given key.
+
+h4. hashlike
+
+Want chokepoints:
+
+keys
+  - each, each_pair
+    - each_value
+    - reject!
+      - delete_if
+      - reject
+    - select!
+      - keep_if
+  - each_key
+  - key
+  - has_key?
+    - values_at
+  - length, size
+  - empty?
+  
+
+* each          keys.each{|k|   yield [k, self[k]] } ; self
+
+* has_key?      keys.include?(k)
+* length        keys.length
+* size          alias for length
+* empty?        keys.empty?
+
+* each_pair     alias for each
+* each_key      keys.each{|k|   yield  k }
+* each_value         each{|k,v| yield  v }
+* key           keys.find{|k|    self[k] == val }
+* values_at     in_keys.each{|k| self[k] if has_key?(k) }
+* values        [].tap{|arr| each{|k,v| arr << v      } }
+* to_hash       {}.tap{|hsh| each{|k,v| hsh[k] = v    } }
+
+* has_value?    keys.any?{|k|    self[k] == val }
+* value?        alias for has_value?
+* include?      alias for has_key?
+* key?          alias for has_key?
+* member?       alias for has_key?
+
+* update        other_hash.each{|k,v| self[k] = (block_given? && has_key?(k) ? yield(k,v,self[k]) : v) }
+* merge!        update
+* merge         dup.merge!
+
+* reject!       chgd = false ; each{|k,v| if  yield(k,v) then delete(k); chgd = true ; end } chgd ? self : nil
+* select!       chgd = false ; each{|k,v| if !yield(k,v) then delete(k); chgd = true ; end } chgd ? self : nil
+* delete_if:    reject! ; return self
+* keep_if:      select! ; return self
+* reject:       self.dup.delete_if
+
+* fetch         [] if has_key? else default else yield else raise KeyError
+* clear         each_key{|k| delete(k) }
+
+* invert        to_hash.invert
+
+
+
+   #all?, #any?, #chunk, #collect, #collect_concat, #count, #cycle, #detect,
+   #drop, #drop_while, #each_cons, #each_entry, #each_slice,
+   #each_with_index, #each_with_object, #entries, #find, #find_all,
+   #find_index, #first, #flat_map, #grep, #group_by, #inject, #map, #max,
+   #max_by, #min, #min_by, #minmax, #minmax_by, #none?, #one?, #partition,
+   #reduce, #reverse_each, #slice_before, #sort, #sort_by, #take,
+   #take_while, #zip
+
+As opposed to hash, does *not* define
+
+  default, default=, default_proc, default_proc=,
+  replace, rehash, compare_by_identity compare_by_identity?,
+  shift, flatten,
+
+h4. Configliere::DeepHash -- a magic hash
+
+  - only allows handles as keys (only things that can be turned into symbols are interesting)
+  - indifferent access
+  - deep access, via the dotted hash
+
+* FancyHash
+
+* *gorillib/hash/compact*         compact, compact!, compact_blank, compact_blank!
+* *gorrilib/hash/deep_compact*    deep_compact, deep_compact!
+* *gorrilib/hash/deep_merge*      deep_merge, deep_merge!
+* *gorillib/hash/keys*            stringify_keys, stringify_keys!, symbolize_keys, symbolize_keys!, assert_valid_keys
+* *gorillib/hash/reverse_merge*   reverse_merge, reverse_merge!
+* *gorillib/hash/tree_merge*      tree_merge, tree_merge!
+* *gorillib/hash/slice*           slice, slice!, extract!
+* *gorillib/hash/zip*             Hash.zip
+
+* Receiver
+
+
+===========================================================================
+===========================================================================
+
+
+?>   [  :store, :delete, :keys, :each, :each_key, :each_value, :has_key?,  :include?, :key?, :member?, :has_value?, :value?, :fetch, :length, :empty?, :to_hash, :values, :values_at, :merge, :update, :key, :invert, :reject!, :select!, :delete_if, :keep_if, :reject, :clear, :assoc, :rassoc].each{|m| puts `ri 'Hash##{m}'` }
+

data/notes/hash_rdocs.textile

@@ -0,0 +1,97 @@
+
+# == Hashlike ==
+#
+# == ActsAsHash ==
+#
+# Uses accessors and instance variables to provide
+# * :[key]        calls the getter <tt>send(key)</tt>
+# * :[key]= val   calls the setter <tt>send("key=", val)</tt>
+# * :delete       removes the instance variable, calls unset!
+# * :keys         all instance variables
+#
+# == Hashlike::Slice        ==
+# == Hashlike::Keys         ==
+# == Hashlike::Compact      ==
+# == Hashlike::DeepCompact  ==
+# == Hashlike::DeepMerge    ==
+# == Hashlike::TreeMerge    ==
+# == Hashlike::ReverseMerge ==
+# == Hashlike::Zip          ==
+# == Hashlike::DeepKeys     ==
+
+
+# Hashlike#each
+
+
+# Hashlike#each_key
+
+
+# Hashlike#each_value
+
+
+# Hashlike#has_key?
+
+
+# Hashlike#include?
+# Hashlike#key?
+# Hashlike#member?
+
+# Hashlike#has_value?
+# Hashlike#value?
+
+
+# Hashlike#fetch
+
+
+# Hashlike#length
+
+
+# Hashlike#empty?
+
+
+# Hashlike#to_hash
+
+
+# Hashlike#values
+
+
+# Hashlike#values_at
+
+
+# Hashlike#key
+
+
+# Hashlike#invert
+
+
+# Hashlike#delete_if
+
+
+# Hashlike#reject!
+
+
+# Hashlike#reject
+
+
+# Hashlike#keep_if
+
+
+# Hashlike#select!
+
+
+# Hashlike#clear
+
+
+# Hashlike#assoc
+
+
+# Hashlike#rassoc
+
+
+# Hashlike#flatten
+
+
+# Hashlike#update
+
+
+# Hashlike#merge