sr-shout-bot 0.0.1 → 0.0.4

data/shout-bot.rb

@@ -5,7 +5,7 @@ ShoutBot
 
 EXAMPLE
 
-  ShoutBot.shout('irc://irc.freenode.net:6667/github', :as => "ShoutBot") do |channel|
+  ShoutBot.shout('irc://shoutbot:password@irc.freenode.net:6667/#github') do |channel|
     channel.say "check me out! http://github.com/sr/shout-bot"
   end
 
@@ -14,8 +14,8 @@ LICENSE
              DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
                      Version 2, December 2004
 
-  Copyright (C) 2008 Simon Rozet <http://purl.org/net/sr/>
-  Copyright (C) 2008 Harry Vangberg <http://trueaffection.net>
+  Copyright (C) 2008, 2009 Simon Rozet <http://purl.org/net/sr/>
+  Copyright (C) 2008, 2009 Harry Vangberg <http://trueaffection.net>
 
   Everyone is permitted to copy and distribute verbatim or modified
   copies of this license document, and changing it is allowed as long
@@ -32,21 +32,30 @@ require "addressable/uri"
 require "socket"
 
 class ShoutBot
-  def self.shout(uri, options={}, &block)
+  def self.shout(uri, &block)
     raise ArgumentError unless block_given?
 
     uri = Addressable::URI.parse(uri)
-    irc = new(uri.host, uri.port, options.delete(:as)) do |irc|
-      irc.join(uri.path[1..-1], &block)
+    irc = new(uri.host, uri.port, uri.user, uri.password) do |irc|
+      if channel = uri.fragment
+        irc.join(channel, &block)
+      else
+        irc.channel = uri.path[1..-1]
+        yield irc
+      end
     end
   end
 
-  def initialize(server, port, nick)
+  attr_accessor :channel
+
+  def initialize(server, port, nick, password=nil)
     raise ArgumentError unless block_given?
 
-    @socket = TCPSocket.open(server, port)
+    @socket = TCPSocket.open(server, port || 6667)
+    @socket.puts "PASSWORD #{password}" if password
     @socket.puts "NICK #{nick}"
     @socket.puts "USER #{nick} #{nick} #{nick} :#{nick}"
+    sleep 1 
     yield self
     @socket.puts "QUIT"
     @socket.gets until @socket.eof?
@@ -67,115 +76,154 @@ class ShoutBot
   end
 end
 
-if $0 == __FILE__
-  begin
-    require "spec"
-  rescue LoadError
-    abort "No test for you :-("
+if $0 == __FILE__ || $0 == "-e"
+  require "test/unit"
+  require "context"
+  require "rr"
+
+  class MockSocket
+    attr_accessor :in, :out
+    def gets() @in.gets end
+    def puts(m) @out.puts(m) end
+    def eof?() true end
   end
 
-  describe "ShoutBot" do
-    def create_shouter(&block)
-      @shouter ||= ShoutBot.new("irc.freenode.net", 6667, "john", &block || lambda {})
-    end
+  class ShoutBot
+    include Test::Unit::Assertions
+  end
+
+  class Test::Unit::TestCase
+    include RR::Adapters::TestUnit
 
-    setup do
-      @socket = mock("socket", :puts => "", :eof? => true, :gets => "")
-      TCPSocket.stub!(:open).and_return(@socket)
+    def setup
+      @socket, @server = MockSocket.new, MockSocket.new
+      @socket.in, @server.out = IO.pipe
+      @server.in, @socket.out = IO.pipe
+
+      stub(TCPSocket).open(anything, anything) {@socket}
     end
+  end
 
-    it "should exists" do
-      ShoutBot.should be_an_instance_of Class
+  class TestShoutBot < Test::Unit::TestCase
+    def create_shoutbot(&block)
+      ShoutBot.new("irc.freenode.net", 6667, "john", &block || lambda {})
     end
 
-    describe "When using Shouter.shout" do
-      def do_shout(&block)
-        ShoutBot.shout("irc://irc.freenode.net:6667/foo", :as => "john", &block || lambda {})
-      end
+    def create_shoutbot_and_register(&block)
+      create_shoutbot &block
+      2.times { @server.gets } # NICK + USER
+    end
 
-      it "raises ArgumentError if no block given" do
-        lambda { do_shout(nil) }.should raise_error(ArgumentError)
+    test "raises error if no block given" do
+      assert_raises ArgumentError do
+        ShoutBot.new("irc.freenode.net", 6667, "john")
       end
+    end
 
-      it "creates a new shouter using URI and :as option" do
-        ShoutBot.should_receive(:new).with("irc.freenode.net", 6667, "john")
-        do_shout
-      end
+    test "registers to the irc server" do
+      create_shoutbot
+      assert_equal "NICK john\n", @server.gets
+      assert_equal "USER john john john :john\n", @server.gets
+    end
 
-      it "join channel using URI's path" do
-        create_shouter.should_receive(:join).with("foo")
-        ShoutBot.stub!(:new).and_yield(create_shouter)
-        do_shout
-      end
+    test "sends password if specified" do
+      # hey, retarded test!
+      ShoutBot.new("irc.freenode.net", 6667, "john", "malbec") {@socket}
+      assert_equal "PASSWORD malbec\n", @server.gets
+    end
+    
+    test "falls back to port 6667 if not specified" do
+      # talk about retarded test
+      mock(TCPSocket).open("irc.freenode.net", 6667) {@socket}
+      ShoutBot.new("irc.freenode.net", nil, "john") {}
+    end
 
