ruber 0.0.8 → 0.0.9

data/spec/document_list_spec.rb

@@ -1,624 +1,734 @@
+require './spec/framework'
 require './spec/common'
-require 'pathname'
 
-require 'ruber/utils'
-require 'ruber/documents/document_list'
-require 'ruber/plugin_specification'
+require 'ruber/world/document_list'
+require 'ruber/editor/document'
 
-describe Ruber::DocumentList do
+describe Ruber::World::DocumentList do
   
-  before do
-    @app = KDE::Application.instance
-    @pdf = Ruber::PluginSpecification.full({:name => :documents, :class => Ruber::DocumentList})
-    @manager = flexmock("manager"){|m| m.should_ignore_missing}
-    flexmock(Ruber).should_receive(:[]).with(:app).and_return @app
-    flexmock(Ruber).should_receive(:[]).with(:components).and_return @manager
-    flexmock(Ruber).should_receive(:[]).with(:config).and_return nil
-    @mw = Qt::Widget.new
-    flexmock(Ruber).should_receive(:[]).with(:main_window).and_return @mw
-    @keeper = Ruber::DocumentList.new @manager, @pdf
-    flexmock(Ruber).should_receive(:[]).with(:docs).and_return @keeper
-    flexmock(Ruber).should_receive(:[]).with(:documents).and_return @keeper
+  def create_list docs
+    Ruber::World::DocumentList.new docs
   end
   
-  after do
-    @keeper.instance_variable_get(:@docs).each{|d| d.dispose rescue nil}
+  before do
+    @docs = 3.times.map{Ruber::Document.new}
   end
   
-  it 'should be Enumerable' do
-    Ruber::DocumentList.ancestors.include?(Enumerable).should be_true
-  end
-
-  it 'should have no documents when created' do
-    @keeper.should be_empty
+  it 'includes the enumerable module' do
+    Ruber::World::DocumentList.ancestors.should include(Enumerable)
   end
   
-  it 'should call the initialize_plugin method' do
-    @keeper.plugin_description.should == @pdf
+  describe '.new' do
+    
+    it 'takes a Ruber::Worl::dDocumentList or an array as parameters' do
+      list = Ruber::World::DocumentList.new @docs
+      list.should == @docs
+      other_list = Ruber::World::MutableDocumentList.new(@docs)
+      list = Ruber::World::DocumentList.new other_list
+      list.should == @docs
+    end
+    
+    it 'doesn\'t create a duplicate of the argument if the argument is a DocumentList' do
+      other_list = Ruber::World::DocumentList.new(@docs)
+      list = Ruber::World::DocumentList.new other_list
+      list.send(:document_array).should equal(other_list.send(:document_array))
+    end
+    
+    it 'creates a duplicate of the argument if the argument is not a DocumentList' do
+      list = Ruber::World::DocumentList.new @docs
+      new_doc = Ruber::Document.new
+      @docs << new_doc
+      list.size.should == 3
+    end
+    
   end
-
-  describe 'Ruber::DocumentList#[]' do
+  
+  describe '#each' do
     
-    context 'when called with an integer argument' do
-      
-      before do
-        @docs = 4.times.map do 
-          doc = Ruber::Document.new Ruber[:main_window]
-          @keeper.add_document doc
-          doc
-        end
-      end
+    before do
+      @list = create_list @docs
+    end
+    
+    context 'when called with a block' do
       
-      it 'returns the document in the given position' do
+      it 'calls the block once for each document' do
         res = []
-        4.times{|i| res[i] = @keeper[i]}
+        @list.each{|d| res << d}
         res.should == @docs
       end
       
-      it 'returns nil if the index is out of range' do
-        @keeper[5].should be_nil
+      it 'returns self' do
+        @list.each{|d|}.should == @list
       end
-    
+      
     end
     
-    context 'when called with a string representing an absolute path' do
+    context 'when called without a block' do
       
-      it 'returns the document associated with the path' do
-        doc = Ruber::Document.new Ruber[:main_window], __FILE__
-        @keeper.add_document doc
-        @keeper[File.expand_path(__FILE__)].should == doc
-      end
-    
-      it 'returns nil if a document for that file doesn\'t exist' do
-        @keeper[`which ruby`].should be_nil
+      it 'returns an enumerator which iterates on all documents' do
+        res = []
+        enum = @list.each
+        enum.should be_an(Enumerator)
+        enum.each{|d| res << d}
+        res.should == @docs
       end
       
     end
     
-    context 'when called with a string which doensn\'t represent an absolute path' do
+  end
+  
+  describe '#empty?' do
+        
+    it 'returns true if the list doesn\'t contain any element' do
+      list = create_list []
+      list.should be_empty
+    end
+    
+    it 'returns false if the list contains at least one element' do
+      list = create_list @docs
+      list.should_not be_empty
+    end
+    
+  end
+  
+  describe '#size' do
+    
+    it 'returns the number of elements in the list' do
+      list = create_list []
+      list.size.should == 0
+      list = create_list [Ruber::Document.new]
+      list.size.should == 1
+      list = create_list @docs
+      list.size.should == 3
+    end
+    
+  end
+  
+  describe '#==' do
+    
+    before do
+      @list = create_list @docs
+    end
+    
+    context 'when the argument is a DocumentList' do
+          
+      it 'returns true if the argument contains the same documents in the same order' do
+        other = create_list @docs
+        @list.should == other
+      end
       
