stella 0.3.2

data/lib/utils/fileutil.rb

@@ -0,0 +1,59 @@
+require 'ftools'
+
+module FileUtil
+  
+  def FileUtil.read_file(path)
+    FileUtil.read_file_to_array(path).join('')
+  end
+  
+  def FileUtil.read_file_to_array(path)
+    contents = []
+    return contents unless File.exists?(path)
+    
+    open(path, 'r') do |l|
+      contents = l.readlines
+    end
+
+    contents
+  end
+  def FileUtil.read_binary_file(path)
+    contents = ''
+    return contents unless File.exists?(path)
+    
+    open(path, 'rb') do |l|
+      while (!l.eof?)
+        contents << l.read(4096)
+      end
+    end
+
+    contents
+  end
+  
+  
+  
+  def FileUtil.write_file(path, content, flush=true)
+    FileUtil.write_or_append_file('w', path, content, flush)
+  end
+  
+  def FileUtil.append_file(path, content, flush=true)
+    FileUtil.write_or_append_file('a', path, content, flush)
+  end
+  
+  def FileUtil.write_or_append_file(write_or_append, path, content = '', flush = true)
+    #STDERR.puts "Writing to #{ path }..." 
+    FileUtil.create_dir(File.dirname(path))
+    
+    open(path, write_or_append) do |f| 
+      f.puts content
+      f.flush if flush;
+    end
+    File.chmod(0600, path)
+  end
+  
+  def FileUtil.create_dir(dirpath)
+    return if File.directory?(dirpath)
+    
+    #STDERR.puts "Creating #{ dirpath }"
+    File.makedirs(dirpath)
+  end
+end

data/lib/utils/httputil.rb

