badboy-jabbot 0.1.0

data/README.rdoc

@@ -0,0 +1,135 @@
+= Jabbot
+Official URL: http://github.com/badboy/jabbot/tree/master
+Jan-Erik Rediger (BadBoy_) (http://badboy.pytalhost.de)
+
+== Description
+
+Jabbot is a Ruby microframework for creating Jabber/MUC
+bots, heavily inspired by Sinatra and Twibot.
+I modified the code of Twibot to fit my needs.
+The original Twibot code is located at:
+http://github.com/cjohansen/twibot/tree/master
+
+A big thank you to Christian Johansen, who wrote the code for Twibot.
+Jabbot is heavily based on his code.
+
+== Usage
+
+=== Simple example
+
+  require 'jabbot'
+
+  # Receive messages, and post them publicly
+  #
+  message do |message, params|
+    post message.text
+  end
+
+  # Respond to query if they come from the right crowd
+  # post "message" => "user" is just some syntax sugar
+  # post "message", "user" will work to
+  query :from => [:cjno, :irbno] do |message, params|
+    post "#{message.user} I agree" => message.user
+  end
+
+  # Listen in and log tweets
+  # (you can use "message :all" too ;)
+  message do |message, params|
+    MyApp.log_message(message)
+  end
+
+=== Running the bot
+
+To run the bot, simply do:
+
+  ruby bot.rb
+
+=== Configuration
+
+Jabbot looks for a configuration file in ./config/bot.yml. It should contain
+atleast:
+
+  login: jabber_login
+  password: jabber_password
+  channel: channel_to_join
+  server: server_to_connect_to
+
+You can also configure with Ruby:
+
+  configure do |conf|
+    conf.login = "my_account"
+  do
+
+If you don't specify login and/or password in any of these ways, Jabbot will fail
+
+=== "Routes"
+
+Like Sinatra, and other web app frameworks, Jabbot supports "routes": patterns
+to match incoming tweets and messages:
+
+  require 'jabbot'
+
+  message "time :country :city" do |message,params|
+    time = MyTimeService.lookup(params[:country], params[:city])
+    post "Time is #{time} in #{params[:city]}, #{params[:country]}"
+  end
+
+You can have several "message" blocks (or "join", "leave", "query" or "subject").
+Every matching block will be called.
+
+Jabbot also supports regular expressions as routes:
+
+  require 'jabbot'
+
+  message /^time ([^\s]*) ([^\s]*)/ do |message, params|
+    # params is an array of matches when using regexp routes
+    time = MyTimeService.lookup(params[0], params[1])
+    post "Time is #{time} in #{params[:city]}, #{params[:country]}"
+  end
+
+== Requirements
+
+xmpp4r. You'll need atleast 0.4.
+You can get it via rubygems:
+ gem install xmpp4r
+or download it from:
+http://home.gna.org/xmpp4r/
+
+== Installation
+
+ gem sources -a http://gems.github.com  # you only have to do this once
+ gem install badboy-jabbot
+
+== Is it Ruby 1.9?
+
+All tests passes even on Ruby 1.9.
+Seems like it works :)
+
+== Contributors
+
+* Christian Johansen (cjohansen) (author of Twibot) - http://www.cjohansen.no
+
+== License
+
+(The MIT License)
+
+Copyright (c) 2009 Jan-Erik Rediger (Badboy_)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/hash.rb

@@ -0,0 +1,8 @@
+class Hash
+  def symbolize_keys!
+    replace(inject({}) do |hash,(key,value)|
+      hash[key.to_sym] = value.is_a?(Hash) ? value.symbolize_keys! : value
+      hash
+    end)
+  end
+end

data/lib/jabbot.rb

@@ -0,0 +1,84 @@
+require 'time'
+require 'xmpp4r'
+require 'xmpp4r/muc/helper/simplemucclient'
+#require 'xmpp4r/muc/helper/mucclient'
+require 'xmpp4r/version/helper/simpleresponder'
+require 'yaml'
+require File.join(File.dirname(__FILE__), 'hash')
+
+module Jabbot
+
+  # :stopdoc:
+  VERSION = '0.0.1'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= File.basename(fname, '.*')
+    search_me = File.expand_path(File.join(File.dirname(fname), dir, '**', '*.rb'))
+    Dir.glob(search_me).sort.each {|rb| require rb }
+  end
+
+  @@app_file = lambda do
+    ignore = [
+      /lib\/twibot.*\.rb/, # Library
+      /\(.*\)/,            # Generated code
+      /custom_require\.rb/ # RubyGems require
+    ]
+
+    path = caller.map { |line| line.split(/:\d/, 2).first }.find do |file|
+      next if ignore.any? { |pattern| file =~ pattern }
+      file
+    end
+
+    path || $0
+  end.call
+
+  #
+  # File name of the application file. Inspired by Sinatra
+  #
+  def self.app_file
+    @@app_file
+  end
+
+  #
+  # Runs application if application file is the script being executed
+  #
+  def self.run?
+    self.app_file == $0
+  end
+
+end  # module Jabbot
+
+Thread.abort_on_exception = true
+Jabbot.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/jabbot/bot.rb

