gopher2000 0.4.0 → 0.5.3

data/spec/dispatching_spec.rb

@@ -24,7 +24,7 @@ describe Gopher::Application do
       @request = Gopher::Request.new("/about")
 
       keys, block = @server.lookup(@request.selector)
-      keys.should == {}
+      expect(keys).to eq({})
     end
 
     it "should translate path" do
@@ -32,7 +32,7 @@ describe Gopher::Application do
       @request = Gopher::Request.new("/about/x/y")
 
       keys, block = @server.lookup(@request.selector)
-      keys.should == {:foo => 'x', :bar => 'y'}
+      expect(keys).to eq({:foo => 'x', :bar => 'y'})
     end
 
     it "should return default route if no other route found, and default is defined" do
@@ -41,8 +41,8 @@ describe Gopher::Application do
       end
       @request = Gopher::Request.new("/about/x/y")
       @response = @server.dispatch(@request)
-      @response.body.should == "DEFAULT ROUTE"
-      @response.code.should == :success
+      expect(@response.body).to eq("DEFAULT ROUTE")
+      expect(@response.code).to eq(:success)
     end
 
     it "should respond with error if no route found" do
@@ -50,7 +50,7 @@ describe Gopher::Application do
       @request = Gopher::Request.new("/junk/x/y")
 
       @response = @server.dispatch(@request)
-      @response.code.should == :missing
+      expect(@response.code).to eq(:missing)
     end
 
     it "should respond with error if invalid request" do
@@ -58,7 +58,7 @@ describe Gopher::Application do
       @request = Gopher::Request.new("x" * 256)
 
       @response = @server.dispatch(@request)
-      @response.code.should == :error
+      expect(@response.code).to eq(:error)
     end
 
     it "should respond with error if there's an exception" do
@@ -66,7 +66,7 @@ describe Gopher::Application do
       @request = Gopher::Request.new("/x")
 
       @response = @server.dispatch(@request)
-      @response.code.should == :error
+      expect(@response.code).to eq(:error)
     end
   end
 
@@ -82,7 +82,7 @@ describe Gopher::Application do
 
     it "should run the block" do
       @response = @server.dispatch(@request)
-      @response.body.should == "GOPHERTRON"
+      expect(@response.body).to eq("GOPHERTRON")
     end
   end
 
@@ -97,33 +97,33 @@ describe Gopher::Application do
 
     it "should use incoming params" do
       @response = @server.dispatch(@request)
-      @response.body.should == "x/a/y/b"
+      expect(@response.body).to eq("x/a/y/b")
     end
   end
 
   describe "dispatch to mount" do
     before(:each) do
-      @h = mock(Gopher::Handlers::DirectoryHandler)
-      @h.should_receive(:application=).with(@server)
-      Gopher::Handlers::DirectoryHandler.should_receive(:new).with({:bar => :baz, :mount_point => "/foo"}).and_return(@h)
+      @h = double(Gopher::Handlers::DirectoryHandler)
+      expect(@h).to receive(:application=).with(@server)
+      expect(Gopher::Handlers::DirectoryHandler).to receive(:new).with({:bar => :baz, :mount_point => "/foo"}).and_return(@h)
 
       @server.mount "/foo", :bar => :baz
     end
 
     it "should work for root path" do
       @request = Gopher::Request.new("/foo")
-      @h.should_receive(:call).with({:splat => ""}, @request)
+      expect(@h).to receive(:call).with({:splat => ""}, @request)
 
       @response = @server.dispatch(@request)
-      @response.code.should == :success
+      expect(@response.code).to eq(:success)
     end
 
     it "should work for subdir" do
       @request = Gopher::Request.new("/foo/bar")
-      @h.should_receive(:call).with({:splat => "bar"}, @request)
+      expect(@h).to receive(:call).with({:splat => "bar"}, @request)
 
       @response = @server.dispatch(@request)
-      @response.code.should == :success
+      expect(@response.code).to eq(:success)
     end
   end
 
