epitools 0.1.11 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.11
+0.2.0

data/epitools.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{epitools}
-  s.version = "0.1.11"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["epitron"]
-  s.date = %q{2010-09-25}
+  s.date = %q{2010-09-28}
   s.description = %q{Miscellaneous utility libraries to make my life easier.}
   s.email = %q{chris@ill-logic.com}
   s.extra_rdoc_files = [
@@ -26,6 +26,9 @@ Gem::Specification.new do |s|
      "epitools.gemspec",
      "lib/epitools.rb",
      "lib/epitools/basetypes.rb",
+     "lib/epitools/browser.rb",
+     "lib/epitools/browser/browser_cache.rb",
+     "lib/epitools/browser/mechanize_progressbar.rb",
      "lib/epitools/hexdump.rb",
      "lib/epitools/http.rb",
      "lib/epitools/lcs.rb",
@@ -33,12 +36,15 @@ Gem::Specification.new do |s|
      "lib/epitools/niceprint.rb",
      "lib/epitools/permutations.rb",
      "lib/epitools/pretty_backtrace.rb",
+     "lib/epitools/progressbar.rb",
      "lib/epitools/rails.rb",
      "lib/epitools/rash.rb",
      "lib/epitools/ratio.rb",
      "lib/epitools/string_to_proc.rb",
+     "lib/epitools/sys.rb",
      "lib/epitools/zopen.rb",
      "spec/basetypes_spec.rb",
+     "spec/browser_spec.rb",
      "spec/lcs_spec.rb",
      "spec/metaclass_spec.rb",
      "spec/permutations_spec.rb",
@@ -46,6 +52,7 @@ Gem::Specification.new do |s|
      "spec/ratio_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
+     "spec/sys_spec.rb",
      "spec/zopen_spec.rb"
   ]
   s.homepage = %q{http://github.com/epitron/epitools}
@@ -54,14 +61,16 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{NOT UTILS... METILS!}
   s.test_files = [
-    "spec/rash_spec.rb",
-     "spec/ratio_spec.rb",
-     "spec/metaclass_spec.rb",
-     "spec/basetypes_spec.rb",
+    "spec/sys_spec.rb",
+     "spec/permutations_spec.rb",
+     "spec/rash_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/browser_spec.rb",
      "spec/lcs_spec.rb",
+     "spec/basetypes_spec.rb",
+     "spec/ratio_spec.rb",
      "spec/zopen_spec.rb",
-     "spec/permutations_spec.rb",
-     "spec/spec_helper.rb"
+     "spec/metaclass_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/epitools/browser.rb

@@ -0,0 +1,213 @@
+require 'mechanize'
+require 'uri'
+require 'fileutils'
+
+require 'epitools/browser/mechanize_progressbar'
+
+# TODO: Make socksify optional (eg: if proxy is specified)
+#require 'socksify'
+
+# TODO: Put options here.
+=begin
+class BrowserOptions < OpenStruct
+
+  DEFAULTS = {
+    :delay => 1,
+    :delay_jitter => 0.2,
+    :use_cache => true,
+    :use_logs => false,
+    :cookie_file => "cookies.txt"
+  }
+  
+  def initialize(extra_opts)
+    
+    @opts = DEFAULTS.dup
+    
+    for key, val in opts
+      if key.in? DEFAULTS
+        @opts[key] = val
+      else
+        raise "Unknown option: #{key}"
+      end
+    end
+  end
+  
+end
+=end
+
+#
+# A mechanize class that emulates a web-browser, with cache and everything.
+# Progress bars are enabled by default.
+#
+class Browser
+
+  attr_accessor :agent, :cache, :use_cache, :delay, :delay_jitter
+
+  #
+  # Default options:
+  #  :delay => 1,                      # Sleep 1 second between gets
+  #  :delay_jitter => 0.2,             # Random deviation from delay
+  #  :use_cache => true,               # Cache all gets
+  #  :use_logs => false,               # Don't log the detailed transfer info
+  #  :cookie_file => "cookies.txt"     # Save cookies to file
+  #
+  def initialize(options={})
+    @last_get     = Time.at(0)
+    @delay        = options[:delay]         || 1
+    @delay_jitter = options[:delay_jitter]  || 0.2
+    @use_cache    = options[:cache]         || true
+    @use_logs     = options[:logs]          || false
+    @cookie_file  = options[:cookiefile]    || "cookies.txt"
+    
+    # TODO: @progress, @user_agent, @logfile, @cache_file (default location: ~/.epitools?) 
+
+    if options[:proxy]
+      host, port = options[:proxy].split(':')
+      TCPSocket::socks_server = host
+      TCPSocket::socks_port   = port.to_i
+    end
+
+    init_agent!
+    init_cache!
+  end
+
+
+  def init_agent!
+    @agent = Mechanize.new do |a|
+      # ["Mechanize", "Mac Mozilla", "Linux Mozilla", "Windows IE 6", "iPhone", "Linux Konqueror", "Windows IE 7", "Mac FireFox", "Mac Safari", "Windows Mozilla"]
+      a.max_history = 10 
+      a.user_agent_alias = "Windows IE 7"
+      a.log = Logger.new "mechanize.log" if @use_logs
+    end
+
+    load_cookies!
+  end
+
+
+  def delay(override_delay=nil, override_jitter=nil)
+    elapsed   = Time.now - @last_get
+    jitter    = rand * (override_jitter || @delay_jitter)
+    amount    = ( (override_delay || @delay) + jitter ) - elapsed
+
+    if amount > 0
+      puts "  |_ sleeping for %0.3f seconds..." % amount
+      sleep amount
+    end
+  end
+
+
+  def init_cache!
+    # TODO: Rescue "couldn't load" exception and disable caching
+    require 'epitools/browser/browser_cache'
+    @cache = CacheDB.new(agent) if @use_cache
+  end
+
+
+  def relative?(url)
+    not url =~ %r{^https?://}
+  end
+
+
+  def cache_put(page, url)
+    if page.is_a? Mechanize::Page and page.content_type =~ %r{^text/}
+      puts "  |_ writing to cache"
+      cache.put(page, url, :overwrite=>true)
+    end
+  end
+
+  #
+  # Retrieve an URL, and return a Mechanize::Page instance (which acts a 
+  # bit like a Nokogiri::HTML::Document instance.)
+  #
+  # Options:
+  #   :use_cache => true/false   | read/write
+  #   :read_cache => true/false  | check cache before getting page
+  #   :write_cache => true/false | write gotten pages to cache
+  #
+  def get(url, options={})
+
+    # TODO: Have a base-URL option
+    
+    #if relative?(url)
+    #  url = URI.join("http://base-url/", url).to_s
+    #end
+
+    # Determine the cache setting
+    options[:use_cache] ||= @use_cache
+    
+    if options[:use_cache] == false
+      options[:read_cache]  = false
+      options[:write_cache] = false
+    end
+    
+    options[:read_cache]  = true   if options[:read_cache].nil?
+    options[:write_cache] = true   if options[:write_cache].nil? 
+
+    read_cache  = options[:read_cache] && cache.include?(url) 
+    write_cache = options[:write_cache]
+
+    puts
+    puts "[ #{url.inspect} (read_cache=#{options[:read_cache]}, write_cache=#{options[:write_cache]}) ]"
+    
+    delay unless read_cache
+
+    begin
+      
+      if read_cache
+        page = cache.get(url)
+        if page.nil?
+          puts "  |_ CACHE FAIL! Re-getting page."
+          page = get(url, false)
+        end
+        puts "  |_ cached (#{page.content_type})"
+      else
+        page = agent.get url
+        @last_get = Time.now
+      end
+
+      cache_put(page, url) if write_cache and not read_cache
+
+      puts
+
+    rescue Net::HTTPBadResponse, Errno::ECONNRESET, SocketError, Timeout::Error, SOCKSError => e
+      puts "  |_ ERROR: #{e.inspect} -- retrying"
+      delay(5)
+      retry
+=begin      
+    rescue Mechanize::ResponseCodeError => e
+      
+      case e.response_code
+        when "401" #=> Net::HTTPUnauthorized
+          p e
+          login!
+          page = get(url)
+          puts
+        when "404"
+          p e
+          raise e
+        when "503"
+          puts "  |_ ERROR: #{e.inspect} -- retrying"
+          delay(5)
+          retry
+      else
+        raise e
+      end
+=end
+
+    end
+
+    page
+  end
+
+private
+
+  def load_cookies!
+    agent.cookie_jar.load @cookie_file if File.exists? @cookie_file
+  end
+
+  def save_cookies!
+    agent.cookie_jar.save_as @cookie_file
+  end
+
+end
+

data/lib/epitools/browser/browser_cache.rb

@@ -0,0 +1,164 @@
+#require 'mechanize'
+require 'sqlite3'
+
+class CacheDB
+
+  include Enumerable
+
+  attr_reader :db, :agent
+
+  def initialize(agent, filename="browsercache.db")
+    @agent    = agent
+    @filename = filename
+
+    @db = SQLite3::Database.new(filename)
+    @db.busy_timeout(50)
+
+    create_tables
+  end
+
+  def inspect
+    "#<CacheDB filename=#{@filename.inspect}, count=#{count}, size=#{File.size @filename} bytes>"
+  end
+
+  def count
+    db.execute("SELECT COUNT(1) FROM cache").first.first.to_i
+  end
+  
+  alias_method :size, :count
+
+  def put(page, original_url=nil, options={})
+    raise "Invalid page" unless [:body, :content_type, :uri].all?{|m| page.respond_to? m }
+
+    url = page.uri.to_s
+
+    if url != original_url
+      # redirect original_url to url
+      expire(original_url) if options[:overwrite]
+      db.execute(
+        "INSERT INTO cache VALUES ( ?, ?, ?, ? )",
+        original_url,
+        page.content_type,
+        nil,
+        url
+      )
+    end
+
+    compressed_body = Zlib::Deflate.deflate(page.body)
+    expire(url) if options[:overwrite]
+    db.execute(
+      "INSERT INTO cache VALUES ( ?, ?, ?, ? )",
+      url,
+      page.content_type,
+      SQLite3::Blob.new( compressed_body  ),
+      nil
+    )
+
+    true
+    
+  rescue SQLite3::SQLException => e
+    p [:exception, e]
+    false
+  end
+
+  def row_to_page(row)
+    url, content_type, compressed_body, redirect = row
+
+    if redirect
+      get(redirect)
+    else
+      body = Zlib::Inflate.inflate(compressed_body)
+
+      WWW::Mechanize::Page.new(
+        URI.parse(url),
+        {'content-type'=>content_type},
+        body,
+        nil,
+        agent
+      )
+    end
+  end
+
+  def pages_via_sql(*args, &block)
+    if block_given?
+      db.execute(*args) do |row|
+        yield row_to_page(row)
+      end
+    else
+      db.execute(*args).map{|row| row_to_page(row) }
+    end
+  end
+
+  def grep(pattern, &block)
+    pages_via_sql("SELECT * FROM cache WHERE url like '%#{pattern}%'", &block)
+  end
+
+  def get(url)
+    pages = pages_via_sql("SELECT * FROM cache WHERE url = ?", url.to_s)
+    
+    if pages.any?
+      pages.first
+    else
+      nil
+    end
+  end
+
+  def includes?(url)
+    db.execute("SELECT url FROM cache WHERE url = ?", url.to_s).any?
+  end
+
+  alias_method :include?, :includes?
+
+  def urls(pattern=nil)
+    if pattern
+      rows = db.execute("SELECT url FROM cache WHERE url LIKE '%#{pattern}%'")
+    else
+      rows = db.execute('SELECT url FROM cache')
+    end
+    rows.map{|row| row.first}
+  end
+
+  def clear(pattern=nil)
+    if pattern
+      db.execute("DELETE FROM cache WHERE url LIKE '%#{pattern}%'")
+    else
+      db.execute("DELETE FROM cache") 
+    end
+  end
+
+  def each(&block)
+    pages_via_sql("SELECT * FROM cache", &block)
+  end
+
+  def each_url
+    db.execute("SELECT url FROM cache") do |row|
+      yield row.first
+    end
+  end
+
+  def expire(url)
+    db.execute("DELETE FROM cache WHERE url = ?", url)
+  end
+
+  def recreate_tables
+    drop_tables rescue nil
+    create_tables
+  end
+
+private
+
+  def list_tables
+    db.execute("SELECT name FROM SQLITE_MASTER WHERE type='table'")
+  end
+
+  def create_tables
+    db.execute("CREATE TABLE IF NOT EXISTS cache ( url varchar(2048), content_type varchar(255), body blob, redirect varchar(2048) )")
+    db.execute("CREATE UNIQUE INDEX IF NOT EXISTS url_index ON cache ( url )")
+  end
+
+  def drop_tables
+    db.execute("DROP TABLE cache")
+  end
+
+
+end

data/lib/epitools/browser/mechanize_progressbar.rb

@@ -0,0 +1,53 @@
+require 'epitools/progressbar'
+
+class Mechanize
+  class Chain
+    class ResponseReader
+      include Mechanize::Handler
+
+      def initialize(response)
+        @response = response
+      end
+
+      def handle(ctx, params)
+        params[:response] = @response
+        body = StringIO.new
+        total = 0
+
+        if @response.respond_to? :content_type
+          pbar = ProgressBar.new("  |_ #{@response.content_type}", @response.content_length)
+        else
+          pbar = nil
+        end
+
+        @response.read_body { |part|
+          total += part.length
+          body.write(part)
+
+          pbar.set(total) if pbar
+          Mechanize.log.debug("Read #{total} bytes") if Mechanize.log
+        }
+
+        pbar.finish if pbar
+
+        body.rewind
+
+        res_klass = Net::HTTPResponse::CODE_TO_OBJ[@response.code.to_s]
+        raise ResponseCodeError.new(@response) unless res_klass
+
+        # Net::HTTP ignores EOFError if Content-length is given, so we emulate it here.
+        unless res_klass <= Net::HTTPRedirection
+          raise EOFError if (!params[:request].is_a?(Net::HTTP::Head)) && @response.content_length() && @response.content_length() != total
+        end
+
+        @response.each_header { |k,v|
+          Mechanize.log.debug("response-header: #{ k } => #{ v }")
+        } if Mechanize.log
+
+        params[:response_body] = body
+        params[:res_klass] = res_klass
+        super
+      end
+    end
+  end
+end

data/lib/epitools/progressbar.rb

@@ -0,0 +1,269 @@
+#
+# Ruby/ProgressBar - a text progress bar library
+#
+# Copyright (C) 2001-2005 Satoru Takabayashi <satoru@namazu.org>
+# Copyright (C) 2010 Chris Gahan <chris@ill-logic.com>
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms
+# of Ruby's license.
+#
+
+class ProgressBar
+  VERSION = "0.10"
+
+  def initialize (title, total=nil, out = STDERR)
+    @title = title
+    @total = total
+    @out = out
+    @terminal_width = 80
+    @bar_mark = "."
+    @current = 0
+    @previous = 0
+    @finished_p = false
+    @start_time = Time.now
+    @previous_time = @start_time
+    @title_width = 18
+    #@format = "%-#{@title_width}s %3d%% %s %s"
+    if @total
+      #@format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]
+      @format_arguments = [:title, :percentage, :stat_for_file_transfer]
+    else
+      @format_arguments = [:title, :stat_for_file_transfer]
+    end
+
+    clear
+    show
+  end
+  
+  attr_reader   :title
+  attr_reader   :current
+  attr_reader   :total
+  attr_accessor :start_time
+
+  private
+  def fmt_bar
+    bar_width = do_percentage * @terminal_width / 100
+    sprintf("|%s%s|", 
+            @bar_mark * bar_width, 
+            " " *  (@terminal_width - bar_width))
+  end
+
+  def fmt_percentage
+    "%3d%%" % do_percentage
+  end
+
+  def fmt_stat
+    if @finished_p then elapsed else eta end
+  end
+
+  def fmt_stat_for_file_transfer
+    if !@total or @finished_p then
+      sprintf("%s %s %s", bytes, transfer_rate, elapsed)
+    else 
+      sprintf("%s %s %s", bytes, transfer_rate, eta)
+    end
+  end
+
+  def fmt_title
+    title = (@title[0,(@title_width - 1)] + ":")
+    @total ? "%-#{@title_width}s" % title : title 
+  end
+
+  def convert_bytes(bytes)
+    if bytes < 1024
+      sprintf("%6dB", bytes)
+    elsif bytes < 1024 * 1000 # 1000kb
+      sprintf("%5.1fKB", bytes.to_f / 1024)
+    elsif bytes < 1024 * 1024 * 1000  # 1000mb
+      sprintf("%5.1fMB", bytes.to_f / 1024 / 1024)
+    else
+      sprintf("%5.1fGB", bytes.to_f / 1024 / 1024 / 1024)
+    end
+  end
+
+  def transfer_rate
+    bytes_per_second = @current.to_f / (Time.now - @start_time)
+    sprintf("%s/s", convert_bytes(bytes_per_second))
+  end
+
+  def bytes
+    convert_bytes(@current)
+  end
+
+  def format_time(t)
+    t = t.to_i
+    sec = t % 60
+    min  = (t / 60) % 60
+    hour = t / 3600
+    sprintf("%02d:%02d:%02d", hour, min, sec);
+  end
+
+  # ETA stands for Estimated Time of Arrival.
+  def eta
+    if @current == 0
+      "ETA:  --:--:--"
+    else
+      elapsed = Time.now - @start_time
+      eta = elapsed * @total / @current - elapsed;
+      sprintf("ETA:  %s", format_time(eta))
+    end
+  end
+
+  def elapsed
+    elapsed = Time.now - @start_time
+    sprintf("Time: %s", format_time(elapsed))
+  end
+  
+  def eol
+    if @finished_p then "\n" else "\r" end
+  end
+
+  def do_percentage
+    if @total.zero?
+      100
+    else
+      @current  * 100 / @total
+    end
+  end
+
+  def get_width
+    # FIXME: I don't know how portable it is.
+    default_width = 80
+    begin
+      tiocgwinsz = 0x5413
+      data = [0, 0, 0, 0].pack("SSSS")
+      if @out.ioctl(tiocgwinsz, data) >= 0 then
+        rows, cols, xpixels, ypixels = data.unpack("SSSS")
+        if cols >= 0 then cols else default_width end
+      else
+        default_width
+      end
+    rescue Exception
+      default_width
+    end
+  end
+
+  def show
+    arguments = @format_arguments.map {|method|
+      send("fmt_#{method}")
+    }
+    #line = sprintf(@format, *arguments)
+    line = arguments.join(" ")
+
+#    width = get_width
+#    if line.length == width - 1
+#      @out.print(line + eol)
+#      @out.flush
+#    elsif line.length >= width
+#      @terminal_width = [@terminal_width - (line.length - width + 1), 0].max
+#      if @terminal_width == 0 then @out.print(line + eol) else show end
+#    else # line.length < width - 1
+#      @terminal_width += width - line.length + 1
+#      show
+#    end
+    @out.print(line + eol)
+    @out.flush
+    
+    @previous_time = Time.now
+  end
+
+
+  def show_if_needed
+
+    if @total
+
+      if @total.zero?
+        cur_percentage = 100
+        prev_percentage = 0
+      else
+        cur_percentage  = (@current  * 100 / @total).to_i
+        prev_percentage = (@previous * 100 / @total).to_i
+      end
+
+      # Use "!=" instead of ">" to support negative changes
+      if cur_percentage != prev_percentage ||
+          Time.now - @previous_time >= 1 || @finished_p
+        show
+      end
+
+    else
+
+      if Time.now - @previous_time >= 1 || @finished_p
+        show
+      end
+
+    end
+
+  end
+
+  public
+  def clear
+    @out.print "\r"
+    @out.print(" " * (get_width - 1))
+    @out.print "\r"
+  end
+
+  def finish
+    @current = @total if @total
+    @finished_p = true
+    show
+  end
+
+  def finished?
+    @finished_p
+  end
+
+  def file_transfer_mode
+    @format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]
+  end
+
+  def format=(format)
+    @format = format
+  end
+
+  def format_arguments=(arguments)
+    @format_arguments = arguments
+  end
+
+  def halt
+    @finished_p = true
+    show
+  end
+
+  def inc(step = 1)
+    @current += step
+    @current = @total if @total and @current > @total
+    show_if_needed
+    @previous = @current
+  end
+
+  def set(count)
+    if @total and (count < 0 || count > @total)
+      raise "invalid count: #{count} (total: #{@total})"
+    end
+    @current = count
+    show_if_needed
+    @previous = @current
+  end
+
+  def inspect
+    "#<ProgressBar:#{@current}/#{@total}>"
+  end
+end
+
+class ReversedProgressBar < ProgressBar
+  def do_percentage
+    100 - super
+  end
+end
+
+if $0 == __FILE__
+  pb = ProgressBar.new("no_total")
+  5.times do
+    pb.inc 4000
+    sleep 1
+  end
+  pb.finish
+end

data/lib/epitools/sys.rb

@@ -0,0 +1,398 @@
+#
+# Cross-platform operating system functions.
+# Includes: process listing, platform detection, etc.
+#
+module Sys
+  
+  #-----------------------------------------------------------------------------
+
+  PS_FIELD_TABLE = [
+    [:pid,    :to_i],
+    [:pcpu,   :to_f],
+    [:pmem,   :to_f],
+    [:stat,   :to_s],
+    [:rss,    :to_i],
+    [:vsz,    :to_i],
+    [:user,   :to_s],
+    [:majflt, :to_i],
+    [:minflt, :to_i],
+    [:command,:to_s],
+  ]
+  
+  PS_FIELDS             = PS_FIELD_TABLE.map { |name, func| name }
+  PS_FIELD_TRANSFORMS   = Hash[ *PS_FIELD_TABLE.flatten ]
+  
+  class ProcessNotFound < Exception; end
+
+  #
+  # Contains all the information that PS can report about a process for
+  # the current platform.
+  #
+  # The following attribute accessor methods are available:
+  #
+  #    pid     (integer)
+  #    pcpu    (float)
+  #    pmem    (float)
+  #    stat    (string)
+  #    rss     (integer)
+  #    vsz     (integer)
+  #    user    (string)
+  #    majflt  (integer)
+  #    minflt  (integer)
+  #    command (string)
+  #    state   (array of symbols; see DARWIN_STATES or LINUX_STATES)
+  #
+  class ProcessInfo < Struct.new(*PS_FIELDS+[:state])
+
+    DARWIN_STATES = {
+      "R"=>:running,
+      "S"=>:sleeping,
+      "I"=>:idle,
+      "T"=>:stopped,
+      "U"=>:wait,
+      "Z"=>:zombie,
+      "W"=>:swapped,
+      
+      "s"=>:session_leader,
+      "X"=>:debugging,
+      "E"=>:exiting,
+      "<"=>:high_priority,
+      "N"=>:low_priority,
+      "+"=>:foreground,
+      "L"=>:locked_pages,
+    }
+    
+    LINUX_STATES = {
+      "R"=>:running,
+      "S"=>:sleeping,
+      "T"=>:stopped,
+      "D"=>:wait,
+      "Z"=>:zombie,
+      "W"=>:swapped,
+      "X"=>:dead,
+
+      "s"=>:session_leader,
+      "<"=>:high_priority,
+      "N"=>:low_priority,
+      "+"=>:foreground,
+      "L"=>:locked_pages,
+      "l"=>:multithreaded,
+    }
+    
+    def initialize(*args)
+      @dead = false
+      args << stat_to_state(args[PS_FIELDS.index(:stat)])
+      super(*args)
+    end
+
+    #
+    # Convert all the process information to a hash.
+    #    
+    def to_hash
+      Hash[ *members.zip(values).flatten(1) ]
+    end
+    
+    #
+    # Send the TERM signal to this process.
+    #
+    def kill!(signal="TERM")
+      puts "Killing #{pid} (#{signal})"
+      Process.kill(signal, pid)
+      # TODO: handle exception Errno::ESRCH (no such process)
+    end
+    
+    #
+    # Has this process been killed?
+    #
+    def dead?
+      @dead ||= Sys.pid(pid).empty?
+    end
+    
+    #
+    # Refresh this process' statistics.
+    #
+    def refresh
+      processes = Sys.ps(pid)
+      
+      if processes.empty?
+        @dead = true
+        raise ProcessNotFound
+      end
+      
+      updated_process = processes.first
+      members.each { |member| self[member] = updated_process[member] }
+      self
+    end
+
+    private 
+    
+    def stat_to_state(str)
+      states = case Sys.os
+        when "Linux"  then LINUX_STATES
+        when "Darwin" then DARWIN_STATES
+        else raise "Unsupported platform: #{Sys.os}"
+      end
+      
+      str.scan(/./).map { |char| states[char] }.compact
+    end
+    
+  end
+
+  #-----------------------------------------------------------------------------
+  
+  #
+  # List all (or specified) processes, and return ProcessInfo objects.
+  # (Takes an optional list of pids as arguments.) 
+  #
+  def self.ps(*pids)
+    options = PS_FIELDS.join(',')
+    
+    if pids.any?
+      command = "ps -p #{pids.join(',')} -o #{options}"
+    else
+      command = "ps ax -o #{options}"
+    end
+
+    lines = `#{command}`.to_a        
+
+    lines[1..-1].map do |line|
+      fields = line.split
+      if fields.size > PS_FIELDS.size
+        fields = fields[0..PS_FIELDS.size-2] + [fields[PS_FIELDS.size-1..-1].join(" ")] 
+      end
+      
+      fields = PS_FIELDS.zip(fields).map { |name, value| value.send(PS_FIELD_TRANSFORMS[name]) }
+      
+      ProcessInfo.new(*fields)
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+
+  #
+  # Return the current operating system: Darwin, Linux, or Windows. 
+  #
+  def self.os
+    return @os if @os
+
+    require 'rbconfig'
+    host_os = Config::CONFIG['host_os']
+    case host_os
+      when /darwin/
+        @os = "Darwin"
+      when /linux/
+        @os = "Linux"
+      when /mingw|mswin/
+        @os = 'Windows'
+    else
+      raise "Unknown OS: #{host_os.inspect}"
+    end
+
+    @os
+  end
+  
+  #
+  # Is this Linux?
+  #
+  def self.linux?
+    os == "Linux"
+  end
+
+  #
+  # Is this Windows?
+  #
+  def self.windows?
+    os == "Windows"
+  end
+
+  #
+  # Is this Darwin?
+  #
+  def self.darwin?
+    os == "Darwin"
+  end
+
+  #
+  # Is this a Mac? (aka. Darwin?)
+  #
+  def self.mac?; darwin?; end
+  
+  #-----------------------------------------------------------------------------
+
+  #
+  # Trap signals!
+  #
+  # usage: trap("EXIT", "HUP", "ETC", :ignore=>["VTALRM"]) { |signal| puts "Got #{signal}!" }
+  # (Execute Signal.list to see what's available.)
+  #
+  # No paramters defaults to all signals except VTALRM, CHLD, CLD, and EXIT.
+  #  
+  def self.trap(*args, &block)
+    options = if args.last.is_a?(Hash) then args.pop else Hash.new end
+    args = [args].flatten
+    signals = if args.any? then args else Signal.list.keys end
+
+    ignore = %w[ VTALRM CHLD CLD EXIT ] unless ignore = options[:ignore]
+    ignore = [ignore] unless ignore.is_a? Array
+
+    signals = signals - ignore
+
+    signals.each do |signal|
+      p [:sig, signal]
+      Signal.trap(signal) { yield signal }
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+
+  #
+  # A metaprogramming helper that allows you to write platform-specific methods
+  # which the user can call with one name. Here's how to use it:
+  #
+  # Define these methods: 
+  #   reboot_linux, reboot_darwin, reboot_windows
+  #
+  # Call the magic method:
+  #   cross_platform_method(:reboot)
+  #
+  # Now the user can execute "reboot" on any platform!
+  #
+  # (Note: If you didn't create a method for a specific platform, then you'll get
+  # NoMethodError exception when the "reboot" method is called on that platform.)
+  #  
+  def self.cross_platform_method(name)
+    platform_method_name = "#{name}_#{os.downcase}"
+    metaclass.instance_eval do
+      define_method(name) do |*args|
+        begin
+          self.send(platform_method_name, *args)
+        rescue NoMethodError
+          raise NotImplementedError.new("#{name} is not yet supported on this platform.")
+        end
+      end
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+
+  cross_platform_method :interfaces
+
+  #
+  # Darwin: Return a hash of (device, IP address) pairs.
+  #
+  # eg: {"en0"=>"192.168.1.101"}
+  #
+  def self.interfaces_darwin
+    sections = `ifconfig`.split(/^(?=[^\t])/)
+    sections_with_relevant_ip = sections.select {|i| i =~ /inet/ }
+
+    device_ips = {}
+    sections_with_relevant_ip.each do |section|
+      device  = section[/[^:]+/]
+      ip      = section[/inet ([^ ]+)/, 1]
+      device_ips[device] = ip
+    end
+
+    device_ips
+  end
+
+  #
+  # Linux: Return a hash of (device, IP address) pairs.
+  #
+  # eg: {"eth0"=>"192.168.1.101"}
+  #
+  def self.interfaces_linux
+    sections = `ifconfig`.split(/^(?=Link encap:Ethernet)/)
+    sections_with_relevant_ip = sections.select {|i| i =~ /inet/ }
+
+    device_ips = {}
+    sections_with_relevant_ip.each do |section|
+      device  = section[/([\w\d]+)\s+Link encap:Ethernet/, 1]
+      ip      = section[/inet addr:([^\s]+)/, 1]
+      device_ips[device] = ip
+    end
+
+    device_ips
+  end
+  
+  #-----------------------------------------------------------------------------
+
+  cross_platform_method :browser_open
+
+  #
+  # Linux: Open an URL in the default browser (using "gnome-open").
+  #
+  def browser_open_linux(url)
+    system("gnome-open", url)
+  end
+
+  #
+  # Darwin: Open the webpage in a new chrome tab.
+  #
+  def browser_open_darwin(url)
+    system("open", "-a", "chrome", url)
+  end
+
+  #-----------------------------------------------------------------------------
+
+  cross_platform_method :memstat
+
+  def self.memstat_linux
+    #$ free
+    #             total       used       free     shared    buffers     cached
+    #Mem:       4124380    3388548     735832          0     561888     968004
+    #-/+ buffers/cache:    1858656    2265724
+    #Swap:      2104504     166724    1937780
+    
+    #$ vmstat
+    raise "Not implemented"    
+  end
+  
+  def self.memstat_darwin
+    #$ vm_stat
+    #Mach Virtual Memory Statistics: (page size of 4096 bytes)
+    #Pages free:                         198367.
+    #Pages active:                       109319.
+    #Pages inactive:                      61946.
+    #Pages speculative:                   18674.
+    #Pages wired down:                    70207.
+    #"Translation faults":            158788687.
+    #Pages copy-on-write:              17206973.
+    #Pages zero filled:                54584525.
+    #Pages reactivated:                    8768.
+    #Pageins:                            176076.
+    #Pageouts:                             3757.
+    #Object cache: 16 hits of 255782 lookups (0% hit rate)
+
+    #$ iostat
+    raise "Not implemented"    
+  end
+
+  def self.temperatures
+    #/Applications/Utilities/TemperatureMonitor.app/Contents/MacOS/tempmonitor -a -l
+    #CPU Core 1: 28 C
+    #CPU Core 2: 28 C
+    #SMART Disk Hitachi HTS543216L9SA02 (090831FBE200VCGH3D5F): 40 C
+    #SMC CPU A DIODE: 41 C
+    #SMC CPU A HEAT SINK: 42 C
+    #SMC DRIVE BAY 1: 41 C
+    #SMC NORTHBRIDGE POS 1: 46 C
+    #SMC WLAN CARD: 45 C
+    raise "Not implemented"    
+  end
+
+end  
+
+if $0 == __FILE__
+  require 'pp'
+  procs = Sys.ps
+  p [:processes, procs.size]
+#  some = procs[0..3]
+#  some.each{|ps| pp ps}
+#  some.first.kill!
+#  pp some.first.to_hash
+#  p [:total_cpu, procs.map{|ps| ps.pcpu}.sum]
+#  p [:total_mem, procs.map{|ps| ps.pmem}.sum]
+
+  pp Sys.interfaces
+end

data/spec/basetypes_spec.rb

@@ -7,10 +7,10 @@ describe Object do
     defined?(Enum).should_not == nil
   end
   
-  it "enums" do
-    generator = enum { |y| y.yield 1 }
-    generator.next.should == 1
-  end
+  #it "enums" do
+  #  generator = enum { |y| y.yield 1 }
+  #  generator.next.should == 1
+  #end
   
   it "in?" do
     5.in?([1,2,3,4,5,6]).should == true

data/spec/browser_spec.rb

@@ -0,0 +1,14 @@
+require 'epitools/browser'
+
+describe Browser do
+
+  before :all do
+    @browser = Browser.new
+  end
+  
+  it "googles" do
+    page = @browser.get("http://google.com")
+    page.body["Feeling Lucky"].should_not be_empty
+  end
+
+end

data/spec/sys_spec.rb

@@ -0,0 +1,64 @@
+require 'epitools/sys'
+
+describe Sys::ProcessInfo do
+
+  specify "checks OS" do
+    proc { Sys.os }.should_not raise_error
+    proc { Sys.linux? }.should_not raise_error
+    proc { Sys.mac? }.should_not raise_error
+    proc { Sys.darwin? }.should_not raise_error
+
+    %w[Linux Windows Darwin].include?(Sys.os).should == true
+    
+    ( (Sys.linux? and not Sys.mac?) or (Sys.mac? and not Sys.linux?) ).should == true
+  end
+    
+  
+  specify "list all processes" do
+#    procs = Sys.ps
+#
+#    procs.first.state.is_a?(Array).should == true
+#
+#    pids = procs.map{ |process| process.pid }
+#
+#    p2s = Hash[ *Sys.ps(*pids).map { |process| [process.pid, process] }.flatten ]
+#    matches = 0
+#    procs.each do |p1|
+#      if p2 = p2s[p1.pid]
+#        matches += 1
+#        p1.command.should == p2.command
+#      end
+#    end
+#
+#    matches.should > 1
+  end
+
+  
+  specify "refresh processes" do
+
+#    STDOUT.sync = true
+#
+#    procs = Sys.ps
+#    procs.shuffle!
+#    procs.each do |process|
+#      proc do
+#        begin
+#          process.refresh
+#          print "."
+#        rescue Sys::ProcessNotFound
+#        end
+#      end.should_not raise_error
+#    end
+#
+#    puts
+
+  end
+
+
+  specify "cross-platform method" do
+    Sys.interfaces.should_not be_nil
+    Sys.cross_platform_method(:cross_platform_test)
+    proc{ Sys.cross_platform_test }.should raise_error
+  end
+  
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: epitools
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 11
-  version: 0.1.11
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - epitron
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-25 00:00:00 -04:00
+date: 2010-09-28 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -53,6 +53,9 @@ files:
 - epitools.gemspec
 - lib/epitools.rb
 - lib/epitools/basetypes.rb
+- lib/epitools/browser.rb
+- lib/epitools/browser/browser_cache.rb
+- lib/epitools/browser/mechanize_progressbar.rb
 - lib/epitools/hexdump.rb
 - lib/epitools/http.rb
 - lib/epitools/lcs.rb
@@ -60,12 +63,15 @@ files:
 - lib/epitools/niceprint.rb
 - lib/epitools/permutations.rb
 - lib/epitools/pretty_backtrace.rb
+- lib/epitools/progressbar.rb
 - lib/epitools/rails.rb
 - lib/epitools/rash.rb
 - lib/epitools/ratio.rb
 - lib/epitools/string_to_proc.rb
+- lib/epitools/sys.rb
 - lib/epitools/zopen.rb
 - spec/basetypes_spec.rb
+- spec/browser_spec.rb
 - spec/lcs_spec.rb
 - spec/metaclass_spec.rb
 - spec/permutations_spec.rb
@@ -73,6 +79,7 @@ files:
 - spec/ratio_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/sys_spec.rb
 - spec/zopen_spec.rb
 has_rdoc: true
 homepage: http://github.com/epitron/epitools
@@ -109,11 +116,13 @@ signing_key:
 specification_version: 3
 summary: NOT UTILS... METILS!
 test_files: 
+- spec/sys_spec.rb
+- spec/permutations_spec.rb
 - spec/rash_spec.rb
-- spec/ratio_spec.rb
-- spec/metaclass_spec.rb
-- spec/basetypes_spec.rb
+- spec/spec_helper.rb
+- spec/browser_spec.rb
 - spec/lcs_spec.rb
+- spec/basetypes_spec.rb
+- spec/ratio_spec.rb
 - spec/zopen_spec.rb
-- spec/permutations_spec.rb
-- spec/spec_helper.rb
+- spec/metaclass_spec.rb