palbo-lijab 0.1.0

data/bin/lijab

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+begin
+   require 'lijab'
+rescue LoadError
+   require 'rubygems'
+   require 'lijab'
+end
+

data/ext/extconf.rb

@@ -0,0 +1,20 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+dir_config("readline")
+
+$headers = ["stdio.h", "readline/readline.h"]
+
+exit unless have_library("readline", "readline")
+
+$headers.each { |h| exit unless have_header(h) }
+
+%w{"rl_line_buffer"
+   "rl_insert_text"
+   "rl_parse_and_bind"
+   "rl_redisplay"}.each { |f| exit unless have_func(f, $headers) }
+
+%w{"rl_pre_input_hook"
+   "rl_getc_function"}.each { |f| exit unless have_var(f, $headers) }
+
+create_makefile("readline_extra")

data/ext/readline_extra.c

@@ -0,0 +1,172 @@
+
+#include <stdio.h>
+
+#include <readline/readline.h>
+
+#include "ruby.h"
+#include "rubyio.h"
+
+#define PRE_INPUT_PROC "pre_input_proc"
+static ID pre_input_proc;
+
+#define CHAR_INPUT_PROC "char_input_proc"
+static ID char_input_proc;
+
+
+VALUE mReadlineExtra = Qnil;
+
+void Init_readline_extra();
+
+static VALUE readline_extra_s_get_line_buffer(VALUE self);
+static VALUE readline_extra_s_set_line_buffer(VALUE self, VALUE str);
+static VALUE readline_extra_insert_text(VALUE self, VALUE text);
+static VALUE readline_extra_parse_and_bind(VALUE self, VALUE text);
+static VALUE readline_extra_redisplay(VALUE self);
+
+static VALUE readline_extra_s_set_pre_input_proc(VALUE self, VALUE proc);
+static VALUE readline_extra_s_get_pre_input_proc(VALUE self);
+static int readline_extra_on_pre_input_hook(void);
+
+int readline_extra_getc(FILE *stream);
+static VALUE readline_extra_s_set_char_input_proc(VALUE self, VALUE proc);
+static VALUE readline_extra_s_get_char_input_proc(VALUE self);
+static int readline_extra_on_char_input_hook(int c);
+
+void Init_readline_extra()
+{
+    mReadlineExtra = rb_define_module("Readline");
+
+    pre_input_proc = rb_intern(PRE_INPUT_PROC);
+    rl_pre_input_hook = readline_extra_on_pre_input_hook;
+
+    rb_define_singleton_method(mReadlineExtra, "pre_input_proc=", readline_extra_s_set_pre_input_proc, 1);
+    rb_define_singleton_method(mReadlineExtra, "pre_input_proc", readline_extra_s_get_pre_input_proc, 0);
+
+    rl_getc_function = readline_extra_getc;
+    char_input_proc = rb_intern(CHAR_INPUT_PROC);
+
+    rb_define_singleton_method(mReadlineExtra, "char_input_proc=", readline_extra_s_set_char_input_proc, 1);
+    rb_define_singleton_method(mReadlineExtra, "char_input_proc", readline_extra_s_get_char_input_proc, 0);
+
+    rb_define_module_function(mReadlineExtra, "line_buffer", readline_extra_s_get_line_buffer, 0);
+    rb_define_module_function(mReadlineExtra, "line_buffer=", readline_extra_s_set_line_buffer, 1);
+    rb_define_module_function(mReadlineExtra, "insert_text", readline_extra_insert_text, 1);
+    rb_define_module_function(mReadlineExtra, "parse_and_bind", readline_extra_parse_and_bind, 1);
+    rb_define_module_function(mReadlineExtra, "redisplay", readline_extra_redisplay, 0);
+
+}
+
+static VALUE readline_extra_s_get_line_buffer(VALUE self)
+{
+    if (rl_line_buffer)
+       return rb_tainted_str_new2(rl_line_buffer);
+    else
+       return rb_tainted_str_new2("");
+}
+
+static VALUE readline_extra_s_set_line_buffer(VALUE self, VALUE str)
+{
+    rl_replace_line(RSTRING(str)->ptr, 1);
+    rl_point = rl_end;
+
+    return readline_extra_s_get_line_buffer(self);
+}
+
+static VALUE readline_extra_insert_text(VALUE self, VALUE text)
+{
+    rl_insert_text(RSTRING(text)->ptr);
+    return self;
+}
+
+// doesn't seem to work
+static VALUE readline_extra_parse_and_bind(VALUE self, VALUE text)
+{
+    rl_parse_and_bind(RSTRING(text)->ptr);
+    return self;
+}
+
+static VALUE readline_extra_redisplay(VALUE self)
+{
+    rl_redisplay();
+    return self;
+}
+
+static int
+readline_extra_on_pre_input_hook(void)
+{
+    VALUE proc;
+
+    proc = rb_attr_get(mReadlineExtra, pre_input_proc);
+
+    if (NIL_P(proc))
+        return -1;
+
+    rb_funcall(proc, rb_intern("call"), 0);
+
+    return 0;
+}
+
+static VALUE
+readline_extra_s_set_pre_input_proc(VALUE self, VALUE proc)
+{
+    rb_secure(4);
+
+    if (!NIL_P(proc) && !rb_respond_to(proc, rb_intern("call")))
+        rb_raise(rb_eArgError, "argument must respond to `call'");
+
+    return rb_ivar_set(mReadlineExtra, pre_input_proc, proc);
+}
+
+static VALUE
+readline_extra_s_get_pre_input_proc(VALUE self)
+{
+    rb_secure(4);
+    return rb_attr_get(mReadlineExtra, pre_input_proc);
+}
+
+int readline_extra_getc(FILE *stream)
+{
+    int c;
+    c = rl_getc(stream);
+    return readline_extra_on_char_input_hook(c);
+}
+
+static int
+readline_extra_on_char_input_hook(int c)
+{
+    VALUE proc, ret;
+
+    proc = rb_attr_get(mReadlineExtra, char_input_proc);
+
+    if (NIL_P(proc))
+        return c;
+
+    ret = rb_funcall(proc, rb_intern("call"), 1, INT2FIX(c));
+
+    if(ret == Qnil)
+        return 0;
+
+    if(!FIXNUM_P(ret))
+        rb_raise(rb_eTypeError, "Readline::char_input_proc must return nil or a Fixnum");
+
+    return (int)FIX2INT(ret);
+}
+
+static VALUE
+readline_extra_s_set_char_input_proc(VALUE self, VALUE proc)
+{
+    rb_secure(4);
+
+    if (!NIL_P(proc) && !rb_respond_to(proc, rb_intern("call")))
+        rb_raise(rb_eArgError, "argument must respond to `call'");
+
+    return rb_ivar_set(mReadlineExtra, char_input_proc, proc);
+}
+
+static VALUE
+readline_extra_s_get_char_input_proc(VALUE self)
+{
+    rb_secure(4);
+    return rb_attr_get(mReadlineExtra, char_input_proc);
+}
+

