Sutto-marvin 0.4.0 → 0.8.0.0

data/lib/marvin/dsl.rb

@@ -0,0 +1,103 @@
+# Handy Dandy DSL style stuff for Marvin
+module Marvin
+  class DSL
+  
+    class Proxy < Perennial::Proxy
+      
+      def initialize(klass)
+        @prototype_klass = Class.new(klass)
+        @mapping         = {}
+      end
+      
+      def define_shortcut(name, method_name)
+        @mapping[name] = method_name
+      end
+      
+      def shortdef(hash = {})
+        hash.each_pair { |k,v| define_shortcut(k, v) }
+      end
+      
+      
+      
+      def initialize_class!
+        @klass = Class.new(@prototype_klass)
+      end
+      
+      def to_instance
+        @klass.new
+      end
+      
+      def to_class
+        @klass
+      end
+      
+      def method_missing(name, *args, &blk)
+        name = name.to_sym
+        if @mapping.has_key?(name)
+          @klass.define_method(@mapping[name], &blk)
+        else
+          @klass.send(name, *args, &blk)
+        end
+      end
+      
+    end
+  
+    def initialize(&blk)
+      instance_eval(&blk)
+    end
+    
+    def logging(&blk)
+      call_prototype(:logging, &blk).register!
+    end
+    
+    def handler(&blk)
+      call_prototype(:handler, &blk).register!
+    end
+    
+    def commands(&blk)
+      call_prototype(:commands, &blk).register!
+    end
+    
+    def configure(&blk)
+      Marvin::Settings.client.configure(&blk)
+    end
+    
+    def server(name, port = nil)
+      name = name.to_s.dup
+    end
+      
+    
+    
+    protected
+    
+    def initialize_prototypes
+      prototype_for(:logging, Marvin::LoggingHandler) do
+        shortdef :setup    => :setup_logging,
+                 :teardown => :teardown_logging,
+                 :incoming => :log_incoming,
+                 :outgoing => :log_outgoing,
+                 :message  => :log_message
+      end
+      prototype_for(:handler, Marvin::Base) do
+        map :on      => :on_event,
+            :numeric => :on_numeric
+      end
+      prototype_for(:handler, Marvin::CommandHandler)
+    end
+    
+    def prototype_for(name, klass, &blk)
+      @prototypes ||= {}
+      p = Proxy.new(klass)
+      p.instance_eval(&blk)
+      @prototypes[name] = p
+    end
+    
+    def call_prototype(name, &blk)
+      p = @prototypes[name]
+      p.initialize_class!
+      p.instance_eval(&blk)
+      return p.to_class
+    end
+    
+  end
+end

data/lib/marvin/exception_tracker.rb

@@ -1,15 +1,18 @@
 module Marvin
   class ExceptionTracker
   
-    cattr_accessor :logger
-    self.logger = Marvin::Logger
+    is :loggable
+    
+    cattr_accessor :log_exception_proc
+    self.log_exception_proc = proc { |e| e }
   
     def self.log(e)
-      logger.fatal "Exception raised inside Marvin Instance."
-      logger.fatal "#{e} - #{e.message}"
+      logger.fatal "Oh noes cap'n - we have an exception!."
+      logger.fatal "#{e.class.name}: #{e.message}"
       e.backtrace.each do |line|
         logger.fatal line
       end
+      @@log_exception_proc.call(e)
     end
   
   end

data/lib/marvin/irc/client.rb

@@ -1,138 +1,166 @@
 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
-    cattr_accessor :stopped
-    self.stopped = false
+    
+    @@stopped = false
     
     attr_accessor :em_connection
     
     class EMConnection < EventMachine::Protocols::LineAndTextProtocol
-      attr_accessor :client, :server, :port
+      is :loggable
+      
+      attr_accessor :client, :port, :configuration
       
       def initialize(*args)
-        opts = args.extract_options!
+        @configuration = args.last.is_a?(Marvin::Nash) ? args.pop : Marvin::Nash.new
         super(*args)
-        self.client = Marvin::IRC::Client.new(opts)
-        self.client.em_connection = self
+        @client = Marvin::IRC::Client.new(@configuration)
+        @client.em_connection = self
+        @connected = false
+      rescue Exception => e
+        Marvin::ExceptionTracker.log(e)
+        Marvin::IRC::Client.stop
       end
       
       def post_init
-        client.process_connect
         super
+        if should_use_ssl?
+          logger.info "Starting SSL for #{host_with_port}"
+          start_tls
+        else
+          connected!
+        end
+      rescue Exception => e
+        Marvin::ExceptionTracker.log(e)
+        Marvin::IRC::Client.stop
+      end
+      
+      def ssl_handshake_completed
+        logger.info "SSL handshake completed for #{host_with_port}"
+        connected! if should_use_ssl?
+      rescue Exception => e
+        Marvin::ExceptionTracker.log(e)
+        Marvin::IRC::Client.stop
       end
 
       def unbind
-        client.process_disconnect
+        @client.process_disconnect
         super
       end
       
       def receive_line(line)
