nutshell-crm 0.0.1 → 0.0.2

data/vendor/bundle/gems/yard-0.7.4/spec/parser/tag_parsing_spec.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe YARD::Parser, "tag handling" do
+  before { parse_file :tag_handler_001, __FILE__ }
+  
+  it "should know the list of all available tags" do
+    P("Foo#foo").tags.should include(P("Foo#foo").tag(:api))
+  end
+  
+  it "should know the text of tags on a method" do
+    P("Foo#foo").tag(:api).text.should == "public"
+  end
+  
+  it "should return true when asked whether a tag exists" do
+    P("Foo#foo").has_tag?(:api).should == true
+  end
+  
+end

data/vendor/bundle/gems/yard-0.7.4/spec/rake/yardoc_task_spec.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::Rake::YardocTask do
+  before do
+    @yardoc = YARD::CLI::Yardoc.new
+    @yardoc.statistics = false
+    @yardoc.use_document_file = false
+    @yardoc.use_yardopts_file = false
+    @yardoc.generate = false
+    Templates::Engine.stub!(:render)
+    Templates::Engine.stub!(:generate)
+    YARD.stub!(:parse)
+    YARD::CLI::Yardoc.stub!(:new).and_return(@yardoc)
+    ::Rake.application.clear
+  end
+  
+  def run
+    ::Rake.application.tasks[0].invoke
+  end
+  
+  describe '#initialize' do
+    it "should allow separate rake task name to be set" do
+      YARD::Rake::YardocTask.new(:notyardoc)
+      ::Rake.application.tasks[0].name.should == "notyardoc"
+    end
+  end
+  
+  describe '#files' do
+    it "should allow files to be set" do
+      YARD::Rake::YardocTask.new do |t|
+        t.files = ['a', 'b', 'c']
+      end
+      run
+      @yardoc.files.should == %w(a b c)
+    end
+  end
+  
+  describe '#options' do
+    it "should allow extra options to be set" do
+      YARD::Rake::YardocTask.new do |t|
+        t.options = ['--private', '--protected']
+      end
+      run
+      @yardoc.visibilities.should == [:public, :private, :protected]
+    end
+  end
+  
+  describe '#before' do
+    it "should allow before callback" do
+      proc = lambda { }
+      proc.should_receive(:call)
+      @yardoc.should_receive(:run)
+      YARD::Rake::YardocTask.new {|t| t.before = proc }
+      run
+    end
+  end
+  
+  describe '#after' do
+    it "should allow after callback" do
+      proc = lambda { }
+      proc.should_receive(:call)
+      @yardoc.should_receive(:run)
+      YARD::Rake::YardocTask.new {|t| t.after = proc }
+      run
+    end
+    
+    describe '#verifier' do
+      it "should allow a verifier proc to be set" do
+        verifier = Verifier.new
+        @yardoc.should_receive(:run) do
+          @yardoc.options[:verifier].should == verifier
+        end
+        YARD::Rake::YardocTask.new {|t| t.verifier = verifier }
+        run
+      end
+
+      it "should override --query options" do
+        verifier = Verifier.new
+        @yardoc.should_receive(:run) do
+          @yardoc.options[:verifier].should == verifier
+        end
+        YARD::Rake::YardocTask.new do |t| 
+          t.options += ['--query', '@return']
+          t.verifier = verifier
+        end
+        run
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/registry_spec.rb

