Sutto-marvin 0.1.0.20081014

data/lib/marvin/data_store.rb

@@ -0,0 +1,73 @@
+require 'json'
+
+module Marvin
+  # Implements a simple datastore interface, designed to make
+  # it easy to develop handlers which have persistent data.
+  class DataStore
+    
+    cattr_accessor :logger, :registered_stores
+    self.logger = Marvin::Logger.logger
+    self.registered_stores = {}
+    
+    # Returns the path to the data store relative to this file.
+    # Used when loading / dumping the data.
+    def self.datastore_location
+      path =  Marvin::Settings[:datastore_location] ? Marvin::Settings.datastore_location : "tmp/datastore.json"
+      return Marvin::Settings.root / path
+    end
+    
+    # Dump the current data store contents to file.
+    def self.dump!
+      File.open(self.datastore_location, "w+") do |f|
+        f.write self.registered_stores.to_json
+      end
+    end
+    
+    # Load the current data store contents from file.
+    def self.load!
+      results = {}
+      if File.exists?(self.datastore_location)
+        begin
+          json = JSON.load(File.read(self.datastore_location))
+          results = json if json.is_a?(Hash)
+        rescue JSON::ParserError
+        end
+      end
+      self.registered_stores = results
+    end
+    
+    
+    # For each individual datastore.
+    
+    attr_accessor :name
+    
+    def initialize(name)
+      self.name = name.to_s
+      self.registered_stores ||= {}
+      self.registered_stores[self.name] ||= {}
+    end
+    
+    def [](key)
+      ((self.registered_stores||={})[self.name]||={})[key.to_s]
+    end
+    
+    def []=(key,value)
+      self.registered_stores[self.name][key.to_s] = value
+    end
+    
+    def method_missing(name, *args, &blk)
+      if name.to_s =~ /^(.*)=$/i
+        self[$1.to_s] = args.first
+      elsif self.registered_stores[self.name].has_key?(name.to_s)
+        return self.registered_stores[self.name][name.to_s]
+      else
+        super(name, *args, &blk)
+      end
+    end
+    
+    def to_hash
+      self.registered_stores[self.name]
+    end
+    
+  end
+end

data/lib/marvin/drb_handler.rb

@@ -0,0 +1,7 @@
+module Marvin
+    
+    def handle(message, options)
+    end
+    
+  end
+end

data/lib/marvin/exception_tracker.rb

@@ -0,0 +1,16 @@
+module Marvin
+  class ExceptionTracker
+  
+    cattr_accessor :logger
+    self.logger = Marvin::Logger.logger
+  
+    def self.log(e)
+      logger.fatal "Exception raised inside Marvin Instance."
+      logger.fatal "#{e} - #{e.message}"
+      e.backtrace.each do |line|
+        logger.fatal line
+      end
+    end
+  
+  end
+end

data/lib/marvin/exceptions.rb

@@ -0,0 +1,8 @@
+module Marvin
+  
+  class Error < StandardError; end
+  
+  # Used to stop the flow of handler chains.
+  class HaltHandlerProcessing < Error; end
+  
+end

data/lib/marvin/irc/abstract_server.rb

@@ -0,0 +1,4 @@
+module Marvin::IRC
+  class AbstractServer
+  end
+end

data/lib/marvin/irc/client.rb