-        Marvin::Logger.debug "<< #{line.strip}"
-        self.client.receive_line(line)
+        return unless @connected
+        line = line.strip
+        logger.debug "<< #{line}"
+        @client.receive_line(line)
+      rescue Exception => e
+        logger.warn "Uncaught exception raised; Likely in Marvin"
+        Marvin::ExceptionTracker.log(e)
       end
       
-    end
-
-    def send_line(*args)
-      args.each { |line| Marvin::Logger.debug ">> #{line.strip}" }
-      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(force = false)
-      return if self.stopped && !force
-      self.setup # So we have options etc
-      settings = YAML.load_file(Marvin::Settings.root / "config/connections.yml")
-      if settings.is_a?(Hash)
-        # Use epoll if available
-        EventMachine.epoll
-        EventMachine::run do
-          settings.each do |name, options|
-            settings = options.symbolize_keys!
-            settings[:server] ||= name
-            settings.reverse_merge!(:port => 6667, :channels => [])
-            connect settings
-          end
+      def send_line(*lines)
+        return unless @connected
+        lines.each do |line|
+          logger.debug ">> #{line.strip}"
+          send_data line
         end
-      else
-        logger.fatal "config/connections.yml couldn't be loaded. Exiting"
       end
+      
+      def connected!
+        @connected = true
+        @client.process_connect
+      end
+      
+      def should_use_ssl?
+        @should_use_ssl ||= @configuration.ssl?
+      end
+      
+      def host_with_port
+        "#{@configuration.host}:#{@configuration.port}"
+      end
+      
     end
     
-    def self.connect(opts = {})
-      logger.info "Connecting to #{opts[:server]}:#{opts[:port]} - Channels: #{opts[:channels].join(", ")}"
-      EventMachine::connect(opts[:server], opts[:port], EMConnection, opts)
-    end
+    ## Client specific details
     
-    def self.stop
-      return if self.stopped
-      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."
-      self.stopped = true
+    def send_line(*args)
+      @em_connection.send_line(*args)
     end
     
-    def self.add_reconnect(opts = {})
-      Marvin::Logger.warn "Adding entry to reconnect to #{opts[:server]}:#{opts[:port]} in 15 seconds"
-      EventMachine::add_timer(15) do
-        Marvin::Logger.warn "Attempting to reconnect to #{opts[:server]}:#{opts[:port]}"
-        Marvin::IRC::Client.connect(opts)
+    class << self
+      
+      # Starts the EventMachine loop and hence starts up the actual
+      # networking portion of the IRC Client.
+      def run(opts = {}, force = false)
+        self.development = opts[:development]
+        return if @stopped && !force
+        self.setup # So we have options etc
+        connections_file = Marvin::Settings.root / "config" / "connections.yml"
+        connections = Marvin::Nash.load_file(connections_file) rescue nil
+        if connections.present?
+          # Use epoll if available
+          EventMachine.kqueue
+          EventMachine.epoll
+          EventMachine.run do
+            connections.each_pair do |server, configuration|
+              connect(configuration.merge(:server => server.to_s))
+            end
+            Marvin::Distributed::Server.start if Marvin::Distributed::Handler.registered?
+            @@stopped = false
+          end
+        else
+          logger.fatal "config/connections.yml couldn't be loaded."
+        end
       end
+
+      def connect(c, &blk)
+        c = normalize_connection_options(c)
+        raise ArgumentError, "Your connection options must specify a server" if !c.server?
+        raise ArgumentError, "Your connection options must specify a port"   if !c.port?
+        real_block = blk.present? ? proc { |c| blk.call(connection.client) } : nil
+        logger.info "Connecting to #{c.server}:#{c.port} (using ssl: #{c.ssl?}) - Channels: #{c.channels.join(", ")}"
+        EventMachine.connect(c.server, c.port, EMConnection, c, &real_block)
+      end
+
+      def stop
+        return if @@stopped
+        logger.debug "Telling all connections to quit"
+        connections.dup.each { |connection| connection.quit }
+        logger.debug "Telling Event Machine to Stop"
+        EventMachine.stop_event_loop
+        logger.debug "Stopped."
+        @@stoped = true
+      end
+
+      def add_reconnect(c)
+        logger.warn "Adding timer to reconnect to #{c.server}:#{c.port} in 15 seconds"
+        EventMachine.add_timer(15) do
+          logger.warn "Preparing to reconnect to #{c.server}:#{c.port}"
+          connect(c)
+        end
+      end
+      
+      protected
+      
+      def normalize_connection_options(config)
+        config = Marvin::Nash.new(config) if !config.is_a?(Marvin::Nash)
+        config = config.normalized
+        channels = config.channels
+        if channels.present?
+          config.channels = [*channels].compact.reject { |c| c.blank? }
+        else
+          config.channels = []
+        end
+        config.host ||= config.server
+        return config
+      end
+      
     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)
+      EventMachine.add_periodic_timer(timing) { dispatch(event_callback.to_sym) }
     end
     
   end

data/lib/marvin/irc/event.rb

