palbo-lijab 0.1.0

data/lib/lijab/commands.rb

@@ -0,0 +1,139 @@
+
+module Lijab
+
+module Commands
+   @registered = {}
+   @overloaded = {}
+
+   module CommandMixin
+      def define_meta(*names)
+         class_eval do
+            names.each do |name|
+               define_method(name) do |*args|
+                  if args.size == 0
+                     instance_variable_get("@#{name}")
+                  else
+                     instance_variable_set("@#{name}", *args)
+                  end
+               end
+            end
+         end
+      end
+   end
+
+   module ContactCompleterMixin
+      def completer(line)
+         _, contact = line.split(nil, 2)
+         Main.contacts.completer(contact, false)
+      end
+   end
+
+   class CommandError < RuntimeError
+   end
+
+   class Command
+      class << self
+         private :new
+      end
+
+      def self.define(name, &block)
+         c = new
+         c.instance_eval(&block)
+         Commands::register(name.to_sym, c)
+      end
+
+      def completer(s)
+      end
+
+      def run(args)
+      end
+
+      extend CommandMixin
+      define_meta :usage, :description
+   end
+
+   module_function
+
+   def init
+      files = Dir[File.join(File.dirname(File.expand_path(__FILE__)), 'commands', '*.rb')] + \
+              Dir[File.join(Config.dirs[:commands], '**', '*.rb')]
+
+      files.each { |f| load f }
+      Config.opts[:aliases].each do |a, c|
+         register_alias(a, c)
+      end
+   end
+
+   def register(name, cmd)
+      name = name.to_sym
+      @overloaded[name] = @registered[name] if @registered.key?(name)
+      @registered[name] = cmd
+   end
+
+   def register_alias(name, s)
+      alias_cmd, alias_args = s.split(" ", 2)
+      alias_cmd.strip!
+      alias_cmd = alias_cmd[1..-1] if alias_cmd[0] == ?/
+      name = name[1..-1] if name[0] == ?/
+
+      Command.define name.to_sym do
+         description %{Alias for "#{s}"}
+         @alias_cmd = alias_cmd
+         @alias_args = alias_args
+         @name = name
+
+         def run(args)
+            Commands::run(@alias_cmd, [@alias_args, args].join(" "), true)
+         end
+
+         def completer(line)
+            args = line.split(" ", 2)[1]
+            Commands::completer("/#{@alias_cmd} #{@alias_args} #{args}").map do |r|
+               r.gsub(/\/#{@alias_cmd}\s?/, "")
+            end
+         end
+      end
+   end
+
+   def get(name)
+      @registered[name.to_sym]
+   end
+
+   def registered?(name)
+      @registered.key?(name.to_sym)
+   end
+
+   def run(cmd, args="", is_alias=false)
+      cmd = cmd.strip.to_sym
+      command = @overloaded[cmd] if is_alias
+      command ||= @registered[cmd]
+      if command
+         begin
+            command.run(args.strip)
+         rescue CommandError => e
+            Out::error("#{cmd}: #{e}", false)
+         end
+      else
+         Out::error("no such command: /#{cmd}", false)
+      end
+   end
+
+   def completer(line)
+      cmd, args = line[1..-1].split(" ", 2).strip
+      cmd ||= ""
+
+      matches = @registered.keys.find_all { |c| c.to_s.match(/^#{Regexp.escape(cmd)}/) }
+
+      if !cmd.empty? && (matches.length == 1 || args) && registered?(cmd)
+         (@registered[cmd.to_sym].completer(line) || []).map { |s| "/#{cmd} #{s}" }
+      else
+         matches.map { |k| "/#{k}" }
+      end
+   end
+
+   attr_reader :registered
+   module_function :registered
+end
+
+end
+

data/lib/lijab/config.rb

@@ -0,0 +1,174 @@
+
+module Lijab
+
+module Config
+   module_function
+
+   def init(args)
+      @opts = {}
+      @dirs = {}
+      @files = {}
+      @accounts = []
+      @account = nil
+
+      setup_basedir(args[:basedir])
+      read_accounts(args[:account])
+      read_options()
+
+      @jid = Jabber::JID.new("#{@account[:jabberid]}")
+      @jid.resource ||= "lijab#{(0...5).map{rand(10).to_s}.join}"
+      @account[:server] ||= @jid.domain
+
+      create_account_dirs()
+   end
+
+   def setup_basedir(basedir)
+      # xdg? meh
+      #xdg = ENV["XDG_CONFIG_HOME"]
+      #xdg && File.join(xdg, "lijab") ||
+
+      @basedir = basedir ||
+                 ENV["LIJABDIR"] ||
+                 "~/.lijab"
+      @basedir = File.expand_path(@basedir)
+
+      unless File.directory?(@basedir)
+         puts "Creating #{@basedir} with the default configs"
+      end
+
+      %w{accounts commands hooks}.each do |d|
+         @dirs[d.to_sym] = path = File.join(@basedir, d)
+         FileUtils.mkdir_p(path)
+      end
+
+      @files[:accounts] = path = File.join(@basedir, "accounts.yml")
+      File.open(path, 'w') { |f| f.puts(DEFAULT_ACCOUNTS_FILE) } unless File.file?(path)
+
+      @files[:config] = File.join(@basedir, "config.yml")
+      dump_config_file(true)
+   end
+
+   def dump_config_file(default=false, clobber=false)
+      if !File.file?(@files[:config]) || clobber
+         File.open(@files[:config], 'w') do |f|
+            DEFAULT_OPTIONS.each do |a|
+               if a[2]
+                  f.puts
+                  a[2].each { |l| f.puts("# #{l}") }
+               end
+               v = default ? a[1] : @opts[a[0]]
+               f.puts(YAML.dump({a[0] => v})[5..-1].chomp)
+            end
+         end
+      end
+   end
+
+   def read_accounts(account)
+      File.open(@files[:accounts]) do |f|
+         YAML.load_documents(f) { |a| @accounts << a }
+      end
+
+      errors = []
+      errors << "need at least one account!" if @accounts.empty?
+
+      @accounts.each do |a|
+         a[:port] ||= a[:use_ssl] ? 5223 : 5222
+
+         errors << "account #{a} needs a name" unless a.key?(:name)
+         errors << "account #{a[:name] || a} needs a jabberid" unless a.key?(:jabberid)
+      end
+
+      @account = account ? @accounts.find { |a| a[:name] == account} : @accounts[0]
+
+      errors << "no account with name #{account} in #{@accounts_file}" if account && !@account
+
+      errors.each do |e|
+         STDERR.puts("#{File.basename($0)}: error: #{e}")
+      end
+
+      exit(1) unless errors.empty?
+   end
+
+   def read_options
+      # FIXME: error check / validate
+
+      @opts = Hash[*DEFAULT_OPTIONS.collect { |a| [a[0], a[1]] }.flatten]
+      @opts.merge!(YAML.load_file(@files[:config]))
+   end
+
+   def create_account_dirs
+      @accounts.each do |a|
+         a[:dir] = File.join(@dirs[:accounts], @jid.strip.to_s)
+         a[:log_dir] = File.join(a[:dir], "logs")
+         a[:typed] = File.join(a[:dir], "typed_history")
+
+         [:dir, :log_dir].each { |s| FileUtils.mkdir_p(a[s]) }
+      end
+   end
+
+   DEFAULT_OPTIONS = [
+      [:datetime_format, "%H:%M:%S", ["Time formatting (leave empty to disable timestamps)"]],
+      [:history_datetime_format, "%Y-%b-%d %H:%M:%S"],
+      [:autocomplete_online_first, true, 
+       ["When completing contacts try to find matches for online contacts, and if none",
+        "is found try to find matches on all of them. Otherwise always match every",
+        "contact."]],
+      [:show_status_changes, true, ["Show changes in contacts' status"]],
+      [:show_groups_in_contact_list, false, ["Group contacts in contact list"]],
+      [:ctrl_c_quits, false,
+       ["ctrl+c quits the program if enabled, otherwise ctrl+c ignores whatever is",
+        "typed and you get a clean prompt, and ctrl+d on a clean line exits lijab,",
+        "terminal style."]],
+      [:terminal_bell_on_message, true,
+       ["Ring the terminal bell on incoming message.",
+        "Useful for setting the urgent hint on the terminal window:",
+        "Set as so in your ~/.Xdefaults, might have to run xrdb -merge ~/.Xdefaults afterwards",
+        "XTerm*bellIsUrgent: true",
+        "or",
+        "URxvt*urgentOnBell: true",
+        "or just look it up on your terminal's man page, don't be lazy."]],
+      [:status_priorities,
+       {:chat => 55, :available => 50, :away => 40, :xa => 30, :dnd => 20},
+       ["Default priority for each status"]],
+      [:aliases, {"/h" => "/history", "/exit" => "/quit"},
+       ["Command aliases.",
+        "<command_alias> : <existing_command>",
+        "Commands can be overloaded.",
+        "For instance /who could be redefined like so to sort by status by default.",
+        "/who : /who status"]]
+   ]
+
+   DEFAULT_ACCOUNTS_FILE = %Q{
+      # Accounts go here. Separate each one with ---
+      # First one is the default.
+
+      #---
+      #:name : an_account                  # the account name
+      #:jabberid : fisk@example.com/lijab  # the resource is optional
+      #:password : frosk                   # optional, will prompt if not present
+      #:server : localhost                 # optional, will use the jid domain if not present
+      #:port : 5222                        # optional
+      #:use_ssl : no                       # deprecated in jabber, but might help sometimes
+      #:log : yes                          # yes|no ; default no
+
+      #---
+      #:name : another_account
+      #:jabberid : another_user@example.com/lijab
+
+      #---
+      #:name : gmail_account
+      #:jabberid : blah@gmail.com/lijab
+      #:server : talk.google.com
+      ## might wanna try use_ssl if the normal settings don't work (e.g. in ubuntu afaik)
+      ##:port : 5223
+      ##:use_ssl : yes
+      #:log : yes
+
+   }.gsub!(/^ */, '')
+
+   attr_reader     :jid, :account, :basedir, :dirs, :files, :opts
+   module_function :jid, :account, :basedir, :dirs, :files, :opts
+end
+
+end
+

data/lib/lijab/contacts.rb

@@ -0,0 +1,318 @@
+
+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)
+         if contact
+            self[jid] = contact
+            if @short.key?(jid.node)
+               self[@short[jid.node].jid].simple_name = jid.strip.to_s
+               @short[@short[jid.node].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