net-irc2 0.0.10

data/lib/net/irc/pattern.rb

@@ -0,0 +1,68 @@
+# coding: ASCII-8BIT
+module Net::IRC::PATTERN # :nodoc:
+  # letter     =  %x41-5A / %x61-7A       ; A-Z / a-z
+  # digit      =  %x30-39                 ; 0-9
+  # hexdigit   =  digit / "A" / "B" / "C" / "D" / "E" / "F"
+  # special    =  %x5B-60 / %x7B-7D
+  #                  ; "[", "]", "\", "`", "_", "^", "{", "|", "}"
+  LETTER   = 'A-Za-z'
+  DIGIT    = '0-9'
+  HEXDIGIT = "#{DIGIT}A-Fa-f"
+  SPECIAL  = '\x5B-\x60\x7B-\x7D'
+
+  # shortname  =  ( letter / digit ) *( letter / digit / "-" )
+  #               *( letter / digit )
+  #                 ; as specified in RFC 1123 [HNAME]
+  # hostname   =  shortname *( "." shortname )
+  SHORTNAME = "[#{LETTER}#{DIGIT}](?:[-#{LETTER}#{DIGIT}]*[#{LETTER}#{DIGIT}])?"
+  HOSTNAME  = "#{SHORTNAME}(?:\\.#{SHORTNAME})*"
+
+  # servername =  hostname
+  SERVERNAME = HOSTNAME
+
+  # nickname   =  ( letter / special ) *8( letter / digit / special / "-" )
+  #NICKNAME = "[#{LETTER}#{SPECIAL}#{DIGIT}_][-#{LETTER}#{DIGIT}#{SPECIAL}]*"
+  NICKNAME = "\\S+" # for multibytes
+
+  # user       =  1*( %x01-09 / %x0B-0C / %x0E-1F / %x21-3F / %x41-FF )
+  #                 ; any octet except NUL, CR, LF, " " and "@"
+  USER = '[\x01-\x09\x0B-\x0C\x0E-\x1F\x21-\x3F\x41-\xFF]+'
+
+  # ip4addr    =  1*3digit "." 1*3digit "." 1*3digit "." 1*3digit
+  IP4ADDR = "[#{DIGIT}]{1,3}(?:\\.[#{DIGIT}]{1,3}){3}"
+  # ip6addr    =  1*hexdigit 7( ":" 1*hexdigit )
+  # ip6addr    =/ "0:0:0:0:0:" ( "0" / "FFFF" ) ":" ip4addr
+  IP6ADDR = "(?:[#{HEXDIGIT}]+(?::[#{HEXDIGIT}]+){7}|0:0:0:0:0:(?:0|FFFF):#{IP4ADDR})"
+  # hostaddr   =  ip4addr / ip6addr
+  HOSTADDR = "(?:#{IP4ADDR}|#{IP6ADDR})"
+
+  # host       =  hostname / hostaddr
+  HOST = "(?:#{HOSTNAME}|#{HOSTADDR})"
+
+  # prefix     =  servername / ( nickname [ [ "!" user ] "@" host ] )
+  PREFIX = "(?:#{NICKNAME}(?:(?:!#{USER})?@#{HOST})?|#{SERVERNAME})"
+
+  # nospcrlfcl =  %x01-09 / %x0B-0C / %x0E-1F / %x21-39 / %x3B-FF
+  #                 ; any octet except NUL, CR, LF, " " and ":"
+  NOSPCRLFCL = '\x01-\x09\x0B-\x0C\x0E-\x1F\x21-\x39\x3B-\xFF'
+
+  # command    =  1*letter / 3digit
+  COMMAND = "(?:[#{LETTER}]+|[#{DIGIT}]{3})"
+
+  # SPACE      =  %x20        ; space character
+  # middle     =  nospcrlfcl *( ":" / nospcrlfcl )
+  # trailing   =  *( ":" / " " / nospcrlfcl )
+  # params     =  *14( SPACE middle ) [ SPACE ":" trailing ]
+  #            =/ 14( SPACE middle ) [ SPACE [ ":" ] trailing ]
+  MIDDLE = "[#{NOSPCRLFCL}][:#{NOSPCRLFCL}]*"
+  TRAILING = "[: #{NOSPCRLFCL}]*"
+  PARAMS = "(?:((?: #{MIDDLE}){0,14})(?: :(#{TRAILING}))?|((?: #{MIDDLE}){14}):?(#{TRAILING}))"
+
+  # crlf       =  %x0D %x0A   ; "carriage return" "linefeed"
+  # message    =  [ ":" prefix SPACE ] command [ params ] crlf
+  CRLF = '\x0D\x0A'
+  MESSAGE = "(?::(#{PREFIX}) )?(#{COMMAND})#{PARAMS}\s*#{CRLF}"
+
+  CLIENT_PATTERN  = /\A#{NICKNAME}(?:(?:!#{USER})?@#{HOST})\z/on
+  MESSAGE_PATTERN = /\A#{MESSAGE}\z/on
+end # PATTERN

