gopher2000 0.2.2 → 0.5.5

data/spec/dsl_spec.rb

@@ -14,103 +14,112 @@ describe Gopher::DSL do
 
     @server = FakeServer.new(@app)
     @server.send :require, 'gopher2000/dsl'
-    @server.stub!(:application).and_return(@app)
-    @app.reset!
   end
 
-
-  describe "set" do
-    it "should set a config var" do
-      @server.set :foo, 'bar'
-      @app.config[:foo].should == 'bar'
+  describe "application" do
+    it "should return a Gopher::Application" do
+      expect(@server.application).to be_a(Gopher::Application)
     end
   end
 
-  describe "route" do
-    it "should pass a lookup and block to the app" do
-      @app.should_receive(:route).with('/foo')
-      @server.route '/foo' do
-        "hi"
+  context "with application" do
+    before do
+      allow(@server).to receive(:application).and_return(@app)
+      @app.reset!
+    end
+
+    describe "set" do
+      it "should set a config var" do
+        @server.set :foo, 'bar'
+        expect(@app.config[:foo]).to eq('bar')
       end
     end
-  end
 
-  describe "default_route" do
-    it "should pass a default block to the app" do
-      @app.should_receive(:default_route)
-      @server.default_route do
-        "hi"
+    describe "route" do
+      it "should pass a lookup and block to the app" do
+        expect(@app).to receive(:route).with('/foo')
+        @server.route '/foo' do
+          "hi"
+        end
       end
     end
-  end
 
-  describe "mount" do
-    it "should pass a route, path, and some opts to the app" do
-      @app.should_receive(:mount).with('/foo', {:path => "/bar"})
-      @server.mount "/foo" => "/bar"
+    describe "default_route" do
+      it "should pass a default block to the app" do
+        expect(@app).to receive(:default_route)
+        @server.default_route do
+          "hi"
+        end
+      end
     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"})
-      @server.mount "/foo" => "/bar", :filter => "*.jpg"
+    describe "mount" do
+      it "should pass a route, path, and some opts to the app" do
+        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
+        expect(@app).to receive(:mount).with('/foo', {:path => "/bar", :filter => "*.jpg"})
+        @server.mount "/foo" => "/bar", :filter => "*.jpg"
+      end
     end
-  end
 
-  describe "menu" do
-    it "should pass a menu key and block to the app" do
-      @app.should_receive(:menu).with('/foo')
-      @server.menu '/foo' do
-        "hi"
+    describe "menu" do
+      it "should pass a menu key and block to the app" do
+        expect(@app).to receive(:menu).with('/foo')
+        @server.menu '/foo' do
+          "hi"
+        end
       end
     end
-  end
 
-  describe "text" do
-    it "should pass a text_template key and block to the app" do
-      @app.should_receive(:text).with('/foo')
-      @server.text '/foo' do
-        "hi"
+    describe "text" do
+      it "should pass a text_template key and block to the app" do
+        expect(@app).to receive(:text).with('/foo')
+        @server.text '/foo' do
+          "hi"
+        end
       end
     end
-  end
 
-  describe "helpers" do
-    it "should pass a block to the app" do
-      @app.should_receive(:helpers)
-      @server.helpers do
-        "hi"
+    describe "helpers" do
+      it "should pass a block to the app" do
+        expect(@app).to receive(:helpers)
+        @server.helpers do
+          "hi"
+        end
       end
     end
-  end
 
-  describe "watch" do
-    it "should pass a script app for watching" do
-      @app.scripts.should_receive(:<<).with("foo")
-      @server.watch("foo")
+    describe "watch" do
+      it "should pass a script app for watching" do
+        expect(@app.scripts).to receive(:<<).with("foo")
+        @server.watch("foo")
+      end
     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)
+    describe "run" do
+      it "should set any incoming opts" do
+        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
+        @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")
+      it "should turn on script watching if in debug mode" do
+        @app.config[:debug] = true
+        expect(@server).to receive(:watch).with("foo.rb")
+        expect(@server).to receive(:load).with("foo.rb")
 
-      @server.run("foo.rb")
-    end
+        @server.run("foo.rb")
+      end
 
-    it "should load the script" do
-      @server.should_receive(:load).with("foo.rb")
-      @server.run("foo.rb")
+      it "should load the script" do
+        expect(@server).to receive(:load).with("foo.rb")
+        @server.run("foo.rb")
+      end
     end
   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,51 +8,58 @@ 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
+      expect(@ctx.figlet('pie')).to eq("        _      \r\n       (_)     \r\n  _ __  _  ___ \r\n | '_ \\| |/ _ \\\r\n | |_) | |  __/\r\n | .__/|_|\\___|\r\n | |           \r\n |_|           \r\n")
+    end
+  end
+
+
   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,102 @@ 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"
+    context "with filepath" do
+      it "should get type with determine_type" do
+        expect(@ctx).to receive(:determine_type).with("foo.txt").and_return("A")
+        expect(@ctx.link("FILE", "thing", "external-server.com", 70, "foo.txt")).to eq("AFILE\tthing\texternal-server.com\t70\r\n")
+      end
+    end
+
+    context "without filepath" do
+      it "should get type with determine_type" do
+        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
+    
+  end
+
+  describe "text_link" do
+    it "should work" do
+      expect(@ctx.text_link("text link", "/files/foo.txt")).to eq("0text link\t/files/foo.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 +121,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