ruber 0.0.8 → 0.0.9

data/lib/ruber/world/world.rb

@@ -0,0 +1,307 @@
+=begin 
+    Copyright (C) 2011 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/plugin_like'
+require 'ruber/world/document_factory'
+require 'ruber/world/project_factory'
+require 'ruber/world/environment'
+require 'ruber/world/project_list'
+require 'ruber/world/document_list'
+require_relative 'ui/workspace_settings_widget'
+
+module Ruber
+  
+  module World
+    
+    class World < Qt::Object
+
+=begin rdoc
+Exception raised from {Ruber::World::World#new_project} when the given file already
+  exists
+=end
+      class ExistingProjectFileError < StandardError
+      end
+
+      include PluginLike
+      
+      attr_reader :default_environment
+      
+      attr_reader :active_environment
+      
+      attr_reader :active_document
+      
+      signals 'active_environment_changed(QObject*)'
+      
+      signals 'active_environment_changed_2(QObject*, QObject*)'
+      
+      signals 'active_project_changed(QObject*)'
+      
+      signals 'active_project_changed_2(QObject*, QObject*)'
+      
+      signals 'document_created(QObject*)'
+      
+      signals 'project_created(QObject*)'
+      
+      signals 'closing_project(QObject*)'
+      
+      signals 'closing_document(QObject*)'
+      
+      signals 'active_document_changed(QObject*)'
+      
+      signals 'active_editor_changed(QWidget*)'
+      
+
+=begin rdoc
+@param [ComponentManager] manager the component manager (unused)
+@param [PluginSpecification] psf the plugin specification object associated with
+  the component
+=end
+      def initialize _, psf
+        super Ruber[:app]
+        @documents = MutableDocumentList.new []
+        @projects = MutableProjectList.new []
+        @environments = {}
+        initialize_plugin psf
+        @active_environment = nil
+        @active_document = nil
+        @document_factory = DocumentFactory.new self
+        connect @document_factory, SIGNAL('document_created(QObject*)'), self, SLOT('slot_document_created(QObject*)')
+        @project_factory = ProjectFactory.new self
+        connect @project_factory, SIGNAL('project_created(QObject*)'), self, SLOT('slot_project_created(QObject*)')
+        @default_environment = Environment.new(nil, self)
+        add_environment @default_environment, nil
+      end
+      
+      def environment prj
+        @environments[prj] 
+#         unless env
+#           env = Environment.new(prj)
+#           connect env, SIGNAL('closing(QObject*)'), self, SLOT('environment_closing(QObject*)')
+#           connect env, SIGNAL('active_editor_changed(QWidget*)'), self, SLOT('slot_active_editor_changed(QWidget*)')
+#           @environments[prj] = env
+#         end
+      end
+      
+      def active_environment= env
+        return if @active_environment == env
+        old = @active_environment
+        old.deactivate if old
+        @active_environment = env
+        emit active_environment_changed(env)
+        emit active_environment_changed_2(env, old)
+        @active_environment.activate if @active_environment
+      end
+      
+      def environments
+        @environments.values
+      end
+      
+      def each_environment
+        if block_given? 
+          @environments.each_value{|e| yield e}
+          self
+        else to_enum(:each_environment)
+        end
+      end
+      
+      def active_project= prj
+        old = @active_environment.project if @active_environment
+        return old if old == prj
+        old.deactivate if old
+        self.active_environment = @environments[prj]
+        emit active_project_changed prj
+        emit active_project_changed_2 prj, old
+        prj.activate if prj
+      end
+      
+      def active_project
+        @active_environment.project if @active_environment
+      end
+      
+      def projects
+        ProjectList.new @environments.keys.compact
+      end
+      
+      def each_project
+        if block_given?
+          @environments.each_key{|prj| yield prj if prj}
+          self
+        else self.to_enum(:each_project)
+        end
+      end
+      
+=begin rdoc
+Creates a new document
+@return [Document] the new document. It will be a child of *self*
+=end
+      def new_document
+        doc = @document_factory.document nil, self
+        doc
+      end
+      
+=begin rdoc
+The document associated with the given file or URL
+
+If a document for the given file or URL already exists, that document will be
+returned, otherwise a new one will be created.
+
+@param [String,KDE::Url] file the absolute name or the URL of the
+file to retrieve the document for
+@return [Document,nil] a document associated with _file_ and having *self* as parent.
+  If _file_ represents a local file and that file doesn't exist, *nil* is returned
+=end
+      def document file
+        @document_factory.document file, self
+      end
+      
+      def documents
+        DocumentList.new @documents
+      end
+      
+      def each_document
+        if block_given?
+          @documents.each{|doc| yield doc}
+          self
+        else self.to_enum :each_document
+        end
+      end
+      
+=begin rdoc
+Creates a new project
+@param [String] file the absolute path of the project file
+@param [String] name the name of the project
+@return [Project] a new project having _file_ as project file and _name_ as project
+  name
+@raise [ExistingProjectFileError] if a file called _file_ already exists (regardless
+  of whether it's a valid project file or not)
+=end
+      def new_project file, name
+        raise ExistingProjectFileError, "#{file} already exists" if File.exist?(file)
+        @project_factory.project file, name
+      end
+   
+=begin rdoc
+Retrieves the project associated with a given project file
+
+If a project associated with the project file _file_ already exists, that project
+is returned. Otherwise, a new project object is created.
+
+@param [String] file the absolute path of the project file. Note that this file
+  *must* already exist and be a valid project file
+@return [Project] a project associated with _file_
+@raise [AbstractProject::InvalidProjectFile] if the project file is not a valid
+  project file
+=end
+      def project file
+        @project_factory.project file
+      end
+      
+      def close_all what, save_behaviour = :save
+        close_docs = (what == :all || what == :documents)
+        close_prjs = (what == :all || what == :projects)
+        save = save_behaviour == :save
+        @projects.dup.each{|prj| prj.close save} if close_prjs
+        @documents.dup.each{|doc| doc.close save} if close_docs
+      end
+      
+      def save_settings
+        @documents.each{|doc| doc.save_settings}
+        @projects.each{|prj| prj.save}
+      end
+      
+      def query_close
+        @documents.each{|doc| return false unless doc.own_project.query_close}
+        return false unless Ruber[:main_window].save_documents @documents.to_a
+        @projects.each{|prj| return false unless prj.query_close}
+        true
+      end
+      
+      private
+      
+      def add_environment env, prj
+        @environments[prj] = env
+        connect env, SIGNAL('closing(QObject*)'), self, SLOT('environment_closing(QObject*)')
+        connect env, SIGNAL('active_editor_changed(QWidget*)'), self, SLOT('slot_active_editor_changed(QWidget*)')
+      end
+      
+      def environment_closing env
+        @environments.delete env.project
+        self.active_environment = nil if @active_environment == env
+      end
+      slots 'environment_closing(QObject*)'
+      
+      def slot_document_created doc
+        @documents.add doc
+        connect doc, SIGNAL('closing(QObject*)'), self, SLOT('slot_document_closing(QObject*)')
+        emit document_created(doc)
+      end
+      slots 'slot_document_created(QObject*)'
+      
+      def slot_project_created prj
+        @projects.add prj
+        connect prj, SIGNAL('closing(QObject*)'), self, SLOT('slot_closing_project(QObject*)')
+        add_environment prj.extension(:environment), prj
+        emit project_created(prj)
+      end
+      slots 'slot_project_created(QObject*)'
+      
+      def slot_document_closing doc
+        emit closing_document(doc)
+        @documents.remove doc
+      end
+      slots 'slot_document_closing(QObject*)'
+      
+      def slot_closing_project prj
+        emit closing_project(prj)
+        @projects.remove prj
+      end
+      slots 'slot_closing_project(QObject*)'
+      
+      def load_settings
+        tabs_closable = Ruber[:config][:workspace, :close_buttons]
+        @environments.each_value{|e| e.tab_widget.tabs_closable = tabs_closable}
+      end
+      slots :load_settings
+      
+      def slot_active_editor_changed editor
+        doc = editor ? editor.document : nil
+        if doc != @active_document
+          @active_document = doc
+          emit active_document_changed(@active_document)
+        end
+        emit active_editor_changed(editor)
+      end
+      slots 'slot_active_editor_changed(QWidget*)'
+      
+    end
+    
+    class WorkspaceSettingsWidget < Qt::Widget
+      
+      def initialize parent = nil
+        super
+        @ui = Ui::WorkspaceSettingsWidgetBase.new
+        @ui.setup_ui self
+      end
+      
+    end
+    
+  end
+  
+end

data/plugins/auto_end/auto_end.rb

@@ -20,32 +20,113 @@
 
 module Ruber
   
+=begin rdoc
+Plugin which automatically inserts an @end@ keyword after the user presses Enter
+after a line starting a construct which requires it.
+
+The algorithm used to find out whether an end should be inserted after the current
+line is very simple: the line is checked against several possible regexps. The @end@
+is inserted if any of the regexps matches.
+
+The above algorithm has the limitation of not being able to tell whether the line
+is inside a multiline string or a block comment, and can thus lead to spurious @end@s
+being added.
+
+Another problem with the way the plugin works now is that it has no way to know
+whether a given keyword already has its closing @end@. To try to lessen this issue,
+before inserting an @end@, this plugin checks the indentation of the following line,
+comparing it to the indentation of the line where Enter has been pressed. If the
+former is greater than the latter, it assumes that the user is editing an already-existing
+construct and doesn't insert the @end@.
+
+@note This plugin does nothing unless the text is inserted in the document while
+  one of the views associated with it has focus
+=end
   module AutoEnd
     
+=begin rdoc
+Extension object for the Auto End plugin
+
+The procedure of inserting an @end@ is split in two parts, performed in separate
+moments:
+# finding out whether the current line needs an end inserted after it. This is
+  done in response to the {Document#text_inserted} signal
+# inserting the text. This is done in response to the {Document#text_changed} signal
+
+The reason for this two-step behaviour is that {Document#text_inserted} is emitted
+multiple times in case of a Paste operation. Thus, inserting the @end@ keywords
+in it would cause them to be added in the middle of the pasted text, which is
+wrong. What we do instead is to analyze each line in response to {Document#text_inserted},
+storing the line position and the text to insert if appropriate, overwriting any
+other information so that only the last position is recorded. When all text has
+been processed, the document emits the {Document#text_changed} signal and, in response
+to this we insert the end keyword (if appropriate).
+=end
     class Extension < Qt::Object
       
       include Ruber::Extension
       
+=begin rdoc
+Contains the information about the next insertion to do
+
+@attr [Integer] line_number the number of the line where the insertion should be done
+@attr [String] lines the text to insert
+@attr [Array(Integer,Integer)] final_position the position to move after the insertion
+  The first element is the line number, relative to the insertion line (for example,
+  a value of 1 means to move the cursor to the line after the insertion line, while
+  a value of -1 means to move it to the line before). The second element is the
+  column number. If negative, it's counted from the end of the line
+=end
       Insertion = Struct.new :line_number, :lines, :final_position
       
+=begin rdoc
+The regexp fragment which matches an identifier. In theory, this should
+just be @\w+@. However, from ruby 1.9.2, @\w@ only matches ASCII characters, while
+identifiers can also contain unicode characters. To allow for this, the @\p{Word}@
+character class is used from ruby 1.9.2 onward, while @\w@ is used for previous
+versions
+=end
       IDENTIFIER_PATTERN = RUBY_VERSION >= '1.9.2' ? '\p{Word}+' : '\w+'
       
+=begin rdoc
+The regexp fragment which matches a multiple identifier (that is, an identifier
+maybe followed by several other identifiers separated by @::@)
+=end
       MULTI_ID_PATTERN = "#{IDENTIFIER_PATTERN}(?:::#{IDENTIFIER_PATTERN})*"
       
+=begin rdoc
+The patterns used to find out whether an @end@ keyword should be inserted after
+a line.
+
+Each entry is itself an array with three elements:
+* the regexp to match agains the line
+* the text to insert if the regexp match
+* an array with two elements, representing the position where the cursor should be
+  moved to after the insertion, as described in {Insertion#final_position}
+=end
       PATTERNS = [
         [/^\s*if\s/, "\nend", [0, -1]],
         [/=\s*if\s/, "\nend", [0, -1]],
+        [/^\s*unless\s/, "\nend", [0, -1]],
+        [/=\s*unless\s/, "\nend", [0, -1]],
         [/\bdo\s*$/, "\nend", [0, -1]],
         [/\bdo\s+\|/, "\nend", [0, -1]],
         [/^\s*def\s/, "\nend", [0, -1]],
         [/^class\s+#{IDENTIFIER_PATTERN}\s*$/, "\nend", [0, -1]],
         [/^class\s+#{MULTI_ID_PATTERN}\s*<{1,2}\s*#{MULTI_ID_PATTERN}\s*$/, "\nend", [0, -1]],
         [/^\s*module\s+#{MULTI_ID_PATTERN}\s*$/, "\nend", [0,-1]],
-        [/^=begin(\s|$)/, "\n=end", [0, -1]],
+        [/^\s*while\s/, "\nend", [0,-1]],
+        [/^\s*until\s/, "\nend", [0,-1]],
+#         [/^=begin(\s|$)/, "\n=end", [0, -1]],
         [/^\s*begin\s/, "\nend", [0, -1]],
-        [/=\s*begin\s/, "\nend", [0, -1]],
+        [/(^=\s+|.=\s*)begin\s/, "\nend", [0, -1]],
+        [/^\s*for\s+#{IDENTIFIER_PATTERN}\s+in.+$/, "\nend", [0,-1]],
+        [/=\s*for\s+#{IDENTIFIER_PATTERN}\s+in.+$/, "\nend", [0,-1]]
       ]
       
+=begin rdoc
+@param [DocumentProject] prj the project associated with the document
+=end
       def initialize prj
         super
         @doc = prj.document
@@ -53,6 +134,20 @@ module Ruber
         connect_slots
       end
       
+      private
+=begin rdoc
+Slot called when some text is inserted
+
+If one of the recognized patterns match the current line, memorizes an {Insertion}
+object pointing to the current line and using the parameters associated with the
+matching pattern.
+
+If the inserted text doesn't end in a newline, nothing is done.
+
+If the current line doesn't match any pattern, the currently memorized insertion
+position (if any) is forgotten
+@param [KTextEditor::Range] the range corresponding to the inserted text
+=end
       def text_inserted range
         text = @doc.text range
         return unless text.end_with? "\n"
@@ -66,9 +161,20 @@ module Ruber
             @insertion = Insertion.new range.end.line, pattern[1], pattern[2]
           end
         end
+        nil
       end
       slots 'text_inserted(KTextEditor::Range)'
       
+=begin rdoc
+Slot called in response to the {Document#text_changed} signal
+
+If there's an insertion position memorized, inserts the corresponding text after
+the current line, then moves the cursor to the position stored with the insertion
+object.
+
+The current insertion is forgotten.
+@return [nil]
+=end
       def text_changed
         if @insertion
           insert_text KTextEditor::Cursor.new(@insertion.line_number, 0), 
@@ -78,22 +184,46 @@ module Ruber
       end
       slots :text_changed
       
+=begin rdoc
+Override of {Extension#remove_from_project}
+@return [nil]
+=end
       def remove_from_project
         disconnect_slots
       end
       
-      private
-      
+=begin rdoc
+Makes connections to the document's signals
+@return [nil]
+=end
       def connect_slots
         connect @doc, SIGNAL('text_inserted(KTextEditor::Range, QObject*)'), self, SLOT('text_inserted(KTextEditor::Range)')
         connect @doc, SIGNAL('text_changed(QObject*)'), self, SLOT(:text_changed)
+        nil
       end
       
+=begin rdoc
+Disconnects connections to the document's signals
+@return [nil]
+=end
       def disconnect_slots
         disconnect @doc, SIGNAL('text_inserted(KTextEditor::Range, QObject*)'), self, SLOT('text_inserted(KTextEditor::Range)')
         disconnect @doc, SIGNAL('text_changed(QObject*)'), self, SLOT(:text_changed)
       end
       
+=begin rdoc
+Inserts text at the given position and moves the cursor to the specified position
+
+To avoid the possibility of infinite recursion, before inserting text {#disconnect_slots}
+is called. After the text has been inserted {#connect_slots} is called.
+
+@note nothing is done unless the active view (according to {Document#active_view})
+  is associated with the document
+@param [KTextEditor::Cursor] insert_pos the position where the text should be inserted
+@param [String] lines the text to insert
+@param [Array(Integer,Integer)] dest the position to move the cursor to, relative
+  to the insertion position, as described in {Insertion#final_position}
+=end
       def insert_text insert_pos, lines, dest
         view = @doc.active_view
         return unless view
@@ -103,7 +233,7 @@ module Ruber
         @doc.insert_text insert_pos, lines 
         final_pos = KTextEditor::Cursor.new insert_pos.line + lines.size - 1,
             lines[-1].size
-        do_indentation view
+        view.execute_action 'tools_align'
         dest_line = insert_pos.line+dest[0]
         dest_col = dest[1]
         dest_col += @doc.line_length(dest_line) + 1 if dest_col < 0
@@ -111,10 +241,6 @@ module Ruber
         connect_slots
       end
       
-      def do_indentation view
-        view.execute_action 'tools_align'
-      end
-      
     end
     
   end