icss 0.0.2 → 0.0.4

data/.rspec

@@ -1,3 +1 @@
 --color
---format documentation
---drb

data/Gemfile

@@ -4,7 +4,7 @@ source "http://rubygems.org"
 #   gem "activesupport", ">= 2.3.5"
 
 gem   'yajl-ruby', "~> 0.8.2"
-gem   'gorillib',  "~> 0.0.7"
+gem   'gorillib',  "~> 0.0.4"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.

data/Gemfile.lock

@@ -26,7 +26,7 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.0.0)
-  gorillib (~> 0.0.7)
+  gorillib (~> 0.0.4)
   jeweler (~> 1.5.2)
   rcov
   rspec (~> 2.3.0)

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.4

data/icss.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{icss}
-  s.version = "0.0.2"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Philip (flip) Kromer for Infochimps"]
@@ -19,8 +19,6 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
     ".rspec",
-    ".watchr",
-    "CHANGELOG.textile",
     "Gemfile",
     "Gemfile.lock",
     "LICENSE.textile",
@@ -46,12 +44,16 @@ Gem::Specification.new do |s|
     "lib/icss.rb",
     "lib/icss/brevity.rb",
     "lib/icss/code_asset.rb",
-    "lib/icss/core_ext.rb",
     "lib/icss/data_asset.rb",
     "lib/icss/message.rb",
     "lib/icss/old.rb",
     "lib/icss/protocol.rb",
     "lib/icss/protocol_set.rb",
+    "lib/icss/receiver.rb",
+    "lib/icss/receiver/acts_as_hash.rb",
+    "lib/icss/receiver/acts_as_loadable.rb",
+    "lib/icss/receiver/tree_diff.rb",
+    "lib/icss/receiver/validations.rb",
     "lib/icss/sample_message_call.rb",
     "lib/icss/target.rb",
     "lib/icss/type.rb",
