net-irc 0.0.1 → 0.0.2

data/lib/net/irc.rb

@@ -4,11 +4,12 @@ require "ostruct"
 require "socket"
 require "thread"
 require "logger"
+require "monitor"
 
 module Net; end
 
 module Net::IRC
-	VERSION = "0.0.1"
+	VERSION = "0.0.2"
 	class IRCException < StandardError; end
 
 	module PATTERN # :nodoc:
@@ -309,7 +310,7 @@ module Net::IRC
 
 		# Extract prefix string to [nick, user, host] Array.
 		def extract
-			_, *ret = *self.match(/^([^\s!]+)!([^\s@]+)@(\S+)$/)
+			_, *ret = *self.match(/^([^\s!]+)(?:!([^\s@]+)@(\S+))?$/)
 			ret
 		end
 	end
@@ -449,6 +450,7 @@ class Net::IRC::Client
 #				:users => [],
 #			}
 		}
+		@channels.extend(MonitorMixin)
 	end
 
 	# Connect to server and start loop.
@@ -495,12 +497,12 @@ class Net::IRC::Client
 	# Default RPL_WELCOME callback.
 	# This sets @prefix from the message.
 	def on_rpl_welcome(m)
-		@prefix = Prefix.new(m[1][/\S+!\S+@\S+/])
+		@prefix = Prefix.new(m[1][/\S+$/])
 	end
 
 	# Default PING callback. Response PONG.
 	def on_ping(m)
-		post PONG, @nick
+		post PONG, @prefix ? @prefix.nick : ""
 	end
 
 	# For managing channel
@@ -509,29 +511,31 @@ class Net::IRC::Client
 		channel = m[2]
 		init_channel(channel)
 
-		m[3].split(/\s+/).each do |u|
-			_, mode, nick = *u.match(/^([@+]?)(.+)/)
+		@channels.synchronize do
+			m[3].split(/\s+/).each do |u|
+				_, mode, nick = *u.match(/^([@+]?)(.+)/)
 
-			@channels[channel][:users] << nick
-			@channels[channel][:users].uniq!
+				@channels[channel][:users] << nick
+				@channels[channel][:users].uniq!
 
-			case mode
-			when "@" # channel operator
-				@channels[channel][:modes] << ["o", nick]
-			when "+" # voiced (under moderating mode)
-				@channels[channel][:modes] << ["v", nick]
+				case mode
+				when "@" # channel operator
+					@channels[channel][:modes] << ["o", nick]
+				when "+" # voiced (under moderating mode)
+					@channels[channel][:modes] << ["v", nick]
+				end
 			end
-		end
 
-		case type
-		when "@" # secret
-			@channels[channel][:modes] << ["s", nil]
-		when "*" # private
-			@channels[channel][:modes] << ["p", nil]
-		when "=" # public
-		end
+			case type
+			when "@" # secret
+				@channels[channel][:modes] << ["s", nil]
+			when "*" # private
+				@channels[channel][:modes] << ["p", nil]
+			when "=" # public
+			end
 
-		@channels[channel][:modes].uniq!
+			@channels[channel][:modes].uniq!
+		end
 	end
 
 	# For managing channel
@@ -540,12 +544,14 @@ class Net::IRC::Client
 		channel = m[0]
 		init_channel(channel)
 
-		info = @channels[channel]
-		if info
-			info[:users].delete(nick)
-			info[:modes].delete_if {|u|
-				u[1] == nick
-			}
+		@channels.synchronize do
+			info = @channels[channel]
+			if info
+				info[:users].delete(nick)
+				info[:modes].delete_if {|u|
+					u[1] == nick
+				}
+			end
 		end
 	end
 
@@ -553,26 +559,31 @@ class Net::IRC::Client
 	def on_quit(m)
 		nick = m.prefix.nick
 
-		@channels.each do |channel, info|
-			info[:users].delete(nick)
-			info[:modes].delete_if {|u|
-				u[1] == nick
-			}
+		@channels.synchronize do
+			@channels.each do |channel, info|
+				info[:users].delete(nick)
+				info[:modes].delete_if {|u|
+					u[1] == nick
+				}
+			end
 		end
 	end
 
 	# For managing channel
 	def on_kick(m)
 		users = m[1].split(/,/)