@@ -0,0 +1,244 @@
+require 'logger'
+require File.join(File.expand_path(File.dirname(__FILE__)), 'macros')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'handlers')
+
+module Jabbot
+  #
+  # Main bot "controller" class
+  #
+  class Bot
+    include Jabbot::Handlers
+    attr_reader :client
+    attr_reader :user
+
+    Message = Struct.new(:user, :text, :time) do
+      def to_s
+        "#{user}: #{text}"
+      end
+    end
+
+    def initialize(options = nil)
+      @conf = nil
+      @config = options || Jabbot::Config.default << Jabbot::FileConfig.new
+      @log = nil
+      @abort = false
+      @user = []
+
+    rescue Exception => krash
+      raise SystemExit.new(krash.message)
+    end
+
+    #
+    # connect to Jabber and join channel
+    #
+    def connect
+      @jid = Jabber::JID.new(login)
+      @mucjid = Jabber::JID.new("#{channel}@#{server}")
+
+      if @jid.node.nil?
+        raise "Your Jabber ID must contain a user name and therefore contain one @ character."
+      elsif @jid.resource
+        raise "If you intend to set a custom resource, put that in the right text field. Remove the slash!"
+      elsif @mucjid.node.nil?
+        raise "Please set a room name, e.g. myroom@conference.jabber.org"
+      elsif @mucjid.resource
+        raise "The MUC room must not contain a resource. Remove the slash!"
+      else
+        @jid.resource = "jabbot1"
+        @mucjid.resource = (config[:nick]||="jabbot")
+        @user << config[:nick]
+      end
+
+      @client = Jabber::Client.new(@jid)
+      @connected = true
+      begin
+        @client.connect
+        @client.auth(password)
+        @muc = Jabber::MUC::SimpleMUCClient.new(@client)
+        muc_handlers.call(@muc)
+        @muc.join(@mucjid)
+       rescue => errmsg
+        STDERR.write "#{errmsg.class}\n#{errmsg}, #{errmsg.backtrace.join("\n")}"
+        exit 1
+      end
+    end
+
+    #
+    # Run application
+    #
+    def run!
+      puts "Jabbot #{Jabbot::VERSION} imposing as #{login} on #{channel}@#{server}"
+
+      trap(:INT) do
+        puts "\nAnd it's a wrap. See ya soon!"
+        exit
+      end
+
+      connect
+      poll
+    end
+
+    #
+    # just a lame infinite loop to keep the bot alive while he is connected
+    # :)
+    #
+    def poll
+      while connected?
+        break unless connected?
+        sleep 1
+      end
+    end
+
+    #
+    # still connected?
+    #
+    def connected?
+      @connected
+    end
+
+    #
+    # close connection
+    #
+    def close
+      if connected?
+        @connected = false
+        client.close
+      end
+    end
+    alias_method :quit, :close
+
+    #
+    # send message
+    # alternative: send query to user
+    #
+    def send_message(msg, to=nil)
+      @muc.say(msg.to_s, to)
+    end
+
+    #
+    # defines what to do on different actions
+    #
+    def muc_handlers
+      Proc.new do |muc|
+        muc.on_message do |time, nick, text|
+          if time.nil?
+            begin
+              dispatch_messages(:message, [Message.new(nick, text, Time.now)]) unless nick == config[:nick]
+            rescue Exception => boom
+              log.fatal boom.inspect
+              log.fatal boom.backtrace[0..5].join("\n")
+            end
+          end
+        end
+
+        muc.on_private_message do |time, nick, text|
+          if time.nil?
+            begin
+              dispatch_messages(:private, [Message.new(nick, text, Time.now)]) unless nick == config[:nick]
+            rescue Exception => boom
+              log.fatal boom.inspect
+              log.fatal boom.backtrace[0..5].join("\n")
+            end
+          end
+        end
+
+        muc.on_join do |time, nick|
+          unless @user.include? nick
+            @user << nick
+          end
+          if time.nil?
+            begin
+              dispatch_messages(:join, [Message.new(nick, "join", Time.now)]) unless nick == config[:nick]
+            rescue Exception => boom
+              log.fatal boom.inspect
+              log.fatal boom.backtrace[0..5].join("\n")
+            end
+          end
+        end
+        
+        muc.on_leave do |time, nick|
+          @user.delete(nick)
+          if time.nil?
+            begin
+              dispatch_messages(:leave, [Message.new(nick, "leave", Time.now)])
+            rescue Exception => boom
+              log.fatal boom.inspect
+              log.fatal boom.backtrace[0..5].join("\n")
+            end
+          end
+        end
+        
+        muc.on_subject do |time, nick, subject|
+          if time.nil?
+            begin
+              dispatch_messages(:subject, [Message.new(nick, subject, Time.now)])
+            rescue Exception => boom
+              log.fatal boom.inspect
+              log.fatal boom.backtrace[0..5].join("\n")
+            end
+          end
+        end
+
+        # not working
+        #muc.on_self_leave  do |*args|
+        #  p args
+        #end
+      end
+    end
+
+    #
+    # Dispatch a collection of messages
+    #
+    def dispatch_messages(type, messages)
+      messages.each { |message| dispatch(type, message) }
+      messages.length
+    end
+
+    #
+    # Return logger instance
+    #
+    def log
+      return @log if @log
+      os = config[:log_file] ? File.open(config[:log_file], "a") : $stdout
+      @log = Logger.new(os)
+      @log.level = Logger.const_get(config[:log_level] ? config[:log_level].upcase : "INFO")
+      @log
+    end
+
+    #
+    # Configure bot
+    #
+    def configure
+      yield @config
+      @conf = nil
+    end
+
+   private
+    #
+    # Map configuration settings
+    #
+    def method_missing(name, *args, &block)
+      return super unless config.key?(name)
+
+      self.class.send(:define_method, name) { config[name] }
+      config[name]
+    end
+
+    #
+    # Return configuration
+    #
+    def config
+      return @conf if @conf
+      @conf = @config.to_hash
+    end
+  end
+end
+
+# Expose DSL
+include Jabbot::Macros
+
+# Run bot if macros has been used
+at_exit do
+  raise $! if $!
+  @@bot.run! if run?
+end

