rubot 0.1.0 → 0.1.1

data/lib/core/command.rb

@@ -5,16 +5,25 @@ require "optparse"
 module Rubot
   module Core
     # Base class that handles the dirty work for IRC commands.
-    # All commands belong in the /commands directory and
-    # inherit this class.
-    #
-    # Since:: 0.0.1
     class Command
   
+      # Takes an instance of Rubot::Core::Dispatcher. Any
+      # child class that needs a constructor should override
+      # this method.
+      #
+      # ==== Parameters
+      # dispatcher<Rubot::Core::Dispatcher>:: The dispatcher that was used to create
+      # the instance of the command.
       def initialize(dispatcher)
         @dispatcher = dispatcher
       end
   
+      # Runs the command with the given server and message.
+      #
+      # ==== Parameters
+      # server<Rubot::Irc::Server>:: Server instance the command should use for
+      # messaging and information.
+      # message<Rubot::Irc::Message>:: The message that invoked the command.
       def run(server, message)
         if protected? && !message.authenticated
           server.msg(message.destination, "unauthorized")
@@ -34,29 +43,64 @@ module Rubot
         end
       end
   
+      # Whether the command is marked as protected or not (using Command::acts_as_protected).
       def protected?
         false
       end
   
       private
   
-      # commands override this
+      # The internal execution of a command, called by #run. This is the method all
+      # children classes should override. 
+      # 
+      # ==== Paramters
+      # server<Rubot::Irc::Server>:: Server instance the command should use for messaging and information.
+      # message<Rubot::Irc:Message>:: The message that invoked the command.
+      # options<OpenStruct>:: The options that were parsed from the message that invoked the command. The
+      # parsing is handled in #run
       def execute(server, message, options)
         server.msg(message.destincation, "unimplemented")
       end
   
+      # Marks the command as protected. Commands that are protected can only be accessed by users who
+      # are authenticated. If you only need pieces of the command to be protected, this is not the method
+      # you're looking for. In that case, use Message#authenticated, which is populated automatically
+      # depending on the invoking user.
+      #
+      # ==== Example
+      #   class Quit < Rubot::Core::Command
+      #     acts_as_protected
+      #     
+      #     def execute(server, message, options)
+      #       server.quit
+      #       exit
+      #     end
+      #   end
       def self.acts_as_protected
         define_method(:protected?) do
           true
         end
       end
   
+      # Allows a command to be called by different names (aliases).
+      #
+      # ==== Example
+      # This command can be invoked by <em>!hi</em>, <em>!hello</em>, or <em>!whats_up</em>.
+      #   class Hi < Rubot::Core::Command
+      #     aliases :hello, :whats_up
+      #     
+      #     def execute(server, message, options)
+      #       server.msg(message.destination, "hi everybody!")
+      #     end
+      #   end
       def self.aliases(*aliases)
         define_method(:aliases) do
           aliases
         end
       end
   
+      # Parses the given array using the default options (help) and any options specified
+      # by the child class by overriding #options.
       def parse(args)
         options = OpenStruct.new
         @parser = OptionParser.new do |parser|
@@ -73,7 +117,25 @@ module Rubot
         options
       end
   
-      # override this to add more options in a command class
+      # Method to be overriden by child class if extra options are to be used. Options are
+      # parsed with OptParse.
+      #
+      # ==== Example
+      #   class Hi < Rubot::Core::Command
+      #     
+      #     def execute(server, message, options)
+      #       if options.bye
+      #         server.msg(message.destination, "bye everybody!")
+      #       else
+      #         server.msg(message.destination, "hi everybody!")
+      #       end
+      #     end
+      #
+      #     def options(parser, options)
+      #       parser.on("-b", "--bye", "Instead of saying hi, say goodbye") do |bye|
+      #         options.bye = bye
+      #       end
+      #   end
       def options(parser, options)
       end
     end

data/lib/core/dispatcher.rb

@@ -2,14 +2,36 @@ require "thread"
 
 module Rubot
   module Core