-		m[0].split(/,/).each do |chan|
-			init_channel(chan)
-			info = @channels[chan]
-			if info
-				users.each do |nick|
-					info[:users].delete(nick)
-					info[:modes].delete_if {|u|
-						u[1] == nick
-					}
+
+		@channels.synchronize do
+			m[0].split(/,/).each do |chan|
+				init_channel(chan)
+				info = @channels[chan]
+				if info
+					users.each do |nick|
+						info[:users].delete(nick)
+						info[:modes].delete_if {|u|
+							u[1] == nick
+						}
+					end
 				end
 			end
 		end
@@ -582,47 +593,52 @@ class Net::IRC::Client
 	def on_join(m)
 		nick    = m.prefix.nick
 		channel = m[0]
-		init_channel(channel)
 
-		@channels[channel][:users] << nick
-		@channels[channel][:users].uniq!
+		@channels.synchronize do
+			init_channel(channel)
+
+			@channels[channel][:users] << nick
+			@channels[channel][:users].uniq!
+		end
 	end
 
 	# For managing channel
 	def on_mode(m)
 		channel = m[0]
-		init_channel(channel)
+		@channels.synchronize do
+			init_channel(channel)
+
+			positive_mode = []
+			negative_mode = []
+
+			mode = positive_mode
+			arg_pos = 0
+			m[1].each_byte do |c|
+				case c
+				when ?+
+					mode = positive_mode
+				when ?-
+					mode = negative_mode
+				when ?o, ?v, ?k, ?l, ?b, ?e, ?I
+					mode << [c.chr, m[arg_pos + 2]]
+					arg_pos += 1
+				else
+					mode << [c.chr, nil]
+				end
+			end
+			mode = nil
 
-		positive_mode = []
-		negative_mode = []
-
-		mode = positive_mode
-		arg_pos = 0
-		m[1].each_byte do |c|
-			case c
-			when ?+
-				mode = positive_mode
-			when ?-
-				mode = negative_mode
-			when ?o, ?v, ?k, ?l, ?b, ?e, ?I
-				mode << [c.chr, m[arg_pos + 2]]
-				arg_pos += 1
-			else
-				mode << [c.chr, nil]
+			negative_mode.each do |m|
+				@channels[channel][:modes].delete(m)
 			end
-		end
-		mode = nil
 
-		negative_mode.each do |m|
-			@channels[channel][:modes].delete(m)
-		end
+			positive_mode.each do |m|
+				@channels[channel][:modes] << m
+			end
 
-		positive_mode.each do |m|
-			@channels[channel][:modes] << m
+			@channels[channel][:modes].uniq!
+			[negative_mode, positive_mode]
 		end
-
-		@channels[channel][:modes].uniq!
-		[negative_mode, positive_mode]
 	end
 
 	# For managing channel
@@ -719,7 +735,7 @@ class Net::IRC::Server
 
 		# Override subclass.
 		def server_name
-			"Net::IRC::Server::Session"
+			"net-irc"
 		end
 
 		# Override subclass.
@@ -830,15 +846,17 @@ class Net::IRC::Server
 			})
 			@log.debug "SEND: #{m.to_s.chomp}"
 			@socket << m
+		rescue IOError
+			finish
 		end
 
 		# Call when client connected.
 		# Send RPL_WELCOME sequence. If you want to customize, override this method at subclass.
 		def inital_message
-			post nil, RPL_WELCOME,  @nick, "Welcome to the Internet Relay Network #{@prefix}"
-			post nil, RPL_YOURHOST, @nick, "Your host is #{server_name}, running version #{server_version}"
-			post nil, RPL_CREATED,  @nick, "This server was created #{Time.now}"
-			post nil, RPL_MYINFO,   @nick, "#{server_name} #{server_version} #{avaiable_user_modes} #{avaiable_channel_modes}"
+			post server_name, RPL_WELCOME,  @nick, "Welcome to the Internet Relay Network #{@prefix}"
+			post server_name, RPL_YOURHOST, @nick, "Your host is #{server_name}, running version #{server_version}"
+			post server_name, RPL_CREATED,  @nick, "This server was created #{Time.now}"
+			post server_name, RPL_MYINFO,   @nick, "#{server_name} #{server_version} #{avaiable_user_modes} #{avaiable_channel_modes}"
 		end
 	end
 end # Server

data/spec/net-irc_spec.rb