data/lib/jabbot/config.rb

@@ -0,0 +1,102 @@
+require 'optparse'
+
+module Jabbot
+  #
+  # Jabbot configuration. Use either Jabbot::CliConfig.new or
+  # JabbotFileConfig.new setup a new bot from either command line or file
+  # (respectively). Configurations can be chained so they override each other:
+  #
+  #   config = Jabbot::FileConfig.new
+  #   config << Jabbot::CliConfig.new
+  #   config.to_hash
+  #
+  # The preceding example will create a configuration which is based on a
+  # configuration file but have certain values overridden from the command line.
+  # This can be used for instance to store everything but the Twitter account
+  # password in your configuration file. Then you can just provide the password
+  # when running the bot.
+  #
+  class Config
+    attr_reader :settings
+
+    DEFAULT = {
+      :log_level => "info",
+      :log_file => nil,
+      :login => nil,
+      :password => nil,
+      :daemonize => false # not yet used!
+    }
+
+    def initialize(settings = {})
+      @configs = []
+      @settings = settings
+    end
+
+    #
+    # Add a configuration object to override given settings
+    #
+    def add(config)
+      @configs << config
+      self
+    end
+
+    alias_method :<<, :add
+
+    #
+    # Makes it possible to access configuration settings as attributes
+    #
+    def method_missing(name, *args, &block)
+      regex = /=$/
+      attr_name = name.to_s.sub(regex, '').to_sym
+      return super if name == attr_name && !@settings.key?(attr_name)
+
+      if name != attr_name
+        @settings[attr_name] = args.first
+      end
+
+      @settings[attr_name]
+    end
+
+    #
+    # Merges configurations and returns a hash with all options
+    #
+    def to_hash
+      hash = {}.merge(@settings)
+      @configs.each { |conf| hash.merge!(conf.to_hash) }
+      hash
+    end
+
+    def self.default
+      Config.new({}.merge(DEFAULT))
+    end
+  end
+
+  #
+  # Configuration from files
+  #
+  class FileConfig < Config
+
+    #
+    # Accepts a stream or a file to read configuration from
+    # Default is to read configuration from ./config/bot.yml
+    #
+    # If a stream is passed it is not closed from within the method
+    #
+    def initialize(fos = File.expand_path("config/bot.yml"))
+      stream = fos.is_a?(String) ? File.open(fos, "r") : fos
+
+      begin
+        config = YAML.load(stream.read)
+        config.symbolize_keys! if config
+      rescue Exception => err
+        puts err.message
+        puts "Unable to load configuration, aborting"
+        exit
+      ensure
+        stream.close if fos.is_a?(String)
+      end
+
+      super config.is_a?(Hash) ? config : {}
+    end
+  end
+end