-    # The middle man.  The Dispatcher takes incomming messages
-    # from the server and determines the appropriate action to
-    # take, handing the messages off to commands or listeners.
-    #
-    # Since:: 0.0.1
+    # The middle man.  The Dispatcher takes incomming messages from the server and
+    # determines the appropriate action to take, handing the messages off to commands
+    # and listeners.
     class Dispatcher
-      attr_reader :commands, :listeners, :function_character, :config, :resource_lock
+      # Hash that holds instances of commands registered with the dispatcher. There
+      # is a single instance of each command, with its name, and aliases, as keys
+      # to that instance.
+      attr_reader :commands
+      
+      # Hash that holds instances of listeners registered with the dispatcher. There
+      # is a single instance of each listener, with its name as the key to that instance.
+      attr_reader :listeners
+      
+      # The value used to denote a command, this is pulled from config.
+      attr_reader :function_character
+      
+      # The config hash that was used to create the Dispatcher instance.
+      attr_reader :config
+      
+      # Mutex that should be used when accessing anything in <em>/resources</em>. This
+      # will most likely be moved to the resource manager when it is implemented.
+      attr_reader :resource_lock
 
+      # Creates an instance of Dispatcher using the given config hash. Values expected to
+      # be in this hash are:
+      # * function_character - The character used to denote a command
+      # * auth_list - Comma separated string of authenticated users
+      #
+      # ==== Parameters
+      # config<Hash>:: Hash containing config values
       def initialize(config)
         @config = config
         @function_character = @config["function_character"]
@@ -22,15 +44,28 @@ module Rubot
         load_dir "runners", @runners = {}
       end
 
+      # Called when successful connection is made to a server. This is when the runners are
+      # executed.
+      #
+      # ==== Parameters
+      # server<Rubot::Irc::Server>:: The server instance that has successfully connected
       def connected(server)
         run_runners(server)
       end
 
+      # Exposed method to reload all commands and listeners.
       def reload
         load_dir "commands", @commands = {}
         load_dir "listeners", @listeners = {}
       end
 
+      # Determines how to handle a message from the server.  If the message fits the format
+      # of a command, an attempt is made to find and execute that command. Otherwise, the
+      # message is passed to the listeners.
+      #
+      # ==== Parameters
+      # server<Rubot::Irc::Server>:: The server where the messge was received
+      # message<Rubot:Irc::Message>:: The message to handle
       def handle_message(server, message)		  
         if message.body =~ /^#{@function_character}([a-z_]+)( .+)?$/i
           message.body = $2.nil? ? "" : $2.strip # remove the function name from the message
@@ -45,30 +80,57 @@ module Rubot
         end
       end
 
+      # Finds a command based on the message alias, and determines if the invoking user
+      # is authenticated.
+      #
+      # ==== Parameters
+      # message<Rubot::Irc::Message>:: The message to be used
       def command_from_message(message)
-        command   = @commands[message.alias]        
+        command = @commands[message.alias]        
         message.authenticated = authenticated?(message.from) unless command.nil?
         command
       end
 
+      # Determines if the given nick has authenticated with the bot.
+      #
+      # ==== Parameters
+      # nick<String>:: The nick to check for auth privledges
       def authenticated?(nick)
         @auth_list.include?(nick)
       end
 
+      # Adds nick to the authenticated list.
+      #
+      # ==== Parameters
+      # nick<String>:: The nick to add to the authenticated list
       def add_auth(nick)
         @auth_list << nick unless authenticated?(nick)
       end
 
+      # Removes nick from the authenticated list.
+      #
+      # ==== Parameters
+      # nick<String>:: The nick to remove from the authenticated list
       def remove_auth(nick)
         @auth_list.delete nick
       end
 
       private
 
+      # Runs all runners using the given server instance.
+      #
+      # ==== Parameters
+      # server<Rubot::Irc::Server>:: Server instance
       def run_runners(server)
         @runners.each_value {|runner| runner.run(server)}
       end
 
+      # Loads all files in the given directory and stores the class instances
+      # in the given set. This is used to load commands, listeners, and runners.
+      #
+      # ==== Parameters
+      # dir<String>:: Directory of files to load
+      # set<Hash>:: Hash to store class instances in
       def load_dir(dir, set)
         Dir["#{dir}/*.rb"].each do |file|
           load file
