newton 0.0.1

data/lib/newton/syncable.rb

@@ -0,0 +1,55 @@
+module Newton
+  module Syncable
+    # Blocks until the object is synced.
+    #
+    # @return [void]
+    def wait_until_synced(attr)
+      attr = attr.to_sym
+      while true
+        return if @synced_attributes.include?(attr)
+        sleep 0.1
+      end
+    end
+
+    # @api private
+    # @return [void]
+    def sync(attribute, value, data = false)
+      if data
+        @data[attribute] = value
+      else
+        instance_variable_set("@#{attribute}", value)
+      end
+      @synced_attributes << attribute
+    end
+
+    def synced?(attribute)
+      @synced_attributes.include?(attribute)
+    end
+
+    def unsync(attribute)
+      @synced_attributes.delete(attribute)
+    end
+
+    # @api private
+    def attr(attribute, data = false, unsync = false)
+      unless unsync
+        if @when_requesting_synced_attribute
+          @when_requesting_synced_attribute.call(attribute)
+        end
+        wait_until_synced(attribute)
+      end
+
+      if data
+        return @data[attribute]
+      else
+        return instance_variable_get("@#{attribute}")
+      end
+    end
+
+    # @api private
+    # @return [void]
+    def mark_as_synced(attribute)
+      @synced_attributes << attribute
+    end
+  end
+end

data/lib/newton/user.rb

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+module Newton
+  class User
+    include Syncable
+
+    @users = {}
+    class << self
+
+      # @overload find_ensured(nick, bot)
+      #   Finds or creates a user based on his nick.
+      #
+      #   @param [String] nick The user's nickname
+      #   @param [Bot]    bot  An instance of Bot
+      # @overload find_ensured(user, nick, host, bot)
+      #   Finds or creates a user based on his nick but already
+      #   setting user and host.
+      #
+      #   @param [String] user The username
+      #   @param [String] nick The nickname
+      #   @param [String] host The user's hostname
+      #   @param [Bot]    bot  An instance of bot
+      #
+      # @return [User]
+      def find_ensured(*args)
+        # FIXME CASEMAPPING
+        case args.size
+        when 2
+          nick = args.first
+          bargs = [args.first]
+          bot  = args.last
+        when 4
+          nick = args[1]
+          bot = args.pop
+          bargs = args
+        else
+          raise ArgumentError
+        end
+        downcased_nick = nick.irc_downcase(bot.irc.isupport["CASEMAPPING"])
+        @users[downcased_nick] ||= new(*bargs, bot)
+        @users[downcased_nick]
+      end
+
+      # Finds a user.
+      #
+      # @param [String] nick nick of a user
+      # @return [User, nil]
+      def find(nick)
+        @users[nick]
+      end
+
+      # @return [Array<User>] Returns all users
+      def all
+        @users.values
+      end
+    end
+
+
+    # @return [String]
+    attr_accessor :nick
+    # @return [Bot]
+    attr_accessor :bot
+    # @return [Boolean]
+    attr_accessor :synced
+
+    # By default, you can use methods like User#user, User#host and
+    # alike – If you however fear that another thread might change
+    # data while you're using it and if this means a critical issue to
+    # your code, you can store the result of this method and work with
+    # that instead.
+    #
+    # @example
+    #   on :channel do
+    #     data = user.data
+    #     do_something_with(data.user)
+    #     do_something_with(data.host)
+    #   end
+    # @return [Hash]
+    attr_accessor :data
+    def initialize(*args)
+      @data = {
+        :user         => nil,
+        :host         => nil,
+        :realname     => nil,
+        :authname     => nil,
+        :idle         => 0,
+        :signed_on_at => nil,
+        :unknown?     => false,
+        :channels     => [],
+        :secure?      => false,
+      }
+      case args.size
+      when 2
+        @nick, @bot = args
+      when 4
+        @data[:user], @nick, @data[:host], @bot = args
+      else
+        raise ArgumentError
+      end
+
+      @synced_attributes  = Set.new
+
+      @when_requesting_synced_attribute = lambda {|attr|
+        unless @synced
+          unsync attr
+          whois
+        end
+      }
+    end
+
+    # Checks if the user is identified. Currently officially supports
+    # Quakenet and Freenode.
+    #
+    # @return [Boolean] true if the user is identified
+    def authed?
+      @data[:authname]
+    end
+
+    # Queries the IRC server for information on the user. This will
+    # set the User's state to not synced. After all information are
+    # received, the object will be set back to synced.
+    #
+    # @return [void]
+    def whois
+      @synced = false
+      @data.keys.each do |attr|
+        unsync attr
+      end
+      @bot.raw "WHOIS #@nick #@nick"
+    end
+
+    # Send a message to the user.
+    #
+    # @param [String] message the message
+    # @return [void]
+    def send(message)
+      @bot.msg(@nick, message)
+    end
+    alias_method :privmsg, :send
+
+    # Send a CTCP to the user.
+    #
+    # @param [String] message the ctcp message
+    # @return [void]
+    def ctcp(message)
+      send "\001#{message}\001"
+    end
+
+    # Send an action (/me) to the user.
+    #
+    # @param [String] message the message
+    # @return [void]
+    def action(message)
+      @bot.action(@name, message)
+    end
+
+    # @return [String]
+    def to_s
+      @nick
+    end
+
+    # @return [String]
+    def inspect
+      "#<User nick=#{@nick.inspect}>"
+    end
+
+    # Generates a mask for the user.
+    #
+    # @param [String] s a pattern for generating the mask. %n =
+    # nickname – %u = username – %h = host – %r = realname – %a =
+    # authname
+    #
+    # @return [Mask]
+    def mask(s = "%n!%u@%h")
+      s = s.gsub(/%(.)/) {
+        case $1
+        when "n"
+          @nick
+        when "u"
+          self.user
+        when "h"
+          self.host
+        when "r"
+          self.realname
+        when "a"
+          self.authname
+        end
+      }
+
+      Mask.new(s)
+    end
+
+    # Provides synced access to user attributes.
+    def method_missing(m, *args)
+      if m.to_s =~ /^(.+)_unsynced$/
+        m = $1.to_sym
+        unsync = true
+      end
+
+      if @data.has_key?(m)
+        attr(m, true, unsync = false)
+      else
+        super
+      end
+    end
+
+    # @return [Boolean]
+    def ==(other)
+      return case other
+             when self.class
+               @nick == other.nick
+             when String
+               self.to_s == other
+             when Bot
+               self.nick == other.config.nick
+             else
+               false
+             end
+    end
+    alias_method :eql?, "=="
+
+    # @return [Fixnum]
+    def hash
+      @nick.hash
+    end
+  end
+end