data/lib/lijab/commands/contacts.rb

@@ -0,0 +1,101 @@
+
+module Lijab
+module Commands
+
+   module ContactsCommandMixin
+      SORTBY = ["status", "alpha"]
+
+      def completer(line)
+         sortby = line.split[1] || ""
+         if SORTBY.grep(sortby).empty?
+            SORTBY.grep(/^#{Regexp.escape(sortby)}/)
+         end
+      end
+
+      def group_contacts(contacts)
+         grouped = {}
+         contacts.each do |jid,contact|
+            groups = contact.roster_item.groups
+            if groups.empty?
+               (grouped["<no group>"] ||= []) << contact
+            else
+               groups.each { |g| (grouped[g] ||= []) << contact }
+            end
+         end
+
+         grouped = grouped.sort_by { |g,c| g }
+      end
+
+      def print_contacts(sort_by_status=false, online_only=false)
+         if sort_by_status
+            contacts = Main.contacts.sort { |a, b| -(a[1].presence <=> b[1].presence) }
+         else
+            contacts = Main.contacts.sort_by { |j,c| c.simple_name }
+         end
+
+         if Config.opts[:show_groups_in_contact_list]
+            grouped = group_contacts(contacts)
+         else
+            grouped = {nil => contacts.map { |j,c| c }}
+         end
+
+         s = []
+         grouped.each do |group, contactz|
+            if online_only
+               next unless contactz.any? { |c| c.online? }
+            end
+
+            s << " #{group} ".on_blue if group
+            contactz.each do |contact|
+               unless online_only && !contact.online?
+                  main = contact.presence
+                  s << "* #{contact.simple_name} #{main.pretty(true)} " \
+                     "(#{main.priority || 0}) [#{main.from || contact.jid}]"
+
+                  if online_only && contact.roster_item.presences.length > 1
+                     contact.roster_item.presences.each do |p|
+                        if p.from != main.from
+                           s << "    #{p.from} #{p.pretty(true)} (#{p.priority || 0})"
+                        end
+                     end
+                  end
+               end
+            end
+         end
+
+         Out::put(s.join("\n")) unless s.empty?
+      end
+
+   end
+
+   Command.define :contacts do
+      usage "/contacts [status|alpha]"
+      description "Show a list of all contacts. Sorted alphabetically or by status."
+
+      SORTBY = ["status", "alpha"]
+
+      def run(args)
+         print_contacts(args.split[0] == "status")
+      end
+
+      class << self
+         include ContactsCommandMixin
+      end
+   end
+
+   Command.define :who do
+      usage "/who [status|alpha]"
+      description "Show a list of online contacts. Sorted alphabetically or by status."
+
+      def run(args)
+         print_contacts(args.split[0] == "status", true)
+      end
+
+      class << self
+         include ContactsCommandMixin
+      end
+   end
+
+end
+
+end

data/lib/lijab/commands/options.rb

@@ -0,0 +1,49 @@
+
+module Lijab
+module Commands
+
+   Command.define :set do
+      usage "/set <option> [<value>]"
+      description "Modify the options. Print the current value if no <value> is given.\n" \
+                  "See #{Config.files[:config]} for the available options."
+      def run(args)
+         option, value = args.split(nil, 2).strip
+
+         option = option.to_sym if option
+
+         if !(Config.opts[option].is_a?(String) ||
+              Config.opts[option].is_a?(Numeric) ||
+              [true, false, nil].include?(Config.opts[option])) &&
+            Config.opts.key?(option)
+            raise CommandError, %{can't change "#{option} with /set"}
+         elsif !Config.opts.key?(option)
+            raise CommandError, %{no such option "#{option}"}
+         end
+
+         if value && !value.empty?
+            begin
+               val = YAML.load(value)
+               #raise TypeError unless val.is_a?(Config.opts[option].class)
+               Config.opts[option] = val
+            rescue
+               Out::error("invalid value", false)
+            end
+         else
+            Out::put(YAML.dump(Config.opts[option])[4..-1].chomp)
+         end
+
+      end
+
+      def completer(line)
+         option = line.split(nil, 2).strip[1] || ""
+         Config.opts.keys.find_all do |k|
+            k.to_s =~ /^#{Regexp.escape(option)}/ &&
+            (Config.opts[k].is_a?(String) ||
+             Config.opts[k].is_a?(Numeric) ||
+             [true, false, nil].include?(Config.opts[k]))
+         end
+      end
+   end
+
+end
+end

data/lib/lijab/commands/simple.rb

@@ -0,0 +1,132 @@
+
+module Lijab
+module Commands
+
+   Command.define :help do
+      usage "/help [<command> | commands]"
+      description "Get some help."
+
+      def run(args)
+         if args.empty?
+            s = %Q{
+               When in doubt, hit <tab>.
+
+               Some general hints:
+
+               Run "lijab -a <name>" to connect to the account named <name>.
+
+               Tab on an empty line will try to complete online contacts.
+               If there are no online contact matches for what you typed, offline contacts will also be
+               considered.
+
+               You can tab-complete specific resources of a contact by typing the contact name
+               followed by an @ character, e.g. somecontact@<tab> will complete all the available 
+               resources for the contact and a message can be sent to that specific resource.
+
+               Config/logs folder is at #{Config.basedir}
+
+               Put your custom commands in #{Config.dirs[:commands]}
+               Check out the files in <install-path>/lib/lijab/commands/ for some examples.
+
+               Put your custom hooks in #{Config.dirs[:hooks]}
+
+               Send mails to quuxbaz@gmail.com to complain about the lack of documentation :-)
+
+            }.gsub!(/^ */, '')
+            Out::put(s)
+         else
+            if args == "commands"
+               Out::put
+               Commands::registered.each do |name, cmd|
+                  Out::put(%{#{cmd.usage || "/#{name}"}}.magenta)
+                  Out::put("#{cmd.description}\n\n")
+               end
+            else
+               cmd = Commands::get(args)
+               if cmd
+                  s = "usage: #{cmd.usage}\n\n" if cmd.usage
+                  s = "#{s}#{cmd.description}"
+                  Out::put(s)
+               else
+                  raise CommandError, %(No such command "#{args}")
+               end
+            end
+         end
+      end
+
+      def completer(line)
+         help_cmd, rest = line.split(" ", 2)
+         rest ||= ""
+
+         m = "commands" =~ /^#{Regexp.escape(rest)}/ ? ["commands"] : []
+
+         rest = "/#{rest}"
+
+         m += Commands::completer(rest).map { |c| c[1..-1] } if rest.split(" ", 2).length == 1
+      end
+   end
+
+   Command.define :history do
+      usage "/history [<contact>] [<limit>]"
+      description "Show the message history with a <contact>, or all the contacts."
+
+      def run(args)
+         contact, limit = args.split(" ", 2).strip
+         limit ||= 10
+
+         if contact
+            raise CommandError, %(No contact named "#{contact}) unless Main.contacts.key?(contact)
+            m = Main.contacts[contact].history.last(limit.to_i)
+         else
+            m = HistoryHandler::last(limit.to_i)
+         end
+         Out::history(*m)
+      end
+
+      class << self
+         include ContactCompleterMixin
+      end
+   end
+
+   Command.define :multiline do
+      usage "/multiline <contact> [<first_line>]"
+      description "Enter multiline mode, meaning, send a multiline message to a contact.\n" \
+                  "Ctrl-d in an empty line exits multiline mode and sends the message."
+
+      def run(args)
+         contact, first_line = args.split(" ", 2).strip
+         first_line = "#{contact}: #{first_line}"
+         InputHandler::multiline(true, first_line)
+      end
+
+      class << self
+         include ContactCompleterMixin
+      end
+   end
+
+   Command.define :quit do
+      usage "/quit"
+      description "Quit lijab"
+
+      def run(args)
+         Main.quit
+      end
+   end
+
+   # TODO: make a generic option changer?
+   Command.define :show_status_changes do
+      usage "/show_status_changes yes|no"
+      description "Enable/disable printing the contacts' status changes. Can get quite spammish."
+
+      def run(args)
+         if !args || args.empty?
+            Out::put(Config.opts[:show_status_changes] ? "yes" : "no")
+         else
+            Config.opts[:show_status_changes] = args.strip == "yes"
+         end
+      end
+   end
+
+end
+end
+

data/lib/lijab/commands/status.rb

@@ -0,0 +1,63 @@
+
+module Lijab
+module Commands
+
+   Command.define :priority do
+      usage "/priority [<priority>]"
+      description "Change the jabber priority. Number must be between -127 and 127.\n" \
+                  "Show current priority if no argument is given."
+
+      def run(args)
+         if args.strip.empty?
+            Out::put("Current priority is #{Main.presence.priority}")
+            return
+         end
+
+         begin
+            p = Integer(args)
+         rescue ArgumentError
+            raise Commands::CommandError, %{"#{args}" is not a valid integer}
+         end
+
+         raise Commands::CommandError, "priority must be between -127 and 127" unless (-127..127).include?(p)
+
+         Main.set_priority(p)
+      end
+   end
+
+   Command.define :status do
+      usage "/status [available|away|chat|xa|dnd|invisible] [<message>]"
+      description "Set your status.\n" \
+                  "If no status is given, keep the current and set the status message.\n" \
+                  "If no message is given, keep the current status and clear the message.\n" \
+                  "If no arguments are given, print the current status."
+
+      STATUSES = ["available", "away", "chat", "xa", "dnd", "invisible"]
+
+      def run(args)
+         status, message = args.split(" ", 2).strip
+
+         unless status
+            p = Main.presence
+            Out::put("#{Config.jid} (#{p.priority || 0}) #{p.pretty(true)}")
+            return
+         end
+
+         unless STATUSES.include?(status)
+            message = "#{status} #{message}".strip
+            status = nil
+         end
+
+         Main.set_status(status && status.to_sym, message)
+      end
+
+      def completer(line)
+         status = line.split[1] || ""
+         if STATUSES.grep(status).empty?
+            STATUSES.grep(/^#{Regexp.escape(status)}/)
+         end
+      end
+   end
+
+end
+end

data/lib/lijab/commands/subscription.rb

@@ -0,0 +1,78 @@
+
+module Lijab
+module Commands
+   Command.define :add do
+      usage "/add <user@server>"
+      description "Add a user to your roster."
+
+      def run(args)
+         Main.contacts.add(args)
+         Out::put("subscription request sent to #{args}")
+      end
+   end
+
+   Command.define :remove do
+      usage "/remove <user@server>"
+      description "Remove a user from your roster."
+      
+      def run(args)
+         unless Main.contacts.remove(args)
+            raise CommandError, "no contact found for #{args}"
+         end
+      end
+
+      class << self
+         include ContactCompleterMixin
+      end
+   end
+
+   # TODO: <user@server | all>
+   Command.define :requests do
+      usage "/requests [accept|accept_and_add|decline <user@server>]"
+      description "Accept/decline a user's request to see your status.\n" \
+                  "Print pending requests if no argument given." \
+
+      ACTIONS = ["accept", "accept_and_add", "decline"]
+
+      def run(args)
+         action, addr = args.split(nil, 2).strip
+
+         if action
+            unless ACTIONS.include?(action)
+               raise CommandError, "action must be accept, accept_and_add or decline"
+            end
+            raise CommandError, "need the user's address" unless addr and !addr.empty?
+
+            if ["accept", "accept_and_add"].include?(action)
+               success = Main.contacts.process_request(addr, :accept)
+               Main.contacts.add(addr) if success && action == "accept_and_add"
+            else
+               success = Main.contacts.process_request(addr, :decline)
+            end
+
+            raise CommandError, "no pending request from #{addr}" unless success
+         else
+            if Main.contacts.has_subscription_requests?
+               Out::put("pending requests from:")
+               Out::put(Main.contacts.subscription_requests.join("\n"))
+            else
+               Out::put("no pending requests")
+            end
+         end
+      end
+
+      def completer(line)
+         _, action, addr = line.split(nil, 3)
+
+         if !addr
+            ACTIONS.grep(/^#{Regexp.escape(action)}/)
+         elsif addr && ACTIONS.include?(action)
+            Main.contacts.subscription_requests.grep(/^#{Regexp.escape(addr)}/).map do |c|
+               "#{action} #{c}"
+            end
+         end
+      end
+   end
+
+end
+end