yard 0.5.8 → 0.6.0

data/spec/server/adapter_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Server::Adapter do
+  after(:all) { Server::Adapter.shutdown }
+
+  describe '#add_library' do
+    it "should add a library" do
+      lib = LibraryVersion.new('yard')
+      a = Adapter.new({})
+      a.libraries.should be_empty
+      a.add_library(lib)
+      a.libraries['yard'].should == [lib]
+    end
+  end
+  
+  describe '#start' do
+    it "should not implement #start" do
+      lambda { Adapter.new({}).start }.should raise_error(NotImplementedError)
+    end
+  end
+  
+  describe '.setup' do
+    it 'should add template paths and helpers' do
+      Adapter.setup
+      Templates::Template.extra_includes.should include(DocServerHelper)
+      Templates::Engine.template_paths.should include(YARD::ROOT + '/yard/server/templates')
+    end
+  end
+  
+  describe '.shutdown' do
+    it 'should cleanup template paths and helpers' do
+      Adapter.setup
+      Adapter.shutdown
+      Templates::Template.extra_includes.should_not include(DocServerHelper)
+      Templates::Engine.template_paths.should_not include(YARD::ROOT + '/yard/server/templates')
+    end
+  end
+end

data/spec/server/commands/base_spec.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class MyProcCommand < Base
+  def initialize(&block) self.class.send(:define_method, :run, &block) end
+end
+
+class MyCacheCommand < Base
+  def run; cache 'foo' end
+end
+
+describe YARD::Server::Commands::Base do
+  describe '#cache' do
+    before do
+      @command = MyCacheCommand.new(:adapter => mock_adapter, :caching => true)
+      @command.request = OpenStruct.new
+    end
+
+    it "should not cache if caching == false" do
+      File.should_not_receive(:open)
+      @command.caching = false
+      @command.run
+    end
+    
+    it "should require document root to cache" do
+      File.should_not_receive(:open)
+      @command.adapter.document_root = nil
+      @command.run
+    end
+    
+    it "should cache to path/to/file.html and create directories" do
+      FileUtils.should_receive(:mkdir_p).with('/public/path/to')
+      File.should_receive(:open).with('/public/path/to/file.html', anything)
+      @command.request.path = '/path/to/file.html'
+      @command.run
+    end
+  end
+  
+  describe '#redirect' do
+    it "should return a valid redirection" do
+      cmd = MyProcCommand.new { redirect '/foo' }
+      cmd.call(mock_request('/foo')).should == 
+        [302, {"Content-Type" => "text/html", "Location" => "/foo"}, [""]]
+    end
+  end
+  
+  describe '#call' do
+    it "should handle a NotFoundError and use message as body" do
+      cmd = MyProcCommand.new { raise NotFoundError, "hello world" }
+      s, h, b = *cmd.call(mock_request('/foo'))
+      s.should == 404
+      b.should == ["hello world"]
+    end
+
+    it "should not use message as body if not provided in NotFoundError" do
+      cmd = MyProcCommand.new { raise NotFoundError }
+      s, h, b = *cmd.call(mock_request('/foo'))
+      s.should == 404
+      b.should == ["Not found: /foo"]
+    end
+
+    it "should handle 404 status code from #run" do
+      cmd = MyProcCommand.new { self.status = 404 }
+      s, h, b = *cmd.call(mock_request('/foo'))
+      s.should == 404
+      b.should == ["Not found: /foo"]
+    end
+    
+    it "should not override body if status is 404 and body is defined" do
+      cmd = MyProcCommand.new { self.body = "foo"; self.status = 404 }
+      s, h, b = *cmd.call(mock_request('/bar'))
+      s.should == 404
+      b.should == ['foo']
+    end
+    
+    it "should handle body as Array" do
+      cmd = MyProcCommand.new { self.body = ['a', 'b', 'c'] }
+      s, h, b = *cmd.call(mock_request('/foo'))
+      b.should == %w(a b c)
+    end
+    
+    it "should allow headers to be defined" do
+      cmd = MyProcCommand.new { self.headers['Foo'] = 'BAR' }
+      s, h, b = *cmd.call(mock_request('/foo'))
+      h['Foo'].should == 'BAR'
+    end
+  end
+end