data/lib/newton.rb

@@ -0,0 +1 @@
+require 'newton/bot'

data/test/helper.rb

@@ -0,0 +1,60 @@
+$LOAD_PATH.unshift 'lib'
+require 'newton'
+require 'rubygems'
+require 'test/unit'
+require 'contest'
+require 'rr'
+require 'timeout'
+begin
+  require 'ruby-debug'
+rescue LoadError; end
+
+module Test::Unit::Assertions
+  def assert_empty_buffer(io)
+    assert_raise(Errno::EAGAIN) { io.read_nonblock 1 }
+  end
+end
+
+class MockSocket
+  def self.pipe
+    socket1, socket2 = new, new
+    socket1.in, socket2.out = IO.pipe
+    socket2.in, socket1.out = IO.pipe
+    [socket1, socket2]
+  end
+
+  attr_accessor :in, :out
+  def gets()
+    Timeout.timeout(1) {@in.gets}
+  end
+  def puts(m) @out.puts(m) end
+  def print(m) @out.print(m) end
+  def eof?() @in.eof? end
+  def empty?
+    begin
+      @in.read_nonblock(1)
+      false
+    rescue Errno::EAGAIN
+      true
+    end
+  end
+end
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+
+  def mock_bot(&b)
+    @socket, @server = MockSocket.pipe
+    stub(TCPSocket).open(anything, anything) {@socket}
+    bot = Newton::Bot.new(&b)
+    bot.config.environment = :test
+    Thread.start { bot.start }
+    bot
+  end
+
+  def bot_is_connected
+    assert_equal "NICK isaac\r\n", @server.gets
+    assert_equal "USER isaac 0 * :Isaac\r\n", @server.gets
+    1.upto(4) {|i| @server.print ":localhost 00#{i}\r\n"}
+  end
+end

