lijab 0.1.1

data/lib/lijab/input.rb

@@ -0,0 +1,234 @@
+require 'readline'
+require 'readline/extra'
+
+module Lijab
+
+module InputHandler
+
+   DEFAULT_PROMPT = "> "
+
+   @prompt = DEFAULT_PROMPT
+   @last_to = ""
+   @last_typed = ""
+   @multiline = false
+   @multilines = []
+
+   module_function
+
+   def init
+      Readline::completer_word_break_characters = ""
+      Readline::completion_append_character = " "
+      Readline::completion_proc = method(:completer).to_proc
+      Readline::pre_input_proc = lambda do
+         print "#{ANSI.cleartoeol}" ; STDOUT.flush
+         unless @last_to.empty?
+            Readline::insert_text("#{@last_to}: ")
+            Readline::redisplay
+         end
+      end
+
+      if Config.opts[:ctrl_c_quits]
+         trap("SIGINT") { Main.quit }
+      else
+         trap("SIGINT") do
+            Readline::line_buffer = ""
+            puts
+            Out::make_infoline
+            print "#{@prompt}"
+            STDOUT.flush
+         end
+      end
+
+      read_typed_history()
+
+      init_char_input_stuff()
+
+      @input_thread = Thread.new { read_input() }
+   end
+
+   def prompt(p=nil)
+      return @prompt unless p
+      @prompt = p
+   end
+
+   def reset_prompt
+      @prompt = DEFAULT_PROMPT
+   end
+
+   def init_char_input_stuff
+      # i'm surprised this doesn't make typing fucking unbearable
+
+      @on_char_input_blocks = []
+
+      @on_char_input_blocks << lambda do |c|
+         to, msg = Readline::line_buffer.split(":", 2).strip
+         if to && msg && Main.contacts.key?(to)
+            # TODO: try to see if a thread improves things
+            Main.contacts[to].typed_stuff
+         end
+         c
+      end
+
+      Readline::char_input_proc = lambda do |c|
+         ret = c
+         @on_char_input_blocks.each do |block|
+            ret = block.call(c)
+            break if ret != c
+         end
+         ret
+      end
+   end
+
+   def on_char_input(&block)
+      @on_char_input_blocks << block
+   end
+
+   #def composing_watcher
+   #   timer = nil
+   #   loop do
+   #      sleep(1)
+
+   #      buf = Readline::line_buffer
+   #      next unless buf != @last_line
+
+   #      @last_line = buf
+   #      to, msg = buf.split(":", 2).strip
+
+   #      next unless to && msg && Main.contacts.key?(to)
+   #   end
+   #end
+
+   def read_input
+      loop do
+         Out::make_infoline
+
+         t = Readline::readline(@prompt, true)
+
+         @last_typed = t || ""
+
+         if !t
+            if @multiline
+               @last_typed = @multilines
+               process_input(@multilines.join("\n"))
+               multiline(false)
+            else
+               if Config.opts[:ctrl_c_quits]
+                  puts ; next
+               else
+                  Main.quit
+               end
+            end
+         elsif !@multiline && t =~ /^\s*$/
+            Readline::HISTORY.pop
+         else
+            Readline::HISTORY.pop if Readline::HISTORY.to_a[-2] == t
+
+            if @multiline
+               @multilines.push(t)
+               @last_typed = @multilines
+            else
+               process_input(t)
+            end
+         end
+      end
+   end
+
+   def process_input(text)
+      return if text.empty?
+
+      if !Main.connected
+         # FIXME: brute force ftw!
+         Out::error("not connected :-(", false)
+         return
+      end
+
+      if text[0] == ?/
+         Commands::run(*text[1..-1].split(" ", 2))
+         @last_to = ""
+      else
+         to, msg = text.split(":", 2)
+         return unless to && msg && !msg.empty? && Main.contacts.key?(to)
+         msg = msg[1..-1] if msg[0].chr == " " # goddammit, whitespace will be the death of me
+
+         @last_to = to
+         jid = Jabber::JID.new(to)
+         jid = nil unless jid.resource
+         Main.contacts[to].send_message(msg, jid)
+      end
+   end
+
+   def delete_last_typed
+      if @last_typed.is_a?(Array)
+         @last_typed.each do |line|
+            # line length + multiline prompt + \n
+            # FIXME: put the multiline prompt somewhere
+            print "\b" * (line.length + 6)
+            print "#{ANSIMove.up(1)}"
+         end
+         print "#{ANSIMove.down(1)}" if @last_typed.length > 0
+      else
+         print "\b" * @last_typed.length
+      end
+   end
+
+   def delete_typed
+      if @multiline
+         delete_last_typed()
+      else
+         print "\b" * Readline::line_buffer.length
+      end
+   end
+
+   def redisplay_input()
+      if @multiline && !@multilines.empty?
+         puts "#{ANSI.clearline}#{DEFAULT_PROMPT}#{@multilines[0]}"
+         @multilines[1..-1].each do |line|
+            puts "#{ANSI.clearline}#{@prompt}#{line}"
+         end
+      end
+
+      Out::make_infoline()
+      print "#{@prompt}#{Readline::line_buffer}"
+      STDOUT.flush
+   end
+
+
+   def completer(line)
+      return if !Main.connected
+
+      if line[0] == ?/
+         Commands::completer(line)
+      else
+         Main.contacts.completer(line)
+      end
+   end
+
+   def save_typed_history
+      File.open(Config.account[:typed], 'w') do |f|
+         f.puts(Readline::HISTORY.to_a[-300..-1] || Readline::HISTORY.to_a)
+      end
+   end
+
+   def read_typed_history
+      path = Config.account[:typed]
+      File.read(path).each { |l| Readline::HISTORY.push(l.chomp) } if File.file?(path)
+   end
+
+   def multiline?
+      @multiline
+   end
+
+   def multiline(enable, first_line="")
+      @multiline = enable
+      @multilines = []
+      if enable
+         @multilines.push(first_line) unless first_line.empty?
+         prompt("---> ")
+      else
+         reset_prompt()
+      end
+   end
+end
+
+end
+

