ruber 0.0.9 → 0.0.10

data/lib/ruber/application/project_files_list.rb

@@ -1,320 +0,0 @@
-=begin 
-    Copyright (C) 2010 by Stefano Crocco   
-    stefano.crocco@alice.it   
-  
-    This program is free software; you can redistribute it andor modify  
-    it under the terms of the GNU General Public License as published by  
-    the Free Software Foundation; either version 2 of the License, or     
-    (at your option) any later version.                                   
-  
-    This program is distributed in the hope that it will be useful,       
-    but WITHOUT ANY WARRANTY; without even the implied warranty of        
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         
-    GNU General Public License for more details.                          
-  
-    You should have received a copy of the GNU General Public License     
-    along with this program; if not, write to the                         
-    Free Software Foundation, Inc.,                                       
-    59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             
-=end
-
-require 'thread'
-require 'facets/kernel/deep_copy'
-require 'find'
-
-require 'ruber/project'
-
-module Ruber
-  
-=begin rdoc
-Project extension to access the name of the files belonging to the project.
-
-The file belonging to the projects are determined using the contents of the @general/project_files@
-project option. This option is a hash which contains rules (in the form of hashes)
-telling which files are part of the project and which aren't.
-
-Files are kept up to date, both regarding the contents of the filesystem (using a
-KDE::DirWatch) and the rules specified in the project.
-
-To avoid needlessly freezing the application in case projects with a large number of files,
-this class only scans the project directory when a list of project files is actually
-requested, that is when one of the methods {#each}, {#abs}, {#rel} and {#project_files}
-is called. Even in that case, the project directory is only scanned if a file has
-been added or removed since the last scan, or if the rules have changed since then.
-A scan can be forced by using the {#update} method, but you usually don't need this.
-
-h3. Rules
-
-The @general/project_files@ setting is a hash containing the rules to use to decide
-whether a given file belongs to the project or not. There are two groups of rules:
-inclusive rules and exclusive rules. Inclusive rules specify files which belong
-to the project, while exclusive rules specify files which do not belong to the 
-project. Exclusive rules have precedence on inclusive rules, meaning that if a
-file matches both an inclusive and an exclusive rule, it's excluded from the project.
-
-There are three kinds of rules:
-
-
-Project extension which scans the project directory and finds out which files belong
-to the project and which don't (according to rules specified by the user in the
-project options), returning an array of the former.
-
-It also watches the project directory to update the list of project files when a
-file in the project directory is added or removed.
-
-This class provides an {#each} method, which yields all the project files to the
-block or, if called without a block, returns an <tt>Enumerable::Enumerator</tt>
-which does the same.
-
-<b>Note:</b> the list of project files is created lazily, only when a method
-explicitly needs it and a file or directory (or the rules) have changed since
-the last time it was generated. A <tt>KDE::DirWatch</tt> object is used to find
-out when a file or directory changes. Also, after a file has changed, the watcher
-is stopped until the list is updated again (a single change is enough to rebuild
-the whole list, so there's no point in keeping watching).
-
-The methods which can cause the list to be rebuild are: +each+, +abs+, +rel+ and 
-<tt>project_files</tt>.
-
-===Rules
-To decide whether a file belongs to the project or not, ProjectFilesList uses
-the general/project_files project option. It is a hash made of three keys, each
-specifying a rule telling whether a file is part of the project or not. In application
-order, they are
-<tt>extensions</tt>::
-  an array of shell globs. Any file matching one of them (according to <tt>File.fnmatch</tt>)
-  will be considered a project file, unless another rule says otherwise
-<tt>include</tt>::
-  an array of strings and/or regexps corresponding to files which belong to the
-  project. Each string entry is the name (relative to the project directory) of
-  a file which belongs to the project. Each regexp is a pattern which should be
-  tested against all the names (still relative to the project directory) of the
-  files in the project directory (and its subdirectories). Each matching file will
-  be a project file (unless another rule says otherwise).
-<tt>exclude</tt>::
-  as the <tt>include</tt> entry, but the matching files will *not* be project
-  files. This entry has the precedence with respect to the other two. This means
-  that if a file is a project file according to one of them but also matches a
-  rule here, it <i>won't</i> be considered a project file.
-=end
-  class ProjectFilesList < Qt::Object
-    
-    include Enumerable
-    
-    include Extension
-    
-=begin rdoc
-Creates a new ProjectFilesList for the Project _prj_.
-
-The new object will read the <tt>general/project_files</tt> option from the project
-and immediately scan the project directory to find the all the project files.
-Besides, it will start monitoring the directory for changes, so as to be
-able to update the list of project files when a new file is created or a file
-is deleted.
-=end
-    def initialize prj
-      super
-      @lock = Mutex.new
-      @project = prj
-      @project_files = nil
-      @watcher = KDE::DirWatch.new self
-      @watcher.add_dir @project.project_dir, KDE::DirWatch::WatchSubDirs
-      @up_to_date = false
-      make_rules
-      @project_files = []
-      @watcher.connect(SIGNAL('dirty(QString)')) do
-        @up_to_date = false
-        @watcher.stop_scan
-      end
-      @project.connect(SIGNAL('option_changed(QString, QString)')) do |g, n|
-        if g == 'general' and n == 'project_files'
-          if @project[:general, :project_files] != @rules
-            @up_to_date = false
-            make_rules
-            scan_project
-          end
-        end
-      end
-      @watcher.start_scan false
-    end
-    
-=begin rdoc
-Returns an array with the name of the files in the project (in arbitrary order).
-If _abs_ is *false*, the file names will be relative to the project directory;
-if it is *true* they'll be absolute. It is the same as calling <tt>list.abs.to_a</tt>
-or <tt>list.rel.to_a</tt>
-
-<b>Note:</b> if the list isn't up to date, the project will be re-scanned
-=end
-    def project_files abs = true
-      refresh unless @up_to_date
-      if abs
-        dir = @project.project_dir
-        @project_files.map{|f| File.join dir, f}
-      else @project_files.deep_copy
-      end
-    end
-    
-=begin rdoc
-If called with a block, calls the block yielding the names of the files in the
-project. If _abs_ is true, absolute file names will be used, otherwise the file
-names will be relative to the project directory.
-
-If called without a block, returns an <tt>Enumerable::Enumerator</tt> which does
-the same as above.
-
-<b>Note:</b> when called with a block and the list isn't up to date, 
-the project will be re-scanned
-=end
-    def each abs = true
-      if block_given?
-        refresh unless @up_to_date
-        dir = @project.project_dir
-        @project_files.each do |f|
-          yield abs ? File.join( dir, f) : f
-        end
-        self
-      else
-        return self.to_enum(:each, abs)
-      end
-    end
-    
-=begin rdoc
-Returns an enumerator as that yields the names of the project files relative to
-the project directory. It's just a shortcut for <tt>each(false)</tt>.
-
-<b>Note:</b> if the list isn't up to date, the project will be re-scanned when
-any enumerable method returned by the object is called
-=end
-    def rel
-      self.each false
-    end
-    alias_method :relative_paths, :rel
-
-=begin rdoc
-Returns an enumerator as that yields the absolute names of the project files.
-It's just a shortcut for <tt>each(true)</tt>.
-
-<b>Note:</b> if the list isn't up to date, the project will be re-scanned when
-any enumerable method returned by the object is called
-=end
-    def abs
-      self.each true
-    end
-    alias_method :absolute_paths, :abs
-    
-=begin rdoc
-Updates the list, so that it reflects the current status of the project directory.
-
-Usually you don't need to call this method, as it's automatically called as needed.
-=end
-    def refresh
-      scan_project
-      @up_to_date = true
-      @watcher.start_scan
-    end
-    
-=begin rdoc
-Tells whether the list is up to date or needs to be rebuilt.
-
-Usually you don't need this method, as the list is automatically updated when needed.
-=end
-    def up_to_date?
-      @up_to_date
-    end
-    
-=begin rdoc
-Tells whether the given file belongs to the project or not. If _file_ is a relative
-path, it is considered relative to the project directory.
-
-Returns *true* if _file_ belongs to the project and *false* otherwise. As this method
-doesn't access the filesystem, the behaviour in the case _file_ is a directory will
-be undefined. If _file_ ends with a slash (which makes it clear it represents a
-directory) then *nil* will be returned
-<b>Note:</b> this method doesn't use the file list to tell whether the file is in
-the project. Rather, it compares the file name with the include and exclude rules
-and the extensions.
-=end
-    def file_in_project? file
-      if file.match %r{^([\w+-.]+)://(.+)}
-        if $1 != 'file' then return false
-        else 
-          file = $2
-        end
-      end
-      file = file.sub %r[^#{Regexp.quote(@project.project_directory)}/], ''
-      return false if file.start_with? '/'
-      return nil if file.end_with? '/'
-# I don't know why I added the following line
-#       file = File.basename(file)
-      
-      return false if @exclude_files.include? file
-      return true if @include_files.any?{|f| f == file}
-
-      if @exclude_regexp.match(file) then false
-      elsif @include_regexp.match file then true
-      elsif @extensions.any?{|e| File.fnmatch?(e, file, File::FNM_DOTMATCH)} then true
-      else false
-      end
-    end
-    
-    private
-
-=begin rdoc
-Applies the rules stored in the <tt>general/project_files</tt> project option
-to all the files in the project directory and fills the internal cache with the
-project files.
-
----
-The <tt>@lock</tt> instance variable is used to (hopefully) avoid issues with
-two threads calling this method together, since Dir.chdir doesn't nest inside
-threads. This created problems with syntax checker, for example.
-=end
-    def scan_project
-      @lock.synchronize do
-        Dir.chdir(@project.project_dir) do
-          res = @include_files.select{|f| File.exist?(f) and File.file?(f)}
-          # remove the leading ./ from the names of the files
-          res.map!{|f| f.sub(%r{^./}, '')}
-          Find.find('.') do |f|
-          # let's skip the current directory, least it somehow matches one of
-          # the exclude rules
-          next if f == '.'
-            if File.directory?(f)
-              f = File.join(f, '')
-              Find.prune if f.match @exclude_regexp
-            else
-              # We remove the leading ./
-              f = f[2..-1]
-              next if f.match @exclude_regexp or @exclude_files.include?(f)
-              res << f if @extensions.any?{|ext| File.fnmatch?(ext, f, File::FNM_DOTMATCH)} or
-                  f.match(@include_regexp)
-            end
-          end
-          res.uniq!
-          @project_files = res
-        end
-      end
-    end
-   
-=begin rdoc
-Creates an internal version of the rules from the values in the
-<tt>general/project_files</tt> project option
-=end
-    def make_rules
-      rules = @project[:general, :project_files]
-      @include_regexp = Regexp.union(*(rules[:include].select{|r| r.is_a?(Regexp)}))
-      @exclude_regexp = Regexp.union(*(rules[:exclude].select{|r| r.is_a?(Regexp)}))
-      @exclude_files = rules[:exclude].select{|rule| rule.is_a? String}.map{|f| f.sub(%r{^\./}, '')}
-      @include_files = rules[:include].select{|rule| rule.is_a? String}.map{|f| f.sub(%r{^\./}, '')}
-      @include_files-= @exclude_files
-      @extensions = rules[:extensions]
-      @rules = YAML.load(YAML.dump rules)
-# TODO Uncomment the following line and remove the previous when found out why Marshal
-# fails
-#       @rules = rules.deep_copy
-    end
-    
-  end
-  
-end

data/spec/project_files_list_spec.rb

@@ -1,411 +0,0 @@
-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 'updates 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 'doesn\'t 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 'returns 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 'doesn\'t 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 'skips 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 'includes 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 'includes 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 'doesn\'t 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 'returns 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 'returns 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 'returns 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 'returns 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 'returns 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 'returns 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 'returns 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 'treats 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 'returns 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 'returns 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 'returns 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
-      
-      it 'returns false if the path represents a remote URL' do
-        @prj[:general, :project_files] = {:include => [], :exclude => [], :extensions => ['*.rb']}
-        @list.file_in_project?("http://#{@dir}/abc.xyz.rb").should be_false
-      end
-      
-      it 'works normally if the path represents a local url' do
-        @prj[:general, :project_files] = {:include => [], :exclude => [], :extensions => ['*.rb']}
-        @list.file_in_project?("file://#{@dir}/abc.xyz.rb").should be_true
-      end
-      
-    end
-    
-  end
-  
-end