@@ -138,7 +138,7 @@ describe Gopher::Application do
     it "should put wildcard into param[:splat]" do
       @request = Gopher::Request.new("/about/a/b")
       @response = @server.dispatch(@request)
-      @response.body.should == "a/b"
+      expect(@response.body).to eq("a/b")
     end
   end
 end

data/spec/dsl_spec.rb

@@ -14,7 +14,7 @@ describe Gopher::DSL do
 
     @server = FakeServer.new(@app)
     @server.send :require, 'gopher2000/dsl'
-    @server.stub!(:application).and_return(@app)
+    allow(@server).to receive(:application).and_return(@app)
     @app.reset!
   end
 
@@ -22,13 +22,13 @@ describe Gopher::DSL do
   describe "set" do
     it "should set a config var" do
       @server.set :foo, 'bar'
-      @app.config[:foo].should == 'bar'
+      expect(@app.config[:foo]).to eq('bar')
     end
   end
 
   describe "route" do
     it "should pass a lookup and block to the app" do
-      @app.should_receive(:route).with('/foo')
+      expect(@app).to receive(:route).with('/foo')
       @server.route '/foo' do
         "hi"
       end
@@ -37,7 +37,7 @@ describe Gopher::DSL do
 
   describe "default_route" do
     it "should pass a default block to the app" do
-      @app.should_receive(:default_route)
+      expect(@app).to receive(:default_route)
       @server.default_route do
         "hi"
       end
@@ -46,19 +46,19 @@ describe Gopher::DSL do
 
   describe "mount" do
     it "should pass a route, path, and some opts to the app" do
-      @app.should_receive(:mount).with('/foo', {:path => "/bar"})
+      expect(@app).to receive(:mount).with('/foo', {:path => "/bar"})
       @server.mount "/foo" => "/bar"
     end
 
     it "should pass a route, path, filter, and some opts to the app" do
-      @app.should_receive(:mount).with('/foo', {:path => "/bar", :filter => "*.jpg"})
+      expect(@app).to receive(:mount).with('/foo', {:path => "/bar", :filter => "*.jpg"})
       @server.mount "/foo" => "/bar", :filter => "*.jpg"
     end
   end
 
   describe "menu" do
     it "should pass a menu key and block to the app" do
-      @app.should_receive(:menu).with('/foo')
+      expect(@app).to receive(:menu).with('/foo')
       @server.menu '/foo' do
         "hi"
       end
@@ -67,7 +67,7 @@ describe Gopher::DSL do
 
   describe "text" do
     it "should pass a text_template key and block to the app" do
-      @app.should_receive(:text).with('/foo')
+      expect(@app).to receive(:text).with('/foo')
       @server.text '/foo' do
         "hi"
       end
@@ -76,7 +76,7 @@ describe Gopher::DSL do
 
   describe "helpers" do
     it "should pass a block to the app" do
-      @app.should_receive(:helpers)
+      expect(@app).to receive(:helpers)
       @server.helpers do
         "hi"
       end
@@ -85,30 +85,30 @@ describe Gopher::DSL do
 
   describe "watch" do
     it "should pass a script app for watching" do
-      @app.scripts.should_receive(:<<).with("foo")
+      expect(@app.scripts).to receive(:<<).with("foo")
       @server.watch("foo")
     end
   end
 
   describe "run" do
     it "should set any incoming opts" do
-      @server.should_receive(:set).with(:x, 1)
-      @server.should_receive(:set).with(:y, 2)
-      @server.stub!(:load)
+      expect(@server).to receive(:set).with(:x, 1)
+      expect(@server).to receive(:set).with(:y, 2)
+      allow(@server).to receive(:load)
 
       @server.run("foo", {:x => 1, :y => 2})
     end
 
     it "should turn on script watching if in debug mode" do
       @app.config[:debug] = true
-      @server.should_receive(:watch).with("foo.rb")
-      @server.should_receive(:load).with("foo.rb")
+      expect(@server).to receive(:watch).with("foo.rb")
+      expect(@server).to receive(:load).with("foo.rb")
 
       @server.run("foo.rb")
     end
 
     it "should load the script" do