data/lib/lijab/main.rb

@@ -0,0 +1,248 @@
+require 'date'
+require 'file/tail'
+require 'monitor'
+require 'optparse'
+require 'term/ansicolor'
+require 'xmpp4r'
+require 'xmpp4r/roster'
+require 'yaml'
+
+require 'lijab/commands'
+require 'lijab/config'
+require 'lijab/contacts'
+require 'lijab/history'
+require 'lijab/hooks'
+require 'lijab/input'
+require 'lijab/out'
+require 'lijab/version'
+require 'lijab/xmpp4r/message'
+
+include Term
+
+
+class String
+   include ANSIColor
+
+   def colored(*colors)
+      s = self
+      colors.each { |c| s = s.send(c) }
+      s
+   end
+end
+
+class Array
+   def strip
+      self.map { |s| s.strip }
+   end
+end
+
+Thread.abort_on_exception = true
+
+module Lijab
+
+module Main
+   module_function
+
+   @monitor = Monitor.new
+
+   def run!
+      args = parse_args()
+      Jabber::debug = args[:debug]
+
+      Config::init(args)
+      read_saved_session()
+
+      @connected = false
+
+      print ANSI.title("lijab -- #{Config.jid.strip}") ; STDOUT.flush
+
+      begin
+         setup_client()
+      rescue SystemCallError, SocketError
+         Out::error("couldn't connect", false)
+         reconnect()
+      end
+
+      Commands::init
+      InputHandler::init
+   end
+
+   def setup_after_connect
+      HooksHandler::init
+   end
+
+   def setup_client
+      return unless @monitor.try_enter
+      begin
+         @client = Jabber::Client.new(Config.jid)
+
+         @client.add_message_callback do |msg|
+            if Main.contacts.key?(msg.from)
+               Main.contacts[msg.from].handle_message(msg)
+            else
+               Main.contacts.handle_non_contact_message(msg)
+            end
+         end
+
+         @client.use_ssl = Config.account[:use_ssl]
+
+         Out::put("connecting...".yellow, false)
+
+         loop do
+            begin
+               @client.connect(Config.account[:server], Config.account[:port])
+
+               if !Config.account[:password]
+                  print "#{ANSI.clearline}#{Config.account[:name]} account password: "
+                  system("stty -echo") # FIXME
+                  STDIN.read_nonblock(9999999) rescue nil
+                  Config.account[:password] = gets.chomp
+                  system("stty echo")
+                  puts
+               end
+
+               @client.auth(Config.account[:password])
+               break
+            rescue Jabber::ClientAuthenticationFailure
+               Out::error("couldn't authenticate: wrong password?", false)
+               Config.account[:password] = nil
+            end
+         end
+
+         @client.on_exception do |e,stream,from|
+            @connected = false
+
+            case from
+            when :disconnected
+               Out::error("disconnected", false)
+               HooksHandler::handle_disconnect
+               reconnect()
+            else
+               # death before lost messages!
+               raise e || "exception raised from #{from}"
+            end
+         end
+
+         @contacts = Contacts::Contacts.new(Jabber::Roster::Helper.new(@client))
+         @client.send(@presence)
+         @connected = true
+
+         setup_after_connect()
+         HooksHandler::handle_connect
+
+         Out::put("connected!".green)
+      ensure
+         @monitor.exit
+      end
+   end
+
+   def reconnect
+      do_sleep = 1
+      loop do
+         do_sleep.downto(1) do |i|
+            Out::make_infoline
+            Out::infoline("trying reconnect in #{i*5} seconds...")
+            sleep(5)
+         end
+         do_sleep = [do_sleep*2, 10].min
+
+         begin
+            setup_client()
+            Out::clear_infoline
+            break
+         rescue SystemCallError, SocketError
+         end
+      end
+   end
+
+   def set_status(status, msg=nil)
+      type = status == :invisible ? :unavailable : nil
+      priority = Config.opts[:status_priorities][status]
+      status = nil if [:available, :invisible].include?(status)
+
+      @presence.set_type(type).set_show(status).set_status(msg).set_priority(priority)
+
+      @client.send(@presence)
+   end
+
+   def clear_status_message
+      set_status(@status)
+   end
+
+   def set_priority(priority)
+      @client.send(@presence.set_priority(priority))
+   end
+
+   def parse_args
+      options = {:debug => false}
+      begin
+         op = OptionParser.new do |opts|
+            opts.banner = "usage: lijab [-h | -V | [-a ACCOUNTNAME] [-d BASEDIR] [-D]]\n\n"
+            opts.on("-D", "--[no-]debug",
+                    "output xmpp debug information to stderr") { |v| options[:debug] = v }
+            opts.on("-d", "--basedir BASEDIR",
+                    "configs base directory") { |v| options[:basedir] = v }
+            opts.on("-a", "--account ACCOUNTNAME",
+                    "the name of the account to connect to") { |v| options[:account] = v }
+            opts.on("-V", "--version", "print version information") do |v|
+               puts "lijab #{Lijab::VERSION}"
+               exit(0)
+            end
+         end
+         begin
+            op.parse!
+         rescue OptionParser::ParseError => e
+            puts "#{e}\n\n#{op.banner.chomp}"
+            exit(1)
+         end
+      rescue OptionParser::MissingArgument
+         puts "lijab: error: #{$!}\n\n#{op}"
+         exit 1
+      end
+      options
+   end
+
+   def save_session
+      return unless @presence
+
+      o = {:status => {:type => @presence.type,
+                       :show => @presence.show,
+                       :status => @presence.status,
+                       :priority => @presence.priority}}
+      File.open(File.join(Config.account[:dir], "session_data.yml"), 'w') do |f|
+         f.puts(YAML.dump(o))
+      end
+   end
+
+   def read_saved_session
+      path = File.join(Config.account[:dir], "session_data.yml")
+
+      if File.file?(path)
+         o = YAML.load_file(path)
+      else
+         o = {:status => {:type => :available, :priority => 51}}
+      end
+
+      @presence = Jabber::Presence.new.set_type(o[:status][:type]) \
+                                      .set_show(o[:status][:show]) \
+                                      .set_status(o[:status][:status]) \
+                                      .set_priority(o[:status][:priority])
+   end
+
+   def quit
+      begin
+         @client.close if @connected
+      rescue
+      end
+      InputHandler::save_typed_history
+      Config::dump_config_file(false, true)
+      save_session()
+      puts "\nexiting..."
+      exit 0
+   end
+
+   attr_reader :contacts, :client, :connected, :presence
+   module_function :contacts, :client, :connected, :presence
+end
+end
+