webget_ruby_ramp 1.7.2

data/lib/webget_ruby_ramp/file.rb

@@ -0,0 +1,15 @@
+# File extensions
+
+class File
+
+  # Return File.join(File.dirname(dirname),strings)
+  #
+  # ==Example
+  #   File.joindir(__FILE__,'foo.txt')
+  #   => '/home/john/foo.txt'
+
+  def File.joindir(dirname,*strings)
+    File.join(File.dirname(dirname),strings)
+  end
+
+end

data/lib/webget_ruby_ramp/hash.rb

@@ -0,0 +1,223 @@
+require 'yaml'
+
+# Hash extensions
+
+class Hash
+
+
+  # Return true if size > 0
+  def size?
+    size>0
+  end
+
+
+  # Calls block once for each key in hsh, passing the key and value to the block as a two-element array.
+  #
+  # The keys are sorted.
+
+  def each_sort
+   keys.sort.each{|key| yield key,self[key] }
+  end
+
+
+  # Calls block once for each key in hsh, 
+  # passing the key as a parameter,
+  # and updating it in place.
+  #
+  # ==Example
+  #   h = { "a" => "b", "c" => "d" }
+  #   h.each_key! {|key| key.upcase }
+  #   h => { "A" => "b", "C" => "d" }
+  #
+  # Return self.
+
+  def each_key!
+    each_pair{|key,value|
+      key2=yield(key)
+      if key===key2
+        #nop
+      else
+        self.delete(key)
+        self[key2]=value
+      end
+    }
+  end
+
+
+  # Calls block once for each key in hsh,
+  # passing the key and value as parameters,
+  # and updated them in place.
+  #
+  # ==Example
+  #   h = { "a" => "b", "c" => "d" }
+  #   h.each_pair! {|key,value| key.upcase, value.upcase }
+  #   h => { "A" => "B", "C" => "D" }
+  #
+  # Return self.
+
+  def each_pair!
+    each_pair{|key,value|
+      key2,value2=yield(key,value)
+      if key===key2
+        if value===value2
+          #nop
+        else
+          self[key]=value2
+        end
+      else
+        self.delete(key)
+        self[key2]=value2
+      end
+    }
+    return self
+  end
+
+
+  # Calls block once for each key in hsh,
+  # passing the value as a parameter, 
+  # and updating it in place.
+  #
+  # ==Example
+  #   h = { "a" => "b", "c" => "d" }
+  #   h.each_value! {|value| value.upcase }
+  #   h => { "a" => "B", "c" => "d" }
+  #
+  # Return self.
+
+  def each_value!
+    each_pair{|key,value| 
+      value2=yield(value)
+      if value===value2
+        #nop
+      else
+        self[key]=yield(value) 
+      end
+    }
+    return self
+  end
+
+
+  # Calls block once for each key-value pair in hsh,
+  # passing the key and value as paramters to the block.
+  #
+  # ==Example
+  #   h = {"a"=>"b", "c"=>"d", "e"=>"f" }
+  #   h.map_pair{|key,value| key+value }
+  #   => ["ab","cd","ef"]
+
+  def map_pair
+    keys.map{|key| yield key, self[key] }
+  end
+
+
+  # Hash#to_yaml with sort 
+  #
+  # From http://snippets.dzone.com/tag/yaml
+
+  def to_yaml_sort( opts = {} )
+    YAML::quick_emit( object_id, opts ) do |out|
+      out.map( taguri, to_yaml_style ) do |map|
+        sort.each do |key, val|   # <-- here's my addition (the 'sort')
+	  map.add(key, val)
+        end
+      end
+    end
+  end
+
+
+  # Hash#pivot aggregates values for a hash of hashes,
+  # for example to calculate subtotals and groups.
+  #
+  # Suppose you have data arranged by companies, roles, and headcounts.
+  #
+  #     data = {
+  #     "Apple"     => {"Accountants" => 11, "Designers" => 22, "Developers" => 33},
+  #     "Goggle"    => {"Accountants" => 44, "Designers" => 55, "Developers" => 66},
+  #     "Microsoft" => {"Accountants" => 77, "Designers" => 88, "Developers" => 99},
+  #   }
+  # 
+  # To calculate each company's total headcount, you pivot up, then sum:
+  # 
+  #   data.pivot(:up,&:sum)
+  #   => {
+  #    "Apple"=>66, 
+  #    "Goggle"=>165, 
+  #    "Microsoft"=>264
+  #   }
+  # 
+  # To calculate each role's total headcount, you pivot down, then sum:
+  # 
+  #   data.pivot(:down,&:sum)
+  #   => {
+  #    "Accountants"=>132,
+  #    "Designers"=>165,
+  #    "Developers"=>198
+  #   }
+  # 
+  #  Generic xxample:
+  #   h={
+  #    "a"=>{"x"=>1,"y"=>2,"z"=>3},
+  #    "b"=>{"x"=>4,"y"=>5,"z"=>6},
+  #    "c"=>{"x"=>7,"y"=>8,"z"=>9},
+  #   }
+  #   h.pivot(:keys) => {"a"=>[1,2,3],"b"=>[4,5,6],"c"=>[7,8,9]} 
+  #   h.pivot(:vals) => {"x"=>[1,4,7],"y"=>[2,5,8],"z"=>[3,6,9]}
+  #
+  # = Calculating subtotals
+  #
+  # The pivot method is especially useful for calculating subtotals.
+  #
+  # ==Example
+  #   r = h.pivot(:keys)
+  #   r['a'].sum => 6
+  #   r['b'].sum => 15
+  #   r['c'].sum => 24
+  #
+  # ==Example
+  #   r=h.pivot(:vals)
+  #   r['x'].sum => 12
+  #   r['y'].sum => 15
+  #   r['z'].sum => 18
+  #
+  # = Block customization
+  #
+  # You can provide a block that will be called for the pivot items.
+  #
+  # ==Examples
+  #   h.pivot(:keys){|items| items.max } => {"a"=>3,"b"=>6,"c"=>9}
+  #   h.pivot(:keys){|items| items.join("/") } => {"a"=>"1/2/3","b"=>"4/5/6","c"=>"7/8/9"}
+  #   h.pivot(:keys){|items| items.inject{|sum,x| sum+=x } } => {"a"=>6,"b"=>15,"c"=>24}
+  #
+  # ==Examples
+  #   h.pivot(:vals){|items| items.max } => {"a"=>7,"b"=>8,"c"=>9}
+  #   h.pivot(:vals){|items| items.join("-") } => {"a"=>"1-4-7","b"=>"2-5-8","c"=>"3-6-9"}
+  #   h.pivot(:vals){|items| items.inject{|sum,x| sum+=x } } => {"a"=>12,"b"=>15,"c"=>18}   
+
+  def pivot(direction='keys',&b)
+    a=self.class.new
+    direction=direction.to_s
+    up=pivot_direction_up?(direction)
+    each_pair{|k1,v1|
+      v1.each_pair{|k2,v2|
+        k = up ? k1 : k2
+        a[k]=[] if (a[k]==nil or a[k]=={})
+        a[k]<<(v2)
+      }
+    }
+    if block_given? 
+      a.each_pair{|k,v| a[k]=(yield v)}
+    end
+    a
+  end
+
+  protected
+
+  def pivot_direction_up?(direction_name)
+    case direction_name
+    when 'key','keys','up','left','out' then return true
+    when 'val','vals','down','right','in' then return false
+    else raise 'Pivot direction must be either: up/left/out or down/right/in'
+    end
+  end
+
+end

