jabbot 0.3.1 → 0.3.2

data/README.md

@@ -27,7 +27,7 @@ and it works great :)
 
     # Respond to query if they come from the right crowd
     # query "message" => "user" is just some syntax sugar
-    # query "message", "user" will work to
+    # query "message", "user" will work, too
     query :from => [:cjno, :irbno] do |message, params|
       post "#{message.user} I agree" => message.user
     end
@@ -48,6 +48,8 @@ Jabbot uses the [at\_exit hook](http://ruby-doc.org/core/classes/Kernel.html#M00
 
 ### Configuration
 
+_Deprecated: The option to configure by YAML files will be removed in the next stable release._
+
 Jabbot looks for a configuration file in ./config/bot.yml. It should contain
 atleast:
 

data/lib/jabbot.rb

@@ -12,7 +12,7 @@ require 'jabbot/handlers.rb'
 require 'jabbot/macros.rb'
 
 module Jabbot
-  VERSION = '0.3.1'
+  VERSION = '0.3.2'
 
   @@app_file = lambda do
     ignore = [
@@ -29,22 +29,21 @@ module Jabbot
     path || $0
   end.call
 
+  # Public: File name of the application file (inspired by Sinatra).
   #
-  # File name of the application file. Inspired by Sinatra
-  #
+  # Returns the String application filename.
   def self.app_file
     @@app_file
   end
 
+  # Public: Determines if the application should be auto-run.
   #
-  # Runs application if application file is the script being executed
-  #
+  # Returns a Boolean indicatin wether to auto-run the application or not.
   def self.run?
     self.app_file == $0
   end
 
-end  # module Jabbot
+end
 
+# xmpp4r runs in another thread.
 Thread.abort_on_exception = true
-
-# EOF

data/lib/jabbot/bot.rb

@@ -2,22 +2,38 @@ require 'logger'
 require File.join(File.expand_path(File.dirname(__FILE__)), 'macros')
 require File.join(File.expand_path(File.dirname(__FILE__)), 'handlers')
 
+require 'eventmachine'
+
 module Jabbot
+  # The main Bot class.
   #
-  # Main bot "controller" class
-  #
+  # It handles the connection as well as the method dispatching.
   class Bot
     include Jabbot::Handlers
     attr_reader :client
     attr_reader :users
 
-    Message = Struct.new(:user, :text, :time) do
+    Message = Struct.new(:user, :text, :time, :type) do
       def to_s
         "#{user}: #{text}"
       end
+
+      # Encode a message in JSON
+      # A message is just a hash of its values
+      def to_json(*a)
+        {
+          :user => user,
+          :text => text,
+          :time => time,
+          :type => type
+        }.to_json(*a)
+      end
     end
 
-    def initialize(options = nil)
+    # Public: Initialize a Bot instance.
+    #
+    # options - A Jabbot::Config options instance (default: nil).
+    def initialize(options=nil)
       @conf = nil
       @config = options || Jabbot::Config.default << Jabbot::FileConfig.new
       @log = nil
@@ -28,18 +44,25 @@ module Jabbot
       raise SystemExit.new(krash.message)
     end
 
-    # Enable debugging mode.
+    # Internal: Enable debugging mode.
+    #
     # All xmpp4r-internal calls to Jabber::Debuglog are
     # printed to $stderr by default.
     # You may change the logger by using
+    #
     #   Jabber::Logger = Logger.new(…)
+    #
+    # Returns nothing.
     def debug!
       Jabber::debug = true
     end
 
+    # Internal: Connect to Jabber and join channel.
     #
-    # connect to Jabber and join channel
+    # It will exit the process and log any exception
+    # on `$stderr` on failure.
     #
+    # Returns nothing.
     def connect
       @jid = Jabber::JID.new(login)
       @mucjid = Jabber::JID.new("#{channel}@#{server}")
@@ -64,24 +87,30 @@ module Jabbot
         $stderr.puts args.inspect
         $stderr.puts "exiting..."
 
+        EventMachine.stop_event_loop
         exit
       end
-      @connected = true
       begin
         @client.connect
         @client.auth(password)
         @muc = Jabber::MUC::SimpleMUCClient.new(@client)
         muc_handlers.call(@muc)
         @muc.join(@mucjid)
-       rescue => errmsg
+        @connected = true
+      rescue => errmsg
+        @connected = false
         $stderr.write "#{errmsg.class}\n#{errmsg}, #{errmsg.backtrace.join("\n")}"
         exit 1
       end
     end
 
+    # Public: Starts the jabber bot.
     #
-    # Run application
+    # Internally it starts the jabber connection inside of `EventMachine.run`,
+    # so you are free to use all EventMachine tasks out there for asynchronously
+    # working on input data.
     #
+    # Returns nothing.
     def run!
       puts "Jabbot #{Jabbot::VERSION} imposing as #{login} on #{channel}@#{server}"
 
@@ -95,31 +124,29 @@ module Jabbot
       Kernel.trap(:QUIT, onclose_block)
 
       debug! if config[:debug]
-      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
+      # connect the bot and keep it running
+      EventMachine.run do
+        connect
+
+        stop_timer = EventMachine.add_periodic_timer(1) do
+          if !connected?
+            EventMachine.stop_event_loop
+          end
+        end
       end
     end
 
+    # Internal: Get information if the bot is still connected.
     #
-    # still connected?
-    #
+    # Returns the connection state as a Boolean.
     def connected?
       @connected
     end
 
+    # Public: Close the server connection.
     #
-    # close connection
-    #
+    # Returns nothing.
     def close
       if connected?
         @connected = false
@@ -128,23 +155,33 @@ module Jabbot
     end
     alias_method :quit, :close
 
+    # Public: Send a message to a given user or publicly.
     #
-    # send message
-    # alternative: send query to user
+    # msg - A String message.
+    # to  - A String username to send to (default: nil).
     #
+    # Returns nothing.
     def send_message(msg, to=nil)
-      @muc.say(msg.to_s, to)
+      @muc.say(msg.to_s, to) if connected?
     end
 
+    # Internal: Assigns handlers for different xmpp messages.
+    #
+    # The handled messages are:
     #
-    # defines what to do on different actions
+    #   * public messages
+    #   * private messages
+    #   * joins
+    #   * leaves
+    #   * subject changes
     #
+    # Returs nothing.
     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]
+              dispatch_messages(:message, [Message.new(nick, text, Time.now, :public)]) unless nick == config[:nick]
             rescue Exception => boom
               log.fatal boom.inspect
               log.fatal boom.backtrace[0..5].join("\n")
@@ -155,7 +192,7 @@ module Jabbot
         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]
