lijab 0.1.1

data/lib/lijab/contacts.rb

@@ -0,0 +1,324 @@
+
+class Jabber::Presence
+   PRETTY = Hash.new(["", []]).update(
+      { :available => ["available", [:green, :bold]],
+        :away => ["away", [:magenta]],
+        :chat => ["chatty", [:green]],
+        :dnd => ["busy", [:red, :bold]],
+        :xa => ["not available", [:red]],
+        :offline => ["offline", [:blue]]
+      })
+
+   def pretty_show
+      case type()
+      when nil
+         show() || :available
+      when :unavailable
+         :offline
+      end
+   end
+
+   def pretty(colorize=false)
+      sh = pretty_show()
+
+      s, colors = PRETTY[sh]
+      s = s.colored(*colors) if colorize
+      message = status() && !status().empty? ? " [#{status()}]" : ""
+      "#{s}#{message}"
+   end
+end
+
+module Lijab
+module Contacts
+
+   class Contact
+      attr_accessor :simple_name, :history
+      attr_writer :color
+      attr_reader :roster_item
+
+      COLORS = [:red, :blue, :yellow, :green, :magenta, :cyan].sort_by { rand() }
+      @@cur_color = 0
+
+      def initialize(simple_name, roster_item)
+         @simple_name = simple_name
+         @roster_item = roster_item
+         @resource_jid = @roster_item.jid
+         @history = HistoryHandler::get(jid())
+      end
+
+      def presence(jid=nil)
+         if jid
+            p = @roster_item.presences.select { |p| p.jid == jid }.first
+         else
+            p = @roster_item.presences.inject(nil) do |max, presence|
+               !max.nil? && max.priority.to_i > presence.priority.to_i ? max : presence
+            end
+         end
+         p || Jabber::Presence.new.set_type(:unavailable)
+      end
+
+      def handle_message(msg)
+         @thread = msg.thread
+
+         if msg.body && !msg.body.empty?
+            @resource_jid = msg.from
+            Out::message_in(@simple_name, msg.body, [color(), :bold])
+            @history.log(msg.body, :from)
+         end
+
+         if msg.chat_state
+            s = ""
+            case msg.chat_state
+            when :composing
+               s = "is typing"
+            when :active
+               Out::clear_infoline
+            when :gone
+               s = "went away"
+            when :paused
+               s = "paused typing"
+            end
+            Out::infoline("* #{@simple_name} #{s}".red) unless s.empty?
+         end
+      end
+
+      def send_message(msg, jid=nil)
+         if msg.kind_of?(Jabber::Message)
+            msg.thread = @thread unless msg.thread
+            message = msg
+         elsif msg.kind_of?(String) && !msg.empty?
+            # TODO: send chat_state only in the first message
+            if jid
+               @resource_jid = jid
+            else
+               jid = @resource_jid
+            end
+            Out::message_out(@simple_name, msg, color())
+            message = Jabber::Message.new(jid, msg).set_type(:chat) \
+                                                             .set_chat_state(:active) \
+                                                             .set_thread(@thread)
+
+            @chat_state_timer.kill if @chat_state_timer && @chat_state_timer.alive?
+         end
+
+         message = HooksHandler::handle_pre_send_message(self, message)
+         return unless message
+
+         Main.client.send(message)
+
+         HooksHandler::handle_post_send_message(self, message)
+
+         @history.log(message.body, :to)
+         @chat_state = :active
+      end
+
+      def send_chat_state(state)
+         return if state == @chat_state
+         msg = Jabber::Message.new(jid(), nil).set_type(:chat).set_chat_state(state)
+         Main.client.send(msg)
+         @chat_state = state
+      end
+
+      def typed_stuff
+         send_chat_state(:composing)
+
+         @chat_state_timer.kill if @chat_state_timer && @chat_state_timer.alive?
+         @chat_state_timer = Thread.new do
+            sleep(3); return if !Main.connected
+            send_chat_state(:paused)
+            sleep(10); return if !Main.connected
+            send_chat_state(:active)
+         end
+      end
+
+      def presence_changed(old_p, new_p)
+         @resource_jid = @roster_item.jid if old_p && old_p.from == @resource_jid
+      end
+
+      def jid
+         @roster_item.jid
+      end
+
+      def online?
+         @roster_item.online?
+      end
+
+      def color
+         @color = COLORS[(@@cur_color = (@@cur_color + 1) % COLORS.length)] unless @color
+         @color
+      end
+
+      def to_s;
+         @simple_name
+      end
+   end
+
+   class Contacts < Hash
+      attr_reader :roster, :subscription_requests
+
+      def initialize(roster)
+         super()
+         @roster = roster
+
+         # why does everything always has to be so hackish?
+         self_ri = Jabber::Roster::Helper::RosterItem.new(Main.client)
+         self_ri.jid = Config.jid.strip
+         @roster.items[self_ri.jid] = self_ri
+
+         @roster.add_presence_callback(&method(:handle_presence))
+         @roster.add_subscription_callback(&method(:handle_subscription))
+         @roster.add_subscription_request_callback(&method(:handle_subscription))
+         @roster.wait_for_roster
+
+         @subscription_requests = {}
+         @short = {}
+
+         @roster.items.each do |jid, item|
+            add(jid, Contact.new(jid.node, item))
+         end
+      end
+
+      def [](k)
+         return @short[k] if @short.key?(k)
+
+         k = Jabber::JID.new(k) unless k.is_a?(Jabber::JID)
+
+         super(k) || super(k.strip)
+      end
+
+      def key?(k)
+         return true if @short.key?(k)
+
+         k = Jabber::JID.new(k) unless k.is_a?(Jabber::JID)
+
+         super(k) || super(k.strip)
+      end
+
+      def add(jid, contact=nil)
+         return unless jid.node # XXX: apparently transports have no node, do something here?
+
+         if contact
+            self[jid] = contact
+            if @short.key?(jid.node)
+               prev = @short[jid.node]
+
+               self[jid].simple_name = jid.strip.to_s
+               self[prev.jid].simple_name = prev.jid.strip.to_s
+
+               @short[prev.jid.strip.to_s] = @short.delete(jid.node)
+               @short[jid.strip.to_s] = self[jid]
+            else
+               @short[jid.node] = self[jid]
+            end
+         else
+            jid = Jabber::JID.new(jid) unless jid.is_a?(Jabber::JID)
+            jid.strip!
+
+            @roster.add(jid, nil, true)
+         end
+
+         contact || self[jid]
+      end
+
+      def remove(jid)
+         return false unless key?(jid)
+
+         contact = self[jid]
+         contact.roster_item.remove()
+         @short.delete(contact.simple_name)
+         self.delete(contact.jid)
+
+         true
+      end
+
+      def process_request(jid, action)
+         jid = Jabber::JID.new(jid) unless jid.is_a?(Jabber::JID)
+         jid.strip!
+         if @subscription_requests.include?(jid)
+
+            @subscription_requests.delete(jid)
+            case action
+            when :accept
+               Main.contacts.roster.accept_subscription(jid)
+            when :decline
+               Main.contacts.roster.decline_subscription(jid)
+            end
+
+            true
+         else
+            false
+         end
+      end
+
+      def has_subscription_requests?
+         !@subscription_requests.empty?
+      end
+
+      def subscription_requests
+         @subscription_requests.keys.map { |jid| jid.to_s }
+      end
+
+      def completer(line, end_with_colon=true)
+         if line.include?(?@)
+            matches = @roster.items.values.collect { |ri| ri.presences }.flatten.select do |p|
+               p.from.to_s =~ /^#{Regexp.escape(line)}/
+            end.map { |p| p.from.to_s }
+         else
+            if Config.opts[:autocomplete_online_first]
+               matches = @short.keys.find_all do |name|
+                  @short[name].online? && name =~ /^#{Regexp.escape(line)}/
+               end
+            end
+            if matches.empty? || !Config.opts[:autocomplete_online_first]
+               matches = @short.keys.find_all { |name| name =~ /^#{Regexp.escape(line)}/ }
+            end
+         end
+         end_with_colon && matches.length == 1 ? "#{matches.first}:" : matches
+      end
+
+      def handle_non_contact_message(msg)
+         # TODO: improve this, maybe show the contact differentiated in /contacts
+
+         jid = msg.from.strip
+
+         ri = Jabber::Roster::Helper::RosterItem.new(Main.client)
+         ri.jid = jid
+
+         self[jid] = Contact.new(jid.to_s, ri)
+         self[jid].handle_message(msg)
+         #add(jid, Contact.new(jid.to_s, ri)).handle_message(msg)
+      end
+
+      def handle_presence(roster_item, old_p, new_p)
+         contact = self[new_p.from]
+         if Config.opts[:show_status_changes]
+            type = new_p.type
+            if type == nil || type == :unavailable && (!contact || !contact.online?)
+               Out::presence(new_p.from.to_s, new_p)
+            end
+         end
+
+         if contact
+            contact.roster_item.presences.delete_if { |p| p.type == :unavailable } rescue nil
+            contact.presence_changed(old_p, new_p)
+         end
+      end
+
+      def handle_subscription(roster_item, presence)
+         show = true
+         if presence.type == :subscribe
+            show = !@subscription_requests.key?(presence.from.strip)
+            @subscription_requests[presence.from.strip] = presence
+         elsif presence.type == :subscribed
+            jid = presence.from.strip
+
+            @roster.add(jid)
+            add(jid, Contact.new(jid.node, @roster[jid]))
+            #p = Jabber::Presence.new.set_type(:probe)
+         end
+
+         Out::subscription(presence.from.to_s, presence.type, presence.status) if show
+      end
+   end
+end
+end

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