isaac 0.2.5 → 0.2.6

data/CHANGES

@@ -0,0 +1,43 @@
+= master / unreleasedd
+
+  * Require 'isaac/bot' to avoid top level bot/methods  [Julian Langschaedel]
+
+  * Add action(), kick() and mode()  [Danny Tatom]
+
+  * SSL support - configure {|c| c.ssl = true}  [postmodern]
+
+  * on :join/:part-events  [postmodern]
+
+= 0.2.5 / 2009-04-25
+
+  * Comply to the RFC - lines end with \r\n, not just \n.
+
+= 0.2.4 / 2009-04-01
+
+  * Bug fixes.
+
+= 0.2.3 / 2009-04-01
+
+  * Pass regular expression groups to block parameters.
+
+  * Internal refactoring of queue and tests.
+
+= 0.2.2 / 2009-02-23
+
+  * Irrelevant.
+
+= 0.2.1 / 2009-02-23
+
+  * config() has been renamed to configure().
+
+  * part() and topic() commands added.
+
+  * Comply to the RFC and wait for 001-004 messages until sending commands.
+
+  * Respond to CTCP action with the content of configure {|c| c.version = "" }.
+
+  * Improved documentation.
+
+= 0.2.0 / 2009-02-23
+
+  * This is a complete rewrite of Isaac.

data/README.rdoc

@@ -74,8 +74,48 @@ Errors, as specified by RFC 1459, can be reacted upon as well. If you e.g. try t
 
 Available variables: +nick+ and +channel+.
 
+=== Non-top level bots
+You might not want to pollute the top-level namespace with Isaac
+helpers, or you want to define multiple bots. This can be done
+easily, by requiring `isaac/bot` instead of `isaac`:
+
+  require 'isaac/bot'
+
+  bot = Isaac::Bot.new do
+    configure do
+      …
+    end
+
+    on :channel do
+      …
+    end
+  end
+
+  bot.start
+  
 == Contribute
 The source is hosted at GitHub: http://github.com/ichverstehe/isaac
 
 == License
-The MIT. Google it.
+Copyright (c) 2009 Harry Vangberg <harry@vangberg.name>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/isaac.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "isaac"
-  s.version  = "0.2.5"
-  s.date     = "2009-04-25"
+  s.version  = "0.2.6"
+  s.date     = "2009-12-21"
   s.summary  = "The smallish DSL for writing IRC bots"
   s.email    = "harry@vangberg.name"
   s.homepage = "http://github.com/ichverstehe/isaac"
@@ -9,11 +9,14 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "isaac"
   s.has_rdoc = true
   s.authors  = ["Harry Vangberg"]
-  s.files    = ["README.rdoc", 
-    "LICENSE",
+  s.files    = [
+    "README.rdoc", 
+    "CHANGES",
 		"isaac.gemspec", 
-		"lib/isaac.rb"]
+		"lib/isaac.rb",
+    "lib/isaac/bot.rb"
+  ]
   s.rdoc_options = ["--main", "README.rdoc"]
-  s.extra_rdoc_files = ["LICENSE", "README.rdoc"]
+  s.extra_rdoc_files = ["CHANGES", "README.rdoc"]
 end
 

data/lib/isaac.rb

@@ -1,217 +1,11 @@
-require 'socket'
+require 'isaac/bot'
 
