yard 0.4.0 → 0.5.0

data/spec/parser/source_parser_spec.rb

@@ -72,23 +72,49 @@ describe YARD::Parser::SourceParser do
     end
   
     it "should parse a set of file globs" do
-      Dir.should_receive(:[]).with('lib/**/*.rb')
+      Dir.should_receive(:[]).with('lib/**/*.rb').and_return([])
       YARD.parse('lib/**/*.rb')
     end
   
     it "should parse a set of absolute paths" do
-      Dir.should_not_receive(:[])
+      Dir.should_not_receive(:[]).and_return([])
+      File.should_receive(:file?).with('/path/to/file').and_return(true)
       IO.should_receive(:read).with('/path/to/file').and_return("")
       YARD.parse('/path/to/file')
     end
 
     it "should parse files with '*' in them as globs and others as absolute paths" do
       Dir.should_receive(:[]).with('*.rb').and_return(['a.rb', 'b.rb'])
+      File.should_receive(:file?).with('/path/to/file').and_return(true)
+      File.should_receive(:file?).with('a.rb').and_return(true)
+      File.should_receive(:file?).with('b.rb').and_return(true)
       IO.should_receive(:read).with('/path/to/file').and_return("")
       IO.should_receive(:read).with('a.rb').and_return("")
       IO.should_receive(:read).with('b.rb').and_return("")
       YARD.parse ['/path/to/file', '*.rb']
     end
+    
+    it "should convert directories into globs" do
+      Dir.should_receive(:[]).with('foo/**/*.{rb,c}').and_return(['foo/a.rb', 'foo/bar/b.rb'])
+      File.should_receive(:directory?).with('foo').and_return(true)
+      File.should_receive(:file?).with('foo/a.rb').and_return(true)
+      File.should_receive(:file?).with('foo/bar/b.rb').and_return(true)
+      IO.should_receive(:read).with('foo/a.rb').and_return("")
+      IO.should_receive(:read).with('foo/bar/b.rb').and_return("")
+      YARD.parse ['foo']
+    end
+    
+    it "should use Registry.checksums cache if file is cached" do
+      data = 'DATA'
+      hash = Registry.checksum_for(data)
+      cmock = mock(:cmock)
+      cmock.should_receive(:[]).with('foo/bar').and_return(hash)
+      log.should_receive(:info)
+      Registry.should_receive(:checksums).and_return(cmock)
+      File.should_receive(:file?).with('foo/bar').and_return(true)
+      IO.should_receive(:read).with('foo/bar').and_return(data)
+      YARD.parse('foo/bar')
+    end
   end
   
   describe '#parse_in_order' do
@@ -109,6 +135,7 @@ describe YARD::Parser::SourceParser do
     
     it "should attempt to order files by length (process toplevel files first)" do
       %w(a a/b a/b/c).each do |file|
+        File.should_receive(:file?).with(file).and_return(true)
         IO.should_receive(:read).with(file).ordered.and_return('')
       end
       YARD.parse %w(a/b/c a/b a)
@@ -116,11 +143,6 @@ describe YARD::Parser::SourceParser do
   end
   
   describe '#parse_statements' do
-    it "should display a warning for C/C++ files" do
-      log.should_receive(:warn).with(/no support/)
-      YARD::Parser::SourceParser.parse_string("int main() { }", :c)
-    end
-    
     it "should display a warning for invalid parser type" do
       log.should_receive(:warn).with(/unrecognized file/)
       YARD::Parser::SourceParser.parse_string("int main() { }", :d)

data/spec/registry_spec.rb

@@ -4,94 +4,115 @@ include CodeObjects
 describe YARD::Registry do
   before { Registry.clear }
   
-  it "should have an empty path for root" do
-    Registry.root.path.should == ""
+  describe '#root' do
+    it "should have an empty path for root" do
+      Registry.root.path.should == ""
+    end
   end
   
-  it "should #resolve any existing namespace" do
-    o1 = ModuleObject.new(:root, :A)
-    o2 = ModuleObject.new(o1, :B)
-    o3 = ModuleObject.new(o2, :C)
-    Registry.resolve(o1, "B::C").should == o3
-    Registry.resolve(:root, "A::B::C")
-  end
+  describe '#resolve' do
+    it "should resolve any existing namespace" do
+      o1 = ModuleObject.new(:root, :A)
+      o2 = ModuleObject.new(o1, :B)
+      o3 = ModuleObject.new(o2, :C)
+      Registry.resolve(o1, "B::C").should == o3
+      Registry.resolve(:root, "A::B::C")
+    end
   
