isaac 0.2.2 → 0.2.5

data/README.rdoc

@@ -45,6 +45,13 @@ If you want to match private messages use the +on :private+ event:
     msg nick, "Login successful!"
   end
 
+You can also pass the RegExp captures as block arguments:
+    
+  on :channel, /catch this: (.*) and this: (.*)/ do |first, last|
+    # `first` will contain the first regexp capture,
+    # `last` the second.
+  end
+
 === Defining helpers
 Helpers should not be defined in the top level, but instead using the +helpers+-constructor:
 
@@ -67,20 +74,6 @@ Errors, as specified by RFC 1459, can be reacted upon as well. If you e.g. try t
 
 Available variables: +nick+ and +channel+.
 
-=== Send commands from outside an event (not implemented in Shaft atm)
-You might want to send messages, join channels etc. without it strictly being the result of an on()-event, e.g. send a message every time a RSS feed is updated or whatever. You can use +Isaac.execute+ for that, and all your normal commands, +msg+, +join+, +topic+ etc. will be available:
-
-  class K
-    def smoke(brand)
-      Isaac.execute { msg "harryjr", "you should smoke #{brand} cigarettes" }
-    end
-  end
-
-  on :connect do
-    k = K.new
-    k.smoke("Lucky Strike")
-  end
-
 == Contribute
 The source is hosted at GitHub: http://github.com/ichverstehe/isaac
 

data/isaac.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "isaac"
-  s.version  = "0.2.2"
-  s.date     = "2009-02-23"
+  s.version  = "0.2.5"
+  s.date     = "2009-04-25"
   s.summary  = "The smallish DSL for writing IRC bots"
   s.email    = "harry@vangberg.name"
   s.homepage = "http://github.com/ichverstehe/isaac"
@@ -16,3 +16,4 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--main", "README.rdoc"]
   s.extra_rdoc_files = ["LICENSE", "README.rdoc"]
 end
+

data/lib/isaac.rb

@@ -20,53 +20,29 @@ module Isaac
       instance_eval(&b) if block_given?
     end
 
-    def start
-      puts "========================================="
-      puts "Connecting to #{@config.server}:#{@config.port}"
-      @irc = IRC.new(self, @config)
-      @irc.connect
-      puts "========================================="
+    def configure(&b)
+      b.call(@config)
     end
 
