imw 0.1.0

data/lib/imw/utils/extensions/hash.rb

@@ -0,0 +1,218 @@
+#
+# h2. lib/imw/utils/extensions/hash.rb -- hash extensions
+#
+# == About
+#
+# Extensions to the built-in +Hash+ class.
+#
+# Author::    (Philip flip Kromer, Dhruv Bansal) for Infinite Monkeywrench Project (mailto:coders@infochimps.org)
+# Copyright:: Copyright (c) 2008 infochimps.org
+# License::   GPL 3.0
+# Website::   http://infinitemonkeywrench.org/
+#
+
+require 'active_support/core_ext/hash/reverse_merge'
+
+class Hash
+  # Return the elements of this hash in a pretty-printed string,
+  # inserting +final_string+ between the last two items.
+  #
+  #   >> {:one => 1, :two => 2, :three => 3}.quote_keys_with "or"
+  #   `one', `two', or `three'
+  #
+  def quote_keys_with final_string = nil
+    self.keys.quote_items_with final_string
+  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
+
+  # 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) { |k,v| hash[k]=v }
+    hash
+  end
+
+  # Turns a collection of pairs into a hash.  The first of each pair
+  # make the keys and the second the values. Elements with length
+  # longer than two will lose those values.
+  #
+  # If there are multiple values of
+  #
+  def from_pairs()
+    hsh = { }
+    self.each{ |k,v| hsh[k] = v }
+    hsh
+  end
+
+  # Merges self with another hash, recursively.
+  #
+  # first  = {
+  #   :balls=> "monkey",
+  #   :data=> {
+  #     :name=> {:first=> "Sam", :middle=>"I", :last=>"am"}}}
+  # second = {
+  #   :data=> {
+  #     :name=> {:middle=>["you", "me", "everyone we know"], :last => "are"}},
+  #   1    => [1,2,5] }
+  #
+  # p first.deep_merge(second)
+  # # => {:data=>{:name=>{:last=>"are", :middle=>["you", "me", "everyone we know"], :first=>"Sam"}}, 1=>[1, 2, 5], :balls=>"monkey"}
+  # from http://snippets.dzone.com/posts/show/4706
+  # From: http://pastie.textmate.org/pastes/30372, Elliott Hird
+  def deep_merge(second)
+    target = dup
+    second.keys.each do |key|
+      if second[key].is_a?(Hash) && self[key].is_a?(Hash)
+        target[key] = target[key].deep_merge(second[key])
+      else
+        target[key] = second[key]
+      end
+    end
+    target
+  end
+
+  # Merges self in-place with another hash, recursively.
+  #
+  # first  = {
+  #   :balls=> "monkey",
+  #   :data=> {
+  #     :name=> {:first=> "Sam", :middle=>"I", :last=>"am"}}}
+  # second = {
+  #   :data=> {
+  #     :name=> {:middle=>["you", "me", "everyone we know"], :last => "are"}},
+  #   1    => [1,2,5] }
+  #
+  # p first.deep_merge(second)
+  # # => {:data=>{:name=>{:last=>"are", :middle=>["you", "me", "everyone we know"], :first=>"Sam"}}, 1=>[1, 2, 5], :balls=>"monkey"}
+  #
+  # From: http://www.gemtacular.com/gemdocs/cerberus-0.2.2/doc/classes/Hash.html
+  # File lib/cerberus/utils.rb, line 42
+  def deep_merge!(second)
+    second.keys.each do |key|
+      if second[key].is_a?(Hash) && self[key].is_a?(Hash)
+        self[key].deep_merge!(second[key])
+      else
+        self[key] = second[key]
+      end
+    end
+    self
+  end
+
+  # Merge another array with this one, accumulating values that appear in both
+  # into arrays.
+  #
+  # Note: array values will be flatten'ed. Sorry.
+  #
+  # first  = {
+  #   :balls=> "monkey",
+  #   :data=> {
+  #     :name=> {:first=> "Sam", :middle=>"I", :last=>"am"}}}
+  # second = {
+  #   :data=> {
+  #     :name=> {:middle=>["you", "me", "everyone we know"], :last => "are"}},
+  #   1    => [1,2,5] }
+  #
+  # p first.deep_merge(second)
+  # # => {:data=>{:name=>{:last=>"are",         :middle=>["you", "me", "everyone we know"],      :first=>"Sam"}}, 1=>[1, 2, 5], :balls=>"monkey"}
+  # p first.keep_merge(second)
+  # # => {:data=>{:name=>{:last=>["am", "are"], :middle=>["I", "you", "me", "everyone we know"], :first=>"Sam"}}, 1=>[1, 2, 5], :balls=>"monkey"}
+  def keep_merge(second)
+    target = dup
+    second.each do |key, val2|
+      if second[key].is_a?(Hash) && self[key].is_a?(Hash)
+        target[key] = target[key].keep_merge(val2)
+      else
+        target[key] = target.include?(key) ? [target[key], val2].flatten.uniq : val2
+      end
+    end
+    target
+  end
+
+  # This is polymorphic to Array#assoc -- that is, it allows you treat a Hash
+  # and an array of pairs equivalently using assoc(). We remind you that Array#assoc
+  #
+  #   "Searches through an array whose elements are also arrays comparing obj
+  #    with the first element of each contained array using obj.== . Returns the
+  #    first contained array that matches (that is, the first associated array)
+  #    or nil if no match is found. See also Array#rassoc."
+  #
+  # Note that this returns an /array/ of [key, val] pairs.
+  def assoc(key)
+    self.include?(key)   ? [key, self[key]] : nil
+  end
+  def rassoc(key)
+    self.has_value?(key) ? [key, self[key]] : nil
+  end
+
+  # Allows loading ostruct directly from YAML
+  def to_openstruct
+    map{ |el| el.to_openstruct }
+  end
+
+
+  # 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
+
+  # Replaces the hash with only the given keys.
+  def slice!(*keys)
+    replace(slice(*keys))
+  end
+
+  # remove all key-value pairs where the value is nil
+  def compact
+    reject{|k,v| v.nil? }
+  end
+
+  # Replaces the hash with its compacted self
+  def compact!
+    replace(compact)
+  end
+
+  # Works like <tt>Enumerable::find</tt> but loops over the keys of
+  # this Hash instead of of arrays of [key,value] and, in the absence
+  # of a matching key, doesn't call the default argument, merely
+  # returns it instead.
+  def dispatch(default=nil, &block)
+    match = self.keys.find(nil,&block)
+    match ? self[match] : default
+  end
+
+
+  # Recurses through the pairs of this Hash collecting all String or
+  # Symbol "terminal" nodes.
+  def terminals &block
+    terminals = []
+    each_value do |value|
+      if value.respond_to? :terminals then
+        terminals += value.terminals
+      else
+        terminals << value
+      end
+    end
+    terminals.map! {|terminal| yield terminal } if block
+    terminals
+  end
+  
+end
+
+# puts "#{File.basename(__FILE__)}: To each improvement there corresponds another, yes?" # at bottom

