muby 0.6.6

data/lib/muby/helper_methods.rb

@@ -0,0 +1,46 @@
+
+module Muby
+
+  module HelperMethods
+    
+    def execute(command, *args)
+      execute_with_verbosity(:debug, command, *args)
+    end
+
+    def execute_with_verbosity(verbosity, command, *args)
+      begin
+        result = nil
+        if Proc === command
+          result = command.call(*args[0...(command.arity)])
+        elsif String === command
+          result = eval(command)
+        elsif Symbol === command
+          method = self.method(command)
+          args = args[0...(method.arity)]
+          result = method.call(*args)
+        elsif Array === command
+          method = self.method(command.first)
+          args = (command[1..-1] + args)[0...(method.arity)]
+          result = method.call(*args)
+        else
+          result = command
+        end
+        unless result.nil?
+          case result
+          when String
+            Muby::OutputWindow.get_instance.show(verbosity, result)
+          else
+            Muby::OutputWindow.get_instance.show(verbosity, result.inspect)
+          end
+        end
+        result
+      rescue SystemExit => ex
+        quit
+      rescue Exception => e
+        exception(e)
+      end
+    end
+    
+  end
+
+end

data/lib/muby/inputwindow.rb

@@ -0,0 +1,173 @@
+
+require 'pathname'
+
+#
+# The fancy window that gets our input.
+# 
+# The class handles everything to do with
+# the input window itself, the user callable
+# methods are in the UserMethods module.
+#
+# All commands entered with conf.escape_character will be eval'd in
+# this class scope.
+#
+class Muby::InputWindow
+
+  include Muby::Logger
+  include Muby::Configurable
+  include Muby::Displayer
+  include Muby::UserMethods
+  include Muby::Styled
+  include Muby::HelperMethods
+
+  @@instance = nil
+
+  def self.get_instance
+    @@instance ||= Muby::InputWindow.new
+  end
+
+  attr_reader :history
+
+  #
+  # Start working!
+  #
+  def go
+    # Init all the default values
+    @buffer = ""
+    @cursorPosition = 0
+    @history = []
+    @historyPointer = nil
+    @connection = nil
+    @statusLine = ""
+    @messageLine = ""
+    @recent_escape = []
+    @handle_mode = :append_buffer!
+
+    # Init the input box
+    @inputBorder = Ncurses.newwin(height, width, top, left)
+    @inputBorder.box(0,0)
+    @inputBorder.keypad(true)
+    @inputBorder.refresh
+
+    # Init the window itself
+    @inputWindow = Ncurses.newwin(height - 2, width - 2, top + 1, left + 1)
+    @inputWindow.keypad(true)
+    @inputWindow.scrollok(true)
+    @inputWindow.nodelay(true)
+    @inputWindow.refresh
+
+    help unless conf.user_edited_config_file
+  end
+  
+  def left
+    execute_with_verbosity(:trace, conf.input_window_geometry[:left])
+  end
+
+  def top
+    execute_with_verbosity(:trace, conf.input_window_geometry[:top])
+  end
+
+  def width
+    execute_with_verbosity(:trace, conf.input_window_geometry[:width])
+  end
+
+  def height
+    execute_with_verbosity(:trace, conf.input_window_geometry[:height])
+  end
+
+  #
+  # Update the input box, redrawing borders and text etc.
+  #
+  def update
+    @inputBorder.box(0,0)
+    @inputBorder.mvwprintw(0,1,"%s", @statusLine)
+    @inputBorder.mvwprintw(height - 1, 1, "%s", @messageLine)
+    @inputBorder.refresh
+
+    @inputWindow.werase
+    row = 0
+    col = @cursorPosition
+    while col > width - 2
+      row = row + 1
+      col = col - width - 2
+    end
+    @inputWindow.mvwprintw(row,col,"%s", @buffer[@cursorPosition,@buffer.size - @cursorPosition])
+    @inputWindow.mvwprintw(0,0,"%s", @buffer[0, @cursorPosition])
+    @inputWindow.refresh
+  end
+
+  #
+  # Save our history into the history file.
+  #
+  def saveHistory
+    # This should be wrapped in something else, which checks for sanity (writability)
+    dir = Pathname.new(conf.history_file).parent
+    dir.mkpath unless dir.exist?
+    file = Pathname.new(conf.history_file)
+    file.open("w") do |output|
+      Marshal.dump(@history, output)
+    end
+  end
+
+  #
+  # Load our history from the history file.
+  #
+  def loadHistory
+    begin
+      if FileTest.readable?(conf.history_file)
+        info("Reading history file")
+        Kernel::open(conf.history_file) do |input|
+          @history = Marshal.load(input.read)
+        end
+        @history.each do |line|
+          Muby::Completer.get_instance.store(line)
+        end if conf.feed_completer_with_history
+      end
+    rescue Exception => e
+      exception(e)
+    end
+    @history ||= []
+  end
+
+  def handle(c, hash)
+    # Echo the keycode we got if we have conf.echo_keycodes == true (good for setting up conf.key_commands)
+    if conf.echo_keycodes && c != Ncurses.const_get("ERR")
+      info(c.to_s)
+    end
+    if hash.include?(c)
+      value = hash[c]
+      if Hash === value
+        c = @inputWindow.wgetch
+        if value.include?(c)
+          handle(c, value)
+        else
+          handle(c, conf.key_commands)
+        end
+      else
+        execute(value, self, Muby::OutputWindow.get_instance, c)
+      end
+    elsif 0 < c && c < 265
+      method = self.method(@handle_mode)
+      method.call(c)
+    end
+  end
+
+  #
+  # Just keep listening to the keyboard input.
+  #
+  def process
+    loadHistory
+    conf.startup_triggers.each do |trigger|
+      execute(trigger, self, Muby::OutputWindow.get_instance)
+    end
+    # We need to check one key at a time due to triggers and conf.key_commands
+    while c = @inputWindow.wgetch
+      if c == Ncurses.const_get("ERR")
+        sleep(0.01)
+      else
+        handle(c, conf.key_commands)
+      end
+    end # while c = @inputWindow.wgetch
+  end # def process
+
+end # class InputWindow