data/lib/webget_ruby_ramp/integer.rb

@@ -0,0 +1,22 @@
+# Integer extensions
+
+class Integer
+
+  # Syntactic sugar to yield n times to a block.
+  #
+  # Return an array of any results.
+  #
+  # ==Example
+  #   3.maps{rand} => [0.0248131784304143, 0.814666170190905, 0.15812816258206]
+  #
+  # ==Parallel to Integer#times
+  #
+  # Integer#maps is similar to Integer#times except that the output from each
+  # call to the block is captured in an array element and that array is
+  # returned to the calling code.
+  
+  def maps
+    (0...self).map{|item| yield item}
+  end
+
+end

data/lib/webget_ruby_ramp/io.rb

@@ -0,0 +1,65 @@
+# IO extensions
+
+class IO
+
+
+  # Reads the entire file specified by name as individual lines as with IO#readlines,
+  # and returns those lines in an array of rows, where each row is an array of fields.
+  #
+  # ==Example
+  #   IO.readrows("my.tsv")
+  #    => [["A1","B1","C1"],["A2","B2","C2"],["A3","B3","C3"]]
+  #
+  # ==Options
+  # - Rows are separated by _row_ option, which defaults to Ruby's record separator $/ or "\n" 
+  # - Cols are separated by _col_ option, which defaults to Ruby's string split separator $; or "\t"
+  #
+  # ==Example with options suitable for a file using TSV (Tab Separated Values)
+  #   IO.readrows("my.tsv", :row=>"\n", :col=>"\t") 
+  #
+  # Note: the col option is sent along to String#split, so can be a string or a regexp.
+  #
+  # See:
+  # - File#readline
+  # - File#readlines
+  # - File#readrow
+
+  def IO.readrows(name, options={})
+    row_sep||=options[:row]||$/||"\n"
+    col_sep||=options[:col]||$;||"\t"
+    return IO.readlines(name, row_sep).map{|line| line.chomp(row_sep).split(col_sep)}
+  end
+
+
+  # Read a line as with IO#readline and return the line as a row of fields.
+  #
+  # ==Example
+  #   file = File.new("my.tsv")
+  #   file.readrow() => ["A1","B1","C1"]
+  #   file.readrow() => ["A2","B2","C2"]
+  #   file.readrow() => ["A3","B3","C3"]]
+  #
+  # ==Options
+  # - Rows are separated by _row_ option, which defaults to Ruby's record separator $/ or "\n" 
+  # - Cols are separated by _col_ option, which defaults to Ruby's string split separator $; or "\t"
+  #
+  # ==Example with options suitable for a file using TSV (Tab Separated Values)
+  #   file = File.new("my.tsv")
+  #   file.readrow(:row=>"\n", :col=>"\t") => ["A1","B1","C1"] 
+  #   file.readrow(:row=>"\n", :col=>"\t") => ["A2","B2","C2"] 
+  #   file.readrow(:row=>"\n", :col=>"\t") => ["A3","B3","C3"] 
+  #
+  # Note: the col option is sent along to String#split, so can be a string or a regexp.
+  #
+  # See:
+  # - File#readline
+  # - File#readlines
+  # - File#readrows
+
+  def readrow(options={})
+    row_sep||=options[:row]||$/||"\n"
+    col_sep||=options[:col]||$;||"\t"
+   return readline(row_sep).chomp(row_sep).split(col_sep)
+  end
+
+end

