challah 1.0.0.beta2 → 1.0.0.beta3

data/vendor/bundle/gems/yard-0.8.6.1/spec/registry_store_spec.rb

@@ -0,0 +1,315 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe YARD::RegistryStore do
+  before do
+    FileUtils.rm_rf("foo")
+    @store = RegistryStore.new
+    @serializer = Serializers::YardocSerializer.new('foo')
+    @foo = CodeObjects::MethodObject.new(nil, :foo)
+    @bar = CodeObjects::ClassObject.new(nil, :Bar)
+    Serializers::YardocSerializer.stub!(:new).and_return(@serializer)
+  end
+
+  describe '#load' do
+    it "should load root.dat as full object list if it is a Hash" do
+      File.should_receive(:directory?).with('foo').and_return(true)
+      File.should_receive(:file?).with('foo/checksums').and_return(false)
+      File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
+      @serializer.should_receive(:deserialize).with('root').and_return({:root => @foo, :A => @bar})
+      @store.load('foo').should == true
+      @store.root.should == @foo
+      @store.get('A').should == @bar
+    end
+
+    it "should load old yardoc format if .yardoc is a file" do
+      File.should_receive(:directory?).with('foo').and_return(false)
+      File.should_receive(:file?).with('foo').and_return(true)
+      File.should_receive(:read_binary).with('foo').and_return('FOO')
+      Marshal.should_receive(:load).with('FOO')
+
+      @store.load('foo')
+    end
+
+    it "should load new yardoc format if .yardoc is a directory" do
+      File.should_receive(:directory?).with('foo').and_return(true)
+      File.should_receive(:file?).with('foo/checksums').and_return(false)
+      File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
+      File.should_receive(:file?).with('foo/objects/root.dat').and_return(false)
+
+      @store.load('foo').should == true
+    end
+
+    it "should return true if .yardoc is loaded (file)" do
+      File.should_receive(:directory?).with('myyardoc').and_return(false)
+      File.should_receive(:file?).with('myyardoc').and_return(true)
+      File.should_receive(:read_binary).with('myyardoc').and_return(Marshal.dump(''))
+      @store.load('myyardoc').should == true
+    end
+
+    it "should return true if .yardoc is loaded (directory)" do
+      File.should_receive(:directory?).with('foo').and_return(true)
+      File.should_receive(:file?).with('foo/checksums').and_return(false)
+      File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
+      File.should_receive(:file?).with('foo/objects/root.dat').and_return(false)
+      @store.load('foo').should == true
+    end
+
+    it "should return false if .yardoc does not exist" do
+      @store.load('NONEXIST').should == false
+    end
+
+    it "should return false if there is no file to load" do
+      @store.load(nil).should == false
+    end
+
+    it "should load checksums if they exist" do
+      File.should_receive(:directory?).with('foo').and_return(true)
+      File.should_receive(:file?).with('foo/checksums').and_return(true)
+      File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/objects/root.dat').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
+      File.should_receive(:readlines).with('foo/checksums').and_return([
+        'file1 CHECKSUM1', '  file2 CHECKSUM2 '
+      ])
+      @store.load('foo').should == true
+      @store.checksums.should == {'file1' => 'CHECKSUM1', 'file2' => 'CHECKSUM2'}
+    end
+
+    it "should load proxy_types if they exist" do
+      File.should_receive(:directory?).with('foo').and_return(true)
+      File.should_receive(:file?).with('foo/checksums').and_return(false)
+      File.should_receive(:file?).with('foo/proxy_types').and_return(true)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
+      File.should_receive(:file?).with('foo/objects/root.dat').and_return(false)
+      File.should_receive(:read_binary).with('foo/proxy_types').and_return(Marshal.dump({'a' => 'b'}))
+      @store.load('foo').should == true
+      @store.proxy_types.should == {'a' => 'b'}
+    end
+
+    it "should load root object if it exists" do
+      File.should_receive(:directory?).with('foo').and_return(true)
+      File.should_receive(:file?).with('foo/checksums').and_return(false)
+      File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
+      File.should_receive(:file?).with('foo/objects/root.dat').and_return(true)
+      File.should_receive(:read_binary).with('foo/objects/root.dat').and_return(Marshal.dump(@foo))
+      @store.load('foo').should == true
+      @store.root.should == @foo
+    end
+  end
+
+  describe '#save' do
+    before do
+      @store.stub!(:write_proxy_types)
+      @store.stub!(:write_checksums)
+      @store.stub!(:destroy)
+    end
+
+    after do
+      Registry.single_object_db = nil
+    end
+
+    def saves_to_singledb
+      @serializer.should_receive(:serialize).once.with(instance_of(Hash))
+      @store.save(true, 'foo')
+    end
+
+    def add_items(n)
+      n.times {|i| @store[i.to_s] = @foo }
+    end
+
+    def saves_to_multidb
+      times = @store.keys.size
+      @serializer.should_receive(:serialize).exactly(times).times
+      @store.save(true, 'foo')
+      @last = times
+    end
+
+    it "should save as single object db if single_object_db is nil and there are less than 3000 objects" do
+      Registry.single_object_db = nil
+      add_items(100)
+      saves_to_singledb
+    end
+
+    it "should save as single object db if single_object_db is nil and there are more than 3000 objects" do
+      Registry.single_object_db = nil
+      add_items(5000)
+      saves_to_singledb
+    end
+
+    it "should save as single object db if single_object_db is true (and any amount of objects)" do
+      Registry.single_object_db = true
+      add_items(100)
+      saves_to_singledb
+      add_items(5000)
+      saves_to_singledb
+    end
+
+    it "should never save as single object db if single_object_db is false" do
+      Registry.single_object_db = false
+      add_items(100)
+      saves_to_multidb
+      add_items(5000)
+      saves_to_multidb
+    end
+  end
+
+  describe '#put' do
+    it "should assign values" do
+      @store.put(:YARD, @foo)
+      @store.get(:YARD).should == @foo
+    end
+
+    it "should treat '' as root" do
+      @store.put('', @foo)
+      @store.get(:root).should == @foo
+    end
+  end
+
+  describe '#get' do
+    it "should hit cache if object exists" do
+      @store.put(:YARD, @foo)
+      @store.get(:YARD).should == @foo
+    end
+
+    it "should hit backstore on cache miss and cache is not fully loaded" do
+      serializer = mock(:serializer)
+      serializer.should_receive(:deserialize).once.with(:YARD).and_return(@foo)
+      @store.load('foo')
+      @store.instance_variable_set("@loaded_objects", 0)
+      @store.instance_variable_set("@available_objects", 100)
+      @store.instance_variable_set("@serializer", serializer)
+      @store.get(:YARD).should == @foo
+      @store.get(:YARD).should == @foo
+      @store.instance_variable_get("@loaded_objects").should == 1
+    end
+  end
+
+  [:keys, :values].each do |item|
+    describe "##{item}" do
+      it "should load entire database if reload=true" do
+        File.should_receive(:directory?).with('foo').and_return(true)
+        @store.load('foo')
+        @store.should_receive(:load_all)
+        @store.send(item, true)
+      end
+
+      it "should not load entire database if reload=false" do
+        File.should_receive(:directory?).with('foo').and_return(true)
+        @store.load('foo')
+        @store.should_not_receive(:load_all)
+        @store.send(item, false)
+      end
+    end
+  end
+
+  describe '#paths_for_type' do
+    after { Registry.clear }
+
+    it "should set all object types if not set by object_types" do
+      File.should_receive(:directory?).with('foo').and_return(true)
+      File.should_receive(:file?).with('foo/checksums').and_return(false)
+      File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
+      @serializer.should_receive(:deserialize).with('root').and_return({:'A#foo' => @foo, :A => @bar})
+      @store.load('foo')
+      @store.paths_for_type(:method).should == ['#foo']
+      @store.paths_for_type(:class).should == ['Bar']
+    end
+
+    it "should keep track of types when assigning values" do
+      @store.put(:abc, @foo)
+      @store.paths_for_type(@foo.type).should == ['abc']
+    end
+
+    it "should reassign path if type changes" do
+      foo = CodeObjects::ClassObject.new(:root, :Foo)
+      @store.put('Foo', foo)
+      @store.get('Foo').type.should == :class
+      @store.paths_for_type(:class).should == ["Foo"]
+      foo = CodeObjects::ModuleObject.new(:root, :Foo)
+      @store.put('Foo', foo)
+      @store.get('Foo').type.should == :module
+      @store.paths_for_type(:class).should == []
+      @store.paths_for_type(:module).should == ["Foo"]
+    end
+  end
+
+  describe '#values_for_type' do
+    it "should return all objects with type" do
+      @store.put(:abc, @foo)
+      @store.values_for_type(@foo.type).should == [@foo]
+    end
+  end
+
+  describe '#load_all' do
+    it "should load the entire database" do
+      foomock = mock(:Foo)
+      barmock = mock(:Bar)
+      foomock.stub!(:type).and_return(:class)
+      barmock.stub!(:type).and_return(:class)
+      foomock.should_receive(:path).and_return('Foo')
+      barmock.should_receive(:path).and_return('Bar')
+      File.should_receive(:directory?).with('foo').and_return(true)
+      File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      File.should_receive(:file?).with('foo/object_types').and_return(false)
+      File.should_receive(:file?).with('foo/checksums').and_return(false)
+      File.should_receive(:file?).with('foo/objects/root.dat').and_return(false)
+      @store.should_receive(:all_disk_objects).at_least(1).times.and_return(['foo/objects/foo', 'foo/objects/bar'])
+      @store.load('foo')
+      serializer = @store.instance_variable_get("@serializer")
+      serializer.should_receive(:deserialize).with('foo/objects/foo', true).and_return(foomock)
+      serializer.should_receive(:deserialize).with('foo/objects/bar', true).and_return(barmock)
+      @store.send(:load_all)
+      @store.instance_variable_get("@available_objects").should == 2
+      @store.instance_variable_get("@loaded_objects").should == 2
+      @store[:Foo].should == foomock
+      @store[:Bar].should == barmock
+    end
+  end
+
+  describe '#destroy' do
+    it "should destroy file ending in .yardoc when force=false" do
+      File.should_receive(:file?).with('foo.yardoc').and_return(true)
+      File.should_receive(:unlink).with('foo.yardoc')
+      @store.instance_variable_set("@file", 'foo.yardoc')
+      @store.destroy.should == true
+    end
+
+    it "should destroy dir ending in .yardoc when force=false" do
+      File.should_receive(:directory?).with('foo.yardoc').and_return(true)
+      FileUtils.should_receive(:rm_rf).with('foo.yardoc')
+      @store.instance_variable_set("@file", 'foo.yardoc')
+      @store.destroy.should == true
+    end
+
+    it "should not destroy file/dir not ending in .yardoc when force=false" do
+      File.should_not_receive(:file?).with('foo')
+      File.should_not_receive(:directory?).with('foo')
+      File.should_not_receive(:unlink).with('foo')
+      FileUtils.should_not_receive(:rm_rf).with('foo')
+      @store.instance_variable_set("@file", 'foo')
+      @store.destroy.should == false
+    end
+
+    it "should destroy any file/dir when force=true" do
+      File.should_receive(:file?).with('foo').and_return(true)
+      File.should_receive(:unlink).with('foo')
+      @store.instance_variable_set("@file", 'foo')
+      @store.destroy(true).should == true
+    end
+  end
+
+  describe '#locale' do
+    it "should load ./po/LOCALE_NAME.po" do
+      fr_locale = I18n::Locale.new("fr")
+      I18n::Locale.should_receive(:new).with("fr").and_return(fr_locale)
+      Registry.should_receive(:po_dir).and_return("po")
+      fr_locale.should_receive(:load).with("po")
+      @store.locale("fr").should == fr_locale
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/spec/rubygems/doc_manager_spec.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.join(YARD::ROOT, 'rubygems_plugin')
+require 'fileutils'
+
+describe Gem::DocManager do
+  before do
+    # Ensure filesystem integrity
+    FileUtils.stub(:mkdir_p)
+    FileUtils.stub(:rm_rf)
+    Dir.stub(:chdir)
+
+    YARD::CLI::Yardoc.stub(:run)
+
+    @spec_file = File.join(YARD::ROOT, '..', 'yard.gemspec')
+    @spec = Gem::SourceIndex.load_specification(@spec_file)
+    @spec.has_yardoc = false # no yardoc docs for now
+    @yardopts = File.join(@spec.full_gem_path, '.yardopts')
+    @doc = Gem::DocManager.new(@spec)
+    @doc.stub(:install_ri_yard_orig)
+    @doc.stub(:install_rdoc_yard_orig)
+  end
+
+  def runs; YARD::CLI::Yardoc.should_receive(:run) end
+
+  describe '.load_yardoc' do
+    it "should properly load YARD" do
+      Gem::DocManager.should_receive(:require) do |path|
+        File.expand_path(path).should == YARD::ROOT + '/yard'
+      end
+      Gem::DocManager.load_yardoc
+    end
+  end
+
+  describe '#install_ri_yard' do
+    def install
+      msg = "Building YARD (yri) index for #{@spec.full_name}..."
+      @doc.should_receive(:say).with(msg)
+      @doc.install_ri_yard
+    end
+
+    it "should pass --quiet to all documentation" do
+      runs.with('-c', '-n', '--quiet', 'lib')
+      install
+    end
+
+    it "should pass extra_rdoc_files to documentation" do
+      @spec.extra_rdoc_files = %w(README LICENSE)
+      runs.with('-c', '-n', '--quiet', 'lib', '-', 'README', 'LICENSE')
+      install
+    end
+
+    it "should add --backtrace if Gem.configuration.backtrace" do
+      Gem.configuration.backtrace = true
+      runs.with('-c', '-n', '--quiet', '--backtrace', 'lib')
+      install
+      Gem.configuration.backtrace = false
+    end
+
+    it "should add require_paths if there is no .yardopts" do
+      File.should_receive(:file?).with(@yardopts).and_return(true)
+      runs.with('-c', '-n', '--quiet')
+      install
+    end
+
+    it "should add extra_rdoc_files if there is no .yardopts" do
+      @spec.extra_rdoc_files = %w(README LICENSE)
+      File.should_receive(:file?).with(@yardopts).and_return(true)
+      runs.with('-c', '-n', '--quiet')
+      install
+    end
+
+    it "should switch to directory before running command" do
+      old = Dir.pwd
+      Dir.should_receive(:chdir).with(@spec.full_gem_path)
+      Dir.should_receive(:chdir).with(old)
+      install
+    end
+
+    it "should ensure that directory is switched back at end of command in failure" do
+      old = Dir.pwd
+      Dir.should_receive(:chdir).with(@spec.full_gem_path)
+      Dir.should_receive(:chdir).with(old)
+      @doc.ui.errs.should_receive(:puts).with(/ERROR:\s*While generating documentation/)
+      @doc.ui.errs.should_receive(:puts).with(/MESSAGE:\s*foo/)
+      @doc.ui.errs.should_receive(:puts).with(/YARDOC args:\s*-c -n --quiet lib/)
+      @doc.ui.errs.should_receive(:puts).with("(continuing with the rest of the installation)")
+      YARD::CLI::Yardoc.should_receive(:run).and_raise(RuntimeError.new("foo"))
+      install
+    end
+
+    it "should handle permission errors" do
+      YARD::CLI::Yardoc.should_receive(:run).and_raise(Errno::EACCES.new("- dir"))
+      lambda { install }.should raise_error(Gem::FilePermissionError)
+    end
+  end
+
+  describe '#install_rdoc_yard' do
+    def install
+      msg = "Installing YARD documentation for #{@spec.full_name}..."
+      @doc.should_receive(:say).with(msg)
+      @doc.install_rdoc_yard
+    end
+
+    it "should add -o outdir when generating docs" do
+      File.should_receive(:file?).with(@yardopts).and_return(true)
+      @spec.has_yardoc = true
+      doc_dir = File.join(@doc.instance_variable_get("@doc_dir"), 'rdoc')
+      runs.with('-o', doc_dir, '--quiet')
+      install
+    end
+  end
+end if Gem::VERSION < '2.0.0'