data/lib/imw/utils/extensions/hpricot.rb

@@ -0,0 +1,48 @@
+#
+# h2. lib/imw/utils/extensions/hpricot.rb -- extensions to hpricot
+#
+# == About
+#
+# Some IMW extensions for Why's Hpricot library.
+#
+# Author::    (Philip flip Kromer, Dhruv Bansal) for Infinite Monkeywrench Project (mailto:coders@infochimps.org)
+# Copyright:: Copyright (c) 2008 infochimps.org
+# License::   GPL 3.0
+# Website::   http://infinitemonkeywrench.org/
+#
+# puts "#{File.basename(__FILE__)}: Something clever" # at bottom
+
+require 'hpricot'
+
+module Hpricot::IMWExtensions
+
+  # Return the contents of the first element to match +path+.
+  def contents_of path
+    cnts = self.at path
+    cnts.inner_html if cnts
+  end
+
+  # Return the value of +attr+ for the first element to match +path+.
+  def path_attr path, attr
+    cnts = self.at path
+    cnts.attributes[attr] if cnts
+  end
+
+  # Return the value of the +class+ attribute of the first element to
+  # match +path+.
+  def class_of path
+    self.path_attr(path, 'class')
+  end
+end
+
+class Hpricot::Elem
+  include Hpricot::IMWExtensions
+end
+
+class Hpricot::Elements
+  include Hpricot::IMWExtensions
+end
+
+class Hpricot::Doc
+  include Hpricot::IMWExtensions
+end

