ruber 0.0.8 → 0.0.9

data/plugins/autosave/autosave.rb

@@ -236,8 +236,8 @@ into account the enabled option and always attempt to save the documents.
 @return [Boolean] see {#autosave}
 =end
       def save_project_files opts, blk
-        docs = Ruber[:docs].documents_with_file
-        prj_files = Ruber[:projects].current.project_files.abs
+        docs = Ruber[:world].active_environment.documents.documents_with_file
+        prj_files = Ruber[:world].active_project.project_files.abs
         docs = docs.select{|d| prj_files.include? d.path}
         save_files docs, opts, blk
       end
@@ -253,7 +253,7 @@ into account the enabled option and always attempt to save the documents.
 @return [Boolean] see {#autosave}
 =end
       def save_open_documents opts, blk
-        save_files Ruber[:docs].documents, opts, blk
+        save_files Ruber[:world].documents, opts, blk
       end
       
 =begin rdoc
@@ -267,7 +267,7 @@ into account the enabled option and always attempt to save the documents.
 @return [Boolean] see {#autosave}
 =end
       def save_documents_with_file opts, blk
-        save_files Ruber[:docs].documents_with_file, opts, blk
+        save_files Ruber[:world].documents.documents_with_file, opts, blk
       end
       
 =begin rdoc

data/plugins/find_in_files/find_in_files.rb

@@ -153,7 +153,7 @@ Replace button
 =end
       def find_replace
         @dlg.clear
-        @dlg.allow_project = Ruber[:projects].current
+        @dlg.allow_project = Ruber[:world].active_project
         @dlg.exec
         case @dlg.action
         when :find then find @dlg.find_text, options_from_dialog
@@ -225,7 +225,7 @@ are saved.
 @return [Boolean] as {Autosave::AutosavePlugin#autosave AutosavePlugin#autosave}
 =end
       def do_autosave places
-        docs = Ruber[:docs].documents_with_file
+        docs = Ruber[:world].documents.documents_with_file
         if places.is_a? String then docs = docs.select{|d| d.path.start_with? places}
         else docs = docs.select{|d| places.include? d.path}
         end
@@ -279,9 +279,9 @@ the following entries:
         opts[:whole_words] = @dlg.whole_words?
         places = case @dlg.places
         when :custom_dir then @dlg.directory
-        when :project_dir then Ruber[:projects].current.project_directory
-        when :project_files then Ruber[:projects].current.project_files.abs.to_a
-        when :open_files then Ruber[:docs].documents_with_file.map{|d| d.path}
+        when :project_dir then Ruber[:world].active_project.project_directory
+        when :project_files then Ruber[:world].active_project.project_files.abs.to_a
+        when :open_files then Ruber[:world].documents.documents_with_file.map{|d| d.path}
         end
         opts[:places] = Array(places)
         opts[:all_files] = @dlg.all_files?

data/plugins/find_in_files/find_in_files_widgets.rb

@@ -359,7 +359,7 @@ Items corresponding to successful replacements are removed from the view.
       def replace
         failed = {}
         success = []
-        docs = Ruber[:docs].documents_with_file.map{|d| [d.path, d]}.to_h
+        docs = Ruber[:world].documents.documents_with_file.map{|d| [d.path, d]}.to_h
         model.each_row.each_with_index do |r, i|
           if r[0].checked?
             res = replace_file r[0], docs[r[0].text]

data/plugins/project_browser/project_browser.rb

@@ -1,5 +1,5 @@
 =begin
-    Copyright (C) 2010 by Stefano Crocco   
+    Copyright (C) 2010, 2011 by Stefano Crocco   
     stefano.crocco@alice.it   
   
     This program is free software; you can redistribute it andor modify  
@@ -54,7 +54,7 @@ something can be done about it
 =end
         def initialize parent = nil
           super
-          @project = Ruber[:projects].current
+          @project = nil
           @do_filtering = true
           self.dynamic_sort_filter = true
         end
@@ -155,7 +155,7 @@ project, if any
 =end
       def initialize parent = nil
         super
-        connect Ruber[:projects], SIGNAL('current_project_changed(QObject*)'), self, SLOT('current_project_changed(QObject*)')
+        connect Ruber[:world], SIGNAL('active_project_changed(QObject*)'), self, SLOT('current_project_changed(QObject*)')
         self.layout = Qt::VBoxLayout.new self
         @view = View.new self
         @model = KDE::DirModel.new @view
@@ -168,7 +168,7 @@ project, if any
         @view.header_hidden = true
         layout.add_widget @view
         @project = nil
-        current_project_changed Ruber[:projects].current
+        current_project_changed Ruber[:world].active_project
         @view.connect(SIGNAL('only_project_files_triggered(bool)')){|val| @filter.do_filtering = val}
         connect @view, SIGNAL('activated(QModelIndex)'), self, SLOT('open_file_in_editor(QModelIndex)')
       end

data/plugins/rake/rake.rb

@@ -142,8 +142,8 @@ Signal emitted when the rake program started with {#run_rake} has exited
           Ruber[:main_window].change_state 'rake_running', false
         end
         self.connect(SIGNAL(:process_failed_to_start)){Ruber[:main_window].change_state 'rake_running', false}
-        connect Ruber[:projects], SIGNAL('current_project_changed(QObject*)'), self, SLOT(:set_current_target)
-        connect Ruber[:main_window], SIGNAL('current_document_changed(QObject*)'), self, SLOT(:set_current_target)
+        connect Ruber[:world], SIGNAL('active_project_changed(QObject*)'), self, SLOT(:set_current_target)
+        connect Ruber[:world], SIGNAL('active_document_changed(QObject*)'), self, SLOT(:set_current_target)
         connect self, SIGNAL('process_finished(int, QString)'), self, SIGNAL(:rake_finished)
         connect self, SIGNAL('extension_added(QString, QObject*)'), self, SLOT(:set_current_target)
         connect self, SIGNAL('extension_removed(QString, QObject*)'), self, SLOT(:set_current_target)
@@ -437,9 +437,9 @@ it isn't a rakefile
 and there's no open project
 =end
       def find_current_target
-        target = Ruber[:main_window].current_document.project rescue nil
+        target = Ruber[:world].active_document.project rescue nil
         if target.nil? or !target.has_extension? :rake
-          prj = Ruber[:projects].current
+          prj = Ruber[:world].active_project
           target = if prj and prj.has_extension? :rake then prj
           else nil
           end

data/plugins/rake/rake_extension.rb

@@ -81,7 +81,7 @@ default task
       def run_rake task
         params = gather_parameters
         files = @project.files
-        docs= Ruber[:documents].documents_with_file.select{|d| files.include? d.path}
+        docs= Ruber[:world].documents.documents_with_file.select{|d| files.include? d.path}
         return unless Ruber[:autosave].autosave Ruber[:rake], docs, :on_failure => :ask
         ruby, *ruby_opts = Ruber[:rake].ruby_command_for @project, params[:dir]
         params[:ruby_options] = ruby_opts

data/plugins/rspec/rspec.rb

@@ -144,7 +144,7 @@ to find out whether the file is a spec file or not.
 @return [Boolean,nil] wheter or not _file_ is a spec file for the given project
   or *nil* if no project was specified and there's no open project
 =end
-      def spec_file? file, prj = Ruber[:projects].current
+      def spec_file? file, prj = Ruber[:world].active_project
         return nil unless prj
         dir = prj[:rspec, :spec_directory, :absolute]
         return false unless file.start_with? dir
@@ -306,7 +306,7 @@ Runs all the specs for the project.
 @return [nil]
 =end
       def run_all
-        prj = Ruber[:projects].current_project
+        prj = Ruber[:world].active_project
         unless prj
           KDE::MessageBox.error nil, "You must have an open project to choose this entry.\nYOU SHOULD NEVER SEE THIS MESSAGE"
           return
@@ -337,7 +337,7 @@ which, most likely, will cause it to fail.
 (including the case when the process was already running or autosaving failed)
 =end
       def run_current what = :all
-        prj = Ruber[:projects].current_project
+        prj = Ruber[:world].active_project
         unless prj
           KDE::MessageBox.error nil, "You must have an open project to choose this entry.\nYOU SHOULD NEVER SEE THIS MESSAGE"
           return
@@ -451,7 +451,7 @@ It does nothing if the file corresponding to the current document isn't found
 =end
       def switch
         file = Ruber[:main_window].current_document.path
-        prj = Ruber[:projects].current_project
+        prj = Ruber[:world].active_project
         if spec_file? file, prj then switch_to = file_for_spec prj, file
         else switch_to = specs_for_file(options(prj), file)[0]
         end

data/plugins/rspec/ruber_rspec_formatter.rb

@@ -301,8 +301,8 @@ example
         hash = {}
         hash[:type] = :pending
         hash[:description] = ex.metadata[:full_description]
-        hash[:message] = ex.metadata[:execution_result][:exception_encountered].message
-        hash[:location] = ex[:metadata][:location]
+        hash[:message] = ex.metadata[:execution_result][:pending_message]
+        hash[:location] = ex.metadata[:location]
         write_data hash
       end
       

data/plugins/ruby_development/ruby_development.rb

@@ -156,7 +156,7 @@ started correctly or not.
 @see #run_file  
 =end
       def run
-        if Ruber[:projects].current then run_project
+        if Ruber[:world].active_project then run_project
         elsif (doc = Ruber[:main_window].current_document) then run_document doc
         else run_file
         end
@@ -178,7 +178,7 @@ started successfully.
 @see #run_ruby_for
 =end
       def run_project
-        prj = Ruber.current_project
+        prj = Ruber[:world].active_project
         data = prj[:ruby]
         prog = Pathname.new(data[:main_program, :abs])
         wdir = Pathname.new(data[:working_dir, :abs]||prj.project_dir)
@@ -259,7 +259,7 @@ was started. If the user pressed the Cancel button of the dialog, *nil* is retur
           file = url.to_encoded.to_s
         end
         
-        if doc = Ruber[:docs].document_for_url(url)
+        if doc = Ruber[:world].documents.document_for_url(url)
          return run_document doc 
         end
         

data/plugins/ruby_runner/ruby_runner.rb

@@ -355,8 +355,8 @@ to it
         when Document
           cont << (ignore_project ? (target.own_project) : target.project)
         when String
-          if !ignore_project and Ruber[:projects].project_for_file target
-            cont << Ruber[:projects].current
+          if !ignore_project and Ruber[:world].projects.project_for_file target
+            cont << Ruber[:world].active_project
           end
         end
         cont << Ruber[:config]

data/plugins/state/plugin.yaml

@@ -9,17 +9,15 @@ class: Ruber::State::Plugin
 require: state
 config_options:
  state:
-  open_documents: {default: []}
-  open_projects: {default: []}
   restore_cursor_position: {default: true}
-  restore_project_files: {default: true}
-  startup_behaviour: {default: :restore_all}
-  tabs: {default: []}
-  active_view: {default: nil}
-  cursor_positions: {default: []}
+  restore_projects: {default: true}
+  startup_behaviour: {default: [:default_environment, :projects]}
+  last_state: {default: []}
+  default_environment_tabs: {default: []}
+  default_environment_active_view: {default: nil}
+  default_environment_cursor_positions: {default: []}
 project_options:
  state:
-  open_documents: {default: [], type: session, scope: global}
   tabs: {default: [], scope: global, type: session}
   cursor_positions: {default: [], type: session, scope: global }
   active_view: {default: ~, type: session, scope: global}

data/plugins/state/state.rb

@@ -51,205 +51,67 @@ user preferences) when the application starts up.
 =end
   module State
     
-=begin rdoc
-Plugin object for the State plugin
-
-@api_method #with
-@api_method #restore
-@api_method #restore_document
-@api_method #restore_project
-=end
-    class Plugin < Ruber::Plugin
+    module EnvironmentState
       
 =begin rdoc
-@param [Ruber::PluginSpecification] psf the plugin specification object associated
-  with the plugin
-=end
-      def initialize psf
-        super
-        @force_restore_project_files = nil
-        @force_restore_cursor_position = nil
-      end
-      
-=begin rdoc
-Override of {PluginLike#delayed_initialize}
-
-If the application is starting and there's no open project and a single, pristine
-document, it uses the {#restore_last_state} method to restore the last state Ruber
-was according to the user preferences.
-
-@return [nil]
-=end
-      def delayed_initialize
-        return unless Ruber[:app].starting?
-        if Ruber[:projects].to_a.empty? and Ruber[:docs].to_a.size == 1 and
-                 Ruber[:docs][0].pristine?
-          restore_last_state
-        end
-        nil
-      end
-      
-=begin rdoc
-Tells whether or not the cursor position should be restored.
-
-This takes into account user settings and eventual requests made by the programmer
-using the {#with} method
-@return [Boolean] *true* if the cursor position should be restored and *false*
-otherwise
-=end
-      def restore_cursor_position?
-        if @force_restore_cursor_position.nil?
-          Ruber[:config][:state, :restore_cursor_position]
-        else @force_restore_cursor_position
-        end
-      end
-
-=begin rdoc
-Tells whether or not the open files in the project should be restored.
+The open tabs configuration in a form suitable to be written to a configuration object
 
-This takes into account user settings and eventual requests made by the programmer
-using the {#with} method
-@return [Boolean] *true* if the open files in the project should be restored and *false*
-otherwise
-=end
-      def restore_project_files?
-        if @force_restore_project_files.nil?
-          Ruber[:config][:state, :restore_project_files]
-        else @force_restore_project_files
-        end
-      end
-      
-=begin rdoc
-Executes a block temporarily overriding the user's settings about what should be
-restored and what shouldn't.
-
-Nested calls to this method are allowed. By default, the outer call wins over the
-inner, meaning that a value set by the inner call are only used if the outer
-call didn't set that value. You can change this behaviour by passing the @:force@
-option.
-@param [Hash] hash the settings to change. All settings not specified here will
-remain as chosen by the user
-@option hash [Boolean] :force (false) if *true*, in case of a nested call to this
-method, the values specified by the inner call will override values set by the
-outer call.
-@option hash [Boolean] :restore_cursor_position (false) whether or not the cursor position
-in documents should be restored, regardless of what the user chose
-@option hash [Boolean] :restore_project_files (false) whether or not the open
-files in projects should be restored, regardless of what the user chose
-@return [Object] the value returned by the block
+@return [Hash] A hash containing the following keys:
+ * @:tabs@: an array of arrays, with each inner array representing one tab, with
+  the format described in {#restore_pane}. This value is the one to write under
+  the @state/tabs@ entry in a project or configuration object
+ * @:cursor_positions@:an array of arrays. Each inner array corresponds to a tab
+  and contains the cursor position of each view. Each cursor position is represented
+  as an array with two elements: the first is the line, the second is the column.
+  The order the views are is the same used by {Pane#each_view}. This value is the one to write under
+  the @state/cursor_positions@ entry in a project or configuration object
+ * @:active_view@: the active view. It is represented by a size 2 array, with the
+  first element being the index of the tab of the active view and the second being
+  the index of the view in the corresponding pane (according to the order used by
+  {Pane#each_view}). If there's no active view, this entry is *nil*. This is the value to write under
+  the @state/active_view@ entry in a project or configuration object
 =end
-      def with hash
-        old_doc = @force_restore_cursor_position
-        old_projects = @force_restore_project_files
-        if hash.has_key? :restore_cursor_position
-          if @force_restore_cursor_position.nil? or hash[:force]
-            @force_restore_cursor_position = hash[:restore_cursor_position] || false 
+      def tabs_state env
+        res = {}
+        doc_map = {}
+        doc_idx = 0
+        env.documents.each do |doc|
+          if !doc.has_file?
+            doc_map[doc] = doc_idx
+            doc_idx += 1
           end
         end
-        if hash.has_key? :restore_project_files
-          if @force_restore_project_files.nil? or hash[:force]
-            @force_restore_project_files = hash[:restore_project_files] || false 
+        tabs = env.tabs
+        tabs_tree = []
+        cursor_positions = []
+        tabs.each do |t|
+          tabs_tree << tab_to_tree(t, doc_map)
+          cursor_positions << t.map do |v|
+            pos = v.cursor_position
+            [pos.line, pos.column]
           end
         end
-        begin yield
-        ensure
-          @force_restore_cursor_position = old_doc
-          @force_restore_project_files = old_projects
+        res[:tabs] = tabs_tree
+        res[:cursor_positions] = cursor_positions
+        active = env.views[0]
+        if active
+          active_tab = env.tab(active)
+          res[:active_view] = [tabs.index(active_tab), active_tab.to_a.index(active)]
         end
+        res
       end
       
-=begin rdoc
-Restores the given document
-
-@see DocumentExtension#restore DocumentExtension#restore for more information
-
-@param [Ruber::Document] doc the document to restore
-@return [nil]
-=end
-      def restore_document doc
-        doc.extension(:state).restore
-      end
-
-=begin rdoc
-Restores the given global project
-
-@see ProjectExtension#restore ProjectExtension#restore for more information
-
-@param [Ruber::Project] prj the document to restore
-@return [nil]
-=end
-      def restore_project prj
-        prj.extension(:state).restore
-      end
-      
-=begin rdoc
-Restores the open projects according to a given configuration object
-
-Restoring the project means closing all the open projects and opening the projects
-and setting the active project according to the information in _conf_
-
-This method is called both when the session is restored and when ruber starts
-up (if the user chose so).
-
-@param [#[Symbol, Symbol]] conf the object from which to read the state. See {#restore}
-for more information
-@return [nil]
-=end
-      def restore_projects conf = Ruber[:config]
-        projects = Ruber[:projects]
-        projects.to_a.each{|pr| projects.close_project pr}
-        file = conf[:state, :open_projects][0]
-        if file
-          prj = Ruber[:main_window].safe_open_project file
-          Ruber[:projects].current_project = prj if prj
-        end
-        nil
-      end
-
-=begin rdoc
-Restores the open documents according to a given configuration object
-
-Restoring the open documents means:
-* closing all the open documents. If any of thess is modified, the user is asked
-  how to proceed. If the choses to abort, nothing else is done
-* opening the documents according to the @state/open_documents@ entry of _conf_
-* recreating the tabs and the editors according to the @state/tabs@ entry of _conf_
-* activating the editor contained in the @state/active_editor@ entry of _conf_
-
-This method is called both when the session is restored and when ruber starts
-up (if the user chose so).
-
-@param [#[Symbol, Symbol]] conf the object from which to read the state. See {#restore}
-for more information
-@return [nil]
-=end
-      def restore_documents config = Ruber[:config]
-        return unless Ruber[:documents].close_all
-        docs = config[:state, :open_documents]
+      def restore_environment env, data
         unnamed_docs = []
-        docs = docs.map do |i| 
-          if i.is_a?(String) then Ruber[:documents].document(i)
-          else 
-            doc = Ruber[:documents].new_document
-            unnamed_docs << doc
-            doc
-          end
+        env.close_editors env.views, false
+        data[:tabs].each_with_index do |t, i|
+          restore_tab env, t, data[:cursor_positions][i] || [], unnamed_docs
         end
-        return if docs.empty?
-        tabs = config[:state, :tabs]
-        mw = Ruber[:main_window]
-        positions = config[:state, :cursor_positions]
-        tabs.each_with_index do |t, i| 
-          pn = restore_pane t, unnamed_docs
-          views = pn.to_a
-          views.each_with_index do |v, j|
-            cursor = KTextEditor::Cursor.new(*(positions[i][j] rescue [0,0]))
-            v.cursor_position = cursor
-          end
-        end
-        active_editor = config[:state, :active_view]
+        active_editor = data[:active_view]
         if active_editor
-          mw.focus_on_editor mw.tabs[active_editor[0]].to_a[active_editor[1]]
+          editor = env.tabs[active_editor[0]].to_a[active_editor[1]]
+          env.activate_editor editor
+          editor.set_focus if editor
         end
       end
       
@@ -279,8 +141,8 @@ format:
   _n_ in _docs_
 @return [Pane] the new pane
 =end
-      def restore_pane data, docs
-        mw = Ruber[:main_window]
+      def restore_tab env, tab, cursor_positions, unnamed_docs
+        world = Ruber[:world]
         find_first_view = lambda do |array|
           if array.size == 1 then array[0]
           elsif array[1].is_a? Array then find_first_view.call array[1]
@@ -295,97 +157,181 @@ format:
             #the first view, which is already contained in the pane
             next if i < 2 
             view = e.is_a?(Array) ? find_first_view.call(e) : e
-            view = mw.editor_for! view.is_a?(String) ? view: docs[view], 
-                        :existing => :never, :show => false
+            if view.is_a?(String) 
+              doc = world.document(KDE::Url.new(view)) || world.new_document
+            else doc = unnamed_docs[view] ||= world.new_document
+            end
+            view = doc.create_view
             pn.split last_view, view, orientation
             last_view = view
             recreate_pane.call view.parent, e if e.is_a? Array
           end
           recreate_pane.call pn.splitter.widget(0), array[1] if array[1].is_a?(Array)
         end
-        view = find_first_view.call data
-        view = mw.editor_for! view.is_a?(String) ? view : docs[view], 
-                      :existing => :never, :new => :new_tab
+        view = find_first_view.call tab
+        if view.is_a?(String) 
+          doc = world.document(KDE::Url.new(view))
+        else doc = unnamed_docs[view] ||= Ruber[:world].new_document
+        end
+        view = env.editor_for! doc, :existing => :never, :new => :new_tab
         pane = view.parent
-        recreate_pane.call pane, data
+        recreate_pane.call pane, tab
+        pane.views.each_with_index do |v, i|
+          pos = cursor_positions[i]
+          v.go_to *pos if pos
+        end
         pane
       end
       
+      private
+      
 =begin rdoc
-Restores ruber state according to the user settings and the data stored in the given object
-
-The argument can be any object which has a @[]@ method which takes two arguments
-and behaves as the hash returned by {#gather_settings}.
+A representation of a pane's configuration suitable to be written to a configuration
+object
 
-@param [#[Symbol, Symbol]] conf the object from which to read the state
-@return [nil]
+@param [Pane] pane the pane to return the representation for
+@param [Hash{Document=>Integer}] docs a map between documents not associated
+  with files and the number to represent them
+@return [Array<Array,Integer,String>] an array as described in {#restore_pane}
 =end
-      def restore cfg = Ruber[:config]
-        if !cfg[:state, :open_projects].empty? then restore_projects cfg
-        else restore_documents cfg
+      def tab_to_tree pane, docs
+        if pane.single_view?
+          doc = pane.view.document
+          return [doc.has_file? ? doc.url.url : docs[doc]]
         end
-        nil
+        panes = {}
+        tab_to_tree_prc = lambda do |pn|
+          if pn.single_view?
+            doc = pn.view.document
+            panes[pn.parent_pane] << (doc.has_file? ? doc.url.url : docs[doc])
+          else 
+            data = [pn.orientation]
+            panes[pn] = data
+            panes[pn.parent_pane] << data if pn.parent_pane
+          end
+        end
+        tab_to_tree_prc.call pane
+        pane.each_pane :recursive, &tab_to_tree_prc
+        panes[pane]
       end
-
+      
+    end
+    
 =begin rdoc
-Restores Ruber's state according to the user settings so that it matches the state
-it was when it was last shut down
+Plugin object for the State plugin
+=end
+    class Plugin < Ruber::Plugin
+      
+      include EnvironmentState
+      
+=begin rdoc
+@param [Ruber::PluginSpecification] psf the plugin specification object associated
+  with the plugin
+=end
+      def initialize psf
+        super
+        @force_restore_project_files = nil
+        @force_restore_cursor_position = nil
+      end
+      
+=begin rdoc
+Override of {PluginLike#delayed_initialize}
 
-The state information is read from the global configuration object.
+If the application is starting and there's no open project and a single, pristine
+document, it uses the {#restore_last_state} method to restore the last state Ruber
+was according to the user preferences.
 
 @return [nil]
 =end
-      def restore_last_state
-        case Ruber[:config][:state, :startup_behaviour]
-        when :restore_all then restore
-        when :restore_projects_only
-          with(:restore_project_files => false){restore_projects}
-        when :restore_documents_only then restore_documents
+      def delayed_initialize
+        return unless Ruber[:app].starting?
+        docs = Ruber[:world].documents
+        if Ruber[:world].projects.empty? and docs.size == 1 and docs[0].pristine?
+          Ruber[:app].sessionRestored? ? restore_last_state(:force) : restore_last_state
         end
+        connect Ruber[:world], SIGNAL('project_created(QObject*)'), self, SLOT('restore_project(QObject*)')
+        nil
       end
-      
+
+      def restore_project prj
+        prx = prj[:state]
+        data = {
+          :tabs => prx[:tabs],
+          :cursor_positions => prx[:cursor_positions],
+          :active_view => prx[:active_view]
+        }
+        env = Ruber[:world].environment(prj)
+        if Ruber[:config][:state, :restore_projects] and env.tabs.count == 0
+          restore_environment env, data
+        end
+      end
+      slots 'restore_project(QObject*)'
+           
 =begin rdoc
-Restores Ruber's state as it was in last session
+Restores Ruber's state according to the user settings so that it matches the state
+it was when it was last shut down
 
-Since this method deals with session management, it ignores the user settings
+The state information is read from the global configuration object.
 
 @return [nil]
 =end
-      def restore_session data
-        hash = data['State'] || {:open_projects => [], :open_documents => [], :active_view => nil, :tabs => []}
-        hash = hash.map_hash{|k, v| [[:state, k], v]}
-        def hash.[] k, v
-          super [k, v]
+      def restore_last_state mode = nil
+        force = mode == :force
+        cfg = Ruber[:config][:state]
+        if force or cfg[:startup_behaviour].include? :default_environment
+          default_env_data = {
+            :tabs => cfg[:default_environment_tabs],
+            :active_view => cfg[:default_environment_active_view],
+            :cursor_positions => cfg[:default_environment_cursor_positions]
+          }
+          restore_environment Ruber[:world].default_environment, default_env_data
         end
-        with(:restore_project_files => true, :restore_cursor_position => true, :force => true) do
-          restore hash
+        active_prj = nil
+        if force || cfg[:startup_behaviour].include?(:projects)
+          cfg[:last_state].each_with_index do |f, i|
+            next if f.nil?
+            begin prj = Ruber[:world].project f
+            rescue Ruber::AbstractProject::InvalidProjectFile
+              next
+            end
+            active_prj = prj if i == 0
+            data = {
+              :tabs => prj[:state, :tabs],
+              :cursor_positions => prj[:state, :cursor_positions],
+              :active_view => prj[:state, :active_view]
+            }
+            restore_environment Ruber[:world].environment(prj), data
+          end
+          Ruber[:world].active_project = active_prj
         end
-        nil
       end
-      
+            
 =begin rdoc
 Saves Ruber's state to the global config object
 
 @return [nil]
 =end
       def save_settings
-        h = gather_settings
-        cfg = Ruber[:config]
-        h.each_pair do |k, v| 
-          cfg[:state, k] = v
+        files = Ruber[:world].environments.map do |e|
+          prj = e.project
+          prj ? prj.project_file : nil
         end
+        active_env = Ruber[:world].active_environment
+        if active_env and active_env.project
+          active_project = active_env.project.project_file
+        else active_project = nil
+        end
+        files.unshift files.delete(active_project)
+        Ruber[:config][:state, :last_state] = files
+        default_env_state = tabs_state Ruber[:world].default_environment
+        Ruber[:config][:state, :default_environment_tabs] = default_env_state[:tabs]
+        Ruber[:config][:state, :default_environment_active_view] =
+            default_env_state[:active_view]
+        Ruber[:config][:state, :default_environment_cursor_positions] = 
+            default_env_state[:cursor_positions]
         nil
       end
       
-=begin rdoc
-Override of {PluginLike#session_data}
-
-@return [Hash] a hash containing the session information under the @State@ key
-=end
-      def session_data
-        {'State' => gather_settings}
-      end
-      
 =begin rdoc
 The open projects in a form suitable to be written to a configuration object
 
@@ -395,129 +341,13 @@ The open projects in a form suitable to be written to a configuration object
   object
 =end
       def projects_state
-        projects = Ruber[:projects].projects.map{|pr| pr.project_file}
+        projects = Ruber[:world].projects.map{|pr| pr.project_file}
         unless projects.empty?
-          active_prj = Ruber[:projects].current
+          active_prj = Ruber[:world].active_document
           projects.unshift projects.delete(active_prj.project_file) if active_prj
         end
         projects
       end
-
-=begin rdoc
-The open documents in a form suitable to be written to a configuration object
-
-@return [Array<String,nil>] an array containing the names of the URLs associated with
-  the currently open documents. Documents not associated with files are represented
-  by *nil*s in the array. This value is the one to write under the @state/open_documents@
-  entry in a project or configuration object
-=end
-      def documents_state
-        docs = Ruber[:documents].documents
-        docs.map{ |doc| doc.has_file? ? doc.url.to_encoded.to_s : nil}
-      end
-
-=begin rdoc
-The open tabs configuration in a form suitable to be written to a configuration object
-
-@return [Hash] A hash containing the following keys:
- * @:tabs@: an array of arrays, with each inner array representing one tab, with
-  the format described in {#restore_pane}. This value is the one to write under
-  the @state/tabs@ entry in a project or configuration object
- * @:cursor_positions@:an array of arrays. Each inner array corresponds to a tab
-  and contains the cursor position of each view. Each cursor position is represented
-  as an array with two elements: the first is the line, the second is the column.
-  The order the views are is the same used by {Pane#each_view}. This value is the one to write under
-  the @state/cursor_positions@ entry in a project or configuration object
- * @:active_view@: the active view. It is represented by a size 2 array, with the
-  first element being the index of the tab of the active view and the second being
-  the index of the view in the corresponding pane (according to the order used by
-  {Pane#each_view}). If there's no active view, this entry is *nil*. This is the value to write under
-  the @state/active_view@ entry in a project or configuration object
-=end
-      def tabs_state
-        res = {}
-        doc_map = {}
-        doc_idx = 0
-        Ruber[:documents].each do |doc|
-          if !doc.has_file?
-            doc_map[doc] = doc_idx
-            doc_idx += 1
-          end
-        end
-        tabs = Ruber[:main_window].tabs
-        tabs_tree = []
-        cursor_positions = []
-        tabs.each do |t|
-          tabs_tree << tab_to_tree(t, doc_map)
-          cursor_positions << t.map do |v|
-            pos = v.cursor_position
-            [pos.line, pos.column]
-          end
-        end
-        res[:tabs] = tabs_tree
-        res[:cursor_positions] = cursor_positions
-        active = Ruber[:main_window].active_editor
-        if active
-          active_tab = Ruber[:main_window].tab(active)
-          res[:active_view] = [tabs.index(active_tab), active_tab.to_a.index(active)]
-        end
-        res
-      end
-      
-      private
-      
-=begin rdoc
-Creates a hash with all the data needed to restore Ruber's state
-
-@return [Hash] a hash with the following keys:
- * @:open_projects@: an array containing the project file of each open project.
-  the first entry is the active project
- * @:open_documents@: an array with the name of the file corresponding to each
-  open document (documents without an associated file can't be restored and aren't
-  included). The order is that of opening
- * @:visible_documents@: an array with the name of the files corresponding to the
-  documents associated with a file and having a view
- * @:active_document@: the name of the file associated with the active document or
-  *nil* if there's no open document
-=end
-      def gather_settings
-        res = {
-          :open_projects => projects_state,
-          :open_documents => documents_state
-        }
-        res.merge! tabs_state
-        res
-      end
-      
-=begin rdoc
-A representation of a pane's configuration suitable to be written to a configuration
-object
-
-@param [Pane] pane the pane to return the representation for
-@param [Hash{Document=>Integer}] docs a map between documents not associated
-  with files and the number to represent them
-@return [Array<Array,Integer,String>] an array as described in {#restore_pane}
-=end
-      def tab_to_tree pane, docs
-        if pane.single_view?
-          doc = pane.view.document
-          return [doc.has_file? ? doc.url.url : docs[doc]]
-        end
-        panes = {}
-        tab_to_tree_prc = lambda do |pn|
-          if pn.single_view?
-            doc = pn.view.document
-            panes[pn.parent_pane] << (doc.has_file? ? doc.url.url : docs[doc])
-          else 
-            data = [pn.orientation]
-            panes[pn] = data
-            panes[pn.parent_pane] << data if pn.parent_pane
-          end
-        end
-        tab_to_tree_prc.call pane
-        pane.each_pane :recursive, &tab_to_tree_prc
-        panes[pane]
-      end
       
     end
     
@@ -594,7 +424,7 @@ is created
 @return [nil]
 =end
       def auto_restore view
-        restore view if Ruber[:state].restore_cursor_position?
+        restore view if Ruber[:config][:state, :restore_cursor_position] #.restore_cursor_position?
         connect view, SIGNAL('focus_in(QWidget*)'), self, SLOT('view_received_focus(QWidget*)')
         nil
       end
@@ -641,6 +471,8 @@ when the project was last closed
       
       include Extension
       
+      include EnvironmentState
+      
       slots :auto_restore, :save_settings
       
 =begin rdoc
@@ -649,21 +481,8 @@ when the project was last closed
       def initialize prj
         super
         @project = prj
-        connect @project, SIGNAL(:activated), self, SLOT(:auto_restore)
-        connect @project, SIGNAL(:deactivated), self, SLOT(:save_settings)
-      end
-      
-=begin rdoc
-Restore Ruber's state as it was when the project was last closed
-
-See {Plugin#restore_documents} for more information
-
-@return [nil]
-=end
-
-      def restore
-        Ruber[:state].restore_documents @project
-        nil
+#         connect @project, SIGNAL(:activated), self, SLOT(:auto_restore)
+#         connect @project, SIGNAL(:deactivated), self, SLOT(:save_settings)
       end
       
 =begin rdoc
@@ -675,27 +494,13 @@ in the views and the active view
 @return [nil]
 =end
       def save_settings
-        @project[:state, :open_documents] = Ruber[:state].documents_state
-        tabs_state = Ruber[:state].tabs_state
-        [:tabs, :cursor_positions, :active_view].each do |e|
-          @project[:state, e] = tabs_state[e]
-        end
+        state = tabs_state Ruber[:world].environment @project
+        @project[:state, :tabs] = state[:tabs]
+        @project[:state, :active_view] = state[:active_view]
+        @project[:state, :cursor_positions] = state[:cursor_positions]
         nil
       end
       
-      private
-
-=begin rdoc
-Restores the project's state when a new project is activated
-
-It does nothing if the user choosed not to restore the projects's state.
-@return [nil]
-=end
-      def auto_restore
-        @project.disconnect SIGNAL(:activated), self, SLOT(:auto_restore)
-        restore if Ruber[:state].restore_project_files?
-      end
-      
     end
     
 =begin rdoc
@@ -706,7 +511,12 @@ Configuration widget for the State plugin
 =begin rdoc
 A list of different behaviour the plugin can have at startup
 =end
-      STARTUP_BEHAVIOURS = [:restore_all, :restore_documents_only, :restore_projects_only, :restore_nothing]
+      STARTUP_BEHAVIOURS = [
+        [:default_environment, :projects],
+        [:projects],
+        [:default_environment],
+        []
+      ]
       
 =begin rdoc
 @param [Qt::Widget, nil] parent the parent widget