-      it 'returns the document with the given document_name' do
-        doc = Ruber::Document.new Ruber[:main_window], __FILE__
-        @keeper.add_document doc
-        @keeper[doc.document_name].should == doc
+      it 'returns false if the argument contains different documents' do
+        other = create_list [@docs[1], @docs[2]]
+        @list.should_not == other
       end
       
-      it 'returns nil if no document with the given document name exists' do
-        @keeper['abcd'].should be_nil
+      it 'returns false if the argument contains the same documents in different order' do
+        other = create_list [@docs[1], @docs[2], @docs[0]]
+        @list.should_not == other
       end
       
     end
     
-    context 'when called with a KDE::Url' do
+    context 'when the argument is an Array' do
       
-      it 'returns the document associated with the url' do
-        url = KDE::Url.new 'http://github.com/stcrocco/ruber/raw/master/ruber.gemspec'
-        doc = Ruber::Document.new Ruber[:main_window], url
-        @keeper.add_document doc
-        @keeper[url].should == doc
+      it 'returns true if the argument contains the same documents in the same order' do
+        @list.should == @docs
       end
       
-      it 'returns nil if no document is associated with the given url' do
-        url = KDE::Url.new 'http://github.com/stcrocco/ruber/raw/master/ruber.gemspec'
-        @keeper[url].should be_nil
+      it 'returns false if the argument contains different documents' do
+        @list.should_not == [@docs[1], @docs[2]]
       end
       
-    end
-
-    context 'when called with any other argument' do
-
-      it 'raises TypeError' do
-        doc = @keeper.document __FILE__
-        lambda{@keeper[1.2]}.should raise_error(TypeError)
-        lambda{@keeper[{}]}.should raise_error(TypeError)
-        lambda{@keeper[:xyz]}.should raise_error(TypeError)
+      it 'returns false if the argument contains the same documents in different order' do
+        @list.should_not == [@docs[1], @docs[2], @docs[0]]
       end
+      
+    end
     
+    context 'when the argument is neither a DocumentList nor an array' do
+      
+      it 'returns false' do
+        @list.should_not == {}
+      end
+      
     end
-
+    
   end
-
-  describe 'Ruber::Document#document_for_file' do
-
-    it 'returns the document corresponding to the given absolute path or nil' do
-      doc = @keeper.document __FILE__
-      @keeper.document_for_file( File.expand_path(__FILE__)).should == doc
-      @keeper.document_for_file('/test').should be_nil
+  
+  describe '#eql?' do
+    
+    before do
+      @list = create_list @docs
     end
-
-    it 'returns the document corresponding to the given relative path (expanding it) or nil' do
-      doc = @keeper.document __FILE__
-      @keeper.document_for_file( __FILE__).should == doc
-      @keeper.document_for_file('test').should be_nil
+    
+    context 'when the argument is a DocumentList' do
+      
+      it 'returns true if the argument contains the same documents in the same order' do
+        other = create_list @docs
+        @list.should eql(other)
+      end
+      
+      it 'returns false if the argument contains different documents' do
+        other = create_list [@docs[1], @docs[2]]
+        @list.should_not eql(other)
+      end
+      
+      it 'returns false if the argument contains the same documents in different order' do
+        other =  create_list [@docs[1], @docs[2], @docs[0]]
+        @list.should_not eql(other)
+      end
+      
     end
-
-  end
-
-  describe 'Ruber::Document#document_with_name' do
     
-    it 'should return the document with the given document_name or nil' do
-      doc = @keeper.document __FILE__
-      @keeper.document_with_name( File.basename(__FILE__)).should == doc
-      @keeper.document_for_file('test').should be_nil
+    context 'when the argument is not a DocumentList' do
+      
+      it 'returns false' do
+        @list.should_not eql([])
+        @list.should_not eql({})
+      end
+      
     end
-
+    
   end
   
-  describe '#document_for_url' do
+  describe '#hash' do
     
-    it 'returns the document associated with the given KDE::Url' do
-      url = KDE::Url.new 'http://github.com/stcrocco/ruber/raw/master/ruber.gemspec'
-      doc = Ruber::Document.new Ruber[:main_window], url
-      @keeper.add_document doc
-      @keeper.document_for_url(url).should == doc
+    it 'returns the same value as an array contining the same arguments' do
+      list = create_list @docs
+      list.hash.should == @docs.hash
     end
     
-    it 'converts the argoment to a KDE::Url if it\'s a string' do
-      str = 'http://github.com/stcrocco/ruber/raw/master/ruber.gemspec'
-      url = KDE::Url.new str
-      doc = Ruber::Document.new Ruber[:main_window], url
-      @keeper.add_document doc
-      @keeper.document_for_url(str).should == doc
-    end
+  end
+  
+  describe '#[]' do
     
-    it 'returns nil if no document corresponding to the url exists' do
-      url = 'http://github.com/stcrocco/ruber/raw/master/ruber.gemspec'
-      @keeper.document_for_url(KDE::Url.new(url)).should be_nil
-      @keeper.document_for_url(url).should be_nil
+    context 'when called with an integer argument' do
+      
+      before do
+        @list = create_list @docs
+      end
+      
+      it 'returns the document at the given position' do
+        @list[1].should == @docs[1]
+      end
+      
+      it 'counts backward if the argument is negative' do
+        @list[-1].should == @docs[2]
+      end
+      
+      it 'returns nil if the argument is out of range' do
+        @list[5].should be_nil
+      end
+      
     end
     