data/spec/server/commands/static_file_command_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Server::Commands::StaticFileCommand do
+  before do
+    adapter = mock_adapter
+    adapter.document_root = '/c'
+    @cmd = StaticFileCommand.new(:adapter => adapter)
+  end
+  
+  describe '#run' do
+    def run(path, status = nil, body = nil)
+      s, h, b = *@cmd.call(mock_request(path))
+      body.should == b.first if body
+      status.should == s if status
+      [s, h, b]
+    end
+    
+    it "should search through document root before static paths" do
+      File.should_receive(:exist?).with('/c/path/to/file.txt').ordered.and_return(false)
+      StaticFileCommand::STATIC_PATHS.each do |path|
+        File.should_receive(:exist?).with(File.join(path, 'path/to/file.txt')).ordered.and_return(false)
+      end
+      run '/path/to/file.txt'
+    end
+    
+    it "should return file contents if found" do
+      path = File.join(StaticFileCommand::STATIC_PATHS[0], '/path/to/file.txt')
+      File.should_receive(:exist?).with('/c/path/to/file.txt').and_return(false)
+      File.should_receive(:exist?).with(path).and_return(true)
+      File.should_receive(:read).with(path).and_return('FOO')
+      run('/path/to/file.txt', 200, 'FOO')
+    end
+    
+    it "should return 404 if not found" do
+      File.should_receive(:exist?).with('/c/path/to/file.txt').ordered.and_return(false)
+      StaticFileCommand::STATIC_PATHS.each do |path|
+        File.should_receive(:exist?).with(File.join(path, 'path/to/file.txt')).ordered.and_return(false)
+      end
+      run('/path/to/file.txt', 404)
+    end
+    
+    it "should return text/html for file with no extension" do
+      File.should_receive(:exist?).with('/c/file').and_return(true)
+      File.should_receive(:read).with('/c/file')
+      s, h, b = *run('/file')
+      h['Content-Type'].should == 'text/html'
+    end
+    
+    {
+      "js" => "text/javascript",
+      "css" => "text/css",
+      "png" => "image/png",
+      "gif" => "image/gif",
+      "htm" => "text/html",
+      "html" => "text/html",
+      "txt" => "text/plain",
+      "unknown" => "application/octet-stream"
+    }.each do |ext, mime|
+      it "should serve file.#{ext} as #{mime}" do
+        File.should_receive(:exist?).with('/c/file.' + ext).and_return(true)
+        File.should_receive(:read).with('/c/file.' + ext)
+        s, h, b = *run('/file.' + ext)
+        h['Content-Type'].should == mime
+      end
+    end
+  end
+end