+              dispatch_messages(:private, [Message.new(nick, text, Time.now, :query)]) unless nick == config[:nick]
             rescue Exception => boom
               log.fatal boom.inspect
               log.fatal boom.backtrace[0..5].join("\n")
@@ -169,7 +206,7 @@ module Jabbot
           end
           if time.nil?
             begin
-              dispatch_messages(:join, [Message.new(nick, "join", Time.now)]) unless nick == config[:nick]
+              dispatch_messages(:join, [Message.new(nick, "join", Time.now, :join)]) unless nick == config[:nick]
             rescue Exception => boom
               log.fatal boom.inspect
               log.fatal boom.backtrace[0..5].join("\n")
@@ -181,7 +218,7 @@ module Jabbot
           @users.delete(nick)
           if time.nil?
             begin
-              dispatch_messages(:leave, [Message.new(nick, "leave", Time.now)])
+              dispatch_messages(:leave, [Message.new(nick, "leave", Time.now, :leave)])
             rescue Exception => boom
               log.fatal boom.inspect
               log.fatal boom.backtrace[0..5].join("\n")
@@ -192,32 +229,30 @@ module Jabbot
         muc.on_subject do |time, nick, subject|
           if time.nil?
             begin
-              dispatch_messages(:subject, [Message.new(nick, subject, Time.now)])
+              dispatch_messages(:subject, [Message.new(nick, subject, Time.now, :subject)])
             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.
     #
-    # Dispatch a collection of messages
+    # type     - The Symbol type to be processed.
+    # messages - An Array of String messages to be dispatched.
     #
+    # Returns the Integer count of messages dispatched.
     def dispatch_messages(type, messages)
       messages.each { |message| dispatch(type, message) }
       messages.length
     end
 
+    # Internal: Instanciates a logger.
     #
-    # Return logger instance
-    #
+    # Returns logger instance.
     def log
       return @log if @log
       os = config[:log_file] ? File.open(config[:log_file], "a") : $stdout
@@ -226,17 +261,18 @@ module Jabbot
       @log
     end
 
+    # Public: Set configure options for the bot.
     #
-    # Configure bot
-    #
+    # Returns the configure Hash.
     def configure
       yield @config