-  end
-
-  describe '#each' do
+    context 'when the argument is an integer range' do
+      
+      before do
+        @list = create_list @docs
+      end
+      
+      it 'returns the document with indexes in the given range' do
+        @list[0..1].should == [@docs[0], @docs[1]]
+      end
+      
+      it 'returns only the documents corresponding to existing indexes if the argument is partially out of range' do
+        @list[0..5].should == @docs
+      end
+      
+      it 'returns nil if the argument is out of range' do
+        @list[5..9].should be_nil
+      end
+      
+    end
     
-    context 'when called with a block' do
-
-      it 'allows to iterate on all documents (in creation order)' do
-        docs = 4.times.map{@keeper.new_document}
-        res = []
-        @keeper.each{|d| res << d}
-        res.should == docs
+    context 'when called with a KDE::Url' do
+      
+      before do
+        @docs << Ruber::Document.new(__FILE__)
+        @list = create_list @docs
       end
       
-      it 'returns self' do
-        docs = 4.times.map{@keeper.new_document}
-        @keeper.each{|d| d}.should equal(@keeper)
+      it 'returns the document associated with the argument' do
+        @list[KDE::Url.new(__FILE__)].should == @docs[-1]
+      end
+      
+      it 'returns the first of the documents associated with the argument if there is more than one document for the given URL' do
+        doc = Ruber::Document.new __FILE__
+        @list = create_list @docs + [doc]
+        @list[KDE::Url.new(__FILE__)].should == @docs[-1]
+      end
+      
+      it 'returns nil if there\'s no document associated with the given URL' do
+        @list[KDE::Url.new('file:///xyz')].should be_nil
       end
+      
+    end
     
+    context 'when called with a string starting with a slash' do
+      
+      before do
+        @docs << Ruber::Document.new(__FILE__)
+        @list = create_list @docs
+      end
+      
+      it 'returns the document associated with the file corresponding to the argument' do
+        @list[__FILE__].should == @docs[-1]
+      end
+      
+      it 'returns the first of the documents associated with the argument if there is more than one document for the given URL' do
+        doc = Ruber::Document.new __FILE__
+        @list = create_list @docs + [doc]
+        @list[__FILE__].should == @docs[-1]
+      end
+      
+      it 'doesn\'t return remote files' do
+        url = KDE::Url.new("http://xyz.it#{__FILE__}")
+        remote_doc = Ruber::Document.new url
+        @list = create_list @docs + [remote_doc]
+        @list[__FILE__].should == @docs[-1]
+      end
+      
+      it 'returns nil if there\'s no local file associated with the given file' do
+        @docs.delete_at -1
+        @list = create_list @docs
+        @list[__FILE__].should be_nil
+        url = KDE::Url.new("http://xyz.it#{__FILE__}")
+        remote_doc = Ruber::Document.new url
+        @list = create_list @docs + [remote_doc]
+        @list[__FILE__].should be_nil
+      end
+      
     end
     
-    context 'when called without a block' do
+    context 'when called with a string not starting with a slash' do
       
-      it 'returns an enumerator which allows to iterate on all documents in creation order and returns the list' do
-        docs = 4.times.map{@keeper.new_document}
-        e = @keeper.each
-        e.should be_an(Enumerable)
-        res = []
-        obj = e.each{|d| res << d}
-        res.should == docs
-        obj.should == @keeper
+      before do
+        flexmock(@docs[1]).should_receive(:document_name).and_return('doc1')
+        flexmock(@docs[2]).should_receive(:document_name).and_return('doc2')
+        @list = create_list @docs
       end
-
+      
+      it 'returns the document with having the argument as document name' do
+        @list['doc1'].should == @docs[1]
+      end
+      
+      it 'returns the first of the documents with the given document name if there is more than one document with that document name' do
+        doc = Ruber::Document.new
+        flexmock(doc).should_receive(:document_name).and_return('doc1')
+        @list = create_list @docs + [doc]
+        @list['doc1'].should == @docs[1]
+      end
+      
+      it 'returns nil if there\'s no document with the given document name' do
+        @list['xyz'].should be_nil
+      end
+      
     end
-
-
+    
   end
-
-  describe 'Ruber::Document#each_document' do
   
-    it 'should allow to iterate on all documents (in creation order) when called with a block' do
-      docs = 4.times.map{@keeper.new_document}
-      res = []
-      @keeper.each_document{|d| res << d}
-      res.should == docs
+  describe '#document_for_file' do
+    
+    before do
+      @docs = [Ruber::Document.new, Ruber::Document.new(__FILE__), Ruber::Document.new]
+      @list = create_list @docs
     end
-  
-    it 'should return an enumerator which allows to iterate on all documents in creation order when called without a block' do
-      docs = 4.times.map{@keeper.new_document}
-      e = @keeper.each_document
-      e.should be_an(Enumerable)
-      res = []
-      e.each{|d| res << d}
-      res.should == docs
+    
+    it 'returns the document associated with the given file' do
+      @list.document_for_file(__FILE__).should == @docs[1]
     end
-  
-  end
-
-  describe 'Ruber::Document#documents' do
-
-    it 'should return an array with all the documents, in an arbitrary order' do
-      docs = 4.times.map{@keeper.new_document}
-      res = @keeper.documents
-      res.should be_kind_of(Array)
-      res.should == docs
+    
+    it 'returns nil if there\'s no document associated with the given file' do
+      @list.document_for_file('/xyz').should be_nil
     end