@@ -0,0 +1,107 @@
+require 'eventmachine'
+
+module Marvin::IRC
+  
+  # == Marvin::IRC::Client
+  # An EventMachine protocol implementation built to
+  # serve as a basic, single server IRC client.
+  #
+  # Operates on the principal of Events as well
+  # as handlers.
+  #
+  # === Events
+  # Events are things that can happen (e.g. an
+  # incoming message). All outgoing events are
+  # automatically handled from within the client
+  # class. Incoming events are currently based
+  # on regular expression based matches of
+  # incoming messages. the Client#register_event
+  # method takes either an instance of Marvin::IRC::Event
+  # or a set of arguments which will then be used
+  # in the constructor of a new Marvin::IRC::Event
+  # instance (see, for example, the source code for
+  # this class for examples).
+  #
+  # === Handlers
+  # Handlers on the other hand do as the name suggests
+  # - they listen for dispatched events and act accordingly.
+  # Handlers are simply objects which follow a certain
+  # set of guidelines. Typically, a handler will at
+  # minimum respond to #handle(event_name, details)
+  # where event_name is a symbol for the current
+  # event (e.g. :incoming_event) whilst details is a
+  # a hash of details about the current event (e.g.
+  # message target and the message itself).
+  #
+  # ==== Getting the current client instance
+  # If the object responds to client=, The client will
+  # call it with the current instance of itself
+  # enabling the handler to do things such as respond.
+  # Also, if a method handle_[message_name] exists,
+  # it will be called instead of handle.
+  #
+  # ==== Adding handlers
+  # To add an object as a handler, you simply call
+  # the class method, register_handler with the
+  # handler as the only argument.
+  class Client < Marvin::AbstractClient
+    attr_accessor :em_connection
+    
+    class EMConnection < EventMachine::Protocols::LineAndTextProtocol
+      attr_accessor :client
+      
+      def initialize
+        super
+        self.client = Marvin::IRC::Client.new
+        self.client.em_connection = self
+      end
+      
+      def post_init
+        super
+        client.process_connect
+      end
+
+      def unbind
+        super
+        client.process_disconnect
+      end
+      
+      def receive_line(line)
+        self.client.receive_line(line)
+      end
+      
+    end
+
+    def send_line(*args)
+      em_connection.send_data *args
+    end
+    
+    ## Client specific details
+    
+    # Starts the EventMachine loop and hence starts up the actual
+    # networking portion of the IRC Client.
+    def self.run
+      self.setup # So we have options etc
+      EventMachine::run do
+        logger.debug "Connecting to #{self.configuration.server}:#{self.configuration.port}"
+        EventMachine::connect self.configuration.server, self.configuration.port, Marvin::IRC::Client::EMConnection
+      end
+    end
+    
+    def self.stop
+      logger.debug "Telling all connections to quit"
+      self.connections.dup.each { |connection| connection.quit }
+      logger.debug "Telling Event Machine to Stop"
+      EventMachine::stop_event_loop
+      logger.debug "Stopped."
+    end
+    
+    # Registers a callback handle that will be periodically run.
+    def periodically(timing, event_callback)
+      callback = proc { self.dispatch_event event_callback.to_sym }
+      EventMachine::add_periodic_timer(timing, &callback)
+    end
+    
+  end
+  
+end

data/lib/marvin/irc/event.rb

@@ -0,0 +1,29 @@
+module Marvin::IRC
+  class Event
+    attr_accessor :keys, :name, :raw_arguments
+    
+    def initialize(name, *args)
+      self.name = name.to_sym
+      self.keys = args.flatten.map { |k| k.to_sym }
+    end
+    
+    def to_hash
+      return {} unless self.raw_arguments
+      results = {}
+      values = self.raw_arguments.to_a
+      self.keys.each do |key|
+        results[key] = values.shift
+      end
+      return results
+    end
+    
+    def inspect
+      "#<Marvin::IRC::Event name=#{self.name} attributes=[#{keys * ","}] >"
+    end
+    
+    def to_incoming_event_name
+      :"incoming_#{self.name}"
+    end
+    
+  end
+end

data/lib/marvin/irc/socket_client.rb

