bbrowning-ponder 0.0.2.1

data/lib/ponder.rb

@@ -0,0 +1,22 @@
+require 'pathname'
+require 'rubygems'
+
+$LOAD_PATH.unshift Pathname.new(__FILE__).dirname.expand_path
+
+module Ponder
+  def self.root
+    Pathname.new($0).dirname.expand_path
+  end
+  
+  require 'ponder/version'
+  require 'ponder/thaum'
+  require 'ponder/formatting'
+  require 'ponder/logger/blind_io'
+  
+  if RUBY_VERSION < '1.9'
+    require 'ponder/logger/twoflogger18'
+  else
+    require 'ponder/logger/twoflogger'
+  end
+end
+

data/lib/ponder/async_irc.rb

@@ -0,0 +1,117 @@
+require 'thread'
+require 'timeout'
+
+module Ponder
+  module AsyncIRC
+    def get_topic(channel)
+      queue = Queue.new
+      @observer_queues[queue] = [/:\S+ (331|332|403|442) \S+ #{Regexp.escape(channel)} :/i]
+      raw "TOPIC #{channel}"
+      
+      topic = begin
+        Timeout::timeout(30) do
+           response = queue.pop
+           raw_numeric = response.scan(/^:\S+ (\d{3})/)[0][0]
+           
+           case raw_numeric
+           when '331'
+             {:raw_numeric => 331, :message => 'No topic is set'}
+           when '332'
+             {:raw_numeric => 332, :message => response.scan(/ :(.*)/)[0][0]}
+           when '403'
+             {:raw_numeric => 403, :message => 'No such channel'}
+           when '442'
+             {:raw_numeric => 442, :message => "You're not on that channel"}
+           end
+        end
+      rescue Timeout::Error
+        false
+      end
+      
+      @observer_queues.delete queue
+      return topic
+    end
+    
+    def channel_info(channel)
+      queue = Queue.new
+      @observer_queues[queue] = [/:\S+ (324|329|403) \S+ #{Regexp.escape(channel)}/i]
+      raw "MODE #{channel}"
+      information = {}
+      running = true
+      
+      begin
+        Timeout::timeout(30) do
+          while running
+            response = queue.pop
+            raw_numeric = response.scan(/^:\S+ (\d{3})/)[0][0]
+            
+             case raw_numeric
+             when '324'
+               information[:modes] = response.scan(/^:\S+ 324 \S+ \S+ \+(\w*)/)[0][0].split('')
+               limit = response.scan(/^:\S+ 324 \S+ \S+ \+\w* (\w*)/)[0]
+               information[:channel_limit] = limit[0].to_i if limit
+             when '329'
+               information[:created_at] = Time.at(response.scan(/^:\S+ 329 \S+ \S+ (\d+)/)[0][0].to_i)
+               running = false
+             when '403'
+               information = false
+               running = false
+             end
+           end
+        end
+      rescue Timeout::Error
+        information = false
+      end
+      
+      @observer_queues.delete queue
+      return information
+    end
+    
+    def whois(nick)
+      queue = Queue.new
+      @observer_queues[queue] = [/^:\S+ (307|311|312|318|319|401) \S+ #{Regexp.escape(nick)}/i]
+      raw "WHOIS #{nick}"
+      whois = {}
+      running = true
+      
+      while running
+        begin
+          Timeout::timeout(30) do
+             response = queue.pop
+             raw_numeric = response.scan(/^:\S+ (\d{3})/)[0][0]
+             
+             case raw_numeric
+             when '307'
+               whois[:registered] = true
+             when '311'
+               response = response.scan(/^:\S+ 311 \S+ (\S+) (\S+) (\S+) \* :(.*)$/)[0]
+               whois[:nick]      = response[0]
+               whois[:username]  = response[1]
+               whois[:host]      = response[2]
+               whois[:real_name] = response[3]
+             when '312'
+               response = response.scan(/^:\S+ 312 \S+ \S+ (\S+) :(.*)/)[0]
+               whois[:server] = {:address => response[0], :name => response[1]}
+             when '318'
+               running = false
+             when '319'
+               channels_with_mode = response.scan(/^:\S+ 319 \S+ \S+ :(.*)/)[0][0].split(' ')
+               whois[:channels] = {}
+               channels_with_mode.each do |c|
+                 whois[:channels][c.scan(/(.)?(#\S+)/)[0][1]] = c.scan(/(.)?(#\S+)/)[0][0]
+               end
+             when '401'
+               whois  = false
+               running = false
+             end
+          end
+        rescue Timeout::Error
+          nil
+        end
+      end
+      
+      @observer_queues.delete queue
+      return whois
+    end
+  end
+end

data/lib/ponder/callback.rb

@@ -0,0 +1,42 @@
+module Ponder
+  class Callback
+    LISTENED_TYPES = [:connect, :channel, :query, :join, :part, :quit, :nickchange, :kick, :topic, :disconnect] # + 3-digit numbers
+    
+    def initialize(event_type = :channel, match = //, proc = Proc.new {})
+      unless self.class::LISTENED_TYPES.include?(event_type) || event_type.is_a?(Integer)
+        raise TypeError, "#{event_type} is an unsupported event-type"
+      end
+      
+      self.match = match
+      self.proc = proc
+    end
+    
+    def call(event_type, event_data = {})
+      if (event_type == :channel) || (event_type == :query)
+        @proc.call(event_data) if event_data[:message] =~ @match
+      elsif event_type == :topic
+        @proc.call(event_data) if event_data[:topic] =~ @match
+      else
+        @proc.call(event_data)
+      end
+    end
+    
+    private
+    
+    def match=(match)
+      if match.is_a?(Regexp)
+        @match = match
+      else
+        raise TypeError, "#{match} must be a Regexp"
+      end
+    end
+    
+    def proc=(proc)
+      if proc.is_a?(Proc)
+        @proc = proc
+      else
+        raise TypeError, "#{proc} must be a Proc"
+      end
+    end
+  end
+end

data/lib/ponder/connection.rb

@@ -0,0 +1,37 @@
+require 'eventmachine'
+
+module Ponder
+  class Connection < EventMachine::Connection
+    include EventMachine::Protocols::LineText2
+
+    def initialize(thaum)
+      @thaum = thaum
+    end
+
+    def connection_completed
+      @thaum.register
+    end
+
+    def unbind
+      @thaum.connected = false
+      @thaum.process_callbacks :disconnect, {}
+      @thaum.traffic_logger.info '-- Ponder disconnected'
+      @thaum.console_logger.info '-- Ponder disconnected'
+
+      if @thaum.config.reconnect
+        @thaum.traffic_logger.info "-- Reconnecting in #{@thaum.config.reconnect_interval} seconds"
+        @thaum.console_logger.info "-- Reconnecting in #{@thaum.config.reconnect_interval} seconds"
+
+        EventMachine::add_timer(@thaum.config.reconnect_interval) do
+          reconnect @thaum.config.server, @thaum.config.port
+        end
+      else
+        EventMachine::stop_event_loop
+      end
+    end
+
+    def receive_line(line)
+      @thaum.parse line
+    end
+  end
+end

data/lib/ponder/delegate.rb

@@ -0,0 +1,11 @@
+module Ponder
+  module Delegate
+    def delegate
+      thaum = self
+      
+      (IRC.instance_methods + [:configure, :on, :connect, :reload!, :reloading?]).each do |method|
+         Object.send(:define_method, method) { |*args, &block| thaum.send(method, *args, &block) }
+      end
+    end
+  end
+end

data/lib/ponder/filter.rb

@@ -0,0 +1,7 @@
+require 'ponder/callback'
+
+module Ponder
+  class Filter < Callback
+    LISTENED_TYPES += [:all]
+  end
+end

data/lib/ponder/formatting.rb

@@ -0,0 +1,30 @@
+module Ponder
+  module Formatting
+    PLAIN        = 15.chr
+    BOLD         = 2.chr
+    ITALIC       = 22.chr
+    UNDERLINE    = 31.chr
+    COLOR_CODE   = 3.chr
+    UNCOLOR_CODE = COLOR_CODE
+    
+    #mIRC color codes from http://www.mirc.com/help/colors.html
+    COLORS = {:white  => '00',
+              :black  => '01',
+              :blue   => '02',
+              :green  => '03',
+              :red    => '04',
+              :brown  => '05',
+              :purple => '06',
+              :orange => '07',
+              :yellow => '08',
+              :lime   => '09',
+              :teal   => '10',
+              :cyan   => '11',
+              :royal  => '12',
+              :pink   => '13',
+              :gray   => '14',
+              :silver => '15'
+             }
+  end
+end
+

data/lib/ponder/irc.rb

@@ -0,0 +1,110 @@
+module Ponder
+  module IRC
+    # raw IRC messages
+    def raw(message)
+      @connection.send_data "#{message}\r\n"
+      @traffic_logger.info ">> #{message}"
+      @console_logger.info ">> #{message}"
+    end
+    
+    # send a message
+    def message(recipient, message)
+      raw "PRIVMSG #{recipient} :#{message}"
+    end
+    
+    # register when connected
+    def register
+      raw "NICK #{@config.nick}"
+      raw "USER #{@config.username} * * :#{@config.real_name}"
+      raw "PASS #{@config.password}" if @config.password
+    end
+    
+    # send a notice
+    def notice(recipient, message)
+      raw "NOTICE #{recipient} :#{message}"
+    end
+    
+    # set a mode
+    def mode(recipient, option)
+      raw "MODE #{recipient} #{option}"
+    end
+    
+    # kick a user
+    def kick(channel, user, reason = nil)
+      if reason
+        raw "KICK #{channel} #{user} :#{reason}"
+      else
+        raw "KICK #{channel} #{user}"
+      end
+    end
+    
+    # perform an action
+    def action(recipient, message)
+      raw "PRIVMSG #{recipient} :\001ACTION #{message}\001"
+    end
+    
+    # set a topic
+    def topic(channel, topic)
+      raw "TOPIC #{channel} :#{topic}"
+    end
+    
+    # joining a channel
+    def join(channel, password = nil)
+      if password
+        raw "JOIN #{channel} #{password}"
+      else
+        raw "JOIN #{channel}"
+      end
+    end
+    
+    # parting a channel
+    def part(channel, message = nil)
+      if message
+        raw "PART #{channel} :#{message}"
+      else
+        raw "PART #{channel}"
+      end
+    end
+    
+    # quitting
+    def quit(message = nil)
+      if message
+        raw "QUIT :#{message}"
+      else
+        raw 'QUIT'
+      end
+      
+      @config.reconnect = false # so Ponder does not reconnect after the socket has been closed
+    end
+    
+    # rename
+    def rename(nick)
+      raw "NICK :#{nick}"
+    end
+    
+    # set an away status
+    def away(message = nil)
+      if message
+        raw "AWAY :#{message}"
+      else
+        raw "AWAY"
+      end
+    end
+    
+    # cancel an away status
+    def back
+      away
+    end
+    
+    # invite an user to a channel
+    def invite(nick, channel)
+      raw "INVITE #{nick} #{channel}"
+    end
+    
+    # ban an user
+    def ban(channel, address)
+      mode channel, "+b #{address}"
+    end
+  end
+end
+

data/lib/ponder/logger/blind_io.rb

@@ -0,0 +1,11 @@
+module Ponder
+  module Logger
+    class BlindIo
+      def initialize
+        [:debug, :info, :warn, :error, :fatal, :unknown, :start_logging, :stop_logging].each do |method_name|
+          self.class.send(:define_method, method_name, Proc.new { |*args| nil })
+        end
+      end
+    end
+  end
+end

data/lib/ponder/logger/twoflogger.rb

@@ -0,0 +1,93 @@
+require 'pathname'
+require 'thread'
+autoload :FileUtils, 'fileutils'
+
+module Ponder
+  module Logger
+    class Twoflogger
+      attr_accessor :level, :levels, :time_format
+      
+      def initialize(destination = Ponder.root.join('logs', 'log.log'), level = :debug, time_format = '%Y-%m-%d %H:%M:%S', levels = {:debug => 0, :info => 1, :warn => 2, :error => 3, :fatal => 4, :unknown => 5})
+        @level = level
+        @time_format = time_format
+        @levels = levels
+        @queue = Queue.new
+        @mutex = Mutex.new
+        @running = false
+        
+        define_level_shorthand_methods
+        self.log_dev = destination
+      end
+      
+      def start_logging
+        @running = true
+        @thread = Thread.new do
+          begin
+            while @running do
+              write(@queue.pop)
+            end
+          ensure
+            @log_dev.close if @log_dev.is_a?(File)
+          end
+        end
+      end
+      
+      def stop_logging
+        @running = false
+      end
+      
+      def log_dev=(destination)
+        stop_logging
+        
+        if destination.is_a?(Pathname)
+          unless destination.exist?
+            unless destination.dirname.directory?
+              FileUtils.mkdir_p destination.dirname
+            end
+            
+            File.new(destination, 'w+')
+          end
+          @log_dev = File.open(destination, 'a+')
+          @log_dev.sync = true
+        elsif destination.is_a?(IO)
+          @log_dev = destination
+        else
+          raise TypeError, 'need a Pathname or IO'
+        end
+      end
+      
+      private
+      
+      def define_level_shorthand_methods
+        @levels.each_pair do |level_name, severity|
+          self.class.send(:define_method, level_name, Proc.new { |*messages| queue(severity, *messages) })
+        end
+      end
+      
+      def queue(severity, *messages)
+        raise(ArgumentError, 'Need a message') if messages.empty?
+        raise(ArgumentError, 'Need messages that respond to #to_s') if messages.any? { |message| !message.respond_to?(:to_s) }
+        
+        if severity >= @levels[@level]
+          message_hashes = messages.map { |message| {:severity => severity, :message => message} }
+          
+          @mutex.synchronize do
+            message_hashes.each do |hash|
+              @queue << hash
+            end
+          end
+        end
+      end
+      
+      def write(*message_hashes)
+        begin
+          message_hashes.each do |hash|
+            @log_dev.puts "#{@levels.key(hash[:severity])} #{Time.now.strftime(@time_format)} #{hash[:message]}"
+          end
+        rescue => e
+          puts e.message, *e.backtrace
+        end
+      end
+    end
+  end
+end