-    def on(event, match=//, &b)
+    def on(event, match=//, &block)
       match = match.to_s if match.is_a? Integer
-      (@events[event] ||= []) << [Regexp.new(match), b]
+      (@events[event] ||= []) << [Regexp.new(match), block]
     end
 
     def helpers(&b)
-      instance_eval &b
-    end
-
-    def configure(&b)
-      b.call(@config)
-    end
-
-    def dispatch(event, env={})
-      self.nick, self.userhost, self.channel, self.error =
-        env[:nick], env[:userhost], env[:channel], env[:error]
-      self.message = env[:message] || ""
-
-      event = @events[event] && @events[event].detect do |regexp,_|
-        message.match(regexp)
-      end
-
-      if event
-        regexp, block = *event
-        self.match = message.match(regexp).captures
-        catch(:halt) { instance_eval(&block) }
-      end
+      instance_eval(&b)
     end
 
     def halt
       throw :halt
     end
 
-    def raw(m)
-      @irc.message(m)
+    def raw(command)
+      @irc.message(command)
     end
 
-    def msg(recipient, m)
-      raw("PRIVMSG #{recipient} :#{m}")
+    def msg(recipient, text)
+      raw("PRIVMSG #{recipient} :#{text}")
     end
 
     def join(*channels)
@@ -80,6 +56,44 @@ module Isaac
     def topic(channel, text)
       raw("TOPIC #{channel} :#{text}")
     end
+
+    def start
+      puts "Connecting to #{@config.server}:#{@config.port}" unless @config.environment == :test
+      @irc = IRC.new(self, @config)
+      @irc.connect
+    end
+
+    def dispatch(event, env={})
+      self.nick, self.userhost, self.channel, self.error =
+        env[:nick], env[:userhost], env[:channel], env[:error]
+      self.message = env[:message] || ""
+
+      if handler = find(event, message)
+        regexp, block = *handler
+        self.match = message.match(regexp).captures
+        invoke block
+      end
+    end
+
+  private
+    def find(type, message)
+      if events = @events[type]
+        events.detect {|regexp,_| message.match(regexp)}
+      end
+    end
+
+    def invoke(block)
+      mc = class << self; self; end
+      mc.send :define_method, :__isaac_event_handler, &block
+
+      bargs = case block.arity <=> 0
+        when -1; match
+        when 0; []
+        when 1; match[0..block.arity-1]
+      end
+
+      catch(:halt) { __isaac_event_handler(*bargs) }
+    end
   end
 
   class IRC
@@ -87,56 +101,44 @@ module Isaac
       @bot, @config = bot, config
       @transfered = 0
       @registration = []
-      @lock = false
-      @queue = []
     end
 
     def connect
       @socket = TCPSocket.open(@config.server, @config.port)
-      message "PASSWORD #{@config.password}" if @config.password
+      @queue = Queue.new(@socket, @bot.config.server)
+      message "PASS #{@config.password}" if @config.password
       message "NICK #{@config.nick}"
       message "USER #{@config.nick} 0 * :#{@config.realname}"
-      @lock = true
+      @queue.lock
 
-      # This should probably be somewhere else..
-      if @config.environment == :test
-        Thread.start {
-          while line = @socket.gets
-            parse line
-          end
-        }
-      else
-        while line = @socket.gets
-          parse line
-        end
+      while line = @socket.gets
+        parse line
       end
     end
 
     def parse(input)
       puts "<< #{input}" if @bot.config.verbose
-      case input
-      when /^:\S+ 00([1-4])/
-        @registration << $1.to_i
+      case input.chomp
+      when /(^:\S+ )?00([1-4])/
+        @registration << $2.to_i
         if registered?
-          @lock = false
+          @queue.unlock
           @bot.dispatch(:connect)
-          continue_queue
         end
-      when /^:(\S+)!\S+ PRIVMSG \S+ :?\001VERSION\001/
-        message "NOTICE #{$1} :\001VERSION #{@bot.config.version}\001"
+      when /(^:(\S+)!\S+ )?PRIVMSG \S+ :?\001VERSION\001/
+        message "NOTICE #{$2} :\001VERSION #{@bot.config.version}\001"
       when /^PING (\S+)/
-        @transfered, @lock = 0, false
+        @queue.unlock
         message "PONG #{$1}"
-      when /^:(\S+)!(\S+) PRIVMSG (\S+) :?(.*)/
-        env = { :nick => $1, :userhost => $2, :channel => $3, :message => $4 }
+      when /(^:(\S+)!(\S+) )?PRIVMSG (\S+) :?(.*)/
+        env = { :nick => $2, :userhost => $3, :channel => $4, :message => $5 }
         type = env[:channel].match(/^#/) ? :channel : :private
         @bot.dispatch(type, env)
-      when /^:\S+ ([4-5]\d\d) \S+ (\S+)/
-        env = {:error => $1.to_i, :message => $1, :nick => $2, :channel => $2}
+      when /(^:\S+ )?([4-5]\d\d) \S+ (\S+)/
+        env = {:error => $2.to_i, :message => $2, :nick => $3, :channel => $3}
         @bot.dispatch(:error, env)
-      when /^:\S+ PONG/
-        @transfered, @lock = 0, false
-        continue_queue
+      when /(^:\S+ )?PONG/
+        @queue.unlock
       end
     end
 
@@ -146,21 +148,60 @@ module Isaac
 
     def message(msg)
       @queue << msg
-      continue_queue
+    end
+  end
+
+  class Queue
+    def initialize(socket, server)
+      # We need  server  for pinging us out of an excess flood
+      @socket, @server = socket, server
+      @queue, @lock, @transfered = [], false, 0
+    end
+
+    def lock
+      @lock = true
+    end
+
+    def unlock
+      @lock, @transfered = false, 0
+      invoke
+    end
+
+    def <<(message)
+      @queue << message
+      invoke
+    end
+
+  private
+    def message_to_send?
+      !@lock && !@queue.empty?
+    end
+
+    def transfered_after_next_send
+      @transfered + @queue.first.size + 2 # the 2 is for \r\n
+    end
+
+    def exceed_limit?
+      transfered_after_next_send > 1472
+    end
+
+    def lock_and_ping
+      lock
+      @socket.print "PING :#{@server}\r\n"
+    end
+
+    def next_message
+      @queue.shift.to_s.chomp + "\r\n"
     end
 
-    def continue_queue
-      # <= 1472 allows for \n
-      while !@lock && msg = @queue.shift
-        if (@transfered + msg.size) < 1472
-          @socket.puts msg
-          puts ">> #{msg}" if @bot.config.verbose
-          @transfered += msg.size + 1
+    def invoke
+      while message_to_send?
+        if exceed_limit?
+          lock_and_ping; break
         else
-          @queue.unshift(msg)
-          @lock = true
-          @socket.puts "PING :#{@bot.config.server}"
-          break
+          @transfered = transfered_after_next_send
+          @socket.print next_message
+          # puts ">> #{msg}" if @bot.config.verbose
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: isaac
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.2.5
 platform: ruby
 authors: 
 - Harry Vangberg
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-23 00:00:00 +01:00
+date: 2009-04-25 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -29,6 +29,8 @@ files:
 - lib/isaac.rb
 has_rdoc: true
 homepage: http://github.com/ichverstehe/isaac
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -50,9 +52,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: isaac
-rubygems_version: 1.3.1
+rubygems_version: 1.3.3
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: The smallish DSL for writing IRC bots
 test_files: []