rb8-trepanning 0.1.3

data/io/input.rb

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Debugger user/command-oriented input possibly attached to IO-style
+# input or GNU Readline.
+# 
+
+require 'rubygems'; require 'require_relative'
+require_relative 'base_io'
+
+module Trepan
+
+  # Debugger user/command-oriented input possibly attached to IO-style
+  # input or GNU Readline.
+  class UserInput < Trepan::InputBase
+
+    @@readline_finalized = false
+
+    def initialize(inp, opts={})
+      @opts         = DEFAULT_OPTS.merge(opts)
+      @input        = inp || STDIN
+      @eof          = false
+      @line_edit    = @opts[:line_edit]
+      @use_readline = @opts[:readline]
+    end
+
+    def closed?; @input.closed? end
+    def eof?; @eof end
+
+    def interactive? 
+      @input.respond_to?(:isatty) && @input.isatty
+    end
+    # Read a line of input. EOFError will be raised on EOF.  
+    def readline(prompt='')
+      raise EOFError if eof?
+      begin 
+        if @line_edit && @use_readline
+          line = Readline.readline(prompt, true)
+        else
+          line = @input.gets
+          end
+      rescue EOFError
+      rescue => e
+        puts $!.backtrace
+        puts "Exception caught #{e.inspect}"
+        @eof = true
+      end
+      @eof = !line
+      raise EOFError if eof?
+      return line
+    end
+    
+    class << self
+      # Use this to set where to read from. 
+      #
+      # Set opts[:line_edit] if you want this input to interact with
+      # GNU-like readline library. By default, we will assume to try
+      # using readline. 
+      def open(inp=nil, opts={})
+        inp ||= STDIN
+        inp = File.new(inp, 'r') if inp.is_a?(String)
+        opts[:line_edit] = @line_edit = 
+          inp.respond_to?(:isatty) && inp.isatty && Trepan::GNU_readline?
+        self.new(inp, opts)
+      end
+
+      def finalize
+       if defined?(RbReadline) && !@@readline_finalized
+          begin 
+            RbReadline.rl_cleanup_after_signal()
+          rescue
+          end
+          begin 
+            RbReadline.rl_deprep_terminal()
+          rescue
+          end
+          @@readline_finalized = true
+        end
+      end
+    end
+  end
+end
+
+module Trepan
+  def suppress_warnings
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original_verbosity
+    return result
+  end  
+  module_function :suppress_warnings
+end
+
+def Trepan::GNU_readline?
+  return @use_readline unless @use_readline.nil?
+  begin
+    require 'rubygems'
+    suppress_warnings { require 'rb-readline' }
+    @use_readline = true
+  rescue LoadError
+    begin
+      suppress_warnings { require 'readline' }
+      @use_readline = true
+    rescue LoadError
+      @use_readline = false
+      return false
+    end
+  else
+    if @use_readline
+      # Returns current line buffer
+      def Readline.line_buffer
+        RbReadline.rl_line_buffer
+      end
+    end
+    at_exit { Trepan::UserInput::finalize }
+    return true
+  end
+end
+    
+# Demo
+if __FILE__ == $0
+  puts 'Have GNU is: %s'  % Trepan::GNU_readline?
+  inp = Trepan::UserInput.open(__FILE__, :line_edit => false)
+  line = inp.readline
+  puts line
+  inp.close
+  filename = 'input.py'
+  begin
+    Trepan::UserInput.open(filename)
+  rescue
+    puts "Can't open #{filename} for reading: #{$!}"
+  end
+  inp = Trepan::UserInput.open(__FILE__, :line_edit => false)
+  while true
+    begin
+      inp.readline
+    rescue EOFError
+      break
+    end
+  end
+  begin
+    inp.readline
+  rescue EOFError
+      puts 'EOF handled correctly'
+  end
+
+  if ARGV.size > 0
+    inp = Trepan::UserInput.open
+    begin
+      print "Type some characters: "
+      line = inp.readline()
+      puts "You typed: %s" % line
+    rescue EOFError
+      puts 'Got EOF'
+    end
+  end
+end

