ichverstehe-isaac 0.0.4 → 0.2.1

data/README.rdoc

@@ -1,5 +1,4 @@
 = Isaac - the smallish DSL for writing IRC bots
-You want to create an IRC bot quickly? Then Isaac is you. It will be. At some point, at least. But you shall be welcome to try it out and help me extend and beautify it. Be aware, the code is not stellar by any measure, most likely it is very crude and a large portion of the IRC standard has not been implemented, simply because I haven't needed it yet. Oh, and a lot of concepts were borrowed from Sinatra (http://sinatrarb.com). Thanks.
 
 == Features
 * Wraps parsing of incoming messages and raw IRC commands in simple constructs.
@@ -9,7 +8,7 @@ You want to create an IRC bot quickly? Then Isaac is you. It will be. At some po
 == Getting started
 An Isaac-bot needs a few basics:
   require 'isaac'
-  config do |c|
+  configure do |c|
     c.nick    = "AwesomeBot"
     c.server  = "irc.freenode.net"
     c.port    = 6667
@@ -25,21 +24,23 @@ After the bot has connected to the IRC server you might want to join some channe
 === Responding to messages
 Joining a channel and sitting idle is not much fun. Let's repeat everything being said in these channels:
 
-  on :channel, /.*/ do
+  on :channel, // do
     msg channel, message
   end
 
-Notice the +channel+ and +message+ variables. Additionally +nick+ and +match+ is available for channel-events. +nick+ being the sender of the message, +match+ being a MatchData object returned by the regular expression you specified:
+Notice the +channel+ and +message+ variables. Additionally +nick+ and +match+ is
+available for channel-events. +nick+ being the sender of the message, +match+
+being an array of captures from the regular expression:
 
   on :channel, /^quote this: (.*)/ do
-    msg channel, "Quote: '#{match[1]}' by #{nick}"
+    msg channel, "Quote: '#{match[0]}' by #{nick}"
   end
 
 If you want to match private messages use the +on :private+ event:
 
   on :private, /^login (\S+) (\S+)/ do
-    username = match[1]
-    password = match[2]
+    username = match[0]
+    password = match[0]
     # do something to authorize or whatevz.
     msg nick, "Login successful!"
   end
@@ -66,7 +67,7 @@ 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
+=== 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
@@ -84,11 +85,4 @@ You might want to send messages, join channels etc. without it strictly being th
 The source is hosted at GitHub: http://github.com/ichverstehe/isaac
 
 == License
-  ------------------------------------------------------------------------------
-  "THE BEER-WARE LICENSE" (Revision 42):
-  <ichverstehe@gmail.com> wrote this file. As long as you retain this notice you
-  can do whatever you want with this stuff. If we meet some day, and you think
-  this stuff is worth it, you can buy me a beer in return.
-  ------------------------------------------------------------------------------
-
-
+The MIT. Google it.

data/isaac.gemspec

@@ -1,9 +1,9 @@
 Gem::Specification.new do |s|
   s.name     = "isaac"
-  s.version  = "0.0.4"
-  s.date     = "2009-01-28"
+  s.version  = "0.2.1"
+  s.date     = "2009-02-23"
   s.summary  = "The smallish DSL for writing IRC bots"
-  s.email    = "ichverstehe@gmail.com"
+  s.email    = "harry@vangberg.name"
   s.homepage = "http://github.com/ichverstehe/isaac"
   s.description = "Small DSL for writing IRC bots."
   s.rubyforge_project = "isaac"

data/lib/isaac.rb

@@ -1,305 +1,180 @@
 require 'socket'
+
 module Isaac
-  # Returns the current instance of Isaac::Application
-  def self.app
-    @app ||= Application.new
-  end
+  VERSION = '0.2.1'
+
+  Config = Struct.new(:server, :port, :password, :nick, :realname, :version, :environment, :verbose)
 
-  # Use EventContext methods such as msg(), join() etc. outside on()-events. See +examples/execute.rb+.
-  #   Isaac.execute do
-  #     msg 'harryjr', 'you're awesome'
-  #   end
-  def self.execute(params={}, &block)
-    app.execute(params, &block)
+  def self.bot
+    @bot ||= Bot.new
   end
 
-  Config = Struct.new(:nick, :server, :port, :username, :realname, :version, :verbose, :password)
+  class Bot
+    attr_accessor :config, :irc, :nick, :channel, :message, :userhost, :match,
+      :error
 