@@ -76,6 +138,14 @@ module Rubot
         end
       end
 
+      # Takes a file and creates an instance of the class within the file and stores it
+      # in hash, with the base filename as the key. If the class instance responds to 
+      # :aliases, these are used as keys to the instance as well.
+      #
+      # ==== Parameters
+      # file<String>:: Filename to use for instantiation
+      # hash<Hash>:: Hash to store the instance in
+      # ext<String>:: File extension of the file to load
       def file_to_instance_hash(file, hash, ext = ".rb")
         name = File.basename(file, ext)
         clazz = eval(name.camelize).new(self)

data/lib/core/listener.rb

@@ -1,10 +1,33 @@
 module Rubot
   module Core
+    # Base class for all listeners. A listener cannot be called directly, but
+    # <em>listens</em> to messages on a server.
+    #
+    # ==== Example
+    # This listener responds when the bot is greeted.
+    #   class Greet < Rubot::Core::Listener
+    #     def execute(server, message)
+    #       server.msg(message.destination, "hi #{message.from}") if message.body == "hi #{server.nick}"
+    #     end
+    #   end
     class Listener
+      # Takes an instance of Rubot::Core::Dispatcher. Any
+      # child class that needs a constructor should override
+      # this method.
+      #
+      # ==== Parameters
+      # dispatcher<Rubot::Core::Dispatcher>:: The dispatcher that was used to create
+      # the instance of the listener.
       def initialize(dispatcher)
         @dispatcher = dispatcher
       end
   
+      # Runs the listener with the given server and message.
+      #
+      # ==== Paramters
+      # server<Rubot::Irc::Server>:: Server instance the listener should use for
+      # messaging and information.
+      # message<Rubot::Irc::Message>:: The message that invoked the command.
       def execute(server, message)
         puts "#{self} listener does not implement execute method"
       end

data/lib/core/runner.rb

@@ -1,11 +1,35 @@
 module Rubot
   module Core
+    # Base class for all runners. Runners are intended to be executed upon
+    # successful connection to a server, and cannot be invoked from a user.
+    #
+    # ==== Example
+    # This runner greets every channel the bot is in upon server connection.
+    #   class Greet < Rubot::Core::Runner
+    #     def run(server)
+    #       server.channels.each do |channel|
+    #         server.msg(channel, "hi everybody!")
+    #       end
+    #     end
+    #   end
     class Runner
   
+      # Takes an instance of Rubot::Core::Dispatcher. Any
+      # child class that needs a constructor should override
+      # this method.
+      #
+      # ==== Parameters
+      # dispatcher<Rubot::Core::Dispatcher>:: The dispatcher that was used to create
+      # the instance of the runner.
       def initialize(dispatcher)
         @dispatcher = dispatcher
       end
   
+      # Runs the runner with the given server.
+      #
+      # ==== Paramters
+      # server<Rubot::Irc::Server>:: Server instance the runner should use for
+      # messaging and information.
       def run(server)
       end
     end

data/lib/extensions/object.rb

@@ -1,4 +1,5 @@
 class Object
+  # Returns a reference to the obkect's eigen (singleton) class.
   def eigen_class
     class << self
       self

data/lib/extensions/string.rb

@@ -1,8 +1,10 @@
 class String
+  # Converts a string camel case. Taken from Rails source.
   def camelize
     self.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
   end
   
+  # Converts a string to underscore form. Taken from Rails source.
   def underscore
     self.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
   end

data/lib/irc/message.rb

@@ -1,9 +1,29 @@
 module Rubot
   module Irc
+    # Represents an IRC message.
     class Message
-      attr_accessor :destination, :body, :alias, :authenticated
+      # The location where the reply to this message should be sent. This defaults
+      # to the source of the message
+      attr_accessor :destination
+      
+      # The body of the message.
+      attr_accessor :body
+      
+      # If the message was used to invoke a command, this will be the command name.
+      attr_accessor :alias
+      
+      # If the user that sent this message is authenticated, this will be true.
+      attr_accessor :authenticated
+      
+      # The user that sent this message.
       attr_reader :from
   