-
-  end
-
-  describe 'Ruber::Document#to_a' do
-
-    it 'should return an array with all the documents, in an arbitrary order' do
-      docs = 4.times.map{@keeper.new_document}
-      res = @keeper.to_a
-      res.should be_kind_of(Array)
-      res.should == docs
+    
+    it 'doesn\'t return remote files' do
+      @docs.delete_at 1
+      url = KDE::Url.new("http://www.xyz.org#{__FILE__}")
+      @list = create_list @docs + [Ruber::Document.new(url)]
+      @list.document_for_file(__FILE__).should be_nil
     end
-
-  end
-
-  describe 'Ruber::Document#document_for_file?' do
-
-    it 'should tell whether there\'s a document for the given filename if called with an absolute filename' do
-      @keeper.document __FILE__
-      @keeper.document_for_file?( File.expand_path(__FILE__) ).should be_true
-      @keeper.document_for_file?('/test').should be_false
+    
+    it 'returns the first document associated with the given file, if more than one document is associated with it' do
+      @list = create_list @docs + [Ruber::Document.new(__FILE__)]
+      @list.document_for_file(__FILE__).should == @docs[1]
     end
-
-    it 'should tell whether there\'s a document for the given filename if called with a relative filename (which will be expanded)' do
-      @keeper.document __FILE__
-      @keeper.document_for_file?( __FILE__ ).should be_true
-      @keeper.document_for_file?('test').should be_false
+    
+    it 'raises ArgumentError if the file name is relative' do
+      file = File.basename(__FILE__)
+      lambda{@list.document_for_file file}.should raise_error(ArgumentError, "#{file} is not an absolute path")
     end
-
+    
   end
   
-  describe '#document_for_url?' do
+  describe '#document_for_file?' do
     
-    it 'returns true if a document associated with the given KDE::Url exists' do
-      url = KDE::Url.new 'http://github.com/stcrocco/ruber/raw/master/ruber.gemspec'
-      doc = Ruber::Document.new Ruber[:main_window], url
-      @keeper.add_document doc
-      @keeper.document_for_url?(url).should be_true
+    before do
+      @docs = [Ruber::Document.new, Ruber::Document.new(__FILE__), Ruber::Document.new]
+      @list = create_list @docs
     end
     
-    it 'converts the argoment to a KDE::Url if it\'s a string' do
-      str = 'http://github.com/stcrocco/ruber/raw/master/ruber.gemspec'
-      url = KDE::Url.new str
-      doc = Ruber::Document.new Ruber[:main_window], url
-      @keeper.add_document doc
-      @keeper.document_for_url?(str).should be_true
+    it 'returns true if there\'s a document associated with the given file' do
+      @list.document_for_file?(__FILE__).should == true
     end
     
-    it 'returns false if no document corresponding to the url exists' do
-      url = 'http://github.com/stcrocco/ruber/raw/master/ruber.gemspec'
-      @keeper.document_for_url(KDE::Url.new(url)).should be_false
-      @keeper.document_for_url(url).should be_false
+    it 'returns false if there\'s no document associated with the given file' do
+      @list.document_for_file?('/xyz').should == false
     end
-
-  end
-
-  describe 'Ruber::Document#document_with_name' do
-
-    it 'should tell whether there\'s a document with the given document_name' do
-      @keeper.document __FILE__
-      @keeper.document_with_name?( File.basename(__FILE__ )).should be_true
-      @keeper.document_with_name?('test').should be_false
+    
+    it 'raises ArgumentError if the file name is relative' do
+      file = File.basename(__FILE__)
+      lambda{@list.document_for_file? file}.should raise_error(ArgumentError, "#{file} is not an absolute path")
     end
-
+    
   end
-
-  describe 'Ruber::Document#documents_with_file' do
+  
+  describe '#document_for_url' do
     
     before do
-      @all_docs = []
-      @empty_docs = []
-      @local_docs = []
-      @remote_docs = []
-      @empty_docs << Ruber::Document.new << Ruber::Document.new
-      @local_docs << Ruber::Document.new(nil, __FILE__) << Ruber::Document.new(nil, File.join(File.dirname(__FILE__), 'common.rb'))
-      @remote_docs << Ruber::Document.new(nil, KDE::Url.new('http://github.com/stcrocco/ruber/raw/master/ruber.gemspec')) << Ruber::Document.new(nil,
-        KDE::Url.new('http://github.com/stcrocco/ruber/raw/master/bin/ruber'))
-      @all_docs << @empty_docs[0] << @local_docs[0] << @remote_docs[0] << @remote_docs[1] << @local_docs[1] << @empty_docs[1]
-      @all_docs.each{|d| @keeper.add_document d}
+      @docs = [Ruber::Document.new, Ruber::Document.new(__FILE__), Ruber::Document.new]
+      @list = create_list @docs
     end
     
-    describe 'when called with the :local argument' do
-      it 'returns an array containing only the documents associated with local files' do
-        @keeper.documents_with_file(:local).should == @local_docs
-      end
+    it 'returns the document associated with the given URL' do
+      @list.document_for_url(KDE::Url.new(__FILE__)).should == @docs[1]
     end
     
-    describe 'when called with the :remote argument' do
-      it 'returns an array containing only the documents associated with remote files' do
-        @keeper.documents_with_file(:remote).should == @remote_docs
-      end
+    it 'returns nil if there\'s no document associated with the given file' do
+      @list.document_for_url(KDE::Url.new('http://xyz.org/abc')).should be_nil
     end
     
-    describe 'when called with the :any argument' do
-      it 'returns an array containing the documents associated with any file' do
-        @keeper.documents_with_file(:any).should == [@local_docs[0], @remote_docs[0], @remote_docs[1], @local_docs[1]]
-      end
+    it 'works if the URL is specified as a string' do
+      @list.document_for_url('file://'+__FILE__).should == @docs[1]
     end
     
