jeffrafter-marvin 0.1.20081115

data/lib/marvin/command_handler.rb

@@ -0,0 +1,62 @@
+module Marvin
+  
+  # A Simple Marvin handler based on processing
+  # commands, similar in design to MatzBot.
+  class CommandHandler < Base
+    
+    class_inheritable_accessor :exposed_methods, :command_prefix
+    
+    self.command_prefix  = ""
+    self.exposed_methods = []
+    
+    class << self
+      
+      def exposes(*args)
+        self.exposed_methods ||= []
+        self.exposed_methods += args.map { |a| a.to_sym }.flatten
+      end
+      
+    end
+    
+    on_event :incoming_message do
+      logger.debug "Incoming message"
+      check_for_commands
+    end
+    
+    def check_for_commands
+      data, command = nil, nil
+      if self.from_channel?
+        logger.debug "Processing command in channel"
+        split_message = options.message.split(" ", 3)
+        prefix = split_message.shift
+        # Return if in channel and it isn't address to the user.
+        return unless prefix == "#{self.client.nickname}:"
+        command, data = split_message # Set remaining.
+      else
+        command, data = options.message.split(" ", 2)
+      end
+      # Double check for sanity
+      return if command.blank?
+      command_name = extract_command_name(command)
+      unless command_name.nil?
+        logger.debug "Command Exists - processing"
+        # Dispatch the command.
+        self.send(command_name, data.to_a) if self.respond_to?(command_name)
+      end
+    end
+    
+    def extract_command_name(command)
+      prefix_length = self.command_prefix.to_s.length
+      has_prefix = command[0...prefix_length] == self.command_prefix.to_s
+      logger.debug "Debugging, prefix is #{prefix_length} characters, has prefix? = #{has_prefix}"
+      if has_prefix
+        # Normalize the method name
+        method_name = command[prefix_length..-1].to_s.underscore.to_sym
+        logger.debug "Computed method name is #{method_name.inspect}"
+        return method_name if self.exposed_methods.to_a.include?(method_name)
+      end
+    end
+    
+  end
+  
+end

data/lib/marvin/core_ext.rb

@@ -0,0 +1,11 @@
+class File
+  def self.present_dir
+    File.dirname(__FILE__)
+  end
+end
+
+class String
+  def /(*args)
+    File.join(self, *args)
+  end
+end

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/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/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/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/abstract_server.rb

@@ -0,0 +1,4 @@
+module Marvin::IRC
+  class AbstractServer
+  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

@@ -0,0 +1,105 @@
+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
+        client.process_connect
+      end
+
+      def unbind
+        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_callback.to_sym }
+      EventMachine::add_periodic_timer(timing, &callback)
+    end
+    
+  end
+  
+end

data/lib/marvin/irc/event.rb

@@ -0,0 +1,30 @@
+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
+      last_index = self.keys.size - 1
+      self.keys.each_with_index do |key, i|
+        results[key] = (i == last_index ? values.join(" ").strip : 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,69 @@
+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_callback.to_sym }
+      Thread.new do
+        while true
+          callback.call
+          sleep timing
+        end
+      end
+    end
+    
+  end
+end

data/lib/marvin/irc.rb

@@ -0,0 +1,9 @@
+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'
+    autoload :BaseServer,     'marvin/irc/base_server'
+  end
+end

data/lib/marvin/loader.rb

@@ -0,0 +1,68 @@
+module Marvin
+  class Loader
+    
+    cattr_accessor :setup_block
+    
+    cattr_accessor :start_hooks, :stop_hooks
+    self.stop_hooks, self.start_hooks = [], []
+    
+    def self.before_connecting(&blk)
+      self.setup_block = blk
+    end
+    
+    def setup_defaults
+      Marvin::Logger.setup
+    end
+    
+    def self.before_run(&blk)
+      self.start_hooks << blk unless blk.blank?
+    end
+    
+    def self.after_stop(&blk)
+      self.stop_hooks << blk unless blk.blank?
+    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
+      self.start_hooks.each { |h| h.call }
+      Marvin::Settings.default_client.run
+    end
+    
+    def stop!
+      Marvin::Settings.default_client.stop
+      self.stop_hooks.each { |h| h.call }
+      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,23 @@
+require 'logger'
+
+module Marvin
+  class Logger
+    
+    cattr_accessor :logger
+    
+    class << self
+      
+      def setup
+        log_path = Marvin::Settings.root / "log/#{Marvin::Settings.environment}.log"
+        self.logger ||= ::Logger.new(Marvin::Settings.daemon? ? log_path : 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