-  it "should resolve an object in the root namespace when prefixed with ::" do
-    o1 = ModuleObject.new(:root, :A)
-    o2 = ModuleObject.new(o1, :B)
-    o3 = ModuleObject.new(o2, :C)
-    Registry.resolve(o3, "::A").should == o1
+    it "should resolve an object in the root namespace when prefixed with ::" do
+      o1 = ModuleObject.new(:root, :A)
+      o2 = ModuleObject.new(o1, :B)
+      o3 = ModuleObject.new(o2, :C)
+      Registry.resolve(o3, "::A").should == o1
     
-    Registry.resolve(o3, "::String", false, true).should == P(:String)
-  end
+      Registry.resolve(o3, "::String", false, true).should == P(:String)
+    end
   
-  it "should resolve instance methods with # prefix" do
-    o1 = ModuleObject.new(:root, :A)
-    o2 = ModuleObject.new(o1, :B)
-    o3 = ModuleObject.new(o2, :C)
-    o4 = MethodObject.new(o3, :methname)
-    Registry.resolve(o1, "B::C#methname").should == o4
-    Registry.resolve(o2, "C#methname").should == o4
-    Registry.resolve(o3, "#methname").should == o4
-  end
+    it "should resolve instance methods with # prefix" do
+      o1 = ModuleObject.new(:root, :A)
+      o2 = ModuleObject.new(o1, :B)
+      o3 = ModuleObject.new(o2, :C)
+      o4 = MethodObject.new(o3, :methname)
+      Registry.resolve(o1, "B::C#methname").should == o4
+      Registry.resolve(o2, "C#methname").should == o4
+      Registry.resolve(o3, "#methname").should == o4
+    end
   
-  it "should resolve instance methods in the root without # prefix" do
-    o = MethodObject.new(:root, :methname)
-    Registry.resolve(:root, 'methname').should == o
-  end
+    it "should resolve instance methods in the root without # prefix" do
+      o = MethodObject.new(:root, :methname)
+      Registry.resolve(:root, 'methname').should == o
+    end
   
-  it "should resolve superclass methods when inheritance = true" do
-    superyard = ClassObject.new(:root, :SuperYard)
-    yard = ClassObject.new(:root, :YARD)
-    yard.superclass = superyard
-    imeth = MethodObject.new(superyard, :hello)
-    cmeth = MethodObject.new(superyard, :class_hello, :class)
+    it "should resolve superclass methods when inheritance = true" do
+      superyard = ClassObject.new(:root, :SuperYard)
+      yard = ClassObject.new(:root, :YARD)
+      yard.superclass = superyard
+      imeth = MethodObject.new(superyard, :hello)
+      cmeth = MethodObject.new(superyard, :class_hello, :class)
 
-    Registry.resolve(yard, "#hello", false).should be_nil
-    Registry.resolve(yard, "#hello", true).should == imeth
-    Registry.resolve(yard, "class_hello", false).should be_nil
-    Registry.resolve(yard, "class_hello", true).should == cmeth
-  end
+      Registry.resolve(yard, "#hello", false).should be_nil
+      Registry.resolve(yard, "#hello", true).should == imeth
+      Registry.resolve(yard, "class_hello", false).should be_nil
+      Registry.resolve(yard, "class_hello", true).should == cmeth
+    end
 
-  it "should resolve mixin methods when inheritance = true" do
-    yard = ClassObject.new(:root, :YARD)
-    mixin = ModuleObject.new(:root, :Mixin)
-    yard.mixins(:instance) << mixin
-    imeth = MethodObject.new(mixin, :hello)
-    cmeth = MethodObject.new(mixin, :class_hello, :class)
+    it "should resolve mixin methods when inheritance = true" do
+      yard = ClassObject.new(:root, :YARD)
+      mixin = ModuleObject.new(:root, :Mixin)
+      yard.mixins(:instance) << mixin
+      imeth = MethodObject.new(mixin, :hello)
+      cmeth = MethodObject.new(mixin, :class_hello, :class)
 
-    Registry.resolve(yard, "#hello", false).should be_nil
-    Registry.resolve(yard, "#hello", true).should == imeth
-    Registry.resolve(yard, "class_hello", false).should be_nil
-    Registry.resolve(yard, "class_hello", true).should == cmeth
+      Registry.resolve(yard, "#hello", false).should be_nil
+      Registry.resolve(yard, "#hello", true).should == imeth
+      Registry.resolve(yard, "class_hello", false).should be_nil
+      Registry.resolve(yard, "class_hello", true).should == cmeth
+    end
   end
   