-    describe 'when called with no arguments' do
-      it 'returns an array containing the documents associated with any file' do
-        @keeper.documents_with_file.should == [@local_docs[0], @remote_docs[0], @remote_docs[1], @local_docs[1]]
-      end
+    it 'returns the first document associated with the given URL, if more than one document is associated with it' do
+      @list = create_list @docs + [Ruber::Document.new(__FILE__)]
+      @list.document_for_url(KDE::Url.new(__FILE__)).should == @docs[1]
     end
-
+    
   end
-
-  describe 'Ruber::DocumentList#close_all' do
+  
+  describe '#document_for_url?' do
     
     before do
-      flexmock(@mw).should_receive(:save_documents).by_default.and_return(true)
-      pdf = Ruber::PluginSpecification.full({:name => :documents, :class => Ruber::DocumentList})
-      @docs = Array.new(5){|i| flexmock("doc #{i}"){|m| m.should_receive(:close).and_return(true).by_default}}
-      5.times {|i| flexmock(Ruber::Document).should_receive(:new).and_return(@docs[i])}
-      @keeper.instance_variable_set :@docs, @docs.dup
+      @docs = [Ruber::Document.new, Ruber::Document.new(__FILE__), Ruber::Document.new]
+      @list = create_list @docs
     end
-
-    it 'should call Ruber[:main_window].save_documents passing it all the documents, if the argument is true' do
-      @mw.should_receive(:save_documents).once.with(@docs).and_return true
-      @keeper.close_all
+    
+    it 'returns true if there\'s a document associated with the given URL' do
+      @list.document_for_url?(KDE::Url.new(__FILE__)).should == true
     end
-
-    it 'should return immediately if the call Ruber[:main_window].save_documents returns false' do
-      @mw.should_receive(:save_documents).once.with(@docs).and_return false
-      @docs.each{|d| d.should_receive(:close).never}
-      @keeper.close_all
+    
+    it 'returns false if there\'s no document associated with the given URL' do
+      @list.document_for_url?(KDE::Url.new('/xyz')).should == false
+    end
+    
+    it 'also works if the URL is specified as a string' do
+      @list.document_for_url?('file://'+__FILE__).should == true
+    end
+    
+  end
+  
+  describe '#document_with_name' do
+    
+    before do
+      @docs = 3.times.map{Ruber::Document.new}
+      flexmock(@docs[0]).should_receive(:document_name).and_return 'doc0'
+      flexmock(@docs[2]).should_receive(:document_name).and_return 'doc2'
+      @list = create_list @docs
     end
     
-    it 'shouldn\'t call Ruber[:main_window].save_documents if the argument is false' do
-      @mw.should_receive(:save_documents).never
-      @keeper.close_all false
+    it 'returns the document with the given document_name' do
+      @list.document_with_name('doc0').should == @docs[0]
     end
     
-    it 'should close each document, passing false argument as argument' do
-      @mw.should_receive(:save_documents).and_return true
-      @docs.each{|d| d.should_receive(:close).once.and_return true}
-      @keeper.close_all false
+    it 'returns nil if there\'s no document with the given document name' do
+      @list.document_with_name('doc3').should be_nil
     end
     
-    it 'should return true if the documents where closed and false otherwise' do
-      @mw.should_receive(:save_documents).once.with(@docs).and_return true
-      @keeper.close_all.should be_true
-      @mw.should_receive(:save_documents).once.with(@docs).and_return false
-      @keeper.close_all.should_not be
+    it 'returns the first document with the given document name, if there is more  than one document with that name' do
+      doc = Ruber::Document.new
+      flexmock(doc).should_receive(:document_name).and_return 'doc0'
+      @list = create_list @docs + [doc]
+      @list.document_with_name('doc0').should == @docs[0]
     end
     
   end
-
-  describe 'Ruber::DocumentList, when a document is closed' do
-
+  
+  describe '#document_with_name?' do
     
-    it 'should emit the "document_closing(QObject*)" signal, passing the document as argument' do
-      doc = @keeper.new_document
-      exp = doc.object_id
-      m = flexmock{|mk| mk.should_receive(:closing_document).once.with(exp)}
-      @keeper.connect(SIGNAL('closing_document(QObject*)')){|d| m.closing_document d.object_id}
-      doc.close
+    before do
+      @docs = 3.times.map{Ruber::Document.new}
+      flexmock(@docs[0]).should_receive(:document_name).and_return 'doc0'
+      flexmock(@docs[2]).should_receive(:document_name).and_return 'doc2'
+      @list = create_list @docs
     end
     
-    it 'should remove the closed file from the list, without leaving a hole' do
-      docs = 3.times.map{ @keeper.new_document}
-      docs[1].close false
-      @keeper.size.should == docs.size - 1
-      @keeper[0].should == docs[0]
-      @keeper[1].should == docs[2]
-      @keeper.to_a.should == @keeper.to_a.compact
+    it 'returns true if there\'s a document with the given name' do
+      @list.document_with_name?('doc0').should == true
     end
-
+    
+    it 'returns false if there\'s no document associated with the given URL' do
+      @list.document_with_name?('doc3').should == false
+    end
+    
   end
-
-  describe 'Ruber::DocumentList#new_document' do
+  
+  describe 'Ruber::Document#documents_with_file' do
     
