ruber 0.0.1.1

data/spec/project_files_list_spec.rb

@@ -0,0 +1,401 @@
+require 'spec/common'
+
+require 'tempfile'
+require 'fileutils'
+require 'flexmock'
+require 'forwardable'
+
+require 'ruber/projects/project_files_list'
+require 'ruber/project'
+
+
+class SimpleProject < Qt::Object
+  signals 'option_changed(QString, QString)'
+end
+
+describe 'Ruber::ProjectFilesList' do
+  
+  before do
+    @app = Qt::Object.new
+    @comp = Qt::Object.new do
+      class << self
+        extend Forwardable
+        def_delegators :@data, :[], :<<
+        def_delegator :@data, :each, :each_component
+      end
+      @data = []
+    end
+    @projects = Qt::Object.new
+    flexmock(Ruber).should_receive(:[]).with(:app).and_return(@app).by_default
+    flexmock(Ruber).should_receive(:[]).with(:components).and_return(@comp).by_default
+    flexmock(Ruber).should_receive(:[]).with(:projects).and_return(@projects).by_default
+    dir = File.dirname __FILE__
+    @prj = Ruber::Project.new File.join(dir, 'test.ruprj'), 'Test'
+    @prj.add_option(OS.new({:group => :general, :name => :project_files, :default => {:include => [], :exclude => [], :extensions => []} }))
+    @l = Ruber::ProjectFilesList.new @prj
+    @prj.add_extension :file_lister, @l
+  end
+  
+  it 'should be an Enumerable' do
+    Ruber::ProjectFilesList.ancestors.should include(Enumerable)
+  end
+  
+  it 'should not be up to date when created' do
+    @l.should_not be_up_to_date
+  end
+  
+  it 'should not attempt to scan the project when created' do
+    flexmock(Find).should_receive(:find).never
+    l = Ruber::ProjectFilesList.new @prj
+  end
+  
+  it 'should mark the list as not up to date when the project_files option changes' do
+    @prj.add_option(OS.new({:group => :general, :name => :xyz, :default => 3}))
+    @prj[:general, :project_files][:extensions] = ['*.rb']
+    @l.instance_variable_set :@up_to_date, true
+    @prj.instance_eval{emit option_changed('general', 'xyz')}
+    @prj[:general, :project_files] = {:include => [], :exclude => [], :extensions => %w[*.rb *.ui]}
+    @l.should_not  be_up_to_date
+  end
+  
+  describe ', when a file or directory changes' do
+    
+    before do
+      @files = YAML.load('[f1.rb, f1.yaml, README, COPYING, [d2, f21.rb, f22.rb, f21.yaml, f22.yaml, CHANGELOG], [d3, f31.rb, f32.rb]]')
+      @dir = make_dir_tree @files
+      @prj = Ruber::Project.new File.join(@dir, 'test.ruprj'), 'Test'
+      @prj.add_option(OS.new({:group => :general, :name => :project_files, :default => {:include => [], :exclude => [], :extensions => []} }))
+      @list = Ruber::ProjectFilesList.new @prj
+      @prj.add_extension :file_lister, @list
+    end
+    
+    it 'should mark itself as not up to date' do
+      @list.instance_variable_set :@up_to_date, true
+      w = @list.instance_variable_get :@watcher
+      dir = @prj.project_directory
+      w.instance_eval{emit dirty(dir)}
+      @list.instance_variable_get(:@up_to_date).should be_false
+    end
+    
+    it 'should stop the watcher' do
+      w = @list.instance_variable_get :@watcher
+      flexmock(w).should_receive(:stop_scan).once
+      dir = @prj.project_directory
+      w.instance_eval{emit dirty(dir)}
+    end
+    
+  end
+  
+  describe Ruber::ProjectFilesList, '#refresh' do
+    
+    before do
+      dir = File.dirname __FILE__
+      @prj = Ruber::Project.new File.join(dir, 'test.ruprj'), 'Test'
+      @prj.add_option(OS.new({:group => :general, :name => :project_files, :default => {:include => [], :exclude => [], :extensions => []} }))
+      @list = Ruber::ProjectFilesList.new @prj
+      @prj.add_extension :file_lister, @list
+    end
+    
+    it 'should call the scan_project method' do
+      flexmock(@list).should_receive(:scan_project).once
+      @list.refresh
+    end
+    
+    it 'should set the file list as up to date' do
+      flexmock(@list).should_receive(:scan_project)
+      @list.refresh
+      @list.should be_up_to_date
+    end
+    
+    it 'should restart the watcher' do
+      flexmock(@list).should_receive(:scan_project)
+      w = @list.instance_variable_get(:@watcher)
+      flexmock(w).should_receive(:start_scan).once
+      @list.refresh
+    end
+    
+  end
+  
+  describe 'Ruber::ProjectFilesList#project_files' do
+    
+    before do
+      @files = YAML.load('[f1.rb, f1.yaml, README, COPYING, [d2, f21.rb, f22.rb, f21.yaml, f22.yaml, CHANGELOG], [d3, f31.rb, f32.rb]]')
+      @dir = make_dir_tree @files
+      @prj = Ruber::Project.new File.join(@dir, 'test.ruprj'), 'Test'
+      @prj.add_option(OS.new({:group => :general, :name => :project_files, :default => {:include => [], :exclude => [], :extensions => []} }))
+      @list = Ruber::ProjectFilesList.new @prj
+      @prj.add_extension :file_lister, @list
+    end
+    
+    after do
+      FileUtils.rm_f @dir
+    end
+    
+    it 'should update the cache if it\'s not up to date' do
+      @list.instance_variable_set :@up_to_date, false
+      flexmock(@list).should_receive(:refresh).once
+      @list.project_files
+    end
+    
+    it 'should not update the cache if it\'s already up to date' do
+      @list.instance_variable_set :@up_to_date, true
+      flexmock(@list).should_receive(:refresh).never
+      @list.project_files
+    end
+    
+    it 'should return an array containing all the files corresponding to include rules of type path unless they also correspond to an exclude rule of type path' do
+      @prj[:general, :project_files] = {:include => ['README', 'COPYING', 'f1.rb', 'd2/CHANGELOG', 'd2/f21.rb'], :exclude => ['COPYING', 'd2/f21.rb'], :extensions => []}
+      @list.project_files(false).should =~ %w[README f1.rb d2/CHANGELOG]
+    end
+    
+    it 'should not include in the returned array files which don\'t exist' do
+      @prj[:general, :project_files] = {:include => ['README1', 'COPYING', 'f1.rb', 'd2/CHANGELOG', 'd2/f211.rb'], :exclude => ['COPYING'], :extensions => []}
+      @list.project_files(false).should =~ %w[f1.rb d2/CHANGELOG]
+    end
+    
+    it 'should skip include rules of type path corresponding to directories' do
+      @prj[:general, :project_files] = {:include => ['README', 'COPYING', 'f1.rb', 'd2/CHANGELOG', 'd2/f21.rb', 'd3'], :exclude => ['COPYING', 'd2/f21.rb'], :extensions => []}
+      @list.project_files(false).should =~ %w[README f1.rb d2/CHANGELOG]
+    end
+    
+    it 'should include all the files in the project directory which correspond to one of the extensions in the returned array, unless they match one of the exclude rule' do
+      @prj[:general, :project_files] = {:include => [], :exclude => ['COPYING', 'd2/f21.rb'], :extensions => %w[*.rb]}
+      @list.project_files(false).should =~ %w[f1.rb d2/f22.rb d3/f31.rb d3/f32.rb]
+    end
+    
+    it 'should include all the files in the project directory which match one of the include rules of type regexp and don\'t match any exclude rule' do
+      @prj[:general, :project_files] = {:include => [%r{d3/.*}, %r{.*\.yaml}], :exclude => [%r{d3/.*2.*}, %r{.*1.*\.rb}], :extensions => []}
+      @list.project_files(false).should =~ %w[d2/f22.yaml f1.yaml d2/f21.yaml]
+    end
+    
+    it 'should not include duplicate elements' do
+      @prj[:general, :project_files] = {:include => [%r{d2/.*}, 'f1.rb'], :exclude => [], :extensions => ['*.rb']}
+      @list.project_files(false).should =~ %w[f1.rb d2/f21.rb d2/f22.rb d2/f21.yaml d2/f22.yaml d2/CHANGELOG d3/f31.rb d3/f32.rb]
+    end
+    
+    it 'should return a deep copy of the cache object' do
+      @prj[:general, :project_files] = {:include => [%r{d2/.*}, 'f1.rb'], :exclude => [], :extensions => ['*.rb']}
+      old_cache = @list.instance_variable_get(:@project_files).deep_copy
+      res = @list.project_files(false)
+      res.should == old_cache
+      res << 'x'
+      @list.instance_variable_get(:@project_files).should == old_cache
+    end
+    
+    it 'should return full paths if the argument is true' do
+      @prj[:general, :project_files] = {:include => [%r{d2/.*}, 'f1.rb'], :exclude => [], :extensions => ['*.rb']}
+      @list.project_files(true).should =~ %w[f1.rb d2/f21.rb d2/f22.rb d2/f21.yaml d2/f22.yaml d2/CHANGELOG d3/f31.rb d3/f32.rb].map{|i| File.join @dir, i}
+    end
+    
+    it 'should return the correct list if a file or directory is added or deleted after the file watcher has been created' do
+      @prj[:general, :project_files] = {:include => [], :exclude => [], :extensions => ['*.rb']}
+      # Experiments show that KDE::DirWatch needs an event loop to work. Since we don't have one running, we'll have to make it emit the 'dirty' signal manually
+      watcher = @list.instance_variable_get(:@watcher)
+      `touch #@dir/f2.rb`
+      watcher.instance_eval{emit dirty( @dir)}
+      `touch #@dir/d2/f23.rb`
+      watcher.instance_eval{emit dirty( @dir)}
+      @list.project_files(false).should include('f2.rb')
+      @list.project_files(false).should include('d2/f23.rb')
+      FileUtils.mkdir("#@dir/d4")
+      watcher.instance_eval{emit dirty( @dir)}
+      `touch #@dir/d4/f41.rb`
+      watcher.instance_eval{emit dirty( @dir)}
+      `touch #@dir/d4/f42.rb`
+      watcher.instance_eval{emit dirty( @dir)}
+      @list.project_files(false).should include('d4/f41.rb')
+      @list.project_files(false).should include('d4/f42.rb')
+      FileUtils.rm_rf "#@dir/d2"
+      watcher.instance_eval{emit dirty( @dir)}
+      @list.project_files(false).should_not include("#@dir/d2/f21.rb")
+      @list.project_files(false).should_not include("#@dir/d2/f22.rb")
+      FileUtils.rm "#@dir/f1.rb"
+      watcher.instance_eval{emit dirty( @dir)}
+      @list.project_files(false).should_not include("f1.rb")
+    end
+    
+  end
+  
+  describe 'Ruber::ProjectFilesList#each' do
+    
+    before do
+      @files = YAML.load('[f1.rb, f1.yaml, README, COPYING, [d2, f21.rb, f22.rb, f21.yaml, f22.yaml, CHANGELOG], [d3, f31.rb, f32.rb]]')
+      @dir = make_dir_tree @files
+      @prj = Ruber::Project.new File.join(@dir, 'test.ruprj'), 'Test'
+      @prj.add_option(OS.new({:group => :general, :name => :project_files, :default => {:include => %w[README f1.yaml], :exclude => %w[d2/f22.rb], :extensions => %w[*.rb]} }))
+      @list = Ruber::ProjectFilesList.new @prj
+      @prj.add_extension :file_lister, @list
+    end
+    
+    it 'should update the cache if it\'s not up to date and a block is given' do
+      @list.instance_variable_set :@up_to_date, false
+      flexmock(@list).should_receive(:refresh).once
+      @list.each{}
+    end
+    
+    it 'should not update the cache if it\'s already up to date and a block is given' do
+      @list.instance_variable_set :@up_to_date, true
+      flexmock(@list).should_receive(:refresh).never
+      @list.each{}
+    end
+    
+    it 'should call the associated block passing the full file name of each project file if called with a block and the argument is true' do
+      exp = %w[f1.rb f1.yaml README d2/f21.rb d3/f31.rb d3/f32.rb].map{|f| File.join @dir, f}
+      m = flexmock do |mk| 
+        exp.each{|f| mk.should_receive(:test).once.with(f)}
+      end
+      @list.each(true){|f| m.test f}
+    end
+    
+    it 'should call the associated block passing the file name of each project file relative to the project directory if called with a block and the argument is false' do
+      exp = %w[f1.rb f1.yaml README d2/f21.rb d3/f31.rb d3/f32.rb]
+      m = flexmock do |mk| 
+        exp.each{|f| mk.should_receive(:test).once.with(f)}
+      end
+      @list.each(false){|f| m.test f}
+    end
+    
+    it 'should return an enumerator which yields the full file name of each project file if called without a block and the argument is true' do
+      enum = @list.each(true)
+      enum.should be_a(Enumerable)
+      exp = %w[f1.rb f1.yaml README d2/f21.rb d3/f31.rb d3/f32.rb].map{|f| File.join @dir, f}
+      m = flexmock do |mk| 
+        exp.each{|f| mk.should_receive(:test).once.with(f)}
+      end
+      enum.each{|f| m.test f}
+    end
+    
+    it 'should return an enumerator which yields the file name of each project file relative to the project directory if called without a block and the argument is false' do
+      enum = @list.each(false)
+      enum.should be_a(Enumerable)
+      exp = %w[f1.rb f1.yaml README d2/f21.rb d3/f31.rb d3/f32.rb]
+      m = flexmock do |mk| 
+        exp.each{|f| mk.should_receive(:test).once.with(f)}
+      end
+      enum.each{|f| m.test f}
+    end
+    
+    it 'should never update the cache if no block is given' do
+      @list.instance_variable_set :@up_to_date, false
+      flexmock(@list).should_receive(:refresh).never
+      @list.each
+      @list.instance_variable_set :@up_to_date, true
+      @list.each
+    end
+    
+  end
+  
+  describe 'Ruber::ProjectFilesList#rel' do
+    
+    before do
+      @files = YAML.load('[f1.rb, f1.yaml, README, COPYING, [d2, f21.rb, f22.rb, f21.yaml, f22.yaml, CHANGELOG], [d3, f31.rb, f32.rb]]')
+      @dir = make_dir_tree @files
+      @prj = Ruber::Project.new File.join(@dir, 'test.ruprj'), 'Test'
+      @prj.add_option(OS.new({:group => :general, :name => :project_files, :default => {:include => %w[README f1.yaml], :exclude => %w[d2/f22.rb], :extensions => %w[*.rb]} }))
+      @list = Ruber::ProjectFilesList.new @prj
+      @prj.add_extension :file_lister, @list
+    end
+    
+    it 'should work as the each method with no block and a false argument' do
+      enum = @list.rel
+      enum.should be_a(Enumerable)
+      exp = %w[f1.rb f1.yaml README d2/f21.rb d3/f31.rb d3/f32.rb]
+      m = flexmock do |mk| 
+        exp.each{|f| mk.should_receive(:test).once.with(f)}
+      end
+      enum.each{|f| m.test f}
+    end
+    
+  end
+  
+  describe 'Ruber::ProjectFilesList#abs' do
+    
+    before do
+      @files = YAML.load('[f1.rb, f1.yaml, README, COPYING, [d2, f21.rb, f22.rb, f21.yaml, f22.yaml, CHANGELOG], [d3, f31.rb, f32.rb]]')
+      @dir = make_dir_tree @files
+      @prj = Ruber::Project.new File.join(@dir, 'test.ruprj'), 'Test'
+      @prj.add_option(OS.new({:group => :general, :name => :project_files, :default => {:include => %w[README f1.yaml], :exclude => %w[d2/f22.rb], :extensions => %w[*.rb]} }))
+      @list = Ruber::ProjectFilesList.new @prj
+      @prj.add_extension :file_lister, @list
+    end
+    
+    it 'should work as the each method with no block and a true argument' do
+      enum = @list.abs
+      enum.should be_a(Enumerable)
+      exp = %w[f1.rb f1.yaml README d2/f21.rb d3/f31.rb d3/f32.rb].map{|f| File.join @dir, f}
+      m = flexmock do |mk| 
+        exp.each{|f| mk.should_receive(:test).once.with(f)}
+      end
+      enum.each{|f| m.test f}
+    end
+    
+    
+  end
+  
+  describe Ruber::ProjectFilesList do
+    
+    describe '#file_in_project?' do
+      
+      before do
+        @dir = File.dirname __FILE__
+        @prj = Ruber::Project.new File.join(@dir, 'test.ruprj'), 'Test'
+        @prj.add_option(OS.new({:group => :general, :name => :project_files, :default => {:include => %w[], :exclude => %w[], :extensions => []} }))
+        @list = Ruber::ProjectFilesList.new @prj
+        @prj.add_extension :file_lister, @list
+      end
+      
+      it 'should return true if the argument matches one of the exact include rules' do
+        @prj[:general, :project_files] = {:include => %w[./xyz ./abc ./123], :exclude => [], :extensions => ['*.rb']}
+        @list.file_in_project?(File.join(@prj.project_dir, 'abc')).should be_true
+      end
+      
+      it 'should return true if the argument matches one of the regexp include rules' do
+        @prj[:general, :project_files] = {:include => [/a/, /x/], :exclude => [], :extensions => ['*.rb']}
+        @list.file_in_project?(File.join(@prj.project_dir, 'xyz')).should be_true
+      end
+      
+      it 'should return true if the argument matches one of the include extensions' do
+        @prj[:general, :project_files] = {:include => [], :exclude => [], :extensions => ['*.rb', '*.yaml']}
+        @list.file_in_project?(File.join(@prj.project_dir, 'abc.rb')).should be_true
+      end
+      
+      it 'should return false if the file isn\'t in the project directory' do
+        @prj[:general, :project_files] = {:include => %w[xyz abc 123], :exclude => [], :extensions => ['*.rb']}
+        @list.file_in_project?('/usr/abc').should be_false
+      end
+      
+      it 'should treat the argument as a path relative to the project directory if it isn\'t an absolute path' do
+        @prj[:general, :project_files] = {:include => %w[xyz abc 123], :exclude => [], :extensions => ['*.rb']}
+        @list.file_in_project?('abc').should be_true
+      end
+      
+      it 'should return false if the file doesn\'t match any include rule' do
+        @list.file_in_project?(File.join(@prj.project_dir, 'abc.rb')).should be_false
+      end
+      
+      it 'should return false if the file matches one of the file exclude rules' do
+        @prj[:general, :project_files] = {:include => %w[xyz abc 123], :exclude => ['abc'], :extensions => ['*.rb']}
+        @list.file_in_project?(File.join(@prj.project_dir, 'abc')).should be_false
+      end
+      
+      it 'should return false if the file matches one of the exclude regexps' do
+        @prj[:general, :project_files] = {:include => [/a/], :exclude => [/a/], :extensions => []}
+        @list.file_in_project?(File.join(@prj.project_dir, 'abc')).should be_false
+      end
+      
+      it 'it considers the whole path of the file, not just the filename' do
+        @prj[:general, :project_files] = {:include => [%r{a/.*}], :exclude => [%r{b/.*}], :extensions => ['*.rb']}
+        @list.file_in_project?(File.join(@prj.project_dir, 'a', 'xyz')).should be_true
+        @list.file_in_project?(File.join(@prj.project_dir, 'b', 'xyz.rb')).should be_false
+      end
+      
+      it 'returns nil if the file name ends with a slash' do
+        @prj[:general, :project_files] = {:include => [%r{a/.*}], :exclude => [%r{b/.*}], :extensions => ['*.rb']}
+        @list.file_in_project?('xyz/').should be_nil
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/project_list_spec.rb