data/spec/server/doc_server_serializer_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class MyDocServerSerializerRouter
+  def docs_prefix; 'PREFIX' end
+end
+
+describe YARD::Server::DocServerSerializer do
+  describe '#serialized_path' do
+    before do
+      Registry.clear
+      @command = mock(:command)
+      @command.stub!(:single_library).and_return(false)
+      @command.stub!(:library).and_return(LibraryVersion.new('foo'))
+      @command.stub!(:adapter).and_return(mock_adapter(:router => MyDocServerSerializerRouter.new))
+      @serializer = Server::DocServerSerializer.new(@command)
+    end
+
+    after(:all) { Server::Adapter.shutdown }
+    
+    it "should return '/PREFIX/library/toplevel' for root" do
+      @serializer.serialized_path(Registry.root).should == "/PREFIX/foo/toplevel"
+    end
+    
+    it "should return /PREFIX/library/Object for Object in a library" do
+      @serializer.serialized_path(P('A::B::C')).should == '/PREFIX/foo/A/B/C'
+    end
+    
+    it "should link to instance method as Class:method" do
+      obj = CodeObjects::MethodObject.new(:root, :method)
+      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel:method'
+    end
+
+    it "should link to class method as Class.method" do
+      obj = CodeObjects::MethodObject.new(:root, :method, :class)
+      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel.method'
+    end
+    
+    it "should link to anchor for constant" do
+      obj = CodeObjects::ConstantObject.new(:root, :FOO)
+      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel#FOO-constant'
+    end
+    
+    it "should link to anchor for class variable" do
+      obj = CodeObjects::ClassVariableObject.new(:root, :@@foo)
+      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel#@@foo-classvariable'
+    end
+    
+    it "should not link to /library/ if single_library = true" do
+      @command.stub!(:single_library).and_return(true)
+      @serializer.serialized_path(Registry.root).should == "/PREFIX/toplevel"
+    end
+    
+    it "should return /PREFIX/foo/version if foo has a version" do
+      @command.stub!(:library).and_return(LibraryVersion.new('foo', 'bar'))
+      @serializer.serialized_path(P('A')).should == '/PREFIX/foo/bar/A'
+    end
+  end
+end

data/spec/server/router_spec.rb

@@ -0,0 +1,115 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class MyRouterSpecRouter < Router
+  def docs_prefix; 'mydocs/foo' end
+  def list_prefix; 'mylist/foo' end
+  def search_prefix; 'mysearch/foo' end
+  
+  def check_static_cache; nil end
+end
+
+describe YARD::Server::Router do
+  before do
+    @adapter = mock_adapter
+    @projects = @adapter.libraries['project']
+  end
+
+  describe '#parse_library_from_path' do
+    def parse(*args)
+      MyRouterSpecRouter.new(@adapter).parse_library_from_path(args.flatten)
+    end
+    
+    it "should parse library and version name out of path" do
+      parse('project', '1.0.0').should == [@projects[0], []]
+    end
+    
+    it "should parse library and use latest version if version is not supplied" do
+      parse('project').should == [@projects[1], []]
+    end
+
+    it "should parse library and use latest version if next component is not a version" do
+      parse('project', 'notaversion').should == [@projects[1], ['notaversion']]
+    end
+    
+    it "should return nil library if no library is found" do
+      parse('notproject').should == [nil, ['notproject']]
+    end
+    
+    it "should not parse library or version if single_library == true" do
+      @adapter.stub!(:options).and_return(:single_library => true)
+      parse('notproject').should == [@projects[0], ['notproject']]
+    end
+  end
+  
+  describe '#route' do
+    def route_to(route, command, *args)
+      req = mock_request(route)
+      router = MyRouterSpecRouter.new(@adapter)
+      command.should_receive(:new).and_return do |*args|
+        @command = command.allocate
+        @command.send(:initialize, *args)
+        class << @command; def call(req); self end end
+        @command
+      end
+      router.call(req)
+    end
+    
+    it "should route /docs/OBJECT to object if single_library = true" do
+      @adapter.stub!(:options).and_return(:single_library => true)
+      route_to('/mydocs/foo/FOO', DisplayObjectCommand)
+    end
+    
+    it "should route /docs" do
+      route_to('/mydocs/foo', LibraryIndexCommand)
+    end
+    
+    it "should route /docs as index for library if single_library == true" do
+      @adapter.stub!(:options).and_return(:single_library => true)
+      route_to('/mydocs/foo/', DisplayObjectCommand)
+    end
+    
+    it "should route /docs/name/version" do
+      route_to('/mydocs/foo/project/1.0.0', DisplayObjectCommand)
+      @command.library.should == @projects[0]
+    end
+    
+    it "should route /docs/name/ to latest version of library" do
+      route_to('/mydocs/foo/project', DisplayObjectCommand)
+      @command.library.should == @projects[1]
+    end
+    
+    it "should route /list/name/version/class" do
+      route_to('/mylist/foo/project/1.0.0/class', ListClassesCommand)
+      @command.library.should == @projects[0]
+    end
+
+    it "should route /list/name/version/methods" do
+      route_to('/mylist/foo/project/1.0.0/methods', ListMethodsCommand)
+      @command.library.should == @projects[0]
+    end
+
+    it "should route /list/name/version/files" do
+      route_to('/mylist/foo/project/1.0.0/files', ListFilesCommand)
+      @command.library.should == @projects[0]
+    end
+    
+    it "should route /list/name to latest version of library" do
+      route_to('/mylist/foo/project/class', ListClassesCommand)
+      @command.library.should == @projects[1]
+    end
+    
+    it "should route /search/name/version" do
+      route_to('/mysearch/foo/project/1.0.0', SearchCommand)
+      @command.library.should == @projects[0]
+    end
+    
+    it "should route /search/name to latest version of library" do
+      route_to('/mysearch/foo/project', SearchCommand)
+      @command.library.should == @projects[1]
+    end
+
+    it "should search static files for non-existent library" do
+      route_to('/mydocs/foo/notproject', StaticFileCommand)
+    end
+  end
+end