+      # Initializes a new object with the given from, destination, and body.
+      #
+      # ==== Parameters
+      # from<String>:: The nick who sent the message
+      # destination<String>:: The destination where the reply to this message should be sent.
+      # body<String>:: The body of the message
       def initialize(from, destination, body)
         @from = from
         @destination = destination

data/lib/irc/message_queue.rb

@@ -1,14 +1,96 @@
 module Rubot
   module Irc
+    # Used to queue outgoing messages with a delay, so we don't get excess flood
+    # kicked for spamming. The actual actions taken can be whatever they need to
+    # be. Currently they're just sending a message and sending an action to the
+    # server.
+    #
+    # I'll rehash the Rubot::Irc::Server code with a few modifications to 
+    # demonstrate how it works.
+    #
+    # ==== Example
+    # This code initializes a message queue with a two second delay, then defines
+    # two methods with different actions.
+    #
+    #   @message_queue = MessageQueue.new(2)
+    #
+    #   @message_queue.message do |destination, message|
+    #     puts "MESSAGE to #{destination} with body #{message}"
+    #   end
+    #
+    #   @message_queue.action do |destination, action|
+    #     puts "ACTION to #{destination} with body #{action}"
+    #   end
+    #
+    # After executing this code, the :message and :action methods are now available
+    # for this queue. Each call to these methods adds another action to the queue
+    # with the appropriate action.
+    #
+    # To use our newly created queue:
+    #
+    #   @message_queue.message "destination_one", "i'm a message"
+    #   @message_queue.action "destination_two", "i'm an action"
+    #   @message_queue.message "destination_one", "i'm anoter message"
+    #
+    # This will yield the following output:
+    #
+    #   MESSAGE to destination_one with body i'm a message
+    #   # two second delay
+    #   ACTION to destination_two with body i'm an action
+    #   # two second delay
+    #   MESSAGE to destination_one with body i'm another message
+    #
+    # These created methods are tailored for messages, and can accept string, arrays,
+    # or exploded arrays as parameters, as long as the first parameter is the destination.
+    # In the case of (exploded) arrays, each element in the array will be treated
+    # as a separate call to the block used to create the method.
+    #
+    # ==== Fancy Pants Paraters
+    # Assuming the code above has been executed, we can run the following:
+    #
+    #   @message_queue.message "destination_three", "message one", "message two", "message three"
+    #   actions = ["action one", "action_two", "action_three"]
+    #   @message_queue.action "destination_two", actions
+    #
+    # which will produce:
+    #
+    #   MESSAGE to destination_three with body message one
+    #   # two second delay
+    #   MESSAGE to destination_three with body message two
+    #   # two second delay
+    #   MESSAGE to destination_three with body message three
+    #   # two second delay
+    #   ACTION to destination_two with body action one
+    #   # two second delay
+    #   ACTION to destination_two with body action two
+    #   # two second delay
+    #   ACTION to destination_two with body action three
     class MessageQueue
+      # The delay in seconds to be used.
       attr_accessor :delay
   
+      # Initiliazes a new queue with the given delay.
+      #
+      # ==== Parameters
+      # delay<Fixnum>:: Delay in seconds
       def initialize(delay)
         @delay = delay
         @lock = Mutex.new
         @queue = []
       end
   
+      # This is where the magic happens. If we're sent a method we don't respond to,
+      # and it contains a block, we create a new method using that block. If no block
+      # is given, we forward to the base method_missing.
+      #
+      # This method makes an assumption about the block that's given. It is assumed
+      # that the block takes two arguments, a destination and a message (This is a
+      # message queue after all).
+      #
+      # ==== Parameters
+      # method<Symbol>:: Method name
+      # args<Array>:: Parameters given to the method
+      # block<Proc>:: The block that was passed 
       def method_missing(method, *args, &block)
         if block
           eigen_class.instance_eval do
@@ -28,6 +110,7 @@ module Rubot
       end
   
       private
+      # Flushes the queue, executing each action it contains
       def flush
         until @queue.empty?
           element = @queue.shift

data/lib/irc/server.rb

@@ -2,10 +2,26 @@ require "socket"
 
 module Rubot
   module Irc
+    # Performs the dirty work of communicating with an IRC server, passing messages
+    # back and forth between the server and a dispatcher.
     class Server
       include Rubot::Irc::Constants
