ruber 0.0.1.1

data/lib/ruber/project_backend.rb

@@ -0,0 +1,105 @@
+=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 'ruber/yaml_option_backend'
+
+module Ruber
+  
+=begin rdoc
+Backend for SettingsContainer used by the project class. It is similar to YamlSettingsBackend,
+except for the fact that it produces three files instead of one: one only contains
+options of type +:global+ (and is referred to as the <i>project file</i>),
+another one contains only options of type +:user+ and
+the last contains only options of type +:session+
+=end
+  class ProjectBackend
+    
+=begin rdoc
+Associates each option type (+:global+, +:user+ and +:session+) with the extension
+of the file where those options will be stored
+=end
+    EXTENSIONS = {:global => '.ruprj', :user => '.ruusr', :session => '.ruses'}
+    
+=begin rdoc
+Creates a new ProjectBackend. <i>file</i> is the name of the project file. The
+name of the file for the user options and the session options is obtained by
+appending the appropriate extension to the project file:
+* +.ruusr+ for the user options file
+* +.ruses+ for the session options file
+If _file_ has the +.ruprj+ extension, that extension will be removed before
+adding the extensions above. If it has any other extension (or no extension at
+all), they'll be kept.
+
+For example, if _file_ is <tt>/home/stefano/xyz.ruprj</tt>, the other two files
+will be <tt>/home/stefano/xyz.ruusr</tt> and <tt>/home/stefano/xyz.ruses</tt>.
+Instead, if _file_ is <tt>/home/stefano/xyz.abc</tt>, the other two files
+will be <tt>/home/stefano/xyz.abc.ruusr</tt> and <tt>/home/stefano/xyz.abc.ruses</tt>
+
+If either the file for the global or the user options already exists but doesn't
+have the correct format, <tt>YamlSettingsBackend::InvalidSettingsFile</tt> will be
+raised. If the same happens for the session options file, instead, a warning
+will be emitted, default values will be used for the session options and they
+will never be saved to file.
+=end
+    def initialize file
+      @backends = {}
+      base_file = file.sub(/#{EXTENSIONS[:global]}$/, '')
+      @backends[:global] = YamlSettingsBackend.new file
+      @backends[:user] = YamlSettingsBackend.new base_file + EXTENSIONS[:user]
+      @backends[:session] = begin YamlSettingsBackend.new base_file + EXTENSIONS[:session]
+      rescue YamlSettingsBackend::InvalidSettingsFile
+        warn "The file #{base_file + '.ruses'} already exists but it's not a valid session file. Session options won't be saved"
+        YamlSettingsBackend.new ''
+      end
+    end
+    
+=begin rdoc
+Returns the path of the file were the global options are stored
+=end
+    def file
+      @backends[:global].file
+    end
+    
+=begin rdoc
+Returns the value of the option described by the option object _opt_
+(see SettingsContainer#add_option).
+
+The value will be retrieved from the backend corresponding to the type of the option
+=end
+    def [] opt
+      @backends[opt.type][opt]
+    end
+    
+=begin rdoc
+Writes the options _opts_ back to disk. The options contained in _opts_ will be
+grouped according to their types and the appropriate backend will be used to
+save each group.
+=end
+    def write opts
+      options = {:global => {}, :user => {}, :session => {}}
+      opts.each{|k, v| options[k.type][k] = v}
+      @backends[:global].write options[:global]
+      @backends[:user].write options[:user]
+      @backends[:session].write options[:session] unless @backends[:session].file.empty?
+    end
+    
+  end
+  
+end

data/lib/ruber/projects/plugin.yaml

@@ -0,0 +1,11 @@
+name: projects
+require: [project_list, project_files_widget, project_files_list]
+class: Ruber::ProjectList
+project_options:
+ general:
+  project_files: {default: {:include: [], :exclude: [], :extensions: ["*.rb"]}}
+  open_documents: {default: [], type: session, scope: [global, document]}
+project_widgets:
+ - {class: Ruber::ProjectFilesWidget, caption: 'General', pixmap: configure}
+extensions:
+ project_files: {class: ProjectFilesList}

data/lib/ruber/projects/project_files_list.rb

@@ -0,0 +1,314 @@
+=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
+      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/lib/ruber/projects/project_files_widget.rb

@@ -0,0 +1,301 @@
+=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 'pathname'
+
+require_relative 'ui/project_files_rule_chooser_widget.rb'
+require_relative 'ui/project_files_widget.rb'
+
+module Ruber
+
+=begin rdoc
+Widget which displays and allows to modify the rules which determine whether a
+file belongs to a project or not.
+
+It contains a @Qt::TreeView@ where the rules are displayed and some buttons to add
+and remove rules. The tree view has two columns: the first displays the contents
+of the rules, while the second contains the rules' type (whether they're regexp
+rules or file rules).
+
+@see Ruber::ProjectFilesList
+=end
+  class ProjectFilesRuleChooser < Qt::Widget
+    
+=begin rdoc
+Signal emitted when the rules have been changed
+=end
+    signals 'rules_edited()'
+    
+=begin rdoc
+@return [Ruber::Project] the project the widget displays rules for
+=end
+    attr_writer :project
+    
+=begin rdoc
+Validator class for regexp rules
+
+It marks the text as @Qt::Validator::Intermediate@ if a valid regexp can't be
+constructed from it and as @Qt::Validator::Acceptable@ if it can
+=end
+    class RegexpRuleValidator < Qt::Validator
+      
+=begin rdoc
+Override of @Qt::Validator#validate@
+
+@param [String] input the text in the widget
+@param [Integer] _pos the cursor position (unused)
+@return [Integer] @Qt::Validator::Acceptable@ if the text is a valid regexp and
+ @Qt::Validator::Intermediate@ otherwise
+=end
+      def validate input, _pos
+        begin 
+          Regexp.new(input)
+          Acceptable
+        rescue RegexpError
+          Intermediate
+        end
+      end
+      
+    end
+    
+    slots :remove_rule, :add_regexp_rule, :add_path_rule, :edit_rule, :change_button_state
+
+=begin rdoc
+@param [Qt::Widget] parent the parent widget
+=end
+    def initialize parent = nil
+      super 
+      @project = nil
+      @ui = Ui::ProjectFilesRuleChooser.new
+      @ui.setupUi self
+      model = Qt::StandardItemModel.new @ui.rules_widget
+      @ui.rules_widget.model = model
+      model.horizontal_header_labels = %w[Pattern Type]
+      connect @ui.add_regexp_btn, SIGNAL('clicked()'), self, SLOT('add_regexp_rule()')
+      connect @ui.add_path_btn, SIGNAL('clicked()'), self, SLOT('add_path_rule()')
+      connect @ui.remove_rule_btn, SIGNAL('clicked()'), self, SLOT('remove_rule()')
+      connect @ui.rules_widget.selection_model, SIGNAL('selectionChanged(QItemSelection, QItemSelection)'), self, SLOT('change_button_state()')
+      @ui.remove_rule_btn.enabled = false
+    end
+    
+=begin rdoc
+Override of @Qt::Widget#sizeHint@
+
+@return [Qt::Size] the optimal size to use (350x200)
+=end
+    def sizeHint
+      Qt::Size.new(350,200)
+    end
+
+=begin rdoc
+The rules chosen by the user
+
+@return [Array<String,Regexp>] an array containing the rules the user has chosen.
+String entries correspond to file rules, while regexp entries correspond to regexp
+rules
+=end
+    def rules
+      @ui.rules_widget.model.enum_for(:each_row).map do |rule, type|
+        if type.text == 'Path' then rule.text
+        else Regexp.new rule.text
+        end
+      end
+    end
+    
+=begin rdoc
+Fills the tree view
+
+*Note:* calling this method won't trigger the {#rules_edited} signal
+
+@param [Array<String,Regexp>] list a list of the rules to insert in the view. String
+entries will be considered as file rules, while regexp entries will be considered
+regexp rules
+@return [nil]
+=end
+    def rules= list
+      model = @ui.rules_widget.model
+      model.clear
+      model.horizontal_header_labels = %w[Pattern Type]
+      list.each do |rule|
+        type = 'Path'
+        if rule.is_a? Regexp
+          type = 'Regexp'
+          rule = rule.source
+        end
+        model.append_row [Qt::StandardItem.new(rule), Qt::StandardItem.new(type)]
+      end
+      nil
+    end
+    
+    private 
+    
+=begin rdoc
+Adds a rule to the tree view
+
+The {#rules_edited} signal will be emitted after the rule has been inserted
+
+@param [String] text the text to insert in the first column of the view. It must
+be the path of the file for a file rule and the source of the regexp for a regexp
+rule
+@param [String] the name of the type of rule. Currently, this should be either
+@Regexp@ or @File@
+@return [(Qt::StandardItem, Qt::StandardItem)] the new items inserted in the view's
+model
+=end
+    def add_rule text, type
+      row = [Qt::StandardItem.new(text), Qt::StandardItem.new(type)]
+      @ui.rules_widget.model.append_row row
+      @ui.rules_widget.selection_model.select row[0].index, 
+            Qt::ItemSelectionModel::SelectCurrent| Qt::ItemSelectionModel::Rows |
+            Qt::ItemSelectionModel::Clear
+      emit rules_edited
+      row
+    end
+    
+=begin rdoc
+Enables or disables the the Remove button
+
+The button is enabled if a rule is selected and disabled otherwise
+
+@return [nil]
+=end
+    def change_button_state
+      @ui.remove_rule_btn.enabled = 
+          !@ui.rules_widget.selection_model.selected_rows.first.nil?
+      nil
+    end
+    
+=begin rdoc
+Adds a file rule to the list
+
+A dialog is shown to the user to select the file to add to the project
+
+@return [nil]
+=end
+    def add_path_rule
+      rule = KDE::FileDialog.get_open_file_name KDE::Url.from_path(@project.project_dir),
+          '', self, "Add files to project"
+      return unless rule
+      path = Pathname.new(rule)
+      if path.child_of?(@project.project_dir)
+        prj_dir = Pathname.new(@project.project_dir)
+        rule = path.relative_path_from(prj_dir).to_s
+      end
+      add_rule rule, 'Path'
+      nil
+    end
+    
+=begin rdoc
+Adds a regexp rule to the list
+
+The user is shown a dialog to choose the regexp
+
+@return [nil]
+=end
+    def add_regexp_rule
+      rule = KDE::InputDialog.get_text "Add regexp rule", "Regexp", 
+          :validator => RegexpRuleValidator.new(self)
+      return unless rule
+      add_rule rule, 'Regexp'
+      nil
+    end
+    
+=begin rdoc
+Removes the selected rule from the list
+
+The {#rules_edited} signal is emitted after removing the rule
+
+*Note:* this method doesn't check whether there's an item selected and will fail
+if it isn't so
+@return [nil]
+=end
+    def remove_rule
+      row = @ui.rules_widget.selection_model.selected_rows.first
+      @ui.rules_widget.model.remove_row row.row
+      emit rules_edited
+      nil
+    end
+
+  end
+
+=begin rdoc
+Widget where the user can choose the rules for files to include and exclude from
+a project.
+
+This widget contains two {ProjectFilesRuleChooser} widgets, one for the files to
+include in the project and another for the files to exclude, and one lineedit where
+the user chooses the extensions of the files to add by default to the project.
+=end
+  class ProjectFilesWidget < ProjectConfigWidget
+    
+=begin rdoc
+Signal emitted whenever the contents of the widgets change so that the Apply button
+in the dialg can be enabled accordingly
+=end
+    signals 'settings_changed()'
+    
+    slots 'read_settings(QObject*)', 'store_settings(QObject*)',
+        'read_default_settings(QObject*)'
+    
+=begin rdoc
+@param [Ruber::Project] prj the project the widget is for
+=end
+    def initialize prj
+      super
+      @ui = Ui::ProjectFilesWidget.new
+      @ui.setupUi self
+      @ui.include_rules.project = prj
+      @ui.exclude_rules.project = prj
+      connect @ui.include_rules, SIGNAL('rules_edited()'), self, SIGNAL('settings_changed()')
+      connect @ui.extensions, SIGNAL('textChanged(QString)'), self, SIGNAL('settings_changed()')
+    end
+    
+=begin rdoc
+Reads the settings from the project
+
+@return [nil]
+=end
+    def read_settings
+      rules = project[:general, :project_files]
+      @ui.include_rules.rules = rules[:include]
+      @ui.exclude_rules.rules = rules[:exclude]
+      exts = rules[:extensions]
+      @ui.extensions.text = exts.join ' '
+      nil
+    end
+    
+=begin rdoc
+Writes the settings to the project
+
+@return [nil]
+=end
+    def store_settings
+      res = {
+        :include => @ui.include_rules.rules,
+        :exclude => @ui.exclude_rules.rules,
+        :extensions => @ui.extensions.text.split(/[\s,;]/)
+      }
+      project[:general, :project_files] = res
+      nil
+    end
+    
+  end
+  
+end