ruber 0.0.9 → 0.0.10

data/spec/ruby_syntax_checker_spec.rb

@@ -0,0 +1,361 @@
+require 'spec/framework'
+require 'spec/common'
+
+require 'tempfile'
+
+require 'plugins/ruby_syntax_checker/ruby_syntax_checker'
+
+describe Ruber::RubySyntaxChecker::Plugin do
+
+  RSpec::Matchers.define :be_same_error_as do |other_err|
+    match do |err|
+      err.line == other_err.line and err.column == other_err.column and
+          err.message == other_err.message and err.formatted_message ==
+          other_err.formatted_message
+    end
+  end
+  
+  NEEDED_PLUGINS = [:syntax_checker, :autosave, :ruby_runner, :ruby_development]
+  
+  before :all do
+    NEEDED_PLUGINS.each do |pl| 
+      dir = File.join 'plugins', pl.to_s
+      Ruber[:components].load_plugin dir
+    end
+  end
+
+  before do
+    Ruber[:components].load_plugin 'plugins/ruby_syntax_checker'
+  end
+  
+  after do
+    Ruber[:components].unload_plugin :ruby_syntax_checker if Ruber[:ruby_syntax_checker]
+  end
+  
+  after :all do
+    NEEDED_PLUGINS.reverse_each{|pl| Ruber[:components].unload_plugin pl}
+  end
+  
+  describe 'when created' do
+    
+    before do
+      @file = Tempfile.open ['', '.rb']
+    end
+    
+    after do
+      @file.close
+    end
+  
+    it 'registers a syntax checker of class Ruber::RubySyntaxChecker::Checker for files ending in .rb with the syntax checker' do
+        checker = Ruber::RubySyntaxChecker::Checker.new flexmock
+        flexmock(Ruber::RubySyntaxChecker::Checker).should_receive(:new).once.with(Ruber::Document).and_return checker
+        doc = Ruber[:world].document @file.path
+      end
+      
+    end
+  
+    describe 'when unloaded' do
+    
+      before do
+        @file = Tempfile.open ['', '.rb']
+      end
+      
+      after do
+        @file.close
+      end
+      
+      it 'removes the Ruber::RubySyntaxChecker::Checker syntax checker' do
+        Ruber[:components].unload_plugin :ruby_syntax_checker
+        flexmock(Ruber::RubySyntaxChecker::Checker).should_receive(:new).never
+        doc = Ruber[:world].document @file.path
+      end
+      
+    end
+    
+end
+
+describe Ruber::RubySyntaxChecker::Checker do
+  NEEDED_PLUGINS = [:syntax_checker, :autosave, :ruby_runner, :ruby_development]
+  
+  before :all do
+    NEEDED_PLUGINS.each do |pl| 
+      dir = File.join 'plugins', pl.to_s
+      Ruber[:components].load_plugin dir
+    end
+  end
+    
+  after :all do
+    NEEDED_PLUGINS.reverse_each{|pl| Ruber[:components].unload_plugin pl}
+  end
+    
+  describe '#check_syntax' do
+    
+    before do
+      @file = Tempfile.open ['', '.rb']
+      @doc = Ruber[:world].document @file.path
+      @checker = Ruber::RubySyntaxChecker::Checker.new @doc
+    end
+    
+    after do
+      @doc.close false
+    end
+    
+    context 'when the first argument is valid ruby' do
+      
+      it 'returns nil' do
+        str = <<-EOS
+class X
+  def y
+    if z
+      1 + 2
+    end
+  end
+end
+EOS
+        @doc.text = str
+        @checker.check_syntax(str, true).should be_nil
+      end
+      
+    end
+    
+    context 'when the first argument is not valid ruby' do
+      
+      it 'returns an array of Ruber::RubySyntaxChecker::SyntaxError with the line of the error if the column is unknown' do
+        str = <<-EOS
+class X
+  def y
+    1 +
+  end
+end
+EOS
+        exp = Ruber::RubySyntaxChecker::SyntaxError.new(3, nil, 'unexpected keyword_end', 'unexpected keyword_end')
+        @checker.check_syntax(str, false)[0].should be_same_error_as(exp)
+      end
+      
+      it 'determines the column number from lines containing all spaces and a single ^' do
+                str = <<-EOS
+def x
+  Y = 1
+end
+EOS
+        @doc.text = str
+        @checker.check_syntax(str, false)[0].column.should == 5
+      end
+      
+      it 'attempts to compute the correct position if the error line before the one with the ^ starts with ...' do
+        pending 'find an error which causes the above situation'
+      end
+      
+      context 'when ruby reports a syntax error' do
+
+        error_types = [
+          [:missing_end, "ruby reports a missing end keyword", 'class X;def y;end'],
+          [:extra_end, "ruby reports an unexpected end keyword at EOF", 'class X;def y;end;end;end'],
+          [:misplaced_end, "ruby reports an unexpected end keyword not at EOF", 'def x;1+end'],
+          [:missing_close_paren, "ruby reports an expected )", 'def x;1*(2+1;end'],
+          [:extra_close_paren, "ruby reports an unexpected )", 'x;1*2+1)'],
+          [:missing_close_bracket, "ruby reports an expected ]", 'x=['],
+          [:extra_close_bracket, "ruby reports an unexpected ]", 'x=]'],
+          [:missing_close_brace, "ruby reports an expected }", 'x={'],
+          [:extra_close_brace, "ruby reports an unexpected }", 'x=}'],
+          [:extra_else, "ruby reports an unexpected else", "x;else;end"],
+          [:missing_quote, "ruby reports an unterminated string", "def x;'"],
+          [:missing_regexp_close_paren, "ruby reports unmatched open parenthesis in regexp", '/xy ( a/'],
+          [:extra_regexp_close_paren, "ruby reports unmatched close parenthesis in regexp", '/xy ) a/'],
+          [:missing_regexp_close_bracket, "ruby reports premature end of char-class", '/ xy [/'],
+          [:unknown_regexp_option, "ruby reports an unknown regexp option", '/a/t'],
+          [:dynamic_constant_assignment , "ruby reports a dynamic constant assignment", 'def x;X=2;end'],
+          [:extra_when, "ruby reports an unexpected when keyword", 'when 2 then 3'],
+          [:extra_rescue, "ruby reports an unexpected rescue keyword", 'rescue'],
+          [:extra_ensure, "ruby reports an unexpected ensure keyword", 'ensure'],
+          [:missing_block_comment_end, "ruby reports an embedded document meets end of file", '=begin'],
+          [:missing_heredoc_end, "ruby reports it can't find the end of a heredoc", "str=<<EOS"]
+        ]
+
+        error_types.each do |type, cond, code|
+          it "sets the error_type attribute of the error object to #{type} if #{cond}" do
+            errors = @checker.check_syntax(code, false)
+            errors[0].error_type.should == type
+          end
+        end
+        
+      end
+      
+      it 'works correctly when ruby reports unmatched open parenthesis in a regexp' do
+        str = '/xy ( a/'
+        @doc.text = str
+        exp = Ruber::RubySyntaxChecker::SyntaxError.new(0, nil, 'end pattern with unmatched parenthesis: /xy ( a/', 'end pattern with unmatched parenthesis: /xy ( a/')
+        @checker.check_syntax(str, false)[0].should be_same_error_as(exp)
+      end
+      
+      it 'works correctly when ruby reports the premature end of a character class' do
+        str = '/xy [ a/'
+        @doc.text = str
+        exp = Ruber::RubySyntaxChecker::SyntaxError.new(0, nil, 'premature end of char-class: /xy [ a/', 'premature end of char-class: /xy [ a/')
+        @checker.check_syntax(str, false)[0].should be_same_error_as(exp)
+      end
+
+      it 'works correctly when ruby reports an invalid regexp option' do
+        str = '/xy/t'
+        @doc.text = str
+        exp = [Ruber::RubySyntaxChecker::SyntaxError.new(0, nil, 'unknown regexp option - t', 'unknown regexp option - t')]
+        @checker.check_syntax(str, false).should be_same_error_as(exp)
+      end
+      
+      it 'works correctly when ruby reports a class definition in a method body' do
+        str = <<-EOS
+def x
+  class Y
+  end
+end
+EOS
+        @doc.text = str
+        msg = 'class definition in method body'
+        exp = Ruber::RubySyntaxChecker::SyntaxError.new(1, nil, msg, msg)
+        @checker.check_syntax(str, false)[0].should == exp
+      end
+
+      it 'works correctly when ruby reports a module definition in a method body' do
+        str = <<-EOS
+def x
+  module Y
+  end
+end
+EOS
+        @doc.text = str
+        msg = 'module definition in method body '
+        exp = [Ruber::RubySyntaxChecker::SyntaxError.new(1, nil, msg, msg)]
+        @checker.check_syntax(str, false).should == exp
+      end
+      
+      it 'works correctly when ruby reports an unterminated string' do
+        @doc.text = 'def x;"'
+        msg = "unterminated string meets end of file "
+        exp = Ruber::RubySyntaxChecker::SyntaxError.new(0, nil, msg, msg)
+        @checker.check_syntax(@doc.text, false)[0].should be_same_error_as(exp)
+      end
+      
+      it 'works correctly when ruby reports an unterminated block comment' do
+        @doc.text = '=begin x'
+        msg = "embedded document meets end of file "
+        exp = Ruber::RubySyntaxChecker::SyntaxError.new(0, nil, msg, msg)
+        @checker.check_syntax(@doc.text, false)[0].should be_same_error_as(exp)
+      end
+      
+      it 'works correctly when ruby reports an unterminated heredoc' do
+        @doc.text = "str=<<EOS"
+        msg = 'can\'t find string "EOS" anywhere before EOF '
+        exp = Ruber::RubySyntaxChecker::SyntaxError.new(0, nil, msg, msg)
+        @checker.check_syntax(@doc.text, false)[0].should be_same_error_as(exp)
+      end
+
+      it 'works correctly when ruby reports a dynamic constant assignment' do
+        str = <<-EOS
+def x
+  Y = 1
+end
+EOS
+        @doc.text = str
+        msg = "dynamic constant assignment \n  Y = 1"
+        exp = Ruber::RubySyntaxChecker::SyntaxError.new(1, 5, msg, msg)
+        @checker.check_syntax(str, false)[0].should be_same_error_as(exp)
+      end
+      
+      it 'works correctly with unknown syntax errors' do
+        error_msg = '-e:10:xyz'
+        flexmock(Open3).should_receive(:popen3).once.and_return error_msg
+        exp = Ruber::RubySyntaxChecker::SyntaxError.new(nil, nil, error_msg, error_msg)
+        @checker.check_syntax('', false)[0].should be_same_error_as(exp)
+      end
+      
+    end
+    
+    it 'uses the ruby interpreter stored in the ruby/ruby project option' do
+      # To check whether the correct interpreter is being used, a syntax which is
+      # correct in ruby 1.8 and incorrect in 1.9 is used
+      @doc.own_project[:ruby, :ruby] = '/usr/bin/ruby18'
+      str = <<-EOS
+if x: y
+else z
+end
+EOS
+      @doc.text = str
+      @checker.check_syntax(str, false).should be_nil
+    end
+    
+    it 'raises Ruber::SyntaxChecker::SyntaxNotChecked if the given interpreter doesn\'t exist'  do
+      @doc.own_project[:ruby, :ruby] = '/usr/bin/nonexisting-ruby'
+      lambda{@checker.check_syntax('', false)}.should raise_error(Ruber::SyntaxChecker::SyntaxNotChecked)
+    end
+    
+    context 'if the second argument is true' do
+      
+      it 'replaces instances of "expected $end" with "expected end of file" in the formatter error message' do
+        error_msg = '-e:12: syntax error, expected $end'
+        flexmock(Open3).should_receive(:popen3).once.and_return error_msg
+        res = @checker.check_syntax('', true)
+        res[0].formatted_message.should == 'expected end of file'
+      end
+      
+      it 'replaces instances of "expecting $end" with "expecting end of file" in the formatter error message' do
+        error_msg = '-e:12: syntax error, expecting $end'
+        flexmock(Open3).should_receive(:popen3).once.and_return error_msg
+        res = @checker.check_syntax('', true)
+        res[0].formatted_message.should == 'expecting end of file'
+      end
+      
+      it 'replaces instances of "unexpected $end" with "unexpected end of file" in the formatter error message' do
+        error_msg = '-e:12: syntax error, unexpected $end'
+        flexmock(Open3).should_receive(:popen3).once.and_return error_msg
+        res = @checker.check_syntax('', true)
+        res[0].formatted_message.should == 'unexpected end of file'
+      end
+      
+      it 'replaces instances of "expected kEND" with "expected `end` keyword" in the formatter error message' do
+        error_msg = '-e:12: syntax error, expected kEND'
+        flexmock(Open3).should_receive(:popen3).once.and_return error_msg
+        res = @checker.check_syntax('', true)
+        res[0].formatted_message.should == 'expected `end` keyword'
+      end
+      
+      it 'replaces instances of "expecting kEND" with "expecting `end` keyword" in the formatter error message' do
+        error_msg = '-e:12: syntax error, expecting kEND'
+        flexmock(Open3).should_receive(:popen3).once.and_return error_msg
+        res = @checker.check_syntax('', true)
+        res[0].formatted_message.should == 'expecting `end` keyword'
+      end
+      
+      it 'replaces instances of "unexpected kEND" with "unexpected `end` keyword" in the formatter error message' do
+        error_msg = '-e:12: syntax error, unexpected kEND'
+        flexmock(Open3).should_receive(:popen3).once.and_return error_msg
+        res = @checker.check_syntax('', true)
+        res[0].formatted_message.should == 'unexpected `end` keyword'
+      end
+
+      it 'replaces instances of "expected keyword_end" with "expected `end` keyword" in the formatter error message' do
+        error_msg = '-e:12: syntax error, expected keyword_end'
+        flexmock(Open3).should_receive(:popen3).once.and_return error_msg
+        res = @checker.check_syntax('', true)
+        res[0].formatted_message.should == 'expected `end` keyword'
+      end
+      
+      it 'replaces instances of "expecting keyword_end" with "expecting `end` keyword" in the formatter error message' do
+        error_msg = '-e:12: syntax error, expecting keyword_end'
+        flexmock(Open3).should_receive(:popen3).once.and_return error_msg
+        res = @checker.check_syntax('', true)
+        res[0].formatted_message.should == 'expecting `end` keyword'
+      end
+      
+      it 'replaces instances of "unexpected keyword_end" with "unexpected `end` keyword" in the formatter error message' do
+        error_msg = '-e:12: syntax error, unexpected keyword_end'
+        flexmock(Open3).should_receive(:popen3).once.and_return error_msg
+        res = @checker.check_syntax('', true)
+        res[0].formatted_message.should == 'unexpected `end` keyword'
+      end
+      
+    end
+
+  end
+  
+  
+end