@@ -3,32 +3,36 @@ module Marvin::IRC
     attr_accessor :keys, :name, :raw_arguments, :prefix
     
     def initialize(name, *args)
-      self.name = name.to_sym
-      self.keys = args.flatten.map { |k| k.to_sym }
+      @name = name.to_sym
+      @keys = args.flatten.map { |k| k.to_sym }
     end
     
     def to_hash
       return @hash_value unless @hash_value.blank?
       results = {}
-      values = self.raw_arguments.to_a
-      last_index = self.keys.size - 1
-      self.keys.each_with_index do |key, i|
+      values = @raw_arguments.to_a
+      last_index = @keys.size - 1
+      @keys.each_with_index do |key, i|
         results[key] = (i == last_index ? values.join(" ").strip : values.shift)
       end
-      results.merge!(prefix.to_hash) unless prefix.blank?
-      return (@hash_value = results)
+      results.merge!(@prefix.to_hash) unless @prefix.blank?
+      @hash_value = results
     end
     
     def inspect
-      "#<Marvin::IRC::Event name=#{self.name} attributes=#{self.to_hash.inspect} >"
+      "#<Marvin::IRC::Event name=#{@name} attributes=#{to_hash.inspect} >"
+    end
+    
+    def to_event_name(prefix = nil)
+      [prefix, @name].join("_").to_sym
     end
     
     def to_incoming_event_name
-      :"incoming_#{self.name}"
+      to_event_name :incoming
     end
     
     def to_outgoing_event_name
-      :"outgoing_#{self.name}"
+      to_event_name :outgoing
     end
     
   end

data/lib/marvin/irc.rb

@@ -2,7 +2,6 @@ module Marvin
   module IRC
     autoload :Client,  'marvin/irc/client'
     autoload :Event,   'marvin/irc/event'
-    autoload :Server,  'marvin/irc/server'
     autoload :Replies, 'marvin/irc/replies'
   end
 end

data/lib/marvin/middle_man.rb

@@ -58,7 +58,7 @@ module Marvin
       # Forcefully do the setup routine.
       def setup!
         # Register ourselves as a new handler.
-        Marvin::Settings.default_client.register_handler self.new
+        Marvin::Settings.client.register_handler self.new
         @@setup = true
       end
       

data/lib/marvin/parsers/command.rb

@@ -20,16 +20,18 @@ module Marvin
       # attempt to recognize the command and convert
       # it to an event which can be used for other stuff.
       def to_event
-        if self.code =~ /^\d+$/
+        # If we have a numeric...
+        if @code =~ /^\d+$/
           ev = @@commands[:numeric].dup
           data = @params[0..-2]
           data << "#{@params.last.include?(" ") ? ":" : ""}#{@params.last}"
           ev.raw_arguments = [self.code.to_s, data.join(" ")]
-        elsif code == "PRIVMSG" && params.last[0] == 1 && params.last[-1] == 1
-          if params.last[0..8] == "\001ACTION: "
-            name, value = :action, params.last[9..-2]
+        elsif code == "PRIVMSG" && params.last =~ /^\001(.*)\001$/
+          results = $1.to_s
+          if results =~ /^ACTION /
+            name, value = :action, results.gsub(/^ACTION /, '')
           else
-            name, value = :ctcp, params.last[1..-2]
+            name, value = :ctcp, results
           end
           self.params[-1] = value
           ev = @@commands[name].dup
@@ -96,9 +98,9 @@ module Marvin
       register_event :ison,     :ISON,     :nick
       # 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
+      # And a few others reserved for special purposes
+      register_event :action,  :action,  :target, :message
+      register_event :ctcp,    :ctcp,    :target, :message
       
     end
   end

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

@@ -3,25 +3,30 @@ module Marvin
     module Prefixes
       # A Generic host mask prefix for a message.
       class HostMask
-        attr_accessor :nickname, :user, :host
+        attr_accessor :nick, :user, :host
         
-        def initialize(nickname = nil, user = nil, host = nil)
-          self.nickname = nickname || ""
-          self.user     = user || ""
-          self.host     = host || ""
+        def initialize(nick = nil, user = nil, host = nil)
+          @nick = nick || ""
+          @user = user || ""
+          @host = host || ""
         end
         
         # Convert it to a usable hash.
         def to_hash
-          {:nick => @nickname.freeze, :ident => @user.freeze, :host => @host.freeze}
+          {
+            :nick => @nick.dup.freeze,
+            :ident => @user.dup.freeze,
+            :host => @host.dup.freeze
+          }
         end
         
         # Converts it back to a nicer form / a string.
         def to_s
           str = ""
-          str << @nickname.to_s
+          str << @nick.to_s
           str << "!#{@user}" unless @user.blank?
           str << "@#{@host}" unless @host.blank?
+          str
         end
         
       end

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

@@ -7,7 +7,7 @@ module Marvin
         attr_accessor :name
         
         def initialize(name = nil)
-          self.name = name || ""
+          @name = name.to_s
         end
         
         def to_hash