data/lib/jabbot/handlers.rb

@@ -0,0 +1,116 @@
+module Jabbot
+  module Handlers
+    #
+    # Add a handler for this bot
+    #
+    def add_handler(type, handler)
+      handlers[type] << handler
+      handler
+    end
+
+    def dispatch(type, message)
+      handlers[type].each { |handler| handler.dispatch(message) }
+    end
+
+    def handlers
+      @handlers ||= {
+        :message => [],
+        :private => [],
+        :join => [],
+        :subject => [],
+        :leave => []
+      }
+    end
+
+    def handlers=(hash)
+      @handlers = hash
+    end
+  end
+
+  #
+  # A Handler object is an object which can handle a direct message, tweet or
+  # at reply.
+  #
+  class Handler
+    def initialize(pattern = nil, options = {}, &blk)
+      if pattern.is_a?(Hash)
+        options = pattern
+        pattern = nil
+      end
+
+      @options = options
+      @options[:from].collect! { |s| s.to_s } if @options[:from] && @options[:from].is_a?(Array)
+      @options[:from] = [@options[:from].to_s] if @options[:from] && [String, Symbol].include?(@options[:from].class)
+      @handler = nil
+      @handler = block_given? ? blk : nil
+      self.pattern = pattern
+    end
+
+    #
+    # Parse pattern string and set options
+    #
+    def pattern=(pattern)
+      return if pattern.nil? || pattern == ""
+
+      if pattern == :all
+        return
+      end
+
+      if pattern.is_a?(Regexp)
+        @options[:pattern] = pattern
+        return
+      end
+
+      words = pattern.split.collect { |s| s.strip }          # Get all words in pattern
+      @options[:tokens] = words.inject([]) do |sum, token|   # Find all tokens, ie :symbol :like :names
+        next sum unless token =~ /^:.*/                      # Don't process regular words
+        sym = token.sub(":", "").to_sym                      # Turn token string into symbol, ie ":token" => :token
+        regex = @options[sym] || '[^\s]+'                    # Fetch regex if configured, else use any character but space matching
+        pattern.sub!(/(^|\s)#{token}(\s|$)/, '\1(' + regex.to_s + ')\2') # Make sure regex captures named switch
+        sum << sym
+      end
+
+      @options[:pattern] = /#{pattern}(\s.+)?/
+    end
+
+    #
+    # Determines if this handler is suited to handle an incoming message
+    #
+    def recognize?(message)
+      return false if @options[:pattern] && message.text !~ @options[:pattern] # Pattern check
+
+      users = @options[:from] ? @options[:from] : nil
+      return false if users && !users.include?(message.user) # Check allowed senders
+      true
+    end
+
+    #
+    # Process message to build params hash and pass message along with params of
+    # to +handle+
+    #
+    def dispatch(message)
+      return unless recognize?(message)
+      @params = {}
+
+      if @options[:pattern] && @options[:tokens]
+        matches = message.text.match(@options[:pattern])
+        @options[:tokens].each_with_index { |token, i| @params[token] = matches[i+1] }
+        @params[:text] = (matches[@options[:tokens].length+1] || "").strip
+      elsif @options[:pattern] && !@options[:tokens]
+        @params = message.text.match(@options[:pattern]).to_a[1..-1] || []
+      else
+        @params[:text] = message.text
+      end
+
+      return handle(message, @params)
+    end
+
+    #
+    # Handle a message. Calls the internal Proc with the message and the params
+    # hash as parameters.
+    #
+    def handle(message, params)
+      @handler.call(message, params) if @handler
+    end
+  end
+end

data/lib/jabbot/macros.rb

@@ -0,0 +1,85 @@
+module Jabbot
+  @@prompt = false
+
+  def self.prompt=(p)
+    @@prompt = f
+  end
+
+  module Macros
+    def self.included(mod)
+      @@bot = nil
+    end
+
+    def configure(&blk)
+      bot.configure(&blk)
+    end
+
+    def message(pattern = nil, options = {}, &blk)
+      add_handler(:message, pattern, options, &blk)
+    end
+
+    def query(pattern = nil, options = {}, &blk)
+      add_handler(:private, pattern, options, &blk)
+    end
+    alias_method :private_message, :query
+
+    def join(options = {}, &blk)
+      add_handler(:join, /\Ajoin\Z/, options, &blk)
+    end
+    
+    def leave(options = {}, &blk)
+      add_handler(:leave, /\Aleave\Z/, options, &blk)
+    end
+
+    def subject(pattern = nil, options = {}, &blk)
+      add_handler(:subject, pattern, options, &blk)
+    end
+    alias_method :topic, :subject
+
+    def client
+      bot.client
+    end
+
+    def close
+      bot.close
+    end
+    alias_method :quit, :close
+
+    def user
+      bot.user
+    end
+
+    def post(msg, to=nil)
+      if msg.is_a?(Hash) && msg.keys.size == 1
+        to = msg.values.first
+        msg = msg.keys.first
+      end
+      bot.send_message(msg, to)
+    end
+
+    def run?
+      !@@bot.nil?
+    end
+
+   private
+    def add_handler(type, pattern, options, &blk)
+      bot.add_handler(type, Jabbot::Handler.new(pattern, options, &blk))
+    end
+
+    def bot
+      return @@bot unless @@bot.nil?
+
+      begin
+        @@bot = Jabbot::Bot.new nil
+      rescue Exception
+        @@bot = Jabbot::Bot.new(Jabbot::Config.default)
+      end
+
+      @@bot
+    end
+
+    def self.bot=(bot)
+      @@bot = bot
+    end
+  end
+end

data/lib/jabbot/message.rb

@@ -0,0 +1,7 @@
+module Jabbot
+  Message = Struct.new(:user, :text, :time) do
+    def to_s
+      "#{user}: #{text}"
+    end
+  end
+end

data/test/test_bot.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Jabbot)
+require 'fileutils'
+
+class TestBot < Test::Unit::TestCase
+  should "not raise errors when initialized" do
+    assert_nothing_raised do
+      Jabbot::Bot.new Jabbot::Config.new
+    end
+  end
+
+  should "raise errors when initialized without config file" do
+    assert_raise SystemExit do
+      Jabbot::Bot.new
+    end
+  end
+
+  should "not raise error on initialize when config file exists" do
+    if File.exists?("config")
+      FileUtils.rm("config/bot.yml")
+    else
+      FileUtils.mkdir("config")
+    end
+
+    File.open("config/bot.yml", "w") { |f| f.puts "" }
+
+    assert_nothing_raised do
+      Jabbot::Bot.new
+    end
+
+    FileUtils.rm_rf("config")
+  end
+
+  should "provide configuration settings as methods" do
+    bot = Jabbot::Bot.new Jabbot::Config.new(:login => "jabbot")
+    assert_equal "jabbot", bot.login
+  end
+
+  should "return logger instance" do
+    bot = Jabbot::Bot.new(Jabbot::Config.default << Jabbot::Config.new)
+    assert bot.log.is_a?(Logger)
+  end
+
+  should "respect configured log level" do
+    bot = Jabbot::Bot.new(Jabbot::Config.new(:log_level => "info"))
+    assert_equal Logger::INFO, bot.log.level
+
+    bot = Jabbot::Bot.new(Jabbot::Config.new(:log_level => "warn"))
+    assert_equal Logger::WARN, bot.log.level
+  end
+end
+
+class TestBotMacros < Test::Unit::TestCase
+  should "provide configure macro" do
+    assert respond_to?(:configure)
+  end
+
+  should "yield configuration" do
+    Jabbot::Macros.bot = Jabbot::Bot.new Jabbot::Config.default
+
+    conf = nil
+    assert_nothing_raised { configure { |c| conf = c } }
+    assert conf.is_a?(Jabbot::Config)
+  end
+
+   should "add handler" do
+     Jabbot::Macros.bot = Jabbot::Bot.new Jabbot::Config.default
+
+     handler = add_handler(:message, ":command", :from => :cjno)
+     assert handler.is_a?(Jabbot::Handler), handler.class
+   end
+
+  should "provide client macro" do
+    assert respond_to?(:client)
+  end
+
+  should "provide user macro" do
+    assert respond_to?(:user)
+  end
+end
+
+class TestBotHandlers < Test::Unit::TestCase
+
+  should "include handlers" do
+    bot = Jabbot::Bot.new(Jabbot::Config.new)
+
+    assert_not_nil bot.handlers
+    assert_not_nil bot.handlers[:message]
+    assert_not_nil bot.handlers[:private]
+    assert_not_nil bot.handlers[:join]
+    assert_not_nil bot.handlers[:leave]
+    assert_not_nil bot.handlers[:subject]
+  end
+
+  should "add handler" do
+    bot = Jabbot::Bot.new(Jabbot::Config.new)
+    bot.add_handler :message, Jabbot::Handler.new
+    assert_equal 1, bot.handlers[:message].length
+
+    bot.add_handler :message, Jabbot::Handler.new
+    assert_equal 2, bot.handlers[:message].length
+
+    bot.add_handler :private, Jabbot::Handler.new
+    assert_equal 1, bot.handlers[:private].length
+
+    bot.add_handler :private, Jabbot::Handler.new
+    assert_equal 2, bot.handlers[:private].length
+
+    bot.add_handler :join, Jabbot::Handler.new
+    assert_equal 1, bot.handlers[:join].length
+
+    bot.add_handler :join, Jabbot::Handler.new
+    assert_equal 2, bot.handlers[:join].length
+
+    bot.add_handler :leave, Jabbot::Handler.new
+    assert_equal 1, bot.handlers[:leave].length
+
+    bot.add_handler :leave, Jabbot::Handler.new
+    assert_equal 2, bot.handlers[:leave].length
+
+    bot.add_handler :subject, Jabbot::Handler.new
+    assert_equal 1, bot.handlers[:subject].length
+
+    bot.add_handler :subject, Jabbot::Handler.new
+    assert_equal 2, bot.handlers[:subject].length
+  end
+end

