wukong 3.0.0.pre → 3.0.0.pre2

data/old/wukong/extensions/class.rb

@@ -1,189 +0,0 @@
-#
-# 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/old/wukong/extensions/date_time.rb

@@ -1,53 +0,0 @@
-require 'time'
-require 'date'
-
-class Time
-  # strftime() format to flatten a date
-  FLAT_FORMAT = "%Y%m%d%H%M%S"
-  # Flatten
-  def to_flat
-    utc.strftime(FLAT_FORMAT)
-  end
-
-  #
-  # Parses the time but never fails.
-  # Return value is always in the UTC time zone.
-  #
-  # A flattened datetime -- a 14-digit YYYYmmddHHMMMSS -- is fixed to the UTC
-  # time zone by parsing it as YYYYmmddHHMMMSSZ <- 'Z' at end
-  #
-  def self.parse_safely dt
-    return nil if dt.blank?
-    begin
-      case
-      when dt.is_a?(Time)               then dt.utc
-      when (dt.to_s =~ /\A\d{14}\z/)    then parse(dt.to_s+'Z', true)
-      else                                   parse(dt.to_s,     true).utc
-      end
-    rescue StandardError => e
-      Log.debug e
-    end
-  end
-
-  def self.parse_and_flatten str
-    parse_safely(str).to_flat
-  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
-
-class Date
-  # strftime() format to flatten a date
-  FLAT_FORMAT = "%Y%m%d"
-  # Flatten
-  def to_flat
-    strftime(FLAT_FORMAT)
-  end
-end

data/old/wukong/extensions/emittable.rb

@@ -1,69 +0,0 @@
-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=false
-    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 Integer
-  #
-  # Express boolean as 1 (true) or 0 (false).  In contravention of typical ruby
-  # semantics (but in a way that is more robust for wukong-like batch
-  # processing), the number 0, the string '0', nil and false are all considered
-  # false. (This also makes the method idempotent: repeated calls give same result.)
-  #
-  def self.unbooleanize bool
-    case bool
-    when 0, '0', false, nil then 0
-    else                         1
-    end
-  end
-end

data/old/wukong/extensions/enumerable.rb

@@ -1,79 +0,0 @@
-module Enumerable
-
-  # Calculates a sum from the elements. Examples:
-  #
-  #  payments.sum { |p| p.price * p.tax_rate }
-  #  payments.sum(&:price)
-  #
-  # The latter is a shortcut for:
-  #
-  #  payments.inject { |sum, p| sum + p.price }
-  #
-  # It can also calculate the sum without the use of a block.
-  #
-  #  [5, 15, 10].sum # => 30
-  #  ["foo", "bar"].sum # => "foobar"
-  #  [[1, 2], [3, 1, 5]].sum => [1, 2, 3, 1, 5]
-  #
-  # The default sum of an empty list is zero. You can override this default:
-  #
-  #  [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
-  #
-  def sum(identity = 0, &block)
-    if block_given?
-      map(&block).sum(identity)
-    else
-      inject { |sum, element| sum + element } || identity
-    end
-  end
-
-  # Iterates over a collection, passing the current element *and* the
-  # +memo+ to the block. Handy for building up hashes or
-  # reducing collections down to one object. Examples:
-  #
-  #   %w(foo bar).each_with_object({}) { |str, hsh| hsh[str] = str.upcase } #=> {'foo' => 'FOO', 'bar' => 'BAR'}
-  #
-  # *Note* that you can't use immutable objects like numbers, true or false as
-  # the memo. You would think the following returns 120, but since the memo is
-  # never changed, it does not.
-  #
-  #   (1..5).each_with_object(1) { |value, memo| memo *= value } # => 1
-  #
-  def each_with_object(memo, &block)
-    returning memo do |m|
-      each do |element|
-        block.call(element, m)
-      end
-    end
-  end unless [].respond_to?(:each_with_object)
-
-  # Convert an enumerable to a hash. Examples:
-  #
-  #   people.index_by(&:login)
-  #     => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
-  #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
-  #     => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
-  #
-  def index_by
-    inject({}) do |accum, elem|
-      accum[yield(elem)] = elem
-      accum
-    end
-  end
-
-  # Returns true if the collection has more than 1 element. Functionally equivalent to collection.size > 1.
-  # Works with a block too ala any?, so people.many? { |p| p.age > 26 } # => returns true if more than 1 person is over 26.
-  def many?(&block)
-    size = block_given? ? select(&block).size : self.size
-    size > 1
-  end
-
-  # Returns true if none of the elements match the given block.
-  #
-  #   success = responses.none? {|r| r.status / 100 == 5 }
-  #
-  # This is a builtin method in Ruby 1.8.7 and later.
-  def none?(&block)
-    !any?(&block)
-  end unless [].respond_to?(:none?)
-end