data/io/null_output.rb

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Nukes output. Used for example in sourcing where you don't want
+# to see output.
+# 
+
+require 'rubygems'; require 'require_relative'
+require_relative 'base_io'
+
+class Trepan::OutputNull < Trepan::OutputBase
+  def initialize(out, opts={})
+    @closed = false
+    super
+  end
+  
+  def close
+    @closed = true
+  end
+  
+  def closed?
+    !!@closed
+  end
+  
+  def flush
+  end
+  
+  # Use this to set where to write to. output can be a 
+  # file object or a string. This code raises IOError on error.
+  def write(*args)
+  end
+  
+  # used to write to a debugger that is connected to this
+  # `str' written will have a newline added to it
+  #
+  def writeline( msg)
+  end
+end
+
+# Demo it
+if __FILE__ == $0
+  output = Trepan::OutputNull.new(nil)
+  p output
+  output.write("Invisible")
+  output.writeline("Invisible")
+end

data/io/string_array.rb

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Simulate I/O using lists of strings.
+
+require 'rubygems'; require 'require_relative'
+require_relative 'base_io'
+
+# Simulate I/O using an array of strings. Sort of like StringIO, but
+# even simplier.
+class Trepan::StringArrayInput < Trepan::InputBase
+
+  def initialize(inp, opts={})
+    super
+    @closed = false
+  end
+
+  # this close() interface is defined for class compatibility
+  def close
+    @closed = true 
+  end
+
+  def closed?
+    @closed
+  end
+
+  def eof?
+    @closed || @input.empty?
+  end
+
+  # Nothing to do here. Interface is for compatibility
+  def flush ; end
+
+  # Read a line of input. EOFError will be raised on EOF.  
+  # Note that we don't support prompting
+  def readline
+    raise EOFError if eof?
+    if @input.empty?
+      raise EOFError
+    end
+    line = @input.shift
+    return line 
+  end
+
+  class << self
+    # Use this to set where to read from.
+    def open(inp, opts={})
+      if inp.is_a?(Array)
+        return self.new(inp)
+      else
+        raise IOError, "Invalid input type (%s) for %s" % [inp.class, inp]
+      end
+    end
+  end
+end
+
+# Simulate I/O using an array of strings. Sort of like StringIO, but
+# even simplier.
+class Trepan::StringArrayOutput < Trepan::OutputBase
+
+  def initialize(out=[], opts={})
+    super 
+    @closed = false
+  end
+
+  # Nothing to do here. Interface is for compatibility
+  def close
+    @closed = true 
+  end
+
+  def closed?
+    @closed
+  end
+
+  def eof?
+    @closed || @output.empty? 
+  end
+
+  # Nothing to do here. Interface is for compatibility
+  def flush ; end
+
+  # This method the debugger uses to write. In contrast to
+  # writeline, no newline is added to the end to `str'.
+  #
+  def write(msg)
+    raise ValueError if @closed
+    @output << msg
+  end
+  
+  # used to write to a debugger that is connected to this
+  # server; Here, we use the null string '' as an indicator of a
+  # newline.
+  def writeline(msg)
+    write(msg)
+    write('')
+  end
+
+  class << self
+    # Use this to set where to write to. output can be a 
+    # file object or a string. This code raises IOError on error.
+    # 
+    # If another file was previously open upon calling this open,
+    # that will be stacked and will come back into use after
+    # a close_write().
+    def open(output=[])
+      if output.is_a?(Array)
+        return self.new(output)
+      else
+        raise IOError, ("Invalid output type (%s) for %s" % 
+                        [output.class, output])
+      end
+    end
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  inp  = Trepan::StringArrayInput.open(['Now is the time', 'for all good men'])
+  line = inp.readline
+  p line
+  line = inp.readline
+  p line
+  begin
+    line = inp.readline
+  rescue EOFError
+    puts 'EOF hit on read'
+  end
+
+  out = Trepan::StringArrayOutput.open
+  p out.output
+#    line = io.readline('Type some more characters: ')
+  out.writeline('Hello, world!')
+  p out.output
+  out.write('Hello');
+  p out.output
+  out.writeline(', again.');
+  p out.output
+#     io.open_write(sys.stdout)
+  out.flush_after_write = true
+  out.write('Last hello')
+  puts "Output is closed? #{out.closed?}"
+  out.close
+  p out.output
+  begin
+    out.writeline("You won't see me")
+  rescue
+  end
+
+  # Closing after already closed is okay
+  out.close
+  puts "Output is closed? #{out.closed?}"
+  puts "Input is closed? #{inp.closed?}"
+  inp.close
+  puts "Input is closed? #{inp.closed?}"
+end
+

