isaac 0.0.2 → 0.2.2

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[1]
     # 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.2"
-  s.date     = "2008-11-15"
+  s.version  = "0.2.2"
+  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,245 +1,183 @@
 require 'socket'
+
 module Isaac
-  # Returns the current instance of Isaac::Application
-  def self.app
-    @app ||= Application.new
-  end
+  VERSION = '0.2.1'
 
-  # 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)
+  Config = Struct.new(:server, :port, :password, :nick, :realname, :version, :environment, :verbose)
+
+  def self.bot
+    @bot ||= Bot.new
   end
 
-  Config = Struct.new(:nick, :server, :port, :username, :realname, :verbose)
-
-  # These are top level methods you use to construct your bot.
-  class Application
-    def initialize #:nodoc:
-      @events = Hash.new {|k,v| k[v] = []}
-    end
-
-    # This is plain stupid. Might be useful for logging or something later on.
-    def start #:nodoc:
-      puts " ==== Starting Isaac ==== "
-      loop { connect }
-      puts " ====  Ending Isaac  ==== "
-    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.verbose   = true
-    #   end
-    def config(&block)
-      @config = Config.new('isaac_bot', 'irc.freenode.net', 6667, 'isaac', 'isaac', false)
-      block.call(@config)
-      @config
-    end
-
-    # Methods defined inside the helpers-block will be available to on()-events at execution time.
-    def helpers(&block)
-      EventContext.class_eval(&block)
-    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
-    end
-
-    def execute(params={}, &block) #:nodoc:
-      event = Event.new(:dsl, block)
-      @queue << event.invoke(params)
-    end
-
-    def event(type, matcher)
-      @events[type].detect do |e| 
-        type == :error ? matcher == e.match : matcher =~ e.match
-      end
-    end
+  class Bot
+    attr_accessor :config, :irc, :nick, :channel, :message, :userhost, :match,
+      :error
 
-    def connect
-      begin
-        puts "Connecting to #{@config.server} at port #{@config.port}"
-        @irc = TCPSocket.open(@config.server, @config.port)
-        puts "Connection established."
-
-        @queue = Queue.new(@irc)
-        @queue << "NICK #{@config.nick}"
-        @queue << "USER #{@config.username} foobar foobar :#{@config.realname}"
-        @queue << @events[:connect].first.invoke if @events[:connect].first
-
-        while line = @irc.gets
-          handle line
-        end
-      rescue Interrupt => e
-        puts "Disconnected! An error occurred: #{e.inspect}"
-      rescue Timeout::Error => e
-        puts "Timeout: #{e}"
-      end
+    def initialize(&b)
+      @events = {}
+      @config = Config.new("localhost", 6667, nil, "isaac", "Isaac", 'isaac', :production, false)
+
+      instance_eval(&b) if block_given?
     end
 
-    # This is one hell of a nasty method. Something should be done, I suppose.
-    def handle(line)
-      puts "< #{line}" if @config.verbose
+    def start
+      puts "========================================="
+      puts "Connecting to #{@config.server}:#{@config.port}"
+      @irc = IRC.new(self, @config)
+      @irc.connect
+      puts "========================================="
+    end
 
-      case line
-      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+ ([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.
-        @queue << "PONG #{$1}" 
-      when /^:\S+ PONG \S+ :excess/
-        @queue.lock = false
-      end
+    def on(event, match=//, &b)
+      match = match.to_s if match.is_a? Integer
+      (@events[event] ||= []) << [Regexp.new(match), b]
     end
-  end
-  
-  class Queue #:nodoc:
-    attr_accessor :lock
-    def initialize(socket)
-      @socket     = socket
-      @queue      = []
-      @transfered = 0
-      @lock       = false
-      transmit
-    end
-
-    # I luvz Rubyz
-    def << (msg)
-      # .flatten! returns nill if no modifications were made, thus we do this. 
-      @queue = (@queue << msg).flatten
-    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.shift
-          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
-          end
-        end
-        sleep 0.1
-      }}
+
+    def helpers(&b)
+      instance_eval &b
     end
-  end
 
-  class Event #:nodoc:
-    attr_accessor :match, :block
-    def initialize(match, block)
-      @match    = match
-      @block    = block
+    def configure(&b)
+      b.call(@config)
     end
 
-    # Execute event in the context of EventContext.
-    def invoke(params={})
-      match = params[:message].match(@match) if @match && params[:message]
-      params.merge!(:match => match)
+    def dispatch(event, env={})
+      self.nick, self.userhost, self.channel, self.error =
+        env[:nick], env[:userhost], env[:channel], env[:error]
+      self.message = env[:message] || ""
 
-      context = EventContext.new(params)
-      context.instance_eval(&@block)
-      context.commands
+      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
     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 = []
+    def halt
+      throw :halt
     end
 
-    # Send a raw IRC message.
-    def raw(command)
-      @commands << command
+    def raw(m)
+      @irc.message(m)
     end
 
-    # Send a message to nick/channel.
-    def msg(recipient, text)
-      raw("PRIVMSG #{recipient} :#{text}")
+    def msg(recipient, m)
+      raw("PRIVMSG #{recipient} :#{m}")
     end
 
-    # Join channel(s):
-    #   join "#awesome_channel"
-    #   join "#rollercoaster", "#j-lo"
     def join(*channels)
       channels.each {|channel| raw("JOIN #{channel}")}
     end
 
-    # Part channel(s):
-    #   part "#awesome_channel"
-    #   part "#rollercoaster", "#j-lo"
     def part(*channels)
       channels.each {|channel| raw("PART #{channel}")}
     end
 
-    # Kick nick from channel, with optional comment.
-    def kick(channel, nick, comment=nil)
-      comment = " :#{comment}" if comment
-      raw("KICK #{channel} #{nick}#{comment}")
+    def topic(channel, text)
+      raw("TOPIC #{channel} :#{text}")
     end
+  end
 
-    # Change topic of channel.
-    def topic(channel, topic)
-      raw("TOPIC #{channel} :#{topic}")
+  class IRC
+    def initialize(bot, config)
+      @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
+      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
+
+    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
+
+    def registered?
+      ([1,2,3,4] - @registration).empty?
+    end
+
+    def message(msg)
+      @queue << msg
+      continue_queue
+    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
+        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: isaac
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.2.2
 platform: ruby
 authors: 
 - Harry Vangberg
@@ -9,12 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-15 00:00:00 +01:00
+date: 2009-02-23 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
 description: Small DSL for writing IRC bots.
-email: ichverstehe@gmail.com
+email: harry@vangberg.name
 executables: []
 
 extensions: []
@@ -50,7 +50,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: isaac
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: The smallish DSL for writing IRC bots