-module Isaac
-  VERSION = '0.2.1'
-
-  Config = Struct.new(:server, :port, :password, :nick, :realname, :version, :environment, :verbose)
-
-  def self.bot
-    @bot ||= Bot.new
-  end
-
-  class Bot
-    attr_accessor :config, :irc, :nick, :channel, :message, :userhost, :match,
-      :error
-
-    def initialize(&b)
-      @events = {}
-      @config = Config.new("localhost", 6667, nil, "isaac", "Isaac", 'isaac', :production, false)
-
-      instance_eval(&b) if block_given?
-    end
-
-    def configure(&b)
-      b.call(@config)
-    end
-
-    def on(event, match=//, &block)
-      match = match.to_s if match.is_a? Integer
-      (@events[event] ||= []) << [Regexp.new(match), block]
-    end
-
-    def helpers(&b)
-      instance_eval(&b)
-    end
-
-    def halt
-      throw :halt
-    end
-
-    def raw(command)
-      @irc.message(command)
-    end
-
-    def msg(recipient, text)
-      raw("PRIVMSG #{recipient} :#{text}")
-    end
-
-    def join(*channels)
-      channels.each {|channel| raw("JOIN #{channel}")}
-    end
-
-    def part(*channels)
-      channels.each {|channel| raw("PART #{channel}")}
-    end
-
-    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
-    def initialize(bot, config)
-      @bot, @config = bot, config
-      @transfered = 0
-      @registration = []
-    end
-
-    def connect
-      @socket = TCPSocket.open(@config.server, @config.port)
-      @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}"
-      @queue.lock
-
-      while line = @socket.gets
-        parse line
-      end
-    end
-
-    def parse(input)
-      puts "<< #{input}" if @bot.config.verbose
-      case input.chomp
-      when /(^:\S+ )?00([1-4])/
-        @registration << $2.to_i
-        if registered?
-          @queue.unlock
-          @bot.dispatch(:connect)
-        end
-      when /(^:(\S+)!\S+ )?PRIVMSG \S+ :?\001VERSION\001/
-        message "NOTICE #{$2} :\001VERSION #{@bot.config.version}\001"
-      when /^PING (\S+)/
-        @queue.unlock
-        message "PONG #{$1}"
-      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 => $2.to_i, :message => $2, :nick => $3, :channel => $3}
-        @bot.dispatch(:error, env)
-      when /(^:\S+ )?PONG/
-        @queue.unlock
-      end
-    end
-
-    def registered?
-      ([1,2,3,4] - @registration).empty?
-    end
-
-    def message(msg)
-      @queue << msg
-    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 invoke
-      while message_to_send?
-        if exceed_limit?
-          lock_and_ping; break
-        else
-          @transfered = transfered_after_next_send
-          @socket.print next_message
-          # puts ">> #{msg}" if @bot.config.verbose
-        end
-      end
-    end
-  end
-end
+$bot = Isaac::Bot.new
 
 %w(configure helpers on).each do |method|
   eval(<<-EOF)
     def #{method}(*args, &block)
-      Isaac.bot.#{method}(*args, &block)
+      $bot.#{method}(*args, &block)
     end
   EOF
 end
@@ -219,6 +13,6 @@ end
 at_exit do
   unless defined?(Test::Unit)
     raise $! if $!
-    Isaac.bot.start
+    $bot.start
   end
 end

data/lib/isaac/bot.rb