-      it "passes given block to join" do
-        pending
-      end
+    test "quits after doing its job" do
+      create_shoutbot_and_register {}
+      assert_equal "QUIT\n", @server.gets
     end
 
-    describe "When initializing" do
-      it "raises ArgumentError if no block given" do
-        lambda do
-          create_shouter(nil)
-        end.should raise_error(ArgumentError)
+    test "raises error if no block is given to join" do
+      create_shoutbot do |bot|
+        assert_raises(ArgumentError) {bot.join "integrity"}
       end
+    end
 
-      it "opens a TCPSocket to the given host on the given port" do
-        TCPSocket.should_receive(:open).with("irc.freenode.net", 6667).and_return(@socket)
-        create_shouter
+    test "joins channel" do
+      create_shoutbot_and_register do |bot|
+        bot.join("integrity") {}
       end
+      assert_equal "JOIN #integrity\n", @server.gets
+    end
 
-      it "sets its nick" do
-        @socket.should_receive(:puts).with("NICK john")
-        create_shouter
-      end
+    test "doesn't do anything until receiving RPL_MYINFO / 004" do
+      # pending
+    end
 
-      it "yields itself" do
-        create_shouter { |shouter| shouter.should respond_to(:join) }
+    test "joins channel and says something" do
+      create_shoutbot_and_register do |bot|
+        bot.join "integrity" do |c|
+          c.say "foo bar!"
+        end
       end
+      @server.gets # JOIN
+      assert_equal "PRIVMSG #integrity :foo bar!\n", @server.gets
+    end
 
-      it "quits" do
-        @socket.should_receive(:puts).with("QUIT")
-        create_shouter
+    test "sends private message to user" do
+      create_shoutbot_and_register do |bot|
+        bot.channel = "sr"
+        bot.say "Look Ma, new tests!"
       end
+      assert_equal "PRIVMSG sr :Look Ma, new tests!\n", @server.gets
     end
+  end
 
-    describe "When joining a channel" do
-      def do_join(&block)
-        create_shouter { |shouter| shouter.join('foo', &block || lambda {}) }
-      end
+  class TestShouter < Test::Unit::TestCase
+    def create_shouter(&block)
+      shouter = ShoutBot.new("irc.freenode.net", 6667, "shouter") {}
+      mock(ShoutBot).new(anything, anything, anything, anything).yields(shouter) {shouter}
+      shouter
+    end
 
-      it "raises ArgumentError if no block given" do
-        lambda do
-          do_join(nil)
-        end.should raise_error(ArgumentError)
+    test "raises error unless block is given" do
+      assert_raises ArgumentError do
+        ShoutBot.shout("irc://shouter@irc.freenode.net:6667/foo")
       end
+    end
 
-      it "joins the given channel" do
-        @socket.should_receive(:puts).with("JOIN #foo")
-        do_join
-      end
+    test "creates a new instance of shoutbot" do
+      mock(ShoutBot).new("irc.freenode.net", 6667, "shouter", nil)
+      ShoutBot.shout("irc://shouter@irc.freenode.net:6667/foo") {}
+    end
 
-      it "yields itself" do
-        do_join { |channel| channel.should respond_to(:say) }
-      end
+    test "creates a new instance of shoutbot with password" do
+      mock(ShoutBot).new("irc.freenode.net", 6667, "shouter", "badass")
+      ShoutBot.shout("irc://shouter:badass@irc.freenode.net:6667/foo") {}
+    end
 
-      it "parts the given channel" do
-        @socket.should_receive(:puts).with("PART #foo")
-        do_join
-      end
+    test "joins channel" do
+      shouter = create_shouter
+      mock(shouter).join("integrity")
+      ShoutBot.shout("irc://shouter@irc.freenode.net:6667/#integrity") {}
     end
 
-    describe "When saying something" do
-      it "should say the given message in the channel" do
-        @socket.should_receive(:puts).with("PRIVMSG #foo :bar")
-        create_shouter { |shouter| shouter.join("foo") { |channel| channel.say "bar" } }
+    test "says stuff in channel" do
+      shouter = create_shouter
+      mock(shouter).say("foo bar!")
+      ShoutBot.shout("irc://shouter@irc.freenode.net:6667/#integrity") do |bot|
+        bot.say "foo bar!"
       end
+      assert_equal "#integrity", shouter.channel
+    end
 
-      it "should stfu and return nil if not joined to a channel" do
-        @socket.should_not_receive(:puts).with("PRIVMSG #foo :bar")
-        create_shouter { |shouter| shouter.say("bar").should be_nil }
+    test "sends private message to nick" do
+      shouter = create_shouter
+      mock(shouter).say("foo bar!")
+      ShoutBot.shout("irc://shouter@irc.freenode.net:6667/harry") do |bot|
+        bot.say "foo bar!"
       end
+      assert_equal "harry", shouter.channel
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sr-shout-bot
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.4
 platform: ruby
 authors: 
 - Simon Rozet
@@ -10,11 +10,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-19 00:00:00 -08:00
+date: 2009-03-02 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: addressable
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: