net-irc 0.0.4 → 0.0.5

data/lib/net/irc/message/serverconfig.rb

@@ -0,0 +1,30 @@
+class Net::IRC::Message::ServerConfig
+	attr_reader :mode_parser
+
+	def initialize
+		@config = {}
+		@mode_parser = Net::IRC::Message::ModeParser.new
+	end
+
+	def set(arg)
+		params = arg.kind_of?(Net::IRC::Message) ? arg.to_a : arg.split(/\s+/)
+
+		params[1..-1].each do |s|
+			case s
+			when /^:?are supported by this server$/
+				# Ignore
+			when /^([^=]+)=(.*)$/
+				key = Regexp.last_match[1].to_sym
+				value = Regexp.last_match[2]
+				@config[key] = value
+				@mode_parser.set(key, value) if key == :CHANMODES || key == :PREFIX
+			else
+				@config[s] = true
+			end
+		end
+	end
+
+	def [](key)
+		@config[key]
+	end
+end

data/spec/channel_manager_spec.rb

@@ -0,0 +1,176 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << "lib"
+$LOAD_PATH << "../lib"
+
+require "net/irc"
+require "net/irc/client/channel_manager"
+include Net::IRC
+include Constants
+
+class ChannelManagerTestServerSession < 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 ChannelManagerTestClient < Net::IRC::Client
+	include Net::IRC::Client::ChannelManager
+	@@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, ChannelManagerTestServerSession, {
+				: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 = ChannelManagerTestClient.new("localhost", @port, {
+				:nick   => "foonick",
+				:user   => "foouser",
+				:real   => "foo real name",
+				:pass   => "foopass",
+				:logger => Logger.new(nil),
+			})
+			@client.start
+		end
+	end
+
+	server_q = ChannelManagerTestServerSession.testq
+	client_q = ChannelManagerTestClient.testq
+
+	it "client should manage channel mode/users correctly" do
+		client = @client
+		client.instance_variable_set(:@prefix, Prefix.new("foonick!foouser@localhost"))
+
+		ChannelManagerTestServerSession.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 = @client.instance_variable_get(:@channels)
+		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
+
+		ChannelManagerTestServerSession.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
+
+		ChannelManagerTestServerSession.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
+
+		ChannelManagerTestServerSession.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
+
+		ChannelManagerTestServerSession.instance.instance_eval do
+			Thread.exclusive do
+				post "foonick!test@localhost",  NICK, "foonick2"
+				post "foonick2!test@localhost", NICK, "foonick"
+				post "foo2!test@localhost",     NICK, "bar2"
+				post "foo3!test@localhost",     NICK, "bar3"
+				post nil,                     NOTICE, "#test", "sep5"
+			end
+		end
+
+		true until client_q.pop.to_s == "NOTICE #test sep5\r\n"
+		c.synchronize do
+			c["#test"][:users].should      == ["foonick", "test1", "test2", "bar2", "bar3", "foo5"]
+			c["#test1"][:users].should     == ["foo1", "bar2", "bar3"]
+			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_not  include([:o, "foo2"])
+			c["#test"][:modes].should      include([:o, "bar2"])
+		end
+	end
+
+	after :all do
+		@server.finish
+		@client.finish
+	end
+end
+

data/spec/modeparser_spec.rb

@@ -6,38 +6,160 @@ require "net/irc"
 include Net::IRC
 include Constants
 
-
 describe Message::ModeParser do
-	it "should parse RFC1459 correctly" do
-		Message::ModeParser::RFC1459::Channel.parse("#Finish +im")[:positive].should        == [[:i, nil], [:m, nil]]
-		Message::ModeParser::RFC1459::Channel.parse("#Finish +o Kilroy")[:positive].should  == [[:o, "Kilroy"]]
-		Message::ModeParser::RFC1459::Channel.parse("#Finish +v Kilroy")[:positive].should  == [[:v, "Kilroy"]]
-		Message::ModeParser::RFC1459::Channel.parse("#Fins -s")[:negative].should           == [[:s, nil]]
-		Message::ModeParser::RFC1459::Channel.parse("#42 +k oulu")[:positive].should        == [[:k, "oulu"]]
-		Message::ModeParser::RFC1459::Channel.parse("#eu-opers +l 10")[:positive].should    == [[:l, "10"]]
-		Message::ModeParser::RFC1459::Channel.parse("&oulu +b")[:positive].should           == [[:b, nil]]
-		Message::ModeParser::RFC1459::Channel.parse("&oulu +b *!*@*")[:positive].should     == [[:b, "*!*@*"]]
-		Message::ModeParser::RFC1459::Channel.parse("&oulu +b *!*@*.edu")[:positive].should == [[:b, "*!*@*.edu"]]
-
-		Message::ModeParser::RFC1459::Channel.parse("#foo +ooo foo bar baz").should   == {
+	it "should parse RFC2812+ correctly" do
+		parser = Message::ModeParser.new
+		
+		parser.parse("#Finish +im")[:positive].should        == [[:i, nil], [:m, nil]]
+		parser.parse("#Finish +o Kilroy")[:positive].should  == [[:o, "Kilroy"]]
+		parser.parse("#Finish +v Kilroy")[:positive].should  == [[:v, "Kilroy"]]
+		parser.parse("#Fins -s")[:negative].should           == [[:s, nil]]
+		parser.parse("#42 +k oulu")[:positive].should        == [[:k, "oulu"]]
+		parser.parse("#eu-opers +l 10")[:positive].should    == [[:l, "10"]]
+		parser.parse("&oulu +b")[:positive].should           == [[:b, nil]]
+		parser.parse("&oulu +b *!*@*")[:positive].should     == [[:b, "*!*@*"]]
+		
+		parser.parse("&oulu +b *!*@*.edu")[:positive].should == [[:b, "*!*@*.edu"]]
+		parser.parse("#oulu +e")[:positive].should           == [[:e, nil]]
+		parser.parse("#oulu +e *!*@*.edu")[:positive].should == [[:e, "*!*@*.edu"]]
+		parser.parse("#oulu +I")[:positive].should           == [[:I, nil]]
+		parser.parse("#oulu +I *!*@*.edu")[:positive].should == [[:I, "*!*@*.edu"]]
+		parser.parse("#oulu +R")[:positive].should           == [[:R, nil]]
+		parser.parse("#oulu +R *!*@*.edu")[:positive].should == [[:R, "*!*@*.edu"]]
+
+		parser.parse("#foo +ooo foo bar baz").should   == {
 			:positive => [[:o, "foo"], [:o, "bar"], [:o, "baz"]],
 			:negative => [],
 		}
-		Message::ModeParser::RFC1459::Channel.parse("#foo +oo-o foo bar baz").should  == {
+		parser.parse("#foo +oo-o foo bar baz").should  == {
 			:positive => [[:o, "foo"], [:o, "bar"]],
 			:negative => [[:o, "baz"]],
 		}
-		Message::ModeParser::RFC1459::Channel.parse("#foo -oo+o foo bar baz").should  == {
+		parser.parse("#foo -oo+o foo bar baz").should  == {
 			:positive => [[:o, "baz"]],
 			:negative => [[:o, "foo"], [:o, "bar"]],
 		}
-		Message::ModeParser::RFC1459::Channel.parse("#foo +imv foo").should  == {
+		parser.parse("#foo +imv foo").should  == {
 			:positive => [[:i, nil], [:m, nil], [:v, "foo"]],
 			:negative => [],
 		}
+		
+		parser.parse("#foo +lk 10 foo").should  == {
+			:positive => [[:l, "10"], [:k, "foo"]],
+			:negative => [],
+		}
+		parser.parse("#foo -l+k foo").should  == {
+			:positive => [[:k, "foo"]],
+			:negative => [[:l, nil]],
+		}
+		parser.parse("#foo +ao foo").should  == {
+			:positive => [[:a, nil], [:o, "foo"]],
+			:negative => [],
+		}
+	end
+
+	it "should parse modes of Hyperion ircd correctly" do
+		parser = Message::ModeParser.new
+		parser.set(:CHANMODES, 'bdeIq,k,lfJD,cgijLmnPQrRstz')
+		
+		parser.parse("#Finish +im")[:positive].should        == [[:i, nil], [:m, nil]]
+		parser.parse("#Finish +o Kilroy")[:positive].should  == [[:o, "Kilroy"]]
+		parser.parse("#Finish +v Kilroy")[:positive].should  == [[:v, "Kilroy"]]
+		parser.parse("#Fins -s")[:negative].should           == [[:s, nil]]
+		parser.parse("#42 +k oulu")[:positive].should        == [[:k, "oulu"]]
+		parser.parse("#eu-opers +l 10")[:positive].should    == [[:l, "10"]]
+		parser.parse("&oulu +b")[:positive].should           == [[:b, nil]]
+		parser.parse("&oulu +b *!*@*")[:positive].should     == [[:b, "*!*@*"]]
+		parser.parse("&oulu +b *!*@*.edu")[:positive].should == [[:b, "*!*@*.edu"]]
+		
+		parser.parse("#oulu +e")[:positive].should           == [[:e, nil]]
+		parser.parse("#oulu +e *!*@*.edu")[:positive].should == [[:e, "*!*@*.edu"]]
+		parser.parse("#oulu +I")[:positive].should           == [[:I, nil]]
+		parser.parse("#oulu +I *!*@*.edu")[:positive].should == [[:I, "*!*@*.edu"]]
 
-		Message::ModeParser::RFC1459::User.parse("WIZ -w")[:negative].should   == [[:w, nil]]
-		Message::ModeParser::RFC1459::User.parse("ANGEL +i")[:positive].should == [[:i, nil]]
-		Message::ModeParser::RFC1459::User.parse("WIZ -o")[:negative].should   == [[:o, nil]]
+		parser.parse("#foo +ooo foo bar baz").should   == {
+			:positive => [[:o, "foo"], [:o, "bar"], [:o, "baz"]],
+			:negative => [],
+		}
+		parser.parse("#foo +oo-o foo bar baz").should  == {
+			:positive => [[:o, "foo"], [:o, "bar"]],
+			:negative => [[:o, "baz"]],
+		}
+		parser.parse("#foo -oo+o foo bar baz").should  == {
+			:positive => [[:o, "baz"]],
+			:negative => [[:o, "foo"], [:o, "bar"]],
+		}
+		parser.parse("#foo +imv foo").should  == {
+			:positive => [[:i, nil], [:m, nil], [:v, "foo"]],
+			:negative => [],
+		}
+		
+		parser.parse("#foo +lk 10 foo").should  == {
+			:positive => [[:l, "10"], [:k, "foo"]],
+			:negative => [],
+		}
+		parser.parse("#foo -l+k foo").should  == {
+			:positive => [[:k, "foo"]],
+			:negative => [[:l, nil]],
+		}
+		parser.parse("#foo +cv foo").should  == {
+			:positive => [[:c, nil], [:v, "foo"]],
+			:negative => [],
+		}
+	end
+
+	it "should parse modes of Unreal ircd correctly" do
+		parser = Message::ModeParser.new
+		parser.set(:PREFIX, '(qaohv)~&@%+')
+		parser.set(:CHANMODES, 'beI,kfL,lj,psmntirRcOAQKVCuzNSMTG')
+		
+		parser.parse("#Finish +im")[:positive].should        == [[:i, nil], [:m, nil]]
+		parser.parse("#Finish +o Kilroy")[:positive].should  == [[:o, "Kilroy"]]
+		parser.parse("#Finish +v Kilroy")[:positive].should  == [[:v, "Kilroy"]]
+		parser.parse("#Fins -s")[:negative].should           == [[:s, nil]]
+		parser.parse("#42 +k oulu")[:positive].should        == [[:k, "oulu"]]
+		parser.parse("#eu-opers +l 10")[:positive].should    == [[:l, "10"]]
+		parser.parse("&oulu +b")[:positive].should           == [[:b, nil]]
+		parser.parse("&oulu +b *!*@*")[:positive].should     == [[:b, "*!*@*"]]
+		parser.parse("&oulu +b *!*@*.edu")[:positive].should == [[:b, "*!*@*.edu"]]
+		
+		parser.parse("#oulu +e")[:positive].should           == [[:e, nil]]
+		parser.parse("#oulu +e *!*@*.edu")[:positive].should == [[:e, "*!*@*.edu"]]
+		parser.parse("#oulu +I")[:positive].should           == [[:I, nil]]
+		parser.parse("#oulu +I *!*@*.edu")[:positive].should == [[:I, "*!*@*.edu"]]
+
+		parser.parse("#foo +ooo foo bar baz").should   == {
+			:positive => [[:o, "foo"], [:o, "bar"], [:o, "baz"]],
+			:negative => [],
+		}
+		parser.parse("#foo +oo-o foo bar baz").should  == {
+			:positive => [[:o, "foo"], [:o, "bar"]],
+			:negative => [[:o, "baz"]],
+		}
+		parser.parse("#foo -oo+o foo bar baz").should  == {
+			:positive => [[:o, "baz"]],
+			:negative => [[:o, "foo"], [:o, "bar"]],
+		}
+		parser.parse("#foo +imv foo").should  == {
+			:positive => [[:i, nil], [:m, nil], [:v, "foo"]],
+			:negative => [],
+		}
+		
+		parser.parse("#foo +lk 10 foo").should  == {
+			:positive => [[:l, "10"], [:k, "foo"]],
+			:negative => [],
+		}
+		parser.parse("#foo -l+k foo").should  == {
+			:positive => [[:k, "foo"]],
+			:negative => [[:l, nil]],
+		}
+		parser.parse("#foo -q+ah foo bar baz").should  == {
+			:positive => [[:a, "bar"], [:h, "baz"]],
+			:negative => [[:q, "foo"]],
+		}
+		parser.parse("#foo +Av foo").should  == {
+			:positive => [[:A, nil], [:v, "foo"]],
+			:negative => [],
+		}
 	end
 end

data/spec/net-irc_spec.rb

@@ -53,6 +53,15 @@ describe Net::IRC::Message, "construct" do
 		channel.should == "#channel"
 		message.should == "message"
 	end
+
+	it "#to_a should return duplicated array" 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"]
+		m.to_a.clear
+		m.to_a.should == ["#channel", "message"]
+	end
 end
 
 describe Net::IRC::Message, "parse" do
@@ -268,75 +277,6 @@ describe Net::IRC, "server and client" do
 		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