data/lib/net/irc/server.rb

@@ -0,0 +1,186 @@
+class Net::IRC::Server
+  # Server global state for accessing Server::Session
+  attr_accessor :state
+  attr_accessor :sessions
+
+  def initialize(host, port, session_class, opts={})
+    @host          = host
+    @port          = port
+    @session_class = session_class
+    @opts          = OpenStruct.new(opts)
+    @sessions      = []
+    @state         = {}
+  end
+
+  # Start server loop.
+  def start
+    @serv = TCPServer.new(@host, @port)
+    @log  = @opts.logger || Logger.new($stdout)
+    @log.info "Host: #{@host} Port:#{@port}"
+    @accept = Thread.start do
+      loop do
+        Thread.start(@serv.accept) do |s|
+          begin
+            @log.info "Client connected, new session starting..."
+            s = @session_class.new(self, s, @log, @opts)
+            @sessions << s
+            s.start
+          rescue Exception => e
+            puts e
+            puts e.backtrace
+          ensure
+            @sessions.delete(s)
+          end
+        end
+      end
+    end
+    @accept.join
+  end
+
+  # Close all sessions.
+  def finish
+    Thread.exclusive do
+      @accept.kill
+      begin
+        @serv.close
+      rescue
+      end
+      @sessions.each do |s|
+        s.finish
+      end
+    end
+  end
+
+
+  class Session
+    include Net::IRC
+    include Constants
+
+    attr_reader :prefix, :nick, :real, :host
+
+    # Override subclass.
+    def server_name
+      "net-irc"
+    end
+
+    # Override subclass.
+    def server_version
+      "0.0.0"
+    end
+
+    # Override subclass.
+    def available_user_modes
+      "eixwy"
+    end
+
+    # Override subclass.
+    def available_channel_modes
+      "spknm"
+    end
+
+    def initialize(server, socket, logger, opts={})
+      @server, @socket, @log, @opts = server, socket, logger, opts
+    end
+
+    def self.start(*args)
+      new(*args).start
+    end
+
+    # Start session loop.
+    def start
+      on_connected
+      while l = @socket.gets
+        begin
+          @log.debug "RECEIVE: #{l.chomp}"
+          m = Message.parse(l)
+          next if on_message(m) === true
+
+          name = "on_#{(COMMANDS[m.command.upcase] || m.command).downcase}"
+          send(name, m) if respond_to?(name)
+
+          break if m.command == QUIT
+        rescue Message::InvalidMessage
+          @log.error "MessageParse: " + l.inspect
+        end
+      end
+    rescue IOError
+    ensure
+      finish
+    end
+
+    # Close this session.
+    def finish
+      begin
+        @socket.close
+      rescue
+      end
+      on_disconnected
+    end
+
+    # Default PASS callback.
+    # Set @pass.
+    def on_pass(m)
+      @pass = m.params[0]
+    end
+
+    # Default NICK callback.
+    # Set @nick.
+    def on_nick(m)
+      @nick = m.params[0]
+      @prefix = Prefix.new("#{@nick}!#{@user}@#{@host}") if defined? @prefix
+    end
+
+    # Default USER callback.
+    # Set @user, @real, @host and call initial_message.
+    def on_user(m)
+      @user, @real = m.params[0], m.params[3]
+      @nick ||= @user
+      @host = @socket.peeraddr[2]
+      @prefix = Prefix.new("#{@nick}!#{@user}@#{@host}")
+      initial_message
+    end
+
+    # Call when socket connected.
+    def on_connected
+    end
+
+    # Call when socket closed.
+    def on_disconnected
+    end
+
+    # Catch all messages.
+    # If this method return true, aother callback will not be called.
+    def on_message(m)
+    end
+
+    # Default PING callback. Response PONG.
+    def on_ping(m)
+      post server_name, PONG, m.params[0]
+    end
+
+    private
+    # Post message to server.
+    #
+    #     include Net::IRC::Constants
+    #     post prefix, PRIVMSG, "#channel", "foobar"
+    def post(prefix, command, *params)
+      m = Message.new(prefix, command, params.map {|s|
+        #s.gsub(/\r\n|[\r\n]/, " ")
+        s.tr("\r\n", " ")
+      })
+      @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 initial_message
+      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} #{available_user_modes} #{available_channel_modes}"
+    end
+  end
+end # Server

