Sutto-marvin 0.1.0.20081016 → 0.1.20081115

data/README.textile

@@ -0,0 +1,155 @@
+h1. Marvin
+
+Marvin is a simple IRC Framework for Rails suitable for building things
+such as simple IRC bots. Extracted from real use - we'd originally used
+a heavily modified version of MatzBot - it's been built to service a
+particular need.
+
+h2. Background
+
+Marvin is an event driven framework in two ways - for one, it uses
+EventMachine for all networking purposes - as a result, it's both
+relatively stable / reliable and also powerful.
+
+Following on from this, the irc library is event driven. At the base
+level, you choose a client (By Default, Marvin::IRC::Client.) and then you register
+any number of handlers. Whenever an event happens e.g. an incoming message,
+a connection unbinding or event just post_init, each handler is notified
+and given a small set of details about the event.
+
+Handlers are very simple - in fact, you could get away with registering
+Object.new as a handler.
+
+To function, handlers only require one method: handle - which takes
+two options. an event name (e.g. :incoming_message) and a hash
+of the aforementioned attributes / details. This data can then be processed.
+Alternatively, if a handler has a "handle_[event_name]" method (e.g.
+handle_incoming_message), it will instead be called. Also, if client=
+is implemented this will be called when the client is setup containing
+a reference to said client. This is used to that the handler can
+respond to actions.
+
+Like Rack for HTTP, Marvin provides a fair amount of example
+handlers for simple stuff inside IRC.
+
+h2. Getting Started
+
+The easiest way to get started with Marvin is by installing the Marvin gem. To
+do this, make sure Github is added to your gem sources (and you are using
+rubygems >= 1.2.0):
+
+  $ gem sources -a http://gems.github.com 
+  $ sudo gem install username-marvin
+
+Once you have installed the gem, you should have access to the "marvin" command:
+
+  $ marvin --help
+  
+You can create a new marvin folder:
+
+  $ marvin create my_marvin_project
+  
+Then simply edit your settings in the +config/settings.yml+
+
+  default:
+    name: "My Marvin Bot"
+    server: irc.freenode.net
+    port: 6667
+    channel: "#marvin-testing"
+    use_logging: false
+    datastore_location: tmp/datastore.json
+  development:
+    user: MarvinBot
+    name: MarvinBot
+    nick:  MarvinBot3000
+  production:
+    deployed: false
+
+You can use the defaults or configure it. By default your marvin bot will not 
+do any logging. You will need to set that up. From this point you can begin
+running the bot as a daemon or as a console application:
+
+  $ ./script/run
+
+The bot should join the specified channel and will resond to some simple
+commands by default:
+
+  |<YourName> MarvinBot3000: hello
+  |<MarvinBot3000> YourName: Hola!
+
+h2. Marvin::Base - A handler starting point
+
+The first, Marvin::Base provides a base set of methods (e.g. say,
+reply etc etc.) which make writing a client easier. You can simply
+inherit from Marvin::Base, write some logic and then use the class
+method on_event to define responses to events. The passed in meta
+data for each event is then usable via options.attribute_name - an
+openstruct version of the details. e.g.
+
+  class NinjaStuff < Marvin::Base
+    on_event :incoming_message do
+      do_something
+    end
+    def do_something
+      reply options.message # Will echo back the message
+    end
+  end
+    
+Or the like. Also, the halt! method can be called in any subclass to
+halt the handler callback chain.
+
+h2. Marvin::CommandHandler - Ridiculously easy Bots
+
+With Marvin::CommandHandler, you get to define seriously
+simple classes which can act as a simple bot. It takes
+great inspiration from "MatzBot":http://github.com/defunkt/matzbot/tree/master
+which was actually one of the main inspirations for
+creating marvin.
+
+To write a CommandHandler, you simply create a subclass
+(ala ActiveRecord::Base), define a few methods and then
+just use the "exposes" class method. e.g.
+
+  class MySecondExample < Marvin::CommandHandler
+    exposes :hello
+    def hello(data)
+      reply "Hello!"
+    end
+  end
+    
+Where data is an array of parameters. exposed methods will be called
+when they match the following pattern:
+
+  Botname: <exposed-method> <space-seperated-list-meaning-data>
+
+h2. Marvin::MiddleMan - Introducing middleware
+
+Marvin::MiddleMan lets you insert middleware between handlers
+and you're client - letting you do things such as translating
+all messages on the fly. It's build to be extensible and is
+relatively simple to use. On any Marvin::Base subclass (baring
+the MiddleMan itself), you can simple use the normal methods
+of registering a handler with one exception - you now pass
+one argument, the class reference to your middleman class.
+
+h2. Marvin::DataStore - A dead simple persistent hash store
+
+Want to save data between when you stop and start your IRC
+Client? With Marvin, it's really, really simple - Marvin::DataStore
+offers a simple syntax for persistent data stores.
+
+New datastores can be created with Marvin::DataStore.new("global-store-key").
+From there, you have a hash to do whatever the hell you want. Just
+make sure the data you store is JSON-serializable.
+
+When you start - stop a server (via Marvin::Loader.run! and Marvin::Loader.stop!)
+you're data will be loaded from and written to disk accordingly.
+
+If you're inside a Marvin::Base subclass it's even easier. You can get a cattr_access
+style accessor for free - just use the "uses_datastore" method. e.g:
+
+  class X < Marvin::Base
+    uses_datastore "datastore-global-key", :cattr_name
+  end
+  
+Then, self.cattr_name will point to the data store instance.