@@ -0,0 +1,511 @@
+require 'spec/common'
+
+require 'flexmock'
+
+require 'ruber/projects/project_list'
+require 'ruber/plugin_specification'
+
+class Ruber::ProjectList::FakeProject < Qt::Object
+  
+  signals 'closing(QObject*)'
+  attr_reader :project_name, :project_file
+  def initialize name = 'test', file = nil
+    super()
+    @project_file = file || Array.new(6){97 + rand(26)}.join
+    @project_name = name
+  end
+  
+  def deactivate;end
+  
+  def activate;end
+    
+    def close
+      emit closing(self)
+    end
+end
+
+describe Ruber::ProjectList do
+  
+  it 'should mix-in Enumerable' do
+    Ruber::ProjectList.ancestors.include?(Enumerable).should be_true
+  end
+    
+end
+
+describe 'Ruber::ProjectList#project_for_file' do
+  
+  before do
+    manager = flexmock('components'){|m| m.should_ignore_missing}
+    flexmock(Ruber).should_receive(:[]).with(:app).and_return(KDE::Application.instance).by_default
+    flexmock(Ruber).should_receive(:[]).with(:config).and_return(nil).by_default
+    flexmock(Ruber).should_receive(:[]).with(:components).and_return(manager).by_default
+    pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @projects = Ruber::ProjectList.new manager, pdf
+  end
+  
+  it 'returns nil if there\'s no current project' do
+    flexmock(@projects).should_receive(:current).twice.and_return nil
+    @projects.project_for_file(__FILE__, :active).should be_nil
+    @projects.project_for_file(__FILE__, :all).should be_nil
+  end
+  
+  it 'returns the current project if there\'s one and the file belongs to it' do
+    prj = flexmock{|m| m.should_receive('project_files.file_in_project?').twice.with(__FILE__).and_return true}
+    flexmock(@projects).should_receive(:current).twice.and_return prj
+    @projects.project_for_file(__FILE__, :active).should == prj
+    @projects.project_for_file(__FILE__, :all).should == prj
+  end
+  
+  it 'returns nil if the file doesn\'t belong to the current project and the second argument is :active, even if the file belongs to another project' do
+    active_prj = flexmock{|m| m.should_receive('project_files.file_in_project?').once.with(__FILE__).and_return false}
+    prj = flexmock{|m| m.should_receive('project_files.file_in_project?').with(__FILE__).and_return true}
+    flexmock(@projects).should_receive(:current).once.and_return(active_prj)
+    flexmock(@projects).should_receive(:each).and_yield(active_prj, prj)
+    @projects.project_for_file(__FILE__, :active).should be_nil
+  end
+  
+  it 'returns the first project to which the file belongs, if it doesn\'t belong to the current one and the second argument is :all' do
+    active_prj = flexmock{|m| m.should_receive('project_files.file_in_project?').twice.with(__FILE__).and_return false}
+    prjs = [
+      flexmock{|m| m.should_receive('project_files.file_in_project?').with(__FILE__).once.and_return false},
+      active_prj,
+      flexmock{|m| m.should_receive('project_files.file_in_project?').with(__FILE__).once.and_return true},
+      flexmock{|m| m.should_receive('project_files.file_in_project?').with(__FILE__).never}
+      ]
+    flexmock(@projects).should_receive(:current).once.and_return(active_prj)
+    projects = {
+      '0' => prjs[0],
+      '1' => prjs[1],
+      '2' => prjs[2],
+      '3' => prjs[3]
+      }
+    @projects.instance_variable_set(:@projects, projects)
+    @projects.project_for_file(__FILE__, :all).should equal(prjs[2])
+  end
+    
+  it 'returns nil if the second argument is :all and the file doesn\'t belong to any project' do
+    active_prj = flexmock{|m| m.should_receive('project_files.file_in_project?').twice.with(__FILE__).and_return false}
+    prjs = [
+      flexmock{|m| m.should_receive('project_files.file_in_project?').with(__FILE__).once.and_return false},
+      active_prj,
+      flexmock{|m| m.should_receive('project_files.file_in_project?').with(__FILE__).once.and_return false},
+      flexmock{|m| m.should_receive('project_files.file_in_project?').with(__FILE__).once.and_return false}
+      ]
+    flexmock(@projects).should_receive(:current).once.and_return(active_prj)
+    projects = {
+      '0' => prjs[0],
+      '1' => prjs[1],
+      '2' => prjs[2],
+      '3' => prjs[3]
+      }
+    @projects.instance_variable_set(:@projects, projects)
+    @projects.project_for_file(__FILE__, :all).should be_nil
+  end
+  
+end
+
+describe 'Ruber::ProjectList#each_project' do
+  
+  before do
+    app = Qt::Object.new
+    manager = flexmock('components'){|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)
+    pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @keeper = Ruber::ProjectList.new manager, pdf
+  end
+
+  
+  it 'should yield all the projects in the list if called with a block' do
+    prjs = Array.new(3){|i| Ruber::ProjectList::FakeProject.new("test#{i}")}
+    prjs.each{|pr| @keeper.add_project pr}
+    res = []
+    @keeper.each_project{|pr| res << pr}
+    res.sort_by{|pr| pr.project_file}.should == prjs.sort_by{|pr| pr.project_file}
+  end
+  
+  it 'should return an enumerable which yields all the projects in the list if called without a block' do
+    prjs = Array.new(3){|i| Ruber::ProjectList::FakeProject.new("test#{i}")}
+    prjs.each{|pr| @keeper.add_project pr}
+    m = flexmock do |mk|
+      prjs.each{|prj| mk.should_receive(:test).once.with prj}
+    end
+    en = @keeper.each_project
+    if RUBY_VERSION.match(/8/) then en.should be_an(Enumerable::Enumerator)
+    else en.should be_an(Enumerator)
+    end
+    en.each{|prj| m.test prj}
+  end
+  
+end
+
+describe 'Ruber::ProjectList, when created' do
+  
+  before do
+    app = Qt::Object.new
+    manager = flexmock('components'){|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)
+    @pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @keeper = Ruber::ProjectList.new manager, @pdf
+  end
+  
+  it 'should call its initialize_plugin method' do
+    @keeper.plugin_description.should == @pdf
+  end
+  
+  it 'should have no project' do
+    @keeper.projects.should be_empty
+  end
+
+  it 'should have no current project' do
+    @keeper.current_project.should be_nil
+  end
+
+end
+
+describe 'Ruber::Project#current_project=, when called with a non-nil argument' do
+
+  before do
+    app = Qt::Object.new
+    manager = flexmock('components'){|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)
+    pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @keeper = Ruber::ProjectList.new manager, pdf
+    @prj = Ruber::ProjectList::FakeProject.new
+    @keeper.instance_variable_get(:@projects)[@prj.project_file] = @prj
+    @keeper.instance_variable_get(:@projects)['test'] = @prj
+  end
+  
+  it 'should set the current project to its argument' do
+    @keeper.current_project = @prj
+    @keeper.current_project.should equal( @prj )
+  end
+  
+  it 'should call the "deactivate" method of the old current project, if it\'s not nil' do
+    @keeper.instance_variable_set(:@current_project, @prj)
+    new_prj = Ruber::ProjectList::FakeProject.new 'Test1'
+    @keeper.add_project new_prj
+    flexmock(@prj).should_receive( :deactivate).once
+    @keeper.current_project = new_prj
+    @keeper.instance_variable_set :@current_project, nil
+    lambda{@keeper.current_project = @prj}.should_not raise_error
+  end
+  
+  it 'should emit the "current_project_changed(QObject*)" signal with the project as argument' do
+    test = flexmock('test'){|m| m.should_receive(:current_project_changed).once.with(@prj)}
+    @keeper.connect(SIGNAL('current_project_changed(QObject*)')){|o| test.current_project_changed(o)}
+    @keeper.current_project = @prj
+  end
+  
+  it 'should call the "activate" method of the new current project' do
+    @keeper.instance_variable_set(:@current_project, @prj)
+    new_prj = Ruber::ProjectList::FakeProject.new 'Test1'
+    @keeper.add_project new_prj
+    flexmock(new_prj).should_receive( :activate).once
+    @keeper.current_project = new_prj
+  end
+  
+  it 'should raise ArgumentError if the project is not in the project list' do
+    @keeper.instance_variable_get(:@projects).clear
+    lambda{@keeper.current_project = @prj}.should raise_error(ArgumentError, "Tried to set an unknown as current project")
+  end
+  
+end
+
+describe 'Ruber::Project#current_project=, when called with nil' do
+  
+  before do
+    app = Qt::Object.new
+    manager = flexmock('components'){|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)
+    pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @keeper = Ruber::ProjectList.new manager, pdf
+  end
+  
+  it 'should set the current project to nil' do
+    @keeper.current_project = nil
+    @keeper.current_project.should be_nil
+  end
+  
+  it 'should emit the "current_project_changed(QObject*)" signal with Qt::NilObject as argument' do
+    test = flexmock('test'){|m| m.should_receive(:current_project_changed).once.with(nil)}
+    @keeper.connect(SIGNAL('current_project_changed(QObject*)')){|o| test.current_project_changed(o)}
+    @keeper.current_project = nil
+  end
+   
+end
+
+describe 'Ruber::ProjectList#add_project' do
+  
+  before do
+    app = Qt::Object.new
+    manager = flexmock('components'){|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)
+    pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @keeper = Ruber::ProjectList.new manager, pdf
+  end
+  
+  it 'should add the project passed as argument to the list of projects' do
+    prj = Ruber::ProjectList::FakeProject.new 'Test'
+    @keeper.add_project prj
+    @keeper.instance_variable_get(:@projects)[prj.project_file].should equal(prj)
+  end
+  
+  it 'should return the project' do 
+    prj = Ruber::ProjectList::FakeProject.new 'Test'
+    @keeper.add_project( prj).should equal(prj)
+  end
+  
+  it 'should emit the "project_added(QObject*)" signal passing the added project' do
+    prj = Ruber::ProjectList::FakeProject.new 'Test'
+    m = flexmock('test'){|mk| mk.should_receive(:project_added).once.with(prj)}
+    @keeper.connect(SIGNAL('project_added(QObject*)')){|o| m.project_added(o)}
+    @keeper.add_project prj
+  end
+  
+  it 'should raise RuntimeError if the project is already in the list' do
+    prj_file = File.expand_path('test.ruprj')
+    prj1 = Ruber::ProjectList::FakeProject.new 'test1', prj_file
+    prj2 = Ruber::ProjectList::FakeProject.new 'test2', prj_file
+    @keeper.add_project prj1
+    lambda{@keeper.add_project prj2}.should raise_error(RuntimeError, "A project with project file #{prj_file} is already open")
+  end
+  
+end
+
+describe 'Ruber::ProjectList, when a project in the list is closed' do
+  
+  before do
+    app = Qt::Object.new
+    manager = flexmock('components'){|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)
+    pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @keeper = Ruber::ProjectList.new manager, pdf
+  end
+  
+  it 'should emit the "project_closing" signal, passing the project as argument' do
+    prj = Ruber::ProjectList::FakeProject.new
+    @keeper.add_project prj
+    m = flexmock{|mk| mk.should_receive(:project_closing).once}
+    @keeper.connect(SIGNAL('closing_project(QObject*)')){|o| m.project_closing(o)}
+    prj.close
+  end
+  
+  it 'should set the current project to nil if the closed project was the current one' do
+    prj = Ruber::ProjectList::FakeProject.new
+    @keeper.add_project prj
+    @keeper.current_project = prj
+    prj.close
+    @keeper.current_project.should be_nil
+  end
+  
+end
+
+describe 'Ruber::ProjectList#close_current_project' do
+  
+  include FlexMock::ArgumentTypes
+  
+  before do
+    app = Qt::Object.new
+    manager = flexmock('components'){|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)
+    pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @keeper = Ruber::ProjectList.new manager, pdf
+    @prj = Ruber::ProjectList::FakeProject.new{self.object_name = 'project'}
+    @keeper.add_project = @prj
+    @keeper.current_project= @prj
+  end
+  
+  it 'should set the current project to nil' do
+    flexmock(@keeper).should_receive(:current_project=).with(nil).once
+    @keeper.close_current_project
+  end
+   
+  it 'should emit the "closing_project(QObject*)" signal after setting the current_project to nil, passing the project as argument' do
+    test = flexmock("test"){|m| m.should_receive(:project_closed).once.with(on{|a| a == @prj and !a.disposed?})}
+    flexmock(Ruber).should_receive(:[]).and_return(flexmock{|m| m.should_ignore_missing})
+    @keeper.connect(SIGNAL('closing_project(QObject*)')){|o| test.project_closed(o)}
+    @keeper.close_current_project
+  end
+  
+  it 'should do nothing if the current project is nil' do
+    @keeper.instance_variable_set(:@current_project, nil)
+    lambda{@keeper.close_current_project}.should_not raise_error
+  end
+  
+end
+
+describe 'Ruber::ProjectList#new_project' do
+  
+  before do
+    app = Qt::Object.new
+    manager = flexmock('components'){|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)
+    pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @keeper = Ruber::ProjectList.new manager, pdf
+  end
+  
+  it 'should create a new empty project and return it' do
+    prj = Ruber::ProjectList::FakeProject.new 'test.ruprj', 'Test'
+    flexmock(Ruber::Project).should_receive(:new).once.with('test.ruprj', 'Test').and_return prj
+    res = @keeper.new_project 'test.ruprj', 'Test'
+    res.should equal(prj)
+  end
+  
+  it 'should add the new project to the project list' do
+    prj = Ruber::ProjectList::FakeProject.new 'Test', 'test.ruprj'
+    flexmock(Ruber::Project).should_receive(:new).once.with('test.ruprj', 'Test').and_return prj
+    @keeper.new_project 'test.ruprj', 'Test'
+    @keeper.instance_variable_get(:@projects)['test.ruprj'].should equal(prj)
+  end
+  
+  it 'should emit the "project_added(QObject*)" signal with the new project as argument' do
+    prj = Ruber::ProjectList::FakeProject.new 'Test', 'test.ruprj'
+    flexmock(Ruber::Project).should_receive(:new).once.with('test.ruprj', 'Test').and_return prj
+    m = flexmock('test'){|mk| mk.should_receive(:project_added).once.with(prj)}
+    @keeper.connect(SIGNAL('project_added(QObject*)')){|o| m.project_added(o)}
+    @keeper.new_project 'test.ruprj', 'Test'
+  end
+  
+end
+
+describe 'Ruber::Project#project' do
+  
+  before do
+    app = Qt::Object.new
+    manager = flexmock('components'){|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)
+    pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @keeper = Ruber::ProjectList.new manager, pdf
+  end
+  
+  it 'should return the project corresponding to the file passed as argument, if it is in the list' do
+    prj = Ruber::ProjectList::FakeProject.new 'Test', 'test.ruprj'
+    @keeper.instance_variable_get(:@projects)[prj.project_file] = prj
+    @keeper.project('test.ruprj').should equal(prj)
+  end
+  
+  it 'should load the project from the file passed as argument if it isn\'t in the list' do
+    prj = Ruber::ProjectList::FakeProject.new 'Test', 'test.ruprj'
+    flexmock(Ruber::Project).should_receive(:new).once.with('test.ruprj').and_return prj
+    @keeper.project('test.ruprj').should equal(prj)
+  end
+  
+  it 'should emit the "project_added(QObject*)" signal, passing the project as argument, if the project isn\'t in the list' do
+    prj = Ruber::ProjectList::FakeProject.new 'Test', 'test.ruprj'
+    flexmock(Ruber::Project).should_receive(:new).once.with('test.ruprj').and_return prj
+    m = flexmock{|mk| mk.should_receive(:project_added).once.with(prj)}
+    @keeper.connect(SIGNAL('project_added(QObject*)')){|o| m.project_added(o)}
+    @keeper.project 'test.ruprj'
+  end
+  
+end
+
+describe 'Ruber::Project#[]' do
+  
+  before do
+    app = Qt::Object.new
+    manager = flexmock('components'){|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)
+    pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @keeper = Ruber::ProjectList.new manager, pdf
+  end
+  
+  it 'should return the project corresponding to the given file, if the argument is a string starting with /, if such a project exists' do
+    prj = Ruber::ProjectList::FakeProject.new 'Test', '/test.ruprj'
+    @keeper.add_project prj
+    @keeper['/test.ruprj'].should equal(prj)
+  end
+  
+  it 'should return the project with the given name if the argument is a string not starting with /, if such a project exists' do
+    prj = Ruber::ProjectList::FakeProject.new 'xyz', '/test.ruprj'
+    @keeper.add_project prj
+    @keeper['xyz'].should equal(prj)
+  end
+  
+  it 'should return nil if the requested project doesn\'t exist' do
+    prj = Ruber::ProjectList::FakeProject.new 'xyz', '/test.ruprj'
+    @keeper.add_project prj
+    @keeper['abc'].should be_nil
+    @keeper['/xyz.ruprj'].should be_nil
+  end
+  
+end
+
+describe 'Ruber::ProjectList#save_settings' do
+  
+  before do
+    app = Qt::Object.new
+    manager = flexmock('components'){|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)
+    pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+    @keeper = Ruber::ProjectList.new manager, pdf
+  end
+  
+  it 'should call the save method of each open project' do
+    projects = @keeper.instance_variable_get(:@projects)
+    5.times do |i|
+      projects[i] = flexmock(i.to_s){|m| m.should_receive(:save).once}
+    end
+    @keeper.save_settings
+  end
+  
+end
+
+describe Ruber::ProjectList do
+  
+  describe '#query_close' do
+    
+    before do
+      app = Qt::Object.new
+      manager = flexmock('components'){|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)
+      pdf = Ruber::PluginSpecification.full({:name => :projects, :class => Ruber::ProjectList})
+      @keeper = Ruber::ProjectList.new manager, pdf
+      @values = 5.times.map{|i| flexmock(:project_name => i.to_s)}
+      prjs = @keeper.instance_variable_get(:@projects)
+      @values.each{|v| prjs[v.project_name] = v}
+      def prjs.values
+        super.sort_by{|p| p.project_name}
+      end
+    end
+    
+    it 'calls the query_close method of all the projects and returns true if they all return true' do
+      @values.each{|pr| pr.should_receive(:query_close).once.and_return true}
+      @keeper.query_close.should be_true
+    end
+    
+    it 'stops iterating through the projects and returns false if one of the project\'s query_close method returns false' do
+      @values[0].should_receive(:query_close).once.and_return true
+      @values[1].should_receive(:query_close).once.and_return true
+      @values[2].should_receive(:query_close).once.and_return false
+      @values[3].should_receive(:query_close).never
+      @values[4].should_receive(:query_close).never
+      @keeper.query_close.should be_false
+    end
+    
+  end
+end