@@ -0,0 +1,63 @@
+require 'socket'
+
+module Marvin::IRC
+  class SocketClient < Marvin::AbstractClient
+    attr_accessor :socket
+    
+    def run
+      @socket = TCPSocket.new(self.configuration.server, self.configuration.port)
+      self.process_connect
+      self.enter_loop
+    end
+    
+    def send_line(*args)
+      args.each { |l| @socket.write l } if !@socket.closed?
+    end
+    
+    def disconnect_processed?
+      @disconnect_processed
+    end
+    
+    def enter_loop
+      until @socket.closed?
+        line = @socket.readline.strip
+        receive_line line
+      end
+      self.process_disconnect unless self.disconnect_processed?
+      @disconnect_processed = true
+    rescue SystemExit
+      self.process_disconnect unless self.disconnect_processed?
+      @disconnect_processed = true
+    rescue Exception => e
+      Marvin::ExceptionTracker.log(e)
+    end
+    
+    def quit(*args)
+      super(*args)
+    end
+    
+    ## Client specific details
+    
+    def self.run
+      self.setup # So we have options etc
+      logger.debug "Connecting to #{self.configuration.server}:#{self.configuration.port}"
+      self.new.run
+    end
+    
+    def self.stop
+      logger.debug "Telling all connections to quit"
+      self.connections.each do |connection|
+        connection.quit
+        logger.debug "Preparing to close socket"
+        connection.socket.close
+      end
+      logger.debug "Stopped."
+    end
+    
+    # Registers a callback handle that will be periodically run.
+    def periodically(timing, event_callback)
+      callback = proc { self.dispatch_event event_callback.to_sym }
+    end
+    
+  end
+end

data/lib/marvin/irc.rb

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

data/lib/marvin/loader.rb

@@ -0,0 +1,55 @@
+module Marvin
+  class Loader
+    
+    cattr_accessor :setup_block
+    
+    def self.before_connecting(&blk)
+      self.setup_block = blk
+    end
+    
+    def setup_defaults
+      Marvin::Logger.setup
+    end
+    
+    def load_handlers
+      handlers = Dir[Marvin::Settings.root / "handlers/**/*.rb"].map { |h| h[0..-4] }
+      handlers.each do |handler|
+        require handler
+      end
+    end
+    
+    def load_settings
+      Marvin::Settings.setup
+      Marvin::Settings.default_client.configuration = Marvin::Settings.to_hash
+      Marvin::Settings.default_client.setup
+    end
+    
+    def pre_connect_setup
+      Marvin::DataStore.load!
+      require(Marvin::Settings.root / "config/setup")
+      self.setup_block.call unless self.setup_block.blank?
+    end
+    
+    def run!
+      self.setup_defaults
+      self.load_settings
+      self.load_handlers
+      self.pre_connect_setup
+      Marvin::Settings.default_client.run
+    end
+    
+    def stop!
+      Marvin::Settings.default_client.stop
+      Marvin::DataStore.dump!
+    end
+    
+    def self.run!
+      self.new.run!
+    end
+    
+    def self.stop!
+      self.new.stop!
+    end
+    
+  end
+end

data/lib/marvin/logger.rb

@@ -0,0 +1,22 @@
+require 'logger'
+
+module Marvin
+  class Logger
+    
+    cattr_accessor :logger
+    
+    class << self
+      
+      def setup
+        self.logger ||= ::Logger.new(STDOUT)
+      end
+      
+      def method_missing(name, *args, &blk)
+       self.setup # Ensure the logger is setup
+       self.logger.send(name, *args, &blk)
+      end
+    
+    end
+    
+  end
+end

data/lib/marvin/middle_man.rb

