Sutto-marvin 0.4.0 → 0.8.0.0

data/lib/marvin/base.rb

@@ -1,131 +1,147 @@
-require 'ostruct'
-
 module Marvin
-  # A Client Handler
+  
+  def self.handler_parent_classes
+    @@handler_parent_classes ||= Hash.new { |h,k| h[k] = Set.new }
+  end
+  
   class Base
+    is :loggable
     
-    cattr_accessor :logger
-    # Set the default logger
-    self.logger ||= Marvin::Logger
-    
-    attr_accessor :client, :target, :from, :options, :logger
-    class_inheritable_accessor :registered_handlers
-    self.registered_handlers = {}
-    
-    def initialize
-      self.registered_handlers ||= {}
-      self.logger ||= Marvin::Logger
+    @@handlers = Hash.new do |h,k|
+      h[k] = Hash.new { |h2, k2| h2[k2] = [] }
     end
     
+    attr_accessor :client, :target, :from, :options
+    
     class << self
+        
+      def registered?
+        @registered ||= false
+      end
+      
+      def registered=(value)
+        @registered = !!value
+      end
       
-      def event_handlers_for(message_name, direct = true)
-        return [] if self == Marvin::Base
-        rh = (self.registered_handlers ||= {})
-        rh[self.name] ||= {}
-        rh[self.name][message_name] ||= []
-        if direct
-          found_handlers = rh[self.name][message_name]
-          found_handlers += self.superclass.event_handlers_for(message_name)
-          return found_handlers
-        else
-          return rh[self.name][message_name]
+      # Returns an array of all handlers associated with
+      # a specific event name (e.g. :incoming_message)
+      def event_handlers_for(message_name)
+        message_name = message_name.to_sym
+        items = []
+        klass = self
+        while klass != Object
+          items += @@handlers[klass][message_name]
+          klass = klass.superclass
         end
+        items
       end
       
-      # Registers a block or method to be called when
-      # a given event is occured.
-      # == Examples
-      #
-      #   on_event :incoming_message, :process_commands
-      # 
-      # Will call process_commands the current object
-      # every time incoming message is called.
-      #
-      #   on_event :incoming_message do
-      #     Marvin::Logger.debug ">> #{options.inspect}"
-      #   end
-      #
-      # Will invoke the block every time an incoming message
-      # is processed.
+      # Registers a block to be used as an event handler. The first
+      # argument is always the name of the event and the second
+      # is either a method name (e.g. :my_awesome_method) or
+      # a block (which is instance_evaled)
       def on_event(name, method_name = nil, &blk)
-        # If the name is set and it responds to :to_sym
-        # and no block was passed in.
-        blk = proc { self.send(method_name.to_sym) } if method_name.respond_to?(:to_sym) && blk.blank?
-        self.event_handlers_for(name, false) << blk
+        blk = proc { self.send(method_name) } if method_name.present?
+        @@handlers[self][name] << blk
       end
       
+      # Like on_event but instead of taking an event name it takes
+      # either a number or a name - corresponding to an IRC numeric
+      # reply.
       def on_numeric(value, method_name = nil, &blk)
-        if value.is_a?(Numeric)
-          new_value = "%03d" % value
-        else
-          new_value = Marvin::IRC::Replies[value]
-        end
-        if new_value.nil?
-          logger.error "The numeric '#{value}' was undefined"
-        else
-          blk = proc { self.send(method_name.to_sym) } if method_name.respond_to?(:to_sym) && blk.blank?
-          self.event_handlers_for(:"incoming_numeric_#{new_value}", false) << blk
-        end
+        value = value.is_a?(Numeric) ? ("%03d" % value) : Marvin::IRC::Replies[value]
+        on_event(:"incoming_numeric_#{new_value}", method_name, &blk) if value.present?
       end
       
-      # Register's in the IRC Client callback chain.
-      def register!(parent = Marvin::Settings.default_client)
+      # Register this specific handler on the IRC handler.
+      def register!(parent = Marvin::Settings.client)
         return if self == Marvin::Base # Only do it for sub-classes.
-        parent.register_handler self.new
+        parent.register_handler self.new unless parent.handlers.any? { |h| h.class == self }
+        Marvin.handler_parent_classes[self.name] << parent
       end