data/VERSION.yml

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

data/handlers/hello_world.rb

@@ -2,13 +2,8 @@ class HelloWorld < Marvin::CommandHandler
   
   exposes :hello
   
-  uses_datastore "hello-count", :counts
-  
   def hello(data)
-    self.counts ||= {}
-    self.counts[options.nick] ||= 0
-    self.counts[options.nick] += 1
-    reply "Oh hai there - This is hello ##{self.counts[options.nick]} from you!"
+    reply "Hola!" unless target == "#all"
   end
   
 end

data/handlers/tweet_tweet.rb

@@ -16,4 +16,6 @@ class TweetTweet < Marvin::Base
   def show_tweet(tweet)
   end
   
+  
+  
 end

data/lib/marvin/abstract_client.rb

@@ -5,11 +5,12 @@ require "marvin/irc/event"
 module Marvin
   class AbstractClient
     
-    cattr_accessor :events, :handlers, :configuration, :logger, :is_setup, :connections
+    include Marvin::Dispatchable
+    
+    cattr_accessor :events, :configuration, :logger, :is_setup, :connections
     attr_accessor  :channels, :nickname
     
     # Set the default values for the variables
-    self.handlers               = []
     self.events                 = []
     self.configuration          = OpenStruct.new
     self.configuration.channels = []
@@ -27,12 +28,13 @@ module Marvin
       logger.debug "Setting the client for each handler"
       self.handlers.each { |h| h.client = self if h.respond_to?(:client=) }
       logger.debug "Dispatching the default :client_connected event"
-      dispatch_event :client_connected
+      dispatch :client_connected
     end
     
     def process_disconnect
       self.connections.delete(self) if self.connections.include?(self)
-      dispatch_event :client_disconnected
+      dispatch :client_disconnected
+      Marvin::Loader.stop! if self.connections.blank?
     end
     
     # Sets the current class-wide settings of this IRC Client
@@ -64,53 +66,10 @@ module Marvin
     
     ## Handling all of the the actual client stuff.
     
-    # Appends a handler to the end of the handler callback
-    # chain. Note that they will be called in the order they
-    # are appended.
-    def self.register_handler(handler)
-      return if handler.blank?
-      self.handlers << handler
-    end
-    
     def receive_line(line)
-      dispatch_event :incoming_line, :line => line
+      dispatch :incoming_line, :line => line
       event = Marvin::Settings.default_parser.parse(line)
-      dispatch_event(event.to_incoming_event_name, event.to_hash) unless event.nil?
-    end
-    
-    # Handles the dispatch of an event and it's associated options
-    # / properties (defaulting to an empty hash) to both the client
-    # (used for things such as responding to PING) and each of the
-    # registered handlers.
-    def dispatch_event(name, opts = {})
-      # The full handler name is simply what is used to handle
-      # a single event (e.g. handle_incoming_message)
-      full_handler_name = "handle_#{name}"
-      
-      # If the current handle_name method is defined on this
-      # class, we dispatch to that first. We use this to provide
-      # functionality such as responding to PING's and handling
-      # required stuff on connections.
-      self.send(full_handler_name, opts) if respond_to?(full_handler_name)
-      
-      begin
-        # For each of the handlers, check first if they respond to
-        # the full handler name (e.g. handle_incoming_message) - calling
-        # that if it exists - otherwise falling back to the handle method.
-        # if that doesn't exist, nothing is done.
-        self.handlers.each do |handler|
-          if handler.respond_to?(full_handler_name)
-            handler.send(full_handler_name, opts)
-          elsif handler.respond_to?(:handle)
-            handler.handle name, opts
-          end
-        end
-      # Raise an exception in order to stop the flow
-      # of the control. Ths enables handlers to prevent
-      # responses from happening multiple times.
-      rescue HaltHandlerProcessing
-        logger.debug "Handler Progress halted; Continuing on."
-      end
+      dispatch(event.to_incoming_event_name, event.to_hash) unless event.nil?
     end
     
     # Default handlers