data/lib/imw/utils/extensions/string.rb

@@ -0,0 +1,49 @@
+#
+# h2. lib/imw/utils/extensions/string.rb -- string extensions
+#
+# == About
+#
+# Implements some useful extensions to the +String+ class.
+#
+# Author::    (Philip flip Kromer, Dhruv Bansal) for Infinite Monkeywrench Project (mailto:coders@infochimps.org)
+# Copyright:: Copyright (c) 2008 infochimps.org
+# License::   GPL 3.0
+# Website::   http://infinitemonkeywrench.org/
+#
+
+class String
+
+  # Does the string end with the specified +suffix+ (stolen from
+  # <tt>ActiveSupport::CoreExtensions::String::StartsEndsWith</tt>)?
+  def ends_with?(suffix)
+    suffix = suffix.to_s
+    self[-suffix.length, suffix.length] == suffix
+  end
+
+  # Does the string start with the specified +prefix+ (stolen from
+  # <tt>ActiveSupport::CoreExtensions::String::StartsEndsWith</tt>)?
+  def starts_with?(prefix)
+    prefix = prefix.to_s
+    self[0, prefix.length] == prefix
+  end
+
+  # # Downcases a string and replaces spaces with underscores.  This
+  # # works slightly differently than
+  # # <tt>ActiveSupport::CoreExtensions::String::Inflections.underscore</tt>
+  # # which is intended to be used for camel-cased Ruby constants.
+  # #
+  # #   "A long and unwieldy phrase".underscore #=> "a_long_and_unwieldy_phrase"
+  # def underscore
+  #   self.to_s.tr("-", "_").tr(" ","_").downcase
+  # end
+
+  # Returns the handle corresponding to this string as a symbol:
+  #
+  #   "A possible title of a dataset".handle #=> :a_possible_title_of_a_dataset
+  def to_handle
+    self.downcase.underscore.to_sym
+  end
+
+end
+
+# puts "#{File.basename(__FILE__)}: You tie a long string to your Monkeywrench, place it on the ground, and hide around the corner with the string in your hand, waiting for passersby to try and make a grab for it." # at bottom

data/lib/imw/utils/extensions/struct.rb

@@ -0,0 +1,42 @@
+Struct.class_eval do
+  def slice *attrs
+    hsh = {}
+    attrs.each{|attr| hsh[attr] = self.send(attr) }
+    hsh
+  end
+
+  def to_hash
+    slice(*self.class.members)
+  end
+  def self.from_hash(hsh)
+    self.new *hsh.values_at(*self.members.map(&:to_sym))
+  end
+
+
+  #
+  # values_at like a hash
+  #
+  def values_of *attrs
+    slice(*attrs).values_at(*attrs)
+  end
+  def each_pair *args, &block
+    self.to_hash.each_pair(*args, &block)
+  end
+
+  def merge *args
+    self.dup.merge! *args
+  end
+  def merge! hashlike, &block
+    raise "can't handle block arg yet" if block
+    hashlike.each_pair{|k,v| self[k] = v }
+    self
+  end
+  alias_method :update, :merge!
+  def indifferent_merge  *args, &block
+    self.dup.indifferent_merge! *args
+  end
+  def indifferent_merge! hashlike, &block
+    merge! hashlike.reject{|k,v| ! self.members.include?(k.to_s) }
+  end
+
+end

data/lib/imw/utils/extensions/symbol.rb