-      @server.should_receive(:load).with("foo.rb")
+      expect(@server).to receive(:load).with("foo.rb")
       @server.run("foo.rb")
     end
   end

data/spec/handlers/directory_handler_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(__FILE__), '..', '/spec_helper')
 
 describe Gopher::Handlers::DirectoryHandler do
   before(:each) do
-    app = mock(Gopher::Application,
+    app = double(Gopher::Application,
       :host => "host",
       :port => 1234,
       :config => {})
@@ -13,18 +13,18 @@ describe Gopher::Handlers::DirectoryHandler do
 
   describe "filtering" do
     before(:each) do
-      File.should_receive(:directory?).with("/tmp/bar/baz").and_return(true)
-      File.should_receive(:directory?).with("/tmp/bar/baz/a.txt").and_return(false)
-      File.should_receive(:directory?).with("/tmp/bar/baz/b.exe").and_return(false)
-      File.should_receive(:directory?).with("/tmp/bar/baz/dir2").and_return(true)
+      expect(File).to receive(:directory?).with("/tmp/bar/baz").and_return(true)
+      expect(File).to receive(:directory?).with("/tmp/bar/baz/a.txt").and_return(false)
+      expect(File).to receive(:directory?).with("/tmp/bar/baz/b.exe").and_return(false)
+      expect(File).to receive(:directory?).with("/tmp/bar/baz/dir2").and_return(true)
 
-      File.should_receive(:file?).with("/tmp/bar/baz/a.txt").and_return(true)
-      File.should_receive(:file?).with("/tmp/bar/baz/b.exe").and_return(true)
+      expect(File).to receive(:file?).with("/tmp/bar/baz/a.txt").and_return(true)
+      expect(File).to receive(:file?).with("/tmp/bar/baz/b.exe").and_return(true)
 
-      File.should_receive(:fnmatch).with("*.txt", "/tmp/bar/baz/a.txt").and_return(true)
-      File.should_receive(:fnmatch).with("*.txt", "/tmp/bar/baz/b.exe").and_return(false)
+      expect(File).to receive(:fnmatch).with("*.txt", "/tmp/bar/baz/a.txt").and_return(true)
+      expect(File).to receive(:fnmatch).with("*.txt", "/tmp/bar/baz/b.exe").and_return(false)
 
-      Dir.should_receive(:glob).with("/tmp/bar/baz/*.*").and_return([
+      expect(Dir).to receive(:glob).with("/tmp/bar/baz/*").and_return([
           "/tmp/bar/baz/a.txt",
           "/tmp/bar/baz/b.exe",
           "/tmp/bar/baz/dir2"])
@@ -39,78 +39,78 @@ describe Gopher::Handlers::DirectoryHandler do
 
   describe "request_path" do
     it "should join existing path with incoming path" do
-      @h.request_path(:splat => "bar/baz").should == "/tmp/bar/baz"
+      expect(@h.request_path(:splat => "bar/baz")).to eq("/tmp/bar/baz")
     end
   end
 
   describe "to_selector" do
     it "should work" do
-      @h.to_selector("/tmp/foo/bar.html").should == "/xyz/123/foo/bar.html"
-      @h.to_selector("/tmp/foo/baz").should == "/xyz/123/foo/baz"
-      @h.to_selector("/tmp").should == "/xyz/123"
+      expect(@h.to_selector("/tmp/foo/bar.html")).to eq("/xyz/123/foo/bar.html")
+      expect(@h.to_selector("/tmp/foo/baz")).to eq("/xyz/123/foo/baz")
+      expect(@h.to_selector("/tmp")).to eq("/xyz/123")
     end
   end
 
   describe "contained?" do
     it "should be false if not under base path" do
-      @h.contained?("/home/gopher").should == false
+      expect(@h.contained?("/home/gopher")).to eq(false)
     end
     it "should be true if under base path" do
-      @h.contained?("/tmp/gopher").should == true
+      expect(@h.contained?("/tmp/gopher")).to eq(true)
     end
   end
 
   describe "safety checks" do
     it "should raise exception for invalid directory" do
-      lambda {
-        @h.call(:splat => "../../../home/foo/bar/baz").to_s.should == "0a\t/tmp/bar/baz/a\thost\t1234"
-     }.should raise_error(Gopher::InvalidRequest)
+      expect {
+        expect(@h.call(:splat => "../../../home/foo/bar/baz").to_s).to eq("0a\t/tmp/bar/baz/a\thost\t1234")
+     }.to raise_error(Gopher::InvalidRequest)
     end
   end
 
   describe "directories" do
     before(:each) do
-      File.should_receive(:directory?).with("/tmp/bar/baz").and_return(true)
-      File.should_receive(:directory?).with("/tmp/bar/baz/a").and_return(false)
-      File.should_receive(:directory?).with("/tmp/bar/baz/dir2").and_return(true)
+      expect(File).to receive(:directory?).with("/tmp/bar/baz").and_return(true)
+      expect(File).to receive(:directory?).with("/tmp/bar/baz/a").and_return(false)
+      expect(File).to receive(:directory?).with("/tmp/bar/baz/dir2").and_return(true)
 
-      File.should_receive(:file?).with("/tmp/bar/baz/a").and_return(true)
-      File.should_receive(:fnmatch).with("*.*", "/tmp/bar/baz/a").and_return(true)
+      expect(File).to receive(:file?).with("/tmp/bar/baz/a").and_return(true)
+      expect(File).to receive(:fnmatch).with("*.*", "/tmp/bar/baz/a").and_return(true)
 
-      Dir.should_receive(:glob).with("/tmp/bar/baz/*.*").and_return([
+      expect(Dir).to receive(:glob).with("/tmp/bar/baz/*").and_return([
           "/tmp/bar/baz/a",
           "/tmp/bar/baz/dir2"])
     end
 
     it "should work" do
-      @h.call(:splat => "bar/baz").to_s.should == "iBrowsing: /tmp/bar/baz\tnull\t(FALSE)\t0\r\n0a\t/xyz/123/bar/baz/a\thost\t1234\r\n1dir2\t/xyz/123/bar/baz/dir2\thost\t1234\r\n"
+      expect(@h.call(:splat => "bar/baz").to_s).to eq("iBrowsing: /tmp/bar/baz\tnull\t(FALSE)\t0\r\n9a\t/xyz/123/bar/baz/a\thost\t1234\r\n1dir2\t/xyz/123/bar/baz/dir2\thost\t1234\r\n")
     end
   end
 
   describe "files" do
     before(:each) do
-      @file = mock(File)
-      File.should_receive(:directory?).with("/tmp/baz.txt").and_return(false)
+      @file = double(File)
+      expect(File).to receive(:directory?).with("/tmp/baz.txt").and_return(false)
 
-      File.should_receive(:file?).with("/tmp/baz.txt").and_return(true)
-      File.should_receive(:new).with("/tmp/baz.txt").and_return(@file)
+      expect(File).to receive(:file?).with("/tmp/baz.txt").and_return(true)
+      expect(File).to receive(:new).with("/tmp/baz.txt").and_return(@file)
     end
 
     it "should work" do
-      @h.call(:splat => "baz.txt").should == @file
+      expect(@h.call(:splat => "baz.txt")).to eq(@file)
     end
   end
 
   describe "missing stuff" do
     before(:each) do
-      File.should_receive(:directory?).with("/tmp/baz.txt").and_return(false)
-      File.should_receive(:file?).with("/tmp/baz.txt").and_return(false)
+      expect(File).to receive(:directory?).with("/tmp/baz.txt").and_return(false)
+      expect(File).to receive(:file?).with("/tmp/baz.txt").and_return(false)
     end
 
     it "should return not found" do
-      lambda {
+      expect {
         @h.call(:splat => "baz.txt")
-      }.should raise_error(Gopher::NotFoundError)
+      }.to raise_error(Gopher::NotFoundError)
     end
   end
 end

data/spec/helpers_spec.rb

@@ -11,6 +11,6 @@ describe Gopher::Application do
       def foo; "FOO"; end
     end
 
-    @obj.foo.should == "FOO"
+    expect(@obj.foo).to eq("FOO")
   end
 end

data/spec/rendering/base_spec.rb

@@ -8,32 +8,32 @@ describe Gopher::Rendering::Base do
   it 'should add text' do
     @ctx.text("line 1")
     @ctx.text("line 2")
-    @ctx.result.should == "line 1\r\nline 2\r\n"
+    expect(@ctx.result).to eq("line 1\r\nline 2\r\n")
   end
 
   it "should add breaks correctly" do
     @ctx.spacing 2
     @ctx.text("line 1")
     @ctx.text("line 2")
-    @ctx.result.should == "line 1\r\n\r\nline 2\r\n\r\n"
+    expect(@ctx.result).to eq("line 1\r\n\r\nline 2\r\n\r\n")
   end
 
   it "br outputs a bunch of newlines" do
-    @ctx.br(2).should == "\r\n\r\n"
+    expect(@ctx.br(2)).to eq("\r\n\r\n")
   end
 
   describe "underline" do
     it "underline outputs a pretty line" do
-      @ctx.underline(1, 'x').should == "x\r\n"
+      expect(@ctx.underline(1, 'x')).to eq("x\r\n")
     end
     it "has defaults" do
-      @ctx.underline.should == "=" * 70 + "\r\n"
+      expect(@ctx.underline).to eq("=" * 70 + "\r\n")
     end
   end
 
   describe "figlet" do
     it "outputs a figlet" do
-      @ctx.figlet('pie').should == "        _      \r\n       (_)     \r\n  _ __  _  ___ \r\n | '_ \\| |/ _ \\\r\n | |_) | |  __/\r\n | .__/|_|\\___|\r\n | |           \r\n |_|           \r\n"
+      expect(@ctx.figlet('pie')).to eq("        _      \r\n       (_)     \r\n  _ __  _  ___ \r\n | '_ \\| |/ _ \\\r\n | |_) | |  __/\r\n | .__/|_|\\___|\r\n | |           \r\n |_|           \r\n")
     end
   end
 
@@ -41,25 +41,25 @@ describe Gopher::Rendering::Base do
   describe "big_header" do
     it "outputs a box with text" do
       @ctx.width(5)
-      @ctx.big_header('pie').should == "\r\n=====\r\n=pie=\r\n=====\r\n\r\n"
+      expect(@ctx.big_header('pie')).to eq("\r\n=====\r\n=pie=\r\n=====\r\n\r\n")
     end
   end
 
   describe "header" do
     it "outputs underlined text" do
       @ctx.width(5)
-      @ctx.header('pie').should == " pie \r\n=====\r\n"
+      expect(@ctx.header('pie')).to eq(" pie \r\n=====\r\n")
     end
   end
 
   it "uses to_s to output result" do
     @ctx.text("line 1")
-    @ctx.to_s.should == @ctx.result
+    expect(@ctx.to_s).to eq(@ctx.result)
   end
 
   describe "block" do
     it "wraps text" do
-      @ctx.should_receive(:text).twice.with "a"
+      expect(@ctx).to receive(:text).twice.with "a"
       @ctx.block("a a",1)
     end
   end

data/spec/rendering/menu_spec.rb

@@ -12,80 +12,86 @@ describe Gopher::Rendering::Menu do
 
   it 'should add text as a gopher line' do
     @ctx.text("gopher forever")
-    @ctx.result.should == "igopher forever\tnull\t(FALSE)\t0\r\n"
+    expect(@ctx.result).to eq("igopher forever\tnull\t(FALSE)\t0\r\n")
   end
 
   describe "sanitize_text" do
     it "should remove extra whitespace from end of line" do
-      @ctx.sanitize_text("x   ").should == "x"
+      expect(@ctx.sanitize_text("x   ")).to eq("x")
     end
 
     it "should convert tabs to spaces" do
-      @ctx.sanitize_text("x\tx").should == "x        x"
+      expect(@ctx.sanitize_text("x\tx")).to eq("x        x")
     end
 
     it "should remove newlines" do
-      @ctx.sanitize_text("x\nx").should == "xx"
+      expect(@ctx.sanitize_text("x\nx")).to eq("xx")
     end
   end
 
   describe "line" do
     it "should work" do
-      @ctx.line("type", "text", "selector", "host", "port").should == "typetext\tselector\thost\tport\r\n"
+      expect(@ctx.line("type", "text", "selector", "host", "port")).to eq("typetext\tselector\thost\tport\r\n")
     end
 
     it "should use application host/port as defaults" do
-      @ctx.line("type", "text", "selector").should == "typetext\tselector\thost\t1234\r\n"
+      expect(@ctx.line("type", "text", "selector")).to eq("typetext\tselector\thost\t1234\r\n")
     end
   end
 
   describe "error" do
     it "should call text with right selector" do
-      @ctx.should_receive(:text).with("foo", '3')
+      expect(@ctx).to receive(:text).with("foo", '3')
       @ctx.error("foo")
     end
   end
 
   describe "directory" do
     it "should call link with right selector" do
-      @ctx.should_receive(:line).with("1", "foo", "/bar/foo", nil, nil)
+      expect(@ctx).to receive(:line).with("1", "foo", "/bar/foo", nil, nil)
       @ctx.directory("foo", "/bar/foo")
     end
   end
 
   describe "link" do
     it "should get type with determine_type" do
-      @ctx.should_receive(:determine_type).with("foo.txt").and_return("A")
-      @ctx.link("FILE", "foo.txt").should == "AFILE\tfoo.txt\thost\t1234\r\n"
+      expect(@ctx).to receive(:determine_type).with("foo.txt").and_return("A")
+      expect(@ctx.link("FILE", "foo.txt")).to eq("AFILE\tfoo.txt\thost\t1234\r\n")
+    end
+  end
+
+  describe "http" do
+    it "should work" do
+      expect(@ctx.http("weblink", "http://google.com")).to eq("hweblink\tURL:http://google.com\thost\t1234\r\n")
     end
   end
 
   describe "search" do
     it "should output link type/text" do
-      @ctx.search("FIND", "search").should == "7FIND\tsearch\thost\t1234\r\n"
+      expect(@ctx.search("FIND", "search")).to eq("7FIND\tsearch\thost\t1234\r\n")
     end
   end
 
   describe "menu" do
     it "should output link type/text" do
-      @ctx.menu("MENU ITEM", "item").should == "1MENU ITEM\titem\thost\t1234\r\n"
+      expect(@ctx.menu("MENU ITEM", "item")).to eq("1MENU ITEM\titem\thost\t1234\r\n")
     end
   end
 
   describe "br" do
     it "should generate an empty text line" do
-      @ctx.should_receive(:text).with("i", "")
+      expect(@ctx).to receive(:text).with("i", "")
       @ctx.br
     end
 
     it "should call #text multiple times" do
-      @ctx.should_receive(:text).twice.with("i", "")
+      expect(@ctx).to receive(:text).twice.with("i", "")
       @ctx.br(2)
     end
 
     it "should output an empty menu item" do
       @ctx.br
-      @ctx.result.should == "i\tnull\t(FALSE)\t0\r\n"
+      expect(@ctx.result).to eq("i\tnull\t(FALSE)\t0\r\n")
     end
   end
 
@@ -99,10 +105,10 @@ describe Gopher::Rendering::Menu do
       "foo.png" => 'I',
       "foo.mp3" => 's',
       "foo.wav" => 's',
-      "foo.random-file" => "0"
+      "foo.random-file" => "9"
     }.each do |file, expected|
       it "should have right selector for #{file}" do
-        @ctx.determine_type(file).should == expected
+        expect(@ctx.determine_type(file)).to eq(expected)
       end
     end
   end