@@ -0,0 +1,303 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+include CodeObjects
+
+require "thread"
+
+describe YARD::Registry do
+  before { Registry.clear }
+  
+  describe '.yardoc_file_for_gem' do
+    before do
+      @gem = mock('gem')
+      @gem.stub!(:name).and_return('foo')
+      @gem.stub!(:full_name).and_return('foo-1.0')
+      @gem.stub!(:full_gem_path).and_return('/path/to/foo')
+    end
+    
+    it "should return nil if gem isn't found" do
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([])
+      Registry.yardoc_file_for_gem('foo').should == nil
+    end
+    
+    it "should allow version to be specified" do
+      Gem.source_index.should_receive(:find_name).with('foo', '= 2').and_return([])
+      Registry.yardoc_file_for_gem('foo', '= 2').should == nil
+    end
+    
+    it "should return existing .yardoc path for gem when for_writing=false" do
+      File.should_receive(:exist?).and_return(false)
+      File.should_receive(:exist?).with('/path/to/foo/.yardoc').and_return(true)
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      Registry.yardoc_file_for_gem('foo').should == '/path/to/foo/.yardoc'
+    end
+    
+    it "should return nil if no .yardoc path exists in gem when for_writing=false" do
+      File.should_receive(:exist?).and_return(false)
+      File.should_receive(:exist?).with('/path/to/foo/.yardoc').and_return(false)
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      Registry.yardoc_file_for_gem('foo').should == nil
+    end
+    
+    it "should search local gem path first if for_writing=false" do
+      File.should_receive(:exist?).and_return(true)
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      Registry.yardoc_file_for_gem('foo').should =~ %r{/.yard/gem_index/foo-1.0.yardoc$}
+    end
+    
+    it "should return global .yardoc path for gem if for_writing=true and dir is writable" do
+      File.should_receive(:writable?).with(@gem.full_gem_path).and_return(true)
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      Registry.yardoc_file_for_gem('foo', '>= 0', true).should == '/path/to/foo/.yardoc'
+    end
+
+    it "should return local .yardoc path for gem if for_writing=true and dir is not writable" do
+      File.should_receive(:writable?).with(@gem.full_gem_path).and_return(false)
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      Registry.yardoc_file_for_gem('foo', '>= 0', true).should =~ %r{/.yard/gem_index/foo-1.0.yardoc$}
+    end
+    
+    it "should return gem path if gem starts with yard-doc- and for_writing=false" do
+      @gem.stub!(:name).and_return('yard-doc-core')
+      @gem.stub!(:full_name).and_return('yard-doc-core-1.0')
+      @gem.stub!(:full_gem_path).and_return('/path/to/yard-doc-core')
+      Gem.source_index.should_receive(:find_name).with('yard-doc-core', '>= 0').and_return([@gem])
+      File.should_receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
+      Registry.yardoc_file_for_gem('yard-doc-core').should == '/path/to/yard-doc-core/.yardoc'
+    end
+    
+    it "should return nil if gem starts with yard-doc- and for_writing=true" do
+      @gem.stub!(:name).and_return('yard-doc-core')
+      @gem.stub!(:full_name).and_return('yard-doc-core-1.0')
+      @gem.stub!(:full_gem_path).and_return('/path/to/yard-doc-core')
+      Gem.source_index.should_receive(:find_name).with('yard-doc-core', '>= 0').and_return([@gem])
+      File.should_receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
+      Registry.yardoc_file_for_gem('yard-doc-core', '>= 0', true).should == nil
+    end
+  end
+  
+  describe '.root' do
+    it "should have an empty path for root" do
+      Registry.root.path.should == ""
+    end
+  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
+    
+      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 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)
+
+      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)
+
+      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 only check 'Path' in lookup on root namespace" do
+      Registry.should_receive(:at).once.with('Test').and_return(true)
+      Registry.resolve(Registry.root, "Test")
+    end
+    
+    it "should not perform lookup by joining namespace and name without separator" do
+      yard = ClassObject.new(:root, :YARD)
+      Registry.should_not_receive(:at).with('YARDB')
+      Registry.resolve(yard, 'B')
+    end
+  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 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
+  
+  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
+  
+  describe '.load_yardoc' do
+    it "should delegate load to RegistryStore" do
+      store = RegistryStore.new
+      store.should_receive(:load).with('foo')
+      RegistryStore.should_receive(:new).and_return(store)
+      Registry.yardoc_file = 'foo'
+      Registry.load_yardoc
+    end
+    
+    it "should return itself" do
+      Registry.load_yardoc.should == Registry
+    end
+    
+    it "should maintain hash key equality on loaded objects" do
+      Registry.clear
+      Registry.load!(File.dirname(__FILE__) + '/serializers/data/serialized_yardoc')
+      baz = Registry.at('Foo#baz')
+      Registry.at('Foo').aliases.keys.should include(baz)
+      Registry.at('Foo').aliases.has_key?(baz).should == true
+    end
+  end
+  
+  ['load', 'load_all', 'load!'].each do |meth|
+    describe('.' + meth) do
+      it "should return itself" do
+        Registry.send(meth).should == Registry
+      end
+    end
+  end
+  
+  describe '.each' do
+    before do 
+      YARD.parse_string "def a; end; def b; end; def c; end"
+    end
+    
+    after { Registry.clear }
+    
+    it "should iterate over .all" do
+      items = []
+      Registry.each {|x| items << x.path }
+      items.sort.should == ['#a', '#b', '#c']
+    end
+    
+    it "should include Enumerable and allow for find, select" do
+      Registry.find {|x| x.path == "#a" }.should be_a(CodeObjects::MethodObject)
+    end
+  end
+  
+  describe '.instance' do
+    it "should return itself" do
+      Registry.instance.should == Registry
+    end
+  end
+  
+  describe '.single_object_db' do
+    it "should default to nil" do
+      Registry.single_object_db.should == nil
+      Thread.new { Registry.single_object_db.should == nil }.join
+    end
+  end
+  
+  describe 'Thread local' do
+    it "should maintain two Registries in separate threads" do
+      barrier = 0
+      mutex   = Mutex.new
+      threads = []
+      threads << Thread.new do
+        Registry.clear
+        YARD.parse_string "# docstring 1\nclass Foo; end"
+        mutex.synchronize { barrier += 1 }
+        while barrier < 2 do
+          s = "barrier < 2, spinning"
+        end
+        Registry.at('Foo').docstring.should == "docstring 1"
+      end
+      threads << Thread.new do
+        Registry.clear
+        YARD.parse_string "# docstring 2\nclass Foo; end"
+        mutex.synchronize { barrier += 1 }
+        while barrier < 2 do
+          s = "barrier < 2, spinning"
+        end
+        Registry.at('Foo').docstring.should == "docstring 2"
+      end
+      threads.each {|t| t.join }
+    end
+
+    it "should allow setting of yardoc_file in separate threads" do
+      barrier = 0
+      mutex   = Mutex.new
+      threads = []
+      threads << Thread.new do
+        Registry.yardoc_file.should == '.yardoc'
+        Registry.yardoc_file = 'foo'
+        mutex.synchronize { barrier += 1 }
+        while barrier == 1 do
+          s = "barrier = 1, spinning"
+        end
+        Registry.yardoc_file.should == 'foo'
+      end
+      threads << Thread.new do
+        while barrier == 0 do
+          s = "barrier = 0, spinning"
+        end
+        Registry.yardoc_file.should == '.yardoc'
+        mutex.synchronize { barrier += 1 }
+        Registry.yardoc_file = 'foo2'
+      end
+      threads.each {|t| t.join }
+    end
+    
+    it "should automatically clear in new threads" do
+      Thread.new { Registry.all.should be_empty }.join
+    end
+  end
+end

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

@@ -0,0 +1,255 @@
+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')
+    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)
+      @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/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/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_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/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 not 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_multidb
+    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, 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, 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 '#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