data/lib/muby/logger.rb

@@ -0,0 +1,28 @@
+#
+# A simple logger that logs to whatever logfiles you have defined
+# in your preferences.
+#
+module Muby::Logger
+
+  include Muby::Configurable
+  
+  #
+  # Logs everything that gets read from the remote connection.
+  #
+  def log_input(c)
+    if conf.input_logfile
+      conf.input_logfile.write(c)
+      conf.input_logfile.flush
+    end
+  end
+
+  #
+  # Logs everything that gets sent to the remote connection.
+  #
+  def log_output(c)
+    if conf.output_logfile
+      conf.output_logfile.write(c)
+      conf.output_logfile.flush
+    end
+  end
+end # module Logger

data/lib/muby/outputwindow.rb

@@ -0,0 +1,189 @@
+#
+# The class that controls what we see.
+#
+class Muby::OutputWindow
+
+  include Muby::Logger
+  include Muby::Configurable
+  include Muby::HelperMethods
+  include Muby::Displayer
+
+  attr_reader :scrollback, :size, :outputBuffer
+
+  @@instance = nil
+
+  def self.get_instance
+    @@instance ||= Muby::OutputWindow.new
+  end
+
+  def initialize
+    @ready = false
+  end
+
+  def ready?
+    @ready
+  end
+
+  #
+  # Start working!
+  #
+  def go
+    @scrollback = 0
+    @waitBuffer = []
+    @lines = 0
+
+    @outputBuffer = Ncurses.newpad(conf.output_buffer, width)
+    @outputBuffer.wclear
+    @outputBuffer.scrollok(true)
+    @outputBuffer.idlok(true)
+    defaultAttributes = Muby::Style.new(conf.default_attributes, conf.default_colors[0], conf.default_colors[1])
+    defaultAttributes.affect(@outputBuffer)
+    # Prepare the output window:
+    @outputBuffer.mvprintw(conf.output_buffer - 1, 0, "\n")
+
+    show_version
+    refresh
+    
+    @ready = true
+  end
+
+  def reload!
+    @left = nil
+    @top = nil
+    @width = nil
+    @height = nil
+  end
+
+  def left
+    @left ||= execute_with_verbosity(:trace, conf.output_window_geometry[:left])
+  end
+
+  def top
+    @top ||= execute_with_verbosity(:trace, conf.output_window_geometry[:top])
+  end
+
+  def width
+    @width ||= execute_with_verbosity(:trace, conf.output_window_geometry[:width])
+  end
+
+  def height
+    @height ||= execute_with_verbosity(:trace, conf.output_window_geometry[:height])
+  end
+
+  def show_version
+    print("
+.--.--.--.     .--.
+:        :--.--:  : .--.--.
+:  :  :  :  :  :  '-:  :  :
+:  :  :  :  :  :  : :  '  :
+'--'--'--'-----'----'--.  :
+  The Ruby MUD Client  :  :
+  -------------------  '--'
+     Version #{Muby::VERSION}
+")
+  end
+
+  #
+  # Refresh the output buffer (if we have scrolled etc)
+  #
+  def refresh
+    @outputBuffer.prefresh(conf.output_buffer - (height * (@scrollback + 1)), 0, top, left, height - 1, width)
+  end
+
+  #
+  # Scroll up, and give the user a message about it.
+  #
+  def scroll_up(inputWindow)
+    if @scrollback * height < conf.output_buffer &&
+        @scrollback * height < @lines
+      @scrollback += 1
+      # BUG: set_message_line is in userMethods.
+      # No, its not a bug.
+      inputWindow.set_message_line("SCROLLED - I/O PAUSED")
+      refresh
+    end
+  end
+
+  #
+  # Scroll down again.
+  #
+  def scroll_down(inputWindow)
+    if @scrollback > 0
+      @scrollback -= 1
+      if @scrollback == 0
+        # BUG:
+        # No
+        inputWindow.set_message_line("")
+        unless @waitBuffer.empty?
+          print(*@waitBuffer)
+          @waitBuffer = []
+        end
+      end
+    end
+    refresh
+  end
+
+  def timestamp(message)
+    if conf.timestamp && @recent_linebreak
+      Time.new.strftime(conf.timeformat) + "\t" + message
+    else
+      message
+    end
+  end
+
+  def show(level, message)
+    if conf.display?(level)
+      to_print = [message, "\n"]
+      if level_attributes = conf.send("#{level}_attributes")
+        level_colors = conf.send("#{level}_colors")
+        style = Muby::Style.new(level_attributes, level_colors[0], level_colors[1])
+        oldStyle = Muby::Style.extract(@outputBuffer)
+        to_print = [style] + to_print + [oldStyle]
+      end
+
+      print_on_newline(*to_print)
+    end
+  end
+
+  def print_on_newline(*info)
+    if @recent_linebreak
+      print(*info)
+    else
+      print(*(["\n"] + info))
+    end
+  end
+
+  #
+  # Print an info Array to the outputBuffer.
+  #
+  # Will print text as is, and add any Styles encountered to the outputBuffer.
+  #
+  def print(*info)
+    if @scrollback == 0
+      info.each do |e|
+        if String === e
+          rest = e
+          while (match = rest.match(/^([^\r\n]*)([\r\n]*)(.*)$/m))
+            to_print = match[1]
+            linebreak = match[2]
+            rest = match[3]
+            
+            break if to_print.empty? and linebreak.empty?
+
+            @outputBuffer.printw("%s", timestamp(to_print) + linebreak)
+
+            @recent_linebreak = !linebreak.empty?
+            @lines += 1 unless linebreak.empty?
+          end
+        elsif Muby::Style === e
+          e.affect(@outputBuffer)
+        end
+      end
+    else
+      @waitBuffer += info
+    end
+    refresh
+    nil
+  end
+
+end # class OutputWindow

data/lib/muby/style.rb

@@ -0,0 +1,142 @@
+module Muby
+
+  #
+  # The encapsulation of all the ncurses horror.
+  #
+  class Style
+
+    include Muby::Logger
+    include Muby::Configurable
+
+    attr_reader :attributes, :color1, :color2
+
+    class ColorPair
+      @@instances = []
+      @@initialized = false
+      def self.init_pairs
+        unless @@initialized
+          1.upto(Ncurses.COLOR_PAIRS - 1) do |n|
+            @@instances << ColorPair.new(n)
+          end
+	  @@initialized = true
+        end
+      end
+      def self.get_pair(fg, bg)
+        init_pairs
+        
+        found = @@instances.find do |color|
+          color.bg == bg && color.fg == fg
+        end
+
+        found = @@instances.find do |color|
+          color.bg.nil? && color.fg.nil?
+        end unless found
+        
+        found = @@instances.sort do |c1, c2|
+          c1.used_at <=> c2.used_at
+        end.first unless found
+        
+        found.use(fg, bg)
+        
+        found
+      end
+
+      attr_accessor :bg, :fg, :number, :used_at
+
+      def initialize(number)
+        @number = number
+        @used_at = Time.new
+      end
+
+      def to_i
+        Ncurses.COLOR_PAIR(@number)
+      end
+
+      def use(fg, bg)
+        @used_at = Time.new
+        if (bg != @bg || fg != @fg)
+          @bg = bg
+          @fg = fg
+          Ncurses.init_pair(@number, @fg, @bg)
+        end
+      end
+    end
+
+    def initialize(attributes, color1, color2, toAdd = false)
+      @attributes = attributes
+      @color1 = color1
+      @color2 = color2
+      @toAdd = toAdd
+    end
+
+    #
+    # Get a Style instance from a window (so we can save it and restore it)
+    #
+    def self.extract(window)
+      tmp = []
+      oldAttributes = []
+      oldAttribute = 0
+      oldColorPair = []
+      oldColor1 = []
+      oldColor2 = []
+
+      window.wattr_get(oldAttributes,oldColorPair,tmp)
+      oldAttribute = oldAttributes[0] ^ Ncurses.COLOR_PAIR(oldColorPair[0])
+      Ncurses.pair_content(oldColorPair[0], oldColor1, oldColor2)
+
+      Muby::Style.new(oldAttribute, oldColor1[0], oldColor2[0])
+    end
+
+    #
+    # Affect the window, either overwriting its style or adding to it.
+    #
+    def affect(window)
+      if @toAdd
+        window.wattron(to_int(window))
+      else
+        window.wattrset(to_int(window))
+      end
+    end
+
+    def get_color_value(fg, bg)
+      Muby::Style::ColorPair.get_pair(fg, bg).to_i
+    end
+
+    #
+    # Get an int representation of this style, to send to ncurses.
+    #
+    def to_int(window)
+      oldAttributes = self.class.extract(window)
+      color1 = @color1 == :copy ? oldAttributes.color1 : @color1 || conf.default_colors[0]
+      color2 = @color2 == :copy ? oldAttributes.color2 : @color2 || conf.default_colors[1]
+      @attributes | get_color_value(color1, color2)
+    end
+
+  end # class Style
+
+  module Styled
+    unless defined?(RED)
+      RED = Muby::Style.new(0, Ncurses.const_get("COLOR_RED"), :copy, true)
+      BLACK = Muby::Style.new(0, Ncurses.const_get("COLOR_BLACK"), :copy, true)
+      GREEN = Muby::Style.new(0, Ncurses.const_get("COLOR_GREEN"), :copy, true)
+      YELLOW = Muby::Style.new(0, Ncurses.const_get("COLOR_YELLOW"), :copy, true)
+      MAGENTA = Muby::Style.new(0, Ncurses.const_get("COLOR_MAGENTA"), :copy, true)
+      BLUE = Muby::Style.new(0, Ncurses.const_get("COLOR_BLUE"), :copy, true)
+      CYAN = Muby::Style.new(0, Ncurses.const_get("COLOR_CYAN"), :copy, true)
+      WHITE = Muby::Style.new(0, Ncurses.const_get("COLOR_WHITE"), :copy, true)
+      
+      BOLD = Muby::Style.new(Ncurses.const_get("A_BOLD"), :copy, :copy, true)
+      DIM = Muby::Style.new(Ncurses.const_get("A_DIM"), :copy, :copy, true)
+      UNDERLINE = Muby::Style.new(Ncurses.const_get("A_UNDERLINE"), :copy, :copy, true)
+      BLINK = Muby::Style.new(Ncurses.const_get("A_BLINK"), :copy, :copy, true)
+      REVERSE = Muby::Style.new(Ncurses.const_get("A_REVERSE"), :copy, :copy, true)
+      INVIS = Muby::Style.new(Ncurses.const_get("A_INVIS"), :copy, :copy, true)
+      STANDOUT = Muby::Style.new(Ncurses.const_get("A_STANDOUT"), :copy, :copy, true)
+      PROTECT = Muby::Style.new(Ncurses.const_get("A_PROTECT"), :copy, :copy, true)
+      ALTCHARSET = Muby::Style.new(Ncurses.const_get("A_ALTCHARSET"), :copy, :copy, true)
+      CHARTEXT = Muby::Style.new(Ncurses.const_get("A_CHARTEXT"), :copy, :copy, true)
+      
+      NORMAL = Muby::Style.new(Ncurses.const_get("A_NORMAL"), :copy, :copy, false)
+    end
+  end
+end