data/test/test_commands.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestCommands < Test::Unit::TestCase
+  test "raw messages can be send" do
+    bot = mock_bot {}
+    bot_is_connected
+
+    bot.raw "PRIVMSG foo :bar baz"
+    assert_equal "PRIVMSG foo :bar baz\r\n", @server.gets
+  end
+
+  test "messages are sent to recipient" do
+    bot = mock_bot {}
+    bot_is_connected
+
+    bot.msg "foo", "bar baz"
+    assert_equal "PRIVMSG foo :bar baz\r\n", @server.gets
+  end
+
+  test "actions are sent to recipient" do
+    bot = mock_bot {}
+    bot_is_connected
+
+    bot.action "foo", "bar"
+    assert_equal "PRIVMSG foo :\001ACTION bar\001\r\n", @server.gets
+  end
+
+  test "channels are joined" do
+    bot = mock_bot {}
+    bot_is_connected
+
+    bot.join "#foo", "#bar"
+    assert_equal "JOIN #foo\r\n", @server.gets
+    assert_equal "JOIN #bar\r\n", @server.gets
+  end
+
+  test "channels are parted" do
+    bot = mock_bot {}
+    bot_is_connected
+
+    bot.part "#foo", "#bar"
+    assert_equal "PART #foo\r\n", @server.gets
+    assert_equal "PART #bar\r\n", @server.gets
+  end
+
+  test "topic is set" do
+    bot = mock_bot {}
+    bot_is_connected
+
+    bot.topic "#foo", "bar baz"
+    assert_equal "TOPIC #foo :bar baz\r\n", @server.gets
+  end
+
+  test "modes can be set" do
+    bot = mock_bot {}
+    bot_is_connected
+
+    bot.mode "#foo", "+o"
+    assert_equal "MODE #foo +o\r\n", @server.gets
+  end
+
+  test "can kick users" do
+    bot = mock_bot {}
+    bot_is_connected
+
+    bot.kick "foo", "bar", "bein' a baz"
+    assert_equal "KICK foo bar :bein' a baz\r\n", @server.gets
+  end
+
+  test "quits" do
+    bot = mock_bot {}
+    bot_is_connected
+
+    bot.quit
+    assert_equal "QUIT\r\n", @server.gets
+  end
+
+  test "quits with message" do
+    bot = mock_bot {}
+    bot_is_connected
+
+    bot.quit "I'm outta here!"
+    assert_equal "QUIT :I'm outta here!\r\n", @server.gets
+  end
+end

data/test/test_events.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestEvents < Test::Unit::TestCase
+  # This is stupid, but it's just there to make it easier to transform to the new
+  # Message class. Should be fixed.
+  def dispatch(type, env)
+    msg = Newton::Message.new(":john!doe@example.com PRIVMSG #foo :#{env[:message]}")
+    @bot.dispatch(type, msg)
+  end
+
+  test "events are registered" do
+    @bot = mock_bot {
+      on(:channel, /Hello/) {msg "foo", "yr formal!"}
+      on(:channel, /Hey/) {msg "foo", "bar baz"}
+    }
+    bot_is_connected
+
+    dispatch(:channel, :message => "Hey")
+    assert_equal "PRIVMSG foo :bar baz\r\n", @server.gets
+  end
+
+  test "catch-all events" do
+    @bot = mock_bot {
+      on(:channel) {msg "foo", "bar baz"}
+    }
+    bot_is_connected
+
+    dispatch(:channel, :message => "lolcat")
+    assert_equal "PRIVMSG foo :bar baz\r\n", @server.gets
+  end
+
+  test "event can be halted" do
+    @bot = mock_bot {
+      on(:channel, /Hey/) { halt; msg "foo", "bar baz" }
+    }
+    bot_is_connected
+
+    dispatch(:channel, :message => "Hey")
+    assert @server.empty?
+  end
+
+  test "connect-event is dispatched at connection" do
+    @bot = mock_bot {
+      on(:connect) {msg "foo", "bar baz"}
+    }
+    bot_is_connected
+
+    assert_equal "PRIVMSG foo :bar baz\r\n", @server.gets
+  end
+
+  test "regular expression match is accessible" do
+    @bot = mock_bot {
+      on(:channel, /foo (bar)/) {msg "foo", match[0]}
+    }
+    bot_is_connected
+
+    dispatch(:channel, :message => "foo bar")
+
+    assert_equal "PRIVMSG foo :bar\r\n", @server.gets
+  end
+
+  test "regular expression matches are handed to block arguments" do
+    @bot = mock_bot {
+      on :channel, /(foo) (bar)/ do |a,b|
+        raw "#{a}"
+        raw "#{b}"
+      end
+    }
+    bot_is_connected
+
+    dispatch(:channel, :message => "foo bar")
+
+    assert_equal "foo\r\n", @server.gets
+    assert_equal "bar\r\n", @server.gets
+  end
+
+  test "only specified number of captures are handed to block args" do
+    @bot = mock_bot {
+      on :channel, /(foo) (bar)/ do |a|
+        raw "#{a}"
+      end
+    }
+    bot_is_connected
+
+    dispatch(:channel, :message => "foo bar")
+
+    assert_equal "foo\r\n", @server.gets
+  end
+end

