ponder 0.0.2 → 0.1.0

data/lib/ponder/thaum.rb

@@ -1,83 +1,88 @@
+require 'ponder/async_irc'
 require 'ponder/callback'
 require 'ponder/connection'
 require 'ponder/irc'
-require 'ponder/async_irc'
-require 'ponder/filter'
+require 'ponder/logger/twoflogger'
+require 'ponder/logger/blind_io'
 require 'ostruct'
+autoload :FileUtils, 'fileutils'
 
 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
-    
+    attr_accessor :connected, :logger, :console_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)
-      
+      @config = OpenStruct.new(
+        :server             => 'localhost',
+        :port               => 6667,
+        :nick               => 'Ponder',
+        :username           => 'Ponder',
+        :real_name          => 'Ponder',
+        :verbose            => true,
+        :logging            => false,
+        :reconnect          => true,
+        :reconnect_interval => 30
+      )
+
+      @logger = BlindIo.new
+      @console_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"
+      on :query, /^\001PING \d+\001$/ do |event_data|
+        time = event_data[:message].scan(/\d+/)[0]
+        notice event_data[:nick], "\001PING #{time}\001"
       end
-      
-      on :query, /^\001VERSION\001$/ do |env|
-        notice env[:nick], "\001VERSION Ponder #{Ponder::VERSION} (http://github.com/tbuehlmann/ponder)\001"
+
+      on :query, /^\001VERSION\001$/ do |event_data|
+        notice event_data[: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"
+
+      on :query, /^\001TIME\001$/ do |event_data|
+        notice event_data[: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'))
+        if @config.verbose
+          @console_logger = @config.console_logger if @config.console_logger
+        else
+          @console_logger = BlindIo.new
         end
-        
-        unless @config.verbose
-          @console_logger = @empty_logger
+
+        if @config.logging
+          log_path = @config.log_path || File.join(ROOT, 'logs', 'log.log')
+          log_dir = File.dirname(log_path)
+          FileUtils.mkdir_p(log_dir) unless File.exist?(log_dir)
+
+          if @config.logger
+            @logger = @config.logger
+          else
+            @logger = Twoflogger.new(log_path, File::WRONLY | File::APPEND)
+          end
         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) }
@@ -85,77 +90,73 @@ module Ponder
         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'
+        @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}"
+      @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
@@ -164,7 +165,7 @@ module Ponder
         end
       end
     end
-    
+
     # process callbacks with its begin; rescue; end
     def process_callbacks(event_type, event_data)
       @callbacks[event_type].each do |callback|
@@ -172,7 +173,7 @@ module Ponder
           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
@@ -180,19 +181,21 @@ module Ponder
                   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)
+              [@logger, @console_logger].each do |logger|
+                logger.error("-- #{e.class}: #{e.message}")
+                e.backtrace.each { |line| logger.error("-- #{line}") }
+              end
             end
           end
         )
@@ -202,24 +205,24 @@ module Ponder
     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)
+
+    def filter(filter_type, event_types = :all, match = //, block = Proc.new)
       if event_types.is_a?(Array)
         event_types.each do |event_type|
           filter_type[event_type] << Filter.new(event_type, match, block)

data/lib/ponder/version.rb

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

data/ponder.gemspec

@@ -1,39 +1,43 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'lib/ponder/version'
+
 Gem::Specification.new do |s|
   s.name = 'ponder'
-  s.version = '0.0.2'
+  s.version = Ponder::VERSION
+  s.date = '2011-01-29'
   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/ruby/1.8/string.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']
+  s.files = %w[
+    LICENSE
+    README.md
+    Rakefile
+    examples/echo.rb
+    examples/github_blog.rb
+    examples/redis_last_seen.rb
+    lib/ponder.rb
+    lib/ponder/async_irc.rb
+    lib/ponder/callback.rb
+    lib/ponder/connection.rb
+    lib/ponder/filter.rb
+    lib/ponder/formatting.rb
+    lib/ponder/irc.rb
+    lib/ponder/logger/blind_io.rb
+    lib/ponder/logger/twoflogger.rb
+    lib/ponder/thaum.rb
+    lib/ponder/version.rb
+    ponder.gemspec
+    test/test_async_irc.rb
+    test/test_callback.rb
+    test/test_helper.rb
+    test/test_irc.rb
+  ]
 end
 

data/test/test_async_irc.rb

@@ -1,18 +1,13 @@
-require 'pathname'
-$LOAD_PATH.unshift Pathname.new(__FILE__).dirname.expand_path
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
 require 'test_helper'
 require 'ponder/async_irc'
 
-module Ponder
-  module AsyncIRC
-    def raw(*args)
-    end
-  end
-end
-
 include Ponder::AsyncIRC
+def raw(*args)
+end
 
-class TestIRC < Test::Unit::TestCase
+class TestAsyncIRC < Test::Unit::TestCase
   def setup
     @observer_queues = {}
   end

data/test/test_callback.rb

@@ -1,5 +1,5 @@
-require 'pathname'
-$LOAD_PATH.unshift Pathname.new(__FILE__).dirname.expand_path
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
 require 'test_helper'
 require 'ponder/callback'
 
@@ -13,42 +13,43 @@ class TestCallback < Test::Unit::TestCase
   def setup
     @empty_proc = Proc.new { }
   end
-  
+
   def test_perfect_case
     callback = Ponder::Callback.new(:channel, /foo/, @empty_proc)
-    
+
     assert_equal(/foo/, callback.match)
     assert_equal(@empty_proc, callback.proc)
   end
-  
+
   def test_unsupported_event_type
     assert_raise(TypeError) do
       Ponder::Callback.new('fu', /foo/, @empty_proc)
     end
   end
-  
+
   def test_regexp
     assert_raise(TypeError) do
       Ponder::Callback.new(:channel, 8, @empty_proc)
     end
   end
-  
+
   def test_proc
     assert_raise(TypeError) do
       Ponder::Callback.new(:channel, /foo/, 8)
     end
   end
-  
+
   def test__trivial_proc
     proc = Proc.new { 7 + 1 }
-    
+
     assert_equal(proc, Ponder::Callback.new(:channel, //, proc).proc)
   end
-  
+
   def test_call
     proc = Proc.new { 8 }
-    
+
     assert_equal(8, Ponder::Callback.new(:channel, /wizzard/, proc).call(:channel, {:message => 'I like wizzards'}))
     assert_nil(Ponder::Callback.new(:channel, /wizzard/, proc).call(:channel, {:message => 'I am a wizard'}))
   end
 end
+