-      @conf = nil
+      @conf = @config.to_hash
     end
 
+    # Internal: Maps configuration settings to real methods.
     #
-    # Map configuration settings
-    #
+    # Returns the value of the configuration setting
+    #  or nil if none is found.
     def method_missing(name, *args, &block)
       return super unless config.key?(name)
 
@@ -244,9 +280,9 @@ module Jabbot
       config[name]
     end
 
+    # Public: Get the current configuration settings.
     #
-    # Return configuration
-    #
+    # Returns the configuration Hash.
     def config
       return @conf if @conf
       @conf = @config.to_hash
@@ -257,7 +293,7 @@ end
 # Expose DSL
 include Jabbot::Macros
 
-# Run bot if macros has been used
+# Run bot if macros has been used.
 at_exit do
   raise $! if $!
   @@bot.run! if run?

data/lib/jabbot/config.rb

@@ -1,7 +1,6 @@
 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:
@@ -36,19 +35,23 @@ module Jabbot
       @settings = settings
     end
 
+    # Public: Add a configuration object to override given settings
     #
-    # Add a configuration object to override given settings
+    # config -
     #
+    # Returns the class object.
     def add(config)
       @configs << config
       self
     end
-
     alias_method :<<, :add
 
+    # Internal: Maps calls to non existant functions to
+    #           configuration values, if they exist.
     #
-    # Makes it possible to access configuration settings as attributes
+    # name, *args and &block as described in the core classes.
     #
+    # Returns the configuration value if any.
     def method_missing(name, *args, &block)
       regex = /=$/
       attr_name = name.to_s.sub(regex, '').to_sym
@@ -61,9 +64,9 @@ module Jabbot
       @settings[attr_name]
     end
 
+    # Public: Merges configurations and returns a hash with all options
     #
-    # Merges configurations and returns a hash with all options
-    #
+    # Returns a Hash of the configuration.
     def to_hash
       hash = {}.merge(@settings)
       @configs.each { |conf| hash.merge!(conf.to_hash) }
@@ -75,18 +78,17 @@ module Jabbot
     end
   end
 
-  #
-  # Configuration from files
-  #
+  # Deprecated: Configuration from files
   class FileConfig < Config
-
+    # Public: Initializes a new FileConfig object.
     #
-    # 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
     #
+    # fos - Accepts a Stream or a String filename to read configuration from
+    #       (default: "./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"))
+      warn "Jabbot::FileConfig is deprecated and will be removed in the next version."
+
       stream = fos.is_a?(String) ? File.open(fos, "r") : fos
 
       begin

data/lib/jabbot/handlers.rb

@@ -1,17 +1,30 @@
 module Jabbot
   module Handlers
+    # Public: Add a handler for a given type.
     #
-    # Add a handler for this bot
+    # type    - The Symbol representation of the type to be handled.
+    # handler - The Jabbot::Handler instance to handle a message.
     #
+    # Returns the handler.
     def add_handler(type, handler)
       handlers[type] << handler
       handler
     end
 
+    # Public: Dispatch a message based on is type.
+    #
+    # type    - The Symbol representation of the type to be dispatched.
+    # message - The String message to be handled.
+    #
+    # Returns nothing.
     def dispatch(type, message)
       handlers[type].each {|handler| handler.dispatch(message) }
     end
 
+    # Internal: Setup Arrays of all handler types.
+    #
+    # Returns a Hash containing the possible handler types and
+    #  its associated Arrays of handlers.
     def handlers
       @handlers ||= {
         :message => [],
@@ -22,20 +35,51 @@ module Jabbot
       }
     end
 
+    # Deprecated: Set the handler types and Arrays
+    #
+    # hash - A hash containing the handler types and associated Arrays
+    #        (see `handlers`).
+    #
+    # Returns nothing.
     def handlers=(hash)
       @handlers = hash
     end
   end
 
-  #
-  # A Handler object is an object which can handle a direct message, tweet or
-  # at reply.
+  # A Handler consists of a pattern to match a given message,
+  # some options and a handler block to be called on dispatch.
   #
   class Handler