data/test/test_config.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Jabbot)
+require 'stringio'
+
+class TestConfig < Test::Unit::TestCase
+  should "default configuration be a hash" do
+    assert_not_nil Jabbot::Config::DEFAULT
+    assert Jabbot::Config::DEFAULT.is_a?(Hash)
+  end
+
+  should "initialize with no options" do
+    assert_hashes_equal({}, Jabbot::Config.new.settings)
+  end
+
+  should "return config from add" do
+    config = Jabbot::Config.new
+    assert_equal config, config.add(Jabbot::Config.new)
+  end
+
+  should "alias add to <<" do
+    config = Jabbot::Config.new
+    assert config.respond_to?(:<<)
+    assert config << Jabbot::Config.new
+  end
+
+  should "mirror method_missing as config getters" do
+    config = Jabbot::Config.default << Jabbot::Config.new
+    assert_equal Jabbot::Config::DEFAULT[:password], config.password
+    assert_equal Jabbot::Config::DEFAULT[:login], config.login
+  end
+
+  should "mirror missing methods as config setters" do
+    config = Jabbot::Config.default << Jabbot::Config.new
+    assert_equal Jabbot::Config::DEFAULT[:login], config.login
+
+    val = "jabbot"
+    config.login = val+'!' 
+    assert_not_equal Jabbot::Config::DEFAULT[:login], config.login
+    assert_equal val+'!', config.login
+  end
+
+  should "not override default hash" do
+    config = Jabbot::Config.default
+    hash = Jabbot::Config::DEFAULT
+
+    config.login = "jabbot"
+    config.password = "secret"
+
+    assert_hashes_not_equal Jabbot::Config::DEFAULT, config.to_hash
+    assert_hashes_equal hash, Jabbot::Config::DEFAULT
+  end
+
+  should "return merged configuration from to_hash" do
+    config = Jabbot::Config.new
+    config.login = "jabbot"
+    config.password = "secret"
+
+    config2 = Jabbot::Config.new({})
+    config2.login = "not_jabbot2"
+    config << config2
+    options = config.to_hash
+
+    assert_equal "secret", options[:password]
+    assert_equal "not_jabbot2", options[:login]
+  end
+end
+
+class TestFileConfig < Test::Unit::TestCase
+  should "subclass config for file config" do
+    assert Jabbot::FileConfig.new(StringIO.new).is_a?(Jabbot::Config)
+  end
+
+  should "read settings from stream" do
+    config = Jabbot::FileConfig.new(StringIO.new <<-YAML)
+login: jabbot
+password: secret
+    YAML
+
+    assert_equal "jabbot", config.login
+    assert_equal "secret", config.password
+  end
+end

