jeffrafter-marvin 0.1.20081115

data/lib/marvin/middle_man.rb

@@ -0,0 +1,103 @@
+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 { |sh| sh.client = self.client if sh.respond_to?(:client=) }
+    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,96 @@
+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 :ping,  /PING (.*)$/, :data
+
+      register_event :numeric, /^\:(\S+) ([0-9]+) (.*)$/,
+                     :server, :code, :data
+    end 
+  end
+end

data/lib/marvin/parsers/simple_parser/default_events.rb

@@ -0,0 +1,37 @@
+class Marvin::Parsers::SimpleParser < Marvin::AbstractParser
+  module DefaultEvents
+    
+    def self.included(parent)
+      parent.class_eval do
+        extend ClassMethods
+        # Register the default set of events with commands
+        register_event :nick,    :NICK,    :new_nick
+        register_event :quit,    :QUIT,    :message
+        register_event :ping,    :PING,    :data
+        register_event :join,    :JOIN,    :target
+        register_event :invite,  :INVITE,  :target,  :channel
+        register_event :message, :PRIVMSG, :target,  :message
+        register_event :part,    :PART,    :target,  :message
+        register_event :mode,    :MODE,    :target,  :mode               
+        register_event :kick,    :KICK,    :target,  :channel, :reason
+        register_event :topic,   :TOPIC,   :target,  :topic
+        # Add the default numeric event
+        register_event :numeric, :numeric, :code, :data
+        # And a few others reserved for special purposed
+        register_event :action,  :action,  :message
+        register_event :ctcp,    :ctcp,    :message
+      end
+    end
+    
+    module ClassMethods
+      
+      # Register an event from a given name,
+      # command as well as a set of arguments.
+      def register_event(name, command, *args)
+        event = Marvin::Parsers::SimpleParser::EventWithPrefix.new(name, *args)
+        self.events[command] = event
+      end
+      
+    end
+  end
+end

data/lib/marvin/parsers/simple_parser/event_extensions.rb

@@ -0,0 +1,14 @@
+# An extension to Marvin::IRC::Event which
+# lets a user specify a prefix to use.
+class Marvin::Parsers::SimpleParser < Marvin::AbstractParser
+  
+  class EventWithPrefix < Marvin::IRC::Event
+    attr_accessor :prefix
+    
+    def to_hash
+      super.merge(prefix.blank? ? {} : prefix.to_hash)
+    end
+    
+  end
+  
+end

data/lib/marvin/parsers/simple_parser/prefixes.rb

@@ -0,0 +1,34 @@
+# A Set of prefixes for a given IRC line
+# as parsed from an incoming line.
+class Marvin::Parsers::SimpleParser < Marvin::AbstractParser
+  
+  class Prefix; end
+  
+  class ServerNamePrefix < Prefix
+    attr_accessor :server_name
+    
+    def initialize(name)
+      self.server_name = name
+    end
+    
+    def to_hash
+      {:server => self.server_name}
+    end
+    
+  end
+  
+  class UserPrefix < Prefix
+    attr_accessor :nick, :ident, :host
+    
+    def initialize(nick, ident = nil, host = nil)
+      self.nick = nick
+      self.ident = ident
+      self.host = host
+    end
+    
+    def to_hash
+      {:host => self.host, :nick => self.nick, :ident => self.ident}
+    end
+  end
+  
+end

data/lib/marvin/parsers/simple_parser.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) / "simple_parser/prefixes"
+require File.dirname(__FILE__) / "simple_parser/event_extensions"
+require File.dirname(__FILE__) / "simple_parser/default_events"
+
+module Marvin
+  module Parsers
+    class SimpleParser < Marvin::AbstractParser
+      
+      cattr_accessor :events
+      self.events ||= {}
+      
+      attr_accessor :arguments, :prefix, :current_line, :parts, :event
+      
+      def initialize(line)
+        self.current_line = line
+        parse!
+      end
+      
+      def to_event
+        if self.event.blank?
+          parse!
+          return nil
+        else
+          return self.event
+        end
+      end
+      
+      private
+    
+      def parse!
+        # Split the message
+        line = self.current_line
+        if line[0] == ?:
+          prefix_text, line = line.split(" ", 2)
+        else
+          prefix_text = nil
+        end
+        extract_prefix! prefix_text
+        
+        head, tail = line.split(":", 2)
+        self.parts = head.split(" ")
+        self.parts << tail
+        command = self.parts.shift.upcase.to_sym
+        if command.to_s =~ /^[0-9]{3}$/
+          # Other Command
+          self.parts.unshift(command.to_s) # Reappend the command
+          process_event self.events[:numeric]
+        elsif self.events.has_key? command
+          # Registered Command
+          process_event self.events[command]
+        else
+          # Unknown Command
+          self.event = nil
+        end
+      end
+      
+      def process_event(prototype, skip_mutation = false)
+        self.event = prototype.dup
+        self.event.prefix = self.prefix
+        self.event.raw_arguments = self.parts
+        mutate_event! unless skip_mutation
+      end
+      
+      def mutate_event!
+        # Do nothing by default
+        name, contents = self.event.name, self.event.raw_arguments.last
+        # mutate for ctcp and actions
+        if name == :message && contents[0..0] == "\001" && contents[-1..-1] == "\001"
+          if message.index("ACTION: ") == 1
+            message = message[9..-2]
+            new_event = :action
+          else
+            message = message[1..-2]
+            new_event = :ctcp
+          end
+          self.parts = [message]
+          process_event self.events[new_event], true
+        end
+      end
+      
+      def extract_prefix!(text)
+        return if text.blank?
+        full_prefix = text[1..-1]
+        prefix = full_prefix
+        # Ugly regexp for nick!ident@host format
+        # Officially this should be less-terse, but hey
+        # it's a simple parser.
+        if full_prefix =~ /^([^@!]+)\!\~?([^@]+)@(.*)$/
+          prefix = UserPrefix.new($1, $2, $3)
+        else
+          # TODO: Validate the hostname here.
+          prefix = ServerNamePrefix.new(prefix.strip)
+        end
+        self.prefix = prefix
+        return prefix
+      end
+      
+      include DefaultEvents
+    end 
+  end
+end