@@ -0,0 +1,385 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << "lib"
+$LOAD_PATH << "../lib"
+
+require "net/irc"
+include Net::IRC
+include Constants
+
+describe Net::IRC::Message, "construct" do
+
+	it "should generate message correctly" do
+		m = Message.new("foo", "PRIVMSG", ["#channel", "message"])
+		m.to_s.should == ":foo PRIVMSG #channel message\r\n"
+
+		m = Message.new("foo", "PRIVMSG", ["#channel", "message with space"])
+		m.to_s.should == ":foo PRIVMSG #channel :message with space\r\n"
+
+		m = Message.new(nil, "PRIVMSG", ["#channel", "message"])
+		m.to_s.should == "PRIVMSG #channel message\r\n"
+
+		m = Message.new(nil, "PRIVMSG", ["#channel", "message with space"])
+		m.to_s.should == "PRIVMSG #channel :message with space\r\n"
+
+		m = Message.new(nil, "MODE", [
+			"#channel",
+			"+ooo",
+			"nick1",
+			"nick2",
+			"nick3"
+		])
+		m.to_s.should == "MODE #channel +ooo nick1 nick2 nick3\r\n"
+
+		m = Message.new(nil, "KICK", [
+			"#channel,#channel1",
+			"nick1,nick2",
+		])
+		m.to_s.should == "KICK #channel,#channel1 nick1,nick2\r\n"
+	end
+
+	it "should have ctcp? method" do
+		m = Message.new("foo", "PRIVMSG", ["#channel", "\x01ACTION foo\x01"])
+		m.ctcp?.should be_true
+	end
+
+	it "should behave as Array contains params" do
+		m = Message.new("foo", "PRIVMSG", ["#channel", "message"])
+		m[0].should   == m.params[0]
+		m[1].should   == m.params[1]
+		m.to_a.should == ["#channel", "message"]
+
+		channel, message = *m
+		channel.should == "#channel"
+		message.should == "message"
+	end
+end
+
+describe Net::IRC::Message, "parse" do
+	it "should parse correctly following RFC." do
+		m = Message.parse("PRIVMSG #channel message\r\n")
+		m.prefix.should  == ""
+		m.command.should == "PRIVMSG"
+		m.params.should  == ["#channel", "message"]
+
+		m = Message.parse("PRIVMSG #channel :message leading :\r\n")
+		m.prefix.should  == ""
+		m.command.should == "PRIVMSG"
+		m.params.should  == ["#channel", "message leading :"]
+
+		m = Message.parse("PRIVMSG #channel middle :message leading :\r\n")
+		m.prefix.should  == ""
+		m.command.should == "PRIVMSG"
+		m.params.should  == ["#channel", "middle", "message leading :"]
+
+		m = Message.parse("PRIVMSG #channel middle message with middle\r\n")
+		m.prefix.should  == ""
+		m.command.should == "PRIVMSG"
+		m.params.should  == ["#channel", "middle", "message", "with", "middle"]
+
+		m = Message.parse(":prefix PRIVMSG #channel message\r\n")
+		m.prefix.should  == "prefix"
+		m.command.should == "PRIVMSG"
+		m.params.should  == ["#channel", "message"]
+
+		m = Message.parse(":prefix PRIVMSG #channel :message leading :\r\n")
+		m.prefix.should  == "prefix"
+		m.command.should == "PRIVMSG"
+		m.params.should  == ["#channel", "message leading :"]
+	end
+
+	it "should allow multibyte " do
+		m = Message.parse(":てすと PRIVMSG #channel :message leading :\r\n")
+		m.prefix.should  == "てすと"
+		m.command.should == "PRIVMSG"
+		m.params.should  == ["#channel", "message leading :"]
+	end
+
+	it "should allow space at end" do
+		m = Message.parse("JOIN #foobar \r\n")
+		m.prefix.should  == ""
+		m.command.should == "JOIN"
+		m.params.should  == ["#foobar"]
+	end
+end
+
+describe Net::IRC::Constants, "lookup" do
+	it "should lookup numeric replies from Net::IRC::COMMANDS" do
+		welcome = Net::IRC::Constants.const_get("RPL_WELCOME")
+		welcome.should == "001"
+		Net::IRC::COMMANDS[welcome].should == "RPL_WELCOME"
+	end
+end
+
+describe Net::IRC::Prefix, "" do
+	it "should be kind of String" do
+		Prefix.new("").should be_kind_of(String)
+	end
+
+	it "should parse prefix correctly." do
+		prefix = Prefix.new("foo!bar@localhost")
+		prefix.extract.should == ["foo", "bar", "localhost"]
+
+		prefix = Prefix.new("foo!-bar@localhost")
+		prefix.extract.should == ["foo", "-bar", "localhost"]
+
+		prefix = Prefix.new("foo!+bar@localhost")
+		prefix.extract.should == ["foo", "+bar", "localhost"]
+
+		prefix = Prefix.new("foo!~bar@localhost")
+		prefix.extract.should == ["foo", "~bar", "localhost"]
+	end
+
+	it "should allow multibyte in nick." do
+		prefix = Prefix.new("あああ!~bar@localhost")
+		prefix.extract.should == ["あああ", "~bar", "localhost"]
+	end
+
+	it "should allow lame prefix." do
+		prefix = Prefix.new("nick")
+		prefix.extract.should == ["nick", nil, nil]
+	end
+
+	it "has nick method" do
+		prefix = Prefix.new("foo!bar@localhost")
+		prefix.nick.should == "foo"
+	end
+
+	it "has user method" do
+		prefix = Prefix.new("foo!bar@localhost")
+		prefix.user.should == "bar"
+	end
+
+	it "has host method" do
+		prefix = Prefix.new("foo!bar@localhost")
+		prefix.host.should == "localhost"
+	end
+end
+
+describe Net::IRC, "utilities" do
+	it "has ctcp_encoding method" do
+		message = ctcp_encoding "ACTION hehe"
+		message.should == "\x01ACTION hehe\x01"
+
+		message = ctcp_encoding "ACTION \x01 \x5c "
+		message.should == "\x01ACTION \x5c\x61 \x5c\x5c \x01"
+
+		message = ctcp_encoding "ACTION \x00 \x0a \x0d \x10 "
+		message.should == "\x01ACTION \x100 \x10n \x10r \x10\x10 \x01"
+	end
+
+	it "has ctcp_decoding method" do
+		message = ctcp_decoding "\x01ACTION hehe\x01"
+		message.should == "ACTION hehe"
+
+		message = ctcp_decoding "\x01ACTION \x5c\x61 \x5c\x5c \x01"
+		message.should == "ACTION \x01 \x5c "
+
+		message = ctcp_decoding "\x01ACTION \x100 \x10n \x10r \x10\x10 \x01"
+		message.should == "ACTION \x00 \x0a \x0d \x10 "
+	end
+end
+
+class TestServerSession < Net::IRC::Server::Session
+	@@testq = SizedQueue.new(1)
+	@@instance = nil
+
+	def self.testq
+		@@testq
+	end
+
+	def self.instance
+		@@instance
+	end
+
+	def initialize(*args)
+		super
+		@@instance = self
+	end
+
+	def on_message(m)
+		@@testq << m
+	end
+end
+
+class TestClient < Net::IRC::Client
+	@@testq = SizedQueue.new(1)
+
+	def self.testq
+		@@testq
+	end
+
+	def on_message(m)
+		@@testq << m
+	end
+end
+
+describe Net::IRC, "server and client" do
+	before :all do
+		@port = nil
+		@server, @client = nil, nil
+
+		Thread.abort_on_exception = true
+		Thread.start do
+			@server = Net::IRC::Server.new("localhost", @port, TestServerSession, {
+				:logger => Logger.new(nil),
+			})
+			@server.start
+		end
+
+		true until @server.instance_variable_get(:@serv)
+
+		@port = @server.instance_variable_get(:@serv).addr[1]
+
+		Thread.start do
+			@client = TestClient.new("localhost", @port, {
+				:nick   => "foonick",
+				:user   => "foouser",
+				:real   => "foo real name",
+				:pass   => "foopass",
+				:logger => Logger.new(nil),
+			})
+			@client.start
+		end
+	end
+
+	server_q = TestServerSession.testq
+	client_q = TestClient.testq
+
+	it "client should send pass/nick/user sequence." do
+		server_q.pop.to_s.should == "PASS foopass\r\n"
+		server_q.pop.to_s.should == "NICK foonick\r\n"
+		server_q.pop.to_s.should == "USER foouser 0 * :foo real name\r\n"
+	end
+
+	it "server should send 001,002,003 numeric replies." do
+		client_q.pop.to_s.should match(/^:net-irc 001 foonick :Welcome to the Internet Relay Network \S+!\S+@\S+/)
+		client_q.pop.to_s.should match(/^:net-irc 002 foonick :Your host is .+?, running version /)
+		client_q.pop.to_s.should match(/^:net-irc 003 foonick :This server was created /)
+	end
+
+	it "client posts PRIVMSG and server receives it." do
+		@client.instance_eval do
+			post PRIVMSG, "#channel", "message a b c"
+		end
+
+		message = server_q.pop
+		message.should be_a_kind_of(Net::IRC::Message)
+		message.to_s.should == "PRIVMSG #channel :message a b c\r\n"
+	end
+
+	it "client should manage channel mode/users correctly" do
+		client = @client
+		c = @client.instance_variable_get(:@channels)
+		TestServerSession.instance.instance_eval do
+			Thread.exclusive do
+				post client.prefix,          JOIN,   "#test"
+				post nil,                    NOTICE, "#test", "sep1"
+			end
+		end
+
+		true until client_q.pop.to_s == "NOTICE #test sep1\r\n"
+		c.synchronize do
+			c.should                       be_a_kind_of(Hash)
+			c["#test"].should              be_a_kind_of(Hash)
+			c["#test"][:modes].should      be_a_kind_of(Array)
+			c["#test"][:users].should      be_a_kind_of(Array)
+			c["#test"][:users].should      == ["foonick"]
+		end
+
+		TestServerSession.instance.instance_eval do
+			Thread.exclusive do
+				post "test1!test@localhost", JOIN,   "#test"
+				post "test2!test@localhost", JOIN,   "#test"
+				post nil,                    NOTICE, "#test", "sep2"
+			end
+		end
+
+		true until client_q.pop.to_s == "NOTICE #test sep2\r\n"
+		c.synchronize do
+			c["#test"][:users].should      == ["foonick", "test1", "test2"]
+		end
+
+		TestServerSession.instance.instance_eval do
+			Thread.exclusive do
+				post nil,                    RPL_NAMREPLY, client.prefix.nick, "@", "#test", "foo1 foo2 foo3 @foo4 +foo5"
+				post nil,                    NOTICE, "#test", "sep3"
+			end
+		end
+
+		true until client_q.pop.to_s == "NOTICE #test sep3\r\n"
+		c.synchronize do
+			c["#test"][:users].should      == ["foonick", "test1", "test2", "foo1", "foo2", "foo3", "foo4", "foo5"]
+			c["#test"][:modes].should      include(["s", nil])
+			c["#test"][:modes].should      include(["o", "foo4"])
+			c["#test"][:modes].should      include(["v", "foo5"])
+		end
+
+		TestServerSession.instance.instance_eval do
+			Thread.exclusive do
+				post nil,                    RPL_NAMREPLY, client.prefix.nick, "@", "#test1", "foo1 foo2 foo3 @foo4 +foo5"
+				post "foo4!foo@localhost",   QUIT,   "message"
+				post "foo5!foo@localhost",   PART,   "#test1", "message"
+				post client.prefix,          KICK,   "#test", "foo1", "message"
+				post client.prefix,          MODE,   "#test", "+o", "foo2"
+				post nil,                    NOTICE, "#test", "sep4"
+			end
+		end
+
+		true until client_q.pop.to_s == "NOTICE #test sep4\r\n"
+		c.synchronize do
+			c["#test"][:users].should      == ["foonick", "test1", "test2", "foo2", "foo3", "foo5"]
+			c["#test1"][:users].should     == ["foo1", "foo2", "foo3"]
+			c["#test"][:modes].should_not  include(["o", "foo4"])
+			c["#test"][:modes].should      include(["v", "foo5"])
+			c["#test1"][:modes].should_not include(["v", "foo5"])
+			c["#test"][:modes].should      include(["o", "foo2"])
+		end
+	end
+
+	it "should allow lame RPL_WELCOME (not prefix but nick)" do
+		client = @client
+		TestServerSession.instance.instance_eval do
+			Thread.exclusive do
+				post "server", RPL_WELCOME, client.prefix.nick, "Welcome to the Internet Relay Network #{client.prefix.nick}"
+				post nil,      NOTICE, "#test", "sep1"
+			end
+		end
+		true until client_q.pop.to_s == "NOTICE #test sep1\r\n"
+		client.prefix.should == "foonick"
+	end
+
+	it "should destroy closed session" do
+		oldclient = @client
+		@client.finish
+
+		Thread.start do
+			@client = TestClient.new("localhost", @port, {
+				:nick   => "foonick",
+				:user   => "foouser",
+				:real   => "foo real name",
+				:pass   => "foopass",
+				:logger => Logger.new(nil),
+			})
+			@client.start
+		end
+
+		Thread.pass
+		true while @client == oldclient
+
+		c = @client.instance_variable_get(:@channels)
+		TestServerSession.instance.instance_eval do
+			Thread.exclusive do
+				post nil,                    NOTICE, "#test", "sep1"
+			end
+		end
+
+		true until client_q.pop.to_s == "NOTICE #test sep1\r\n"
+	end
+
+	after :all do
+		@server.finish
+		@client.finish
+	end
+end
+