data/old/wukong/extensions/hash.rb

@@ -1,167 +0,0 @@
-#
-# 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 unless defined?(::Hash::DEEP_MERGER)
-
-  #
-  # 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 unless method_defined?(:deep_merge)
-
-  def deep_merge! hsh2
-    merge! hsh2, &Hash::DEEP_MERGER
-  end unless method_defined?(:deep_merge!)
-
-  #
-  # Treat hash as tree of hashes:
-  #
-  #     x = { 1 => :val, :subhash => { 1 => :val1 } }
-  #     x.deep_set(:subhash, :cat, :hat)
-  #     # => { 1 => :val, :subhash => { 1 => :val1,   :cat => :hat } }
-  #     x.deep_set(:subhash, 1, :newval)
-  #     # => { 1 => :val, :subhash => { 1 => :newval, :cat => :hat } }
-  #
-  #
-  def deep_set *args
-    val      = args.pop
-    last_key = args.pop
-    # dig down to last subtree (building out if necessary)
-    hsh = args.empty? ? self : args.inject(self){|h, k| h[k] ||= {} }
-    # set leaf value
-    hsh[last_key] = val
-  end unless method_defined?(:deep_set)
-
-  #
-  # Treat hash as tree of hashes:
-  #
-  #     x = { 1 => :val, :subhash => { 1 => :val1 } }
-  #     x.deep_get(:subhash, 1)
-  #     # => :val
-  #     x.deep_get(:subhash, 2)
-  #     # => nil
-  #     x.deep_get(:subhash, 2, 3)
-  #     # => nil
-  #     x.deep_get(:subhash, 2)
-  #     # => nil
-  #
-  def deep_get *args
-    last_key = args.pop
-    # dig down to last subtree (building out if necessary)
-    hsh = args.inject(self){|h, k| h[k] || {} }
-    # get leaf value
-    hsh[last_key]
-  end unless method_defined?(:deep_get)
-
-
-  #
-  # Treat hash as tree of hashes:
-  #
-  #     x = { 1 => :val, :subhash => { 1 => :val1, 2 => :val2 } }
-  #     x.deep_delete(:subhash, 1)
-  #     #=> :val
-  #     x
-  #     #=> { 1 => :val, :subhash => { 2 => :val2 } }
-  #
-  def deep_delete *args
-    last_key  = args.pop
-    last_hsh  = args.empty? ? self : (deep_get(*args)||{})
-    last_hsh.delete(last_key)
-  end unless method_defined?(:deep_delete)
-
-  #
-  # remove all key-value pairs where the value is nil
-  #
-  def compact
-    reject{|key,val| val.nil? }
-  end unless method_defined?(:compact)
-  #
-  # Replace the hash with its compacted self
-  #
-  def compact!
-    replace(compact)
-  end unless method_defined?(:compact!)
-
-  #
-  # remove all key-value pairs where the value is blank
-  #
-  def compact_blank
-    reject{|key,val| val.blank? }
-  end
-  #
-  # Replace the hash with its compact_blank'ed self
-  #
-  def compact_blank!
-    replace(compact_blank)
-  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
-
-end