data/test/test_helpers.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestHelpers < Test::Unit::TestCase
+  test "helpers are registered" do
+    bot = mock_bot {
+      helpers { def foo; msg "foo", "bar baz"; end }
+      on(:private, //) {foo}
+    }
+    bot_is_connected
+
+    bot.irc.parse ":johnny!john@doe.com PRIVMSG isaac :hello, you!"
+    assert_equal "PRIVMSG foo :bar baz\r\n", @server.gets
+  end
+end

data/test/test_irc.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestIrc < Test::Unit::TestCase
+  test "a new bot connects to IRC" do
+    bot = mock_bot {}
+
+    assert_equal "NICK isaac\r\n", @server.gets
+    assert_equal "USER isaac 0 * :#{bot.config.realname}\r\n", @server.gets
+  end
+
+  test "password is sent if specified" do
+    bot = mock_bot {
+      configure {|c| c.password = "foo"}
+    }
+    assert_equal "PASS foo\r\n", @server.gets
+  end
+
+  test "no messages are sent when registration isn't complete" do
+    bot = mock_bot {
+      on(:connect) {raw "Connected!"}
+    }
+    2.times { @server.gets } # NICK / USER
+    bot.dispatch :connect
+
+    assert @server.empty?
+  end
+
+  test "no messages are sent until registration is complete" do
+    bot = mock_bot {
+      on(:connect) {raw "Connected!"}
+    }
+    2.times { @server.gets } # NICK / USER
+    bot.dispatch :connect
+
+    1.upto(4) {|i| @server.puts ":localhost 00#{i}"}
+    assert_equal "Connected!\r\n", @server.gets
+  end
+end

data/test/test_message.rb

@@ -0,0 +1,117 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestMessage < Test::Unit::TestCase
+  include Newton
+
+  test "host prefix" do
+    msg = Message.new(":jeff!spicoli@beach.com QUIT")
+    assert_equal "jeff!spicoli@beach.com", msg.prefix
+    assert_equal "jeff", msg.nick
+    assert_equal "spicoli", msg.user
+    assert_equal "beach.com", msg.host
+    assert_nil msg.server
+  end
+
+  test "server prefix" do
+    msg = Message.new(":some.server.com PING")
+    assert_equal "some.server.com", msg.prefix
+    assert_equal "some.server.com", msg.server
+    assert_nil msg.nick
+    assert_nil msg.user
+    assert_nil msg.host
+  end
+
+  test "without prefix" do
+    msg = Message.new("PING foo.bar")
+    assert_nil msg.prefix
+    assert_nil msg.nick
+    assert_nil msg.host
+  end
+
+  test "command" do
+    msg = Message.new("PING foo.bar")
+    assert_equal "PING", msg.command
+  end
+
+  test "numeric reply" do
+    msg = Message.new("409")
+    assert msg.numeric_reply?
+    assert_equal "409", msg.command
+  end
+
+  test "single param" do
+    msg = Message.new("PING foo.bar")
+    assert_equal 1, msg.params.size
+    assert_equal "foo.bar", msg.params[0]
+  end
+
+  test "multiple params" do
+    msg = Message.new("FOO bar baz")
+    assert_equal 2, msg.params.size
+    assert_equal ["bar", "baz"], msg.params
+  end
+
+  test "single param with whitespace" do
+    msg = Message.new("FOO :bar baz")
+    assert_equal 1, msg.params.size
+    assert_equal "bar baz", msg.params[0]
+  end
+
+  test "single param with whitespace and colon" do
+    msg = Message.new("FOO :bar :baz")
+    assert_equal 1, msg.params.size
+    assert_equal "bar :baz", msg.params[0]
+  end
+
+  test "multiple params with whitespace" do
+    msg = Message.new("FOO bar :lol cat")
+    assert_equal 2, msg.params.size
+    assert_equal "bar", msg.params[0]
+    assert_equal "lol cat", msg.params[1]
+  end
+
+  test "multiple params with whitespace and colon" do
+    msg = Message.new("FOO bar :lol :cat")
+    assert_equal 2, msg.params.size
+    assert_equal "bar", msg.params[0]
+    assert_equal "lol :cat", msg.params[1]
+  end
+
+  test "error" do
+    msg = Message.new("200")
+    assert_equal false, msg.error?
+    assert_nil msg.error
+
+    msg = Message.new("400")
+    assert_equal true, msg.error?
+    assert_equal 400, msg.error
+  end
+
+  test "if error, #message has the error code string" do
+    msg = Message.new("400")
+    assert_equal "400", msg.message
+  end
+
+  test "channel has channel name" do
+    msg = Message.new(":foo!bar@baz.com PRIVMSG #awesome :lol cat")
+    assert_equal true, msg.channel?
+    assert_equal "#awesome", msg.channel
+  end
+
+  test "channel has nothing when receiver is a nick" do
+    msg = Message.new(":foo!bar@baz.com PRIVMSG john :wazzup boy?")
+    assert_equal false, msg.channel?
+    assert_equal nil, msg.channel
+  end
+
+  test "privmsg has #message" do
+    msg = Message.new(":foo!bar@baz.com PRIVMSG #awesome :lol cat")
+    assert_equal "lol cat", msg.message
+  end
+
+  # test "non-privmsg doesn't have #message" do
+  #   msg = Message.new("PING :foo bar")
+  #   p msg.message
+  #   assert_nil msg.message
+  # end
+end