palbo-lijab 0.1.0

data/lib/lijab/history.rb

@@ -0,0 +1,122 @@
+require 'time'
+
+class File
+   include File::Tail
+end
+
+module Lijab
+
+module HistoryHandler
+   class DummyHistory
+      def log(*a)
+      end
+
+      def last(*a)
+         Out::put("warning: logs are disabled")
+         []
+      end
+   end
+
+   class History
+      MEMORY_LOG_LENGTH = 50
+
+      def initialize(path, target=nil, log_to_session=false)
+         @path, @target, @log_to_session = path, target, log_to_session
+         @m = []
+      end
+
+      def init_logfile
+         @w = File.open(@path, 'a')
+         @r = File.open(@path, 'r')
+         @r.return_if_eof = true
+      end
+
+      def log(msg, direction, target=nil)
+         init_logfile() unless @w
+
+         time = Time.now.utc
+         target ||= @target
+         arrow = direction == :from ? "<-" : "->"
+         quoted = [msg].pack("M").gsub(/=?\n/) { |m| m[0] == ?= ? "" : "=0A" }
+
+         @w.puts("#{time.iso8601} #{target} #{arrow} #{quoted}")
+         @w.flush
+
+         @m.push({:time=>time.localtime, :target=>target, :direction=>direction, :msg=>msg})
+         @m.shift if @m.length > MEMORY_LOG_LENGTH
+
+         @m = []
+
+         HistoryHandler::log(msg, direction, target) if @log_to_session
+
+         self
+      end
+
+      def last(n)
+         return [] if n <= 0
+
+         init_logfile() unless @r
+
+         if n <= @m.length
+            @m[-n..-1]
+         else
+            ret = []
+            @r.seek(0, File::SEEK_END)
+            @r.backward(n)
+            @r.tail(n-@m.length) do |l|
+               time, target, direction, msg = l.split(" ", 4)
+               ret << {:time => Time.parse(time).localtime,
+                       :target => target,
+                       :direction => direction == "<-" ? :from : :to,
+                       :msg => msg.strip.unpack("M").first}
+            end
+            ret += @m
+            if @m.length < MEMORY_LOG_LENGTH
+               @m = (ret[0...n-@m.length] + @m)
+               @m = @m[-MEMORY_LOG_LENGTH..-1] if @m.length > MEMORY_LOG_LENGTH
+            end
+            ret
+         end
+      end
+   end
+
+   module_function
+
+   @histories = {}
+
+   def get(jid)
+      name = jid.strip.to_s
+      if Config.account[:log]
+         path = File.join(Config.account[:log_dir], "#{name}.log")
+         @histories[name] ||= History.new(path, name, true)
+      else
+         @dummy ||= DummyHistory.new
+      end
+   end
+
+   def log(msg, direction, target)
+      return unless Config.account[:log]
+
+      init_session_log() unless @session
+      @session.log(msg, direction, target)
+   end
+
+   def last(n)
+      unless Config.account[:log]
+         Out::put("warning: logs are disabled")
+         return []
+      end
+
+      init_session_log() unless @session
+      @session.last(n)
+   end
+
+   def init_session_log
+      return unless Config.account[:log]
+
+      @session = History.new(path = File.join(Config.account[:log_dir], "session.log"))
+   end
+end
+
+end
+

data/lib/lijab/hooks.rb

@@ -0,0 +1,109 @@
+
+module Lijab
+
+module HooksHandler
+   module_function
+
+   @on_connect = []
+   @on_disconnect = []
+   @on_incoming_message = []
+   @on_presence = []
+   @on_pre_send_message = []
+   @on_post_send_message = []
+
+   def init
+      @on_connect, @on_disconnect, @on_incoming_message, @on_presence = [], [], [], []
+      @on_pre_send_message, @on_post_send_message = [], []
+
+      Dir[File.join(Config.dirs[:hooks], '**', '*.rb')].each { |f| load f }
+
+      Main.client.add_message_callback(&method(:handle_message))
+      Main.contacts.roster.add_presence_callback(&method(:handle_presence))
+   end
+
+   def handle_message(msg)
+      return unless msg.body && !msg.body.empty?
+
+      @on_incoming_message.each do |b|
+         b.call(Main.contacts[msg.from.strip], msg.body)
+      end
+   end
+
+   def handle_presence(roster_item, old_p, new_p)
+      @on_presence.each do |b|
+         b.call(Main.contacts[roster_item.jid.strip], old_p, new_p)
+      end
+   end
+
+   def handle_pre_send_message(contact, msg)
+      return msg if @on_pre_send_message.empty? || !msg.body || msg.body.empty?
+
+      @on_pre_send_message.inject(msg) do |ret_msg, block|
+         args = [contact, ret_msg.body]
+         args.push(msg) if block.arity == 3
+
+         m = block.call(*args)
+         break if !m 
+
+         if m.is_a?(Jabber::Message)
+            m
+         else
+            ret_msg.body = m.to_s
+            ret_msg
+         end
+      end
+   end
+
+   def handle_post_send_message(contact, msg)
+      return if !msg.body || msg.body.empty?
+
+      @on_post_send_message.each do |block|
+         args = [contact, msg.body]
+         args.push(msg) if block.arity == 3
+         block.call(*args)
+      end
+   end
+
+   def handle_connect
+      @on_connect.each { |b| b.call }
+   end
+
+   def handle_disconnect
+      @on_disconnect.each { |b| b.call }
+   end
+
+   attr_reader :on_connect, :on_disconnect, :on_incoming_message, :on_presence,
+      :on_pre_send_message, :on_post_send_message
+   module_function :on_connect, :on_disconnect, :on_incoming_message,:on_presence,
+      :on_pre_send_message, :on_post_send_message
+end
+
+module Hooks
+   module_function
+
+   def on_incoming_message(&block)
+      HooksHandler::on_incoming_message.push(block)
+   end
+
+   def on_presence(&block)
+      HooksHandler::on_presence.push(block)
+   end
+
+   def on_pre_send_message(&block)
+      HooksHandler::on_pre_send_message.push(block)
+   end
+
+   def on_post_send_message(&block)
+      HooksHandler::on_post_send_message.push(block)
+   end
+
+   def on_connect(&block)
+      HooksHandler::on_connect.push(block)
+   end
+
+   def on_disconnect(&block)
+      HooksHandler::on_disconnect.push(block)
+   end
+end
+
+end

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,246 @@
+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")
+         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.on_exception do |e,stream,from|
+            @connected = false
+
+            case from
+            when :disconnected
+               Out::error("disconnected")
+               HooksHandler::handle_disconnect
+               reconnect()
+            else
+               # death before lost messages!
+               raise e || "exception raised from #{from}"
+            end
+         end
+
+         @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
+
+         Out::put("connecting...".yellow, true)
+
+         @client.use_ssl = Config.account[:use_ssl]
+         @client.connect(Config.account[:server], Config.account[:port])
+
+         loop do
+            begin
+               if !Config.account[:password]
+                  print "#{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
+
+         @contacts = Contacts::Contacts.new(Jabber::Roster::Helper.new(@client))
+         @client.send(@presence)
+         @connected = true
+
+         setup_after_connect()
+         HooksHandler::handle_connect
+
+         Out::put("connected!".green, true)
+      ensure
+         @monitor.exit
+      end
+   end
+
+   def reconnect
+      do_sleep = 1
+      loop do
+         do_sleep.downto(1) do |i|
+            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
+