PerfectlyNormal-Flexo 0.3.9

data/lib/daemonize.rb

@@ -0,0 +1,59 @@
+# Shamelessly downloaded and included in Flexo
+# from http://grub.ath.cx/daemonize/
+# Not my own work at all.
+module Daemonize
+  VERSION = "0.1.2"
+
+  # Try to fork if at all possible retrying every 5 sec if the
+  # maximum process limit for the system has been reached
+  def safefork
+    tryagain = true
+
+    while tryagain
+      tryagain = false
+      begin
+        if pid = fork
+          return pid
+        end
+      rescue Errno::EWOULDBLOCK
+        sleep 5
+        tryagain = true
+      end
+    end
+  end
+
+  # This method causes the current running process to become a daemon
+  # If closefd is true, all existing file descriptors are closed
+  def daemonize(oldmode=0, closefd=false)
+    srand # Split rand streams between spawning and daemonized process
+    safefork and exit # Fork and exit from the parent
+
+    # Detach from the controlling terminal
+    unless sess_id = Process.setsid
+      raise 'Cannot detach from controlled terminal'
+    end
+
+    # Prevent the possibility of acquiring a controlling terminal
+    if oldmode.zero?
+      trap 'SIGHUP', 'IGNORE'
+      exit if pid = safefork
+    end
+
+    Dir.chdir "/"   # Release old working directory
+    File.umask 0000 # Insure sensible umask
+
+    if closefd
+      # Make sure all file descriptors are closed
+      ObjectSpace.each_object(IO) do |io|
+        unless [STDIN, STDOUT, STDERR].include?(io)
+          io.close rescue nil
+        end
+      end
+    end
+
+    STDIN.reopen "/dev/null"       # Free file descriptors and
+    STDOUT.reopen File.expand_path("~/flexo-err.log"), "a+" # point them somewhere sensible
+    STDERR.reopen STDOUT           # STDOUT/STDERR should go to a logfile
+    return oldmode ? sess_id : 0   # Return value is mostly irrelevant
+  end
+end

data/lib/flexo/client.rb

@@ -0,0 +1,30 @@
+# dirty haxx
+$:.push 'lib'
+
+require 'daemonize'
+require 'flexo/manager'
+
+module Flexo
+  # This is the 'main' class of Flexo.
+  # The main file just creates an instance of this class, and then
+  # everything goes automatically. Additionally, it contains tons of
+  # convenience functions, so plugins don't neccessarily have to do everything
+  # so complicated.
+  class Client
+    include Daemonize
+
+    def initialize
+      @nickname = nil
+      
+      begin
+        @manager = Flexo::Manager.instance
+        @manager.setup
+      rescue InvalidConfigurationException => e
+        $stderr.puts "Invalid configuration from Flexo::Client"
+        exit 1
+      end
+      
+      daemonize
+    end
+  end
+end

data/lib/flexo/config.rb

@@ -0,0 +1,79 @@
+require 'yaml'
+
+module Flexo
+  # Configuration-related functions.
+  # Able to read settings from a file, look them up, change them, and save
+  # them back to the file while the bot is running.
+  class Config
+    attr_reader :configpath
+    attr_reader :configfile
+
+    alias path configpath
+    alias file configfile
+
+    # Reads the configuration file into an array
+    def initialize
+      @configpath = File.expand_path("~/.flexo")
+      @configfile = "#{@configpath}/config.yaml"
+      @config     = {}
+      reload(:first)
+    end
+    
+    # Very basic validity-test. Just checks if we have *anything*
+    # stored in the configuration.
+    def valid?
+      return !@config.empty?
+    end
+
+    # Lookup-function. Lets us use Config as an array,
+    # for convenience. so instead of Config.lookup('key'),
+    # we can use Config['key']
+    def [](key)
+      if @config[key]
+        return @config[key]
+      end
+
+      return nil
+    end
+
+    # Same as [], lets you use this class as an array for saving
+    # values as well. Plugins also have access to this class, and
+    # can store their own permanent values here. 
+    # 
+    # Flexo would preferably use a "namespace", and plugins use their own
+    # namespace, using keys like core.nicks instead of just making a mess. 
+    # This would also prevent collisions
+    def []=(key, value)
+      @config[key] = value
+      return @config[key]
+    end
+
+    # Reloads configuration from file, resetting changes made since the 
+    # last write.
+    def reload(first = false)
+      begin
+        Dir["#{@configpath}/*.yaml"].each do |file|
+          tmp = YAML.load_file(file)
+          next if tmp.class != Hash && tmp.class != Array
+          @config.merge!(tmp)
+        end
+      rescue
+        if first == :first
+          Flexo::Logger.error "No configuration found. "
+          Flexo::Logger.error "Try mkflexorc for an automated tool to help "
+          Flexo::Logger.error "you create a configuration for Flexo.\n"
+          exit
+        else
+          Flexo::Logger.warn "Configuration has disappeared! Aborting reload."
+        end
+      end
+    end
+
+    # Saves the current configuration to a file.
+    def write
+      File.open(@configfile, 'w') do |f|
+        f.puts @config.to_yaml
+      end
+    end
+  end
+end

