ruber 0.0.9 → 0.0.10

data/plugins/ruberri/ui/tool_widget.ui

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>RIToolWidget</class>
+ <widget class="QWidget" name="RIToolWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>676</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="0">
+    <widget class="QLabel" name="label">
+     <property name="text">
+      <string>Find</string>
+     </property>
+     <property name="buddy">
+      <cstring>search_term</cstring>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="1">
+    <widget class="KLineEdit" name="search_term"/>
+   </item>
+   <item row="0" column="2">
+    <widget class="QPushButton" name="search">
+     <property name="text">
+      <string>&amp;Search</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0" colspan="3">
+    <widget class="QTextBrowser" name="content"/>
+   </item>
+  </layout>
+ </widget>
+ <tabstops>
+  <tabstop>search_term</tabstop>
+  <tabstop>search</tabstop>
+  <tabstop>content</tabstop>
+ </tabstops>
+ <resources/>
+ <connections/>
+</ui>

data/plugins/ruby_runner/ruby_runner.rb

@@ -346,7 +346,7 @@ object
 current project, even if _target_ is a {Document} or the name of a file belonging
 to it
 @param [Boolean] abs it has the same meaning as in {SettingsContainer#[]}
-@raise ArgumentError if the option can be found
+@raise [IndexError] if the option can't be found
 =end
       def option_for target, group, name, ignore_project = false, abs = false
         cont = []
@@ -363,7 +363,7 @@ to it
         abs = :abs if abs
         cont.each_with_index do |c, i|
           begin return c[group, name, abs]
-          rescue ArgumentError
+          rescue IndexError
             raise if i == cont.size - 1
           end
         end

data/plugins/ruby_syntax_checker/plugin.yaml

@@ -0,0 +1,11 @@
+name: ruby_syntax_checker
+version: 0.0.1
+about:
+ authors: [Stefano Crocco, stefano.crocco@alice.it]
+ license: gpl
+ description: Syntax checker for ruby documents. Requires the syntax checker plugin
+ bug_address: http://github.com/stcrocco/ruber/issues
+ icon: tools-check-spelling
+deps: [syntax_checker, ruby_development]
+class: Ruber::RubySyntaxChecker::Plugin
+require: ruby_syntax_checker

data/plugins/ruby_syntax_checker/ruby_syntax_checker.rb

@@ -0,0 +1,147 @@
+=begin 
+    Copyright (C) 2010, 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
+
+module Ruber
+  
+  module RubySyntaxChecker
+    
+    SyntaxError = Struct.new :line, :column, :message, :formatted_message, :error_type
+    
+    class Plugin < Ruber::Plugin
+      
+      def initialize psf
+        super
+        Ruber[:syntax_checker].register_syntax_checker RubySyntaxChecker::Checker, ['application/x-ruby'],
+            %w[*.rb rakefile Rakefile]
+      end
+
+      def unload
+        Ruber[:syntax_checker].remove_syntax_checker RubySyntaxChecker::Checker
+      end
+
+    end
+    
+    class Checker
+      
+      SPECIAL_ERROR_STRINGS = [
+        'unmatched close parenthesis:',
+        'end pattern with unmatched parenthesis:',
+        'unknown regexp option -',
+        'class|module definition in method body',
+        'dynamic constant assignment',
+        'unterminated string meets end of file',
+        'premature end of char-class:',
+        'embedded document meets end of file',
+        'can\'t find string "[^"]+" anywhere before EOF'
+      ]
+      
+      ERROR_TYPES=[
+        [/\bunexpected \$end,\s+expecting (?:keyword_end|kEND)/, :missing_end],
+        [/\bunexpected (?:keyword_end|kEND),\s+expecting \$end/, :extra_end],
+        [/\bexpecting '\)/, :missing_close_paren],
+        [/\bunexpected '\)/, :extra_close_paren],
+        [/\bexpecting '\]'/, :missing_close_bracket],
+        [/\bunexpected '\]/, :extra_close_bracket],
+        [/\bexpecting '\}'/, :missing_close_brace],
+        [/\bunexpected '\}/, :extra_close_brace],
+        [/\bunexpected (?:keyword_else|kELSE)/, :extra_else],
+        [/\bunexpected (?:keyword_when|kWHEN)/, :extra_when],
+        [/\bunexpected (?:keyword_rescue|kRESCUE)/, :extra_rescue],
+        [/\bunexpected (?:keyword_ensure|kENSURE)/, :extra_ensure],
+        [/\bunterminated string/, :missing_quote],
+        [/\bunexpected (?:keyword_end|kEND)/, :misplaced_end],
+        [/end pattern with unmatched parenthesis/, :missing_regexp_close_paren],
+        [/unmatched close parenthesis/, :extra_regexp_close_paren],
+        [/premature end of char-class/, :missing_regexp_close_bracket],
+        [/unknown regexp option/, :unknown_regexp_option],
+        [/dynamic constant assignment/, :dynamic_constant_assignment],
+        [/embedded document meets end of file/, :missing_block_comment_end],
+        [/can't find string "[^"]+" anywhere before EOF/, :missing_heredoc_end]
+      ]
+      
+      def initialize doc
+        @doc = doc
+        @regexp = %r{^-e:(\d+):\s+(?:syntax error,|(#{SPECIAL_ERROR_STRINGS.join '|'}))(?:\s+(.*)|$)}
+      end
+      
+      def check_syntax text, formatted
+        ruby = Ruber[:ruby_development].interpreter_for @doc
+        begin
+          msg = Open3.popen3(ruby, '-c', '-e', text) do |in_s, out_s, err_s|
+            error = err_s.read
+            out_s.read.strip != 'Syntax OK' ? error : ''
+          end
+        rescue SystemCallError
+          raise Ruber::SyntaxChecker::SyntaxNotChecked
+        end
+        parse_output msg, formatted
+      end
+      
+      private
+      
+      def parse_output str, formatted
+        # The inner array is needed in case the first message doesn\'t use a
+        # recognized format (for example, regexp syntax errors don\'t have a standard
+        # format). Without this, in the lins cycle, the else clause would be
+        # executed and would fail because the error_lines array is empty.
+        error_lines = [ [ [] ] ]
+        lines = str.split_lines
+        return if lines.empty?
+        lines.each do |l|
+          if l.match @regexp
+            error = [[$2 ? "#{$2} #{$3}" : $3], $1.to_i - 1]
+            error_type = ERROR_TYPES.find{|a| a[0] =~ l}
+            error << error_type[1] if error_type
+            error_lines << error
+          else error_lines[-1][0] << l
+          end
+        end
+        error_lines.shift if error_lines.first.first.empty?
+        errors = error_lines.map do |a, number, type|
+          error = SyntaxError.new number, nil, a.shift, nil, type
+          a.each_with_index do |l, i|
+            if l.match %r{^\s*\^\s*$} 
+              error.column = l.index '^'
+              previous_line = a[i-1]
+              if previous_line and previous_line.match /^\.{3}/
+                offset = ( @doc.line(error.line) =~ /#{Regexp.quote(previous_line[3..-1])}/)
+                error.column += offset if offset
+              end
+            else error.message << "\n" << l
+            end
+          end
+          if formatted
+            msg = error.message.dup
+            msg.gsub! /expect(ed|ing)\s+\$end/, 'expect\1 end of file'
+            msg.gsub! /expect(ed|ing)\s+kEND/, 'expect\1 `end` keyword'
+            msg.gsub! /expect(ed|ing)\s+keyword_end/, 'expect\1 `end` keyword'
+            error.formatted_message = msg
+          else error.formatted_message = error.message.dup
+          end
+          error
+        end
+        errors
+      end
+      
+    end
+      
+  end
+  
+end

data/plugins/syntax_checker/plugin.yaml

@@ -3,16 +3,20 @@ version: 0.0.1
 about:
  authors: [Stefano Crocco, stefano.crocco@alice.it]
  license: :gpl
- description: Checks the syntax of the current document
+ description: Infrastructure to check the syntax of documents (needs other plugins to perform the actual syntax check)
  icon: tools-check-spelling
  bug_address: http://github.com/stcrocco/ruber/issues
-class: Ruber::SyntaxChecker::SyntaxCheckerPlugin
+class: Ruber::SyntaxChecker::Plugin
 require: syntax_checker
-deps: ruby_development
 config_options:
  syntax_checker:
-  automatic_check: {default: true}
+  time_interval: {default: 1}
+project_options:
+ syntax_checker:
+  auto_check: {scope: document, default: true}
 config_widgets:
- {caption: Syntax, code: 'Qt::CheckBox.new("&Automatically check syntax"){self.object_name = "_syntax_checker__automatic_check"}', pixmap: tools-check-spelling.png}
+ {caption: Syntax, class: Ruber::SyntaxChecker::ConfigWidget, pixmap: tools-check-spelling.png}
+project_widgets:
+ {caption: Syntax, code: 'Qt::CheckBox.new("&Automatically check syntax for this document"){self.object_name = "_syntax_checker__auto_check"}', pixmap: tools-check-spelling.png, scope: document}
 extensions:
- syntax_checker: {class: Ruber::SyntaxChecker::SyntaxCheckerExtension, scope: document}
+ syntax_checker: {class: Ruber::SyntaxChecker::Extension, scope: document}

data/plugins/syntax_checker/syntax_checker.rb

@@ -22,6 +22,7 @@ require 'tempfile'
 require 'open3'
 
 require 'facets/boolean'
+require_relative 'ui/config_widget'
 
 module Ruber
   
@@ -61,604 +62,299 @@ syntax checks after one second of inactivity
 =end
   module SyntaxChecker
 
+#     SyntaxError = Struct.new :line, :column, :message, :formatted_message
+    
+    class SyntaxNotChecked < Exception
+    end
+#     
+#     class SyntaxError
+#       
+#       def format
+#         res = ""
+#         res << KDE.i18n("Line %d") % (line + 1) if line
+#         res << KDE.i18n(", column %d") % (column + 1) if line and column
+#         msg = formatted_message || message
+#         res << ": " if msg and !res.empty?
+#         res << msg
+#         res
+#       end
+#       
+#     end
+    
 =begin rdoc
-Plugin object for the @sytax_checker@ feature
+Plugin object for the @syntax_checker@ feature
 
 @api class SyntaxChecker::SyntaxCheckerPlugin
 @api_method #register_syntax_checker
 @api_method #remove_syntax_checker
 =end
-    class SyntaxCheckerPlugin < Plugin
+    class Plugin < Ruber::Plugin
       
-=begin rdoc
-Class containing the information about a syntax error. It has four attributes:
-line:= the line at which the syntax error occurred (note that this starts from
-1, while Document and EditorView count lines from 0)
-message:= a string describing the syntax error
-code:= a string with the code around the point where the syntax error occurred
-column:= the column at which the syntax error occurred
-
-This class'constructor can take up to four parameters, corresponding (in
-the same order) to the four attributes described above.
-=end
-      ErrorDescription = Struct.new(:line, :message, :code, :column)
+      attr_reader :current_status
+      
+      attr_reader :current_errors
       
-=begin rdoc
-Colors used to display the different states of the document
-=end
       COLORS = {
         :correct => Qt::Color.new(Qt.green),
-        :error => Qt::Color.new(Qt.red),
-        :unknown => Qt::Color.new(Qt.gray)
-        }
+        :unknown => Qt::Color.new(Qt.gray),
+        :incorrect => Qt::Color.new(Qt.red)
+      }
       
-=begin rdoc
-Signal emitted when it's time to perform an automatic syntax check
-=end
-      signals :timeout
-
-=begin rdoc
-Creates an instance of the plugin
-
-It also registers the two built-in syntax checkers
+      MESSAGES = {
+        :correct => 'No syntax errors',
+        :unknown => 'Unknown document type',
+        :incorrect => 'There are syntax errors'
+      }
 
-@param [Ruber::PluginSpecification] the specification associated to the
-plugin
-=end
+      class Led < KDE::Led
+        
+        signals 'context_menu_requested(QPoint)'
+        
+        signals :left_clicked
+        
+        def contextMenuEvent e
+          emit context_menu_requested(e.global_pos)
+        end
+        
+        def mouseReleaseEvent e
+          emit left_clicked if e.button == Qt::LeftButton
+        end
+        
+      end
+      
+      signals :settings_changed
+      
+      signals :syntax_checker_added
+      
+      signals :syntax_checker_removed
+      
       def initialize psf
         super
-        @availlable_syntax_checkers = {}
-        register_syntax_checker RubySyntaxChecker, 'application/x-ruby',
-            %w[*.rb rakefile Rakefile]
-        register_syntax_checker YamlSyntaxChecker, [], %w[*.yml *.yaml]
-        @led = SyntaxResultWidget.new
+        self.connect(SIGNAL('extension_added(QString, QObject*)')) do |name, prj|
+          connect prj.extension(name.to_sym), SIGNAL('syntax_checked(QObject*)'), self, SLOT('document_checked(QObject*)')
+        end
+        @syntax_checkers = {}
+        @led = Led.new
+        connect @led, SIGNAL('context_menu_requested(QPoint)'), self, SLOT('display_context_menu(QPoint)')
+        connect @led, SIGNAL(:left_clicked), self, SLOT(:jump_to_first_error)
         Ruber[:main_window].status_bar.add_permanent_widget @led
-        mark_document_as :unknown
+        set_current_status :unknown
       end
       
-=begin rdoc
-Instantiates an appropriate syntax checker for a document
-
-@param [Document] doc the document to create the syntax checker for
-@return [Object,nil] a syntax checker suitable for _doc_ or *nil* if _doc_ is not
-associated with a file or no syntax checker has been registered for <i>doc</i>'s extension
-or mimetype
-=end
-      def syntax_checker_for doc
-        checker_cls = @availlable_syntax_checkers.find! do |cls, data|
-          doc.file_type_match?(*data) ? cls : nil
-        end
-        checker_cls ? checker_cls.new(doc) : nil
+      def unload
+        Ruber[:main_window].status_bar.remove_widget @led
+        super
+        self
       end
       
-=begin rdoc
-Tells the plugin to display the result of the syntax check for the current document
-
-@param [Symbol] status the result of the syntax check. It can be one of @:correct@,
-@:error@ or @:unknown@ (if no syntax checker was availlable for the document)
-@param [Array<SyntaxCheckerPlugin::ErrorDescription>] errors an array containing
-instances of class {SyntaxCheckerPlugin::ErrorDescription} describing each of the
-syntax error which where found in the document. This argument is only used if
-_status_ is @:error@
-@return [SyntaxCheckerPlugin] *self*
-=end
-      def mark_document_as status, errors = []
-        msg = case status
-        when :correct then 'Syntax OK'
-        when :unknown then 'Document type unknown'
-        when :error then errors.map{|e| format_error_message e}.join "\n"
+      def format_error error
+        msg = ''
+        if error.line
+          msg << KDE.i18n("Line %d") % (error.line + 1)
+          msg << (error.column ? (KDE.i18n(", column %d: ")) % (error.column + 1) : ': ')
         end
-        @led.tool_tip = msg
+        msg << KDE.i18n(error.formatted_message || error.message || 'UNKNOWN ERROR')
+        msg
+      end
+      
+      def set_current_status status, errors = []
         @led.color = COLORS[status]
-        self
+        if status == :incorrect and !errors.empty?
+          tool_tip = errors.map do |e|
+            format_error e
+          end.join "\n"
+          @led.tool_tip = tool_tip
+        else @led.tool_tip = i18n(MESSAGES[status])
+        end
+        @current_status = status
+        if @current_status == :incorrect
+          @current_errors = errors.dup
+        else @current_errors = nil
+        end
       end
       
-=begin rdoc
-Registers a new syntax checker.
-
-A syntax checker is an object which analyzes the contents of a document and tells
-whether its syntax is correct or not. To register it with the plugin, you need
-to pass the object's class, toghether with the mimetypes and file patterns it
-should be used to check syntax for, to this method. When a new document with the
-appropriate mimetype or file name is created, a new instances of the syntax checker
-class will be created.
-
-The syntax checker class must have the following characteristics:
-* its constructor should take the document as only parameter
-* it should have a @check@ method which takes a string (corresponding to the text
-of the document) and performs the syntax check on it. It must return a string
-with all the information needed to retrieve the information about the single
-errors.
-* it should have a @convert_check_result@ method, which takes the string
-returned by the @check@ method and converts it to an array of {ErrorDescription}
-objects, with each object containing the information about a single error. If
-the document doesn't contain any syntax error, this method should return an
-empty array.
-
-
-@param [Class] cls the class to instantiate to create the syntax checker
-@param [String, <String>] mimetypes the mimetypes to use the new syntax checker
-for. It has the format described in {Document#file_type_match?}
-@param [String, <String>] patterns the file patterns to use the new syntax checker
-for. It has the format described in {Document#file_type_match?}
-@return [SyntaxCheckerPlugin] *self*
-@raise ArgumentError if _cls_ had already been registered as a syntax checker.
-=end
       def register_syntax_checker cls, mimetypes, patterns = []
-        if @availlable_syntax_checkers.include? cls
-          raise ArgumentError, "class #{cls} has already been registered as syntax checker"
-        else
-          @availlable_syntax_checkers[cls] = [mimetypes, patterns]        end
+        if @syntax_checkers.include? cls
+          raise ArgumentError, "#{cls} has already been registered as syntax checker"
+        end
+        @syntax_checkers[cls] = [mimetypes, patterns]
+        emit syntax_checker_added
       end
       
-=begin rdoc
-Removes a registered syntax checker.
-
-Nothing is done if the syntax checker hadn't been registered.
-
-@param [Class] cls the class of the syntax checker to remove
-@return [Boolean] *true* if the syntax checker was removed and *false* if it wasn't
-registered
-=end
       def remove_syntax_checker cls
-        res = @availlable_syntax_checkers.delete cls
-        res.to_bool
-      end  
-
-=begin rdoc
-Prepares the plugin for application shutdown
-@return [SyntaxCheckerPlugin] *self*
-=end
-      def shutdown
-        @timer.stop
-        self
+        emit syntax_checker_removed if @syntax_checkers.delete cls
       end
       
-=begin rdoc
-Prepares the plugin to be unloaded
-
-@return [SyntaxCheckerPlugin] *self*
-=end
-      def unload
-        Ruber[:main_window].status_bar.remove_widget @led
-        super
-        self
+      def syntax_checker_for doc
+        cls = @syntax_checkers.find do |_, rules| 
+          doc.file_type_match?(rules[0], rules[1])
+        end
+        return unless cls
+        cls[0]
       end
       
-=begin rdoc
-Generates an error message from an error object
-
-The returned string contains the error message together with information about
-the line and the column (if known) where the error happened
-
-@param [ErrorDescription] error the object containing the error message
-@return [String] a string containing the error message, including line and row
-where the error happened, formatted in a standard way
-=end
-      def format_error_message error
-        res = "Line #{error.line}"
-        res += " Col #{error.column}" if error.column
-        res += ": #{error.message}"
-        res
+      def load_settings
+        emit settings_changed
       end
       
-=begin
-Starts the timer for the automatic check
-
-@return [SyntaxCheckerPlugin] *self*
-=end
-      def start_timer
-        if @timer
-          @timer.stop
-          @timer.start
+      private
+      
+      def display_context_menu pt
+        return if @current_status == :unknown
+        if !@current_errors || @current_errors.empty?
+          actions = [KDE::Action.new(i18n(MESSAGES[@current_status]), @led)]
+        else actions = @current_errors.map{|e| KDE::Action.new format_error(e), @led}
         end
-        self
+        choice = Qt::Menu.exec actions, pt
+        return if !choice or !@current_errors or @current_errors.empty?
+        error = @current_errors[actions.index(choice)]
+        line = error.line
+        col = error.column || 0
+        Ruber[:world].active_environment.active_editor.go_to line, col if line
       end
+      slots 'display_context_menu(QPoint)'
       
-=begin
-Stops the timer for the automatic check
-
-@return [SyntaxCheckerPlugin] *self*
-=end
-      def stop_timer
-        @timer.stop if @timer
-        self
+      def jump_to_first_error
+        return unless @current_errors and !@current_errors.empty?
+        e = @current_errors[0]
+        col = e.column || 0
+        if e.line
+          Ruber[:world].active_environment.active_editor.go_to e.line, col
+        end
       end
+      slots :jump_to_first_error
       
-=begin rdoc
-Loads the settings
-
-If automatic checking has been enabled, a timer is created; if it has been disabled,
-the timer is destroyed
-
-@return [nil]
-=end
-      def load_settings
-        auto_check = Ruber[:config][:syntax_checker, :automatic_check]
-        if auto_check and !@timer
-          @timer = Qt::Timer.new self
-          @timer.interval = 1000
-          connect @timer, SIGNAL(:timeout), self, SIGNAL(:timeout)
-          @timer.start if Ruber[:main_window].current_document
-        elsif !auto_check
-          @timer.disconnect self
-          @timer.dispose
-          @timer = nil
-        end
-        nil
+      def document_checked doc
+        return unless doc.active?
+        ext = doc.extension(:syntax_checker)
+        set_current_status ext.status, ext.errors
       end
+      slots 'document_checked(QObject*)'
       
     end
-
-=begin rdoc
-Document extension which checks the syntax for a document. The syntax check happens:
-* when the document becomes active
-* when the document is saved
-* one second after the last modification (if the user has enabled automatic checks)
-
-The check can only be done if a syntax checker for the document's mimetype
-or file extension exists. New syntax checkers must be added to the syntax checker
-plugin using the {SyntaxCheckerPlugin#register_syntax_checker} method,
-and can be removed using {SyntaxCheckerPlugin#remove_syntax_checker}.
-
-The appropriate syntax checker for the document is chosen when the extension is
-added to the document, and is changed (if needed) whenever the @document_name@
-of the document changes.
-
-*Note:* in the documentation of this class, the term _document_ will refer
-to the Document passed as argument to the constructor.
-=end
-    class SyntaxCheckerExtension < Qt::Object
+    
+    class Extension < Qt::Object
       
-      include Extension
-
-=begin rdoc
-Signal emitted after a syntax check has been completed
-
-@param [String] result a string containing the results of the syntax check
-=end
-      signals 'check_done(QString)'
+      include Ruber::Extension
       
-      slots 'update_ui(QString)', :check, :document_activated,
-          :document_deactivated, :document_name_changed, :create_syntax_checker
-
-=begin rdoc
-A list of the syntax errors found in the document
+      SyntaxErrorMark = KTextEditor::MarkInterface.markType09
+      
+      DEFAULT_CHECK_OPTIONS = {:format => true, :update => true}
       
-The list is empty if the document doesn't contain syntax errors or if it hasn't
-been checked yet
-
-@return [<SyntaxCheckerPlugin::ErrorDescription>] the syntax errors found in the
-document
-=end
       attr_reader :errors
       
-=begin rdoc
-Creates a new instance
-
-@param [DocumentProject] prj the project associated with the document
-=end
+      attr_reader :status
+      
+      signals 'syntax_checked(QObject*)'
+      
       def initialize prj
         super
-        @plugin = Ruber[:syntax_checker]
+        @status = :unknown
+        @errors = nil
         @doc = prj.document
-        @errors = []
-        @checker = nil
+        @project = prj
+        connect @doc, SIGNAL('document_url_changed(QObject*)'), self, SLOT(:create_syntax_checker)
+        connect @doc, SIGNAL('document_saved_or_uploaded(QObject*, bool)'), self,
+            SLOT(:auto_check)
+        connect @doc, SIGNAL('text_changed(QObject*)'), self, SLOT(:start_waiting)
+        create_syntax_checker
         connect @doc, SIGNAL(:activated), self, SLOT(:document_activated)
-        connect @doc, SIGNAL(:deactivated), self, SLOT(:document_deactivated)
-        @doc.connect(SIGNAL('modified_changed(bool, QObject*)')) do |mod, _|
-          check if !mod
+        connect @doc, SIGNAL(:deactivated), self, SLOT(:delete_timer)
+        connect Ruber[:syntax_checker], SIGNAL(:settings_changed), self, SLOT(:load_settings)
+        connect Ruber[:syntax_checker], SIGNAL(:syntax_checker_added), self, SLOT(:create_syntax_checker_if_needed)
+        connect Ruber[:syntax_checker], SIGNAL(:syntax_checker_removed), self, SLOT(:create_syntax_checker)
+        load_settings
+        document_activated false if @doc.active?
+      end
+      
+      def check_syntax options = DEFAULT_CHECK_OPTIONS
+        options = DEFAULT_CHECK_OPTIONS.merge options
+        if @checker
+          begin
+            errors = @checker.check_syntax @doc.text, options[:format]
+            res = {:errors => errors, :result => errors ? :incorrect : :correct}
+          rescue SyntaxNotChecked 
+            res = {:result => :unknown, :errors => nil}
+          end
+        else res = {:result => :unknown, :errors => nil}
         end
-        connect @doc, SIGNAL('document_name_changed(QString, QObject*)'), self, SLOT(:create_syntax_checker)
-        @doc.connect SIGNAL('text_changed(QObject*)') do
-          if @doc.active?
-            @plugin.stop_timer
-            @plugin.start_timer
+        if options[:format] and options[:update]
+          @errors = errors
+          @status = res[:result]
+          if errors
+  #Uncomment the following lines when KTextEditor::MarkInterface#marks works
+  #           iface = @doc.interface('mark_interface')
+  #           errors.each do |e|
+  #             iface.add_mark e.line, SyntaxErrorMark if e.line
+  #           end
           end
+          emit syntax_checked(@doc) if options[:format]
         end
-        @thread = nil
-        create_syntax_checker
+        res
       end
+      slots :check_syntax
       
-=begin rdoc
-Sets the syntax status according to the results of the last syntax check
-
-It marks the current document as having correct or incorrect syntax depending on
-the contents of _str_.
-
-@param [String] str the string containing the results of the syntax check (such as
-the one that a syntax checker's @check@ method). It is passed to the syntax checker's
-@convert_check_result@ method
-@return [nil]
-=end
-      def update_ui str
-        @errors = @checker.convert_check_result str
-        if @errors.empty? then @plugin.mark_document_as :correct
-        else @plugin.mark_document_as :error, @errors
-        end
-        nil
+      def remove_from_project
+        super
+        @timer.stop if @timer
       end
       
-      def check_syntax async = false
-        
-      end
+      private
       
-=begin rdoc
-Starts a syntax check for the document
-
-The syntax check can be synchronous or asynchronous, according to the value of
-the argument. In the first case, this method won't return until the syntax check
-has finished and the UI has been updated. In the second case, the method will
-start the syntax check in a new thread and return immediately. The {#check_done}
-signal will be emitted when the syntax check has been finished.
-
-Nothing will be done if no checker exists for the document.
-
-*Note:* while an asynchronous syntax check avoids freezing the UI if it takes
-a long time, it seems that it takes much longer than a synchronous check.
-
-@param [Boolean] async whether the syntax check should or not be asynchronous
-@todo the decision on whether the check should be synchronous or asynchronous 
-should be delegated to the checker
-@return [nil]
-=end
-      def check async = false
-        return unless @checker
-        @plugin.stop_timer
-        if async
-          @threak.kill if @thread
-          @thread = Thread.new(@doc.text) do |str|
-            res = @checker.check @doc.text
-            emit check_done res
-          end
-        else
-          res = @checker.check @doc.text
-          update_ui res
+      def create_syntax_checker_if_needed
+        unless @checker
+          create_syntax_checker
         end
-        nil
       end
+      slots :create_syntax_checker_if_needed
       
-      private
-      
-=begin rdoc
-Creates a syntax checker for the document
-
-If needed, it also removes the old one and immediately performs a syntax check
-
-@return [nil]
-=end
       def create_syntax_checker
-        new_checker = Ruber[:syntax_checker].syntax_checker_for @doc
-        if @checker.class != new_checker.class
-          @checker.disconnect if @checker
-          @checker = nil
-          if new_checker
-            @checker = new_checker
-            connect self, SIGNAL('check_done(QString)'), self, SLOT('update_ui(QString)')
-          end
-          check if @doc.active?
-        end
-        nil
+        checker_cls = Ruber[:syntax_checker].syntax_checker_for @doc
+        @checker = checker_cls ? checker_cls.new(@doc) : nil
+        auto_check
       end
+      slots :create_syntax_checker
       
-=begin rdoc
-Informs the extension that the document is not active anymore
-
-@return [nil]
-=end
-      def document_deactivated
-        @thread.kill if @thread
-        @plugin.stop_timer
-        @plugin.disconnect SIGNAL(:timeout), self, SLOT(:check)
-        Ruber[:syntax_checker].mark_document_as :unknown
-        nil
+      def auto_check
+        check_syntax if @project[:syntax_checker, :auto_check]
       end
+      slots :auto_check
       
-=begin rdoc
-Informs the extension that the document became active
-
-@return [nil]
-=end
-      def document_activated
-        connect @plugin, SIGNAL(:timeout), self, SLOT(:check)
-        check
-        nil
+      def document_activated check_syntax = true
+        @timer = Qt::Timer.new self
+        @timer.singleShot = true
+        connect @timer, SIGNAL(:timeout), self, SLOT(:auto_check)
+        auto_check if check_syntax
       end
+      slots :document_activated
       
-    end
-    
-=begin rdoc
-Class which checks the syntax of a ruby file.
-
-To do so, it runs a separate ruby process (using the ruby interpreter set by the
-Ruby Runner plugin) passing it the @-c@ and the @-e@ options with the document's
-content as argument.
-
-The process is executed using @Open3.popen3@
-=end
-    class RubySyntaxChecker
-    
-=begin rdoc
-Creates a new instance.
-
-@param [Document] doc the document to check
-=end
-      def initialize doc
-        @doc = doc
+      def delete_timer
+        @timer.stop
+        @timer.delete_later
+        @timer = nil
       end
+      slots :delete_timer
       
-=begin rdoc
-Checks the syntax of the given string.
-
-@param [String] str the string to check (usually, it'll be the document's text)
-@return [String] a string containing the lines of output produced by ruby concerning
-syntax errors or an empty string if there were no syntax error
-=end
-      def check str
-        ruby = Ruber[:ruby_development].interpreter_for @doc
-        Open3.popen3(ruby, '-c', '-e', str) do |in_s, out_s, err_s|
-          error = err_s.read
-          error.gsub! %r{^-e(?=:\d+:\s+syntax error,)}, @doc.path
-          out_s.read.strip != 'Syntax OK' ? error : ''
-        end
+      def load_settings
+        @time_interval = Ruber[:config][:syntax_checker, :time_interval]
       end
+      slots :load_settings
       
-=begin rdoc
-Parses the output of {#check}
-
-@param [String] str the string to parse.
-@return [<SyntaxCheckerPlugin::ErrorDescription>] a list of {SyntaxCheckerPlugin::ErrorDescription ErrorDescription}s
-corresponding to the syntax errors mentioned in _str_
-=end
-      def convert_check_result str
-        groups = [[]]
-        lines = str.split "\n"
-        lines.each do |l|
-          if l.match(/^#{Regexp.quote(@doc.path||'')}:\d+:\s+syntax error,\s+/) then groups << [l]
-          else groups[-1] << l
-          end
-        end
-        groups.delete_if{|g| g.empty?}
-        groups.map do |a|
-          a.shift.match(/^#{Regexp.quote(@doc.path||'')}:(\d+):\s+syntax error,\s+(.*)/)
-          msgs = [$2]
-          error = SyntaxCheckerPlugin::ErrorDescription.new $1.to_i
-          if a[-1] and a[-1].match(/^\s*\^\s*$/)
-            error.code = a[-2]
-# Sometimes, ruby doesn't report the whole line where the error occurs, but only
-# the part nearest it. In this case, the beginning of the line is replaced with ... . 
-# In this case, to obtain the correct column number, we try a regexp match
-# between the part of code reported by ruby and the whole line. If it works, we
-# add that position to the one returned by ruby. If it doesn't (for example because
-# the user changed the document in the meantime), we'll just report what ruby reports
-            col = a[-1].index('^') 
-            if a[-2].match(/^\.\.\./)
-              lines = @doc.text.split("\n")
-              # error.line is 1-based
-              l = lines[error.line-1] || ''
-              pos = (l =~ /#{Regexp.quote(a[-2][3..-1])}/)
-              error.column = pos ? col + pos - 1 : col
-            else error.column = col
-            end
-            a.pop 2
-          end
-          a.each{|l| msgs << l}
-          error.message = msgs.join ' '
-          error
-        end
+      def start_waiting
+        @timer.start 1_000 * @time_interval if @time_interval > 0 and @doc.active?
       end
+      slots :start_waiting
       
     end
-
-=begin rdoc
-Class which checks the syntax of a ruby file.
-
-It calls the @YAML.load@ method on the document's content within a begin/rescue
-block, rescuing any ArgumentError exception. The message of the exception is used
-to find information about the error
-=end
-    class YamlSyntaxChecker
-      
-=begin rdoc
-Creates a new instance
-
-@param [Document] doc the document to check
-=end
-      def initialize doc
-      end
-
-=begin rdoc
-Checks the syntax of the given string.
-
-@param [String] str the string to check (usually, it'll be the document's text)
-@return [String] a string containing the lines of output produced by @YAML.load@
-concerning syntax errors or an empty string if there were no syntax error
-=end
-      def check str
-        begin 
-          YAML.load str
-          ''
-        rescue ArgumentError => e
-          e.message
-        end
-      end
+    
+    class ConfigWidget < Qt::Widget
       
-=begin rdoc
-Parses the output of {#check}
-
-@param [String] str the string to parse.
-@return [<SyntaxCheckerPlugin::ErrorDescription>] a list of {SyntaxCheckerPlugin::ErrorDescription ErrorDescription}s
-corresponding to the syntax errors mentioned in _str_
-=end
-      def convert_check_result str
-        return [] if str.empty?
-        str.match(/^syntax error on line (\d+), col (\d+): `(.*)'$/)
-        error = SyntaxCheckerPlugin::ErrorDescription.new $1.to_i, 'Syntax error', $3.to_s, $2.to_i
-        [error]
+      def initialize parent = nil
+        super
+        @ui = Ui::SyntaxCheckerConfigWidget.new
+        @ui.setup_ui self
       end
       
-    end    
-    
-=begin rdoc
-  @KDE::Led@ with the ability to jump to the first syntax error on left or middle mouse
-  click and to popup a menu with a list of all syntax errors in the current document
-  on right click
-=end
-    class SyntaxResultWidget < KDE::Led
-    
-=begin rdoc
-Override of @Qt::Widget#mouseReleaseEvent@
-
-If the event refers to the left button and the current document contains syntax
-errors, it moves the cursor in the editor view to the position of the first error
-
-@return [nil]
-=end
-      def mouseReleaseEvent e
-        return unless e.button == Qt::LeftButton or e.button == Qt::MidButton
-        doc = Ruber[:main_window].current_document
-        view = Ruber[:main_window].active_editor
-        return unless view and doc and doc.extension(:syntax_checker)
-        checker = doc.extension(:syntax_checker)
-        err = checker.errors.first
-        if err
-          view.go_to err.line - 1, (err.column || 0)
-          Ruber[:main_window].status_bar.show_message Ruber[:syntax_checker].format_error_message(err), 4000
-        end
-        nil
-      end
-        
-=begin rdoc
-Override of @Qt::Widget#contextMenuEvent@
-
-If the current document contains syntax errors, it displays a menu listing them.
-Each action in the menu moves the cursor in the editor view to display to the line
-and column of the corresponding error.
-
-If the current document doesn't contain syntax errors, the menu will only contain
-an entry with text @Syntax OK@ which does nothing when activated.
-
-@return [nil]
-=end
-      def contextMenuEvent event
-        doc = Ruber[:main_window].current_document
-        view = Ruber[:main_window].active_editor
-        return unless doc and view and (checker = doc.extension :syntax_checker)
-        errors = checker.errors
-        actions = errors.map do |e|
-          a = KDE::Action.new Ruber[:syntax_checker].format_error_message(e), self
-        end
-        actions << KDE::Action.new('Syntax OK', self) if actions.empty?
-        res = Qt::Menu.exec(actions, event.global_pos)
-        return if !res or errors.empty?
-        idx = actions.index res
-        return unless idx
-        error = errors[idx]
-        view.go_to error.line - 1, (error.column || 0)
-        Ruber[:main_window].status_bar.show_message res.text, 4000
-        nil
-      end
-
     end
     
   end