@@ -0,0 +1,105 @@
+module Marvin
+  # The middle man is a class you can use to register
+  # other handlers on. e.g. it acts as a way to 'filter'
+  # incoming and outgoing messages. Akin to Rack / WSGI
+  # middleware.
+  class MiddleMan
+    
+    # Set the logger cattr to the default marvin logger.
+    cattr_accessor :logger
+    self.logger ||= Marvin::Logger
+    
+    # By default, we are *not* setup.
+    @@setup = false
+    
+    # Our list of subhandlers. We make sure
+    # the list is unique to our subclass / class.
+    class_inheritable_accessor :subhandlers
+    self.subhandlers = []
+    
+    # Finally, the client.
+    attr_reader :client
+  
+    # When we're told to set the client,
+    # not only do we set out own instance
+    # but we also echo the command down
+    # to all of our sub-clients.
+    def client=(new_client)
+      @client = new_client
+      setup_subhandler_clients
+    end
+    
+    def process_event(message, options)
+      return message, options
+    end
+    
+    # Filter incoming events.
+    def handle(message, options)
+      # Process the current event.
+      message, options = process_event(message, options)
+      full_handler_name = "handle_#{message}"
+      self.send(full_handler_name, opts) if respond_to?(full_handler_name)
+      self.subhandlers.each do |sh|
+        forward_message_to_handler(sh, message, options, full_handler_name)
+      end
+    rescue HaltHandlerProcessing
+      logger.info "Asked to halt the filter processing chain inside a middleman."
+    rescue Exception => e
+      logger.fatal "Exception processing handle #{message}"
+      Marvin::ExceptionTracker.log(e)
+    end
+    
+    class << self
+      
+      def setup?
+        @@setup
+      end
+      
+      # Forcefully do the setup routine.
+      def setup!
+        # Register ourselves as a new handler.
+        Marvin::Settings.default_client.register_handler self.new
+        @@setup = true
+      end
+      
+      # Setup iff setup hasn't been done.
+      def setup
+        return if self.setup?
+        self.setup!
+      end
+      
+      # Register a single subhandler.
+      def register_handler(handler, run_setup = true)
+        self.setup if run_setup
+        self.subhandlers << handler unless handler.blank?
+      end
+      
+      # Registers a group of subhandlers.
+      def register_handlers(*args)
+        self.setup
+        args.each { |h| self.register_handler(h, false) }
+      end
+      
+    end
+    
+    private
+    
+    def setup_subhandler_clients
+      self.subhandlers.each do |sh|
+        sh.client = self.client if sh.respond_to?(:client=)
+      end
+    end
+    
+    # This should probably be extracted into some sort of Util's library as
+    # it's shared across a couple of classes but I really can't be bothered
+    # at the moment - I just want to test the concept.
+    def forward_message_to_handler(handler, message, options, full_handler_name)
+      if handler.respond_to?(full_handler_name)
+        handler.send(full_handler_name, options)
+      elsif handler.respond_to?(:handle)
+        handler.handle message, options
+      end
+    end
+    
+  end
+end

data/lib/marvin/parsers/regexp_parser.rb

@@ -0,0 +1,94 @@
+module Marvin
+  module Parsers
+    class RegexpParser < Marvin::AbstractParser
+    
+      cattr_accessor :regexp_matchers, :events
+      # Since we cbf implemented an ordered hash, just use regexp => event at the same
+      # index.
+      self.regexp_matchers = []
+      self.events = []
+    
+      attr_accessor :current_line
+    
+      # Appends an event to the end of the the events callback
+      # chain. It will be search in order of first-registered
+      # when used to match a URL (hence, order matters).
+      def self.register_event(*args)
+        matcher = args.delete_at(1) # Extract regexp.
+        if args.first.is_a?(Marvin::IRC::Event)
+          event = args.first
+        else
+          event = Marvin::IRC::Event.new(*args)
+        end
+        self.regexp_matchers << matcher
+        self.events << event
+      end
+    
+    
+      # Initialize a new RegexpParser from the given line.
+      def initialize(line)
+        self.current_line = line
+      end
+    
+      def to_event
+        self.regexp_matchers.each_with_index do |matcher, offset|
+          if (match_data = matcher.match(self.current_line))
+            event = self.events[offset].dup
+            event.raw_arguments = match_data.to_a[1..-1]
+            return event
+          end
+        end
+        # otherwise, return nil
+        return nil
+      end
+    
+      ## The Default IRC Events
+    
+      # Note that some of these Regexp's are from Net::YAIL,
+      # which apparantly sources them itself from the IRCSocket
+      # library.
+    
+      register_event :invite,  /^\:(.+)\!\~?(.+)\@(.+) INVITE (\S+) :?(.+?)$/i,
+                     :nick, :ident, :host, :target, :channel
+                   
+      register_event :action,  /^\:(.+)\!\~?(.+)\@(.+) PRIVMSG (\S+) :?\001ACTION (.+?)\001$/i,
+                     :nick, :ident, :host, :target, :message
+                   
+      register_event :ctcp, /^\:(.+)\!\~?(.+)\@(.+) PRIVMSG (\S+) :?\001(.+?)\001$/i,
+                     :nick, :ident, :host, :target, :message
+    
+      register_event :message, /^\:(.+)\!\~?(.+)\@(.+) PRIVMSG (\S+) :?(.+?)$/i,
+                     :nick, :ident, :host, :target, :message
+                   
+      register_event :join,    /^\:(.+)\!\~?(.+)\@(.+) JOIN (\S+)/i,
+                     :nick, :ident, :host, :target               
+                   
+      register_event :part,    /^\:(.+)\!\~?(.+)\@(.+) PART (\S+)\s?:?(.+?)$/i,
+                     :nick, :ident, :host, :target, :message
+                   
+      register_event :mode,    /^\:(.+)\!\~?(.+)\@(.+) MODE (\S+) :?(.+?)$/i,
+                     :nick, :ident, :host, :target, :mode               
+
+      register_event :kick,    /^\:(.+)\!\~?(.+)\@(.+) KICK (\S+) (\S+)\s?:?(.+?)$/i,
+                     :nick, :ident, :host, :target, :channel, :reason
+                   
+      register_event :topic,  /^\:(.+)\!\~?(.+)\@(.+) TOPIC (\S+) :?(.+?)$/i,
+                     :nick, :ident, :host, :target, :topic
+                   
+      register_event :nick,    /^\:(.+)\!\~?(.+)\@(.+) NICK :?(.+?)$/i,
+                     :nick, :ident, :host, :new_nick
+
+      register_event :quit,    /^\:(.+)\!\~?(.+)\@(.+) QUIT :?(.+?)$/i,
+                     :nick, :ident, :host, :message
+                   
+      register_event :nick_taken, /^\:(\S+) 433 \* (\w+) :(.+)$/,
+                     :server, :target, :message
+                   
+      register_event :ping,   /^\:(.+)\!\~?(.+)\@(.+) PING (.*)$/,
+                     :nick, :ident, :host, :data
+
+      register_event :numeric, /^\:(\S+) ([0-9]+) (.*)$/,
+                     :host, :code, :data
+    end 
+  end
+end