data/io/tcpclient.rb

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Debugger Socket Input/Output Interface.
+
+require 'socket'
+require 'rubygems'; require 'require_relative'
+require_relative 'base_io'
+require_relative 'tcpfns'
+
+module Trepan 
+  # Debugger Client Input/Output Socket.
+  class TCPDbgClient < Trepan::InOutBase
+
+    include Trepanning::TCPPacking
+
+    DEFAULT_INIT_OPTS = {:open => true}
+
+    CLIENT_SOCKET_OPTS = {
+      :host    => 'localhost', # Symbolic name
+      :port    => 1027,  # Arbitrary non-privileged port
+    }
+
+    attr_reader :state
+
+    def initialize(opts={})
+      @opts      = CLIENT_SOCKET_OPTS.merge(opts)
+      @addr      = nil
+      @buf       = ''
+      @line_edit = false # Our name for GNU readline capability
+      @state     = :disconnected
+      @inout     = nil
+      open(@opts) if @opts[:open]
+    end
+
+    # Closes both input and output
+    def close
+      @state = :closing
+      @inout.close if @inout
+      @state = :disconnected
+    end
+
+    def disconnected?
+      :disconnected == @state
+    end
+
+    def open(opts={})
+      @opts = CLIENT_SOCKET_OPTS.merge(opts)
+      @host = @opts[:host]
+      @port = @opts[:port]
+      begin
+        @inout = TCPSocket.new(@host, @port)
+        @state = :connected
+      rescue SystemCallError => e
+        raise IOError, 
+        ('Open client for host %s on port %s gives error: %s' %
+         [@host, @port, e])
+      end
+    end
+    
+    # Read one message unit. It's possible however that
+    # more than one message will be set in a receive, so we will
+    # have to buffer that for the next read.
+    # EOFError will be raised on EOF.
+    def read_msg
+      if @state == :connected
+        if !@buf || @buf.empty?
+          @buf = @inout.recv(TCP_MAX_PACKET)
+          if @buf.empty?
+            @state = :disconnected
+            raise EOFError
+          end
+        end
+        @buf, data = unpack_msg(@buf)
+        return data
+      else
+        raise IOError, ("read_msg called in state: %s." % @state.to_s)
+      end
+    end
+
+    # This method the debugger uses to write a message unit.
+    def write(msg)
+      # FIXME: do we have to check the size of msg and split output? 
+      @inout.write(pack_msg(msg))
+    end
+
+    def writeline(msg)
+      write(msg + "\n")
+    end
+  end
+end
+
+# Demo
+if __FILE__ == $0
+  client = Trepan::TCPDbgClient.new({'open' => false})
+  if ARGV.size > 0
+    threads = []
+    Thread.new do
+      server = TCPServer.new('localhost', 1027)
+      session = server.accept
+      while 'quit' != (line = session.gets)
+        session.puts line 
+      end
+      session.close
+    end
+
+    threads << Thread.new do
+      print 'Connecting...'
+      client.open()
+      puts 'connected.'
+      while true
+        print "input? "
+        line = STDIN.gets
+        break if line.chomp == 'quit'
+        begin
+          line = client.writeline(line)
+          puts "Got: #{client.read_msg.chomp}"
+        rescue EOFError
+          puts "Got EOF"
+          break
+        rescue Exception => e
+          puts "Got #{e}"
+          break
+        end
+      end
+    end
+    threads.each {|t| t.join }
+  end
+  client.close
+end