data/lib/flexo/constants.rb

@@ -0,0 +1,15 @@
+module Flexo
+  # A collection of various constants
+  module Constants
+    LOG_DEBUG2 = 4
+    LOG_DEBUG  = 3
+    LOG_INFO   = 2
+    LOG_WARN   = 1
+    LOG_ERROR  = 0
+
+    CHANPREFIX = ['#', '&', '+', '!']
+
+    FLEXO_VERSION = '0.3.9'
+    FLEXO_RELEASE = 'Bendless Love'
+  end
+end

data/lib/flexo/data.rb

@@ -0,0 +1,104 @@
+module Flexo
+  # This is a handy objecty representation
+  # of an IRC message. Each line is broken into
+  # tiny little pieces, made available to the rest
+  # of Flexo through accessors (only readers).
+  class Data
+    attr_reader :raw
+    attr_reader :message
+    attr_reader :origin
+    attr_reader :params
+    attr_reader :string
+    attr_reader :hostmask
+    attr_reader :numeric
+
+    # Calls parse() and fills up all the variables
+    # with sensible data
+    def initialize(raw)
+      @manager = Flexo::Manager.instance
+      data = parse(raw)
+
+      if data == nil
+        @manager.logger.error("Unable to parse\n#{raw}")
+        return
+      end
+
+      @raw      = raw
+      @message  = data[:message]
+      @origin   = data[:origin]
+      @params   = data[:params]
+      @string   = data[:string]
+      @hostmask = parse_hostmask(@origin) if @origin
+      @numeric  = @message =~ /^\d+$/ ? true : false
+    end
+
+    def numeric?
+      @numeric
+    end
+
+    def to_s
+      @raw
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class}:#{(@raw.size > 40 ? @raw[0..40] + '...' : @raw).inspect}>"
+    end
+
+    # Does the actual parsing and splitting and trickery
+    # with the received line
+    def parse(line)
+      m = line.lstrip.chomp.match(/^(?::(\S+) )?(\S+)(?: ([^:].*?[^:]))?(?: :(.*?))?$/)
+      {:origin  => m[1], :message => m[2], :params  => m[3] ? m[3].split(' ') : [], :string  => m[4] || ''} if m
+    end
+
+    # This parses the hostmask, creating an instance of
+    # Flexo::Data::Hostmask.
+    def parse_hostmask(mask)
+      m = mask.match(/^([^!\s]+)(?:(?:!([^@\s]+))?@(\S+))?$/)
+      
+      if m
+        host = Hostmask.new(m[1], m[2], m[3])
+        return host
+      end
+      
+      return nil
+    end
+  end
+
+  # For added fun, we have a small, separate class
+  # for hostmasks. And, being very creative, we call it...
+  # Data::Hostmask!
+  class Data::Hostmask
+    attr_reader :nickname
+    attr_reader :hostname
+    attr_reader :username
+    attr_reader :hostmask
+
+    alias :nick  :nickname
+    alias :from  :nickname
+    alias :by    :nickname
+
+    alias :host  :hostname
+    alias :ip    :hostname
+
+    alias :user  :username
+    alias :ident :username
+
+    alias :mask  :hostmask
+
+    # The only function in this class.
+    # When instanciated, this populates some instance variables
+    # with sensible values, and then allow us to access those using
+    # attr_readers
+    def initialize(nickname, username, hostname)
+      @nickname = nickname
+      @username = username
+      @hostname = hostname
+      @hostmask = "#{@nickname}!#{@username}@#{@hostname}".sub(/!?@?$/, '')
+    end
+
+    def inspect
+      "#<#{self.class}:#{@hostmask}>"
+    end
+  end
+end