-      attr_reader :nick, :connected_at, :channels
-  
+      # Our current nick
+      attr_reader :nick
+      
+      # When a successful connection to the server was made
+      attr_reader :connected_at
+      
+      # The list of channels we're currently in
+      attr_reader :channels
+  
+      # Initializes a Server using the given dispatcher.
+      #
+      # The connection info to be used is extracted from the dispatcher's config method. (This
+      # needs to be changed)
+      #
+      # ==== Parameters
+      # dispatcher<Rubot::Core::Dispatcher>:: The dispatcher to handle the messages we receive
       def initialize(dispatcher)
         dispatcher.config["server"].each_pair do |key, value|
           instance_variable_set("@#{key}".to_sym, value)
@@ -24,6 +40,7 @@ module Rubot
         end
       end
   
+      # Attempts to make a connection to the server
       def connect
         return if @is_connected
     
@@ -42,55 +59,88 @@ module Rubot
         end
       end
   
+      # Sends the quit command to the IRC server, then closes the connection.
       def quit
         raw "QUIT :#{@quit_message}"
         @conn.close
       end
   
+      # Changes our nick.
       def change_nick(new_nick)
         raw "NICK #{new_nick}"
         @nick = new_nick
       end
   
+      # Joins the specified channels, which can be comma separated string or an array.
+      #
+      # ==== Parameters
+      # channels<String,Array>:: The channels to join
       def join(channels)
         channels = channels.split(',') if channels.is_a? String
         @channels.concat(channels).uniq!
         bulk_command("JOIN %s", channels)
       end
   
+      # Parts the specified channels, which can be comma separated string or an array.
+      #
+      # ==== Parameters
+      # channels<String,Array>:: The channels to part
       def part(channels)
         channels = channels.split(',') if channels.is_a? String
         @channels.reject! { |channel| channels.include?(channel) }
         bulk_command("PART %s :#{@quit_message}", channels)
       end
   
+      # Adds message(s) to the outgoing queue
+      #
+      # ==== Parameters
+      # destination<String>:: Where to send the message
+      # message<String,Array>:: The message(s) to be sent
       def msg(destination, message)
         @message_queue.message(destination, message)
+        # TODO use build_message_array with the queue
         #message = message.to_s.split("\n") unless message.is_a? Array
         #build_message_array(message).each do |l|
         #  raw "PRIVMSG #{destination} :#{l}"
         #end
       end
-  
-      def action(destination, message)
-        @message_queue.action(destination, message)
-        #msg(destination, "\001ACTION #{message}\001")
-      end
-  
+      
+      # Adds action(s) to the outgoing queue
+      #
+      # ==== Parameters
+      # destination<String>:: Where to send the message
+      # action<String,Array>:: The actions(s) to be sent
+      def action(destination, action)
+        @message_queue.action(destination, action)
+      end
+  
+      # Sends a raw line to the server and dumps it the console (to be replaced with a logger)
+      #
+      # ==== Parameters
+      # message<String>:: The raw line to send
       def raw(message)
         puts "--> #{message}"
         @conn.puts "#{message}\n"
       end
   
+      # Get the list of nicks in the given channel. I'm not sure if the current implementation
+      # is really how it should be. TODO investigate
+      #
+      # ==== Parameters
+      # channel<String>:: The channel whose nicks we want
       def names(channel)
         raw "NAMES #{channel}"
         @conn.gets.split(":")[2].split(" ")
       end
   
       private
-  
+      
+      # The loop that goes on forever, reading input from the server.
       def main_loop
-        while true
+        loop do
+          # something about this doesn't seem right. why are we using select and creating 
+          # the ready object if we're never using it. TODO investigate wtf is going on here
+          # and find a better solution
           ready = select([@conn])
           next unless ready
       
@@ -100,8 +150,9 @@ module Rubot
     		end
       end
   
+      # Determines what to do with the input from the server
       def handle_server_input(s)
-    	  puts s
+    	  puts s # TODO logger
     
         case s.strip
           when /^PING :(.+)$/i
@@ -126,6 +177,7 @@ module Rubot
         end
       end
   