data/spec/server/spec_helper.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'ostruct'
+
+include Server
+include Commands
+
+def mock_adapter(opts = {})
+  opts[:libraries] ||= {'project' => [LibraryVersion.new('project', '1.0.0'), LibraryVersion.new('project', '1.0.1')]}
+  opts[:document_root] ||= '/public'
+  opts[:options] ||= {:single_library => false, :caching => false}
+  opts[:server_options] ||= {}
+  OpenStruct.new(opts)
+end
+
+def mock_request(path = '/')
+  OpenStruct.new(:path => path)
+end

data/spec/server/static_caching_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Server::StaticCaching do
+  include StaticCaching
+  
+  describe '#check_static_cache' do
+    def adapter; @adapter ||= mock_adapter end
+    def request; @request ||= OpenStruct.new end
+
+    it "should return nil if document root is not set" do
+      adapter.document_root = nil
+      check_static_cache.should be_nil
+    end
+    
+    it "should read a file from document root if path matches file on system" do
+      request.path = '/hello/world.html'
+      File.should_receive(:file?).with('/public/hello/world.html').and_return(true)
+      File.should_receive(:open).with('/public/hello/world.html', anything).and_return('body')
+      s, h, b = *check_static_cache
+      s.should == 200
+      b.should == ["body"]
+    end
+    
+    it "should read a file if path matches file on system + .html" do
+      request.path = '/hello/world'
+      File.should_receive(:file?).with('/public/hello/world.html').and_return(true)
+      File.should_receive(:open).with('/public/hello/world.html', anything).and_return('body')
+      s, h, b = *check_static_cache
+      s.should == 200
+      b.should == ["body"]
+    end
+    
+    it "should return nil if no matching file is found" do
+      request.path = '/hello/foo'
+      File.should_receive(:file?).with('/public/hello/foo.html').and_return(false)
+      check_static_cache.should == nil
+    end
+  end
+end

data/spec/server/webrick_servlet_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe YARD::Server::WebrickServlet do
+  describe '#do_GET' do
+    it "should perform a GET" do
+      resp = OpenStruct.new
+      class << resp
+        def []=(name, value) (self.headers ||= {})[name] = value end
+      end
+      server = mock(:server)
+      server.stub!(:[])
+      adapter = mock_adapter
+      adapter.router = proc { [200, {'Header' => 'foo'}, ['body']]}
+      WebrickServlet.new(server, adapter).do_GET(mock_request('/foo'), resp)
+      resp.status.should == 200
+      resp.headers.should == {'Header' => 'foo'}
+      resp.body.should == 'body'
+    end
+  end
+end