webget_ruby_ramp 1.7.2

data/lib/webget_ruby_ramp/object.rb

@@ -0,0 +1,20 @@
+# Object extensions
+
+class Object
+
+  # Syntactic sugar for arrays.
+  #
+  # ==Definition
+  #   object.in? array === array.include? object
+  #
+  # ==Example
+  #   array=['a','b','c']
+  #   object='b'
+  #   object.in? array 
+  #   => true
+  
+  def in?(array)
+    array.include?(self)
+  end
+  
+end

data/lib/webget_ruby_ramp/process.rb

@@ -0,0 +1,153 @@
+# Process extensions to help debug Ruby programs.
+#
+# ==Examples
+#
+#   p = Process.ps
+#   puts p
+#   => the results of the 'ps' command for the current process id
+#
+#   p = Process.ps(1234)
+#   puts p
+#   => the results of the 'ps' command for process id 1234
+#
+#   p = Process.pss
+#   p['%cpu'] => percentage of cpu use, as a float
+#   p['%mem'] => percentage of memory use, as a float
+##
+
+module Process
+
+
+ # Get the 'ps' command as one long text string.
+ #
+ # This is typically useful for logging to a text file.
+
+ def self.ps(pid=Process.pid)
+   `#{self.ps_command} #{pid.to_i}`
+ end
+
+
+ # Get the 'ps' command as a hash of keys and values.
+ # -
+ # OPTIMIZE: add dates, times
+
+ def self.pss(pid=Process.pid)
+   ps=self.ps(pid)
+   h=Hash[*self.ps_keys.zip(ps.split).flatten]
+   h['c']      =h['c'].to_i
+   h['cp']     =h['cp'].to_f
+   h['egid']   =h['egid'].to_i
+   h['egroup'] =h['egroup'].to_i
+   h['uid']    =h['uid'].to_i
+   h['fgid']   =h['fgid'].to_i
+   h['lwp']    =h['lwp'].to_i
+   h['ni']     =h['ni'].to_i
+   h['nlwp']   =h['nlwp'].to_i
+   h['pcpu']   =h['pcpu'].to_f
+   h['pgid']   =h['pgid'].to_i
+   h['pid']    =h['pid'].to_i
+   h['pmem']   =h['pmem'].to_f
+   h['ppid']   =h['ppid'].to_i
+   h['rgid']   =h['rgid'].to_i
+   h['rss']    =h['rss'].to_i
+   h['ruid']   =h['ruid'].to_i  
+   h['sid']    =h['sid'].to_i  
+   h['sgid']   =h['sgid'].to_i  
+   h['suid']   =h['suid'].to_i  
+   self.ps_aliases.each_pair{|key,val| h[key]=h[val]}
+  return h
+ end
+
+  # Get the list of process alias keywords as typically defined by the shell.
+  #
+  # For example, a shell may consider "%cpu" and "pcpu" to be identical.
+
+  def self.ps_aliases
+    @@ps_aliases||=Hash[*%w'
+    %cpu pcpu
+    %mem pmem
+    sig_block blocked
+    sigmask blocked
+    sig_catch caught
+    sigcatch caught
+    cls class
+    cls policy
+    cputime time
+    gid egid 
+    group egroup
+    uid euid 
+    uname euser
+    user euser 
+    flag f
+    flags f
+    fsuid fuid
+    sig_ignore ignored
+    sigignore ignored
+    spid lwp 
+    tid lwp 
+    nice ni
+    thcount nlwp
+    sig pending 
+    sig_pend pending
+    pgrp pgid 
+    rssize rss
+    rsz rss
+    state s
+    sess sid
+    session sid
+    svgid sgid
+    tt tname 
+    tty tname 
+    vsz vsize
+  ']
+ end
+
+
+ # Set the list of process alias keywords.
+
+ def self.ps_aliases=(aliases)
+  @@ps_aliases=aliases
+ end
+
+
+ # Get the list of process keywords.
+ #
+ # ==Example
+ #   Process.ps_keys => ["blocked","group","pending","size"]
+
+ def self.ps_keys
+  @@ps_keys||=%w'blocked bsdtime c caught class cp egid egroup eip esp etime euid euser f fgid fgroup fuid fuser group ignored label lwp ni nlwp nwchan pending pcpu pgid pid pmem ppid pri psr rgid rgroup rss rtprio ruid ruser s sched sgi_p sgid sgroup sid sig size stackp start_time stat suid suser sz time tname tpgid vsize wchan'
+ end
+
+ 
+ # Set the list of process keywords.
+ #
+ # ==Example 
+ #   Process.ps_keys = ["blocked","group","pending","size"]
+
+ def self.ps_keys=(keys)
+  @@ps_keys=keys
+ end
+
+
+ # Get the process command, i.e. what the sytem will call for the "ps" command.
+ #
+ # ==Example
+ #   Process.ps_command => "ps h ww -o blocked,group,pending,size"
+ 
+ def self.ps_command
+  @@ps_command||='ps h ww -o "'+self.ps_keys.join(',')+'"'
+ end
+
+
+ # Set the process command, i.e. what the sytem will call for the "ps" command.
+ #
+ # ==Example
+ #   Process.ps_command = "ps h ww -o blocked,group,pending,size"
+ 
+ def self.ps_command=(command)
+  @@ps_comannd=command
+ end
+
+
+end

data/lib/webget_ruby_ramp/string.rb

@@ -0,0 +1,221 @@
+# String extensions
+
+class String
+
+  ACCENTS =  Hash[*'
+ à a á a â a ã a ä a å a ā a ă a
+ æ ae
+ ď d đ d             
+ ç c ć c č c ĉ c ċ c
+ è e é e ê e ë e ē e ę e ě e ĕ e ė e           
+ ƒ f              
+ ĝ g ğ g ġ g ģ g             
+ ĥ h ħ h             
+ ì i ì i í i î i ï i ī i ĩ i ĭ i            
+ į j ı j ij j ĵ j             
+ ķ k ĸ k             
+ ł l ľ l ĺ l ļ l ŀ l             
+ ñ n ń n ň n ņ n ʼn n ŋ n            
+ ò o ó o ô o õ o ö o ø o ō o ő o ŏ o ŏ o           
+ œ oek             
+ ą q              
+ ŕ r ř r ŗ r             
+ ś s š s ş s ŝ s ș s             
+ ť t ţ t ŧ t ț t             
+ ù u ú u û u ü u ū u ů u ű u ŭ u ũ u ų u           
+ ŵ w              
+ ý y ÿ y ŷ y             
+ ž z ż z ź z             
+ '.split]
+
+
+ # Return the string with words capitalized
+
+ def capitalize_words
+  split(/\b/).map{|word| word.capitalize }.join
+ end
+
+
+ # Return an array that is the string split into words, i.e. split(\W*\b\*)
+
+ def words
+  split(/\W*\b\W*/)
+ end
+
+
+ # Return an array that is the string split at tabs, i.e. split(/\t/)
+
+ def split_tab
+  split(/\t/)
+ end
+
+
+ # Return an array that is the string split at newlines, then tabs.
+ # This is useful to split a TSV (Tab Separated Values) string
+ # into an array of rows, and each row into an array of fields.
+
+ def split_tsv
+   split(/\n/).map{|line| line.split(/\t/)}
+ end
+
+
+ # Return the string in lowercase, with any non-word-characters
+ # replaced with single underscores (aka low dashes).
+ #
+ # ==Example
+ #   'Foo Goo Hoo' => 'foo_goo_hoo'
+ #   'Foo***Goo***Hoo' => 'foo_goo_hoo'
+
+ def lowcase
+  downcase.gsub(/[_\W]+/,'_')
+ end
+
+
+ # Return the string as an XML id, which is the same as #lowcase
+ #
+ # ==Example
+ #   "Foo Hoo Goo" => 'foo_goo_hoo'
+ #   "Foo***Goo***Hoo" => 'foo_goo_hoo'
+
+ def to_xid
+  self.lowcase
+ end
+
+ # Ruby String#to_class method to convert from a String to a class
+ #
+ # From Mirage at http://infovore.org/archives/2006/08/02/getting-a-class-object-in-ruby-from-a-string-containing-that-classes-name/
+
+ def to_class
+  split('::').inject(Kernel) {|scope, const_name| scope.const_get(const_name)}
+ end
+
+
+ # Increment the rightmost natural number 
+ #
+ # ==Example
+ #   'foo5bar'.increment => 'foo4bar'
+ #   'foo5bar'.increment(3) => 'foo8bar'
+ #   'foo9bar'.increment => 'foo10bar'
+ #
+ # - see String#decrement
+
+ def increment(step=1)
+  self=~/\d+/ ? $`+($&.to_i+step).to_s+$' : self
+ end
+
+
+ # Decrement the rightmost natural number
+ # 
+ # ==Example
+ #   'foo5bar'.decrement => 'foo4bar'
+ #   'foo5bar'.decrement(3) => 'foo2bar'
+ #   'foo10bar'.derement => 'foo9bar'
+ #
+ # - see String#increment
+
+ def decrement(step=1)
+  self=~/\d+/ ? $`+($&.to_i-step).to_s+$' : self
+ end
+
+
+ # Return the previous character, with a changed flag and carry flag
+ #
+ # ==Examples
+ #   String.prev_char('n') => 'm', true, false   # change 
+ #   String.prev_char('a') => 'z', true, true    # change & carry
+ #   String.prev_char('6') => '5', true, false   # change
+ #   String.prev_char('0') => '9', true, true    # change & carry
+ #   String.prev_char('-') => '-', false, false  # unchanged
+
+ def self.prev_char(c) #=> prev_char, changed_flag, carry_flag
+  case c
+  when '1'..'9', 'B'..'Z', 'b'..'z'
+    i=(c.respond_to?(:ord) ? c.ord : c[0])
+    return (i-1).chr, true, false
+  when '0'
+    return '9', true, true
+  when 'A'
+    return 'Z', true, true
+  when 'a'
+    return 'z', true, true
+  else
+    return c, false, false
+  end
+ end
+
+ # Return the previous string
+ #
+ #  c.f. String#next
+ #
+ # ==Examples
+ #   '888'.prev => '887'
+ #   'n'.prev => 'm'
+ #   'N'.prev => 'M'
+ #
+ # ==Examples with carry
+ #   '880'.prev => '879'
+ #   'nna'.prev => 'nmz'
+ #   'NNA'.prev => 'NMZ'
+ #   'nn0aA'.prev => 'nm9zZ'
+ 
+ def prev
+  self.clone.prev!
+ end
+
+
+ # Do String#prev in place
+
+ def prev!
+  return self if length==0
+  index=length-1 # rightmost
+  while true do
+   chr=self[index].chr
+   prev_chr,changed_flag,carry_flag=String.prev_char(chr)
+    return self if !changed_flag
+   self[index]=prev_chr
+   return self if !carry_flag
+   index-=1
+   return nil if index<0
+  end
+ end
+
+ alias pred  prev   # String#pred : predecessor :: String#succ : successor
+ alias pred! prev!
+ 
+ class << self
+  alias_method :pred_char, :prev_char
+ end
+
+ # Helpful constants
+
+ LOWERCASE_ENGLISH_CHARS = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
+ UPPERCASE_ENGLISH_CHARS = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
+
+
+ ##
+ #
+ #  Lorem Ipsum random text generator
+ #
+ ##
+ 
+ # Return a random length suitable for a "lorem ipsum" string.
+ #
+ # This method uses 1+rand(10)
+
+ def self.lorem_length
+  1+rand(10)
+ end
+
+ # Return a random string suitable for "lorem ipsum" text.
+ #
+ # This method chooses from lowercase letters a-z.
+ #
+ # This method defaults to length = self.lorem_length.
+ 
+ def self.lorem(length=self.lorem_length)
+  ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'].choices(length).join
+ end
+
+
+end
+

data/lib/webget_ruby_ramp/symbol.rb

@@ -0,0 +1,11 @@
+# Symbol extensions
+
+class Symbol
+
+  include Comparable
+  def <=>(that)
+    self.to_s<=>that.to_s
+  end
+
+end
+

data/lib/webget_ruby_ramp/time.rb

@@ -0,0 +1,11 @@
+# Time extensions
+
+class Time
+
+  # Return current time in UTC as a timestamp string "YYYYMMDDHHMMSS"
+
+  def self.stamp
+    now.utc.strftime('%Y%m%d%H%M%S')
+  end
+
+end

data/lib/webget_ruby_ramp/xml.rb

@@ -0,0 +1,193 @@
+require 'rexml/document' 
+
+# XML extensions
+
+module XML
+
+
+  # Specify one or more directory patterns and pass each XML file in the matching directories to a block.
+  #
+  # See [Dir#glob](http://www.ruby-doc.org/core/classes/Dir.html#M002347) for pattern details.
+  #
+  # ==Example
+  #   XML.load_dir('/tmp/*.xml'){|xml_document|
+  #     #...whatever you want to do with each xml document
+  #   }
+  #
+  # ==Example to load xml documents in files beginning in "foo" or "bar"
+  #   XML.load_dir('/tmp/foo*.yaml','/tmp/bar*.xml','){|xml_document|
+  #     #...whatever you want to do with the xml document
+  #   }
+
+  def XML.load_dir(*dirpaths)
+    dirpaths=[*dirpaths.flatten]
+    dirpaths.each do |dirpath|
+      Dir[dirpath].sort.each do |filename|
+        File.open(filename) do |file|
+          doc = REXML::Document.new file
+          yield doc
+        end #file
+      end #dir
+    end #each
+  end #def                                                                                                                                                                                                                          
+
+
+  # Sugar to load elements from a file.
+  #
+  # ==Example
+  #   XML.load_attributes('config.xml','userlist/user'){|element| pp element.attributes['first_name'] }
+
+  def XML.load_elements(dirpath,xpath)
+    XML.load_dir(dirpath){|doc|
+      doc.elements.each(xpath){|elem|
+        yield elem
+      }
+    }
+  end
+
+
+  # Sugar to load attributes from a file.
+  #
+  # ==Example
+  #   XML.load_attributes('config.xml','userlist/user'){|attributes| pp attributes['first_name'] }
+
+  def XML.load_attributes(dirpath,xpath)
+    XML.load_elements(dirpath,xpath){|elem|
+      yield elem.attributes
+    }
+  end
+
+  # Sugar to load attributes hash from a file.
+  #
+  # ==Example
+  #   XML.load_attributes('config.xml','userlist/user'){|attributes| pp attributes['first_name'] }
+
+  def XML.load_attributes_hash(dirpath,xpath)
+    XML.load_elements(dirpath,xpath){|elem|
+      yield elem.attributes.to_hash
+    }
+  end
+
+
+  # Santize dirty xml by removing unprintables, bad tags,
+  # comments, and generally anything else we might need
+  # to enable the XML parser to handle a dirty document.
+  #
+  # ==Example 
+  #   # This example shows curly braces instead of angle braces because of HTML formatting
+  #   s="{foo a=b c=d}{!--comment--}Hello{!-[if bar]}Microsoft{![endif]}World{/foo}"
+  #   XML.strip_all(s) => "{foo}HelloWorld{/foo}"
+  #
+  # This method calls these in order:
+  #   - XML.strip_unprintables
+  #   - XML.strip_microsoft
+  #   - XML.strip_comments
+  #   - XML.strip_attributes
+
+  def XML.strip_all(xml_text)
+    return XML.strip_attributes(XML.strip_comments(XML.strip_microsoft(XML.strip_unprintables(xml_text))))
+  end
+
+
+  # Strip out all attributes from the xml text's tags.
+  #
+  # ==Example
+  #   s="<foo a=b c=d e=f>Hello</foo>"
+  #   XML.strip_attributes(s) => "<foo>Hello</foo>"
+
+  def XML.strip_attributes(xml_text)
+    return xml_text.gsub(/<(\/?\w+).*?>/im){"<#{$1}>"}  # delete attributes
+  end
+
+
+  # Strip out all comments from the xml text.
+  #
+  # ==Example
+  #   # This example shows curly braces instead of angle braces because of HTML formatting
+  #   s="Hello{!--comment--}World"
+  #   XML.strip_comments(s) => "HelloWorld"
+
+  def XML.strip_comments(xml_text)
+    return xml_text.gsub(/<!.*?>/im,'')  
+  end
+
+
+  # Strip out all microsoft proprietary codes.
+  #
+  # ==Example
+  #   s="Hello<!-[if foo]>Microsoft<![endif]->World"
+  #   XML.strip_microsoft(s) => "HelloWorld"
+
+  def XML.strip_microsoft(xml_text)
+    return xml_text.gsub(/<!-*\[if\b.*?<!\[endif\]-*>/im,'')
+  end
+
+
+  # Strip out all unprintable characters from the input string.
+  #
+  # ==Example
+  #   s="Hello\XXXWorld" # where XXX is unprintable
+  #   XML.strip_unprintables(s) => "HelloWorld"
+
+  def XML.strip_unprintables(xml_text)
+    return xml_text.gsub(/[^[:print:]]/, "")
+  end
+
+end
+
+
+# REXML::Attributes extensions
+
+class REXML::Attributes
+
+  # Return a new hash of the attribute keys and values.
+  #
+  # ==Example
+  #   attributes.to_hash => {"src"=>"pic.jpg", "height" => "100", "width" => "200"} 
+
+  def to_hash
+    h=Hash.new
+    self.keys.each{|k| h[k]=self[k]}
+    h
+  end
+
+end
+
+
+# REXML::Document extensions
+
+class REXML::Document
+
+  # Remove all attributes from the document's elements.
+  # 
+  # Return the document.
+  #
+  # cf. Element#remove_attributes
+
+  def remove_attributes
+    self.elements.each("//") { |e| e.attributes.each_attribute{|attribute| attribute.remove }}
+    self
+  end
+  
+end
+
+
+# REXML::Element extensions
+
+class REXML::Element
+
+  # Remove all attributes from the element.
+  #
+  # Return the element.
+  #
+  # cf. Document#remove_attributes
+
+  def remove_attributes
+    self.attributes.each_attribute{|attribute| attribute.remove }
+    self
+  end
+
+end
+
+
+