-    it 'should create and return a new empty document' do
-      doc = @keeper.new_document
-      doc.should be_kind_of(Ruber::Document)
-      doc.should be_pristine
+    before do
+      @all_docs = []
+      @empty_docs = []
+      @local_docs = []
+      @remote_docs = []
+      @empty_docs << Ruber::Document.new << Ruber::Document.new
+      @local_docs << Ruber::Document.new(__FILE__) << Ruber::Document.new( File.join(File.dirname(__FILE__), 'common.rb'))
+      @remote_docs << Ruber::Document.new( KDE::Url.new('http://github.com/stcrocco/ruber/raw/master/ruber.gemspec')) << Ruber::Document.new(
+        KDE::Url.new('http://github.com/stcrocco/ruber/raw/master/bin/ruber'))
+      @all_docs << @empty_docs[0] << @local_docs[0] << @remote_docs[0] << @remote_docs[1] << @local_docs[1] << @empty_docs[1]
+      @list = create_list @all_docs
     end
     
-    it 'should add the new document to the list' do
-      doc = @keeper.new_document
-      @keeper.documents.should == [doc]
+    it 'returns an array containing only the documents associated with local files if called with the :local argument' do
+      @list.documents_with_file(:local).should == @local_docs
     end
     
-    it 'should connect the "closing(QObject*)" signal of the document to the "close_document(QObject*) slot' do
-      doc = Ruber::Document.new
-      flexmock(Ruber::Document).should_receive(:new).with(@mw).once.and_return(doc)
-      flexmock(@keeper).should_receive(:close_document).once
-      @keeper.new_document
-      doc.close
+    it 'returns an array containing only the documents associated with remote files if called with the :remote argument' do
+      @list.documents_with_file(:remote).should == @remote_docs
     end
     
-    it 'should emit the "document_created(QObject*)" signal passing the document as argument' do
-      doc = Ruber::Document.new
-      exp = doc.object_id
-      flexmock(Ruber::Document).should_receive(:new).with(@mw).once.and_return(doc)
-      m = flexmock{|mk| mk.should_receive(:document_created).with(exp).once}
-      @keeper.connect(SIGNAL('document_created(QObject*)')){|d| m.document_created d.object_id}
-      @keeper.new_document
+    it 'returns an array containing the documents associated with any file when called with the :any argument' do
+      @list.documents_with_file(:any).should == [@local_docs[0], @remote_docs[0], @remote_docs[1], @local_docs[1]]
+    end
+    
+    it 'returns an array containing the documents associated with any file when called with no arguments' do
+      @list.documents_with_file.should == [@local_docs[0], @remote_docs[0], @remote_docs[1], @local_docs[1]]
     end
     
   end
+  
+end
 
-  describe '#document' do
-    
-    context 'when a document for the given file or url already exists' do
+describe Ruber::World::MutableDocumentList do
+  
+  before do
+    @list = Ruber::World::MutableDocumentList.new
+  end
+  
+  it 'inherits from Ruber::World::DocumentList' do
+    Ruber::World::DocumentList.ancestors.should include(Ruber::World::DocumentList)
+  end
 
-      it 'doesn\'t create a new document but return the existing one if a document for the given file or url already exists in the list' do
-        url = KDE::Url.new 'http://github.com/stcrocco/ruber/raw/ruber.gemspec'
-        doc1 = Ruber::Document.new nil, __FILE__
-        doc2 = Ruber::Document.new nil, url
-        @keeper.add_document doc1
-        @keeper.add_document doc2
-        flexmock(Ruber::Document).should_receive(:new).never
-        @keeper.document(__FILE__).should equal(doc1)
-        #Since the tests are run from the top directory, we need to prepend the spec directory
-        @keeper.document(File.expand_path(File.join('spec', File.basename(__FILE__)))).should equal(doc1)
-        @keeper.document(url).should equal(doc2)
+  describe '#initialize' do
+    
+    context 'when called with no arguments' do
+    
+      it 'creates an empty list' do
+        @list.should be_empty
       end
       
     end
     
-    context 'when a document for the given file or url doesn\'t exist' do
+    context 'when called with an array as argument' do
       
-      context 'and the second argument is false' do
-        
-        it 'returns nil' do
-          @keeper.document( File.expand_path(__FILE__), false).should be_nil
-          @keeper.document(KDE::Url.new('http://github.com/stcrocco/ruber/raw/ruber.gemspec'), false).should be_nil
-          @keeper.documents.should == []
-        end
-        
+      it 'creates a list containing the same documents as the argument' do
+        docs = 3.times.map{Ruber::Document.new}
+        @list = Ruber::World::MutableDocumentList.new docs
+        @list.to_a.should == docs
       end
       