data/lib/flexo/dispatcher.rb

@@ -0,0 +1,134 @@
+require 'flexo/event'
+require 'flexo/events/privmsg'
+require 'flexo/events/notice'
+require 'flexo/events/reply'
+require 'flexo/events/unknown'
+require 'flexo/events/mode'
+require 'flexo/events/ping'
+require 'flexo/events/pong'
+require 'flexo/events/join'
+require 'flexo/events/part'
+require 'flexo/events/quit'
+require 'flexo/events/kick'
+require 'flexo/events/nick'
+require 'flexo/events/topic'
+
+module Flexo
+  # Dispatcher receives data from Flexo::Server, analyzes it, and creates 
+  # relevant events (see Flexo::Event), which is then broadcast
+  # to all classes and plugins wanting to use it for something.
+  #
+  # This class also manages subscriptions for events, so all plugins
+  # that want to listen for an event, can use subscribe and unsubscribe
+  # to manage things.
+  class Dispatcher
+    # Save a reference to Flexo::Manager, set up the dispatching-queue,
+    # and get ready for working.
+    def initialize
+      @manager  = Flexo::Manager.instance
+      @queue    = Queue.new
+      @handlers = {}
+      @triggers = []
+
+      @manager.thread do 
+        while event = @queue.shift
+          next unless @handlers.key?(event.class)
+          @handlers[event.class].each { |h| 
+            @manager.logger.debug2("Running handler #{h} for #{event.class}")
+            h.call(event) 
+          }
+        end
+      end
+    end
+
+    # Does the handling of incoming lines.
+    # First, we use Flexo::Data to get
+    # anything meaningful out of the line received.
+    # Then, we create a subclass of Flexo::Event, which
+    # is pushed onto the dispatching-queue for further processing.
+    def receive(line)
+      @manager.logger.debug2("Received \"#{line.chomp}\"")
+      data  = Data.new(line)
+      event = case data.message
+      when /^\d+$/   then Flexo::Events::ReplyEvent.new   @manager, data
+      when 'JOIN'    then Flexo::Events::JoinEvent.new    @manager, data
+      when 'KICK'    then Flexo::Events::KickEvent.new    @manager, data
+      when 'MODE'    then Flexo::Events::ModeEvent.new    @manager, data
+      when 'NICK'    then Flexo::Events::NickEvent.new    @manager, data
+      when 'NOTICE'  then Flexo::Events::NoticeEvent.new  @manager, data
+      when 'PART'    then Flexo::Events::PartEvent.new    @manager, data
+      when 'PING'    then Flexo::Events::PingEvent.new    @manager, data
+      when 'PONG'    then Flexo::Events::PongEvent.new    @manager, data
+      when 'PRIVMSG' then Flexo::Events::PrivmsgEvent.new @manager, data
+      when 'QUIT'    then Flexo::Events::QuitEvent.new    @manager, data
+      when 'TOPIC'   then Flexo::Events::TopicEvent.new   @manager, data
+      else                Flexo::Events::UnknownEvent.new @manager, data
+      end
+
+      @queue << event
+    end
+
+    # Registers a callback function for a specific event.
+    def subscribe(event, &block)
+      if event.is_a?(Symbol) || event.kind_of?(String)
+        if (e = event.to_s) =~ /^(?:RPL|ERR)_/i
+          event = Flexo::Events::ReplyEvent[e.upcase]
+        else
+          match = e.match(/^(.+?)(?:_?event)?$/i)
+          event = Flexo::Events.const_get("#{match[1].capitalize}Event")
+        end
+      end
+
+      if event.is_a? Flexo::Events::ReplyEvent::Numeric
+        numeric = event.numeric
+        event   = Flexo::Events::ReplyEvent
+      else
+        numeric = false
+      end
+
+      handler = Handler.new(numeric, &block)
+      @manager.mutex do
+        @handlers[event] ||= []
+        @handlers[event] << handler
+      end
+
+      return handler
+    end
+
+    # Removes an event handler.
+    # Known to be broken.
+    # DO NOT USE.
+    # See bug #28
+    def unsubscribe(handler)
+      @manager.logger.debug("Going to remove handler #{handler}")
+      events = []
+      @manager.mutex do
+        @handlers.each { |e,handlers| 
+          if handlers.delete(handler) 
+            events << e
+            @manager.logger.debug("Adding #{e} to removal queue")
+          end
+        }
+        events.each { |e|
+          @manager.logger.debug("Removing #{e}")
+          @handlers.delete(e)
+        }
+      end
+    end
+
+    # Easy way to add a trigger.
+    # See Flexo::Trigger for documentation
+    def add_trigger(pattern, &block)
+      trigger = Flexo::Trigger.new(pattern, &block)
+      @manager.mutex { @triggers << trigger }
+      trigger
+    end
+
+    # Easy way to remove a trigger.
+    # Must be passed a Flexo::Trigger object
+    def remove_trigger(trigger)
+      trigger.unsubscribe
+      @manager.mutex { @triggers.delete(trigger) }
+    end
+  end
+end