@@ -123,16 +82,18 @@ module Marvin
     def handle_client_connected(opts = {})
       logger.debug "About to handle post init"
       # IRC Connection is establish so we send all the required commands to the server.
-      logger.debug "sending user command"
-      command :user, self.configuration.user, "0", "*", Marvin::Util.last_param(self.configuration.name)
-      default_nickname = self.configuration.nick || self.configuration.nicknames.shift
       logger.debug "Setting default nickname"
+      default_nickname = self.configuration.nick || self.configuration.nicknames.shift
       nick default_nickname
+      logger.debug "sending user command"
+      command :user, self.configuration.user, "0", "*", Marvin::Util.last_param(self.configuration.name)
       # If a password is specified, we will attempt to message
       # NickServ to identify ourselves.
       say ":IDENTIFY #{self.configuration.password}", "NickServ" unless self.configuration.password.blank?
       # Join the default channels
       self.configuration.channels.each { |c| self.join c }
+    rescue Exception => e
+      Marvin::ExceptionTracker.log(e)
     end
    
     # The default handler for when a users nickname is taken on
@@ -167,7 +128,7 @@ module Marvin
     def handle_incoming_numeric(opts = {})
       code = opts[:code].to_i
       args = Marvin::Util.arguments(opts[:data])
-      dispatch_event :incoming_numeric_processed, {:code => code, :data => args}
+      dispatch :incoming_numeric_processed, {:code => code, :data => args}
     end
     
     ## General IRC Functions
@@ -190,14 +151,14 @@ module Marvin
       self.channels << channel
       command :JOIN, channel
       logger.info "Joined channel #{channel}"
-      dispatch_event :outgoing_join, :target => channel
+      dispatch :outgoing_join, :target => channel
     end
     
     def part(channel, reason = nil)
       channel = Marvin::Util.channel_name(channel)
       if self.channels.include?(channel)
         command :part, channel, Marvin::Util.last_param(reason)
-        dispatch_event :outgoing_part, :target => channel, :reason => reason
+        dispatch :outgoing_part, :target => channel, :reason => reason
         logger.info "Parted from room #{channel}#{reason ? " - #{reason}" : ""}"
       else
         logger.warn "Tried to disconnect from #{channel} - which you aren't a part of"
@@ -212,7 +173,7 @@ module Marvin
       end
       logger.debug "Parted from all channels, quitting"
       command :quit
-      dispatch_event :quit
+      dispatch :quit
       # Remove the connections from the pool
       self.connections.delete(self)
       logger.info  "Quit from server"
@@ -221,19 +182,19 @@ module Marvin
     def msg(target, message)
       command :privmsg, target, Marvin::Util.last_param(message)
       logger.info "Message sent to #{target} - #{message}"
-      dispatch_event :outgoing_message, :target => target, :message => message
+      dispatch :outgoing_message, :target => target, :message => message
     end
     
     def action(target, message)
       action_text = Marvin::Util.last_param "\01ACTION #{message.strip}\01"
       command :privmsg, target, action_text
-      dispatch_event :outgoing_action, :target => target, :message => message
+      dispatch :outgoing_action, :target => target, :message => message
       logger.info "Action sent to #{target} - #{message}"
     end
     
     def pong(data)
       command :pong, data
-      dispatch_event :outgoing_pong
+      dispatch :outgoing_pong
       logger.info "PONG sent to #{data}"
     end
     
@@ -241,7 +202,7 @@ module Marvin
       logger.info "Changing nickname to #{new_nick}"
       command :nick, new_nick
       self.nickname = new_nick
-      dispatch_event :outgoing_nick, :new_nick => new_nick
+      dispatch :outgoing_nick, :new_nick => new_nick
       logger.info "Nickname changed to #{new_nick}"
     end
     

data/lib/marvin/base.rb

@@ -97,11 +97,11 @@ module Marvin
     
     # Determines whether the previous message was inside a channel.
     def from_channel?