-      context 'and the second argument is true' do
-        
-        it 'creates a new document for the given file or url' do
-          url = KDE::Url.new 'http://github.com/stcrocco/ruber/raw/ruber.gemspec'
-          doc = @keeper.document __FILE__
-          doc.should be_kind_of( Ruber::Document)
-          doc.path.should ==  __FILE__
-          doc.text.should == File.read( __FILE__)
-          doc = @keeper.document url
-          doc.url.should == url
-        end
-        
-        it 'raises ArgumentError if the argument is a string or local url and the corresponding file doesn\'t exist' do
-          lambda{@keeper.document 'test'}.should raise_error(ArgumentError, "File #{File.expand_path 'test'} doesn't exist")
-          lambda{@keeper.document File.expand_path('test')}.should raise_error(ArgumentError, "File #{File.expand_path 'test'} doesn't exist")
-          lambda{@keeper.document KDE::Url.new('file:///test')}.should raise_error(ArgumentError, "File #{'/test'} doesn't exist")
-        end
-        
-        it 'doesn\'t raise ArgumentError if the argument is a remote url which doesn\'t exist' do
-          lambda{@keeper.document KDE::Url.new('http://xyz/abc.def')}.should_not raise_error
-        end
-        
-        it 'adds the new document to the list of documents' do
-          doc = @keeper.document __FILE__
-          @keeper.documents.size.should == 1
-          @keeper.documents.include?(doc).should be_true
-        end
-        
-        it 'connects the "closing(QObject*)" signal of the new document to the "close_document(QObject*) slot' do
-          file = File.expand_path(__FILE__)
-          doc = Ruber::Document.new @keeper, file
-          flexmock(Ruber::Document).should_receive(:new).with(@mw, file).once.and_return(doc)
-          flexmock(@keeper).should_receive(:close_document).once
-          @keeper.document __FILE__
-          doc.close
-        end
-        
-        it 'emits the "document_created(QObject*)" signal passing the new document as argument' do
-          file = File.expand_path(__FILE__)
-          doc = Ruber::Document.new nil, file
-          exp = doc.object_id
-          flexmock(Ruber::Document).should_receive(:new).with(@mw, file).once.and_return(doc)
-          m = flexmock{|mk| mk.should_receive(:document_created).with(exp).once}
-          @keeper.connect(SIGNAL('document_created(QObject*)')){|d| m.document_created d.object_id}
-          @keeper.document __FILE__
-        end
-        
+      it 'creates a duplicate of the argument' do
+        docs = 3.times.map{Ruber::Document.new}
+        @list = Ruber::World::MutableDocumentList.new docs
+        new_doc = Ruber::Document.new
+        @list.add new_doc
+        docs.size.should == 3
       end
       
     end
     
-    it 'expands the given file name relative to the current directory if the file name is relative' do
-      flexmock(Ruber::Document).should_receive(:new).with(@mw, File.expand_path(__FILE__))
-      doc = @keeper.document __FILE__
-      # this is necessary because otherwise the 'after' block fails (because the document list contains nil)
-      @keeper.instance_variable_get(:@docs).clear
+    context 'when called with a DocumentList as argument' do
+      
+      it 'creates a list containing the same documents as the argument' do
+        docs = 3.times.map{Ruber::Document.new}
+        orig = Ruber::World::MutableDocumentList.new docs
+        @list = Ruber::World::MutableDocumentList.new orig
+        @list.to_a.should == docs
+      end
+      
+      it 'creates a duplicate of the argument' do
+        docs = 3.times.map{Ruber::Document.new}
+        orig = Ruber::World::MutableDocumentList.new docs
+        @list = Ruber::World::MutableDocumentList.new orig
+        new_doc = Ruber::Document.new
+        @list.add new_doc
+        orig.size.should == 3
+      end
+      
     end
     
-    it 'treats strings containing URLs as URLs rather than as relative files' do
-      url_str = 'http://xyz/abc.rb'
-      flexmock(Ruber::Document).should_receive(:new).with(@mw, KDE::Url.new(url_str))
-      doc = @keeper.document url_str
-      # this is necessary because otherwise the 'after' block fails (because the document list contains nil)
-      @keeper.instance_variable_get(:@docs).clear
+  end
+  
+  describe '#dup' do
+    
+    it 'duplicates the document list' do
+      docs = 3.times.map{Ruber::Document.new}
+      @list.add docs
+      new_list = @list.dup
+      new_list.remove docs[1]
+      @list.should == docs
     end
-
+    
   end
-
-  describe '#add_document' do
+  
+  describe '#clone' do
     
-    it 'adds the given document to the list of documents' do
-      doc = Ruber::Document.new
-      @keeper.add_document doc
-      @keeper.documents.size.should == 1
-      @keeper.documents.include?(doc).should be_true
+    it 'duplicates the document list' do
+      docs = 3.times.map{Ruber::Document.new}
+      @list.add docs
+      new_list = @list.clone
+      new_list.remove docs[1]
+      @list.should == docs
     end
     
-    it 'connects the "closing(QObject*)" signal of the given document to the "close_document(QObject*) slot' do
-      file = File.expand_path(__FILE__)
-      doc = Ruber::Document.new @keeper, file
-      flexmock(@keeper).should_receive(:close_document).once
-      @keeper.add_document doc
-      doc.close
+    it 'copies the frozen status of the document list' do
+      docs = 3.times.map{Ruber::Document.new}
+      @list.add docs
+      @list.freeze
+      new_list = @list.clone
+      new_list.should be_frozen
+      lambda{new_list.add Ruber::Document.new}.should raise_error(RuntimeError)
     end
     
   end
-
-  describe '#save_documents' do
+  
+  describe '#add' do
+    
+    before do
+      @docs = 3.times.map{Ruber::Document.new}
+    end
+    
+    it 'appends the given documents to the list' do
+      @list.add @docs[0]
+      @list.to_a.should == [@docs[0]]
+      @list.add *@docs[1..-1]
+      @list.to_a.should == @docs
+    end
+    
+    it 'treats arrays of documents as if each document was an argument by itself' do
+      @list.add @docs
+      @list.to_a.should == @docs
+    end
+    
+    it 'returns self' do
+      @list.add(@docs).should equal(@list)
+    end
+    
+  end
+  
+  describe '#uniq!' do
+    
+    it 'removes all duplicate elements from the list' do
+      docs = [Ruber::Document.new, Ruber::Document.new(__FILE__)]
+      @list.add docs
+      @list.add docs[0]
+      @list.uniq!
+      @list.should == docs
+    end
+    
+    it 'returns self' do
+      @list.uniq!.should == @list
+    end
+    
+  end
+  
+  describe '#merge!' do
     
     before do