-  # These are top level methods you use to construct your bot.
-  class Application
-    def initialize #:nodoc:
-      @events = Hash.new {|k,v| k[v] = []}
-      @registration = []
-    end
+    def initialize(&b)
+      @events = {}
+      @config = Config.new("localhost", 6667, nil, "isaac", "Isaac", 'isaac', :production, false)
 
-    # This is plain stupid. Might be useful for logging or something later on.
-    def start #:nodoc:
-      puts " ==== Starting Isaac ==== "
-      connect
-      puts " ====  Ending Isaac  ==== "
+      instance_eval(&b) if block_given?
     end
 
-    # Configure the bot:
-    #   config do |c|
-    #     c.server    = "irc.freenode.net"
-    #     c.nick      = "AwesomeBot"
-    #     c.port      = 6667
-    #     c.realname  = "James Dean"
-    #     c.username  = "jdean"
-    #     c.version   = "James Dean Bot v2.34"
-    #     c.verbose   = true
-    #   end
-    def config(&block)
-      @config = Config.new('isaac_bot', 'irc.freenode.net', 6667, 'isaac', 'isaac', 'isaac-bot', false)
-      block.call(@config)
-      @config
+    def start
+      @irc = IRC.new(self, @config)
+      @irc.connect
     end
 
-    # Methods defined inside the helpers-block will be available to on()-events at execution time.
-    def helpers(&block)
-      EventContext.class_eval(&block)
+    def on(event, match=//, &b)
+      match = match.to_s if match.is_a? Integer
+      (@events[event] ||= []) << [Regexp.new(match), b]
     end
 
-    # on()-events responds to certain actions. Depending on +type+ certain local variables are available:
-    # +nick+, +channel+, +message+ and in particular +match+, which contains a MatchData object returned 
-    # by the given regular expression.
-    #
-    # * Do something after connection has been established, e.g. join channels.
-    #     on :connect do
-    #       join "#awesome_channel", "#lee_marvin_fans"
-    #     end
-    # * Respond to private messages matching a given regular expression.
-    #     on :private, /^echo (.*)/ do
-    #       msg nick, "You said '#{match[1]}!"
-    #     end
-    # * Respond to messages matching a given regular expression send to a channel.
-    #     on :channel, /quote/ do
-    #       msg channel, "#{nick} requested a quote: 'Smoking, a subtle form a suicide.' - Vonnegut"
-    #     end
-    # * Respond to error codes, according to the RFC.
-    #     on :error, 401 do
-    #       # Execute this if you try to send a message to a non-existing nick/channel.
-    #     end
-    def on(type, match=nil, &block)
-      @events[type] << e = Event.new(match, block)
-      return e
+    def helpers(&b)
+      instance_eval &b
     end
 
-    def execute(params={}, &block) #:nodoc:
-      event = Event.new(:dsl, block)
-      @queue << event.invoke(params)
+    def configure(&b)
+      b.call(@config)
     end
 
-    def event(type, matcher)
-      @events[type].detect do |e| 
-        type == :error ? matcher == e.match : matcher =~ e.match
-      end
-    end
-
-    def connect
-      begin
-        puts "Connecting to #{@config.server} at port #{@config.port}"
-        @irc = TCPSocket.open(@config.server, @config.port)
-        puts "Connection established."
-	
-      	@irc.puts "PASS #{@config.password}" if @config.password
-        @irc.puts "NICK #{@config.nick}"
-        @irc.puts "USER #{@config.username} foobar foobar :#{@config.realname}"
+    def dispatch(event, env={})
+      self.nick, self.userhost, self.channel, self.error =
+        env[:nick], env[:userhost], env[:channel], env[:error]
+      self.message = env[:message] || ""
 
-        @queue = Queue.new(@irc)
-        @queue << @events[:connect].first.invoke if @events[:connect].first
+      event = @events[event] && @events[event].detect do |regexp,_|
+        message.match(regexp)
+      end
 
-        while line = @irc.gets
-          handle line
-        end
-      rescue Interrupt => e
-        puts "Disconnected! An error occurred: #{e.inspect}"
-      rescue Timeout::Error => e
-        puts "Timeout: #{e}. Reconnecting."
-        connect
+      if event
+        regexp, block = *event
+        self.match = message.match(regexp).captures
+        catch(:halt) { instance_eval(&block) }
       end
     end
 
-    def registered?
-      arr = [1,2,3,4] - @registration 
-      arr.empty?
+    def halt
+      throw :halt
     end
 
-    # This is one hell of a nasty method. Something should be done, I suppose.
-    def handle(line)
-      puts "> #{line}" if @config.verbose
-
-      case line
-      when /^:(\S+)!\S+ PRIVMSG \S+ :?\001VERSION\001/
-        @queue << "NOTICE #{$1} :\001VERSION #{@config.version}\001"
-      when /^:(\S+)!(\S+) PRIVMSG (\S+) :?(.*)/
-        nick, userhost, channel, message = $1, $2, $3, $4
-        type = channel.match(/^#/) ? :channel : :private
-        if event = event(type, message)
-          @queue << event.invoke(:nick => nick, :userhost => userhost, :channel => channel, :message => message)
-        end
-      when /^:\S+ 00([1-4])/
-        @registration << $1.to_i
-        @queue.lock = false if registered?
-      when /^:\S+ ([4-5]\d\d) \S+ (\S+)/
-        error = $1
-        nick = channel = $2
-        if event = event(:error, error.to_i)
-          @queue << event.invoke(:nick => nick, :channel => channel)
-        end
-      when /^PING (\S+)/
-        #TODO not sure this is correct. Damned RFC.
-	if registered?
-	  @queue << "PONG #{$1}"
-        else
-          @irc.puts "PONG #{$1}"
-        end
-      when /^:\S+ PONG \S+ :excess/
-        @queue.lock = false
-      end
-    end
-  end
-  
-  class Queue #:nodoc:
-    attr_accessor :lock
-    def initialize(socket)
-      @socket     = socket
-      @queue      = []
-      @transfered = 0
-      @lock       = true
-      transmit
+    def raw(m)
+      @irc.message(m)
     end
 
-    # I luvz Rubyz
-    def << (msg)
-      # .flatten! returns nill if no modifications were made, thus we do this. 
-      @queue = (@queue << msg).flatten
+    def msg(recipient, m)
+      raw("PRIVMSG #{recipient} :#{m}")
     end
 
-    # To prevent excess flood no more than 1472 bytes will be sent to the
-    # server. When that limit is reached, @lock = true and the server will be
-    # PINGed. @lock will be true until a PONG is received (Application#handle).
-    def transmit
-      Thread.start { loop {
-        unless @lock || @queue.empty?
-          msg = @queue.first
-          if (@transfered + msg.size) > 1472
-            # No honestly, :excess. The RFC is not too clear on this subject TODO
-            @socket.puts "PING :excess"
-            @lock = true
-            @transfered = 0
-          else
-            @socket.puts msg
-            @transfered += msg.size
-            @queue.shift
-          end
-        end
-        sleep 0.1
-      }}
+    def join(*channels)
+      channels.each {|channel| raw("JOIN #{channel}")}
     end
-  end
 
-  class Event #:nodoc:
-    attr_accessor :match, :block
-    def initialize(match, block)
-      @match    = match
-      @block    = block
+    def part(*channels)
+      channels.each {|channel| raw("PART #{channel}")}
     end
 
-    # Execute event in the context of EventContext.
-    def invoke(params={})
-      match = params[:message].match(@match) if @match && params[:message]
-      params.merge!(:match => match)
-
-      context = EventContext.new(params)
-      context.instance_eval(&@block)
-      context.commands
+    def topic(channel, text)
+      raw("TOPIC #{channel} :#{text}")
     end
   end
 
-  class EventContext
-    attr_accessor :nick, :userhost, :channel, :message, :match, :commands
-    def initialize(args = {})
-      args.each {|k,v| instance_variable_set("@#{k}",v)}
-      @commands = []
-    end
-
-    # Send a raw IRC message.
-    def raw(command)
-      @commands << command
+  class IRC
+    def initialize(bot, config)
+      @bot, @config = bot, config
+      @transfered = 0
+      @registration = []
+      @lock = false
+      @queue = []
     end
 
-    # Send a message to nick/channel.
-    def msg(recipient, text)
-      raw("PRIVMSG #{recipient} :#{text}")
+    def connect
+      @socket = TCPSocket.open(@config.server, @config.port)
+      message "PASSWORD #{@config.password}" if @config.password
+      message "NICK #{@config.nick}"
+      message "USER #{@config.nick} 0 * :#{@config.realname}"
+      @lock = true
+
+      # 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
+      end
     end
 
-    # Send a notice to nick/channel
-    def notice(recipient, text)
-      raw("PRIVMSG #{recipient} :#{text}")
-    end
-    
-    # Set modes(s)
-    # mode "#awesome" "+im"
-    # mode "arnie" "+o-v"
-    # mode "#awesome" "+k" "password"
-    def mode(target, mode, option=nil)
-      option = " #{option}" if option
-      raw "MODE #{target} #{mode}#{option}"
-    end
-    
-    # Ban a hostmask
-    # ban_mask "#awesome" "*!*@*"
-    def ban_mask(channel, mask)
-      mode channel, "+b", mask
-    end
-    
-    # Unban a hostmask
-    # unban_mask "#awesome" "*!*@*"
-    def unban_mask(channel, mask)
-      mode channel, "-b", mask
-    end    
-    
-    # Join channel(s):
-    #   join "#awesome_channel"
-    #   join "#rollercoaster", "#j-lo"
-    def join(*channels)
-      channels.each {|channel| raw("JOIN #{channel}")}
+    def parse(input)
+      puts "<< #{input}" if @bot.config.verbose
+      case input
+      when /^:\S+ 00([1-4])/
+        @registration << $1.to_i
+        if registered?
+          @lock = false
+          @bot.dispatch(:connect)
+          continue_queue
+        end
+      when /^:(\S+)!\S+ PRIVMSG \S+ :?\001VERSION\001/
+        message "NOTICE #{$1} :\001VERSION #{@bot.config.version}\001"
+      when /^PING (\S+)/
+        @transfered, @lock = 0, false
+        message "PONG #{$1}"
+      when /^:(\S+)!(\S+) PRIVMSG (\S+) :?(.*)/
+        env = { :nick => $1, :userhost => $2, :channel => $3, :message => $4 }
+        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}
+        @bot.dispatch(:error, env)
+      when /^:\S+ PONG/
+        @transfered, @lock = 0, false
+        continue_queue
+      end
     end
 
-    # Part channel(s):
-    #   part "#awesome_channel"
-    #   part "#rollercoaster", "#j-lo"
-    def part(*channels)
-      channels.each {|channel| raw("PART #{channel}")}
+    def registered?
+      ([1,2,3,4] - @registration).empty?
     end
 
-    # Kick nick from channel, with optional comment.
-    def kick(channel, nick, comment=nil)
-      comment = " :#{comment}" if comment
-      raw("KICK #{channel} #{nick}#{comment}")
+    def message(msg)
+      @queue << msg
+      continue_queue
     end
 
-    # Change topic of channel.
-    def topic(channel, topic)
-      raw("TOPIC #{channel} :#{topic}")
-    end
-    
-    # Invite nicks to channel
-    #    invite "#awesome_channel", "arnie"
-    #    invite "#awesome_channel", "arnie", "brigitte"
-    def invite(channel, *nicks)
-      nicks.each {|nick| raw("INVITE #{nick} #{channel}")}
-    end
-    
-    # Change nickname
-    def set_nick(nickname)
-      raw("NICK #{nickname}")
+    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
+        else
+          @queue.unshift(msg)
+          @lock = true
+          @socket.puts "PING :#{@bot.config.server}"
+          break
+        end
+      end
     end
   end
 end
 
-# Assign methods to current Isaac instance
-%w(config helpers on).each do |method|
+%w(configure helpers on).each do |method|
   eval(<<-EOF)
     def #{method}(*args, &block)
-      Isaac.app.#{method}(*args, &block)
+      Isaac.bot.#{method}(*args, &block)
     end
   EOF
 end
 
-# Clever, thanks Sinatra.
 at_exit do
-  raise $! if $!
-  Isaac.app.start
+  unless defined?(Test::Unit)
+    raise $! if $!
+    Isaac.bot.start
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ichverstehe-isaac
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.2.1
 platform: ruby
 authors: 
 - Harry Vangberg
@@ -9,12 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-28 00:00:00 -08:00
+date: 2009-02-23 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
 description: Small DSL for writing IRC bots.
-email: ichverstehe@gmail.com
+email: harry@vangberg.name
 executables: []
 
 extensions: []