data/lib/marvin/parsers.rb

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

data/lib/marvin/settings.rb

@@ -0,0 +1,77 @@
+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 daemon?
+        defined?(IS_DAEMON) && IS_DAEMON
+      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

data/lib/marvin/test_client.rb

@@ -0,0 +1,60 @@
+require 'ostruct'
+require 'active_support'
+
+module Marvin
+  # Marvin::TestClient is a simple client used for testing
+  # Marvin::Base derivatives in a non-network-reliant setting.
+  class TestClient < AbstractClient
+    attr_accessor :incoming_commands, :outgoing_commands, :last_sent, :dispatched_events, :connection_open
+    
+    cattr_accessor :instances
+    self.instances = []
+    
+    DispatchedEvents = Struct.new(:name, :options)
+    
+    def initialize
+      super
+      self.incoming_commands = []
+      self.outgoing_commands = []
+      self.dispatched_events = []
+      self.connection_open   = false
+      self.instances << self
+    end
+    
+    def connection_open?
+      self.connection_open
+    end
+    
+    def send_line(*args)
+      self.outgoing_commands += args
+      self.last_sent = args.last
+    end
+    
+    def test_command(name, *args)
+      options = args.extract_options!
+      host_mask = options.delete(:host_mask) || ":WiZ!jto@tolsun.oulu.fi"
+      name = name.to_s.upcase
+      args = args.flatten.compact
+      irc_command = "#{host_mask} #{name} #{args.join(" ").strip}"
+      self.receive_line irc_command
+    end
+    
+    def dispatch(name, opts = {})
+      self.dispatched_events << [name, opts]
+      super(name, opts)
+    end
+    
+    def self.run
+      self.instances.each do |i|
+        i.connection_open = true
+      end
+    end
+    
+    def self.stop
+      self.instances.each do |i|
+        i.connection_open = false
+      end
+    end
+    
+  end
+end

data/lib/marvin/util.rb

@@ -0,0 +1,30 @@
+module Marvin
+  module Util
+      
+      # Return the channel-name version of a string by
+      # appending "#" to the front if it doesn't already
+      # start with it.
+      def channel_name(name)
+        return name.to_s[0..0] == "#" ? name.to_s : "##{name}"
+      end
+      alias chan channel_name
+      
+      def arguments(input)
+        prefix, *ending = input.split(":")
+        prefix = prefix.split(" ")
+        prefix << ending.join(":").strip
+        return prefix
+      end
+
+      # Specifies the last parameter of a response, used to
+      # specify parameters which have spaces etc (for example,
+      # the actual message part of a response).
+      def last_param(section)
+        section && ":#{section.to_s.strip} "
+      end
+      alias lp last_param
+     
+      extend self
+     
+  end
+end

data/lib/marvin.rb

@@ -0,0 +1,44 @@
+$:.unshift File.dirname(__FILE__) # Append the current working dir to the front of the line.
+
+require 'rubygems'
+require 'active_support'
+require 'marvin/core_ext'
+
+# Make all exceptions available
+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'
+  autoload :Settings,         'marvin/settings'
+  autoload :Logger,           'marvin/logger'
+  autoload :IRC,              'marvin/irc'
+  autoload :TestClient,       'marvin/test_client'
+  autoload :Loader,           'marvin/loader'
+  autoload :MiddleMan,        'marvin/middle_man'
+  autoload :DRBHandler,       'marvin/drb_handler'
+  autoload :DataStore,        'marvin/data_store'
+  autoload :ExceptionTracker, 'marvin/exception_tracker'
+  # Parsers
+  autoload :AbstractParser,   'marvin/abstract_parser'
+  autoload :Parsers,          'marvin/parsers.rb'
+  
+  # Default Handlers
+  autoload :CommandHandler, 'marvin/command_handler'
+  
+  Settings.setup # Load Settings etc.
+  
+end
+
+def p(text)
+  res = Marvin::Parsers::SimpleParser.parse(text)
+  if res.blank?
+    puts "Unrecognized Result"
+  else
+    STDOUT.puts "Event: #{res.to_incoming_event_name}"
+    STDOUT.puts "Args:  #{res.to_hash.inspect}"
+  end
+end

data/script/daemon-runner

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'daemons'
+
+DIR = File.join(File.dirname(__FILE__), "..")
+
+Daemons.run(File.join(DIR, "script/run --is-daemon"),
+            {:mode => :exec,
+             :dir => DIR,
+             :dir_mode => :normal,
+             :log_output => true,
+             :app_name => 'marvin'})

data/script/run

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+
+if File.exist?(File.dirname(__FILE__) + "/../lib/marvin.rb")
+  $:.unshift(File.dirname(__FILE__) + "/../lib/")
+end
+
+MARVIN_ROOT = File.join(File.dirname(__FILE__), "..")
+IS_DAEMON = ARGV.include?("--is-daemon")
+
+# And Require Marvin.
+require 'marvin'
+
+["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