data/lib/flexo/errors.rb

@@ -0,0 +1,29 @@
+module Flexo
+  # Our base-class for errors and exceptions
+  class Error < StandardError
+  end
+  
+  # Raised when the configuration is invalid, and there's no way to recover
+  class InvalidConfigurationException < Error
+  end
+
+  # Raised when a plugin is missing a required dependency
+  class PluginDependencyError < Error
+  end
+
+  # Default error for plugins
+  class PluginError < Error
+  end
+
+  # Exception raised when a plugin is missing a name
+  class PluginNameError < PluginError
+  end
+
+  # Raised when there's a name conflict
+  class PluginConflictError < PluginError
+  end
+
+  # Trying to load, but could not be found (404)
+  class PluginNotFoundError < PluginError
+  end
+end

data/lib/flexo/event.rb

@@ -0,0 +1,31 @@
+module Flexo
+  # Base class for all events generated by Flexo.
+  # Nothing of interest happening here, actually.
+  # Most of the fun stuff is taken care of by the subclasses
+  class Event
+    attr_reader :data
+    attr_reader :nickname
+
+    alias nick nickname
+    alias from nickname
+    alias by   nickname
+    alias who  nickname
+
+    # Create the event, setting some variables
+    def initialize(manager, data)
+      @manager = manager
+      @data    = data
+      @manager.logger.debug("Creating instance of #{self.class}")
+    end
+
+    # Checks the nickname in the hostmask
+    # to see if you're the one that made this event trigger,
+    # or if it was someone else.
+    def me?
+    end
+
+    alias is_me?   me?
+    alias from_me? me?
+    alias by_me?   me?
+  end
+end

data/lib/flexo/events/join.rb

@@ -0,0 +1,13 @@
+module Flexo
+  module Events
+    class JoinEvent < Event
+      attr_reader :channel
+      attr_reader :nick
+
+      def initialize(*args)
+        super
+        @channel = @data.params[0] || @data.string
+      end
+    end
+  end
+end

data/lib/flexo/events/kick.rb

@@ -0,0 +1,29 @@
+module Flexo
+  module Events
+    class KickEvent < Event
+      attr_reader :channel
+      attr_reader :kicker
+      attr_reader :victim
+      attr_reader :reason
+
+      alias kicked_by kicker
+
+      def initialize(*args)
+        super
+        @kicker  = @data.hostmask.nick
+        @channel = @data.params[0]
+        @victim  = @data.params[1]
+        @reason  = @data.string
+      end
+
+      def kicked_me?
+        @victim == @manager.nickname
+      end
+
+      def rejoin
+        sleep rand*5
+        @manager.sender.join(@channel)
+      end
+    end
+  end
+end

data/lib/flexo/events/mode.rb