-  it "should allow symbols as object type in #all" do
-    ModuleObject.new(:root, :A)
-    o1 = ClassObject.new(:root, :B)
-    o2 = MethodObject.new(:root, :testing)
-    r = Registry.all(:method, :class)
-    r.should include(o1, o2)
-  end
+  describe '#all' do
+    it "should return objects of types specified by arguments" do
+      ModuleObject.new(:root, :A)
+      o1 = ClassObject.new(:root, :B)
+      o2 = MethodObject.new(:root, :testing)
+      r = Registry.all(:method, :class)
+      r.should include(o1, o2)
+    end
   
-  it "should allow code object classes in #all" do
-    o1 = ModuleObject.new(:root, :A)
-    o2 = ClassObject.new(:root, :B)
-    MethodObject.new(:root, :testing)
-    r = Registry.all(CodeObjects::NamespaceObject)
-    r.should include(o1, o2)
+    it "should return code objects" do
+      o1 = ModuleObject.new(:root, :A)
+      o2 = ClassObject.new(:root, :B)
+      MethodObject.new(:root, :testing)
+      r = Registry.all(CodeObjects::NamespaceObject)
+      r.should include(o1, o2)
+    end
+  
+    it "should allow #all to omit list" do
+      o1 = ModuleObject.new(:root, :A)
+      o2 = ClassObject.new(:root, :B)
+      r = Registry.all
+      r.should include(o1, o2)
+    end
   end
   
-  it "should allow #all to omit list" do
-    o1 = ModuleObject.new(:root, :A)
-    o2 = ClassObject.new(:root, :B)
-    r = Registry.all
-    r.should include(o1, o2)
+  describe '#paths' do
+    it "should return all object paths" do
+      o1 = ModuleObject.new(:root, :A)
+      o2 = ClassObject.new(:root, :B)
+      Registry.paths.should include('A', 'B')
+    end
   end
   
-  it "should respond to #paths" do
-    o1 = ModuleObject.new(:root, :A)
-    o2 = ClassObject.new(:root, :B)
-    Registry.paths.should include('A', 'B')
+  describe '#load_yardoc' do
+    before do
+      @store = RegistryStore.new
+      RegistryStore.should_receive(:new).and_return(@store)
+    end
+    
+    it "should delegate load to RegistryStore" do
+      @store.should_receive(:load).with('foo')
+      Registry.yardoc_file = 'foo'
+      Registry.load_yardoc
+    end
   end
 end

data/spec/registry_store_spec.rb

@@ -0,0 +1,184 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe YARD::RegistryStore do
+  before { @store = RegistryStore.new }
+  
+  describe '#load' do
+    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).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/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).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/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(: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/objects/root.dat').and_return(false)
+      File.should_receive(:read).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/objects/root.dat').and_return(true)
+      File.should_receive(:read).with('foo/objects/root.dat').and_return(Marshal.dump('foo'))
+      @store.load('foo').should == true
+      @store.root.should == 'foo'
+    end
+  end
+  
+  describe '#put' do
+    it "should assign values" do
+      @store.put(:YARD, true)
+      @store.get(:YARD).should == true
+    end
+    
+    it "should treat '' as root" do
+      @store.put('', 'value')
+      @store.get(:root).should == 'value'
+    end
+  end
+  
+  describe '#get' do
+    it "should hit cache if object exists" do
+      @store.put(:YARD, true)
+      @store.get(:YARD).should == true
+    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)
+      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 '#load_all' do
+    it "should load the entire database" do
+      foomock = mock(:Foo)
+      barmock = mock(:Bar)
+      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/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
+end

data/spec/serializers/file_system_serializer_spec.rb

@@ -8,90 +8,111 @@ describe YARD::Serializers::FileSystemSerializer do
     File.stub!(:open)
   end
   
-  it "should default the base path to the 'doc/'" do
-    obj = Serializers::FileSystemSerializer.new
-    obj.basepath.should == 'doc'
-  end
-  
-  it "should default the file extension to .html" do
-    obj = Serializers::FileSystemSerializer.new
-    obj.extension.should == "html"
-  end
-  
-  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'
+  describe '#basepath' do
+    it "should default the base path to the 'doc/'" do
+      obj = Serializers::FileSystemSerializer.new
+      obj.basepath.should == 'doc'
+    end
   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"
+
+  describe '#extension' do
+    it "should default the file extension to .html" do
+      obj = Serializers::FileSystemSerializer.new
+      obj.extension.should == "html"
+    end
   end
   
-  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")
-    
+  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.serialize(obj, "data")
+      s.serialized_path('test.txt').should == 'test.txt'
     end
-  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
+    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 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
   
-  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 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)
+  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)
 
-    FileUtils.should_receive(:mkdir_p).once.with('doc/Really/Long/PathName')
-    
-    s = Serializers::FileSystemSerializer.new
-    s.serialize(obj, "data")
+      { '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