+      # Handles predefined events from the server.
       def handle_meta(server, code, message)
         case code
         when ERR_NICK_IN_USE
@@ -143,6 +195,8 @@ module Rubot
         end
       end
   
+      # Preps the string for sending to the server by breaking it down into
+      # an array if it's too long
       def string_to_irc_lines(str)
         str.split(" ").inject([""]) do |arr, word|
           arr.push("") if arr.last.size > MAX_MESSAGE_LENGTH
@@ -151,6 +205,8 @@ module Rubot
         end.map(&:strip)
       end
   
+      # Ensures each string in the array is shorter than the max allowed message
+      # length, breaking the string if necessary
       def build_message_array(arr)
         arr.each_with_index.map do |message, index|
           message.size > MAX_MESSAGE_LENGTH ? string_to_irc_lines(message) : arr[index]

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Chris Thorn
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 -08:00
+date: 2010-04-07 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -28,42 +28,34 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - bin/rubot
-- bin/rubot~
+- lib/core/command.rb
+- lib/core/dispatcher.rb
+- lib/core/listener.rb
+- lib/core/runner.rb
 - lib/core.rb
-- lib/irc/message.rb
-- lib/irc/server.rb
-- lib/irc/constants.rb
-- lib/irc/message_queue.rb
-- lib/irc/server.rb~
-- lib/generators/command.rb~
-- lib/generators/listener.template~
-- lib/generators/listeners.template
-- lib/generators/commands.template
-- lib/generators/command.template~
-- lib/generators/runner.template~
-- lib/generators/runners.template
 - lib/extensions/object.rb
 - lib/extensions/string.rb
-- lib/template/commands/reload.rb
-- lib/template/commands/quit.rb
-- lib/template/commands/part.rb
-- lib/template/commands/msg.rb
-- lib/template/commands/up_time.rb
-- lib/template/commands/join.rb
+- lib/extensions.rb
+- lib/generators/commands.template
+- lib/generators/listeners.template
+- lib/generators/runners.template
+- lib/irc/constants.rb
+- lib/irc/message.rb
+- lib/irc/message_queue.rb
+- lib/irc/server.rb
+- lib/irc.rb
+- lib/rubot.rb
 - lib/template/commands/auth.rb
 - lib/template/commands/help.rb
+- lib/template/commands/join.rb
+- lib/template/commands/msg.rb
+- lib/template/commands/part.rb
+- lib/template/commands/quit.rb
+- lib/template/commands/reload.rb
+- lib/template/commands/up_time.rb
 - lib/template/main.rb
 - lib/template/resources/config.yml
-- lib/core/dispatcher.rb
-- lib/core/listener.rb
-- lib/core/command.rb
-- lib/core/runner.rb
-- lib/core/runner.rb~
-- lib/irc.rb
 - lib/template.rb
-- lib/extensions.rb
-- lib/rubot.rb
-- lib/template.rb~
 - README.rdoc
 has_rdoc: true
 homepage: http://github.com/thorncp/rubot

data/bin/rubot~

@@ -1,48 +0,0 @@
-#!/usr/bin/env ruby
-
-require "optparse"
-require "ostruct"
-require "template"
-
-options = OpenStruct.new
-parser = OptionParser.new do |parser|
-  parser.banner = "Usage: #{__FILE__} <options>"
-  
-  parser.separator ""
-  parser.separator "Initialization"
-  
-  parser.on("-i", "--init ProjectName", "Initializes a new rubot project in the ProjectName directory") do |name|
-    init name
-    exit
-  end
-  
-  parser.separator ""
-  parser.separator "Generators"
-  
-  parser.on("-c", "--command Name", "Generates a new command named Name") do |name|
-    generate_command(name)
-    exit
-  end
-  
-  parser.on("-l", "--listener Name", "Generates a new listener named Name") do |listener|
-    generate_listener(name)
-    exit
-  end
-  
-  parser.on("-r", "--runner Name", "Generates a new listener named Name") do |runner|
-   generate_runner(name)
-    exit
-  end
-  
-  parser.separator ""
-  parser.separator "Common options:"
-  
-  parser.on_tail("-h", "--help", "Show this message") do
-    puts parser
-    exit
-  end
-end
-
-parser.parse!(ARGV)
-puts parser
-