data/test/test_handler.rb

@@ -0,0 +1,191 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Jabbot)
+
+class TestHandler < Test::Unit::TestCase
+  context "pattern writer" do
+    should "abort on empty values" do
+      handler = Jabbot::Handler.new
+
+      handler.pattern = nil
+      assert_nil handler.instance_eval { @options[:pattern] }
+      assert_nil handler.instance_eval { @options[:tokens] }
+
+      handler.pattern = ""
+      assert_nil handler.instance_eval { @options[:pattern] }
+      assert_nil handler.instance_eval { @options[:tokens] }
+    end
+
+    should "turn regular pattern into regex" do
+      handler = Jabbot::Handler.new
+      handler.pattern = "command"
+
+      assert_equal(/command(\s.+)?/, handler.instance_eval { @options[:pattern] })
+      assert_equal 0, handler.instance_eval { @options[:tokens] }.length
+    end
+
+    should "convert single named switch to regex" do
+      handler = Jabbot::Handler.new
+      handler.pattern = ":command"
+
+      assert_equal(/([^\s]+)(\s.+)?/, handler.instance_eval { @options[:pattern] })
+      assert_equal 1, handler.instance_eval { @options[:tokens] }.length
+      assert_equal :command, handler.instance_eval { @options[:tokens].first }
+    end
+
+    should "convert several named switches to regexen" do
+      handler = Jabbot::Handler.new
+      handler.pattern = ":command fixed_word :subcommand"
+
+      assert_equal(/([^\s]+) fixed_word ([^\s]+)(\s.+)?/, handler.instance_eval { @options[:pattern] })
+      assert_equal 2, handler.instance_eval { @options[:tokens] }.length
+      assert_equal :command, handler.instance_eval { @options[:tokens].first }
+      assert_equal :subcommand, handler.instance_eval { @options[:tokens][1] }
+    end
+
+    should "convert several named switches to regexen specified by options" do
+      handler = Jabbot::Handler.new(":time :hour", :hour => /\d\d/)
+
+      assert_equal(/([^\s]+) ((?-mix:\d\d))(\s.+)?/, handler.instance_eval { @options[:pattern] })
+      assert_equal 2, handler.instance_eval { @options[:tokens] }.length
+      assert_equal :time, handler.instance_eval { @options[:tokens].first }
+      assert_equal :hour, handler.instance_eval { @options[:tokens][1] }
+    end
+  end
+
+  should "recognize empty pattern" do
+    handler = Jabbot::Handler.new
+    message = message "cjno", "A jabber message"
+
+    assert handler.recognize?(message)
+  end
+
+  should "recognize empty pattern and allowed user" do
+    handler = Jabbot::Handler.new "", :from => "cjno"
+    message = message "cjno", "A jabber message"
+    assert handler.recognize?(message)
+
+    handler = Jabbot::Handler.new "", :from => ["cjno", "irbno"]
+    assert handler.recognize?(message)
+  end
+
+  should "not recognize empty pattern and disallowed user" do
+    handler = Jabbot::Handler.new "", :from => "irbno"
+    message = message "cjno", "A jabber message"
+    assert !handler.recognize?(message)
+
+    handler = Jabbot::Handler.new "", :from => ["irbno", "satan"]
+    assert !handler.recognize?(message)
+  end
+
+  should "recognize fixed pattern and no user" do
+    handler = Jabbot::Handler.new "time"
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+  end
+
+  should "recognize dynamic pattern and no user" do
+    handler = Jabbot::Handler.new "time :city :country"
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+  end
+
+  should "not recognize dynamic pattern and no user" do
+    handler = Jabbot::Handler.new "time :city :country"
+    message = message "cjno", "oslo norway what is the time?"
+    assert !handler.recognize?(message)
+  end
+
+  should "recognize fixed pattern and user" do
+    handler = Jabbot::Handler.new "time", :from => ["cjno", "irbno"]
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+  end
+
+  should "recognize dynamic pattern and user" do
+    handler = Jabbot::Handler.new "time :city :country", :from => ["cjno", "irbno"]
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+  end
+
+  should "not recognize dynamic pattern and user" do
+    handler = Jabbot::Handler.new "time :city :country", :from => ["cjno", "irbno"]
+    message = message "dude", "time oslo norway"
+    assert !handler.recognize?(message)
+  end
+
+  should "recognize symbol users" do
+    handler = Jabbot::Handler.new "time :city :country", :from => [:cjno, :irbno]
+    message = message "dude", "time oslo norway"
+    assert !handler.recognize?(message)
+
+    message = message("cjno", "time oslo norway")
+    assert handler.recognize?(message)
+  end
+
+  should "recognize messages from allowed users" do
+    handler = Jabbot::Handler.new :from => [:cjno, :irbno]
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+  end
+  
+  should "not recognize messages from unallowed users with capital screen names" do
+    handler = Jabbot::Handler.new :from => [:cjno, :irbno]
+    message = message "Cjno", "time oslo norway"
+    assert !handler.recognize?(message)
+  end
+
+  should "accept options as only argument" do
+    handler = Jabbot::Handler.new :from => :cjno
+    assert_equal(['cjno'], handler.instance_eval { @options[:from] })
+    assert_nil handler.instance_eval { @options[:pattern] }
+  end
+
+  should "provide parameters in params hash" do
+    handler = Jabbot::Handler.new("time :city :country", :from => ["cjno", "irbno"]) do |message, params|
+      assert_equal "oslo", params[:city]
+      assert_equal "norway", params[:country]
+    end
+
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+    handler.dispatch(message)
+  end
+
+  should "call constructor block from handle" do
+    handler = Jabbot::Handler.new("time :city :country", :from => ["cjno", "irbno"]) do |message, params|
+      raise "Boom!"
+    end
+
+    assert_raise(RuntimeError) do
+      handler.handle(nil, nil)
+    end
+  end
+
+  should "recognize regular expressions" do
+    handler = Jabbot::Handler.new /(?:what|where) is (.*)/i
+    message = message "dude", "Where is this shit?"
+    assert handler.recognize?(message)
+
+    message = message "dude", "How is this shit?"
+    assert !handler.recognize?(message)
+  end
+
+  should "recognize regular expressions from specific users" do
+    handler = Jabbot::Handler.new /(?:what|where) is (.*)/i, :from => "cjno"
+    message = message "dude", "Where is this shit?"
+    assert !handler.recognize?(message)
+
+    message = message "cjno", "Where is this shit?"
+    assert handler.recognize?(message)
+  end
+
+  should "provide parameters as arrays when matching regular expressions" do
+    handler = Jabbot::Handler.new(/time ([^\s]*) ([^\s]*)/) do |message, params|
+      assert_equal "oslo", params[0]
+      assert_equal "norway", params[1]
+    end
+
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+    handler.dispatch(message)
+  end
+end