data/lib/webget_ruby_ramp/kernel.rb

@@ -0,0 +1,36 @@
+require 'pp'
+require 'stringio'  
+
+# Kernel extensions
+
+module Kernel
+
+  # See:
+  # - http://www.ruby-forum.com/topic/75258
+  # - In 1.9 (Ruby CVS HEAD) there is #__method__ and #__callee__
+  # - http://eigenclass.org/hiki.rb?Changes+in+Ruby+1.9#l90
+
+  def method_name(caller_index=0)
+    # Make this fast because its often doing logging & reporting.
+    # Inline this and use $1 because it's empirically faster than /1
+    caller[caller_index] =~ /`([^']*)'/ and $1
+  end
+
+  # Pretty print to a string.
+  # 
+  # Created by Graeme Mathieson.
+  #
+  # See http://rha7dotcom.blogspot.com/2008/07/ruby-and-rails-how-to-get-pp-pretty.html
+
+  def pp_s(*objs)  
+    str = StringIO.new  
+    objs.each {|obj|  
+        PP.pp(obj, str)  
+      }  
+      str.rewind  
+      str.read  
+  end  
+  module_function :pp_s  
+
+end
+

data/lib/webget_ruby_ramp/math.rb

@@ -0,0 +1,20 @@
+# Math extensions
+
+module Math
+
+
+  # Return the natural log of _num_
+
+  def Math.ln(num)
+   Math.log(num)
+  end
+
+
+  # Return the log of _num_ in base _base_
+ 
+  def Math.logn(num,base)
+    Math.ln(num)/Math.ln(base)
+  end
+
+
+end

data/lib/webget_ruby_ramp/nil.rb

@@ -0,0 +1,17 @@
+# NilClass provides an instantiatable object
+# suitable for more careful thorough programming.
+
+class NilClass
+
+ # Same as Rails
+ def blank?
+  return true
+ end
+
+ # Return false
+ def size?
+  return false
+ end
+
+end
+

data/lib/webget_ruby_ramp/numeric.rb

@@ -0,0 +1,98 @@
+# Numeric extensions
+
+class Numeric
+
+
+ # Return 0 if the given flag is any of: nil, false, 0, [], {}
+ #
+ # ==Example
+ #   3.if(true) => 3
+ #   3.if(false) => 0
+ #   
+
+ def if(flag)
+   # inline for speed
+   return (flag==nil or flag==false or flag==0 or flag==[] or flag=={}) ? 0 : self
+ end
+
+
+ # Return self if flag is nil, false, 0, [], {}; otherwise return 0.
+ #
+ # ==Example
+ #   3.unless(true) => 0
+ #   3.unless(false) => 3
+
+ def unless(flag)
+   # inline for speed
+   return (flag==nil or flag==false or flag==0 or flag==[] or flag=={}) ? self : 0
+ end
+
+
+ ###
+ #
+ #  Metric conversions
+ #
+ ###
+
+ # Return self / 10^15
+ def peta
+  self/1000000000000000
+ end
+
+ # Return self / 10^12
+ def tera
+  self/1000000000000
+ end
+
+ # Return self / 10^9
+ def giga
+  self/1000000000
+ end
+
+ # Return self / 10^6
+ def mega
+  self/100000
+ end
+
+ # Return self / 10^3
+ def kilo
+  self/1000
+ end
+
+ # Return self / 10^2
+ def hecto
+  self/100
+ end
+
+ # Return self / 10
+ def deka
+  self/10
+ end
+ 
+ # Return self * 10
+ def deci
+  self*10
+ end
+
+ # Return self * 10^2
+ def centi
+  self*100
+ end
+
+ # Return self * 10^3
+ def milli
+  self*1000
+ end
+
+ # Return self * 10^6
+ def micro
+  self*1000000
+ end
+
+ # Return self * 10^9
+ def nano
+  self*1000000000
+ end
+
+
+end