@@ -0,0 +1,210 @@
+require 'net/http'
+require 'uri'
+require 'timeout'
+
+  module HTTPUtil
+    VALID_METHODS = %w{GET HEAD POST PUT DELETE}
+    @@timeout = 20
+    
+    def HTTPUtil.hostname(tmp_uri)
+      return if tmp_uri.empty?
+      uri = URI.parse(tmp_uri) if tmp_uri.is_a? String
+      
+      #STDERR.puts "Hostname for #{ uri.port }"
+      uri.host
+    end
+    
+    # Normalize all URIs before they are used for anything else
+    def HTTPUtil.normalize(uri_str, scheme = true) 
+      
+      
+      #STDERR.puts "  BEFORE: " << uri_str
+      if (!uri_str.index(/^https?:\/\//))
+        uri_str = 'http://' << uri_str
+      end
+      #STDERR.puts "   AFTER: " << uri_str
+      
+      uri_str.gsub!(/\s/, '%20')
+      
+      uri = URI.parse(uri_str)
+      
+      uri_clean = ""
+      
+      # TODO: use URI.to_s instead of manually creating the string
+      
+      if (scheme)
+        uri_clean << uri.scheme.to_s + '://'  
+      end
+      
+        
+      if (!uri.userinfo.nil?)
+        uri_clean << uri.userinfo.to_s
+        uri_clean << '@'
+      end
+      
+      #uri.host.gsub!(/^www\./, '')
+      
+      uri_clean << uri.host.to_s
+      
+      if (!uri.port.nil? && uri.port != 80 && uri.port != 443)
+        uri_clean << ':' + uri.port.to_s
+      end
+      
+      
+      
+      if (!uri.path.nil? && !uri.path.empty?)
+        uri_clean << uri.path
+      elsif
+        uri_clean << '/'
+      end
+      
+      
+      if (!uri.query.nil? && !uri.path.empty?)
+        uri_clean << "?" << uri.query
+      end
+      
+      #STDERR.puts "IN: " << uri_str
+      #STDERR.puts "OUT: " << uri_clean
+      
+      uri_clean
+    end
+    
+    def HTTPUtil.fetch_content(uri, limit = 10)
+      res = self.fetch(uri,limit)
+      return (res) ? res.body : ""
+    end
+    
+    def HTTPUtil.fetch(uri, limit = 10)
+       
+      # You should choose better exception.
+      raise ArgumentError, 'HTTP redirect too deep' if limit == 0
+      STDERR.puts "URL: #{uri.to_s}"
+      uri = URI.parse(uri) if uri.is_a? String
+      
+      begin
+        timeout(@@timeout) do
+           response = Net::HTTP.get_response(uri)
+        
+        
+          case response
+          when Net::HTTPSuccess     then response
+          when Net::HTTPRedirection then fetch(response['location'], limit - 1)
+          else
+            STDERR.puts "Not found: " << uri.to_s
+          end
+        end
+      rescue TimeoutError
+        STDERR.puts "Net::HTTP timed out for " << uri.to_s
+        return
+      rescue => ex
+        STDERR.puts "Error: #{ex.message}"
+      end
+    
+    end
+    
+    def HTTPUtil.post(uri, params = {}, limit = 10)
+       
+      # You should choose better exception.
+      raise ArgumentError, 'HTTP redirect too deep' if limit == 0
+      
+      uri = URI.parse(uri) if uri.is_a? String
+      
+      begin
+        timeout(@@timeout) do
+           response = Net::HTTP.post_form(uri, params)
+        
+          case response
+          when Net::HTTPSuccess     then response
+          when Net::HTTPRedirection then fetch(response['location'], limit - 1)
+          else
+            STDERR.puts "Error for " << uri.to_s
+            STDERR.puts response.body
+          end
+        end
+      rescue TimeoutError
+        STDERR.puts "Net::HTTP timed out for " << uri.to_s
+        return
+      end
+      
+      
+      
+    end
+    
+    def HTTPUtil.exists(uri)
+      
+      begin
+        response = fetch(uri)
+        case response
+        when Net::HTTPSuccess     then true
+        when Net::HTTPRedirection then fetch(response['location'], limit - 1)
+        else
+          false
+        end
+        
+      rescue Exception => e
+        STDERR.puts "Problem: " + e.message
+        false
+      end
+      
+    end
+    
+    def HTTPUtil.parse_query(query)
+      params = Hash.new([].freeze)
+
+      query.split(/[&;]/n).each do |pairs|
+        key, value = pairs.split('=',2).collect{|v| URI.unescape(v) }
+        if params.has_key?(key)
+          params[key].push(value)
+        else
+          params[key] = [value]
+        end
+      end
+
+      params
+    end
+    
+    def HTTPUtil.validate_method(meth='GET')
+      meth = (VALID_METHODS.member? meth.upcase) ? meth : VALID_METHODS[0]
+    end
+    
+    # Extend the basic query string parser provided by the cgi module.
+    # converts single valued params (the most common case) to
+    # objects instead of arrays
+    #
+    # Input:
+    # the query string
+    #
+    # Output:
+    # hash of parameters, contains arrays for multivalued parameters
+    # (multiselect, checkboxes , etc)
+    # If no query string is provided (nil or "") returns an empty hash.
+
+    def HTTPUtil.query_to_hash(query_string)
+      return {} unless query_string
+
+      query_parameters = HTTPUtil.parse_query(query_string)
+
+      query_parameters.each { |key, val|
+        # replace the array with an object
+        query_parameters[key] = val[0] if 1 == val.length
+      }
+
+      # set default value to nil! cgi sets this to []
+      query_parameters.default = nil
+
+      return query_parameters
+    end
+    
+    def HTTPUtil.hash_to_query(parameters)
+      return '' unless parameters
+      pairs = []
+      parameters.each do |param, value|
+        pairs << "#{param}=#{URI.escape(value.to_s)}"
+      end
+      return pairs.join('&')
+      #return pairs.join(";")
+    end
+    
+    
+  end
+

data/lib/utils/mathutil.rb

@@ -0,0 +1,78 @@
+
+
+module MathUtil
+  
+  def self.variance(population)
+    n = 0
+    mean = 0.0
+    s = 0.0
+    population.each { |x|
+      n = n + 1
+      delta = (x - mean).to_f
+      mean = (mean + (delta / n)).to_f
+      s = (s + delta * (x - mean)).to_f
+    }
+    
+    return s / n
+  end
+
+  # calculate the standard deviation of a population
+  # accepts: an array, the population
+  # returns: the standard deviation
+  def self.standard_deviation(population)
+    Math.sqrt(variance(population))
+  end
+  
+  # enforce_limit
+  #
+  # Enforce a minimum and maximum value 
+  def self.enforce_limit(val,min,max)
+    val = min  if val < min
+    val = max  if val > max
+    val
+  end
+  
+end
+
+
+
+
+module Enumerable
+
+    ##
+    # Sum of all the elements of the Enumerable
+
+    def sum
+        return self.inject(0) { |acc, i| acc + i }
+    end
+
+    ##
+    # Average of all the elements of the Enumerable
+    #
+    # The Enumerable must respond to #length
+
+    def average
+        return self.sum / self.length.to_f
+    end
+
+    ##
+    # Sample variance of all the elements of the Enumerable
+    #
+    # The Enumerable must respond to #length
+
+    def sample_variance
+        avg = self.average
+        sum = self.inject(0) { |acc, i| acc + (i - avg) ** 2 }
+        return (1 / self.length.to_f * sum)
+    end
+
+    ##
+    # Standard deviation of all the elements of the Enumerable
+    #
+    # The Enumerable must respond to #length
+
+    def standard_deviation
+        return Math.sqrt(self.sample_variance)
+    end
+
+end

data/lib/utils/textgraph.rb

@@ -0,0 +1,267 @@
+# A port of Text::Graph, which generates pretty ascii bar graphs from
+# numeric datasets, like
+# 
+#     aaaa :       (1)
+#       bb :..*    (22)
+#      ccc :...*   (43)
+#   dddddd :.....* (500)
+#       ee :......*(1000)
+#        f :.....* (300)
+#      ghi :...*   (50)
+# 
+# It accepts data in the following forms (see the 'extract' method):
+# 
+# # { label => value, label => value, ... }
+# # { :values => { label => value, ...} }
+# # { :values => [values] }
+# # {:values => { label => value, label => value }, :labels => [...]}
+# # {:values => [values], :labels => [labels]}
+# # [ [label, value], [label, value], ...]
+# # [[values], [labels]]
+# 
+# Numeric parameters:
+# :minval
+# :maxval
+# :maxlen
+# 
+# Boolean parameters:
+# :log   # logarithmic scale
+# :right # label justification
+# 
+# Display parameters:
+# :marker
+# :fill
+# :separator
+# :style # {:bar|:line} - sets default values for marker and fill
+# :showval # numeric value after bar
+
+# Text::Graph
+# Port of Wade Johnson's Text::Graph for perl
+#   http://search.cpan.org/src/GWADEJ/Text-Graph-0.23/Graph.pm
+#  
+# Author: Martin DeMello <martindeme...@gmail.com>
+
+module Enumerable
+  def minmax
+    min = 1.0/0
+    max = -1.0/0
+    each {|i|
+      min = i if i < min
+      max = i if i > max
+    }
+    [min, max]
+  end
+
+  def map_with_index
+    a = []
+    each_with_index {|e, i| a << yield(e,i)}
+    a
+  end
+end
+
+class TextGraph
+  include Math
+
+  def initialize(data, params = {})
+    @data = extract(data)
+    @params = {:style => (params[:style] || :bar)}
+    apply_style(@params[:style])
+    @params.update(params)
+    @params[:separator] ||= " :"
+  end
+
+  def update_params(par)
+    apply_style(par[:style]) if par[:style]
+    @params.update(par)
+  end
+
+  def apply_style(style)
+    if style == :bar
+      @params[:marker] = "*"
+      @params[:fill] = "*"
+    elsif style == :line
+      @params[:marker] = '*'
+      @params[:fill] = ' '
+    else
+      raise "Invalid style #{style}"
+    end
+  end
+
+  def extract(data)
+    if data.is_a? Array
+      if data.length == 2 and data[0].is_a? Array and data[1].is_a? Array
+  # [[values], [labels]]
+  a = {}
+  a[:values] = data[0]
+  a[:labels] = data[1]
+  data = a
+      else
+  # [ [label, value], [label, value], ...]
+  a = {:values => [], :labels => []}
+  data.each {|i,j| a[:labels] << i; a[:values] << j}
+      end
+    end
+
+    if (data.length == 2) and data[:values] and data[:labels]
+      if data[:values].is_a? Array
+  # {:values => [values], :labels => [labels]}
+  # do nothing
+      elsif data[:values].is_a? Hash
+  # {:values => { label => value, label => value }, :labels => [...]}
+  a = data[:labels].map {|i| data[:values][i]}
+  data[:values] = a
+      else
+  raise "Invalid valueset"
+      end
+    elsif (data.length == 1) and data[:values]
+      if data[:values].is_a? Array
+  # { :values => [values] }
+  data[:labels] = data[:values].map {""}
+      elsif data[:values].is_a? Hash
+  # { :values => { label => value, ...} }
+  data[:labels] = data[:values].keys.sort_by {|i| i.to_s}
+  data[:values] = data[:labels].map {|i| data[:values][i]}
+      else
+  raise "Invalid valueset"
+      end
+    else
+      # { label => value, label => value, ... }
+      a = {}
+      a[:labels] = data.keys.sort_by {|i| i.to_s}
+      a[:values] = a[:labels].map {|i| data[i]}
+      data = a
+    end
+    data[:labels].map! {|i| i.to_s}
+    data
+  end
+
+  def make_within(val, min, max)
+    (val < min) ? min : (val > max ? max : val)
+  end
+
+  def makebar(val, m, f)
+    val = (val + 0.5).to_i
+    (val > 0) ? (f*(val - 1) + m) : ""
+  end
+
+  def fmt_labels (right, labels)
+    len = labels.map {|i| i.length}.max
+    just = right ? :rjust : :ljust
+    labels.map {|i| i.send(just, len)}
+  end
+
+  def make_labelled_lines(data)
+    labels = fmt_labels(@params[:right], data[:labels])
+    lines  = histogram(data)
+    lines.zip(labels).map {|line, label| label + @params[:separator] + line}
+  end
+
+  def histogram(data)
+    values = data[:values].dup
+    minval, maxval, maxlen =
+      @params[:minval], @params[:maxval], @params[:maxlen]
+
+    if @params[:log]
+      values.map! {|i| log(i)}
+      minval = log(minval) rescue 1 if minval
+      maxval = log(maxval) rescue 1 if maxval
+    end
+
+    min, max = values.minmax
+    minval ||= min
+    maxval ||= max
+    maxl = maxval - minval + 1
+    maxlen ||= maxl
+    scale = maxlen*1.0/maxl
+    values = values.map {|i|
+      j = make_within(i, minval, maxval) - minval
+      makebar(j*scale, @params[:marker], @params[:fill])
+    }
+
+    if(@params[:showval])
+      values = values.map_with_index {|v, i|
+  v.ljust(maxlen) + "(#{data[:values][i]})"
+      }
+    end
+
+    values
+  end
+
+  def to_s
+    make_labelled_lines(@data).join("\n") + "\n"
+  end
+end
+
+if __FILE__ == $0
+
+  a = TextGraph.new({
+    :values => [100,142,43,54,111,62,52],
+    :labels => %w(aaaa bb ccc dddddd ee f ghi)
+  })
+
+  puts a
+
+  #  aaaa   :
+  #  bb     :*
+  #  ccc    :***
+  #  dddddd :****
+  #  ee     :*********
+  #  f      :**
+  #  ghi    :****
+
+  puts "-------------------------------------------------------------"
+
+  a.update_params(:style => :line, :right => true, :showval => true)
+  puts a
+
+  #    aaaa :          (1)
+  #      bb :*         (2)
+  #     ccc :  *       (4)
+  #  dddddd :   *      (5)
+  #      ee :        * (10)
+  #       f : *        (3)
+  #     ghi :   *      (5)
+
+  puts "-------------------------------------------------------------"
+
+  b = TextGraph.new({ :a=>1, :b=>5, :c=>20, :d=>10, :e=>17 }, {:maxlen => 10})
+  puts b
+
+  #  a :
+  #  b :**
+  #  c :**********
+  #  d :*****
+  #  e :********
+
+  puts "-------------------------------------------------------------"
+
+  c = TextGraph.new({:values => { :a=>1, :b=>5, :c=>20, :d=>10, :e=>17 },
+        :labels => [:a, :c, :d]},
+        {:minval => 0, :maxval => 15, :showval => true})
+  puts c
+
+  #  a :*               (1)
+  #  c :*************** (20)
+  #  d :**********      (10)
+
+  puts "-------------------------------------------------------------"
+
+  d = TextGraph.new([[10,22,43,500,1000,300,50], %w(aaaa bb ccc dddddd ee f ghi)],
+        { :style => :line,
+          :right => true,     # right-justify labels
+          :fill => '.',       # change fill-marker
+          :log => false,       # logarithmic graph
+          :showval => true    # show actual values
+  }
+       )
+       puts d
+
+       #    aaaa :       (1)
+       #      bb :..*    (22)
+       #     ccc :...*   (43)
+       #  dddddd :.....* (500)
+       #      ee :......*(1000)
+       #       f :.....* (300)
+       #     ghi :...*   (50)
+
+end