rubeechat 0.1.0

data/Rakefile

@@ -0,0 +1,28 @@
+# The Mohel cuts our gems
+def define_mohel_task
+  require 'rubygems'
+  gem 'mohel', '>= 0.4.10'
+  require 'mohel'
+
+  Mohel::Task.new do |t|
+    s           = t.gem_spec
+    s.name      = 'rubeechat'
+    s.summary   = "Rubeechat: little ruby helpers for scripting WeeChat"
+    s.has_rdoc  = true
+    s.authors   = ['Jonathan D. Simms']
+    s.email     = 'slyphon@gmail.com'
+    s.files     = FileList["Rakefile", '{lib,plugins}/**/*']
+    s.executables = 'rubeechat-install-plugins'
+    yield t if block_given?
+
+  end
+rescue LoadError => e
+  
+  $stderr.puts %Q[#{e.class}: #{e.message}\n#{e.backtrace.map { |l| "\t#{l}" }.join("\n")}]
+
+  $stderr.puts "You must do 'gem install mohel' to create rubeechat gems"
+end
+
+define_mohel_task
+
+

data/bin/rubeechat-install-plugins

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'fileutils'
+
+RUBEECHAT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..')) unless defined?(RUBEECHAT_ROOT)
+
+module Rubeechat
+  class Installer
+    include FileUtils
+
+    BANNER = <<-EOS
+Usage: #{File.basename($0)} [opts]
+
+Installs symlinks to the packaged plugins in your $HOME/.weechat/ruby directory (or in
+the --plugins-dir directory, if given).
+
+Will not overwrite existing links or files unless --force option is given.
+
+Options:
+
+    EOS
+
+    def self.run(*argv)
+      self.new.run(*argv)
+    end
+
+    def initialize
+      @plugins_dir = File.expand_path('~/.weechat/ruby')
+      @plugins = Dir[File.join(RUBEECHAT_ROOT, 'plugins', '*.rb')]
+      @force = false
+    end
+
+    def optparser
+      @optparser ||= OptionParser.new do |o|
+        o.banner = BANNER
+        o.on('-f', '--force', 'forces overwriting of existing symlinks in plugin-dir') { @force = true }
+        o.on('-D', '--plugin-dir DIR', 'path to the .weechat/ruby plugins dir to install to') { |d| @plugins_dir = File.expand_path(d) }
+        o.on('-h', '--help', "you're reading it") { help! }
+      end
+    end
+
+    def help!
+      $stderr.puts optparser
+      exit 1
+    end
+
+    def run(*argv)
+      optparser.parse!(argv)
+
+      @plugins.each do |p|
+        target = File.expand_path(File.join(@plugins_dir, File.basename(p)))
+
+        if File.exists?(target)
+          if @force
+            rm_f(target)
+          else
+            $stderr.puts "file #{target} already exists, not clobbering without --force option"
+            next
+          end
+        end
+
+        $stderr.puts "installing symlink #{target} -> #{p}"
+
+        ln_s(p, target)
+      end
+    end
+  end
+end
+
+Rubeechat::Installer.run(*ARGV)
+
+# vim:ft=ruby:ts=2:sw=2:et

data/lib/rubeechat.rb

@@ -0,0 +1,13 @@
+RUBEECHAT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+$LOAD_PATH.unshift(File.join(RUBEECHAT_ROOT, 'lib'))
+$LOAD_PATH.uniq!
+
+module Rubeechat
+end
+
+require 'rubeechat/info_list'
+require 'rubeechat/privmsg'
+require 'rubeechat/config'
+require 'rubeechat/installer'
+

data/lib/rubeechat/base.rb

@@ -0,0 +1,12 @@
+module Rubeechat
+  class Base
+    attr_accessor :name, :author, :license, :description, :shutdown_function, :charset
+
+
+    def register!
+      ::Weechat.register
+    end
+  
+  end
+end
+

data/lib/rubeechat/config.rb

@@ -0,0 +1,33 @@
+module Rubeechat
+  module Config
+    class OptionNotFoundError < StandardError; end
+    class GenericOptionError < StandardError; end
+
+    include Weechat
+    extend Weechat
+
+    def self.[](key)
+      key = key.to_s
+      return nil unless has_key?(key)
+      config_get_plugin(key)
+    end
+
+    def self.[]=(key,value)
+      case config_set_plugin(key.to_s, value.to_s)
+      when WEECHAT_CONFIG_OPTION_SET_OK_CHANGED
+        value
+      when WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE
+        value
+      when WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND
+        raise OptionNotFoundError, key.to_s
+      when WEECHAT_CONFIG_OPTION_SET_ERROR
+        raise GenericOptionError, key.to_s
+      end
+    end
+
+    def self.has_key?(key)
+      config_is_set_plugin(key) > 0
+    end
+  end
+end
+

data/lib/rubeechat/info_list.rb

@@ -0,0 +1,106 @@
+module Rubeechat
+  class InfoList
+    include Enumerable
+
+    # a very cheezy implemenation of a buffer object
+    class Buffer
+      def initialize(ptr, hash)
+        @p = ptr
+        @hash = hash
+      end
+
+      # print a message to this buffer
+      def print(msg)
+        Weechat.print(@p, msg)
+      end
+
+      def server
+        name.split('.').first
+      end
+
+      def current_buffer?
+        current_buffer == 1
+      end
+
+      private
+        def method_missing(name, *a, &b)
+          name = name.to_sym
+          if @hash.has_key?(name)
+            @hash[name]
+          else
+            super(name, *a, &b)
+          end
+        end
+    end
+
+    attr_reader :p
+
+    def self.open(name, ptr='')
+      obj = self.new(name, ptr)
+      yield obj
+    ensure
+      obj.close
+    end
+
+    # return a buffer object from information in infolist pointed to by ptr
+    def self.buffer(ptr)
+      open(:buffer, ptr) do |info|
+        Buffer.new(ptr, info.first)
+      end
+    end
+
+    def initialize(name, ptr='')
+      @name = name.to_s
+      @p    = Weechat.infolist_get(@name, ptr, '')
+    end
+
+    def close
+      return unless @p
+      i, @p = @p , nil
+      Weechat.infolist_free(i)
+      nil
+    end
+
+    def each
+      while Weechat.infolist_next(@p) > 0
+        hash = Weechat.infolist_fields(@p).split(',').inject({}) do |memo,str|
+          ftype, name = str.split(':')
+
+          next memo if name =~ /^localvar/
+
+          if val = fetch_item(ftype, name)
+            memo[name.to_sym] = val
+          end
+
+          memo
+        end
+
+        yield hash
+      end
+    end
+
+    # returns the first struct in the infolist
+    def first
+      to_a.first  # inefficient!
+    end
+
+    private
+      def fetch_item(ftype, name)
+        case ftype
+        when 'i'
+          Weechat.infolist_integer(@p, name)
+        when 's'
+          Weechat.infolist_string(@p, name)
+        when 'p'
+          Weechat.infolist_pointer(@p, name)
+        when 'b'
+          nil
+        when 't'
+          Weechat.infolist_time(@p, name)
+        else
+          raise "Wtf? unknown field type string: #{ftype}"
+        end
+      end
+  end
+end
+

data/lib/rubeechat/privmsg.rb

@@ -0,0 +1,72 @@
+module Rubeechat
+
+  class Privmsg
+    def self.parse(signal, data)
+      server, _ = signal.split(',')
+
+      if data =~ /:([^ ]+) PRIVMSG (#?[^ ]+) :(.*)/
+        self.new(server, $1, $2, $3)
+      end
+    end
+
+    attr_reader :server, :user, :channel, :message
+
+    def initialize(server, user, channel, message)
+      @server, @user, @channel, @message = server, user, channel, message
+    end
+
+    # :trptcolin!~trptcolin@c-24-15-225-118.hsd1.il.comcast.net
+
+    def nick
+      @nick ||= user[/^([^!]+)!/, 1]
+    end
+
+    def login
+      @login ||= user[/!~([^@]+)@/, 1]
+    end
+
+    def hostname
+      @hostname ||= user[/@(.*)$/, 1]
+    end
+
+    # the buffer name that is related to this message
+    def buffer_name
+      "#{server}.#{channel}"
+    end
+
+    # lazily construct a buffer object associated with this privmsg
+    def buffer
+      unless @buffer
+        if ptr = Weechat.buffer_search('irc', buffer_name)
+          @buffer = InfoList.buffer(ptr)
+        else
+          raise "Could not find buffer named: #{buffer_name.inspect}"
+        end
+      end
+      @buffer
+    end
+
+    def about_me?
+      message =~ /#{nick_ptrn_str}/
+    end
+
+    def to_me?
+      message =~ /^#{nick_ptrn_str}/
+    end
+
+    def involves_me?
+      about_me? or to_me?
+    end
+
+    def in_current_buffer?
+      buffer.current_buffer?
+    end
+
+    private
+      # regular expression string for our nick
+      def nick_ptrn_str
+        @nick_ptrn ||= Regexp.new(Regexp.escape(Weechat.info_get('irc_nick', server)))
+      end
+  end
+end
+

data/plugins/growl.rb

@@ -0,0 +1,376 @@
+#growl notifications for weechat
+require 'time'
+require 'date'
+require 'md5'
+require 'socket'
+
+#------------------------------------------------------------------------------
+# taken from ruby-growl-1.0.1 verbatim
+
+class Growl
+
+  ##
+  # The Ruby that ships with Tiger has a broken #pack, so 'v' means network
+  # byte order instead of 'n'.
+
+  BROKEN_PACK = [1].pack("n") != "\000\001" # :nodoc:
+
+  ##
+  # ruby-growl Version
+
+  VERSION = "1.0.1"
+
+  ##
+  # Growl Network Registration Packet +pack+ Format
+  #--
+  # Format:
+  # 
+  #   struct GrowlNetworkRegistration {
+  #     struct GrowlNetworkPacket {
+  #       unsigned char version;
+  #       unsigned char type;
+  #     } __attribute__((packed));
+  #     unsigned short appNameLen;
+  #     unsigned char numAllNotifications;
+  #     unsigned char numDefaultNotifications;
+  #     /*
+  #      *  Variable sized. Format:
+  #      *  <application name><all notifications><default notifications><checksum>
+  #      *  where <all notifications> is of the form (<length><name>){num} and
+  #      *  <default notifications> is an array of indices into the all notifications
+  #      *  array, each index being 8 bits.
+  #      */
+  #     unsigned char data[];
+  #   } __attribute__((packed));
+
+  GNR_FORMAT = "CCnCCa*"
+
+  GNR_FORMAT.gsub!(/n/, 'v') if BROKEN_PACK
+
+  ##
+  # Growl Network Notification Packet +pack+ Format
+  #--
+  # Format:
+  # 
+  #   struct GrowlNetworkNotification {
+  #     struct GrowlNetworkPacket {
+  #       unsigned char version;
+  #       unsigned char type;
+  #     } __attribute__((packed));
+  #     struct GrowlNetworkNotificationFlags {
+  #       unsigned reserved: 12;
+  #       signed   priority: 3;
+  #       unsigned sticky:   1;
+  #     } __attribute__((packed)) flags; //size = 16 (12 + 3 + 1)
+  #     unsigned short nameLen; 
+  #     unsigned short titleLen;
+  #     unsigned short descriptionLen;
+  #     unsigned short appNameLen;
+  #     /*
+  #      *  Variable sized. Format:
+  #      *  <notification name><title><description><application name><checksum>
+  #      */
+  #     unsigned char data[];
+  #   } __attribute__((packed));
+
+  GNN_FORMAT = "CCnnnnna*"
+
+  GNN_FORMAT.gsub!(/n/, 'v') if BROKEN_PACK
+
+  ##
+  # Growl UDP Port
+
+  GROWL_UDP_PORT = 9887
+
+  ##
+  # Growl Protocol Version
+
+  GROWL_PROTOCOL_VERSION = 1
+
+  ##
+  # Growl Registration Packet Id
+
+  GROWL_TYPE_REGISTRATION = 0
+
+  ##
+  # Growl Notification Packet Id
+
+  GROWL_TYPE_NOTIFICATION = 1
+
+  ##
+  # Creates a new Growl notifier and automatically registers any notifications
+  # with the remote machine.
+  #
+  # +host+ is the host to contact.
+  #
+  # +app_name+ is the name of the application sending the notifications.
+  #
+  # +all_notifies+ is a list of notification types your application sends.
+  #
+  # +default_notifies+ is a list of notification types that are turned on by
+  # default.
+  #
+  # I'm not sure about what +default_notifies+ is supposed to be set to, since
+  # there is a comment that says "not a subset of all_notifies" in the code.
+  #
+  # +password+ is the password needed to send notifications to +host+.
+
+  def initialize(host, app_name, all_notifies, default_notifies = nil,
+                 password = nil)
+    @socket = UDPSocket.open
+    # FIXME This goes somewhere else
+    @socket.connect host, GROWL_UDP_PORT
+    @app_name = app_name
+    @all_notifies = all_notifies
+    @default_notifies = default_notifies.nil? ? all_notifies : default_notifies
+    @password = password
+
+    register
+  end
+
+  ##
+  # Sends a notification.
+  #
+  # +notify_type+ is the type of notification to send.
+  #
+  # +title+ is a title for the notification.
+  #
+  # +message+ is the body of the notification.
+  #
+  # +priority+ is the priorty of message to send.
+  #
+  # +sticky+ makes the notification stick until clicked.
+
+  def notify(notify_type, title, message, priority = 0, sticky = false)
+    raise "Unknown Notification" unless @all_notifies.include? notify_type
+    raise "Invalid Priority" unless priority >= -2 and priority <= 2
+
+    send notification_packet(notify_type, title, message, priority, sticky)
+  end
+  
+  # really? i had to add this?
+  def close
+    @socket.close
+  end
+
+  private unless $TESTING
+
+  ##
+  # Registers the notification types with +host+.
+
+  def register
+    send registration_packet
+  end
+
+  ##
+  # Sends a Growl packet
+
+  def send(packet)
+    set_sndbuf packet.length
+    @socket.send packet, 0
+    @socket.flush
+  end
+
+  ##
+  # Builds a Growl registration packet
+
+  def registration_packet
+    length = 0
+    data = []
+    data_format = ""
+
+    packet = [
+      GROWL_PROTOCOL_VERSION,
+      GROWL_TYPE_REGISTRATION
+    ]
+
+    packet << @app_name.length
+    packet << @all_notifies.length
+    packet << @default_notifies.length
+
+    data << @app_name
+    data_format = "a#{@app_name.length}"
+
+    @all_notifies.each do |notify|
+      data << notify.length
+      data << notify
+      data_format << "na#{notify.length}"
+    end
+
+    @default_notifies.each do |notify|
+      data << @all_notifies.index(notify) if @all_notifies.include? notify
+      data_format << "C"
+    end
+
+    data_format.gsub!(/n/, 'v') if BROKEN_PACK
+
+    data = data.pack data_format
+
+    packet << data
+
+    packet = packet.pack GNR_FORMAT
+
+    checksum = MD5.new packet
+    checksum.update @password unless @password.nil?
+
+    packet << checksum.digest
+
+    return packet
+  end
+
+  ##
+  # Builds a Growl notification packet
+
+  def notification_packet(name, title, description, priority, sticky)
+    flags = 0
+    data = []
+
+    packet = [
+      GROWL_PROTOCOL_VERSION,
+      GROWL_TYPE_NOTIFICATION,
+    ]
+
+    flags = 0
+    flags |= ((0x7 & priority) << 1) # 3 bits for priority
+    flags |= 1 if sticky # 1 bit for sticky
+
+    packet << flags
+    packet << name.length
+    packet << title.length
+    packet << description.length
+    packet << @app_name.length
+
+    data << name
+    data << title
+    data << description
+    data << @app_name
+
+    packet << data.join
+    packet = packet.pack GNN_FORMAT
+
+    checksum = MD5.new packet
+    checksum.update @password unless @password.nil?
+
+    packet << checksum.digest
+
+    return packet
+  end
+
+  ##
+  # Set the size of the send buffer
+  #--
+  # Is this truly necessary?
+
+  def set_sndbuf(length)
+    @socket.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDBUF, length
+  end
+
+end
+
+# end ruby-growl
+#-----------------------------------------------------------------------------
+
+require 'rubygems'
+require 'rubeechat'
+
+require 'logger'
+require 'ostruct'
+
+require 'rubygems'
+require 'ruby-debug'
+
+# Debugger.start_remote('127.0.0.1', [Debugger::PORT, Debugger::PORT + 1], false) do
+#   # load initrc script
+#   Debugger.run_init_script(StringIO.new)
+# end
+
+L = Logger.new('/dev/null')
+L.level = Logger::DEBUG
+
+class Privmsg < Rubeechat::Privmsg
+end
+
+def disabled?
+  Rubeechat::Config['disabled'] == 'true'
+end
+
+GROWLER = Growl.new('127.0.0.1', 'weechat', ['message'])
+
+def inactivity
+  Weechat.info_get('inactivity', '').to_i
+end
+
+def growl_notify(title, message, priority=0, sticky=false)
+  L.debug "sending growl notification, type: 'message', title: %p, message: %p, priority: %p, sticky: %p" % [title, message, priority, sticky]
+  GROWLER.notify('message', title, message, priority, sticky)
+end
+
+def ok
+  Weechat::WEECHAT_RC_OK
+end
+
+def growl_cmd(_, buf_ptr, args)
+  buf = Rubeechat::InfoList.buffer(buf_ptr)
+
+  cmd, args = args.split(' ', 2)
+
+  case cmd
+  when 'test'
+    growl_notify('test', args)
+  when 'disable'
+    Rubeechat::Config['disabled'] = 'true'
+  when 'enable'
+    Rubeechat::Config['disabled'] = 'false'
+  when 'break'
+#     debugger
+  end
+
+  ok
+end
+
+def privmsg_cb(_, signal, signal_data)
+  p = Rubeechat::Privmsg.parse(signal, signal_data)
+
+  if p.involves_me?
+    # if the message is in a different channel than the current buffer, or
+    # we've been inactive for more then 30 seconds
+    if !p.in_current_buffer? or (inactivity > 30) and not disabled?
+
+      msg_type_str = p.to_me? ? "#{p.nick} is talking about you" : "#{p.nick} is talking to you"
+      growl_notify("#{msg_type_str} in #{p.channel}", p.message)
+    end
+  end
+
+  ok
+end
+
+DEFAULT_OPTS = {
+  'disabled' => 'false'
+}
+
+ARG_INFO = <<-EOS
+test: send a test message to growl daemon
+enable: unsilence the growler (default)
+disable: silence the growler
+EOS
+
+ARG_FORM = '[test|enable|disable]'
+
+def weechat_destructor
+  L.close
+  GROWLER.close
+  ok
+end
+
+def weechat_init
+  Weechat.register('growler', 'slyphon', '0.1', 'GPL3', 'Growl notify when mentioned', 'weechat_destructor', '')
+  Weechat.hook_signal('*,irc_in_PRIVMSG', 'privmsg_cb', '')
+  Weechat.hook_command('growl', 'control the growler', ARG_FORM, ARG_INFO, '', 'growl_cmd', '')
+
+  DEFAULT_OPTS.each do |k,v|
+    Rubeechat::Config[k] = v unless Rubeechat::Config.has_key?(k)
+  end
+
+  ok
+end
+

data/plugins/urlopen.rb

@@ -0,0 +1,220 @@
+require 'rubygems'
+require 'rubeechat'
+
+require 'logger'
+require 'ostruct'
+
+## start remote debugger
+
+# require 'rubygems'
+# require 'ruby-debug'
+
+# Debugger.start_remote('127.0.0.1', [Debugger::PORT, Debugger::PORT + 1], false) do
+#   # load initrc script
+#   Debugger.run_init_script(StringIO.new)
+# end
+
+L = Logger.new('/dev/null')
+L.level = Logger::DEBUG
+
+class ::Symbol
+  include Comparable
+
+  def <=>(other)
+    to_s <=> other.to_s
+  end
+end
+
+class UrlRingBuffer
+  include Enumerable
+
+  DEFAULT_SIZE = 20
+
+  attr_reader :current_index, :array
+
+  def initialize(size=nil)
+    @max_size ||= DEFAULT_SIZE
+
+    @array = Array.new(@max_size)
+
+    @current_index = -1       # initial state
+  end
+
+  def [](idx)
+    @array[idx]
+  end
+
+  def replace(other)
+    unless other.kind_of?(UrlRingBuffer)
+      raise ArgumentError, "argument to replace must be a UrlRingBuffer, not: #{other.inspect}"
+    end
+
+    @array.replace(other.array)
+    self
+  end
+
+  def empty?
+    (@current_index == -1)
+  end
+
+  def clear
+    @array.clear
+    @current_index = -1
+  end
+
+  def add(obj)
+    @current_index += 1
+
+    if @current_index >= @max_size      # if we are over the max # of items to store
+      puts "resetting index to 0"
+      @current_index = 0                # start again at 0
+    end
+
+    @array[@current_index] = obj 
+  end
+
+  def current_item
+    (@current_index >= 0) ? @array[@current_index] : nil
+  end
+
+  # yields [idx, obj] to the block given
+  def each
+    @array.each_with_index do |obj,i|
+      next unless obj
+      yield i, obj
+    end
+  end
+end
+
+Rubeechat::InfoList::Buffer.class_eval do
+  def urls
+    RING_BUFFERS[name]
+  end
+
+  def current_url
+    RING_BUFFERS[name].current_item
+  end
+end
+
+class Privmsg < Rubeechat::Privmsg
+  def urls
+    unless @urls
+      @urls, str = [], message
+      while str =~ %r%([a-z0-9]+://[^ ]+)%
+        @urls << $1
+        str = $~.post_match
+      end
+    end
+    @urls
+  end
+end
+
+
+def ok
+  Weechat::WEECHAT_RC_OK
+end
+
+# --- plugin implementation ---------------------------------
+
+RING_BUFFERS = Hash.new { |n,q| n[q] = UrlRingBuffer.new } unless defined?(RING_BUFFERS)
+
+def _debug(m=nil, &b)
+  L.debug(m=nil, &b)
+end
+
+def open_url(buffer, i=nil)
+  url = i.nil? ? buffer.current_url : buffer.urls[i]
+
+  if url
+    cmd = Rubeechat::Config['command'] % [url]
+    system(cmd)
+  else
+    msg = i.nil? ? "url ring empty" : "no url # #{i} for buffer #{buffer.name}"
+    buffer.print("urlopen: #{msg}")
+  end
+end
+
+def open_cmd(data, buf_ptr, args)
+  buf = Rubeechat::InfoList.buffer(buf_ptr)
+
+  cmd, args = args.split(' ', 2)
+
+  case cmd
+  when 'list'
+    if buf.urls.empty?
+      buf.print("urlopen: no saved urls!")
+    else
+      buf.urls.each do |idx, url|
+        next unless url
+        buf.print("[%d]: %s" % [idx,url])
+      end
+    end
+  when 'set-command'
+    Rubeechat::Config['command'] = args
+    buf.print("urlopen: command is now #{args}")
+  when 'clear'
+    buf.urls.clear
+    buf.print("urlopen: cleared url list")
+  when 'clobber'
+    RING_BUFFERS.clear
+    buf.print("urlopen: clobbered url list (all saved urls)")
+  when /(\d+)/
+    open_url(buf, $1.to_i)
+  when 'debug'
+    debugger
+  else
+    open_url(buf) 
+  end
+
+  ok
+end
+
+def privmsg_cb(data, signal, signal_data)
+  _debug { "privmsg_cb signal: #{signal}, #{signal_data}" }
+  pm = Privmsg.parse(signal, signal_data)
+
+  pm.urls.each do |url|
+    _debug { "found url: #{url} in buffer: #{pm.buffer_name}" }
+
+    _debug { "pm.buffer.urls: #{pm.buffer.urls.inspect}, pm.buffer.name #{pm.buffer.name}" }
+
+    pm.buffer.urls.add(url)  # only does the expensive buffer loading if we found somethin
+
+    _debug { "pm.buffer.urls: #{pm.buffer.urls.inspect}, pm.buffer.name #{pm.buffer.name}" }
+
+    pm.buffer.print("[%d]: %s" % [pm.buffer.urls.current_index, pm.buffer.current_url])
+  end
+
+  ok
+end
+
+ARG_INFO = <<-EOS
+[1-20]: enter a url number from the current buffer
+list: list all urls we know about
+clear: forget all urls for this buffer
+dump: display all urls we know about
+EOS
+
+ARG_FORM = '[1-20] | [list|clear|dump]'
+
+DEFAULT_OPTS = {
+  'command' => %q[/usr/bin/open '%s'],
+}
+
+def weechat_destructor
+  L.close
+  ok
+end
+
+def weechat_init
+  Weechat.register('urlopen', 'slyphon', '0.1', 'GPL3', 'Open urls pasted in chat', 'weechat_destructor', '')
+  Weechat.hook_signal('*,irc_in_PRIVMSG', 'privmsg_cb', '')
+  Weechat.hook_command('open', 'open a url', ARG_FORM, ARG_INFO, '', 'open_cmd', '')
+
+  DEFAULT_OPTS.each do |k,v|
+    Rubeechat::Config[k] = v unless Rubeechat::Config.has_key?(k)
+  end
+
+  ok
+end
+

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: rubeechat
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jonathan D. Simms
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-23 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: 
+email: slyphon@gmail.com
+executables: 
+- rubeechat-install-plugins
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/rubeechat/base.rb
+- lib/rubeechat/config.rb
+- lib/rubeechat/info_list.rb
+- lib/rubeechat/privmsg.rb
+- lib/rubeechat.rb
+- plugins/growl.rb
+- plugins/urlopen.rb
+- bin/rubeechat-install-plugins
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: "Rubeechat: little ruby helpers for scripting WeeChat"
+test_files: []
+