data/lib/marvin/parsers.rb

@@ -0,0 +1,7 @@
+module Marvin
+  module Parsers
+    # Default Parsers
+    autoload :RegexpParser, 'marvin/parsers/regexp_parser'
+    
+  end
+end

data/lib/marvin/settings.rb

@@ -0,0 +1,73 @@
+require 'yaml'
+
+module Marvin
+  class Settings
+    
+    cattr_accessor :environment, :configuration, :is_setup, :default_client, :handler_folder, :default_parser
+    
+    class << self
+      
+      def root
+        defined?(MARVIN_ROOT) ? MARVIN_ROOT : File.dirname(__FILE__) / "../.."
+      end
+      
+      def setup(options = {})
+        return if self.is_setup
+        self.setup!(options)
+      end
+      
+      def setup!(options = {})
+        self.environment ||= "development"
+        self.configuration = {}
+        self.default_client ||= begin
+                                  require 'eventmachine'
+                                  Marvin::IRC::Client
+                                rescue LoadError
+                                  Marvin::IRC::SocketClient
+                                end
+        self.default_parser ||= Marvin::Parsers::RegexpParser
+        loaded_yaml = YAML.load_file(root / "config/settings.yml")
+        loaded_options = loaded_yaml["default"].
+                           merge(loaded_yaml[self.environment]).
+                           merge(options)
+        self.configuration.merge!(loaded_options)
+        self.configuration.symbolize_keys!
+        mod = Module.new do
+          Settings.configuration.keys.each do |k|
+            define_method(k) do
+              return Settings.configuration[k]
+            end
+          
+            define_method("#{k}=") do |val|
+              Settings.configuration[k] = val
+            end
+          end
+        end
+        
+        # Extend and include.
+        
+        extend  mod
+        include mod
+        
+        self.is_setup = true
+      end
+      
+      def [](key)
+        self.setup
+        return self.configuration[key.to_sym]
+      end
+      
+      def []=(key, value)
+        self.setup
+        self.configuration[key.to_sym] = value
+        return value
+      end
+      
+      def to_hash
+        self.configuration
+      end
+      
+    end
+
+  end
+end