lijab 0.1.1

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/ext/test.rb

@@ -0,0 +1,29 @@
+require 'readline'
+require 'readline_extra'
+
+Thread.abort_on_exception = true
+Thread.new do
+   sleep(40)
+   #puts
+   #puts "got #{Readline::line_buffer}"
+   #print "reset to: "
+   #p (Readline::line_buffer = "congaland!")
+   ##puts "\n#{Readline::line_buffer}\n> "
+   #Readline::line_buffer = "congaland!"
+   Readline::line_buffer = ""
+   puts
+   #print "> #{Readline::line_buffer}"
+   #$stdout.flush
+   Readline::redisplay
+end
+
+trap('SIGINT') do
+   Readline::line_buffer = ""
+   print "\n> "
+   $stdout.flush
+   #print "> #{Readline::line_buffer}"
+   #$stdout.flush
+   Readline::redisplay
+end
+
+puts Readline::readline('> ')

data/lib/bleh.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'xmpp4r'
+require 'xmpp4r/client'
+require 'xmpp4r/roster'
+require 'xmpp4r/vcard'
+include Jabber
+
+Thread.abort_on_exception = true
+Jabber::debug = true if ARGV.length > 0
+$jid = JID.new("a@poobar/bloh")
+$cl = Client.new($jid)
+$cl.connect("localhost")
+$cl.auth("lalala")
+#$jid = JID.new("pflouret@gmail.com/irb")
+#$cl = Client.new($jid)
+#$cl.connect("talk.google.com")
+#$cl.auth("")
+$roster = Roster::Helper.new($cl)
+self_ri = Roster::Helper::RosterItem.new($cl)
+self_ri.jid = $jid
+$roster.items[self_ri.jid] = self_ri
+$roster.wait_for_roster
+$v = Vcard::Helper.new($cl)
+
+require 'pp'
+def prin(from, i, pr)
+   puts
+   puts from
+   p i
+   puts pr.from
+   p pr.type
+   p pr.show
+   p pr.status
+   p pr.priority
+   #puts
+   #pp $roster.items
+end
+
+$roster.add_subscription_callback { |i, pr| prin(:subscallback, i, pr) }
+$roster.add_subscription_request_callback { |i, pr| prin(:reqcallback, i, pr) }
+
+$cl.send(Jabber::Presence.new.set_type(:available).set_priority(1))
+
+
+Thread.stop

data/lib/configs/commands/cowsay.rb

@@ -0,0 +1,33 @@
+
+include Lijab
+
+Commands::Command.define :cowsay do
+   usage "/cowsay <contact> <msg>"
+   description %q{
+ _______________________
+< Send a message by cow >
+ -----------------------
+        \   ^__^
+         \  (oo)\_______
+            (__)\       )\/\
+                ||----w |
+                ||     ||}[1..-1]
+
+   def run(args)
+      contact, say = args.split(" ", 2).strip
+      if say && Main.contacts.key?(contact)
+         msg = "\n#{`cowsay #{say} 2>&1`}"
+         if $?.success?
+            Main.contacts[contact].send_message(msg)
+         else
+            raise Commands::CommandError, %{shell complained: "#{msg.chomp}"}
+         end
+      end
+   end
+
+   def completer(line)
+      contact = line.split[1] || ""
+      Main.contacts.completer(contact, false) if contact.empty? || !Main.contacts.key?(contact)
+   end
+end
+

data/lib/configs/hooks/ting.rb

@@ -0,0 +1,23 @@
+
+include Lijab
+
+require 'festivaltts4r'
+
+Hooks::on_incoming_message do |contact, msg|
+   Thread.new do
+      system("aplay -q /usr/share/gajim/data/sounds/message2.wav &> /dev/null")
+   end
+end
+
+#Hooks::on_incoming_message do |contact, msg|
+#   msg.to_speech
+#end
+
+#Hooks::on_pre_send_message do |contact, body|
+#   Out::inline("before sending message to #{contact}")
+#   "#{body}, motherfucker"
+#end
+
+#Hooks::on_post_send_message do |contact, body|
+#   Out::inline("after sending message to #{contact}")
+#end

data/lib/lijab.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'lijab/main'
+
+Lijab::Main.run!
+Thread.stop
+

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
+