@@ -64,7 +66,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/mrflip/icss}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.7.2}
+  s.rubygems_version = %q{1.5.0}
   s.summary = %q{Infochimps Stupid Schema library: an avro-compatible data description standard. ICSS completely describes a collection of data (and associated assets) in a way that is expressive, scalable and sufficient to drive remarkably complex downstream processes.}
   s.test_files = [
     "spec/icss_spec.rb",
@@ -76,7 +78,7 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<yajl-ruby>, ["~> 0.8.2"])
-      s.add_runtime_dependency(%q<gorillib>, ["~> 0.0.7"])
+      s.add_runtime_dependency(%q<gorillib>, ["~> 0.0.4"])
       s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
       s.add_development_dependency(%q<yard>, ["~> 0.6.0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
@@ -84,7 +86,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<rcov>, [">= 0"])
     else
       s.add_dependency(%q<yajl-ruby>, ["~> 0.8.2"])
-      s.add_dependency(%q<gorillib>, ["~> 0.0.7"])
+      s.add_dependency(%q<gorillib>, ["~> 0.0.4"])
       s.add_dependency(%q<rspec>, ["~> 2.3.0"])
       s.add_dependency(%q<yard>, ["~> 0.6.0"])
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
@@ -93,7 +95,7 @@ Gem::Specification.new do |s|
     end
   else
     s.add_dependency(%q<yajl-ruby>, ["~> 0.8.2"])
-    s.add_dependency(%q<gorillib>, ["~> 0.0.7"])
+    s.add_dependency(%q<gorillib>, ["~> 0.0.4"])
     s.add_dependency(%q<rspec>, ["~> 2.3.0"])
     s.add_dependency(%q<yard>, ["~> 0.6.0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])

data/lib/icss/protocol.rb

@@ -105,7 +105,7 @@ module Icss
 
     def receive_targets hsh
       self.targets = hsh.inject({}) do |target_obj_hsh, (target_name, target_info_list)|
-        target_obj_hsh[target_name] = TargetListFactory.receive(target_info_list, target_name) # returns an arry of targets
+        target_obj_hsh[target_name] = TargetListFactory.receive(target_name, target_info_list) # returns an arry of targets
         target_obj_hsh
       end
     end

data/lib/icss/receiver/acts_as_hash.rb

@@ -0,0 +1,436 @@
+module Receiver
+
+  #
+  # 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
+  #
+  # All methods are defined naturally on [], []= and has_key? -- if you enjoy
+  #
+  #
+  # in addition to the below, by including Enumerable, this also adds
+  #
+  #    #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=, shift
+  #   length, size, empty?, flatten, replace, keep_if, key(value)
+  #   compare_by_identity compare_by_identity? rehash, select!
+  #
+  #   assoc rassoc
+  #
+  module ActsAsHash
+
+    # Fake hash reader semantics: delegates to self.send(key)
+    #
+    # Note: indifferent access -- either of :foo or "foo" will work
+    #
+    def [](name)
+      self.send(name) if keys.include?(name.to_sym)
+    end
+
+    # Fake hash writer semantics: delegates to self.send("key=", val)
+    #
+    # NOTE: this calls self.foo= 5, not self.receive_foo(5)
+    # NOTE: indifferent access -- either of :foo or "foo" will work
+    #
+    def []=(name, val)
+      self.send("#{name}=", val) if keys.include?(name)
+    end
+    alias_method(:store, :[]=)
+
+    # @param key<Object> The key to check for.
+    #
+    # @return [Boolean] True if
+    #   * the attribute is one of this object's keys, and
+    #   * its value is non-nil OR the corresponding instance_variable is defined.
+    #
+    # For attributes that are virtual accessors, if its value is explicitly set
+    # to nil then has_key? is true.
+    #
+    # @example
+    #    class Foo
+    #      include Receiver
+    #      include Receiver::ActsAsHash
+    #      rcvr_accessor :a, Integer
+    #      rcvr_accessor :b, String
+    #    end
+    #    foo = Foo.receive({:a => 1})
+    #    foo.has_key?(:b)               # false
+    #    foo[:b]                        # nil
+    #    foo.b = nil
+    #    foo.has_key?(:b)               # true
+    #    foo[:b]                        # nil
+    #
+    def has_key?(key)
+      keys.include?(key) && ((not self[key].nil?) || attr_set?(key))
+    end
+
+    # @param key<Object> The key to remove
+    #
+    # @return [Object]
+    #   returns the value of the given attribute, and sets its new value to nil.
+    #   If there is a corresponding instance_variable, it is subsequently removed.
+    def delete(key)
+      val = self[key]
+      self[key]= nil
+      unset!(key)
+      val
+    end
+
+    #
+    # Convert to a hash
+    #
+    # Each key in #keys becomes an element in the new array if the value of its
+    # attribute is non-nil OR the corresponding instance_variable is defined.
+    def to_hash
+      keys.inject({}) do |hsh, key|
+        val = self[key]
+        hsh[key] = val if (val || self.instance_variable_defined?("@#{key}"))
+        hsh
+      end
+    end
+
+    module ClassMethods
+      # By default, the hashlike methods iterate over the receiver attributes.
+      # If you want to filter our add to the keys list, override this method
+      #
+      # @example
+      #     def self.keys
+      #       super + [:firstname, :lastname] - [:fullname]
+      #     end
+      #
+      def keys
+        receiver_attr_names
+      end
+    end
+
+    # ===========================================================================
+    #
+    # The below methods are natural extensions of the above
+    #
+
+    # delegates to the class method. Typically you'll want to override that one,
+    # not the instance keys
+    def keys
+      self.class.keys
+    end
+
+    # Returns an array consisting of the value for each attribute in
+    # #keys, guaranteed in same order
+    def values
+      values_at *keys
+    end unless method_defined?(:values)
+
+    # Returns an array consisting of the value for each attribute in
+    # allowed_keys, guaranteed in same order
+    def values_at *allowed_keys
+      allowed_keys.map do |k|
+        self[k]
+      end
+    end
+
+    # a nested array of [ key, value ] pairs. Delegates to to_hash.to_a
+    def to_a
+      to_hash.to_a
+    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
+
+    #
+    # Return a Hash containing only values for the given keys where self.has_key?(k)
+    #
+    def slice *allowed_keys
+      allowed_keys.inject({}){|h,k| h[k] = self[k] if self.has_key?(k) ; h }
+    end
+
+    # Calls block once for each key in #keys in order, passing the key and value as parameters.
+    def each &block
+      keys.each do |key|
+        yield(key, self[key])
+      end
+    end
+    alias_method :each_pair, :each
+
+    # Calls block once for each key in #keys in order, passing the key as parameter.
+    def each_key &block
+      keys.each(&block)
+    end
+
+    # Calls block once for each key in #keys in order, passing the value as parameter.
+    def each_value &block
+      keys.each do |key|
+        yield self[key]
+      end
+    end
+
+    #
+    # Analogous to Hash#merge: returns a duplicate of self where for each
+    # element of self.keys, adopts the corresponding element of hsh if that key
+    # is set in hsh.
+    #
+    # Returns a duplicate of self, but adopting the corresponding element of hsh
+    # if that key is set in hsh. Only keys in self.keys are candidates for merging.
+    #
+    # With no block parameter, overwrites entries in hsh with duplicate keys
+    # with those from other_hash.
+    #
+    # The block parameter semantics aren't implemented yet. If a block is
+    # specified, it is called with each duplicate key and the values from the
+    # two hashes. The value returned by the block is stored in the new hash.
+    #
+    # @example
+    #   h1 = { "a" => 100, "b" => 200 }
+    #   h2 = { "b" => 254, "c" => 300 }
+    #   h1.merge(h2)                 -> {"a"=>100, "b"=>254, "c"=>300}
+    #   h1.merge(h2){|k,o,n| o}      -> {"a"=>100, "b"=>200, "c"=>300}
+    #   h1                           -> {"a"=>100, "b"=>200}
+    #
+    def merge *args, &block
+      self.dup.merge!(*args, &block)
+    end
+
+    # For all keys that are in self.keys *and* other_hash.has_key?(key),
+    # sets the value to that from other_hash
+    #
+    def update other_hash, &block
+      raise "can't handle block arg yet" if block
+      keys.each do |key|
+        self[key] = other_hash[key] if other_hash.has_key?(key)
+      end
+      self
+    end
+    alias_method :merge!, :update
+
+    # # Returns a new hash with +self+ and +other_hash+ merged recursively.
+    # def deep_merge(other_hash)
+    #   dup.deep_merge!(other_hash)
+    # end
+
+    # Recursively merges using receive
+    #
+    # Modifies the full receiver chain in-place.
+    #
+    # For each key in keys,
+    # * if self's value is nil, receive the attribute.
+    # * if self's attribute is an Array, append to it.
+    # * if self's value responds to tree_merge!, tree merge it.
+    # * if self's value responds_to merge!, merge! it.
+    # * otherwise, receive the value from other_hash
+    #
+    def tree_merge!(other_hash)
+      keys.each do |key|
+        # get other's val if any
+        if    other_hash.has_key?(key.to_sym) then other_val = other_hash[key.to_sym]
+        elsif other_hash.has_key?(key.to_s)   then other_val = other_hash[key.to_s]
+        else  next ; end
+        #
+        self_val  = self[key]
+        # p ['receiver tree_merge', key, self_val.respond_to?(:tree_merge!), self[key], other_val]
+        case
+        when other_val.nil?                     then next
+        when (not has_key?(key))                then _receive_attr(key, other_val)
+        when receiver_attrs[key][:merge_as] == :hash_of_arrays
+          self_val.merge!(other_val) do |k, v1, v2| case when v1.blank? then v2 when v2.blank? then v1 else v1 + v2 end end
+        when self_val.is_a?(Array)              then self[key] += other_val
+        when self_val.respond_to?(:tree_merge!) then self[key] = self_val.tree_merge!(other_val)
+        when self_val.respond_to?(:merge!)      then self[key] = self_val.merge!(other_val)
+        else                                         _receive_attr(key, other_val)
+        end
+      end
+      run_after_receivers(other_hash)
+      self
+    end
+
+    # Searches the hash for an entry whose value == value, returning the
+    # corresponding key. If multiple entries has this value, the key returned
+    # will be that on one of the entries. If not found,returns nil.
+    #
+    # You are guaranteed that the first matching key in #keys will be the one
+    # returned.
+    #
+    # @example
+    #   foo = Foo.receive( "a" => 100, "b" => 200, "c" => 100 )
+    #   foo.index(100) -> "a"
+    #   foo.index(999) -> nil
+    #
+    def index val
+      keys.find{|key| self[key] == val }
+    end
+
+    # Returns a new hash created by using inverting self.to_hash. If this new
+    # hash has duplicate values, the result will contain only one of them as a
+    # key -- which one is not predictable.
+    def invert
+      to_hash.invert
+    end
+
+    # Returns true if the given value is present for some attribute in #keys
+    def has_value? val
+      !! index(val)
+    end
+    alias_method :value?, :has_value?
+
+    # def include? def key? def member?
+    alias_method :include?, :has_key?
+    alias_method :key?,     :has_key?
+    alias_method :member?,  :has_key?
+
+    # Deletes every attribute for which block is true.
+    # Returns nil if no changes were made, self otherwise.
+    def reject!(&block)
+      changed = false
+      each do |key, val|
+        if yield(key, val)
+          changed = true
+          delete(key)
+        end
+      end
+      changed ? self : nil
+    end
+
+    # Deletes every attribute for which block is true.
+    # Similar to reject! but returns self.
+    def delete_if(&block)
+      reject!(&block)
+      self
+    end
+
+    # Deletes every attribute for which block is true.
+    # Equivalent to self.dup.delete_if.
+    def reject(&block)
+      self.dup.delete_if(&block)
+    end
+
+    # deletes all attributes
+    def clear
+      each_key{|k| delete(k) }
+    end
+
+    # delete all attributes where the value is blank?, and return self. Contrast with compact!
+    def compact_blank!
+      delete_if{|k,v| v.blank? }
+    end
+    # delete all attributes where the value is nil?, and return self. Contrast with compact_blank!
+    def compact!
+      delete_if{|k,v| v.nil? }
+    end
+    # returns a hash with key/value pairs having nil? values removed
+    def compact
+      to_hash.delete_if{|k,v| v.nil? }
+    end
+    # returns a hash with key/value pairs having blank? values removed
+    def compact_blank
+      to_hash.delete_if{|k,v| v.blank? }
+    end
+
+    def self.included base
+      base.class_eval do
+        extend  ClassMethods
+        include Enumerable
+      end
+    end
+
+    #
+    # Not yet implemented
+    #
+
+    # # Returns true if has_key? is false for all attributes in #keys
+    # def empty?
+    #   keys.all?{|key| not has_key?(key) }
+    # end
+    #
+    # # The number of keys where #has_key is true
+    # def length
+    #   keys.select{|key| has_key?(key) }.length
+    # end
+    # alias_method :size, :length
+
+    # # @param key<Object> The key to fetch.
+    # # @param *extras<Array> Default value.
+    # #
+    # # Returns a value for the given key. If the object doesn't has_key?(key),
+    # # several options exist:
+    # #
+    # # * With no other arguments, it will raise an IndexError exception;
+    # # * if default is given, then that will be returned;
+    # # * if the optional code block is specified, then that will be run and its
+    # #   result returned.
+    # #
+    # # fetch does not evaluate any default values supplied when
+    # # the hash was created -- it only looks for keys in the hash.
+    # #
+    # # @return [Object] The value at key or the default value.
+    # def fetch(key, default=nil, &block)
+    #   raise ""
+    # end
+
+
+  end
+end
+
+
+class Hash
+
+    # Recursively merges using receive
+    #
+    # Modifies the full receiver chain in-place.
+    #
+    # For each key in keys,
+    # * if self's value is nil, receive the attribute.
+    # * if self's attribute is an Array, append to it.
+    # * if self's value responds to tree_merge!, deep merge it.
+    # * if self's value responds_to merge!, merge! it.
+    # * otherwise, receive the value from other_hash
+    #
+    def tree_merge!(other_hash)
+      [self.keys, other_hash.keys].flatten.uniq.each do |key|
+        # get other's val if any
+        if    other_hash.has_key?(key.to_sym) then other_val = other_hash[key.to_sym]
+        elsif other_hash.has_key?(key.to_s)   then other_val = other_hash[key.to_s]
+        else  next ; end
+        #
+        self_val  = self[key]
+        # p ['hash tree_merge', key, self_val.respond_to?(:tree_merge!), self_val, other_val]
+        case
+        when other_val.nil?                     then next
+        when (not has_key?(key))                then self[key] = other_val
+        when self_val.is_a?(Array)              then self[key] += other_val
+        when self_val.respond_to?(:tree_merge!) then self[key] = self_val.tree_merge!(other_val)
+        when self_val.respond_to?(:merge!)      then self[key] = self_val.merge!(other_val)
+        else                                         self[key] = other_val
+        end
+      end
+      self
+    end
+
+    def compact_blank!
+      reject!{|k,v| v.blank? } ; self
+    end
+
+end

data/lib/icss/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/icss/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/icss/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/icss/receiver.rb

@@ -0,0 +1,289 @@
+require 'active_support/core_ext/class'
+require 'time'
+require 'icss/receiver/validations'
+
+# dummy type for receiving True or False
+class Boolean ; end unless defined?(Boolean)
+
+# Receiver lets you describe complex (even recursive!) actively-typed data models that
+# * are creatable or assignable from static data structures
+# * perform efficient type conversion when assigning from a data structure,
+# * but with nothing in the way of normal assignment or instantiation
+# * and no requirements on the initializer
+#
+#    class Tweet
+#      include Receiver
+#      rcvr_accessor :id,           Integer
+#      rcvr_accessor :user_id,      Integer
+#      rcvr_accessor :created_at,   Time
+#    end
+#    p Tweet.receive(:id => "7", :user_id => 9, :created_at => "20101231010203" )
+#     # => #<Tweet @id=7, @user_id=9, @created_at=2010-12-31 07:02:03 UTC>
+#
+# You can override receive behavior in a straightforward and predictable way:
+#
+#    class TwitterUser
+#      include Receiver
+#      rcvr_accessor :id,           Integer
+#      rcvr_accessor :screen_name,  String
+#      rcvr_accessor :follower_ids, Array, :of => Integer
+#      # accumulate unique follower ids
+#      def receive_follower_ids(arr)
+#        @follower_ids = (@follower_ids||[]) + arr.map(&:to_i)
+#        @follower_ids.uniq!
+#      end
+#    end
+#
+# The receiver pattern works naturally with inheritance:
+#
+#    class TweetWithUser < Tweet
+#      rcvr_accessor :user, TwitterUser
+#      after_receive do |hsh|
+#        self.user_id = self.user.id if self.user
+#      end
+#    end
+#    p TweetWithUser.receive(:id => 8675309, :created_at => "20101231010203", :user => { :id => 24601, :screen_name => 'bob', :follower_ids => [1, 8, 3, 4] })
+#     => #<TweetWithUser @id=8675309, @created_at=2010-12-31 07:02:03 UTC, @user=#<TwitterUser @id=24601, @screen_name="bob", @follower_ids=[1, 8, 3, 4]>, @user_id=24601>
+#
+# TweetWithUser was able to add another receiver, applicable only to itself and its subclasses.
+#
+# The receive method works well with sparse data -- you can accumulate
+# attributes without trampling formerly set values:
+#
+#    tw = Tweet.receive(:id => "7", :user_id => 9 )
+#    p tw
+#    # => #<Tweet @id=7, @user_id=9>
+#
+#    tw.receive!(:created_at => "20101231010203" )
+#    p tw
+#    # => #<Tweet @id=7, @user_id=9, @created_at=2010-12-31 07:02:03 UTC>
+#
+# Note the distinction between an explicit nil field and a missing field:
+#
+#    tw.receive!(:user_id => nil, :created_at => "20090506070809" )
+#    p tw
+#    # => #<Tweet @id=7, @user_id=nil, @created_at=2009-05-06 12:08:09 UTC>
+#
+# There are helpers for default and required attributes:
+#
+#    class Foo
+#      include Receiver
+#      rcvr_accessor :is_reqd,     String, :required => true
+#      rcvr_accessor :also_reqd,   String, :required => true
+#      rcvr_accessor :has_default, String, :default => 'hello'
+#    end
+#    foo_obj = Foo.receive(:is_reqd => "hi")
+#    # => #<Foo:0x00000100bd9740 @is_reqd="hi" @has_default="hello">
+#    foo_obj.missing_attrs
+#    # => [:also_reqd]
+#
+module Receiver
+
+  RECEIVER_BODIES           = {} unless defined?(RECEIVER_BODIES)
+  RECEIVER_BODIES[Symbol]   = %q{ v.nil? ? nil : v.to_sym }
+  RECEIVER_BODIES[String]   = %q{ v.to_s }
+  RECEIVER_BODIES[Integer]  = %q{ v.nil? ? nil : v.to_i }
+  RECEIVER_BODIES[Float]    = %q{ v.nil? ? nil : v.to_f }
+  RECEIVER_BODIES[Time]     = %q{ v.nil? ? nil : Time.parse(v.to_s).utc }
+  RECEIVER_BODIES[Date]     = %q{ v.nil? ? nil : Date.parse(v.to_s) }
+  RECEIVER_BODIES[Array]    = %q{ v.nil? ? nil : v }
+  RECEIVER_BODIES[Hash]     = %q{ v.nil? ? nil : v }
+  RECEIVER_BODIES[Boolean]  = %q{ v.nil? ? nil : (v.to_s.strip != "false") }
+  RECEIVER_BODIES[NilClass] = %q{ raise "This field must be nil, but #{v} was given" unless (v.nil?) ; nil }
+  RECEIVER_BODIES[Object]   = %q{ v } # accept and love the object just as it is
+  RECEIVER_BODIES.each do |k,b|
+    if k.is_a?(Class)
+      k.class_eval <<-STR, __FILE__, __LINE__ + 1
+      def self.receive(v)
+        #{b}
+      end
+      STR
+    end
+  end
+
+  TYPE_ALIASES = {
+    :null    => NilClass,
+    :boolean => Boolean,
+    :string  => String,  :bytes   => String,
+    :symbol  => Symbol,
+    :int     => Integer, :integer => Integer,  :long    => Integer,
+    :time    => Time,    :date    => Date,
+    :float   => Float,   :double  => Float,
+    :hash    => Hash,    :map     => Hash,
+    :array   => Array,
+  } unless defined?(TYPE_ALIASES)
+
+  #
+  # modify object in place with new typecast values.
+  #
+  def receive! hsh
+    raise "Can't receive (it isn't hashlike): #{hsh.inspect}" unless hsh.respond_to?(:[])
+    self.class.receiver_attr_names.each do |attr|
+      if    hsh.has_key?(attr.to_sym) then val = hsh[attr.to_sym]
+      elsif hsh.has_key?(attr.to_s)   then val = hsh[attr.to_s]
+      else  next ; end
+      _receive_attr attr, val
+    end
+    impose_defaults!(hsh)
+    run_after_receivers(hsh)
+    self
+  end
+
+  def unset!(attr)
+    self.send(:remove_instance_variable, "@#{attr}") if self.instance_variable_defined?("@#{attr}")
+  end
+
+  # true if the attr is a receiver variable and it has been set
+  def attr_set?(attr)
+    receiver_attrs.has_key?(attr) && self.instance_variable_defined?("@#{attr}")
+  end
+
+  protected
+  def _receive_attr attr, val
+    self.send("receive_#{attr}", val)
+  end
+
+  def impose_defaults!(hsh)
+    self.class.receiver_defaults.each do |attr, val|
+      next if attr_set?(attr)
+      self.instance_variable_set "@#{attr}", val
+    end
+  end
+
+  def run_after_receivers(hsh)
+    self.class.after_receivers.each do |after_receiver|
+      self.instance_exec(hsh, &after_receiver)
+    end
+  end
+  public
+
+  module ClassMethods
+
+    #
+    # Returns a new instance with the given hash used to set all rcvrs.
+    #
+    # All args after the first are passed to the initializer.
+    #
+    def receive hsh, *args
+      hsh ||= {}
+      obj = self.new(*args)
+      obj.receive!(hsh)
+    end
+
+    #
+    # define a receiver attribute.
+    # automatically generates an attr_accessor on the class if none exists
+    #
+    # @option [Boolean] :required - Adds an error on validation if the attribute is never set
+    # @option [Object]  :default  - After any receive! operation, attribute is set to this value unless attr_set? is true
+    # @option [Class]   :of       - For collections (Array, Hash, etc), the type of the collection's items
+    #
+    def rcvr name, type, info={}
+      name = name.to_sym
+      type = type_to_klass(type)
+      class_eval  <<-STR, __FILE__, __LINE__ + 1
+        def receive_#{name}(v)
+          self.#{name} = #{receiver_body_for(type, info)}
+        end
+      STR
+      receiver_attr_names << name unless receiver_attr_names.include?(name)
+      receiver_attrs[name] = info.merge({ :name => name, :type => type })
+    end
+
+    def after_receive &block
+      self.after_receivers << block
+    end
+
+    def type_to_klass(type)
+      case
+      when type.is_a?(Class)                             then return type
+      when TYPE_ALIASES.has_key?(type)                   then TYPE_ALIASES[type]
+      # when (type.is_a?(Symbol) && type.to_s =~ /^[A-Z]/) then type.to_s.constantize
+      else raise "Can\'t handle type #{type}: is it a Class or one of the TYPE_ALIASES? "
+      end
+    end
+
+    # defines a receiver attribute, an attr_reader and an attr_writer
+    # attr_reader is skipped if the getter method is already defined;
+    # attr_writer is skipped if the setter method is already defined;
+    def rcvr_accessor name, type, info={}
+      attr_reader(name) unless method_defined?(name)
+      attr_writer(name) unless method_defined?("#{name}=")
+      rcvr name, type, info
+    end
+    # defines a receiver attribute and an attr_reader
+    # attr_reader is skipped if the getter method is already defined.
+    def rcvr_reader name, type, info={}
+      attr_reader(name) unless method_defined?(name)
+      rcvr name, type, info
+    end
+    # defines a receiver attribute and an attr_writer
+    # attr_writer is skipped if the setter method is already defined.
+    def rcvr_writer name, type, info={}
+      attr_writer(name) unless method_defined?("#{name}=")
+      rcvr name, type, info
+    end
+
+    #
+    # Defines a receiver for attributes sent to receive! that are
+    # * not defined as receivers
+    # * attribute name does not start with '_'
+    #
+    # @example
+    #     class Foo ; include Receiver
+    #       rcvr_accessor  :bob, String
+    #       rcvr_remaining :other_params
+    #     end
+    #     foo_obj = Foo.receive(:bob => 'hi, bob", :joe => 'hi, joe')
+    #     # => <Foo @bob='hi, bob' @other_params={ :joe => 'hi, joe' }>
+    def rcvr_remaining name, info={}
+      rcvr_reader name, Hash, info
+      after_receive do |hsh|
+        remaining_vals_hsh = hsh.except(* keys).reject!{|k,v| k.to_s =~ /^_/}
+        self._receive_attr name, remaining_vals_hsh
+      end
+    end
+
+    # a hash from attribute names to their default values if given
+    def receiver_defaults
+      defs = {}
+      receiver_attrs.each do |name, info|
+        defs[name] = info[:default] if info.has_key?(:default)
+      end
+      defs
+    end
+
+  private
+    def receiver_body_for type, info
+      type = type_to_klass(type)
+      # Note that Array and Hash only need (and only get) special treatment when
+      # they have an :of => SomeType option.
+      case
+      when info[:of] && (type == Array)
+        %Q{ v.nil? ? nil : v.map{|el| #{info[:of]}.receive(el) } }
+      when info[:of] && (type == Hash)
+        %Q{ v.nil? ? nil : v.inject({}){|h, (el,val)| h[el] = #{info[:of]}.receive(val); h } }
+      when Receiver::RECEIVER_BODIES.include?(type)
+        Receiver::RECEIVER_BODIES[type]
+      when type.is_a?(Class)
+        %Q{v.blank? ? nil : #{type}.receive(v) }
+      # when (type.is_a?(Symbol) && type.to_s =~ /^[A-Z]/)
+      #   # a hack so you can use a class not defined yet
+      #   %Q{v.blank? ? nil : #{type}.receive(v) }
+      else
+        raise("Can't receive #{type} #{info}")
+      end
+    end
+  end
+
+  # set up receiver attributes, and bring in methods from the ClassMethods module at class-level
+  def self.included base
+    base.class_eval do
+      class_inheritable_accessor :receiver_attrs, :receiver_attr_names, :after_receivers
+      self.receiver_attrs      = {} # info about the attr
+      self.receiver_attr_names = [] # ordered set of attr names
+      self.after_receivers     = [] # blocks to execute following receive!
+      extend ClassMethods
+    end
+  end
+end

data/lib/icss/type.rb

@@ -128,7 +128,7 @@ module Icss
     rcvr_accessor :namespace, String
     attr_accessor :parent
     # the avro base type name
-    class_attribute :type
+    class_inheritable_accessor :type
     include Icss::Validations
 
     # In named types, the namespace and name are determined in one of the following ways:
@@ -385,8 +385,7 @@ module Icss
   # (do not confuse with EnumType, which is not an EnumerableType. sigh).
   #
   class EnumerableType < Type
-    class_attribute :type
-    class_attribute :ruby_klass
+    class_inheritable_accessor :type, :ruby_klass
     def to_hash
       super.merge( :type => type.to_s )
     end
@@ -489,7 +488,7 @@ module Icss
   #
   class FixedType < NamedType
     rcvr_accessor :size, Integer, :required => true
-    class_attribute :ruby_klass
+    class_inheritable_accessor :ruby_klass
     self.type = :fixed
     self.ruby_klass = String
 

data/lib/icss.rb

@@ -1,12 +1,12 @@
-require 'icss/core_ext' unless Object.respond_to?(:class_attribute)
-
-require 'gorillib/receiver'
-require 'gorillib/receiver/acts_as_hash'
-require 'gorillib/receiver/acts_as_loadable'
-require 'gorillib/receiver/validations'
-require 'time' # ain't that always the way
+require 'active_support/inflector' # for classify and constantize
+require 'active_support/core_ext/hash/keys'
+# require 'active_support/core_ext/hash/deep_merge'
 
 $: << File.dirname(__FILE__)
+require 'icss/receiver'
+require 'icss/receiver/acts_as_hash'
+require 'icss/receiver/acts_as_loadable'
+#
 require 'icss/validations'
 require 'icss/type'
 require 'icss/message'

data/spec/spec_helper.rb

@@ -1,31 +1,12 @@
-require 'spork'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
+require 'icss'
 
-Spork.prefork do
-  # This code is run only once when the spork server is started
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
-  ENV["RACK_ENV"] ||= 'test'
-  RACK_ENV = ENV["RACK_ENV"] unless defined?(RACK_ENV)
-
-  require File.join(File.dirname(__FILE__), '../lib/boot')
-  $LOAD_PATH.unshift(File.dirname(__FILE__))
-
-  require 'goliath'
-  require 'em-synchrony'
-  require 'goliath/test_helper'
-  require 'support/test_helper'
-
-  # Requires custom matchers & macros, etc from files in ./support/ & subdirs
-  Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
-
-  # Configure rspec
-  RSpec.configure do |config|
-    config.include Goliath::TestHelper, :example_group => {
-      :file_path => /spec/
-    }
-  end
-end
-
-Spork.each_run do
-  # This code will be run each time you run your specs.
+RSpec.configure do |config|
+  
 end

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: icss
 version: !ruby/object:Gem::Version 
-  hash: 27
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 2
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors: 
 - Philip (flip) Kromer for Infochimps
@@ -15,118 +10,86 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-07 00:00:00 Z
+date: 2011-06-07 00:00:00 -07:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  prerelease: false
   name: yajl-ruby
-  type: :runtime
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 59
-        segments: 
-        - 0
-        - 8
-        - 2
         version: 0.8.2
-  requirement: *id001
-- !ruby/object:Gem::Dependency 
+  type: :runtime
   prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: gorillib
-  type: :runtime
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 17
-        segments: 
-        - 0
-        - 0
-        - 7
-        version: 0.0.7
-  requirement: *id002
-- !ruby/object:Gem::Dependency 
+        version: 0.0.4
+  type: :runtime
   prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 2
-        - 3
-        - 0
         version: 2.3.0
-  requirement: *id003
-- !ruby/object:Gem::Dependency 
+  type: :development
   prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: yard
-  type: :development
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 0
-        - 6
-        - 0
         version: 0.6.0
-  requirement: *id004
-- !ruby/object:Gem::Dependency 
+  type: :development
   prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
   name: bundler
-  type: :development
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 0
-        - 0
         version: 1.0.0
-  requirement: *id005
-- !ruby/object:Gem::Dependency 
+  type: :development
   prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
   name: jeweler
-  type: :development
-  version_requirements: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 1
-        - 5
-        - 2
         version: 1.5.2
-  requirement: *id006
-- !ruby/object:Gem::Dependency 
+  type: :development
   prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
   name: rcov
-  type: :development
-  version_requirements: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
-  requirement: *id007
+  type: :development
+  prerelease: false
+  version_requirements: *id007
 description: "Infochimps Stupid Schema library: an avro-compatible data description standard. ICSS completely describes a collection of data (and associated assets) in a way that is expressive, scalable and sufficient to drive remarkably complex downstream processes."
 email: coders@infochimps.com
 executables: []
@@ -139,8 +102,6 @@ extra_rdoc_files:
 files: 
 - .document
 - .rspec
-- .watchr
-- CHANGELOG.textile
 - Gemfile
 - Gemfile.lock
 - LICENSE.textile
@@ -166,12 +127,16 @@ files:
 - lib/icss.rb
 - lib/icss/brevity.rb
 - lib/icss/code_asset.rb
-- lib/icss/core_ext.rb
 - lib/icss/data_asset.rb
 - lib/icss/message.rb
 - lib/icss/old.rb
 - lib/icss/protocol.rb
 - lib/icss/protocol_set.rb
+- lib/icss/receiver.rb
+- lib/icss/receiver/acts_as_hash.rb
+- lib/icss/receiver/acts_as_loadable.rb
+- lib/icss/receiver/tree_diff.rb
+- lib/icss/receiver/validations.rb
 - lib/icss/sample_message_call.rb
 - lib/icss/target.rb
 - lib/icss/type.rb
@@ -180,6 +145,7 @@ files:
 - lib/icss/view_helper.rb
 - spec/icss_spec.rb
 - spec/spec_helper.rb
+has_rdoc: true
 homepage: http://github.com/mrflip/icss
 licenses: 
 - MIT
@@ -193,7 +159,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: -803655258578775756
       segments: 
       - 0
       version: "0"
@@ -202,14 +168,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
 summary: "Infochimps Stupid Schema library: an avro-compatible data description standard. ICSS completely describes a collection of data (and associated assets) in a way that is expressive, scalable and sufficient to drive remarkably complex downstream processes."

data/.watchr

@@ -1,20 +0,0 @@
-# -*- ruby -*-
-
-def run_spec(file)
-  unless File.exist?(file)
-    puts "#{file} does not exist"
-    return
-  end
-
-  puts   "Running #{file}"
-  system "bundle exec rspec #{file}"
-  puts
-end
-
-watch("spec/.*/*_spec\.rb") do |match|
-  run_spec match[0]
-end
-
-watch("app/(.*)\.rb") do |match|
-  run_spec %{spec/#{match[1]}_spec.rb}
-end

data/CHANGELOG.textile

@@ -1,8 +0,0 @@
-
-
-h3. v0.0.3 May 22ish
-
-* used gorillib, got rid of active_support, extlib HOORAY
-* moved Receiver to gorillib.
-* *breaking change*. Gorillib changed the signature of receive() to be @receive(*constructor_args, hsh)@ (formerly, the hsh was first).
-* 

data/lib/icss/core_ext.rb

@@ -1,4 +0,0 @@
-require 'gorillib/string/inflections'
-require 'gorillib/string/constantize'
-require 'gorillib/hash/keys'
-require 'gorillib/metaprogramming/class_attribute'