wukong 0.1.1

data/lib/wukong/extensions/class.rb

@@ -0,0 +1,189 @@
+#
+# This is taken in whole from the extlib gem. Thanks y'all.
+#
+
+
+# Copyright (c) 2004-2008 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Allows attributes to be shared within an inheritance hierarchy, but where
+# each descendant gets a copy of their parents' attributes, instead of just a
+# pointer to the same. This means that the child can add elements to, for
+# example, an array without those additions being shared with either their
+# parent, siblings, or children, which is unlike the regular class-level
+# attributes that are shared across the entire hierarchy.
+class Class
+  # Defines class-level and instance-level attribute reader.
+  #
+  # @param *syms<Array> Array of attributes to define reader for.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_readers
+  #
+  # @api public
+  #
+  # @todo Is this inconsistent in that it does not allow you to prevent
+  #   an instance_reader via :instance_reader => false
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      RUBY
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute writer.
+  #
+  # @param <Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_writers
+  #
+  # @api public
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      RUBY
+
+      unless options[:instance_writer] == false
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute accessor.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into accessors
+  #
+  # @api public
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def class_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if defined?(@#{ivar})
+          return nil      if self.object_id == #{self.object_id}
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil?
+          @#{ivar} = ivar.try_dup
+        end
+      RUBY
+
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+  #
+  # @api public
+  #
+  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
+  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+  def class_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:instance_writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+  #
+  # @api public
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+end
+
+
+class Fixnum
+  def try_dup
+    self
+  end
+end

data/lib/wukong/extensions/date_time.rb

@@ -0,0 +1,24 @@
+require 'time'
+DateTime.class_eval do
+  #
+  # Parses the time but never fails.
+  #
+  # A flattened time -- a 12-digit YYYYmmddHHMMMSS -- is treated as a UTC
+  # datetime.
+  #
+  def self.parse_safely dt
+    begin
+      if dt.to_s =~ /\A\d{12}Z?\z/
+        parse(dt+'Z', true)
+      else
+        parse(dt, true)
+      end
+    rescue
+      nil
+    end
+  end
+
+  def self.parse_and_flatten str
+    parse_safely(str).to_flat
+  end
+end

data/lib/wukong/extensions/emittable.rb

@@ -0,0 +1,82 @@
+
+Object.class_eval do
+  def to_flat() [to_s] end
+end
+
+module Enumerable
+  alias_method :to_flat, :to_a
+end
+
+Struct.class_eval do
+  #
+  # The last portion of the class in underscored form
+  # note memoization
+  #
+  def self.resource_name
+    @resource_name ||= self.to_s.gsub(%r{.*::}, '').underscore.to_sym
+  end
+  #
+  # Flatten for packing as resource name followed by all fields
+  #
+  def to_flat include_key=true
+    if include_key.is_a? Proc
+      sort_key = include_key.call(self)
+    elsif (! include_key.blank?) && respond_to?(:key)
+      sort_key = [self.class.resource_name, key].flatten.join("-")
+    else
+      sort_key = self.class.resource_name
+    end
+    [sort_key, *to_a] # .map(&:to_flat).flatten
+  end
+end
+
+module HashLike
+  #
+  # Flatten for packing as resource name followed by all fields
+  #
+  def to_flat include_key=true
+    if include_key.is_a? Proc
+      sort_key = include_key.call(self)
+    elsif include_key && respond_to?(:key)
+      sort_key = [self.class.resource_name, key].flatten.join("-")
+    else
+      sort_key = self.class.resource_name
+    end
+    [sort_key, *to_a] # .map(&:to_flat).flatten
+  end
+end
+
+Hash.class_eval do
+  def to_flat
+    map do |k, v|
+      [k.to_flat, v.to_flat].join(":")
+    end
+  end
+end
+
+class Time
+  # strftime() format to flatten a date
+  FLAT_FORMAT = "%Y%m%d%H%M%S"
+  # Flatten
+  def to_flat
+    strftime(FLAT_FORMAT)
+  end
+end
+
+class Date
+  # strftime() format to flatten a date
+  FLAT_FORMAT = "%Y%m%d"
+  # Flatten
+  def to_flat
+    strftime(FLAT_FORMAT)
+  end
+end
+
+class DateTime < Date
+  # strftime() format to flatten a date
+  FLAT_FORMAT = "%Y%m%d%H%M%S"
+  # Flatten
+  def to_flat
+    strftime(FLAT_FORMAT)
+  end
+end

data/lib/wukong/extensions/hash.rb

@@ -0,0 +1,120 @@
+#
+# h2. extensions/hash.rb -- hash extensions
+#
+
+require 'set'
+class Hash
+
+  # Slice a hash to include only the given keys. This is useful for
+  # limiting an options hash to valid keys before passing to a method:
+  #
+  #   def search(criteria = {})
+  #     assert_valid_keys(:mass, :velocity, :time)
+  #   end
+  #
+  #   search(options.slice(:mass, :velocity, :time))
+  # Returns a new hash with only the given keys.
+  def slice(*keys)
+    allowed = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+    reject{|key,| !allowed.include?(key) }
+  end
+  #
+  # Replace the hash with only the given keys.
+  #
+  def slice!(*keys)
+    replace(slice(*keys))
+  end
+  #
+  # #values_of is an alias for #values_at, but can be called on a Hash, a
+  # Struct, or an instance of a class that includes HashLike
+  #
+  alias_method :values_of, :values_at
+
+  #
+  # Create a hash from an array of keys and corresponding values.
+  #
+  def self.zip(keys, values, default=nil, &block)
+    hash = block_given? ? Hash.new(&block) : Hash.new(default)
+    keys.zip(values){|key,val| hash[key]=val }
+    hash
+  end
+
+  # lambda for recursive merges
+  Hash::DEEP_MERGER = proc do |key,v1,v2|
+    (v1.respond_to?(:merge) && v2.respond_to?(:merge)) ? v1.merge(v2.compact, &Hash::DEEP_MERGER) : (v2.nil? ? v1 : v2)
+  end
+
+  #
+  # Merge hashes recursively.
+  # Nothing special happens to array values
+  #
+  #     x = { :subhash => { 1 => :val_from_x, 222 => :only_in_x, 333 => :only_in_x }, :scalar => :scalar_from_x}
+  #     y = { :subhash => { 1 => :val_from_y, 999 => :only_in_y },                    :scalar => :scalar_from_y }
+  #     x.deep_merge y
+  #     => {:subhash=>{1=>:val_from_y, 222=>:only_in_x, 333=>:only_in_x, 999=>:only_in_y}, :scalar=>:scalar_from_y}
+  #     y.deep_merge x
+  #     => {:subhash=>{1=>:val_from_x, 222=>:only_in_x, 333=>:only_in_x, 999=>:only_in_y}, :scalar=>:scalar_from_x}
+  #
+  # Nil values always lose.
+  #
+  #     x = {:subhash=>{:nil_in_x=>nil, 1=>:val1,}, :nil_in_x=>nil}
+  #     y = {:subhash=>{:nil_in_x=>5},              :nil_in_x=>5}
+  #     y.deep_merge x
+  #     => {:subhash=>{1=>:val1, :nil_in_x=>5}, :nil_in_x=>5}
+  #     x.deep_merge y
+  #     => {:subhash=>{1=>:val1, :nil_in_x=>5}, :nil_in_x=>5}
+  #
+  def deep_merge hsh2
+    merge hsh2, &Hash::DEEP_MERGER
+  end
+
+  def deep_merge! hsh2
+    merge! hsh2, &Hash::DEEP_MERGER
+  end
+
+
+  #
+  # Treat hash as tree of hashes:
+  #
+  #     x = { 1 => :val, :subhash => { 1 => :val1 } }
+  #     x.deep_set(:subhash, 3, 4)
+  #     # => { 1 => :val, :subhash => { 1 => :val1,   3 => 4 } }
+  #     x.deep_set(:subhash, 1, :newval)
+  #     # => { 1 => :val, :subhash => { 1 => :newval, 3 => 4 } }
+  #
+  #
+  def deep_set *args
+    hsh = self
+    head_keys = args[0..-3]
+    last_key  = args[-2]
+    val       = args[-1]
+    # grab last subtree (building out if necessary)
+    head_keys.each{|key| hsh = (hsh[key] ||= {}) }
+    # set leaf value
+    hsh[last_key] = val
+  end
+
+  # Stolen from ActiveSupport::CoreExtensions::Hash::ReverseMerge.
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
+  end
+
+  # Stolen from ActiveSupport::CoreExtensions::Hash::ReverseMerge.
+  def reverse_merge!(other_hash)
+    replace(reverse_merge(other_hash))
+  end
+
+  #
+  # remove all key-value pairs where the value is nil
+  #
+  def compact
+    reject{|key,val| val.nil? }
+  end
+  #
+  # Replace the hash with its compacted self
+  #
+  def compact!
+    replace(compact)
+  end
+
+end

data/lib/wukong/extensions/hash_like.rb

@@ -0,0 +1,119 @@
+module Wukong
+  #
+  # A hashlike has to
+  #
+  # *
+  # * The arguments to your initializer should be the same as the keys, in order
+  #   If not, you must override #from_hash
+  #
+  #
+  module HashLike
+
+    # List of possible keys --
+    # delegates to the class
+    def keys
+      self.class.keys
+    end
+
+    #
+    # Return a Hash containing only values for the given keys.
+    #
+    # Since this is intended to mirror Hash#slice it will harmlessly ignore keys
+    # not present in the struct.  They will be unset (hsh.include? is not true)
+    # as opposed to nil.
+    #
+    def slice *keys
+      keys.inject({}) do |hsh, key|
+        hsh[key] = send(key) if respond_to?(key)
+        hsh
+      end
+    end
+
+    #
+    # values_at like a hash
+    #
+    # Since this is intended to mirror Hash#values_at it will harmlessly ignore
+    # keys not present in the struct
+    #
+    def values_of *keys
+      keys.map{|key| self.send(key) if respond_to?(key) }
+    end
+
+    #
+    # Convert to a hash
+    #
+    def to_hash
+      slice(*self.class.members)
+    end
+
+    #
+    # Analagous to Hash#each_pair
+    #
+    def pairs
+      self.class.members.map{|attr| [attr, self[attr]] }
+    end
+
+    #
+    # Analagous to Hash#each_pair
+    #
+    def each_pair *args, &block
+      pairs.each(*args, &block)
+    end
+
+    #
+    # Analagous to Hash#merge
+    #
+    def merge *args
+      self.dup.merge! *args
+    end
+    def merge! hsh, &block
+      raise "can't handle block arg yet" if block
+      hsh.each_pair{|key, val| self.send("#{key}=", val) if self.respond_to?("#{key}=") }
+      self
+    end
+    alias_method :update, :merge!
+
+    #
+    # Merge hashes recursively.
+    # Nothing special happens to array values
+    #
+    #     x = { :subhash => { 1 => :val_from_x, 222 => :only_in_x, 333 => :only_in_x }, :scalar => :scalar_from_x}
+    #     y = { :subhash => { 1 => :val_from_y, 999 => :only_in_y },                    :scalar => :scalar_from_y }
+    #     x.deep_merge y
+    #     => {:subhash=>{1=>:val_from_y, 222=>:only_in_x, 333=>:only_in_x, 999=>:only_in_y}, :scalar=>:scalar_from_y}
+    #     y.deep_merge x
+    #     => {:subhash=>{1=>:val_from_x, 222=>:only_in_x, 333=>:only_in_x, 999=>:only_in_y}, :scalar=>:scalar_from_x}
+    #
+    def deep_merge hsh2
+      merge hsh2, &Hash::DEEP_MERGER
+    end
+
+    module ClassMethods
+      #
+      # Instantiate an instance of the struct from a hash
+      #
+      # Specify has_symbol_keys if the supplied hash's keys are symbolic;
+      # otherwise they must be uniformly strings
+      #
+      def from_hash(hsh, has_symbol_keys=false)
+        keys = self.keys
+        keys = keys.map(&:to_sym) if has_symbol_keys
+        self.new *hsh.values_of(*keys)
+      end
+      #
+      # The last portion of the class in underscored form
+      # note memoization
+      #
+      def self.resource_name
+        @resource_name ||= self.to_s.gsub(%r{.*::}, '').underscore.to_sym
+      end
+    end
+
+    def self.included base
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+  end
+
+end