+    # Public: Initialize a new handler instance.
+    #
+    # pattern - The String, Symbol or Regexp pattern to match the messages
+    #           against or a Hash (default: nil).
+    #           If pattern is a Hash containing just one key :exact,
+    #           its value is used as the pattern and should therefore be
+    #           a String or Regexp.
+    #           If the pattern is a Hash, but not containing
+    #           the key :exact, the pattern is set to nil
+    #           and the passed value is re-used as `options`.
+    #           A pattern of nil will match every message.
+    # options - The Hash options to refine the handler (default: {})
+    #           :from - A String, Symbol or Array of usernames to
+    #                   accept messages from
+    #           *     - Any String here is later used in the pattern
+    #                   parsing and its value is used as a replacement
+    #                   of the pattern parameter and should be a
+    #                   valid String to be used in a Regexp,
+    #                   containing just one match group.
+    # blk     - The block to handle a pattern-matched message
+    #           and respond to it.
+    #           It will be passed to arguments:
+    #             message - The actual Message struct.
+    #             params  - An Array of matched params if any.
     def initialize(pattern = nil, options = {}, &blk)
+      @exact_match = false
       if pattern.is_a?(Hash)
         if pattern.keys.first == :exact
-          pattern = /\A#{pattern[:exact]}\Z/
+          @exact_match = true
+          pattern = pattern[:exact]
         else
           options = pattern
           pattern = nil
@@ -43,72 +87,129 @@ module Jabbot
       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
+      if from = @options[:from]
+        if from.respond_to?(:collect)
+          @options[:from] = from.collect {|s| s.to_s }
+        elsif from.respond_to?(:to_s)
+          @options[:from] = [@options[:from].to_s]
+        else
+          @options[:from] = nil
+        end
+      end
+
       @handler = block_given? ? blk : nil
-      self.pattern = pattern
+
+      # Set pattern (parse it if needed)
+      self.pattern = pattern ? pattern.dup : pattern
     end
 
+    # Internal: Parse pattern string and set parameter options.
+    #
+    # There are a few special cases:
+    #
+    # If the pattern is nil, empty or the Symbol :all, the handler is
+    # dispatched on all incoming messages for the given type.
     #
-    # Parse pattern string and set options
+    # If the pattern is a Regexp it is used as-is.
     #
+    # If the pattern is a String or any other Symbol (coerced to a String)
+    # it is parsed.
+    #
+    # Parsing:
+    #
+    # Every word in the pattern starting with a colon (:) and followed by
+    # any non-whitespace characters is used as a parameter match name.
+    #
+    # Matched pattern names are then replaced to match any
+    # non-whitespace character by default.
+    # Otherwise defined patterns may be used instead.
+    #
+    # If @exact_match is set, the resulting pattern is nested
+    # between \A and \Z to match a whole string without
+    # leading or trailing characters.
+    #
+    # Example:
+    #
+    #     handler.pattern = "Welcome :me"
+    #     # => /Welcome ([^\s]+)/
+    #
+    #     handler.pattern = "Welcome :me" # with @exact_match = true
+    #     # => /\AWelcome ([^\s]+)\Z/
+    #
+    #     options = { "me" => "([aeiou]+)" }
+    #     handler.pattern = "Welcome :me"
+    #     # => /Welcome ([aeiou]+)/
+    #
+    # Returns nothing.
     def pattern=(pattern)
+      @pattern = nil
       return if pattern.nil? || pattern == '' || pattern == :all
 
       if pattern.is_a?(Regexp)
         @options[:pattern] = pattern
+        @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
+      words = pattern.split.collect {|s| s.strip }   # Get all words in pattern
+      @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.+)?/
+      if @exact_match
+        @pattern = /\A#{pattern}\Z/
+      else
+        @pattern = /#{pattern}/
+      end
     end
 
+    # Public: Get the pattern RegExp.
+    attr_reader :pattern
+
+    # Internal: Determines if this handler is suited to handle
+    #           an incoming message.
     #
-    # Determines if this handler is suited to handle an incoming message
-    #
+    # Returns a Boolean if it recognized the given message.
     def recognize?(message)
-      return false if @options[:pattern] && message.text !~ @options[:pattern] # Pattern check
+      return false if @pattern && message.text !~ @pattern
 
       users = @options[:from] ? @options[:from] : nil
       return false if users && !users.include?(message.user) # Check allowed senders
       true
     end
 
+    # Public: Process a message to build params hash and handle it.
     #
-    # Process message to build params hash and pass message along with params of
-    # to +handle+
+    # message - The incoming String message.
     #
+    # Returns the response from `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] || []
+      params = {}
+
+      if @pattern && @tokens
+        matches = message.text.match(@pattern)
+        @tokens.each_with_index {|token, i| params[token] = matches[i+1] }
+        params[:text] = (matches[@tokens.length+1] || '').strip
+      elsif @pattern && !@tokens
+        params = message.text.match(@pattern).to_a[1..-1] || []
       else