@@ -0,0 +1,28 @@
+#
+# h2. lib/imw/utils/extensions/symbol.rb -- extensions to symbol class
+#
+# == About
+#
+# Author::    (Philip flip Kromer, Dhruv Bansal) for Infinite Monkeywrench Project (mailto:coders@infochimps.org)
+# Copyright:: Copyright (c) 2008 infochimps.org
+# License::   GPL 3.0
+# Website::   http://infinitemonkeywrench.org/
+#
+
+class Symbol
+
+  # Turn the symbol into a simple proc (stolen from
+  # <tt>ActiveSupport::CoreExtensions::Symbol</tt>).
+  def to_proc
+    Proc.new { |*args| args.shift.__send__(self, *args) }
+  end
+
+  # Returns the symbol itself (for compatibility with
+  # <tt>String.uniqnae</tt> and so on.
+  def handle
+    self
+  end
+
+end
+
+# puts "#{File.basename(__FILE__)}: You whisper a word of power and smile as the the Ruby Palace thunders with the sound of falling blocks." # at bottom

data/lib/imw/utils/extensions/typed_struct.rb

@@ -0,0 +1,22 @@
+#
+# A struct
+# but has an idea of what type attributes should be
+#
+#
+class TypedStruct < Struct
+  def self.new attrs, convs
+    struct = super *attrs
+    struct_attr_convs = Hash.zip(attrs, convs).reject{|a,t| t.nil? }
+    struct.class_eval do
+      cattr_accessor :attr_convs
+      self.attr_convs = struct_attr_convs
+      def remap!
+        attr_convs.each do |attr, conv|
+          curr = self.send(attr)
+          self.send("#{attr}=", curr.send(conv)) if curr.respond_to?(conv)
+        end
+      end
+    end # class_eval
+    struct
+  end
+end

data/lib/imw/utils/extensions/uri.rb

@@ -0,0 +1,59 @@
+#
+# h2. lib/imw/utils/extensions/uri.rb -- extensions to uri module
+#
+# == About
+#
+# Some useful extensions to the +URI+ module.
+#
+# Author::    (Philip flip Kromer, Dhruv Bansal) for Infinite Monkeywrench Project (mailto:coders@infochimps.org)
+# Copyright:: Copyright (c) 2008 infochimps.org
+# License::   GPL 3.0
+# Website::   http://infinitemonkeywrench.org/
+# 
+
+require 'uri'
+
+module URI
+
+  # List of prefixes ignored when returning domains (or reversed
+  # domains).
+  IGNORED_PREFIXES = ['www']
+  
+  # Returns the domain of the given URI, first scrubbing it of any
+  # prefixes we can ignore.
+  def self.domain(uri)
+      uriobj = self.parse(uri)
+    if uriobj.host then
+      host = uriobj.host
+    elsif uriobj.path then
+      host = uriobj.path.split('/')[0]
+    else
+      raise ArgumentError, "Invalid URI: #{uri}"
+    end
+    # remove any ignored prefixes from the hostname (i.e. - 'www')
+    parts = host.split('.')
+    parts = (IGNORED_PREFIXES.member?(parts[0]) ? parts[1...parts.size] : parts)
+    host = parts.join('.')
+    host
+  end
+
+  # Returns the reversed domain of the given URI, first scrubbing it of
+  # any prefixes we can ignore.  Will not reverse numeric addresses of
+  # the form 127.0.0.1
+  def self.reverse_domain(uri)
+    begin
+      d = self.domain(uri)
+      # check for numeric ip
+      # in a TERRIBLE way that needs to be fixed!`
+      if d=~/^[0-9]*\.[0-9]*\.[0-9]*\.[0-9]*$/ then
+        return d
+      else
+        return d.split('.').reverse.join('.')
+      end
+    rescue URI::InvalidURIError,ArgumentError
+      raise $!
+    end
+  end
+end
+
+# puts "#{File.basename(__FILE__)}: In the end, it's either you or I." # at bottom