-      
-      def uses_datastore(datastore_name, local_name)
-        if Marvin::Loader.type == :distributed_client
-          Marvin::Logger.warn "Using datastores inside of a distributed client is a bad idea, mmmkay?"
+    
+      def reloading!
+        Marvin.handler_parent_classes[self.name].each do |dispatcher|
+          parent_handlers = dispatcher.handlers
+          related = parent_handlers.select { |h| h.class == self }
+          related.each do |h|
+            h.handle(:reloading, {})
+            dispatcher.delete_handler(h)
+          end
         end
-        cattr_accessor local_name.to_sym
-        self.send("#{local_name}=", Marvin::DataStore.new(datastore_name))
-        rescue Exception => e
-          logger.debug "Exception in datastore declaration - #{e.inspect}"
       end
       
+      def reloaded!
+        Marvin.handler_parent_classes[self.name].each do |dispatcher|
+          before = dispatcher.handlers
+          register!(dispatcher)
+          after = dispatcher.handlers
+          (after - before).each { |h| h.handle(:reloaded, {}) }
+        end
+        
+      end
+    
     end
     
-    # Given an incoming message, handle it appropriatly.
     def handle(message, options)
-      begin
-        self.setup_defaults(options)
-        h = self.class.event_handlers_for(message)
-        h.each { |handle| self.instance_eval(&handle) }
-      rescue Exception => e
-        logger.fatal "Exception processing handle #{message}"
-        Marvin::ExceptionTracker.log(e)
-      end
+      dup._handle(message, options)
+    end
+    
+    # Given an incoming message, handle it appropriately by getting all
+    # associated event handlers. It also logs any exceptions (aslong as
+    # they raised by halt)
+    def _handle(message, options)
+      setup_details(options)
+      h = self.class.event_handlers_for(message)
+      h.each { |eh| self.instance_eval(&eh) }
+    rescue Exception => e
+      # Pass on halt_handler_processing events.
+      raise e if e.is_a?(Marvin::HaltHandlerProcessing)
+      logger.fatal "Exception processing handler for #{message.inspect}"
+      Marvin::ExceptionTracker.log(e)
+    ensure
+      reset_details
     end
     
+    # The default handler for numerics. mutates them into a more
+    # friendly version of themselves. It will also pass through
+    # the original incoming_numeric event.
     def handle_incoming_numeric(opts)
-      self.handle(:incoming_numeric, opts)
-      name = :"incoming_numeric_#{options.code}"
-      events = self.class.event_handlers_for(name)
-      logger.debug "Dispatching #{events.size} events for #{name}"
-      events.each { |eh| self.instance_eval(&eh) }
+      handle(:incoming_numeric, opts)
+      handle(:"incoming_numeric_#{opts[:code]}", opts)
+    end
+    
+    # msg sends the given text to the current target, be it
+    # either a channel or a specific user.
+    def msg(message, target = self.target)
+      client.msg(target, message)
     end
     
-    def say(message, target = self.target)
-      client.msg target, message
+    alias say msg
+    
+    def action(message, target = self.target)
+      client.action(target, message)
     end
     
-    def pm(target, message)
-      say(target, message)
+    # A conditional version of message that will only send the message
+    # if the target / from is a user. To do this, it uses from_channel?
+    def pm(message, target)
+      say(message, target) unless from_channel?(target)
     end
     
+    # Replies to a message. if it was received in a channel, it will
+    # use the standard irc "Name: text" convention for replying whilst
+    # if it was in a direct message it sends it as is.
     def reply(message)
       if from_channel?
-        say "#{self.from}: #{message}"
+        say("#{from}: #{message}")
       else
-        say message, self.from # Default back to pm'ing the user
+        say(message, from)
       end
     end
     
     def ctcp(message)
-      return if from_channel? # Must be from user
-      say "\01#{message}\01", self.from
+      say("\01#{message}\01", from) if !from_channel?
     end
     
     # Request information
@@ -133,29 +149,46 @@ module Marvin
     # reflects whether or not the current message / previous message came
     # from a user via pm.
     def from_user?
-      self.target && !from_channel?
+      !from_channel?
     end
     