-      self.target && self.target[0..0] == "#"
+      self.target && self.target[0] == ?#
     end
     
     def addressed?
-      self.from_user? || options.message.split(" ").first == "#{self.client.nickname}:"
+      self.from_user? || options.message.split(" ").first.downcase == "#{self.client.nickname.downcase}:"
     end
     
     def setup_defaults(options)

data/lib/marvin/core_ext.rb

@@ -2,4 +2,10 @@ class File
   def self.present_dir
     File.dirname(__FILE__)
   end
+end
+
+class String
+  def /(*args)
+    File.join(self, *args)
+  end
 end

data/lib/marvin/dispatchable.rb

@@ -0,0 +1,94 @@
+module Marvin
+  # = Marvin::Dispatchable
+  # A Generic mixin which lets you define an object
+  # Which accepts handlers which can have arbitrary
+  # events dispatched.
+  # == Usage
+  #
+  #   class X
+  #     include Marvin::Dispatchable
+  #     self.handlers << SomeHandler.new
+  #   end
+  #   X.new.dispatch(:name, {:args => "Values"})
+  #
+  # Will first check if SomeHandler#handle_name exists,
+  # calling handle_name({:args => "Values"}) if it does,
+  # otherwise calling SomeHandler#handle(:name, {:args => "Values"})
+  module Dispatchable
+    
+    def self.included(parent)
+      parent.class_eval do
+        include InstanceMethods
+        extend  ClassMethods
+      end
+    end
+    
+    module InstanceMethods
+      
+      # Returns the handlers registered on this class,
+      # used inside +dispatch+.
+      def handlers
+        self.class.handlers
+      end
+      
+      # Dispatch an 'event' with a given name to the handlers
+      # registered on the current class. Used as a nicer way of defining
+      # behaviours that should occur under a given set of circumstances.
+      # == Params
+      # +name+: The name of the current event
+      # +opts+: an optional hash of options to pass
+      def dispatch(name, opts = {})
+        # The full handler name is the method we call given it exists.
+        full_handler_name = :"handle_#{name.to_s.underscore}"
+        # First, dispatch locally if the method is defined.
+        if self.respond_to?(full_handler_name)
+          self.send(full_handler_name, opts)
+        end
+        # Iterate through all of the registered handlers,
+        # If there is a method named handle_<event_name>
+        # defined we sent that otherwise we call the handle
+        # method on the handler. Note that the handle method
+        # is the only required aspect of a handler. An improved
+        # version of this would likely cache the respond_to?
+        # call.
+        self.handlers.each do |handler|
+          if handler.respond_to?(full_handler_name)
+            handler.sent(full_handler_name, opts)
+          else
+            handler.handle name, opts
+          end
+        end
+      # If we get the HaltHandlerProcessing exception, we
+      # catch it and continue on our way. In essence, we
+      # stop the dispatch of events to the next set of the
+      # handlers.
+      rescue HaltHandlerProcessing
+      end
+      
+    end
+    
+    module ClassMethods
+      
+      # Return an array of all registered handlers, stored in the
+      # class variable @@handlers. Used inside the #handlers instance
+      # method as well as inside things such as register_handler.
+      def handlers
+        @@handlers ||= []
+      end
+      
+      # Assigns a new array of handlers and assigns each.
+      def handlers=(new_value)
+        @@handlers = []
+        new_value.to_a.each { |h| register_handler h }
+      end
+      
+      # Appends a handler to the list of handlers for this object.
+      # Handlers are called in the order they are registered.
+      def register_handler(handler)
+        self.handlers << handler unless handler.nil? || !handler.respond_to?(:handle)
+      end
+      
+    end
+    
+  end
+end

data/lib/marvin/handler.rb

@@ -0,0 +1,12 @@
+module Marvin
+  module Handler
+    
+    # Received a given +message+ with a set of default
+    # +opts+ (defaulting back to an empty hash), which
+    # will be used to perform some sort of action.
+    def handle(message, opts = {})
+      Marvin::Logger.debug "NOP handle - got message #{message.inspect}"
+    end
+    
+  end
+end

data/lib/marvin/irc/base_server.rb

@@ -0,0 +1,11 @@
+require 'webrick'
+
+module Marvin::IRC
+  class BaseServer < WEBrick::GenericServer
+    
+    def run(sock)
+      File.open("x", "w+") { |f| f.puts sock.inspect }
+    end
+    
+  end
+end

data/lib/marvin/irc/client.rb