-        @params[:text] = message.text
+        params[:text] = message.text
       end
 
-      return handle(message, @params)
+      handle(message, params)
     end
 
+    # Internal: Call the assigned message handler if any.
     #
-    # Handle a message. Calls the internal Proc with the message and the params
-    # hash as parameters.
+    # message - The incoming String message.
+    # params  - The hash containing matched tokens.
     #
+    # Returns the return from the handler block.
     def handle(message, params)
       @handler.call(message, params) if @handler
     end

data/lib/jabbot/macros.rb

@@ -25,6 +25,9 @@ module Jabbot
     # blk     - The block to execute on successfull match
     def message(pattern = nil, options = {}, &blk)
       add_handler(:message, pattern, options, &blk)
+
+      # if :query => true, add this block for queries, too
+      add_handler(:private, pattern, options, &blk) if options && options[:query]
     end
 
     # Add query handler
@@ -104,6 +107,12 @@ module Jabbot
       if msg.is_a?(Hash) && msg.keys.size == 1
         to = msg.values.first
         msg = msg.keys.first
+      elsif to.kind_of?(Struct)
+        if to.type == :query
+          to = to.user
+        else
+          to = nil
+        end
       end
       bot.send_message(msg, to)
     end

data/test/test_handler.rb

@@ -5,48 +5,48 @@ context "Handler" do
     handler = Jabbot::Handler.new
 
     handler.pattern = nil
-    assert_nil handler.instance_eval { @options[:pattern] }
-    assert_nil handler.instance_eval { @options[:tokens] }
+    assert_nil handler.pattern
+    assert_nil handler.instance_eval { @tokens }
 
     handler.pattern = ""
-    assert_nil handler.instance_eval { @options[:pattern] }
-    assert_nil handler.instance_eval { @options[:tokens] }
+    assert_nil handler.pattern
+    assert_nil handler.instance_eval { @tokens }
   end
 
   test "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
+    assert_equal(/command/, handler.pattern)
+    assert_equal 0, handler.instance_eval{ @tokens }.length
   end
 
   test "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 }
+    assert_equal(/([^\s]+)/, handler.pattern)
+    assert_equal 1, handler.instance_eval { @tokens }.length
+    assert_equal :command, handler.instance_eval { @tokens.first }
   end
 
   test "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] }
+    assert_equal(/([^\s]+) fixed_word ([^\s]+)/, handler.pattern)
+    assert_equal 2, handler.instance_eval { @tokens }.length
+    assert_equal :command, handler.instance_eval { @tokens.first }
+    assert_equal :subcommand, handler.instance_eval { @tokens[1] }
   end
 
   test "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] }
+    assert_equal(/([^\s]+) ((?-mix:\d\d))/, handler.pattern)
+    assert_equal 2, handler.instance_eval { @tokens }.length
+    assert_equal :time, handler.instance_eval { @tokens.first }
+    assert_equal :hour, handler.instance_eval { @tokens[1] }
   end
 
   test "recognize empty pattern" do

metadata

@@ -2,7 +2,7 @@
 name: jabbot
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
 - badboy
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-12 00:00:00 +02:00
+date: 2011-06-25 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -19,23 +19,34 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         version: "0.4"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: shoulda
+  name: eventmachine
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.12"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         version: 2.10.1
   type: :development
-  version_requirements: *id002
-description: "  Jabbot is a Ruby micro-framework for creating Jabber/MUC bots,\n  heavily inspired by Sinatra and Twibot.\n\n  I modified the code of Twibot to fit my needs.\n  The original Twibot code is located at:\n  http://github.com/cjohansen/twibot/tree/master\n\n  A big thank you to Christian Johansen, who wrote the code for Twibot.\n  Jabbot is heavily based on his code.\n\n  It's as easy as definig a small message handler:\n    message do |message, params|\n      post message.text\n    end\n"
+  version_requirements: *id003
+description: "  Jabbot is a Ruby micro-framework for creating Jabber/MUC bots,\n  heavily inspired by Sinatra and Twibot.\n\n  I modified the code of Twibot to fit my needs.\n  The original Twibot code by Christian Johansen is located at:\n  http://github.com/cjohansen/twibot\n\n  It's as easy as definig a small message handler:\n    message {|message, params|\n      post message.text\n    }\n"
 email: badboy@archlinux.us
 executables: []