-    # Determines whether the previous message was inside a channel.
-    def from_channel?
-      self.target && [?#, ?&].include?(self.target[0])
+    # Determines whether a given target (defaulting to the target of the
+    # last message was in a channel)
+    def from_channel?(target = self.target)
+      target.present? && target =~ /^[\&\#]/
     end
     
     def addressed?
-      self.from_user? || options.message =~ /^#{self.client.nickname.downcase}:\s+/i
+      from_user? || options.message =~ /^#{client.nickname.downcase}:\s+/i
+    end
+    
+    # A Perennial automagical helper for dispatch
+    def registered=(value)
+      self.class.registered = value
+    end
+    
+    protected
+    
+    # Initializes details for the current cycle - in essence, this makes the
+    # details of the current request available.
+    def setup_details(options)
+      @options = options.is_a?(Marvin::Nash) ? options : Marvin::Nash.new(options.to_hash)
+      @target  = @options.target if @options.target?
+      @from    = @options.nick   if @options.nick?
     end
     
-    def setup_defaults(options)
-      self.options = options.is_a?(OpenStruct) ? options : OpenStruct.new(options)
-      self.target  = options[:target] if options.has_key?(:target)
-      self.from    = options[:nick]   if options.has_key?(:nick)
+    def reset_details
+      @options = nil
+      @target = nil
+      @from = nil
     end
     
-    # Halt's on the handler, used to prevent
-    # other handlers also responding to the same
-    # message more than once.
+    # Halt can be called during the handle / process. Doing so
+    # prevents any more handlers in the handler chain from being
+    # called. It's kind of like return but it works across all
+    # handlers, not just the current one.
     def halt!
-      raise HaltHandlerProcessing
+      raise Marvin::HaltHandlerProcessing
     end
     
   end

data/lib/marvin/client/actions.rb

@@ -0,0 +1,104 @@
+module Marvin
+  class AbstractClient
+   
+    ## General IRC Functions / Actions
+    
+    # Sends a specified command to the server.
+    # Takes name (e.g. :privmsg) and all of the args.
+    # Very simply formats them as a string correctly
+    # and calls send_data with the results.
+    def command(name, *args)
+      # First, get the appropriate command
+      name = name.to_s.upcase
+      args = args.flatten
+      args << util.last_param(args.pop)
+      send_line "#{name} #{args.compact.join(" ").strip}\r\n"
+    end
+    
+    # Join one or more channels on the current server
+    # e.g.
+    #   client.join "#marvin-testing"
+    #   client.join ["#marvin-testing", "#rubyonrails"]
+    #   client.join "#marvin-testing", "#rubyonrails"
+    def join(*channels_to_join)
+      channels_to_join = channels_to_join.flatten.map { |c| util.channel_name(c) }
+      # If you're joining multiple channels at once, we join them together
+      command :JOIN, channels_to_join.join(",")
+      channels_to_join.each { |channel| dispatch :outgoing_join, :target => channel }
+      logger.info "Sent JOIN for channels #{channels_to_join.join(", ")}"
+    end
+    
+    # Parts a channel, with an optional reason
+    # e.g.
+    #    part "#marvin-testing"
+    #    part "#marvin-testing", "Ninjas stole by felafel"
+    def part(channel, reason = nil)
+      channel = util.channel_name(channel)
+      # Send the command anyway, even if we're not a
+      # a recorded member something might of happened.
+      command :part, channel, reason
+      if channels.include?(channel)
+        dispatch :outgoing_part, :target => channel, :reason => reason
+        logger.info "Parted channel #{channel} - #{reason.present? ? reason : "Non given"}"
+      else
+        logger.warn "Parted channel #{channel} but wasn't recorded as member of channel"
+      end
+    end
+    
+    # Quites from a server, first parting all channels if a second
+    # argument is passed as true
+    # e.g.
+    #    quit
+    #    quit "Going to grab some z's"
+    def quit(reason = nil, part_before_quit = false)
+      @disconnect_expected = true
+      # If the user wants to part before quitting, they should
+      # pass a second, true, parameter
+      if part_before_quit
+        logger.info "Preparing to part from channels before quitting"
+        channels.to_a.each { |chan| part(chan, reason) }
+        logger.info "Parted from all channels, quitting"
+      end
+      command :quit, reason
+      dispatch :outgoing_quit
+      # Remove the connections from the pool
+      connections.delete(self)
+      logger.info  "Quit from #{host_with_port}"
+    end
+    
+    # Sends a message to a target (either a channel or a user)
+    # e.g.
+    #    msg "#marvin-testing", "Hello there!"
+    #    msg "SuttoL", "Hey, I'm playing with marvin!"
+    def msg(target, message)
+      command :privmsg, target, message
+      dispatch :outgoing_message, :target => target, :message => message
+      logger.info "Message #{target} - #{message}"
+    end
+    
+    # Does a CTCP action in a channel (equiv. to doing /me in most IRC clients)
+    # e.g.
+    #    action "#marvin-testing", "is about to sleep"
+    #    action "SuttoL", "is about to sleep"
+    def action(target, message)
+      command :privmsg, target, "\01ACTION #{message.strip}\01"
+      dispatch :outgoing_action, :target => target, :message => message
+      logger.info "Action sent to #{target} - #{message}"
+    end
+    
+    def pong(data)
+      command :pong, data
+      dispatch :outgoing_pong
+      logger.info "PONG sent to #{host_with_port} w/ data - #{data}"
+    end
+    
+    def nick(new_nick)
+      logger.info "Changing nick to #{new_nick}"
+      command :nick, new_nick
+      @nickname = new_nick
+      dispatch :outgoing_nick, :new_nick => new_nick
+      logger.info "Nick changed to #{new_nick}"
+    end
+    
+  end
+end

data/lib/marvin/client/default_handlers.rb

@@ -0,0 +1,97 @@
+module Marvin
+  class AbstractClient
+    
+    # Default handlers
+    
+    # The default handler for all things initialization-related
+    # on the client. Usually, this will send the user command,
+    # set out nick, join all of the channels / rooms we wish
+    # to be in and if a password is specified in the configuration,
+    # it will also attempt to identify us.
+    def handle_client_connected(opts = {})
+      logger.info "About to handle client connected"
+      # If the pass is set
+      unless pass.blank?
+        logger.info "Sending pass for connection"
+        command :pass, pass
+      end
+      # IRC Connection is establish so we send all the required commands to the server.
+      logger.info "Setting default nickname"
+      nick nicks.shift
+      logger.info "Sending user command"
+      command :user, configuration.user, "0", "*", configuration.name
+    rescue Exception => e
+      Marvin::ExceptionTracker.log(e)
+    end
+    
+    # handle a bunch of default events that happen at a connection
+    # level instead of a per-app level.
+    
+    # The default response for PING's - it simply replies
+    # with a PONG.
+    def handle_incoming_ping(opts = {})
+      logger.info "Received Incoming Ping - Handling with a PONG"
+      pong(opts[:data])
+    end
+    
+    # TODO: Get the correct mapping for a given
+    # Code.
+    def handle_incoming_numeric(opts = {})
+      case opts[:code]
+        when Marvin::IRC::Replies[:RPL_WELCOME]
+          handle_welcome
+        when Marvin::IRC::Replies[:ERR_NICKNAMEINUSE]
+          handle_nick_taken
+        when Marvin::IRC::Replies[:RPL_TOPIC]
+          handle_channel_topic
+      end
+      code = opts[:code].to_i
+      args = Marvin::Util.arguments(opts[:data])
+      dispatch :incoming_numeric_processed, :code => code, :data => args
+    end
+    
+    def handle_welcome
+      logger.info "Welcome received from server"
+      # If a password is specified, we will attempt to message
+      # NickServ to identify ourselves.
+      say ":IDENTIFY #{self.configuration.password}", "NickServ" if configuration.password.present?
+      # Join the default channels IF they're already set
+      # Note that Marvin::IRC::Client.connect will set them AFTER this stuff is run.
+      join default_channels
+    end
+    
+    # The default handler for when a users nickname is taken on
+    # on the server. It will attempt to get the nicknickname from
+    # the nicknames part of the configuration (if available) and
+    # will then call #nick to change the nickname.
+    def handle_nick_taken
+      logger.info "Nickname '#{nickname}' on #{server} taken, trying next." 
+      logger.info "Available Nicknames: #{nicks.empty? ? "None" : nicks.join(", ")}"
+      if !nicks.empty?
+        logger.info "Getting next nickname to switch"
+        next_nick = nicks.shift # Get the next nickname
+        logger.info "Attemping to set nickname to '#{next_nick}'"
+        nick next_nick
+      else
+        logger.fatal "No Nicknames available - QUITTING"
+        quit
+      end
+    end
+    
+    # Only record joins when you've successfully joined the channel.
+    def handle_incoming_join(opts = {})
+      if opts[:nick] == @nickname
+        channels << opts[:target]
+        logger.info "Successfully joined channel #{opts[:target]}"
+      end
+    end
+    
+    # Make sure we show user server errors
+    def handle_incoming_error(opts = {})
+      if opts[:message].present?
+        logger.info "Got ERROR Message: #{opts[:message]}"
+      end
+    end
+    
+  end
+end

data/lib/marvin/command_handler.rb

@@ -1,80 +1,91 @@
 require 'set'
 
 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
-    cattr_accessor :descriptions, :last_description, :exposed_method_names
+    class_inheritable_accessor :command_prefix
+    self.command_prefix  = ""
     
-    self.command_prefix       = ""
-    self.exposed_methods      = Set.new
-    self.descriptions         = {}
-    self.exposed_method_names = Set.new
+    @@exposed_method_mapping = Hash.new { |h,k| h[k] = [] }
+    @@method_descriptions    = Hash.new { |h,k| h[k] = {} }
+    @@registered_classes     = Set.new
     
     class << self
       
+      def command(name, method_desc = nil, &blk)
+        exposes name
+        desc method_desc unless method_desc.blank?
+        define_method(name, &blk)
+      end
+      
+      def prefix_is(p)
+        self.command_prefix = p
+      end
+      
       def exposes(*args)
-        names = args.map { |a| a.to_sym }.flatten
-        self.exposed_methods      += names
-        self.exposed_method_names += names
+        args.each { |name| @@exposed_method_mapping[self] << name.to_sym }
+      end
+      
+      def exposed_methods
+        methods = []
+        klass   = self
+        while klass != Object
+          methods += @@exposed_method_mapping[klass]
+          klass = klass.superclass
+        end
+        return methods.uniq.compact
+      end
+      
+      def prefix_regexp
+        /^#{command_prefix}/
+      end
+      
+      def desc(description)
+        @last_description = description
+      end
+      
+      def exposed_name(method)
+        "#{command_prefix}#{method}"
       end
       
     end
     
-    on_event :incoming_message do
-      logger.debug "Incoming message"
-      check_for_commands
-    end
+    on_event :incoming_message, :check_for_commands
     
     def check_for_commands
+      message = options.message.to_s.strip
       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.
+      if from_channel?
+        name, command, data = message.split(/\s+/, 2)
+        return if name !~ /^#{client.nickname}:/i
       else
-        command, data = options.message.split(" ", 2)
+        command, data = message.splt(/\s+/, 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_s.split(" ")) if self.respond_to?(command_name)
+      data ||= ""
+      if (command_name = extract_command_name(command)).present?
+        logger.info "Processing command '#{command_name}' for #{from}"
+        send(command_name, data.to_s) if 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
-      if has_prefix
-        method_name = command[prefix_length..-1].to_s.underscore.to_sym
-        return method_name if self.exposed_methods.to_a.include?(method_name)
+      re = self.class.prefix_regexp
+      if command =~ re
+        method_name = command.gsub(re, "").underscore.to_sym
+        return method_name if self.class.exposed_methods.include?(method_name)
       end
     end
     
-    class << self
-      
-      def desc(desc)
-        self.last_description = desc
-      end
-      
-      def method_added(name)
-        unless last_description.blank?
-          descriptions[name.to_sym] = self.last_description
-          self.last_description = nil
-        end
+    def exposed_name(name)
+      self.class.exposed_name(name)
+    end
+    
+    def self.method_added(name)
+      if @last_description.present?
+        @@method_descriptions[self][name.to_sym] = @last_description
+        @last_description = nil
       end
-      
     end
     
   end
-  
 end