bbrowning-ponder 0.0.2.1

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,233 @@
+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
+                              )
+      
+      @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
+      
+      # 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
+      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
+      else
+        filter_type[event_types] << Filter.new(event_types, match, block)
+      end
+    end
+  end
+end
+

data/lib/ponder/version.rb

@@ -0,0 +1,3 @@
+module Ponder
+  VERSION = '0.0.2'
+end

data/ponder.gemspec

@@ -0,0 +1,38 @@
+Gem::Specification.new do |s|
+  s.name = 'ponder'
+  s.version = '0.0.2'
+  s.summary = 'IRC bot framework'
+  s.description = 'Ponder (Stibbons) is a Domain Specific Language for writing IRC Bots using the EventMachine library.'
+  
+  s.author = 'Tobias Bühlmann'
+  s.email = 'tobias.buehlmann@gmx.de'
+  s.homepage = 'http://github.com/tbuehlmann/ponder'
+  
+  s.required_ruby_version = '>= 1.8.6'
+  s.add_dependency('eventmachine', '>= 0.12.10')
+  s.files = ['examples/echo.rb',
+             'examples/github_blog.rb',
+             'examples/redis_last_seen.rb',
+             'lib/ponder/async_irc.rb', 
+             'lib/ponder/callback.rb',
+             'lib/ponder/connection.rb',
+             'lib/ponder/delegate.rb',
+             'lib/ponder/filter.rb',
+             'lib/ponder/formatting.rb',
+             'lib/ponder/irc.rb',
+             'lib/ponder/logger',
+             'lib/ponder/thaum.rb',
+             'lib/ponder/version.rb',
+             'lib/ponder/logger/blind_io.rb', 
+             'lib/ponder/logger/twoflogger.rb', 
+             'lib/ponder/logger/twoflogger18.rb',
+             'lib/ponder.rb',
+             'test/test_async_irc.rb',
+             'test/test_callback.rb', 
+             'test/test_helper.rb',
+             'test/test_irc.rb',
+             'LICENSE',
+             'ponder.gemspec',
+             'README.md']
+end
+

data/test/test_async_irc.rb

@@ -0,0 +1,108 @@
+require 'pathname'
+$LOAD_PATH.unshift Pathname.new(__FILE__).dirname.expand_path
+require 'test_helper'
+require 'ponder/async_irc'
+
+module Ponder
+  module AsyncIRC
+    def raw(*args)
+    end
+  end
+end
+
+include Ponder::AsyncIRC
+
+class TestIRC < Test::Unit::TestCase
+  def setup
+    @observer_queues = {}
+  end
+  
+  def test_get_topic_no_topic_set
+    topic = Thread.new do
+      assert_equal({:raw_numeric => 331, :message => 'No topic is set'}, get_topic('#mended_drum'))
+    end
+    
+    event_loop = Thread.new do
+      loop do
+        message = ':server 331 Ponder #mended_drum :No topic is set.'
+        @observer_queues.each do |queue, regexps|
+          regexps.each do |regexp|
+            if message =~ regexp
+              queue << message
+            end
+          end
+        end
+        
+        sleep 0.1
+      end
+    end
+    topic.join
+  end
+  
+  def test_get_topic
+    topic = Thread.new do
+      assert_equal({:raw_numeric => 332, :message => 'No dwarfs in here!'}, get_topic('#mended_drum'))
+    end
+    
+    event_loop = Thread.new do
+      loop do
+        message = ':server 332 Ponder #mended_drum :No dwarfs in here!'
+        @observer_queues.each do |queue, regexps|
+          regexps.each do |regexp|
+            if message =~ regexp
+              queue << message
+            end
+          end
+        end
+        
+        sleep 0.1
+      end
+    end
+    topic.join
+  end
+  
+  def test_get_topic_no_such_channel
+    topic = Thread.new do
+      assert_equal({:raw_numeric => 403, :message => 'No such channel'}, get_topic('#mended_drum'))
+    end
+    
+    event_loop = Thread.new do
+      loop do
+        message = ':server 403 Ponder #mended_drum :No such channel'
+        @observer_queues.each do |queue, regexps|
+          regexps.each do |regexp|
+            if message =~ regexp
+              queue << message
+            end
+          end
+        end
+        
+        sleep 0.1
+      end
+    end
+    topic.join
+  end
+  
+  def test_get_topic_you_are_not_on_that_channel
+    topic = Thread.new do
+      assert_equal({:raw_numeric => 442, :message => "You're not on that channel"}, get_topic('#mended_drum'))
+    end
+    
+    event_loop = Thread.new do
+      loop do
+        message = ":server 442 Ponder #mended_drum :You're not on that channel"
+        @observer_queues.each do |queue, regexps|
+          regexps.each do |regexp|
+            if message =~ regexp
+              queue << message
+            end
+          end
+        end
+        
+        sleep 0.1
+      end
+    end
+    topic.join
+  end
+end
+