data/spec/syntax_checker_spec.rb

@@ -0,0 +1,1132 @@
+require 'spec/framework'
+require 'spec/common'
+
+require 'tempfile'
+
+require 'plugins/syntax_checker/syntax_checker'
+
+describe Ruber::SyntaxChecker::Plugin do
+  
+  before do
+    Ruber[:world].close_all :documents, :discard
+    Ruber[:components].load_plugin 'plugins/syntax_checker/'
+    @plug = Ruber[:syntax_checker]
+  end
+
+  after do
+    Ruber[:world].close_all :documents, :discard
+    Ruber[:components].unload_plugin :syntax_checker
+    led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+    led.delete_later
+    Qt::Application.send_posted_events led, Qt::Event::DeferredDelete
+  end
+  
+  it 'inherits Ruber::Plugin' do
+    Ruber::SyntaxChecker::Plugin.ancestors.should include(Ruber::Plugin)
+  end
+  
+  context 'when created' do
+    
+    it 'has no registered syntax checkers' do
+      @plug.instance_variable_get(:@syntax_checkers).should == {}
+    end
+    
+    it 'inserts a KDE::Led in the status bar' do
+      Ruber[:main_window].status_bar.find_children(KDE::Led).should_not be_empty
+    end
+    
+    it 'sets the current status to :unknown' do
+      @plug.current_status.should == :unknown
+    end
+    
+  end
+  
+  context 'when unloaded' do
+    
+    it 'removes the led from the status bar' do
+      led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+      led_id = led.object_id
+      flexmock(Ruber[:main_window].status_bar).should_receive(:remove_widget).with(FlexMock.on{|arg| arg.object_id == led_id}).once
+      #The plugin will be unloaded in the after block
+    end
+    
+  end
+  
+  describe 'format_error' do
+    
+    context 'if the argument\'s line, column and formatted_message methods all return non nil' do
+      
+      it 'returns a string of the form "Line lineno+1, column columnno+1: formatted_message"' do
+        err = OpenStruct.new :line => 5, :column => 3, :formatted_message => 'Xyz'
+        @plug.format_error(err).should == 'Line 6, column 4: Xyz'
+      end
+      
+    end
+    
+    context 'if the argument\'s line and formatted_message methods all return non nil but the column method returns nil' do
+      
+      it 'returns a string of the form "Line lineno+1: formatted_message"' do
+        err = OpenStruct.new :line => 5, :formatted_message => 'Xyz'
+        @plug.format_error(err).should == 'Line 6: Xyz'
+      end
+      
+    end
+    
+    context 'if the line method of the argument returns nil and the formatted_message method does not' do
+      
+      it 'returns a string containing only the formatted message' do
+        err = OpenStruct.new :formatted_message => 'Xyz'
+        @plug.format_error(err).should == 'Xyz'
+        err = OpenStruct.new :column => 4, :formatted_message => 'Xyz'
+        @plug.format_error(err).should == 'Xyz'
+      end
+      
+    end
+    
+    context 'if the formatted_message method of the argument returns nil' do
+      
+      it 'uses the value returned by the message method of the argument if not nil' do
+        err = OpenStruct.new :line => 5, :column => 3, :message => 'Xyz'
+        @plug.format_error(err).should == 'Line 6, column 4: Xyz'
+        err = OpenStruct.new :line => 5, :message => 'Xyz'
+        @plug.format_error(err).should == 'Line 6: Xyz'
+        err = OpenStruct.new :message => 'Xyz'
+        @plug.format_error(err).should == 'Xyz'
+        err = OpenStruct.new :column => 5, :message => 'Xyz'
+        @plug.format_error(err).should == 'Xyz'
+      end
+      
+      it 'uses the string "UNKNOWN ERROR" if the message method also returns nil' do
+        err = OpenStruct.new :line => 5, :column => 3
+        @plug.format_error(err).should == 'Line 6, column 4: UNKNOWN ERROR'
+        err = OpenStruct.new :line => 5
+        @plug.format_error(err).should == 'Line 6: UNKNOWN ERROR'
+        err = OpenStruct.new
+        @plug.format_error(err).should == 'UNKNOWN ERROR'
+        err = OpenStruct.new :column => 5
+        @plug.format_error(err).should == 'UNKNOWN ERROR'
+      end
+      
+    end
+    
+    it 'translates all messages using KDE.i18n' do
+      flexmock(KDE).should_receive(:i18n).once.with('Line %d').and_return('Riga %d')
+      flexmock(KDE).should_receive(:i18n).once.with(', column %d: ').and_return(', colonna %d: ')
+      flexmock(KDE).should_receive(:i18n).once.with('Xyz').and_return('Abc')
+      flexmock(KDE).should_receive(:i18n).once.with('UNKNOWN ERROR').and_return('ERRORE SCONOSCIUTO')
+      err = OpenStruct.new :line => 5, :column => 3, :formatted_message => 'Xyz'
+      @plug.format_error(err).should == 'Riga 6, colonna 4: Abc'
+      @plug.format_error(OpenStruct.new).should == 'ERRORE SCONOSCIUTO'
+    end
+    
+  end
+
+  describe '#set_current_status' do
+    
+    context 'if the first argument is :correct' do
+      
+      it 'sets the current_errors attribute to nil' do
+        @plug.instance_variable_set :@current_errors, []
+        @plug.set_current_status :correct
+        @plug.current_errors.should be_nil
+      end
+      
+      it 'sets the led to the color contained in the COLORS hash under the :correct key' do
+        led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+        led.color = Qt::Color.new Qt.black
+        @plug.set_current_status :correct
+        led.color.should == Ruber::SyntaxChecker::Plugin::COLORS[:correct]
+      end
+      
+      it 'sets the tooltip of the led to "No syntax errors"' do
+        led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+        @plug.set_current_status :correct
+        led.tool_tip.should == "No syntax errors"
+      end
+      
+      it 'sets the current_status attribute to :correct' do
+        @plug.set_current_status :correct
+        @plug.current_status.should == :correct
+      end
+    
+    end
+    
+    context 'if the first argument is :unknown' do
+      
+      it 'sets the current_errors attribute to nil' do
+        @plug.instance_variable_set :@current_errors, []
+        @plug.set_current_status :unknown
+        @plug.current_errors.should be_nil
+      end
+      
+      it 'sets the led to the color contained in the COLORS hash under the :unknown key' do
+        led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+        led.color = Qt::Color.new Qt.black
+        @plug.set_current_status :unknown
+        led.color.should == Ruber::SyntaxChecker::Plugin::COLORS[:unknown]
+      end
+      
+      it 'sets the tooltip of the led to "Unknown document type"' do
+        led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+        @plug.set_current_status :unknown
+        led.tool_tip.should == "Unknown document type"
+      end
+      
+      it 'sets the current_status attribute to :unknown' do
+        @plug.set_current_status :unknown
+        @plug.current_status.should == :unknown
+      end
+    
+    end
+    
+    context 'if the first argument is :incorrect' do
+      
+      before do
+        @errors = [
+          OpenStruct.new( :line => 15, :column => 2, :message => 'xyz', :formatted_message=> 'XYZ'),
+          OpenStruct.new( :line => 15, :column => 0, :message => 'abc', :formatted_message=> 'ABC'),
+        ]
+      end
+      
+      context 'and the second argument is an array with at least one element' do
+
+        it 'stores the contents of the second argument in the current_errors attribute' do
+          @plug.set_current_status :incorrect, @errors
+          @plug.current_errors.should == @errors
+          @plug.current_errors.should_not equal(@errors)
+        end
+      
+        it 'sets the tooltip of the led to a list of the formatted_message for the errors given as second argument, preceded by lines and columns (increased by 1)' do
+          led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+          @plug.set_current_status :incorrect, @errors
+          led.tool_tip.should == "Line 16, column 3: XYZ\nLine 16, column 1: ABC"
+        end
+        
+      end
+      
+      context 'and the second argument is an empty array' do
+        
+        it 'stores an empty array in the current_errors attribute' do
+          @plug.set_current_status :incorrect, []
+          @plug.current_errors.should == []
+        end
+        
+        it 'sets the tooltip of the led to "There are syntax errors"' do
+          led = Ruber[:main_window].status_bar.find_children(KDE::Led)[-1]
+          @plug.set_current_status :incorrect, []
+          led.tool_tip.should == "There are syntax errors"
+        end
+        
+      end
+      
+      it 'sets the led to the color contained in the COLORS hash under the :incorrect key' do
+        led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+        led.color = Qt::Color.new Qt.black
+        @plug.set_current_status :incorrect, @errors
+        led.color.should == Ruber::SyntaxChecker::Plugin::COLORS[:incorrect]
+      end
+            
+      it 'sets the current_status attribute to :incorrect' do
+        @plug.set_current_status :incorrect
+        @plug.current_status.should == :incorrect
+      end
+      
+    end
+    
+  end
+  
+  context 'when the user right-clicks on the led' do
+    
+    before do
+      @led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+    end
+   
+    context 'if the current_status attribute is :correct' do
+      
+      it 'displays a menu with the entry "No syntax errors"' do
+        @plug.set_current_status :correct
+        actions_prc = Proc.new do |list|
+          list.count == 1 && list[0].text == 'No syntax errors'
+        end
+        flexmock(Qt::Menu).should_receive(:exec).once.with(FlexMock.on(&actions_prc), Qt::Point)
+        ev = Qt::ContextMenuEvent.new Qt::ContextMenuEvent::Mouse, Qt::Point.new(0,0)
+        Qt::Application.send_event(@led, ev)
+      end
+      
+    end
+    
+    context 'if the current_status attribute is :unknown' do
+      
+      it 'doesn\'t display any menu' do
+        @plug.set_current_status :unknown
+        flexmock(Qt::Menu).should_receive(:exec).never
+        ev = Qt::ContextMenuEvent.new Qt::ContextMenuEvent::Mouse, Qt::Point.new(0,0)
+        Qt::Application.send_event(@led, ev)
+      end
+      
+    end
+    
+    context 'if the current_status attribute is :incorrect' do
+      
+      context 'and the current_errors attribute is empty' do
+        
+        it 'displays a menu with the entry "There are syntax errors"' do
+          @plug.set_current_status :incorrect
+          actions_prc = Proc.new do |list|
+            list.count == 1 && list[0].text == 'There are syntax errors'
+          end
+          flexmock(Qt::Menu).should_receive(:exec).once.with(FlexMock.on(&actions_prc), Qt::Point)
+          ev = Qt::ContextMenuEvent.new Qt::ContextMenuEvent::Mouse, Qt::Point.new(0,0)
+          Qt::Application.send_event(@led, ev)
+        end
+        
+      end
+      
+      context 'and the current_errors attribute is not empty' do
+        
+        before do
+          @errors = [
+            OpenStruct.new(:line => 15, :column => 2, :message => 'xyz', :formatted_message => 'XYZ'),
+            OpenStruct.new(:line => 15, :mesage => 'abc', :formatted_message => 'ABC'),
+          ]
+          @plug.set_current_status :incorrect, @errors
+        end
+        
+        it 'displays a menu with an entry for each error (increasing lines and columns by 1)' do
+          exp_texts = ["Line 16, column 3: XYZ", "Line 16: ABC"]
+          actions_prc = Proc.new{|list| list.map{|a| a.text} == exp_texts}
+          flexmock(Qt::Menu).should_receive(:exec).once.with(FlexMock.on(&actions_prc), Qt::Point)
+          ev = Qt::ContextMenuEvent.new Qt::ContextMenuEvent::Mouse, Qt::Point.new(0,0)
+          Qt::Application.send_event(@led, ev)
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+  context 'when the user clicks on an entry in the context menu' do
+    
+    before do
+      @led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+      @docs = Array.new(3){Ruber[:world].new_document}
+      @views = @docs.map{|d| Ruber[:world].active_environment.editor_for! d}
+      Ruber[:world].active_environment.activate_editor @views[0]
+    end
+    
+    context 'and the current_errors attribute contains errors' do
+      
+      before do
+        @errors = [
+          OpenStruct.new(:line => 15, :column => 2, :message => 'xyz', :formatted_message=> 'XYZ'),
+          OpenStruct.new(:line => 15, :message => 'abc', :formatted_message => 'ABC'),
+          OpenStruct.new(:message =>'fgh'),
+        ]
+        @plug.set_current_status :incorrect, @errors
+      end
+      
+      it 'moves the cursor of the current view to the line and column of the error corresponding to the chosen entry' do
+        actions = @errors.map{|e| KDE::Action.new(e.format, nil)}
+        actions.each do |a|
+          flexmock(KDE::Action).should_receive(:new).once.and_return(a)
+        end
+        flexmock(Qt::Menu).should_receive(:exec).once.and_return(actions[0])
+        flexmock(@views[0]).should_receive(:go_to).with(15, 2).once
+        ev = Qt::ContextMenuEvent.new Qt::ContextMenuEvent::Mouse, Qt::Point.new(0,0)
+        Qt::Application.send_event(@led, ev)
+      end
+      
+      it 'moves the cursor to column 0 of the appropriate line if the error doesn\'t specify a column number' do
+        actions = @errors.map{|e| KDE::Action.new(e.format, nil)}
+        actions.each do |a|
+          flexmock(KDE::Action).should_receive(:new).once.and_return(a)
+        end
+        flexmock(Qt::Menu).should_receive(:exec).once.and_return(actions[1])
+        flexmock(@views[0]).should_receive(:go_to).with(15, 0).once
+        ev = Qt::ContextMenuEvent.new Qt::ContextMenuEvent::Mouse, Qt::Point.new(0,0)
+        Qt::Application.send_event(@led, ev)
+      end
+      
+      it 'doesn\'t move the cursor if the error doesn\'t specify a line number' do
+        actions = @errors.map{|e| KDE::Action.new(e.format, nil)}
+        actions.each do |a|
+          flexmock(KDE::Action).should_receive(:new).once.and_return(a)
+        end
+        flexmock(Qt::Menu).should_receive(:exec).once.and_return(actions[2])
+        flexmock(@views[0]).should_receive(:go_to).never
+        ev = Qt::ContextMenuEvent.new Qt::ContextMenuEvent::Mouse, Qt::Point.new(0,0)
+        Qt::Application.send_event(@led, ev)
+      end
+      
+    end
+    
+    context 'and the current_errors attribute is nil or empty' do
+      
+      it 'does nothing' do
+        action = KDE::Action.new 'Text', nil
+        flexmock(KDE::Action).should_receive(:new).and_return(action)
+        flexmock(Qt::Menu).should_receive(:exec).and_return(action)
+        flexmock(@views[0]).should_receive(:go_to).never
+        @plug.set_current_status :correct
+        ev = Qt::ContextMenuEvent.new Qt::ContextMenuEvent::Mouse, Qt::Point.new(0,0)
+        Qt::Application.send_event(@led, ev)
+        @plug.set_current_status :unknown
+        ev = Qt::ContextMenuEvent.new Qt::ContextMenuEvent::Mouse, Qt::Point.new(0,0)
+        Qt::Application.send_event(@led, ev)
+        @plug.set_current_status :incorrect
+        ev = Qt::ContextMenuEvent.new Qt::ContextMenuEvent::Mouse, Qt::Point.new(0,0)
+        Qt::Application.send_event(@led, ev)
+      end
+      
+    end
+    
+  end
+  
+  context 'when the user clicks on the led' do
+    
+    before do
+      @led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+      @docs = Array.new(3){Ruber[:world].new_document}
+      @views = @docs.map{|d| Ruber[:world].active_environment.editor_for! d}
+      Ruber[:world].active_environment.activate_editor @views[0]
+    end
+    
+    context 'and the current_errors attribute contains errors' do
+      
+      before do
+        @errors = [
+          OpenStruct.new(:line => 15, :column => 2, :message => 'xyz', :formatted_message=> 'XYZ'),
+          OpenStruct.new(:line => 15, :message => 'abc', :formatted_message => 'ABC'),
+          OpenStruct.new(:message =>'fgh'),
+        ]
+        @plug.set_current_status :incorrect, @errors
+      end
+      
+      it 'moves the cursor to the line and column associated with the first error' do
+        flexmock(@views[0]).should_receive(:go_to).with(15, 2).once
+        ev = Qt::MouseEvent.new Qt::Event::MouseButtonRelease, Qt::Point.new(0,0), Qt::LeftButton, Qt::NoButton, Qt::NoModifier
+        Qt::Application.send_event(@led, ev)
+      end
+      
+      it 'moves the cursor to column 0 of the appropriate line if the error doesn\'t specify a column number' do
+        @errors[0].column = nil
+        flexmock(@views[0]).should_receive(:go_to).with(15, 0).once
+        ev = Qt::MouseEvent.new Qt::Event::MouseButtonRelease, Qt::Point.new(0,0), Qt::LeftButton, Qt::NoButton, Qt::NoModifier
+        Qt::Application.send_event(@led, ev)
+      end
+      
+      it 'does nothing if the first error doesn\'t specify a line number' do
+        @errors[0].line = nil
+        flexmock(@views[0]).should_receive(:go_to).never
+        ev = Qt::MouseEvent.new Qt::Event::MouseButtonRelease, Qt::Point.new(0,0), Qt::LeftButton, Qt::NoButton, Qt::NoModifier
+        Qt::Application.send_event(@led, ev)
+      end
+  
+    end
+    
+    context 'and the current_errors attribute is nil or empty' do
+      
+      it 'does nothing' do
+        flexmock(@views[0]).should_receive(:go_to).never
+        @plug.set_current_status :correct
+        ev = Qt::MouseEvent.new Qt::Event::MouseButtonRelease, Qt::Point.new(0,0), Qt::LeftButton, Qt::NoButton, Qt::NoModifier
+        Qt::Application.send_event(@led, ev)
+        @plug.set_current_status :unknown
+        ev = Qt::MouseEvent.new Qt::Event::MouseButtonRelease, Qt::Point.new(0,0), Qt::LeftButton, Qt::NoButton, Qt::NoModifier
+        Qt::Application.send_event(@led, ev)
+        @plug.set_current_status :incorrect
+        ev = Qt::MouseEvent.new Qt::Event::MouseButtonRelease, Qt::Point.new(0,0), Qt::LeftButton, Qt::NoButton, Qt::NoModifier
+        Qt::Application.send_event(@led, ev)
+      end
+      
+    end
+    
+  end
+  
+  describe '#register_syntax_checker' do
+
+    before do
+      @cls = Class.new
+      @mimetypes = %w[application/x-ruby text/x-python]
+      @patterns = %w[*.rb *.py]
+    end
+
+    it 'stores the given class with the associated rules' do
+      @plug.register_syntax_checker @cls, @mimetypes, @patterns
+      @plug.instance_variable_get(:@syntax_checkers)[@cls].should == [@mimetypes, @patterns]
+    end
+    
+    it 'emits the syntax_checker_added signal' do
+      mk = flexmock{|m| m.should_receive(:syntax_checker_added).once}
+      @plug.connect(SIGNAL(:syntax_checker_added)){mk.syntax_checker_added}
+      @plug.register_syntax_checker @cls, @mimetypes, @patterns
+    end
+    
+    it 'raises ArgumentError if the given syntax checker has already been registered' do
+      cls = Class.new
+      mimetypes = %w[application/x-ruby]
+      patterns = %w[*.rb]
+      @plug.register_syntax_checker cls, mimetypes, patterns
+      lambda{@plug.register_syntax_checker cls, ['text/plain']}.should raise_error(ArgumentError, "#{cls} has already been registered as syntax checker")
+    end
+    
+  end
+  
+  describe '#syntax_checker_for' do
+    
+    context 'if a syntax checker for which the document\'s file_type_match? method returns true exists' do
+      
+      it 'returns the syntax checker class' do
+        doc = Ruber[:world].new_document
+        checkers = Array.new(2){Class.new}
+        @plug.register_syntax_checker checkers[0], ['text/x-python']
+        @plug.register_syntax_checker checkers[1], ['application/x-ruby']
+        flexmock(doc).should_receive(:file_type_match?).with(['text/x-python'], []).and_return false
+        flexmock(doc).should_receive(:file_type_match?).with(['application/x-ruby'], []).and_return true
+        checker = @plug.syntax_checker_for doc
+        checker.should == checkers[1]
+      end
+      
+      it 'returns the first syntax checker with matches if there are more than one of them' do
+        doc = Ruber[:world].new_document
+        checkers = Array.new(2){Class.new}
+        @plug.register_syntax_checker checkers[0], ['text/x-python']
+        @plug.register_syntax_checker checkers[1], ['application/x-ruby']
+        flexmock(doc).should_receive(:file_type_match?).with(['text/x-python'], []).and_return true
+        flexmock(doc).should_receive(:file_type_match?).with(['application/x-ruby'], []).and_return true
+        checker = @plug.syntax_checker_for doc
+        checker.should == checkers[0]
+      end
+      
+    end
+    
+    context 'if the document\'s file_type_match? method returns false for all syntax checkers' do
+      
+      it 'returns nil' do
+        doc = Ruber[:world].new_document
+        checkers = Array.new(2){Class.new}
+        @plug.register_syntax_checker checkers[0], ['text/x-python']
+        @plug.register_syntax_checker checkers[1], ['application/x-ruby']
+        flexmock(doc).should_receive(:file_type_match?).with(['text/x-python'], []).and_return false
+        flexmock(doc).should_receive(:file_type_match?).with(['application/x-ruby'], []).and_return false
+        checker = @plug.syntax_checker_for doc
+        checker.should be_nil
+      end
+      
+    end
+    
+  end
+  
+  describe '#remove_syntax_checker' do
+    
+    before do
+      @cls = Class.new
+      @plug.register_syntax_checker @cls, ['application/x-ruby']
+    end
+    
+    it 'removes the given syntax checker from the list' do
+      @plug.remove_syntax_checker @cls
+      @plug.instance_variable_get(:@syntax_checkers).should_not include(@cls)
+    end
+    
+    it 'emits the syntax_checker_removed signal' do
+      mk = flexmock{|m| m.should_receive(:syntax_checker_removed).once}
+      @plug.connect(SIGNAL(:syntax_checker_removed)){mk.syntax_checker_removed}
+      @plug.remove_syntax_checker @cls
+    end
+    
+    it 'does nothing if the given syntax checker has not been registered' do
+      cls = Class.new
+      mk = flexmock{|m| m.should_receive(:syntax_checker_removed).never}
+      @plug.connect(SIGNAL(:syntax_checker_removed)){mk.syntax_checker_removed}
+      lambda{@plug.remove_syntax_checker cls}.should_not raise_error
+    end
+    
+  end
+  
+  describe '#load_settings ' do
+    
+    it 'emits the :settings_changed signal' do
+      mk = flexmock{|m| m.should_receive(:settings_changed).once}
+      @plug.connect(SIGNAL(:settings_changed)){mk.settings_changed}
+      @plug.load_settings
+    end
+    
+  end
+  
+  context 'when the syntax checker extension complete a syntax check' do
+    
+    before do
+      @doc = Ruber[:world].document __FILE__
+      @ext = @doc.extension(:syntax_checker)
+      @errors = [OpenStruct.new(:line => 2, :column => 5, :message => 'X', :formatted_message=> 'x')]
+    end
+    
+    after do
+      @doc.close false
+    end
+    
+    it 'updates the current state accordingly if the extension is associated with the active document' do
+      flexmock(@doc).should_receive(:active?).and_return true
+      flexmock(@ext).should_receive(:status).and_return(:incorrect)
+      flexmock(@ext).should_receive(:errors).and_return @errors
+      flexmock(@plug).should_receive(:set_current_status).once.with(:incorrect, @errors)
+      @ext.instance_eval{emit syntax_checked(@doc)}
+    end
+    
+    it 'does nothing if the extension is not associated with the active document' do
+      flexmock(@doc).should_receive(:active?).and_return false
+      flexmock(@ext).should_receive(:status).and_return(:incorrect)
+      flexmock(@ext).should_receive(:errors).and_return @errors
+      flexmock(@plug).should_receive(:set_current_status).never
+      @ext.instance_eval{emit syntax_checked(@doc)}
+    end
+    
+  end
+  
+end
+
+describe Ruber::SyntaxChecker::Extension do
+  
+  before do
+    Ruber[:world].close_all :documents, :discard
+    Ruber[:components].load_plugin 'plugins/syntax_checker/'
+    @plug = Ruber[:syntax_checker]
+    @file = Tempfile.new ['', '.rb']
+    @doc = Ruber[:world].document @file.path
+    @ext = @doc.own_project.extension(:syntax_checker)
+  end
+
+  after do
+    Ruber[:components].unload_plugin :syntax_checker
+    led = Ruber[:main_window].status_bar.find_children(KDE::Led)[0]
+    led.delete_later
+    Qt::Application.send_posted_events led, Qt::Event::DeferredDelete
+    @file.close
+  end
+
+  it 'inherits Qt::Object' do
+    Ruber::SyntaxChecker::Extension.ancestors.should include(Qt::Object)
+  end
+  
+  it 'includes the Ruber::Extension module' do
+    Ruber::SyntaxChecker::Extension.ancestors.should include(Ruber::Extension)
+  end
+    
+  context 'when created' do
+    
+    it 'creates a new syntax checker as appropriate for the document' do
+      cls = Class.new{def initialize doc;end; def check_syntax *args;end}
+      flexmock(Ruber[:syntax_checker]).should_receive(:syntax_checker_for).with(@doc).once.and_return cls
+      ext = Ruber::SyntaxChecker::Extension.new @doc.own_project
+      ext.instance_variable_get(:@checker).should be_a(cls)
+    end
+    
+    it 'doesn\'t attempt to create a syntax checker if there is none suitable for the document associated with the extension' do
+      doc = Ruber[:world].new_document
+      cls = Class.new{def check_syntax *args;end}
+      flexmock(Ruber[:syntax_checker]).should_receive(:syntax_checker_for).with(doc).once.and_return nil
+      flexmock(doc.own_project).should_receive(:[]).with(:syntax_checker, :auto_check).and_return true
+      ext = Ruber::SyntaxChecker::Extension.new doc.own_project
+      ext.instance_variable_get(:@checker).should be_nil
+    end
+    
+    it 'reads the syntax_checker/time_interval option from the config' do
+      flexmock(Ruber[:config]).should_receive(:[]).with(:syntax_checker, :time_interval).once.and_return 10
+      ext = Ruber::SyntaxChecker::Extension.new @doc.own_project
+    end
+    
+    it 'has the errors attribute set to nil' do
+      @ext.errors.should be_nil
+    end
+    
+    it 'has the status attribute set to unknown' do
+      @ext.status.should == :unknown
+    end
+    
+    context 'if the document is active' do
+      
+      before do
+        flexmock(@doc).should_receive(:active?).and_return true
+      end
+      
+      it 'creates a single shot timer' do
+        ext = Ruber::SyntaxChecker::Extension.new @doc.own_project
+        timer = ext.instance_variable_get :@timer
+        timer.should be_a Qt::Timer
+        timer.singleShot.should be_true
+      end
+      
+    end
+    
+  end
+  
+  describe 'when the document\'s URL changes' do
+    
+    before do
+      @cls = Class.new{def check_syntax *args;end}
+      flexmock(Ruber[:syntax_checker]).should_receive(:syntax_checker_for).by_default.and_return @cls
+    end
+      
+    it 'creates a new syntax checker if needed' do
+      @doc.instance_eval{emit document_url_changed(self)}
+      @ext.instance_variable_get(:@checker).should be_a(@cls)
+    end
+    
+    it 'removes the old syntax checker if no valid syntax checkers are found' do
+      @ext.instance_variable_set :@checker, @cls.new
+      flexmock(Ruber[:syntax_checker]).should_receive(:syntax_checker_for).once.and_return nil
+      @doc.instance_eval{emit document_url_changed(self)}
+      @ext.instance_variable_get(:@checker).should be_nil
+    end
+    
+  end
+  
+  context 'when the plugin emits the syntax_checker_added signal' do
+    
+    context 'and the extension has no syntax checker' do
+      
+      it 'creates a syntax checker if possible' do
+        cls = Class.new{def check_syntax *args;end}
+        flexmock(Ruber[:syntax_checker]).should_receive(:syntax_checker_for).with(@doc).once.and_return cls
+        @plug.instance_eval{emit syntax_checker_added}
+        @ext.instance_variable_get(:@checker).should be_a(cls)
+      end
+      
+    end
+    
+    context 'and the extension alredy has a syntax checker' do
+      
+      it 'does nothing' do
+        @ext.instance_variable_set :@checker, Object.new
+        flexmock(Ruber[:syntax_checker]).should_receive(:syntax_checker_for).with(@doc).never
+        @plug.instance_eval{emit syntax_checker_added}
+      end
+        
+    end
+    
+  end
+  
+  context 'when the plugin emits the syntax_checker_removed signal' do
+    
+    it 'attempts to create a new syntax checker if possible' do
+      cls = Class.new{def check_syntax *args;end}
+      flexmock(Ruber[:syntax_checker]).should_receive(:syntax_checker_for).with(@doc).once.and_return cls
+      @plug.instance_eval{emit syntax_checker_removed}
+      @ext.instance_variable_get(:@checker).should be_a(cls)
+    end
+    
+  end
+  
+  context 'when the syntax checker is changed' do
+    
+    context 'and the syntax_checker/auto_check document option is true' do
+      
+      before do
+        @doc.own_project[:syntax_checker, :auto_check] = true
+      end
+      
+      it 'performs a syntax check' do
+        cls = Class.new
+        flexmock(@plug).should_receive(:syntax_checker_for).and_return cls
+        mk = flexmock{|m| m.should_receive(:check_syntax).once}
+        flexmock(cls).should_receive(:new).once.and_return mk
+        @plug.instance_eval{emit syntax_checker_added}
+      end
+      
+    end
+    
+    context 'and the syntax_checker/auto_check document option is false' do
+      
+      before do
+        @doc.own_project[:syntax_checker, :auto_check] = false
+      end
+      
+      it 'performs a syntax check' do
+        cls = Class.new
+        flexmock(@plug).should_receive(:syntax_checker_for).and_return cls
+        mk = flexmock{|m| m.should_receive(:check_syntax).never}
+        flexmock(cls).should_receive(:new).once.and_return mk
+        @plug.instance_eval{emit syntax_checker_added}
+      end
+      
+    end
+    
+  end
+  
+  describe '#check_syntax' do
+    
+    context 'if there\'s a syntax checker' do
+      
+      before do
+        @checker = flexmock{|mk| mk.should_receive(:check_syntax).by_default}
+        @ext.instance_variable_set :@checker, @checker
+      end
+      
+      it 'calls the check_syntax method of the checker passing it the text of the document and the value of the :format key' do
+        @doc.text = 'xyz'
+        @checker.should_receive(:check_syntax).once.with 'xyz', true
+        @ext.check_syntax :format => true
+      end
+
+      context 'and the #check_syntax method of the syntax checker returns nil' do
+        
+        it 'returns a hash with the :result entry set to :correct and the :errors entry set to nil' do
+          @checker.should_receive(:check_syntax).and_return nil
+          @ext.check_syntax.should == {:result => :correct, :errors => nil}
+        end
+        
+      end
+      
+      context 'and the #check_syntax method of the syntax checker returns an array' do
+
+        it 'returns a hash with the :result entry set to :incorrect and the :errors entry set to the array' do
+          errors = [OpenStruct.new(:line => 0, :column => 2)]
+          @checker.should_receive(:check_syntax).and_return errors
+          @ext.check_syntax.should == {:result => :incorrect, :errors => errors}
+        end
+        
+      end
+      
+      context 'and the #check_syntax method of the syntax checker raises Ruber::SyntaxChecker::SyntaxNotChecked' do
+        
+        it 'returns a hash with the :result entry set to :unknown and the :errors entry set to nil' do
+          flexmock(@checker).should_receive(:check_syntax).and_raise(Ruber::SyntaxChecker::SyntaxNotChecked)
+          @ext.check_syntax.should == {:result => :unknown, :errors => nil}
+        end
+
+      end
+      
+    end
+    
+    context 'and there isn\'t a syntax checker' do
+      
+      it 'doesn\'t attempt to call the check_syntax method of the syntax checker' do
+        lambda{@ext.check_syntax}.should_not raise_error
+      end
+      
+      it 'returns a hash with the :result entry set to :unknown and the :errors entry set to nil' do
+        @ext.check_syntax.should == {:result => :unknown, :errors => nil}
+      end
+      
+    end
+    
+    context 'if the :format and :update options are true' do
+      
+      before do
+        @checker = flexmock{|mk| mk.should_receive(:check_syntax).by_default}
+        @ext.instance_variable_set :@checker, @checker
+      end
+      
+      it 'sets the :status entry to the same value of the :result entry in the returned hash' do
+        @checker.should_receive(:check_syntax).once.and_return nil
+        @checker.should_receive(:check_syntax).once.and_return []
+        @ext.check_syntax :format => true, :update => true
+        @ext.status.should == :correct
+        @ext.check_syntax :format => true, :update => true
+        @ext.status.should == :incorrect
+        @ext.instance_variable_set :@checker, nil
+        @ext.check_syntax :format => true, :update => true
+        @ext.status.should == :unknown
+      end
+      
+      it 'sets the errors attribute to the value returned by the #check_syntax method of the checker' do
+        errors = [
+          OpenStruct.new(:line => 0, :column => 2),
+          OpenStruct.new(:line => 1, :column => 0),
+        ]
+        flexmock(@checker).should_receive(:check_syntax).once.and_return errors
+        flexmock(@checker).should_receive(:check_syntax).once.and_return nil
+        @ext.check_syntax
+        @ext.errors.should == errors
+        @ext.check_syntax
+        @ext.errors.should be_nil
+      end
+      
+      it 'sets the errors attribute to nil if there\'s no syntax checker' do
+        @ext.instance_variable_set :@checker, nil
+        @ext.check_syntax :format => true, :update => true
+        @ext.errors.should be_nil
+      end
+      
+      it 'emits the syntax_checked signal passing the document as argument' do
+        mk = flexmock{|m| m.should_receive(:syntax_checked).once.with(@doc)}
+        @ext.connect(SIGNAL('syntax_checked(QObject*)')){|doc| mk.syntax_checked doc}
+        @ext.check_syntax
+      end
+      
+      context 'and the #check_syntax method of the checker returns non-nil' do
+        
+        it 'adds a mark of a custom type for each found error to the document' do
+          pending "Use marks only when KTextEditor::MarkInterface actually works"
+          @doc.text = "abc\ncde\nfgh"
+          errors = [
+            Ruber::SyntaxChecker::SyntaxError.new(0,2),
+            Ruber::SyntaxChecker::SyntaxError.new(1,0)
+          ]
+          flexmock(@checker).should_receive(:check_syntax).and_return errors
+          @ext.check_syntax
+          iface = @doc.interface('mark_interface')
+          (iface.mark(0) & @ext.class::SyntaxErrorMark).should_not == 0
+          (iface.mark(1) & @ext.class::SyntaxErrorMark).should_not == 0
+          (iface.mark(2) & @ext.class::SyntaxErrorMark).should == 0
+        end
+        
+        it 'doesn\'t add marks for errors without a line number' do
+          pending "Use marks only when KTextEditor::MarkInterface#marks actually works"
+          @doc.text = "abc\ncde\nfgh"
+          checker = Object.new
+          @ext.instance_variable_set :@checker, checker
+          errors = [
+            Ruber::SyntaxChecker::SyntaxError.new(0,2),
+            Ruber::SyntaxChecker::SyntaxError.new(nil, 2)
+          ]
+          flexmock(checker).should_receive(:check_syntax).and_return errors
+          @ext.check_syntax
+          iface = @doc.interface('mark_interface')
+          (iface.mark(0) & @ext.class::SyntaxErrorMark).should_not == 0
+          (iface.mark(1) & @ext.class::SyntaxErrorMark).should == 0
+          (iface.mark(2) & @ext.class::SyntaxErrorMark).should == 0
+        end
+        
+      end
+      
+      context 'and the #check_syntax method of the checker returns nil' do
+        
+        it 'clears all the marks put by the extension' do
+          pending "Use marks only when KTextEditor::MarkInterface actually works"
+          @doc.text = "abc\ncde\nfgh"
+          iface = @doc.interface('mark_interface')
+          iface.add_mark 0, @ext.class::SyntaxErrorMark 
+          iface.add_mark 2, @ext.class::SyntaxErrorMark
+          flexmock(@checker).should_receive(:check_syntax).and_return nil
+          iface.marks.should be_empty
+        end
+        
+      end
+      
+    end
+    
+    shared_examples_for 'the syntax checker extension when it should not update after a syntax check' do
+      
+      before do
+        @checker = Object.new
+        flexmock(@checker).should_receive(:check_syntax).by_default
+        @ext.instance_variable_set :@checker, @checker
+      end
+
+      it 'doesn\'t change the marks' do
+        pending "Use marks only when KTextEditor::MarkInterface actually works"
+      end
+      
+      it 'doesn\'t emit the syntax_checked signal' do
+        mk = flexmock{|m| m.should_receive(:syntax_checked).never}
+        @ext.connect(SIGNAL('syntax_checked(QObject*)')){|doc| mk.syntax_checked doc}
+        @ext.check_syntax @options
+      end
+      
+      it 'doesn\'t change the errors attribute' do
+        errors = [
+          OpenStruct.new(:line => 0, :column => 2),
+          OpenStruct.new(:column => 2)
+        ]
+        @ext.instance_variable_set :@errors, errors
+        flexmock(@checker).should_receive(:check_syntax).and_return nil
+        @ext.check_syntax @options
+        @ext.errors.should == errors
+      end
+      
+    end
+    
+    context 'when the :format option is false' do
+      
+      before do
+        @options = {:format => false, :update => true}
+      end
+      
+      it_behaves_like 'the syntax checker extension when it should not update after a syntax check'
+
+    end
+    
+    context 'when the :update option is false' do
+      
+      before do
+        @options = {:format => true, :update => false}
+      end
+      
+      it_behaves_like 'the syntax checker extension when it should not update after a syntax check'
+
+    end
+    
+  end
+  
+  shared_examples_for 'the syntax checker extension doing an auto syntax check' do
+    
+    context 'if the syntax_checker/check document option is true' do
+      
+      before do
+        @doc.own_project[:syntax_checker, :auto_check] = true
+      end
+      
+      it 'checks the document syntax passing no arguments to #check_syntax' do
+        flexmock(@ext).should_receive(:check_syntax).once.with_no_args
+        @proc.call
+      end
+      
+    end
+    
+    context 'if the syntax_checker/auto_check document option is false' do
+      
+      before do
+        @doc.own_project[:syntax_checker, :auto_check] = false
+      end
+      
+      it 'doesn\'t check the document syntax' do
+        flexmock(@ext).should_receive(:check_syntax).never
+        @proc.call
+      end
+      
+    end
+    
+  end
+  
+  context 'when the document is saved' do
+    
+    before do
+      @proc = Proc.new{@doc.instance_eval{emit document_saved_or_uploaded(self, false)}}
+    end
+    
+    it_behaves_like 'the syntax checker extension doing an auto syntax check'
+    
+  end
+  
+  context 'when the document becomes active' do
+    
+    before do
+      @proc = Proc.new{@doc.activate}
+    end
+
+    it_behaves_like 'the syntax checker extension doing an auto syntax check'
+    
+    it 'creates a single shot timer' do
+      @doc.activate
+      timer = @ext.instance_variable_get :@timer
+      timer.should be_a(Qt::Timer)
+      timer.singleShot.should be_true
+    end
+    
+  end
+  
+  context 'when the document becomes inactive' do
+    
+    before do
+      @doc.activate
+    end
+    
+    it 'stops the timer' do
+      flexmock(@ext.instance_variable_get(:@timer)).should_receive(:stop).once
+      @doc.deactivate
+    end
+    
+    it 'calls the #delete_later method of the timer' do
+      flexmock(@ext.instance_variable_get(:@timer)).should_receive(:delete_later).once
+      @doc.deactivate
+    end
+    
+    it 'removes the timer' do
+      @doc.deactivate
+      @ext.instance_variable_get(:@timer).should be_nil
+    end
+        
+  end
+  
+  context 'when the plugin emits the settings_changed signal' do
+    
+    it 'reads the syntax_checker/time_interval option from the config' do
+      flexmock(Ruber[:config]).should_receive(:[]).with(:syntax_checker, :time_interval).once.and_return 10
+      @plug.instance_eval{emit settings_changed}
+    end
+    
+  end
+  
+  context 'when the text in the document changes' do
+    
+    context 'and the document is active' do
+      
+      before do
+        @doc.deactivate
+        @doc.activate
+      end
+      
+      context 'and the time interval is greater than 0' do
+        
+        it 'starts the timer using the given time interval multiplied by 1000' do
+          @ext.instance_variable_set :@time_interval, 10
+          timer = @ext.instance_variable_get :@timer
+          flexmock(timer).should_receive(:start).with(10_000).once
+          @doc.text = 'y'
+        end
+        
+      end
+      
+      context 'and the time interval is 0' do
+        
+        it 'doesn\'t start the timer' do
+          @ext.instance_variable_set :@time_interval, 0
+          timer = @ext.instance_variable_get :@timer
+          flexmock(timer).should_receive(:start).never
+          @doc.text = 'x'
+        end
+        
+        
+      end
+      
+    end
+    
+    context 'and the document is not active' do
+      
+      before do
+        @doc.deactivate
+      end
+      
+      it 'doesn\'t attempt to start the timer' do
+        @ext.instance_variable_set :@time_interval, 10
+        timer = @ext.instance_variable_get :@timer
+        flexmock(timer).should_receive(:start).never
+        @doc.text = 'x'
+      end
+      
+    end
+    
+  end
+  
+  context 'when the timer times out' do
+    
+    it 'calls the auto_check method' do
+      @doc.activate
+      flexmock(@ext).should_receive(:auto_check).once
+      @ext.instance_variable_get(:@timer).instance_eval{emit timeout}
+    end
+    
+  end
+  
+  describe '#remove_from_project' do
+    
+    it 'stops the timer' do
+      @doc.activate
+      flexmock(@ext.instance_variable_get(:@timer)).should_receive(:stop).once
+      @ext.remove_from_project
+      #needed becouse remove_from_project is called in the after block when 
+      #unloading the plugin. Without this, the method is called twice
+      flexmock(@ext).should_receive(:remove_from_project)
+    end
+    
+    it 'doesn\'t stop the timer if it doesn\'t exist' do
+      @ext.instance_variable_set(:@timer, nil)
+      lambda{@ext.remove_from_project}.should_not raise_error
+    end
+    
+  end
+  
+end