rubot 0.0.1

data/README

@@ -0,0 +1 @@
+# todo Add documentation here

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('rubot', '0.0.1') do |p|
+  p.description    = "A Ruby Bot framwork for IRC"
+  p.url            = "http://github.com/tombombadil/hello_world"
+  p.author         = "Chris Thorn"
+  p.email          = "thorncp @nospam@ gmail.com"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.development_dependencies = []
+end

data/lib/core.rb

@@ -0,0 +1,8 @@
+module Rubot
+  module Core
+    smartload :Dispatcher
+    smartload :Command
+    smartload :Listener
+    smartload :Runner
+  end
+end

data/lib/core/command.rb

@@ -0,0 +1,70 @@
+require "shellwords"
+module Rubot
+  module Core
+    class Command
+      attr_reader :protected
+  
+      def initialize(dispatcher)
+        @dispatcher = dispatcher
+      end
+  
+      def run(server, message)
+        args = Shellwords.shellwords(message.body.gsub(/(')/n, "\\\\\'"))
+        options = parse(args)
+    
+        if options.help
+          # this to_s.lines.to_a business is a hack to not display the -h, --help line
+          # there's got to be an easier/better way to do this. but it'll work for now
+          server.msg(message.destination, options.help.to_s.lines.to_a[0..-2])
+        else
+          message.body = args.join(" ")
+          execute(server, message, options)
+        end
+      end
+  
+      def is_protected?
+        false
+      end
+  
+      private
+  
+      # commands override this
+      def execute(server, message, options)
+        server.msg(message.destincation, "unimplemented")
+      end
+  
+      def self.acts_as_protected
+        define_method(:is_protected?) do
+          true
+        end
+      end
+  
+      def self.aliases(*aliases)
+        raise ArgumentError, 'only symbols allowed' unless aliases.all? {|a| a.is_a? Symbol}
+        define_method(:aliases) do
+          aliases
+        end
+      end
+  
+      def parse(args)
+        options = OpenStruct.new
+        @parser = OptionParser.new do |parser|
+          parser.banner = "Usage: !#{self.class.to_s.downcase} [options]"
+      
+          options(parser, options)
+      
+          parser.on_tail("-h", "--help", "Show this message") do
+            options.help = parser
+          end
+        end
+  
+        @parser.parse!(args)
+        options
+      end
+  
+      # override this to add more options in a command class
+      def options(parser, options)
+      end
+    end
+  end
+end

data/lib/core/dispatcher.rb

@@ -0,0 +1,84 @@
+require "thread"
+
+module Rubot
+  module Core
+    class Dispatcher
+  
+      attr_reader :commands, :listeners, :function_character, :config, :resource_lock
+  
+      def initialize(config)
+        @config = config
+        @function_character = @config["function_character"]
+    
+        @auth_list = config["auth_list"].split(',')
+    
+        @resource_lock = Mutex.new
+        reload
+        # runners are only run on server connection, so there's no need them to be in reload 
+        load_dir "runners", @runners = {}
+      end
+  
+      def connected(server)
+        run_runners(server)
+      end
+  
+      def reload
+    		load_dir "commands", @commands = {}
+    	  load_dir "listeners", @listeners = {}
+    	end
+  
+      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
+    		  command = @commands[$1.underscore.to_sym]
+		  
+    		  if command.nil?
+    		    puts "#{$1} does not yield a command"
+    		    return
+    	    end
+		  
+    		  #if command is protected and user is not authenticated, return
+    		  if command.is_protected? && !@auth_list.include?(message.from)
+    		    server.msg(message.destination, "unauthorized")
+    		    return
+    	    end
+		  
+    		  command.run(server, message)
+    	  elsif message.from != server.nick
+    	    @listeners.each_value do |listener|
+    	      listener.execute(server, message)
+          end
+        end
+      end
+  
+      def add_auth(nick)
+        unless @auth_list.include? nick
+          @auth_list.push nick
+        end
+      end
+  
+      def remove_auth(nick)
+        @auth_list.delete nick
+      end
+  
+      private
+  
+      def run_runners(server)
+        @runners.each_value {|r| r.run(server)}
+      end
+	
+    	def load_dir(dir, set = nil)
+    	  Dir["#{dir}/*.rb"].each do |file|
+    	    load file
+	    
+    	    next unless set
+	    
+          name = File.basename(file, ".rb")
+          clazz = eval(name.camelize).new(self)
+          set[name.to_sym] = clazz
+          clazz.aliases.each{|a| set[a] = clazz} if clazz.respond_to? :aliases
+        end
+      end
+    end
+  end
+end

data/lib/core/listener.rb

@@ -0,0 +1,13 @@
+module Rubot
+  module Core
+    class Listener
+      def initialize(dispatcher)
+        @dispatcher = dispatcher
+      end
+  
+      def execute(server, message)
+        puts "#{self} listener does not implement execute method"
+      end
+    end
+  end
+end

data/lib/core/runner.rb

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

data/lib/extensions.rb

@@ -0,0 +1,4 @@
+dir = File.dirname(__FILE__)
+
+require "#{dir}/extensions/string"
+require "#{dir}/extensions/kernel"

data/lib/extensions/kernel.rb

@@ -0,0 +1,6 @@
+module Kernel
+  def smartload(name)
+    # find a less hackish way to do this
+    require "#{File.dirname(__FILE__)}/../#{File.basename(self.to_s.underscore, '.rb')}/#{name.to_s.underscore}"
+  end
+end

data/lib/extensions/string.rb

@@ -0,0 +1,9 @@
+class String
+  def camelize
+    self.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+  
+  def underscore
+    self.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end
+end

data/lib/init/bundler.rb

@@ -0,0 +1,9 @@
+begin
+  # Try to require the preresolved locked set of gems.
+  require File.expand_path('../.bundle/environment', __FILE__)
+rescue LoadError
+  # Fall back on doing an unlocked resolve at runtime.
+  require "rubygems"
+  require "bundler"
+  Bundler.setup
+end

data/lib/irc.rb

@@ -0,0 +1,7 @@
+module Rubot
+  module Irc
+    smartload :Constants
+    smartload :Message
+    smartload :Server
+  end
+end

data/lib/irc/constants.rb

@@ -0,0 +1,10 @@
+module Rubot
+  module Irc
+    module Constants
+      MAX_MESSAGE_LENGTH = 400
+
+      WELLCOME = 1
+      ERR_NICK_IN_USE = 433
+    end
+  end
+end

data/lib/irc/message.rb

@@ -0,0 +1,14 @@
+module Rubot
+  module Irc
+    class Message
+      attr_accessor :destination, :body
+      attr_reader :from
+  
+      def initialize(from, destination, body)
+        @from = from
+        @destination = destination
+        @body = body
+      end
+    end
+  end
+end

data/lib/irc/server.rb

@@ -0,0 +1,149 @@
+require "socket"
+
+module Rubot
+  module Irc
+    class Server
+      include Rubot::Irc::Constants
+      attr_reader :nick, :connected_at
+  
+      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
+      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 = 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)
+        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/rubot.rb

@@ -0,0 +1,12 @@
+module Rubot
+  
+  dir = File.dirname(__FILE__)
+  
+  # run initializers
+  Dir["#{dir}/init/*.rb"].each {|file| require file}
+  
+  # load rubot
+  require "#{dir}/extensions"
+  require "#{dir}/core"
+  require "#{dir}/irc"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: rubot
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Chris Thorn
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-04 00:00:00 -09:00
+default_executable: 
+dependencies: []
+
+description: A Ruby Bot framwork for IRC featuring reloadable commands and listeners.
+email: thorncp@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/core/command.rb
+- lib/core/dispatcher.rb
+- lib/core/listener.rb
+- lib/core/runner.rb
+- lib/core.rb
+- lib/extensions/kernel.rb
+- lib/extensions/string.rb
+- lib/extensions.rb
+- lib/init/bundler.rb
+- lib/irc/constants.rb
+- lib/irc/message.rb
+- lib/irc/server.rb
+- lib/irc.rb
+- lib/rubot.rb
+- README
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/thorncp/rubot
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- NiftyGenerators
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Ruby Bot framwork for IRC
+test_files: []
+