data/test/test_hash.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Jabbot)
+
+class TestHash < Test::Unit::TestCase
+  should "convert string keys to symbols" do
+    hash = { "one" => 1, "two" => 2 }
+    hash.symbolize_keys!
+
+    assert_equal 1, hash[:one]
+    assert_equal 2, hash[:two]
+    assert_nil hash["one"]
+    assert_nil hash["two"]
+  end
+
+  should "convert string keys and preserve symbol keys" do
+    hash = { "one" => 1, :two => 2 }
+    hash.symbolize_keys!
+
+    assert_equal 1, hash[:one]
+    assert_equal 2, hash[:two]
+    assert_nil hash["one"]
+    assert_nil hash["two"]
+  end
+
+  should "convert hashes recursively" do
+    hash = { "one" => 1, :two => { "three" => 3, "four" => 4 } }
+    hash.symbolize_keys!
+
+    assert_equal 1, hash[:one]
+    assert_equal 3, hash[:two][:three]
+    assert_equal 4, hash[:two][:four]
+    assert_nil hash["one"]
+    assert_nil hash["two"]
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+if RUBY_VERSION =~ /1\.9/
+  Gem.all_load_paths
+  gem "thoughtbot-shoulda"
+  gem "xmpp4r"
+end
+require 'test/unit'
+require 'shoulda'
+require File.join(File.dirname(__FILE__), '../lib/jabbot')
+
+module Test::Unit::Assertions
+  def assert_hashes_equal(expected, actual, message = nil)
+    full_message = build_message(message, <<EOT, expected.inspect, actual.inspect)
+<?> expected but was
+<?>.
+EOT
+    assert_block(full_message) do
+      break false if expected.keys.length != actual.keys.length
+      expected.keys.all? { |k| expected[k] == actual[k] }
+    end
+  end
+
+  def assert_hashes_not_equal(expected, actual, message = nil)
+    full_message = build_message(message, <<EOT, expected.inspect, actual.inspect)
+<?> expected but was
+<?>.
+EOT
+    assert_block(full_message) do
+      break false if expected.keys.length != actual.keys.length
+      expected.keys.any? { |k| expected[k] != actual[k] }
+    end
+  end
+end
+
+Message = Struct.new(:user, :text, :time)
+def message(user, text)
+  Message.new(user, text, Time.now)
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: badboy-jabbot
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- BadBoy_
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-29 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: xmpp4r
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.10.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: technicalpickles-jeweler
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.10.2
+    version: 
+description: 
+email: badboy@archlinux.us
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- VERSION.yml
+- lib/jabbot
+- lib/jabbot/config.rb
+- lib/jabbot/handlers.rb
+- lib/jabbot/message.rb
+- lib/jabbot/macros.rb
+- lib/jabbot/bot.rb
+- lib/jabbot.rb
+- lib/hash.rb
+- test/test_helper.rb
+- test/test_bot.rb
+- test/test_hash.rb
+- test/test_config.rb
+- test/test_handler.rb
+has_rdoc: true
+homepage: http://github.com/badboy/jabbot
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Simple framework for creating Jabber/MUC bots, inspired by Sinatra and Twibot
+test_files: []
+