@@ -0,0 +1,338 @@
+require 'socket'
+
+module Isaac
+  VERSION = '0.2.1'
+
+  Config = Struct.new(:server, :port, :ssl, :password, :nick, :realname, :version, :environment, :verbose)
+
+  class Bot
+    attr_accessor :config, :irc, :nick, :channel, :message, :user, :host, :match,
+      :error
+
+    def initialize(&b)
+      @events = {}
+      @config = Config.new("localhost", 6667, false, nil, "isaac", "Isaac", 'isaac', :production, false)
+
+      instance_eval(&b) if block_given?
+    end
+
+    def configure(&b)
+      b.call(@config)
+    end
+
+    def on(event, match=//, &block)
+      match = match.to_s if match.is_a? Integer
+      (@events[event] ||= []) << [Regexp.new(match), block]
+    end
+
+    def helpers(&b)
+      instance_eval(&b)
+    end
+
+    def halt
+      throw :halt
+    end
+
+    def raw(command)
+      @irc.message(command)
+    end
+
+    def msg(recipient, text)
+      raw("PRIVMSG #{recipient} :#{text}")
+    end
+
+    def action(recipient, text)
+      raw("PRIVMSG #{recipient} :\001ACTION #{text}\001")
+    end
+
+    def join(*channels)
+      channels.each {|channel| raw("JOIN #{channel}")}
+    end
+
+    def part(*channels)
+      channels.each {|channel| raw("PART #{channel}")}
+    end
+
+    def topic(channel, text)
+      raw("TOPIC #{channel} :#{text}")
+    end
+
+    def mode(channel, option)
+      raw("MODE #{channel} #{option}")
+    end
+
+    def kick(channel, user, reason=nil)
+      raw("KICK #{channel} #{user} :#{reason}")
+    end
+
+    def quit(message=nil)
+      command = message ? "QUIT :#{message}" : "QUIT"
+      raw command
+    end
+
+    def start
+      puts "Connecting to #{@config.server}:#{@config.port}" unless @config.environment == :test
+      @irc = IRC.new(self, @config)
+      @irc.connect
+    end
+
+    def message
+      @message ||= ""
+    end
+
+    def dispatch(event, msg=nil)
+      if msg
+        @nick, @user, @host, @channel, @error, @message = 
+          msg.nick, msg.user, msg.host, msg.channel, msg.error, msg.message
+      end
+
+      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
+
+      # -1  splat arg, send everything
+      #  0  no args, send nothing
+      #  1  defined number of args, send only those
+      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
+    def initialize(bot, config)
+      @bot, @config = bot, config
+      @transfered = 0
+      @registration = []
+    end
+
+    def connect
+      tcp_socket = TCPSocket.open(@config.server, @config.port)
+
+      if @config.ssl
+        begin
+          require 'openssl'
+        rescue ::LoadError
+          raise(RuntimeError,"unable to require 'openssl'",caller)
+        end
+
+        ssl_context = OpenSSL::SSL::SSLContext.new
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        unless @config.environment == :test
+          puts "Using SSL with #{@config.server}:#{@config.port}"
+        end
+
+        @socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+        @socket.sync = true
+        @socket.connect
+      else
+        @socket = tcp_socket
+      end
+
+      @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}"
+      @queue.lock
+
+      while line = @socket.gets
+        parse line
+      end
+    end
+
+    def parse(input)
+      puts "<< #{input}" if @bot.config.verbose
+      msg = Message.new(input)
+
+      if ("001".."004").include? msg.command
+        @registration << msg.command
+        if registered?
+          @queue.unlock
+          @bot.dispatch(:connect)
+        end
+      elsif msg.command == "PRIVMSG"
+        if msg.params.last == "\001VERSION\001"
+          message "NOTICE #{msg.nick} :\001VERSION #{@bot.config.version}\001"
+        end
+
+        type = msg.channel? ? :channel : :private
+        @bot.dispatch(type, msg)
+      elsif msg.error?
+        @bot.dispatch(:error, msg)
+      elsif msg.command == "PING"
+        @queue.unlock
+        message "PONG :#{msg.params.first}"
+      elsif msg.command == "PONG"
+        @queue.unlock
+      else
+        event = msg.command.downcase.to_sym
+        @bot.dispatch(event, msg)
+      end
+    end
+
+    def registered?
+      (("001".."004").to_a - @registration).empty?
+    end
+
+    def message(msg)
+      @queue << msg
+    end
+  end
+
+  class Message
+    attr_accessor :raw, :prefix, :command, :params
+
+    def initialize(msg=nil)
+      @raw = msg
+      parse if msg
+    end
+
+    def numeric_reply?
+      @numeric_reply ||= !!@command.match(/^\d\d\d$/)
+    end
+
+    def parse
+      match = @raw.match(/(^:(\S+) )?(\S+)(.*)/)
+      _, @prefix, @command, raw_params = match.captures
+
+      raw_params.strip!
+      if match = raw_params.match(/:(.*)/)
+        @params = match.pre_match.split(" ")
+        @params << match[1]
+      else
+        @params = raw_params.split(" ")
+      end
+    end
+
+    def nick
+      return unless @prefix
+      @nick ||= @prefix[/^(\S+)!/, 1]
+    end
+
+    def user
+      return unless @prefix
+      @user ||= @prefix[/^\S+!(\S+)@/, 1]
+    end
+
+    def host
+      return unless @prefix
+      @host ||= @prefix[/@(\S+)$/, 1]
+    end
+
+    def server
+      return unless @prefix
+      return if @prefix.match(/[@!]/)
+      @server ||= @prefix[/^(\S+)/, 1]
+    end
+
+    def error?
+      !!error
+    end
+
+    def error
+      return @error if @error
+      @error = command.to_i if numeric_reply? && command[/[45]\d\d/]
+    end
+
+    def channel?
+      !!channel
+    end
+
+    def channel
+      return @channel if @channel
+      if regular_command? and params.first.start_with?("#")
+        @channel = params.first
+      end
+    end
+
+    def message
+      return @message if @message
+      if error?
+        @message = error.to_s
+      elsif regular_command?
+        @message = params.last
+      end
+    end
+
+    private
+    # This is a late night hack. Fix.
+    def regular_command?
+      %w(PRIVMSG JOIN PART QUIT).include? command
+    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 invoke
+      while message_to_send?
+        if exceed_limit?
+          lock_and_ping; break
+        else
+          @transfered = transfered_after_next_send
+          @socket.print next_message
+          # puts ">> #{msg}" if @bot.config.verbose
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: isaac
 version: !ruby/object:Gem::Version 
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors: 
 - Harry Vangberg
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-25 00:00:00 +02:00
+date: 2009-12-21 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -20,13 +20,14 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- LICENSE
+- CHANGES
 - README.rdoc
 files: 
 - README.rdoc
-- LICENSE
+- CHANGES
 - isaac.gemspec
 - lib/isaac.rb
+- lib/isaac/bot.rb
 has_rdoc: true
 homepage: http://github.com/ichverstehe/isaac
 licenses: []

data/LICENSE

@@ -1,6 +0,0 @@
-------------------------------------------------------------------------------
-"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.
-------------------------------------------------------------------------------