data/lib/core/runner.rb~

@@ -1,13 +0,0 @@
-module Rubot
-  module Core
-    class BaseRunner
-  
-      def initialize(dispatcher)
-        @dispatcher = dispatcher
-      end
-  
-      def run(server)
-      end
-    end
-  end
-end

data/lib/generators/command.rb~

@@ -1,5 +0,0 @@
-class  < Rubot::Core::Command
-  def execute(server, message, options)
-    server.msg(message.destination, "unimplemented")
-  end
-end

data/lib/generators/command.template~

@@ -1,5 +0,0 @@
-class $NAME$ < Rubot::Core::Command
-  def execute(server, message, options)
-    server.msg(message.destination, "unimplemented")
-  end
-end

data/lib/generators/listener.template~

@@ -1,7 +0,0 @@
-class --NAME-- < Rubot::Core::Listener
-  def execute(server, message)
-    if message.from == server.nick
-      server.msg(message.destination, "hi #{message.from}")
-    end
-  end
-end

data/lib/generators/runner.template~

@@ -1,5 +0,0 @@
-class --NAME-- < Rubot::Core::Runner
-  def run(server)
-    server.msg(message.destination, "unimplemented")
-  end
-end

data/lib/irc/server.rb~

@@ -1,162 +0,0 @@
-require "socket"
-
-module Rubot
-  module Irc
-    class Server
-      include Rubot::Irc::Constants
-      attr_reader :nick, :connected_at, :channels
-  
-      def initialize(dispatcher)
-        dispatcher.config["server"].each_pair do |key, value|
-          instance_variable_set("@#{key}".to_sym, value)
-        end
-        @channels = @channels.split(",").collect(&:strip)
-        @dispatcher = dispatcher
-        
-        @message_queue = MessageQueue.new(@message_delay)
-        
-        @message_queue.message do |destination, message|
-          raw "PRIVMSG #{destination} :#{message}"
-        end
-        
-        @message_queue.action do |destination, action|
-          raw "PRIVMSG #{destination} :\001ACTION #{action}\001"
-        end
-      end
-  
-      def connect
-        return if @is_connected
-    
-        @conn = TCPSocket.open(@host, @port, @vhost)
-        raw "USER #{@nick} #{@nick} #{@nick} :#{@real_name}"
-        change_nick @nick
-        join @channels
-    
-        begin
-            main_loop()
-        rescue Interrupt
-        rescue Exception => detail
-            puts detail.message()
-            print detail.backtrace.join("\n")
-            retry
-        end
-      end
-  
-      def quit
-        raw "QUIT :#{@quit_message}"
-        @conn.close
-      end
-  
-      def change_nick(new_nick)
-        raw "NICK #{new_nick}"
-        @nick = new_nick
-      end
-  
-      def join(channels)
-        channels = channels.split(',') if channels.is_a? String
-        @channels.concat(channels).uniq!
-        bulk_command("JOIN %s", channels)
-      end
-  
-      def part(channels)
-        channels = channels.split(',') if channels.is_a? String
-        @channels.reject! { |channel| channels.include?(channel) }
-        bulk_command("PART %s :#{@quit_message}", channels)
-      end
-  
-      def msg(destination, message)
-        @message_queue.message(destination, message)
-        #message = message.to_s.split("\n") unless message.is_a? Array
-        #build_message_array(message).each do |l|
-        #  raw "PRIVMSG #{destination} :#{l}"
-        #end
-      end
-  
-      def action(destination, message)
-        @message_queue.action(destination, message)
-        #msg(destination, "\001ACTION #{message}\001")
-      end
-  
-      def raw(message)
-        puts "--> #{message}"
-        @conn.puts "#{message}\n"
-      end
-  
-      def names(channel)
-        raw "NAMES #{channel}"
-        @conn.gets.split(":")[2].split(" ")
-      end
-  
-      private
-  
-      def main_loop
-        while true
-          ready = select([@conn])
-          next unless ready
-      
-          return if @conn.eof
-          s = @conn.gets
-          handle_server_input(s)
-    		end
-      end
-  
-      def handle_server_input(s)
-    	  puts s
-    
-        case s.strip
-          when /^PING :(.+)$/i
-            raw "PONG :#{$1}"
-          when /^:([-.0-9a-z]+)\s([0-9]+)\s(.+)\s(.*)$/i
-            handle_meta($1, $2.to_i, $4)
-          when /^:(.+?)!(.+?)@(.+?)\sPRIVMSG\s(.+)\s:(.+)$/i
-            message = Rubot::Irc::Message.new($1, $4 == @nick ? $1 : $4, $5)
-            # TODO add ability to pass events other than privmsg to dispatcher. ie, nick changes, parts, joins, quits, bans, etc, etc
-            @dispatcher.handle_message(self, message)
-        end
-      end
-  
-      # performs the same command on each element in the given collection, separated by comma
-      def bulk_command(formatted_string, elements)
-        if elements.is_a? String
-          elements = elements.split(',')
-        end
-    
-        elements.each do |e|
-          raw sprintf(formatted_string, e.to_s.strip)
-        end
-      end
-  
-      def handle_meta(server, code, message)
-        case code
-        when ERR_NICK_IN_USE
-          if @nick == @alt_nick
-            puts "all nicks used, don't know how to name myself."
-            quit
-            exit!
-          end
-          change_nick @alt_nick
-          join @channels
-        when WELLCOME
-          @dispatcher.connected(self)
-          @is_connected = true
-          @connected_at = Time.now
-        end
-      end
-  
-      def string_to_irc_lines(str)
-        str.split(" ").inject([""]) do |arr, word|
-          arr.push("") if arr.last.size > MAX_MESSAGE_LENGTH
-          arr.last << "#{word} "
-          arr
-        end.map(&:strip)
-      end
-  
-      def build_message_array(arr)
-        arr.each_with_index.map do |message, index|
-          message.size > MAX_MESSAGE_LENGTH ? string_to_irc_lines(message) : arr[index]
-        end.flatten
-      end
-    end
-  end
-end
-