@@ -0,0 +1,23 @@
+module Flexo
+  module Events
+    class ModeEvent < Event
+      attr_reader :modes
+
+      def initialize(*args)
+        super
+        @channelmode = Flexo::Constants::CHANPREFIX.include?(@data.params[0][0])
+        @modes       = @data.params[1..-1].join(' ')
+      end
+
+      def usermode?
+        !@channelmode
+      end
+
+      def channelmode?
+        @channelmode
+      end
+
+      alias chanmode? channelmode?
+    end
+  end
+end

data/lib/flexo/events/nick.rb

@@ -0,0 +1,14 @@
+module Flexo
+  module Events
+    class NickEvent < Event
+      attr_reader :old
+      attr_reader :new
+
+      def initialize(*args)
+        super
+        @old = @nickname
+        @new = @data.params[0] || @data.string
+      end
+    end
+  end
+end

data/lib/flexo/events/notice.rb

@@ -0,0 +1,12 @@
+module Flexo
+  module Events
+    # A little special event. This one is identical to Flexo::Events::PrivmsgEvent,
+    # so see that one for documentation.
+    class NoticeEvent < PrivmsgEvent
+      # We default to not replying to a channel for these.
+      def reply(target, to_channel=false)
+        super
+      end
+    end
+  end
+end

data/lib/flexo/events/part.rb

@@ -0,0 +1,14 @@
+module Flexo
+  module Events
+    class PartEvent < Event
+      attr_reader :channel
+      attr_reader :reason
+
+      def initialize(*args)
+        super
+        @channel = @data.params[0]
+        @reason  = @data.string
+      end
+    end
+  end
+end

data/lib/flexo/events/ping.rb

@@ -0,0 +1,16 @@
+module Flexo
+  module Events
+    class PingEvent < Event
+      attr_reader :server
+
+      def initialize(*args)
+        super
+        @server = @data.params[0] || @data.string
+      end
+
+      def pong
+        @manager.sender.pong(@server)
+      end
+    end
+  end
+end

data/lib/flexo/events/pong.rb

@@ -0,0 +1,14 @@
+module Flexo
+  module Events
+    class PongEvent < Event
+      attr_reader :server
+      attr_reader :origin
+
+      def initialize(*args)
+        super
+        @server = @data.params[0]
+        @origin = @data.params[1] || @data.string
+      end
+    end
+  end
+end

data/lib/flexo/events/privmsg.rb

@@ -0,0 +1,46 @@
+module Flexo
+  module Events
+    # Private messages, which, in fact, isn't neccessarily private.
+    # When the target of a privmsg is a channel, it's displayed to the
+    # entire channel. Which isn't very private at all.
+    class PrivmsgEvent < Event
+      attr_reader :sender
+      attr_reader :target
+      attr_reader :text
+      alias from sender
+
+      def initialize(*args)
+        super
+        @sender = @data.hostmask.nick if @data.hostmask
+        @target = @data.params[0]
+        @ctcp   = (m = @data.string.match(/^\x01(.+?)\x01$/)) ? true : false
+        @text   = @ctcp ? m[1] : @data.string
+      end
+
+      # Returns true if this was a CTCP-message, and false if not.
+      def ctcp?
+        return @ctcp
+      end
+
+      # Were you the target of the message?
+      def to_me?
+        return @target == @manager.nickname # FIXME: Should this be stored here?
+      end
+
+      # Sent to a channel, or was it actually a private message?
+      def to_channel?
+        return Flexo::Constants::CHANPREFIX.include?(@target[0..0])
+      end
+
+      # Sends a quick reply to the message.
+      # If to_channel is false, it's sent to the person who sent the
+      # message, whether he sent it to a channel, or private.
+      # If it was sent to you, this will send a direct reply
+      # no matter what to_channel is set to.
+      def reply(text, to_channel=true)
+        target = (to_channel && to_channel?) ? @target : @sender
+        @manager.sender.privmsg(target, text)
+      end
+    end
+  end
+end

data/lib/flexo/events/quit.rb

@@ -0,0 +1,12 @@
+module Flexo
+  module Events
+    class QuitEvent < Event
+      attr_reader :reason
+
+      def initialize(*args)
+        super
+        @reason = @data.string
+      end
+    end
+  end
+end