@@ -57,12 +57,10 @@ module Marvin::IRC
       end
       
       def post_init
-        super
         client.process_connect
       end
 
       def unbind
-        super
         client.process_disconnect
       end
       
@@ -98,7 +96,7 @@ module Marvin::IRC
     
     # Registers a callback handle that will be periodically run.
     def periodically(timing, event_callback)
-      callback = proc { self.dispatch_event event_callback.to_sym }
+      callback = proc { self.dispatch event_callback.to_sym }
       EventMachine::add_periodic_timer(timing, &callback)
     end
     

data/lib/marvin/irc/socket_client.rb

@@ -56,7 +56,13 @@ module Marvin::IRC
     
     # Registers a callback handle that will be periodically run.
     def periodically(timing, event_callback)
-      callback = proc { self.dispatch_event event_callback.to_sym }
+      callback = proc { self.dispatch event_callback.to_sym }
+      Thread.new do
+        while true
+          callback.call
+          sleep timing
+        end
+      end
     end
     
   end

data/lib/marvin/irc.rb

@@ -1,8 +1,9 @@
 module Marvin
   module IRC
-    autoload :Client,       'marvin/irc/client'
-    autoload :Event,        'marvin/irc/event'
-    autoload :SocketClient, 'marvin/irc/socket_client'
+    autoload :Client,         'marvin/irc/client'
+    autoload :Event,          'marvin/irc/event'
+    autoload :SocketClient,   'marvin/irc/socket_client'
     autoload :AbstractServer, 'marvin/irc/abstract_server'
+    autoload :BaseServer,     'marvin/irc/base_server'
   end
 end

data/lib/marvin/middle_man.rb

@@ -85,9 +85,7 @@ module Marvin
     private
     
     def setup_subhandler_clients
-      self.subhandlers.each do |sh|
-        sh.client = self.client if sh.respond_to?(:client=)
-      end
+      self.subhandlers.each { |sh| sh.client = self.client if sh.respond_to?(:client=) }
     end
     
     # This should probably be extracted into some sort of Util's library as

data/lib/marvin/parsers/regexp_parser.rb

@@ -86,6 +86,8 @@ module Marvin
                    
       register_event :ping,   /^\:(.+)\!\~?(.+)\@(.+) PING (.*)$/,
                      :nick, :ident, :host, :data
+                     
+      register_event :ping,  /PING (.*)$/, :data
 
       register_event :numeric, /^\:(\S+) ([0-9]+) (.*)$/,
                      :server, :code, :data

data/lib/marvin/test_client.rb

@@ -39,9 +39,9 @@ module Marvin
       self.receive_line irc_command
     end
     
-    def dispatch_event(name, opts = {})
+    def dispatch(name, opts = {})
       self.dispatched_events << [name, opts]
-      super(name, opts = {})
+      super(name, opts)
     end
     
     def self.run

data/lib/marvin/util.rb

@@ -1,6 +1,5 @@
 module Marvin
-  class Util
-    class << self
+  module Util
       
       # Return the channel-name version of a string by
       # appending "#" to the front if it doesn't already
@@ -25,6 +24,7 @@ module Marvin
       end
       alias lp last_param
      
-    end
+      extend self
+     
   end
 end

data/lib/marvin.rb

@@ -1,7 +1,7 @@
 $:.unshift File.dirname(__FILE__) # Append the current working dir to the front of the line.
 
 require 'rubygems'
-require 'extlib'
+require 'active_support'
 require 'marvin/core_ext'
 
 # Make all exceptions available
@@ -9,6 +9,7 @@ require 'marvin/exceptions'
 
 module Marvin
   autoload :Util,             'marvin/util'
+  autoload :Dispatchable,     'marvin/dispatchable'
   autoload :AbstractClient,   'marvin/abstract_client'
   autoload :Base,             'marvin/base'
   autoload :ClientMixin,      'marvin/client_mixin'

data/script/run

@@ -11,9 +11,15 @@ IS_DAEMON = ARGV.include?("--is-daemon")
 # And Require Marvin.
 require 'marvin'
 
-trap "SIGINT" do
-  Marvin::Loader.stop!
-  exit
+["INT", "TERM"].each do |sig|
+  
+  # Trap a given signal and run all
+  # of our callbacks etc,
+  trap sig do
+    Marvin::Loader.stop!
+    exit
+  end
+  
 end
 
 Marvin::Loader.run!