data/vendor/bundle/gems/yard-0.8.6.1/spec/serializers/data/serialized_yardoc/checksums

@@ -0,0 +1 @@
+test.rb 80e5834ff1e98223761615c0917ff9b77b7ae057

data/vendor/bundle/gems/yard-0.8.6.1/spec/serializers/data/serialized_yardoc/proxy_types

@@ -0,0 +1,2 @@
+{I"Object:EF:
+class

data/vendor/bundle/gems/yard-0.8.6.1/spec/serializers/file_system_serializer_spec.rb

@@ -0,0 +1,124 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+require 'stringio'
+
+describe YARD::Serializers::FileSystemSerializer do
+  before do
+    FileUtils.stub!(:mkdir_p)
+    File.stub!(:open)
+  end
+
+  describe '#basepath' do
+    it "should default the base path to the 'doc/'" do
+      obj = Serializers::FileSystemSerializer.new
+      obj.basepath.should == 'doc'
+    end
+  end
+
+  describe '#extension' do
+    it "should default the file extension to .html" do
+      obj = Serializers::FileSystemSerializer.new
+      obj.extension.should == "html"
+    end
+  end
+
+  describe '#serialized_path' do
+    it "should allow no extension to be used" do
+      obj = Serializers::FileSystemSerializer.new :extension => nil
+      yard = CodeObjects::ClassObject.new(nil, :FooBar)
+      obj.serialized_path(yard).should == 'FooBar'
+    end
+
+    it "should serialize to top-level-namespace for root" do
+      obj = Serializers::FileSystemSerializer.new :extension => nil
+      obj.serialized_path(Registry.root).should == "top-level-namespace"
+    end
+
+    it "should return serialized_path for a String" do
+      s = Serializers::FileSystemSerializer.new(:basepath => 'foo', :extension => 'txt')
+      s.serialized_path('test.txt').should == 'test.txt'
+    end
+
+    it "should remove special chars from path" do
+      m = CodeObjects::MethodObject.new(nil, 'a')
+      s = Serializers::FileSystemSerializer.new
+
+      { :/ => '_2F_i.html',
+        :gsub! => 'gsub_21_i.html',
+        :ask? => 'ask_3F_i.html',
+        :=== => '_3D_3D_3D_i.html',
+        :+ => '_2B_i.html',
+        :- => '-_i.html',
+        :[]= => '_5B_5D_3D_i.html',
+        :<< => '_3C_3C_i.html',
+        :>= => '_3E_3D_i.html',
+        :` => '_60_i.html',
+        :& => '_26_i.html',
+        :* => '_2A_i.html',
+        :| => '_7C_i.html',
+        :/ => '_2F_i.html',
+        :=~ => '_3D_7E_i.html'
+      }.each do |meth, value|
+        m.stub!(:name).and_return(meth)
+        s.serialized_path(m).should == value
+      end
+    end
+
+    it "should handle ExtraFileObject's" do
+      s = Serializers::FileSystemSerializer.new
+      e = CodeObjects::ExtraFileObject.new('filename.txt', '')
+      s.serialized_path(e).should == 'file.filename.html'
+    end
+
+    it "should differentiate instance and class methods from serialized path" do
+      s = Serializers::FileSystemSerializer.new
+      m1 = CodeObjects::MethodObject.new(nil, 'meth')
+      m2 = CodeObjects::MethodObject.new(nil, 'meth', :class)
+      s.serialized_path(m1).should_not == s.serialized_path(m2)
+    end
+
+    it "should serialize path from overload tag" do
+      YARD.parse_string <<-'eof'
+        class Foo
+          # @overload bar
+          def bar; end
+        end
+      eof
+
+      serializer = Serializers::FileSystemSerializer.new
+      object = Registry.at('Foo#bar').tag(:overload)
+      serializer.serialized_path(object).should == "Foo/bar_i.html"
+    end
+  end
+
+  describe '#serialize' do
+    it "should serialize to the correct path" do
+      yard = CodeObjects::ClassObject.new(nil, :FooBar)
+      meth = CodeObjects::MethodObject.new(yard, :baz, :class)
+      meth2 = CodeObjects::MethodObject.new(yard, :baz)
+
+      { 'foo/FooBar/baz_c.txt' => meth,
+        'foo/FooBar/baz_i.txt' => meth2,
+        'foo/FooBar.txt' => yard }.each do |path, obj|
+        io = StringIO.new
+        File.should_receive(:open).with(path, 'wb').and_yield(io)
+        io.should_receive(:write).with("data")
+
+        s = Serializers::FileSystemSerializer.new(:basepath => 'foo', :extension => 'txt')
+        s.serialize(obj, "data")
+      end
+    end
+
+    it "should guarantee the directory exists" do
+      o1 = CodeObjects::ClassObject.new(nil, :Really)
+      o2 = CodeObjects::ClassObject.new(o1, :Long)
+      o3 = CodeObjects::ClassObject.new(o2, :PathName)
+      obj = CodeObjects::MethodObject.new(o3, :foo)
+
+      FileUtils.should_receive(:mkdir_p).once.with('doc/Really/Long/PathName')
+
+      s = Serializers::FileSystemSerializer.new
+      s.serialize(obj, "data")
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/spec/serializers/spec_helper.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+include YARD

data/vendor/bundle/gems/yard-0.8.6.1/spec/serializers/yardoc_serializer_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+instance_eval do
+  class YARD::Serializers::YardocSerializer
+    public :dump
+    public :internal_dump
+  end
+end
+
+describe YARD::Serializers::YardocSerializer do
+  before do
+    @serializer = YARD::Serializers::YardocSerializer.new('.yardoc')
+
+    Registry.clear
+    @foo = CodeObjects::ClassObject.new(:root, :Foo)
+    @bar = CodeObjects::MethodObject.new(@foo, :bar)
+  end
+
+  describe '#dump' do
+    it "should maintain object equality when loading a dumped object" do
+      newfoo = @serializer.internal_dump(@foo)
+      newfoo.should equal(@foo)
+      newfoo.should == @foo
+      @foo.should equal(newfoo)
+      @foo.should == newfoo
+      newfoo.hash.should == @foo.hash
+    end
+
+    it "should maintain hash key equality when loading a dumped object" do
+      newfoo = @serializer.internal_dump(@foo)
+      {@foo => 1}.should have_key(newfoo)
+      {newfoo => 1}.should have_key(@foo)
+    end
+  end
+
+  describe '#serialize' do
+    it "should accept a hash of codeobjects (and write to root)" do
+      data = {:root => Registry.root}
+      marshaldata = Marshal.dump(data)
+      filemock = mock(:file)
+      filemock.should_receive(:write).with(marshaldata)
+      File.should_receive(:open!).with('.yardoc/objects/root.dat', 'wb').and_yield(filemock)
+      @serializer.serialize(data)
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/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