data/lib/net/irc.rb

@@ -0,0 +1,77 @@
+#!ruby
+
+require "bundler"
+Bundler.setup
+
+require "ostruct"
+require "socket"
+require "logger"
+require 'buftok'
+
+module Net; end
+
+module Net::IRC
+  VERSION = "0.0.10".freeze
+  class IRCException < StandardError; end
+
+  require "net/irc/constants"
+  require "net/irc/pattern"
+
+  autoload :Message, "net/irc/message"
+  autoload :Client,  "net/irc/client"
+  autoload :Server,  "net/irc/server"
+
+  class Prefix < String
+    def nick
+      extract[0]
+    end
+
+    def user
+      extract[1]
+    end
+
+    def host
+      extract[2]
+    end
+
+    # Extract Prefix String to [nick, user, host] Array.
+    def extract
+      _, *ret = *self.match(/\A([^\s!]+)(?:!([^\s@]+)@(\S+))?\z/)
+      ret
+    end
+  end
+
+  # Encode to CTCP message. Prefix and postfix \x01.
+  def ctcp_encode(str)
+    "\x01#{ctcp_quote(str)}\x01"
+  end
+  #alias :ctcp_encoding :ctcp_encode
+  module_function :ctcp_encode #, :ctcp_encoding
+
+  # Decode from CTCP message delimited with \x01.
+  def ctcp_decode(str)
+    ctcp_dequote(str.delete("\x01"))
+  end
+  #alias :ctcp_decoding :ctcp_decode
+  module_function :ctcp_decode #, :ctcp_decoding
+
+  def ctcp_quote(str)
+    low_quote(str.gsub("\\", "\\\\\\\\").gsub("\x01", "\\a"))
+  end
+  module_function :ctcp_quote
+
+  def ctcp_dequote(str)
+    low_dequote(str).gsub("\\a", "\x01").gsub(/\\(.|\z)/m, "\\1")
+  end
+  module_function :ctcp_dequote
+
+  private
+  def low_quote(str)
+    str.gsub("\x10", "\x10\x10").gsub("\x00", "\x10\x30").gsub("\r", "\x10r").gsub("\n", "\x10n")
+  end
+
+  def low_dequote(str)
+    str.gsub("\x10n", "\n").gsub("\x10r", "\r").gsub("\x10\x30", "\x00").gsub("\x10\x10", "\x10")
+  end
+end
+

data/spec/channel_manager_spec.rb

@@ -0,0 +1,184 @@
+#!spec
+
+$LOAD_PATH << "lib"
+$LOAD_PATH << "../lib"
+
+require "rubygems"
+require "rspec"
+require "thread"
+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
+
+    Thread.pass
+    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
+
+    Thread.pass
+    true until @client
+  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"))
+
+    true until ChannelManagerTestServerSession.instance
+    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

@@ -0,0 +1,165 @@
+
+$LOAD_PATH << "lib"
+$LOAD_PATH << "../lib"
+
+require "net/irc"
+include Net::IRC
+include Constants
+
+describe Message::ModeParser do
+  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 => [],
+    }
+    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 +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"]]
+
+    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