-      @docs = [@keeper.document(__FILE__), @keeper.new_document, @keeper.new_document]
+      @docs = 5.times.map{Ruber::Document.new}
+      @list.add @docs[3..4]
     end
     
-    it 'saves all the documents passed as argument' do
-      @docs.each{|d| flexmock(d).should_receive(:save).once}
-      @keeper.save_documents @docs
+    it 'adds the contents of the argument to self' do
+      other = Ruber::World::MutableDocumentList.new @docs[0..2]
+      @list.merge!(other).should == @docs[3..4]+@docs[0..2]
     end
     
-    it 'returns an empty array if all the documents were saved successfully' do
-      @docs.each{|d| flexmock(d).should_receive(:save).once.and_return true}
-      @keeper.save_documents( @docs).should == []
+    it 'also works with an array argument' do
+      @list.merge!(@docs[0..2]).should == @docs[3..4]+@docs[0..2]
     end
     
-    it 'returns an array containing the documents for which save returned false, if the second argument is false' do
-      flexmock(@docs[0]).should_receive(:save).once.and_return true
-      flexmock(@docs[2]).should_receive(:save).once.and_return true
-      flexmock(@docs[1]).should_receive(:save).once.and_return false
-      @keeper.save_documents( @docs, false).should == [@docs[1]]
+    it 'returns self' do
+      @list.merge!(@docs[0..2]).should equal(@list)
     end
     
-    it 'doesn\'t call the save method on all remaining documents if one fails, if the second argument is true' do
-      flexmock(@docs[0]).should_receive(:save).once.and_return true
-      flexmock(@docs[1]).should_receive(:save).once.and_return false
-      flexmock(@docs[2]).should_receive(:save).never
-      @keeper.save_documents( @docs, true)
+    it 'removes duplicate elements from the list if the second parameter is true' do
+      @list.merge!(@docs[0..3], true).should == @docs[3..4]+@docs[0..2]
     end
     
-    it 'returns an array containing the first document for which save returned false and all the documents which weren\'t saved if the second argument is true' do
-      flexmock(@docs[0]).should_receive(:save).once.and_return true
-      flexmock(@docs[1]).should_receive(:save).once.and_return false
-      flexmock(@docs[2]).should_receive(:save).never
-      @keeper.save_documents( @docs, true).should == @docs[1..-1]
+    it 'doesn\'t remove duplicate elements from the list if the second parameter is false' do
+      @list.merge!(@docs[0..3], false).should == @docs[3..4]+@docs[0..3]
     end
     
   end
   
-  describe '#save_settings' do
+  describe '#remove' do
+    
+    before do
+      @docs = 3.times.map{Ruber::Document.new}
+      @list.add @docs
+    end
+      
+    it 'removes the document from the list' do
+      @list.remove @docs[1]
+      @list.to_a.should == [@docs[0], @docs[2]]
+    end
+    
+    it 'does nothing if the document is not in the list' do
+      @list.remove Ruber::Document.new
+      @list.to_a.should == @docs
+    end
+    
+    it 'returns the removed document, if any' do
+      @list.remove(@docs[1]).should == @docs[1]
+    end
+    
+    it 'returns nil if no document was removed' do
+      @list.remove(Ruber::Document.new).should be_nil
+    end
+    
+  end
   
-    it 'calls the save_settings method of each document\'s own project' do
-      docs = [@keeper.document(__FILE__), @keeper.new_document, @keeper.new_document]
-      docs.each{|d| flexmock(d).should_receive(:save_settings).once}
-      @keeper.save_settings
+  describe '#clear' do
+    
+    it 'removes all elements from the list' do
+      @list.add 3.times.map{Ruber::Document.new}
+      @list.clear
+      @list.should be_empty
+    end
+    
+    it 'returns self' do
+      @list.clear.should equal(@list)
     end
     
   end
   
-  describe '#query_close' do
+  describe '#delete_if' do
     
     before do
-      @docs = [@keeper.document(__FILE__), @keeper.new_document, @keeper.new_document]
+      @docs = [Ruber::Document.new, Ruber::Document.new(__FILE__), Ruber::Document.new]
+      @list.add @docs
     end
     
-    it 'calls the query_close method of each document\'s own project and returns false if one of them returns false' do
-      flexmock(@docs[0].own_project).should_receive(:query_close).once.and_return true
-      flexmock(@docs[1].own_project).should_receive(:query_close).once.and_return false
-      flexmock(@docs[2].own_project).should_receive(:query_close).never.and_return(true)
-      @keeper.query_close.should be_false
+    it 'removes all the elements for which the block returns true' do
+      @list.delete_if{|doc| !doc.has_file?}
+      @list.should == [@docs[1]]
     end
     
-    it 'calls the main window\'s close_documents method and return its value' do
-      @docs.each{|d| flexmock(d.own_project).should_receive(:query_close).twice.and_return true}
-      flexmock(@mw).should_receive(:save_documents).once.with_no_args.and_return true
-      flexmock(@mw).should_receive(:save_documents).once.with_no_args.and_return false
-      @keeper.query_close.should be_true
-      @keeper.query_close.should be_false
+    it 'returns self' do
+      @list.delete_if{|doc| !doc.has_file?}.should equal(@list)
     end
     
   end