ponder 0.0.1

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.force_encoding('utf-8')
+    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

data/lib/ponder/logger/twoflogger18.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.index(hash[:severity])} #{Time.now.strftime(@time_format)} #{hash[:message]}"
+          end
+        rescue => e
+          puts e.message, *e.backtrace
+        end
+      end
+    end
+  end
+end

data/lib/ponder/thaum.rb

@@ -0,0 +1,242 @@
+require 'ponder/callback'
+require 'ponder/connection'
+require 'ponder/irc'
+require 'ponder/async_irc'
+require 'ponder/filter'
+require 'ostruct'
+
+module Ponder
+  class Thaum
+    include IRC
+    include AsyncIRC
+    
+    if RUBY_VERSION >= '1.9'
+      require 'ponder/delegate'
+      include Delegate
+    end
+    
+    attr_reader :config
+    attr_accessor :connected, :traffic_logger, :error_logger, :console_logger, :empty_logger
+    
+    def initialize
+      @config = OpenStruct.new(:server             => 'localhost',
+                               :port               => 6667,
+                               :nick               => 'Ponder',
+                               :username           => 'Ponder',
+                               :real_name          => 'Ponder',
+                               :verbose            => true,
+                               :logging            => false,
+                               :reconnect          => true,
+                               :reconnect_interval => 30,
+                               :auto_rename        => true
+                              )
+      
+      @empty_logger   = Logger::BlindIo.new
+      @traffic_logger = @empty_logger
+      @error_logger   = @empty_logger
+      @console_logger = Logger::Twoflogger.new($stdout)
+      
+      @observer_queues = {}
+      
+      @connected = false
+      @reloading = false
+      
+      # user callbacks
+      @callbacks = Hash.new { |hash, key| hash[key] = [] }
+      
+      # standard callbacks for PING, VERSION, TIME and Nickname is already in use
+      on :query, /^\001PING \d+\001$/ do |env|
+        time = env[:message].scan(/\d+/)[0]
+        notice env[:nick], "\001PING #{time}\001"
+      end
+      
+      on :query, /^\001VERSION\001$/ do |env|
+        notice env[:nick], "\001VERSION Ponder #{Ponder::VERSION} (http://github.com/tbuehlmann/ponder)\001"
+      end
+      
+      on :query, /^\001TIME\001$/ do |env|
+        notice env[:nick], "\001TIME #{Time.now.strftime('%a %b %d %H:%M:%S %Y')}\001"
+      end
+      
+      on 433 do
+        rename "#{@config.nick}#{rand(10)}#{rand(10)}#{rand(10)}"
+      end
+      
+      # before and after filter
+      @before_filters = Hash.new { |hash, key| hash[key] = [] }
+      @after_filters = Hash.new { |hash, key| hash[key] = [] }
+    end
+    
+    def configure(&block)
+      unless @reloading
+        block.call(@config)
+        
+        # logger changes (if differing from initialize)
+        if @config.logging
+          @traffic_logger = @config.traffic_logger ? @config.traffic_logger : Logger::Twoflogger.new(Ponder.root.join('logs', 'traffic.log'))
+          @error_logger = @config.error_logger ? @config.error_logger : Logger::Twoflogger.new(Ponder.root.join('logs', 'error.log'))
+        end
+        
+        unless @config.verbose
+          @console_logger = @empty_logger
+        end
+        
+        # remove auto_rename callback (if differing from initialize)
+        unless @config.auto_rename
+          @callbacks.delete(433)
+        end
+      end
+    end
+    
+    def on(event_types = [:channel], match = //, &block)
+      if event_types.is_a?(Array)
+        callbacks = event_types.map { |event_type| Callback.new(event_type, match, block) }
+      else
+        callbacks = [Callback.new(event_types, match, block)]
+        event_types = [event_types]
+      end
+      
+      callbacks.each_with_index do |callback, index|
+        @callbacks[event_types[index]] << callback
+      end
+    end
+    
+    def connect
+      unless @reloading
+        @traffic_logger.start_logging
+        @error_logger.start_logging
+        @console_logger.start_logging
+        
+        @traffic_logger.info '-- Starting Ponder'
+        @console_logger.info '-- Starting Ponder'
+        
+        EventMachine::run do
+          @connection = EventMachine::connect(@config.server, @config.port, Connection, self)
+        end
+      end
+    end
+    
+    def reload!
+      @reloading = true
+      @callbacks.clear
+      load $0
+      @reloading = false
+    end
+    
+    def reloading?
+      @reloading
+    end
+    
+    # parsing incoming traffic
+    def parse(message)
+      message.chomp!
+      @traffic_logger.info "<< #{message}"
+      @console_logger.info "<< #{message}"
+      
+      case message
+      when /^PING \S+$/
+        raw message.sub(/PING/, 'PONG')
+      
+      when /^:\S+ (\d\d\d) /
+        number = $1.to_i
+        parse_event(number, :type => number, :params => $')
+      
+      when /^:(\S+)!(\S+)@(\S+) PRIVMSG #(\S+) :/
+        parse_event(:channel, :type => :channel, :nick => $1, :user => $2, :host => $3, :channel => "##{$4}", :message => $')
+      
+      when /^:(\S+)!(\S+)@(\S+) PRIVMSG \S+ :/
+        parse_event(:query, :type => :query, :nick => $1, :user => $2, :host => $3, :message => $')
+      
+      when /^:(\S+)!(\S+)@(\S+) JOIN :*(\S+)$/
+        parse_event(:join, :type => :join, :nick => $1, :user => $2, :host => $3, :channel => $4)
+      
+      when /^:(\S+)!(\S+)@(\S+) PART (\S+)/
+        parse_event(:part, :type => :part, :nick => $1, :user => $2, :host => $3, :channel => $4, :message => $'.sub(/ :/, ''))
+      
+      when /^:(\S+)!(\S+)@(\S+) QUIT/
+        parse_event(:quit, :type => :quit, :nick => $1, :user => $2, :host => $3, :message => $'.sub(/ :/, ''))
+      
+      when /^:(\S+)!(\S+)@(\S+) NICK :/
+        parse_event(:nickchange, :type => :nickchange, :nick => $1, :user => $2, :host => $3, :new_nick => $')
+      
+      when /^:(\S+)!(\S+)@(\S+) KICK (\S+) (\S+) :/
+        parse_event(:kick, :type => :kick, :nick => $1, :user => $2, :host => $3, :channel => $4, :victim => $5, :reason => $')
+      
+      when /^:(\S+)!(\S+)@(\S+) TOPIC (\S+) :/
+        parse_event(:topic, :type => :topic, :nick => $1, :user => $2, :host => $3, :channel => $4, :topic => $')
+      end
+      
+      @observer_queues.each do |queue, regexps|
+        regexps.each do |regexp|
+          if message =~ regexp
+            queue << message
+          end
+        end
+      end
+    end
+    
+    # process callbacks with its begin; rescue; end
+    def process_callbacks(event_type, event_data)
+      @callbacks[event_type].each do |callback|
+        EM.defer(
+          Proc.new do
+            begin
+              stop_running = false
+              
+              # before filters (specific filters first, then :all)
+              (@before_filters[event_type] + @before_filters[:all]).each do |filter|
+                if filter.call(event_type, event_data) == false
+                  stop_running = true
+                  break
+                end
+              end
+              
+              unless stop_running
+                # handling
+                callback.call(event_type, event_data)
+                
+                # after filters (specific filters first, then :all)
+                (@after_filters[event_type] + @after_filters[:all]).each do |filter|
+                  filter.call(event_type, event_data)
+                end
+              end
+            rescue => e
+              @error_logger.error(e.message, *e.backtrace)
+              @console_logger.error(e.message, *e.backtrace)
+            end
+          end
+        )
+      end
+    end
+    
+    def before_filter(event_types = :all, match = //, &block)
+      filter(@before_filters, event_types, match, block)
+    end
+    
+    def after_filter(event_types = :all, match = //, &block)
+      filter(@after_filters, event_types, match, block)
+    end
+    
+    private
+    
+    # parses incoming traffic (types)
+    def parse_event(event_type, event_data = {})
+      if ((event_type == 376) || (event_type == 422)) && !@connected
+        @connected = true
+        process_callbacks(:connect, event_data)
+      end
+      
+      process_callbacks(event_type, event_data)
+    end
+    
+    def filter(filter_type, event_types = :all, match = //, block)
+      if event_types.is_a?(Array)
+        event_types.each do |event_type|
+          filter_type[event_type] << Filter.new(event_type, match, block)
+        end
+      elsif
+        filter_type[event_types] << Filter.new(event_types, match, block)
+      end
+    end
+  end
+end