gorillib 0.0.8 → 0.1.0

data/lib/gorillib/hashlike/tree_merge.rb

@@ -0,0 +1,76 @@
+module Gorillib
+  module Hashlike
+    module TreeMerge
+
+      # 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
+
+    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
+end

data/lib/gorillib/metaprogramming/mattr_accessor.rb

@@ -57,5 +57,5 @@ class Module
     mattr_reader(*syms)
     mattr_writer(*syms)
   end unless method_defined?(:mattr_accessor)
-  
+
 end

data/lib/gorillib/receiver.rb

@@ -0,0 +1,315 @@
+# 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.blank? ? nil : v.to_sym }
+  RECEIVER_BODIES[Integer]  = %q{ v.blank? ? nil : v.to_i }
+  RECEIVER_BODIES[Float]    = %q{ v.blank? ? nil : v.to_f }
+  RECEIVER_BODIES[String]   = %q{ v.to_s }
+  RECEIVER_BODIES[Time]     = %q{ v.nil?   ? nil : Time.parse(v.to_s).utc rescue nil }
+  RECEIVER_BODIES[Date]     = %q{ v.nil?   ? nil : Date.parse(v.to_s)     rescue nil }
+  RECEIVER_BODIES[Array]    = %q{ case when v.nil? then nil when v.blank? then [] else Array(v) end }
+  RECEIVER_BODIES[Hash]     = %q{ case when v.nil? then nil when v.blank? then {} else v end }
+  RECEIVER_BODIES[Boolean]  = %q{ case when v.nil? then nil when v.to_s.strip.blank? then false else v.to_s.strip != "false" end }
+  RECEIVER_BODIES[NilClass] = %q{ raise ArgumentError, "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
+
+  #
+  # Give each base class a receive method
+  #
+  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 ArgumentError, "Can't receive (it isn't hashlike): {#{hsh.inspect}}" unless hsh.respond_to?(:[]) && hsh.respond_to?(:has_key?)
+    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
+
+  # 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 unset!(attr)
+    self.send(:remove_instance_variable, "@#{attr}") if self.instance_variable_defined?("@#{attr}")
+  end
+
+  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.
+    #
+    # @param hsh [Hash] attr-value pairs to set on the newly created object
+    # @param *args [Array] arguments to pass to the constructor
+    # @return [Object] a new instance
+    def receive *args
+      hsh = args.extract_options!
+      raise ArgumentError, "Can't receive (it isn't hashlike): {#{hsh.inspect}} -- the hsh should be the *last* arg" unless hsh.respond_to?(:[]) && hsh.respond_to?(:has_key?)
+      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)
+          v = (#{receiver_body_for(type, info)}) ;
+          self.instance_variable_set("@#{name}", v)
+        end
+      STR
+      # careful here: don't modify parent's class_attribute in-place
+      self.receiver_attrs = self.receiver_attrs.dup
+      self.receiver_attr_names += [name] unless receiver_attr_names.include?(name)
+      self.receiver_attrs[name] = info.merge({ :name => name, :type => type })
+    end
+
+    # make a block to run after each time  .receive! is invoked
+    def after_receive &block
+      self.after_receivers += [block]
+    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.reject{|k,v| (receiver_attrs.include?(k)) || (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
+
+  protected
+    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
+
+    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 ArgumentError, "Can\'t handle type #{type}: is it a Class or one of the TYPE_ALIASES?"
+      end
+    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.members
+    #       super + [:firstname, :lastname] - [:fullname]
+    #     end
+    #
+    def members
+      receiver_attr_names
+    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_attribute :receiver_attrs
+      class_attribute :receiver_attr_names
+      class_attribute :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/gorillib/receiver/active_model_shim.rb

@@ -0,0 +1,19 @@
+require 'active_model'
+
+module Receiver
+  class ActiveModelShim
+    extend ActiveModel::Naming
+
+    def to_model
+      self
+    end
+
+    def valid?()      true  end
+    def new_record?() true  end
+    def destroyed?()  false end
+
+    def errors
+      @_errors ||= ActiveModel::Errors.new(self)
+    end
+  end
+end

data/lib/gorillib/receiver/acts_as_hash.rb

@@ -0,0 +1,191 @@
+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
+  #
+  #     :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 ActsAsHash
+
+    # 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
+      members & instance_variables.map{|s| convert_key(s[1..-1]) }
+    end
+
+    def members
+      self.class.members
+    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
+
+  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
+
+    def self.included base
+      base.extend ClassMethods
+    end
+  end
+end