muby 0.6.6

data/lib/muby/connection.rb

@@ -0,0 +1,332 @@
+#
+# The class that encapsulates the actual Connection
+#
+class Muby::Connection
+
+  include Muby::Logger
+  include Muby::Configurable
+  include Muby::Displayer
+
+  #
+  # Set it up with windows, handle and host info.
+  #
+  def initialize(inputWindow, outputWindow, host, port)
+    @inputWindow = inputWindow
+    @outputWindow = outputWindow
+    status("Connecting to " + host.inspect + ":" + port.inspect)
+    @host = host
+    @port = port
+    @socket = TCPSocket.open(host, port) if host && port
+    conf.connect_triggers.each do |command|
+      @inputWindow.execute(command, @inputWindow, @outputWindow)
+    end
+    status("Connected to " + host.inspect + ":" + port.inspect)
+    @matchBuffer = ""
+    @showBuffer = []
+    @used_triggers = {}
+    @listener = Thread.new do
+      begin
+        status("Listening thread started")
+        listen
+        status("Listening thread finished")
+      rescue Exception => e
+        exception(e)
+      ensure
+        close
+      end
+    end if @socket
+  end
+
+  #
+  # Display a status message in the outputwindow if wanted (conf.connection_status)
+  #
+  def status(message)
+    if conf.connection_status
+      @outputWindow.print_on_newline(*[message + "\n"])
+    end
+  end
+
+  #
+  # Check if we want to gag the current matchBuffer and debug about it.
+  #
+  # Remove the gag regexp if it is broken.
+  #
+  def gag(matchBuffer)
+    returnValue = false
+    conf.gags.each do |gag|
+      begin
+        if matchBuffer.match(gag)
+          trace(matchBuffer + " matches " + gag.inspect + ": gag active")
+          returnValue = true
+        end
+      rescue RegexpError => error
+        conf.gags.delete(key)
+        exception(e)
+      end
+    end
+    returnValue
+  end
+
+  #
+  # Check if we should definitely NOT gag the current matchBuffer, and debug about it.
+  #
+  # Remove the nongag regexp if it is broken.
+  #
+  def nongag(matchBuffer)
+    returnValue = false
+    conf.anti_gags.each do |nongag|
+      begin
+        if matchBuffer.match(nongag)
+          trace(matchBuffer + " matches " + nongag.inspect + ": nongag active")
+          returnValue = true
+        end
+      rescue RegexpError => error
+        conf.anti_gags.delete(key)
+        exception(e) 
+      end
+    end
+    returnValue
+  end
+
+  #
+  # Check if we should trigger a Proc on the current matchBuffer, and debug about it.
+  #
+  # Remove the trigger regexp if it is broken.
+  #
+  def trigger(matchBuffer, hash, skip_used = true)
+    hash.each do |key, value|
+      if skip_used && @used_triggers.include?(key)
+        trace("#{key.inspect} has already been matched on this line, skipping it")
+      else
+        trace("checking if " + matchBuffer + " matches " + key.inspect)
+        begin
+          if match = matchBuffer.match(key)
+            trace(matchBuffer + " matches " + key.inspect + ": .call'ing Proc")
+            # Run the procedure associated with that trigger:
+            @inputWindow.execute(value, @inputWindow, @outputWindow, match)
+            @used_triggers[key] = true if skip_used
+          end
+          # If we received an error with the regular expression:
+        rescue RegexpError => error
+          hash.delete(key)
+          exception(error)
+        end
+      end
+    end
+  end
+
+  def feed(s)
+    s.unpack("C*").each do |c|
+      handle(c)
+    end
+    nil
+  end
+
+  def getc
+    c = @socket.getc
+    log_input(c.chr) if c
+    c
+  end
+
+  def handle(c)
+    #
+    # The telnet support (just so we dont explode or something)
+    #
+    # We are just plain ignoring it atm.
+    #
+    if c == 255 # telnet interpret as command (IAC)
+      c = getc # get the request (DO|DONT)
+      c = getc # get the latest part whatever that is
+    elsif c == 27 # escape char! this is probably some ANSI color or shite
+      c = getc
+      if c.chr == "[" # this is an ansi-something that is more than one char long
+        ansiString = ""
+        while !"cnRhl()HABCfsurhgKJipm".include?((c = getc).chr)
+          ansiString << c.chr
+        end
+        if c.chr == "m" && Ncurses.has_colors? # ah, text property! i understand this!
+          properties = ansiString.split(";")
+          attributes = 0
+          bgcolor = false
+          fgcolor = false
+          reset = properties.index("0")
+          if reset
+            properties.delete("0")
+          end
+          properties.each do |property|
+            case property.to_i
+            when 1
+              attributes = attributes | Ncurses.const_get("A_BOLD")
+            when 2
+              attributes = attributes | Ncurses.const_get("A_DIM")
+            when 4
+              attributes = attributes | Ncurses.const_get("A_UNDERLINE")
+            when 5
+              attributes = attributes | Ncurses.const_get("A_BLINK") unless conf.disable_blink
+            when 7
+              attributes = attributes | Ncurses.const_get("A_REVERSE")
+            when 8
+              attributes = attributes | Ncurses.const_get("A_INVIS")
+            when 30
+              fgcolor = Ncurses.const_get("COLOR_BLACK")
+            when 31
+              fgcolor = Ncurses.const_get("COLOR_RED")
+            when 32
+              fgcolor = Ncurses.const_get("COLOR_GREEN")
+            when 33
+              fgcolor = Ncurses.const_get("COLOR_YELLOW")
+            when 34
+              fgcolor = Ncurses.const_get("COLOR_BLUE")
+            when 35
+              fgcolor = Ncurses.const_get("COLOR_MAGENTA")
+            when 36
+              fgcolor = Ncurses.const_get("COLOR_CYAN")
+            when 37
+              fgcolor = Ncurses.const_get("COLOR_WHITE")
+            when 40
+              bgcolor = Ncurses.const_get("COLOR_BLACK")
+            when 41
+              bgcolor = Ncurses.const_get("COLOR_RED")
+            when 42
+              bgcolor = Ncurses.const_get("COLOR_GREEN")
+            when 43
+              bgcolor = Ncurses.const_get("COLOR_YELLOW")
+            when 44
+              bgcolor = Ncurses.const_get("COLOR_BLUE")
+            when 45
+              bgcolor = Ncurses.const_get("COLOR_MAGENTA")
+            when 46
+              bgcolor = Ncurses.const_get("COLOR_CYAN")
+            when 47
+              bgcolor = Ncurses.const_get("COLOR_WHITE")
+            end
+          end
+          style = nil
+          if reset
+            style = Muby::Style.new(attributes, fgcolor, bgcolor, false)
+          else
+            style = Muby::Style.new(attributes, fgcolor, bgcolor, true)
+          end
+          @showBuffer.push(style)
+        end
+      end
+    elsif ! conf.broken_keycodes.include?(c)
+      #
+      # This is not telnet command OR ansi, lets treat it as nice MUD text!
+      #
+      # Debug about it, add it to match buffer, add it to show buffer and show if we want to show.
+      # Then check it for triggers.
+      #
+      @matchBuffer = @matchBuffer + c.chr
+      append_show_buffer(c.chr)
+      manage_buffers(c)
+    end
+  end
+
+  def append_show_buffer(c)
+    if String === @showBuffer.last
+      @showBuffer.last << c
+    else
+      @showBuffer << c
+    end
+  end
+
+  #
+  # Keep listening to the remote socket and react accordingly.
+  #
+  def listen
+    c = true
+    # We have to look at each byte for ncurses reasons as well as triggers etc.
+    while c
+      while select([@socket],nil,nil,1) && c = getc
+        handle(c)
+      end
+      if conf.flush
+        display_buffer
+      end
+    end
+    status("Connection closed by remote end")
+    @inputWindow.disconnect
+  end
+
+  def close
+    if Thread.current != @listener && @listener && @listener.alive?
+      status("Killing listening thread")
+      @listener.kill
+    end
+    if @socket && !@socket.closed?
+      status("Disconnecting our end")
+      @socket.close if @socket
+    end
+  end
+
+  def manage_buffers(c)
+    trigger(@matchBuffer, conf.remote_character_triggers, true)
+    if c == 10
+      trigger(@matchBuffer, conf.remote_triggers, false)
+      display_buffer
+      @matchBuffer = ""
+      @used_triggers = {}
+      @showBuffer = []
+    end
+  end
+
+  def homemade_split(s, r)
+    rval = []
+    rest = s
+    while match = rest.match(/(.*?)#{r.source}(.*)/)
+      rval << match[1]
+      rest = match[2]
+    end
+    rval << rest
+    rval
+  end
+
+  def substitute(buffer, hash)
+    return_value = []
+    buffer.each do |part|
+      if String === part
+        part_to_append = [part]
+        hash.each do |regexp, substitution|
+          case substitution
+          when String
+            part_to_append = [part.gsub(regexp, substitution)]
+          when Array
+            if part.match(regexp)
+              split_part = homemade_split(part, regexp)
+              part_to_append = split_part.zip([substitution] * (split_part.size - 1)).flatten.compact
+            end
+          end
+        end
+        return_value += part_to_append
+      else
+        return_value << part
+      end
+    end
+    return_value
+  end
+  
+  def display_buffer
+    unless @showBuffer.empty?
+      if !gag(@matchBuffer) || nongag(@matchBuffer)
+        @showBuffer = substitute(@showBuffer, conf.remote_substitutions)
+        Muby::Completer.get_instance.store(@matchBuffer) if conf.feed_completer_with_input
+        @outputWindow.print(*@showBuffer)
+      end
+      @showBuffer = []
+    end
+  end
+
+  #
+  # Just plain send the string we got.
+  #
+  def send(s)
+    log_output(s)
+    conf.local_substitutions.each do |key, value|
+      # It might be useful to allow colour codes for highlighting local substitutions.. but only when echo is on.
+      # No, cause this only gets sent to the server, it never shows up to the user.
+      s.gsub!(key, value)
+    end
+    @socket.print(s) if @socket
+  end
+end # class Connection

data/lib/muby/displayer.rb

@@ -0,0 +1,60 @@
+
+module Muby
+
+  module Displayer
+
+    def exception(e)
+      error("#{e.class}: #{e.message}")
+      debug(e.backtrace.join("\n"))
+    end
+    
+    def trace(s)
+      if Muby::OutputWindow.get_instance.ready?
+        Muby::OutputWindow.get_instance.show(:trace, s)
+      elsif Muby::Configuration.get.display?(:trace)
+        puts s
+      end
+    end
+
+    def debug(s)
+      if Muby::OutputWindow.get_instance.ready?
+        Muby::OutputWindow.get_instance.show(:debug, s)
+      elsif Muby::Configuration.get.display?(:debug)
+        puts s
+      end
+    end
+
+    def info(s)
+      if Muby::OutputWindow.get_instance.ready?
+        Muby::OutputWindow.get_instance.show(:info, s)
+      elsif Muby::Configuration.get.display?(:info)
+        puts s
+      end
+    end
+
+    def warn(s)
+      if Muby::OutputWindow.get_instance.ready?
+        Muby::OutputWindow.get_instance.show(:warn, s)
+      elsif Muby::Configuration.get.display?(:warn)
+        puts s
+      end
+    end
+
+    def error(s)
+      if Muby::OutputWindow.get_instance.ready?
+        Muby::OutputWindow.get_instance.show(:error, s)
+      elsif Muby::Configuration.get.display?(:error)
+        puts s
+      end
+    end
+
+    module_function :trace
+    module_function :debug
+    module_function :info
+    module_function :warn
+    module_function :error
+    module_function :exception
+
+  end
+
+end

data/lib/muby/help.rb

@@ -0,0 +1,88 @@
+module Muby
+
+  module Help
+    def self.configuration
+      {
+        :feed_completer_with_history => "If true, the completion command will use history to calculate possible completions.",
+        :feed_completer_with_input => "If true, the completion command will use everything seen from the remote end to calculate possible completions.",
+        :extra_completions => "Fill this array with words that you allways want to be able to complete to.",
+        :extra_verbosity_settings => "The settings we want to toggle to when running the toggle_verbosity! method.",
+        :echo_keycodes => "Whether to echo the keycode for every key pressed or not.",
+        :echo => "Whether to print what is sent to the server to the outputwindow.",
+        :show_level => "What level of information to provide the user.
+:trace may tell you each and every step the app takes.
+:debug may tell the user most everything that happens.
+:info will tell the user basically what we are doing.
+:warn will only tell the user when we think he/she may gain from it.
+:error will only tell the user when an error occurs.",
+        :timestamp => "Whether to timestamp all messages in the output window.",
+        :connection_status => "Whether to give status reports on the connections.",
+        :timeformat => "What type of timestamp to use.",
+        :loaded_rc_file => "This will be set to whichever mubyrc file was loaded upon startup.",
+        :disable_blink => "Set this to true if you NEVER want to see BLINKING text from the server.",
+        :broken_keycodes => "Which characters to filter out completely.",
+        :max_history => "The maximum length of the history buffer.",
+        :user_edited_config_file => "Change this to true when you dont want to see the help message anymore.",
+        :default_attributes => "The default ncurses attributes for text.",
+        :default_colors => "The default ncurses colors for text.",
+        :echo_attributes => "The default ncurses attributes for echoed (typed by you, showed in the output window) text.",
+        :echo_colors => "The default ncurses colors for echoed (typed by you, showed in the output window) text.",
+        :trace_attributes => "The default ncurses attributes for messages shown under trace loglevel.",
+        :trace_colors => "The default ncurses colors attributes for messages shown under trace loglevel.",
+        :debug_attributes => "The default ncurses attributes for messages shown under debug loglevel.",
+        :debug_colors => "The default ncurses colors attributes for messages shown under debug loglevel.",
+        :info_attributes => "The default ncurses attributes for messages shown under info loglevel.",
+        :info_colors => "The default ncurses colors attributes for messages shown under info loglevel.",
+        :warn_attributes => "The default ncurses attributes for messages shown under warn loglevel.",
+        :warn_colors => "The default ncurses colors attributes for messages shown under warn loglevel.",
+        :error_attributes => "The default ncurses attributes for messages shown under error loglevel.",
+        :error_colors => "The default ncurses colors attributes for messages shown under error loglevel.",
+        :flush => "Whether to display every char we get as soon as there is a pause in the transfer or a newline.
+In contrast to only displaying the input characters when there is a newline.",
+        :gags => "The gags. All lines from the server are checked against these regular expressions.
+If any one matches that line will not be shown. Note that if you have flush == true, the characters may already have been shown.",
+        :remote_substitutions => "The remote substitutions. 
+The same buffer that the remote_triggers work on will be searched for matches to the keys in this hash.
+All values to matching keys will replace the keys in the buffer.",
+        :local_substitutions => "The local substitutions.
+The text you send to the server will be searched for matches to the keys in this hash.
+All values to matching keys will replace the keys in the text.",
+        :anti_gags => "The anti gags. 
+If flush == false the lines matching these regular expressions will be shown as soon as they are matched.
+A line matching an anti gag and a gag will also be shown.",
+        :shutdown_triggers => "The shutdown triggers. Code in this array will be run in order at shutdown.",
+	:connect_triggers => "The connect triggers. Code in this array will be run in order when a connection is made.",
+        :startup_triggers => "The startup triggers. Code in this array will be run in order after the windows have been properly initialized.",
+        :remote_triggers => 'The remote triggers.
+Each line received from the server will be checked against all regular expression keys in this hash, and all values to matching keys will be executed with three parameters: the input window, the output window and the match object.
+Example: conf.remote_triggers[/^You feel dazed$/] = Proc.new do |inwin, outwin, match| inwin.set_status_message("dazed") end',
+        :remote_character_triggers => 'The remote character triggers.
+All input from the server is added to a buffer that is cleared on newline and each time a new character is added to that buffer the buffer will be checked against all the regular expression keys in the remote_character_triggers.
+All code values belonging to matching keys will be executed with three parameters: the input window, the output window and the match object.
+Example: conf.remote_character_triggers[/^(\S+) attacks you$/] = Proc.new do |inwin, outwin, match| inwin.send("kill #{match[1]}") end',
+        :local_triggers => 'The local triggers.
+Every line that is to be sent to the server is matched against the regular expression keys in this hash before they are sent.
+All code values belonging to matching keys will be executed with three parameters: the input window, the output window and the match object.
+Only if the return value of this execution is not false will the line be sent to the server.
+Example: conf.local_triggers[/^bp (\S+)$/] = Proc.new do |inwin, outwin, match| inwin.send("put #{match[1]} in backpack") end',
+        :key_commands => 'The key commands.
+Each key pressed will have its keycode checked against the integer keys of this hash.
+If no key match and the keycode is below 256, the character corresponding to this code will be appended to the input line.
+If a key matches the value in the hash will be checked.
+If the value is another hash a new key will be waited for, and the same procedure will take place with the value hash instead.
+If the value is not a hash it will be executed as code with three parameters: the input window, the output window and the matching key.
+Example: conf.key_commands[65] = Proc.new do |inwin, outwin, char| inwin.echo("I just pressed A") end',
+        :userdir => 'The user directory. All *.rb files in this directory will be loaded on startup and on reload_application!
+The root of the user directory takes precidence over (overrides) sub-directories.
+Symbolic links (files and directories) are also used.
+Directories beginning with a period are ignored.',
+        :history_file => 'The file where we will store the history of entered commands.',
+        :output_buffer => 'The number of rows that will be buffered in the output window for scrollback.',
+        :input_height => 'The number of rows in the input window.',
+        :input_logfile => 'The IO object that will receive everything we receive from the remote end.',
+        :output_logfile => 'The IO object that will receive everything we send to the remote end.'
+      }
+    end
+  end
+
+end