data/lib/template.rb~

@@ -1,52 +0,0 @@
-require "fileutils"
-require "extensions/string"
-
-def init(name)
-  if Dir.exist? name
-    puts "directory '#{name}' already exists"
-    return
-  end
-  
-  template_dir = File.join(File.dirname(__FILE__), "template")
-  
-  FileUtils.cp_r(template_dir, name)
-  
-  dir_structure = %w{resources commands listeners runners}
-  
-  # for some reason gem doesn't include empty folders during the install.
-  # this is to make sure these directories exist
-  dir_structure.each do |dir|
-    FileUtils.mkdir File.join(name, dir) unless File.exist? File.join(name, dir)
-  end
-end
-
-def generate_command(name)
-  #command = File.join("commands", "#{name.underscore}.rb")
-  #template_file = File.join(File.dirname(__FILE__), "generators", "command.template")
-  #source = IO.read(template_file).gsub(/--NAME--/, name.camelize)
-  #File.open(command, "w") {|file| file.write(source)}
-  generate("commands", name)
-end
-
-def generate_listener(name)
-  #template_file = File.join(File.dirname(__FILE__), "generators", "listener.template")
-  #command = IO.read(template_file).gsub(/--NAME--/, name.camelize)
-  #File.open("listeners/#{name.underscore}.rb", "w") {|file| file.write(command)}
-  generate("listeners", name)
-end
-
-def generate_runner(name)
-  #template_file = File.join(File.dirname(__FILE__), "generators", "runner.template")
-  #command = IO.read(template_file).gsub(/--NAME--/, name.camelize)
-  #File.open("runners/#{name.underscore}.rb", "w") {|file| file.write(command)}
-  generate("runners", name)
-end
-
-def generate(template, name)
-  filename = File.join(template, "#{name.underscore}.rb")
-  puts "file '#{filename}' already exists" and return if File.exist?(filename)
-  
-  template_file = File.join(File.dirname(__FILE__), "generators", "#{template}.template")
-  source = IO.read(template_file).gsub(/--NAME--/, name.camelize)
-  File.open(filename, "w") {|file| file.write(source)}
-end