data/spec/marvin/abstract_client_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+# Tests the behaviour of the AbstractClient functionality
+# via a thin wrapper of the class via Marvin::TestClient.
+
+describe "the base Marvin::TestClient functionality" do
+  
+  it "should dispatch :client_connected as the first event on process_connect" do
+    client(true).dispatched_events.should == []
+    client.process_connect
+    client.dispatched_events.first.should == [:client_connected, {}]
+  end
+  
+  it "should dispatch :client_connected as the first event on process_connect" do
+    client(true).dispatched_events.should == []
+    client.process_connect
+    Marvin::Logger.info client.outgoing_commands.inspect
+    client.dispatched_events[-2].first.should == :outgoing_nick
+    client.dispatched_events[-1].first.should == :outgoing_join
+    client.outgoing_commands.length.should == 3
+    client.outgoing_commands[0].should =~ /^USER \w+ 0 \* :\w+ \r\n$/
+    client.outgoing_commands[1].should =~ /^NICK \w+ \r\n$/
+    client.outgoing_commands[2].should =~ /^JOIN \#[A-Za-z0-9\-\_]+ \r\n$/
+  end
+  
+  it "should dispatch :client_disconnect on process_disconnect" do
+    client(true).dispatched_events.should == []
+    client.process_disconnect
+    client.dispatched_events.last.should == [:client_disconnected, {}]
+  end
+  
+  it "should add an :incoming_line event for each incoming line" do
+    client(true).dispatched_events.should == []
+    client.receive_line "SOME RANDOM LINE THAT HAS ZERO ACTUAL USE"
+    client.dispatched_events.first.should == [:incoming_line, {:line => "SOME RANDOM LINE THAT HAS ZERO ACTUAL USE"}]
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require "rubygems"
+require "bacon"
+
+require File.dirname(__FILE__) + "/../lib/marvin"
+# Now, Set everything up.
+Marvin::Logger.logger = Logger.new(File.dirname(__FILE__) + "/../log/test.log")
+Marvin::Settings.default_client = Marvin::TestClient
+Marvin::Loader.run!
+
+def client(force_new = false)
+  $test_client = Marvin::TestClient.new if force_new || $test_client.nil?
+  return $test_client
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: Sutto-marvin
 version: !ruby/object:Gem::Version 
-  version: 0.1.0.20081016
+  version: 0.1.20081115
 platform: ruby
 authors: 
 - Darcy Laycock
@@ -9,8 +9,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-05 00:00:00 -07:00
-default_executable: marvin
+date: 2008-11-15 00:00:00 -08:00
+default_executable: 
 dependencies: []
 
 description: Marvin is a Ruby IRC library / framework for ultimate awesomeness and with an evented design.
@@ -22,6 +22,9 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- README.textile
+- VERSION.yml
+- bin/marvin
 - lib/marvin
 - lib/marvin/abstract_client.rb
 - lib/marvin/abstract_parser.rb
@@ -29,11 +32,14 @@ files:
 - lib/marvin/command_handler.rb
 - lib/marvin/core_ext.rb
 - lib/marvin/data_store.rb
+- lib/marvin/dispatchable.rb
 - lib/marvin/drb_handler.rb
 - lib/marvin/exception_tracker.rb
 - lib/marvin/exceptions.rb
+- lib/marvin/handler.rb
 - lib/marvin/irc
 - lib/marvin/irc/abstract_server.rb
+- lib/marvin/irc/base_server.rb
 - lib/marvin/irc/client.rb
 - lib/marvin/irc/event.rb
 - lib/marvin/irc/socket_client.rb
@@ -53,16 +59,18 @@ files:
 - lib/marvin/test_client.rb
 - lib/marvin/util.rb
 - lib/marvin.rb
-- bin/marvin
-- config/settings.yml.sample
-- config/setup.rb
+- spec/marvin
+- spec/marvin/abstract_client_test.rb
+- spec/spec_helper.rb
+- script/daemon-runner
+- script/run
 - handlers/hello_world.rb
 - handlers/logging_handler.rb
 - handlers/tweet_tweet.rb
-- script/daemon-runner
-- script/run
-has_rdoc: true
-homepage: http://github.com/sutto/marvin
+- config/setup.rb
+- config/settings.yml.sample
+has_rdoc: false
+homepage: http://blog.ninjahideout.com/
 post_install_message: 
 rdoc_options: []
 
@@ -80,8 +88,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version 
       version: "0"
   version: 
-requirements: 
-- install the eventmachine gem to get better client support
+requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.2.0
 signing_key: