ruber 0.0.1.1

data/spec/document_project_spec.rb

@@ -0,0 +1,373 @@
+require 'spec/common'
+
+require 'tempfile'
+
+require 'ruber/editor/document'
+require 'ruber/document_project'
+
+
+class DocumentProjectSpecComponentManager < Qt::Object
+  extend Forwardable
+  signals 'component_loaded(QObject*)', 'unloading_component(QObject*)'
+  def_delegators :@data, :[], :<<
+  def_delegator :@data, :each, :each_component
+  
+  def initialize parent = nil
+    super
+    @data = []
+  end
+  
+end
+
+
+describe Ruber::DocumentProject::Backend do
+  
+  it 'inherits Ruber::YamlSettingsBackend' do
+    Ruber::DocumentProject::Backend.ancestors.should include(Ruber::YamlSettingsBackend)
+  end
+  
+  describe ', when created' do
+    
+    it 'accepts a path as argument' do
+      lambda{Ruber::DocumentProject::Backend.new __FILE__}.should_not raise_error
+    end
+    
+    it 'uses an empty string as file name if the path is empty' do
+      Ruber::DocumentProject::Backend.new('').file.should be_empty
+    end
+    
+    it 'creates an hexdigest of the document name and uses it as the file name' do
+      path = "#{ENV['HOME']}/test.rb"
+      exp = '0e589e6c62cec2f5c41117ada4a28c52'
+      bk = Ruber::DocumentProject::Backend.new path
+      File.basename(bk.file).should == exp
+    end
+
+    it 'sets the directory of the associated file to $appdir/documents' do
+      path = "#{ENV['HOME']}/test.rb"
+      exp = File.join(ENV['HOME'], '.kde4/share/apps/test/documents')
+      bk = Ruber::DocumentProject::Backend.new path
+      File.dirname(bk.file).should == exp
+    end
+    
+    it 'doesn\'t rise an exception if the file isn\'t a valid project file' do
+      path = "#{ENV['HOME']}/test.rb"
+      flexmock(File).should_receive(:exist?).once.and_return true
+      flexmock(File).should_receive(:read).once.and_return '{'
+      bk = nil
+      lambda{bk = Ruber::DocumentProject::Backend.new path}.should_not raise_error
+      bk.instance_variable_get(:@data).should == {}
+    end
+    
+    it 'has no old files' do
+      Ruber::DocumentProject::Backend.new( __FILE__).instance_variable_get(:@old_files).should be_empty
+    end
+    
+  end
+  
+  describe "#write" do
+    
+    before do
+      @dir = File.join Dir.tmpdir, 'ruber_project_document_option_backend'
+      FileUtils.mkdir @dir
+      @filename = File.join @dir, 'ruber_project_document_option_backend.yaml'
+      @doc = File.join(ENV['HOME'],'test.rb')
+      @back = Ruber::DocumentProject::Backend.new @doc
+      @back.instance_variable_set :@filename, @filename
+    end
+    
+    after do
+      FileUtils.rm_rf @dir
+    end
+    
+    it 'raises Errno::ENOENT if the backend isn\'t associated with a file' do
+      @back.instance_variable_set :@filename, ''
+      lambda do
+        @back.write({OS.new(:name => :o1, :group => :G1, :default => 3) => 5})
+      end.should raise_error(Errno::ENOENT)
+    end
+    
+    it 'behaves as YamlSettingsBackend#write if there are options to be written' do
+      @back.instance_variable_set :@data, {:G1 => {:o1 => 1}}
+      @back.write({OS.new(:name => :o1, :group => :G1, :default => 3) => 5})
+      (YAML.load File.read(@filename)).should == {:G1 => {:o1 => 5}}
+      @back.instance_variable_get(:@data).should == {:G1 => {:o1 => 5}}
+    end
+    
+    it 'doesn\'t write anything to file if the only option is the project name' do
+      @back.write( {OS.new(:name => :project_name, :group => :general, :default => nil) => @doc})
+      File.exist?(@filename).should be_false
+    end
+    
+    it 'deletes the file when it exists and the only option to write would be the project name' do
+      `touch #{@filename}`
+      @back.write( {OS.new(:name => :project_name, :group => :general, :default => nil) => @doc})
+      File.exist?(@filename).should be_false
+    end
+    
+    it 'deletes all the old files' do
+      files = %w[x y].map{|f| File.join @dir, f}
+      files.each do |f|
+        @back.instance_variable_get(:@old_files) << f
+        `touch #{f}`
+      end
+      @back.write({OS.new(:name => :o1, :group => :G1, :default => 3) => 5})
+      files.each{|f| File.exist?(f).should be_false}
+    end
+    
+    it 'clears the list of old files' do
+      files = %w[x y].map{|f| File.join @dir, f}
+      @back.instance_variable_set(:@old_files, files)
+      @back.write({OS.new(:name => :o1, :group => :G1, :default => 3) => 5})
+      @back.instance_variable_get(:@old_files).should be_empty
+    end
+      
+  end
+  
+  describe "#document_path=" do
+    
+    before do
+      @doc = File.join(ENV['HOME'],'test.rb')
+      @back = Ruber::DocumentProject::Backend.new @doc
+    end
+    
+    
+    it 'sets the project name to the argument' do
+      file = File.join(ENV['HOME'],'test1.rb')
+      @back.document_path = file
+      @back.instance_variable_get(:@data)[:general][:project_name].should == file
+    end
+    
+    it 'changes the file name according to the argument' do
+      file = File.join(ENV['HOME'],'test1.rb')
+      exp = (Digest::MD5.new << file).hexdigest
+      @back.document_path = file
+      @back.file.should == File.join(KDE::Global.dirs.locate_local('appdata', 'documents/'), exp)
+    end
+    
+    it 'adds the old file name to the list of old files, unless it was empty' do
+      file = File.join(ENV['HOME'],'test1.rb')
+      old = @back.file
+      @back.document_path = file
+      @back.instance_variable_get(:@old_files).should include(old)
+      @back = Ruber::DocumentProject::Backend.new ''
+      @back.document_path = file
+      @back.instance_variable_get(:@old_files).should be_empty
+    end
+    
+  end
+
+end
+
+describe Ruber::DocumentProject do
+  
+  include FlexMock::ArgumentTypes
+  
+  before(:all) do
+    
+    class Ruber::DocumentProject
+      
+      def connect *args
+        super
+      end
+      
+      alias_method :old_connect, :connect
+      
+      def connect *args, &blk
+        @_connections ||= []
+        args << blk if blk
+        @_connections << args
+      end
+      
+    end
+    
+  end
+  
+  after(:all) do
+    
+    class Ruber::DocumentProject 
+    alias_method :connect, :old_connect
+    end
+  end
+  
+  it 'derives from AbstractProject' do
+    Ruber::DocumentProject.ancestors.should include(Ruber::AbstractProject)
+  end
+  
+  def create_doc path
+    doc = Qt::Object.new
+    class << doc
+      attr_accessor :path
+    end
+    doc.path = path
+    doc
+  end
+  
+  before do
+    @app = KDE::Application.instance
+    @comp = DocumentProjectSpecComponentManager.new
+    flexmock(Ruber).should_receive(:[]).with(:components).and_return(@comp).by_default
+    flexmock(Ruber).should_receive(:[]).with(:app).and_return(@comp).by_default
+  end
+  
+  describe ', when created' do
+    
+    it 'accepts a document as parameter' do
+      doc = create_doc __FILE__
+      lambda{Ruber::DocumentProject.new doc}.should_not raise_error
+    end
+    
+    it 'uses the document as parent' do
+      doc = create_doc __FILE__
+      prj = Ruber::DocumentProject.new doc
+      prj.parent.should equal(doc)
+    end
+    
+    it 'uses Ruber::DocumentProject::Backend as backend and the file associated with the document as project name, if needed' do
+      doc = create_doc __FILE__
+      prj = Ruber::DocumentProject.new doc
+      prj.instance_variable_get(:@backend).should be_a(Ruber::DocumentProject::Backend)
+      prj.project_name.should == __FILE__
+      file = '/home/stefano/xyz/document_project_spec_data_.rb'
+      md5 = Digest::MD5.new
+      md5 << file
+      data_path = File.join ENV['HOME'], '.kde4/share/apps/test/documents', md5.hexdigest
+      File.open(data_path, 'w'){|f| YAML.dump( {:general => {:project_name => file}}, f)}
+      doc = create_doc file
+      prj = Ruber::DocumentProject.new doc
+      prj.project_name.should == file
+      FileUtils.rm_rf data_path
+    end
+    
+    it 'doesn\'t raise an error if the document isn\'t associated with a file' do
+      doc = create_doc ''
+      prj = nil
+      lambda{prj = Ruber::DocumentProject.new doc}.should_not raise_error
+      prj.project_name.should be_empty
+    end
+    
+    it 'connects the document\s "document_url_changed(QObject*)" signal with its "change_file()" slot' do
+      doc = create_doc File.join(ENV['HOME'], 'test.rb')
+      prj = Ruber::DocumentProject.new doc
+      prj.instance_variable_get(:@_connections).should include([doc, SIGNAL('document_url_changed(QObject*)'), prj, SLOT(:change_file)])
+    end
+    
+  end
+  
+  describe "#scope" do
+    
+    it 'returns :document' do
+      doc = create_doc __FILE__
+      prj = Ruber::DocumentProject.new doc
+      prj.scope.should == :document
+    end
+    
+  end
+  
+  describe '#match_rule?' do
+    
+    it 'returns false if the rule\'s scope doesn\'t include :document' do
+      doc = create_doc __FILE__
+      prj = Ruber::DocumentProject.new doc
+      o1 = OS.new(:file_extension => [], :scope => [:global], :mimetype => [])
+      flexmock(doc).should_receive(:file_type_match?).with([], []).and_return true
+      prj.match_rule?(o1).should be_false
+    end
+    
+    it 'returns false if the document\'s file_type_match? method returns false' do
+      doc = create_doc __FILE__
+      prj = Ruber::DocumentProject.new doc
+      o1 = OS.new(:file_extension => ['*.rb'], :scope => [:document], :mimetype => [])
+      flexmock(doc).should_receive(:file_type_match?).once.with([], ['*.rb']).and_return false
+      prj.match_rule?(o1).should be_false
+    end
+    
+    it 'returns true if both the mimetype and the file extension of the rule match those of the document and the rule\'s scope include :document' do
+      doc = create_doc __FILE__
+      prj = Ruber::DocumentProject.new doc
+      o1 = OS.new(:file_extension => ['*.rb'], :scope => [:document], :mimetype => [])
+      flexmock(doc).should_receive(:file_type_match?).once.with([], ['*.rb']).and_return true
+      prj.match_rule?(o1).should be_true
+    end
+    
+  end
+  
+  describe '#change_file' do
+    
+    it 'changes the filename associated with the backend' do
+      file = File.join ENV['HOME'], 'test.rb'
+      new_file = File.join ENV['HOME'], 'test.rb1'
+      doc = create_doc file
+      prj = Ruber::DocumentProject.new doc
+      flexmock(prj.instance_variable_get(:@backend)).should_receive(:document_path=).once.with new_file
+      doc.path = new_file
+      prj.send :change_file
+    end
+    
+  end
+  
+  describe "#project_directory" do
+    
+    before do
+      @app = KDE::Application.instance
+      @comp = DocumentProjectSpecComponentManager.new
+      flexmock(Ruber).should_receive(:[]).with(:components).and_return(@comp).by_default
+      flexmock(Ruber).should_receive(:[]).with(:app).and_return(@comp).by_default
+    end
+    
+    it 'returns the directory where the document is if the document is associated with a file' do
+      doc = create_doc __FILE__
+      prj = Ruber::DocumentProject.new doc
+      prj.project_directory.should == File.dirname(__FILE__)
+    end
+    
+    it 'returns the current directory if the document is not associated with a file' do
+      doc = create_doc ''
+      prj = Ruber::DocumentProject.new doc
+      prj.project_directory.should == Dir.pwd
+    end
+    
+  end
+  
+  describe '#write' do
+    
+    it 'calls the backend\'s write method' do
+      doc = create_doc __FILE__
+      prj = Ruber::DocumentProject.new doc
+      flexmock(prj.instance_variable_get(:@backend)).should_receive(:write).once
+      prj.write
+    end
+    
+    it 'doesn\'t raise an exception if the document isn\'t associated with a file' do
+      doc = create_doc ''
+      prj = Ruber::DocumentProject.new doc
+      flexmock(prj.instance_variable_get(:@backend)).should_receive(:write).once.and_raise(Errno::ENOENT)
+      prj.write
+    end
+    
+    it 'raises an exception if the backend raises Errno::ENOENT but the document is associated with a file' do
+      doc = create_doc __FILE__
+      prj = Ruber::DocumentProject.new doc
+      flexmock(prj.instance_variable_get(:@backend)).should_receive(:write).once.and_raise(Errno::ENOENT)
+      lambda{prj.write}.should raise_error(Errno::ENOENT)
+    end
+    
+  end
+  
+  describe '#files' do
+    
+    it 'returns an array containing the path of the file if the document is associated with a file' do
+      doc = create_doc __FILE__
+      prj = Ruber::DocumentProject.new doc
+      prj.files.should == [__FILE__]
+    end
+    
+    it 'returns an empty array if the document isn\'t associated with a path' do
+      doc = create_doc ''
+      prj = Ruber::DocumentProject.new doc
+      prj.files.should == []
+    end
+    
+  end
+  
+end

data/spec/document_spec.rb

@@ -0,0 +1,779 @@
+require 'spec/common'
+
+require 'tempfile'
+require 'fileutils'
+require 'flexmock/argument_types'
+require 'facets/string/camelcase'
+
+require 'ruber/editor/document'
+
+class DocumentSpecComponentManager < Qt::Object
+  extend Forwardable
+  signals 'component_loaded(QObject*)', 'unloading_component(QObject*)'
+  def_delegators :@data, :[], :<<
+  def_delegator :@data, :each, :each_component
+  
+  def initialize parent = nil
+    super
+    @data = []
+  end
+  
+end
+
+describe Ruber::Document do
+  
+  include FlexMock::ArgumentTypes
+  
+  before do
+    @app = KDE::Application.instance
+    @w = Qt::Widget.new
+    @comp = DocumentSpecComponentManager.new
+    flexmock(Ruber).should_receive(:[]).with(:components).and_return(@comp)
+    @doc = Ruber::Document.new @app
+  end
+  
+  describe ', when created' do
+
+    it 'should load a KTextEditor::Document' do
+      @doc.instance_variable_get(:@doc).should be_instance_of(KTextEditor::Document)
+    end
+
+    it 'has an annotation model' do
+      @doc.interface('annotation_interface').annotation_model.should_not be_nil
+    end
+    
+    it 'should not have a view' do
+      @doc.view.should be_nil
+    end
+
+    it 'should open a given file if new is called with a string or KDE::Url second argument' do
+      doc = Ruber::Document.new @app, __FILE__
+      doc.text.should == File.read(__FILE__)
+      doc.url.path.should == __FILE__
+      doc = Ruber::Document.new @app, KDE::Url.from_path(__FILE__)
+      doc.text.should == File.read(__FILE__)
+      doc.url.path.should == __FILE__
+    end
+    
+    it 'creates a document project for itself, after opening the file (if given)' do
+      doc = Ruber::Document.new @app
+      prj = doc.instance_variable_get(:@project)
+      prj.should be_a(Ruber::DocumentProject)
+      prj.project_name.should be_empty
+      doc = Ruber::Document.new @app, __FILE__
+      prj = doc.instance_variable_get(:@project)
+      prj.should be_a(Ruber::DocumentProject)
+      prj.project_name.should == __FILE__
+    end
+    
+    
+    it 'should not be active' do
+      doc = Ruber::Document.new @app, __FILE__
+      doc.should_not be_active
+    end
+    
+  end
+  
+  describe '#own_project' do
+  
+    it 'returns the DocumentProject associated with the document' do
+      doc = Ruber::Document.new @app, __FILE__
+      doc.own_project.project_name.should == __FILE__
+    end
+
+  end
+  
+  describe '#project' do
+    
+    before do
+      @list = flexmock
+      @prj = flexmock(:project_files => @list)
+      @projects = flexmock{|m| m.should_receive(:current).and_return(@prj).by_default}
+      flexmock(Ruber).should_receive(:[]).with(:projects).and_return(@projects)
+      @doc = Ruber::Document.new @app, __FILE__
+    end
+    
+    it 'returns the current project if one exists and the document belongs to it' do
+      flexmock(@list).should_receive(:file_in_project?).with(__FILE__).and_return true
+      @doc.project.should == @prj
+    end
+    
+    it 'returns the document project if the file associated with the document doesn\'t belong to the current project' do
+      flexmock(@list).should_receive(:file_in_project?).with(__FILE__).and_return false
+      @doc.project.should be_a(Ruber::DocumentProject)
+    end
+    
+    it 'returns the document project if the document isn\'t associated with a file' do
+      @doc = Ruber::Document.new @app
+      @doc.project.should be_a(Ruber::DocumentProject)
+    end
+    
+    it 'returns the document project if there isn\'t a project open' do
+      @projects.should_receive(:current).and_return nil
+      @doc.project.should be_a(Ruber::DocumentProject)
+    end
+    
+  end
+  
+  describe '#save' do
+    
+    it 'calls document_save_as if the document has no filename' do
+      flexmock(@doc).should_receive(:document_save_as).once.and_return(true)
+      flexmock(@doc).should_receive(:document_save_as).once.and_return(false)
+      @doc.save.should be_true
+      @doc.save.should be_false
+      #     tmp_file = File.join Dir.tmpdir, "ruber_document_test" + 3.times.map{rand(10)}.join.to_s
+      #     flexmock(KDE::FileDialog).should_receive(:get_save_file_name).times(2).and_return(nil, tmp_file)
+      #     @doc.text = 'test'
+      #     @doc.save.should be_false
+      #     @doc.save.should be_true
+      #     File.exists?(tmp_file).should be_true
+      #     File.read(tmp_file).should == 'test'
+      #     FileUtils.rm tmp_file
+    end
+    
+    describe ', when the document is associated with a file' do
+      
+      it 'calls the document_save_as method if the document is read only' do
+        Tempfile.open('ruber_document_test') do |f|
+          f.write 'test'
+          f.flush
+          doc = Ruber::Document.new nil, f.path
+          flexmock(doc.send :internal).should_receive(:is_read_write).once.and_return false
+          flexmock(doc).should_receive(:document_save_as).once
+          doc.text += ' added'
+          doc.save
+        end
+      end
+      
+      it 'calls its own project\'s save method' do
+        Tempfile.open('ruber_document_test') do |f|
+          f.write 'test'
+          f.flush
+          doc = Ruber::Document.new nil, f.path
+          flexmock(doc.own_project).should_receive(:save).once
+          doc.text += ' added'
+          doc.save
+        end
+      end
+      
+      it 'saves the document if the document is associated with a file' do
+        Tempfile.open('ruber_document_test') do |f|
+          f.write 'test'
+          f.flush
+          doc = Ruber::Document.new nil, f.path
+          doc.text += ' added'
+          doc.save.should be_true
+          File.read( f.path ).should == 'test added'
+        end
+      end
+      
+    end
+
+  end
+  
+  it 'should allow to create a view if none exists' do
+    @doc.create_view(Qt::Widget.new).should_not be_nil
+  end
+
+  it 'should not allow to create a view if one already exists' do
+    @doc.create_view(Qt::Widget.new)
+    lambda{@doc.create_view(Qt::Widget.new)}.should raise_error(RuntimeError)
+  end
+
+  it 'should allow to get and change the text' do
+    txt="test text"
+    lambda{@doc.text="test text"}.should_not raise_error
+    @doc.text.should == txt
+  end
+
+  it 'should return the mimetype of the document' do
+    @doc.mime_type.should == 'text/plain'
+    @doc.open_url KDE::Url.from_path(__FILE__)
+    @doc.mime_type.should == 'application/x-ruby'
+  end
+
+  it 'should return the view attached to it (or nil) with the view method' do
+    @doc.view.should be_nil
+    @doc.create_view nil
+    @doc.view.should be_instance_of Ruber::EditorView
+    @doc.view.close
+  end
+
+  it 'should emit the "modified_changed(QObject*, bool)" signal when the modified status changes' do
+    m = flexmock
+    m.should_receive(:test).ordered.with(true, @doc)
+    m.should_receive(:test).ordered.with(false, @doc)
+    @doc.connect(SIGNAL('modified_changed(bool, QObject*)')){|mod, o| m.test mod, o}
+    d = @doc.instance_variable_get(:@doc)
+    d.instance_eval do
+      self.modified = true
+      emit modifiedChanged(self)
+      self.modified = false
+      emit modifiedChanged(self)
+    end
+
+  end
+
+  it 'should emit the "document_name_changed(QString, QObject*)" signal when the document name changes' do
+    m = flexmock
+    m.should_receive(:document_name_changed).twice
+    @doc.connect(SIGNAL('document_name_changed(QString, QObject*)')) do |str, obj|
+      obj.should == @doc
+      str.should == @doc.document_name
+      m.document_name_changed
+    end
+    @doc.open_url KDE::Url.from_path( __FILE__)
+  end
+
+  it 'should return the path of the file usgin the "path" method or an empty string if the document is not associated with a file' do
+    @doc.path.should == ''
+    @doc.open_url KDE::Url.from_path( __FILE__ )
+    @doc.path.should == __FILE__
+  end
+
+  it 'should return an empty string if the document is empty' do
+    @doc.text.should_not be_nil
+  end
+
+  it 'should tell whether it\'s associated with a file or not' do
+    @doc.should_not have_file
+    Ruber::Document.new(nil, __FILE__).should have_file
+  end
+
+  it 'should tell whether it\'s a pristine document' do
+    @doc.should be_pristine
+    @doc.text = "a"
+    @doc.should_not be_pristine
+    projects = flexmock(:current => nil)
+    config = flexmock{|m| m.should_receive(:[]).with(:general, :default_script_directory).and_return ENV['HOME']}
+    flexmock(Ruber).should_receive(:[]).with(:projects).and_return(projects)
+    flexmock(Ruber).should_receive(:[]).with(:config).and_return(config)
+    flexmock(Ruber).should_receive(:[]).with(:main_window).and_return(Qt::Widget.new)
+    Tempfile.open('ruber_document_test') do |f|
+      res = OpenStruct.new(:file_names => [f.path], :encoding => @doc.encoding)
+      flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).and_return(res)
+      flexmock(KDE::MessageBox).should_receive(:warning_continue_cancel).and_return KDE::MessageBox::Continue
+      @doc.save
+      @doc.should_not be_pristine
+    end
+    Ruber::Document.new(nil, __FILE__).should_not be_pristine
+  end
+
+  ["text_changed(QObject*)", "about_to_close(QObject*)", 'about_to_close(QObject*)', 
+'about_to_reload(QObject*)', 'document_url_changed(QObject*)'].each do |sig|
+    sig_name = sig[0...sig.index('(')]
+    o_sig_name = sig_name.camelcase(false)
+    o_sig = sig.camelcase(false).sub('(QObject*','(KTextEditor::Document*')
+    it "should emit the \"#{sig}\" signal in response to the underlying KTextEditor::Document \"#{o_sig}\" signal" do
+    m = flexmock
+    m.should_receive( sig_name.to_sym).once.with(@doc.object_id)
+    @doc.connect(SIGNAL(sig)){|o| m.send(sig_name.to_sym, o.object_id)}
+    d = @doc.instance_variable_get(:@doc)
+    d.instance_eval "emit #{o_sig_name}( self)"
+    end
+  end
+
+  it 'should emit the "mode_changed(QObject*)" signal in response to the underlying KTextEditor::Document "modeChanged(KTextEditor::Document)" signal' do
+    m = flexmock
+    m.should_receive( :mode_changed).once.with(@doc.object_id)
+    @doc.connect(SIGNAL('mode_changed(QObject*)')){|o| m.mode_changed o.object_id}
+    @doc.mode = "Ruby"
+  end
+
+  it 'should emit the "highlighting_mode_changed(QObject*)" signal in response to the underlying KTextEditor::Document "highlightingModeChanged(KTextEditor::Document)" signal' do
+    m = flexmock
+    m.should_receive( :h_mode_changed).once.with(@doc.object_id)
+    @doc.connect(SIGNAL('highlighting_mode_changed(QObject*)')){|o| m.h_mode_changed o.object_id}
+    @doc.highlighting_mode = "Ruby"
+  end
+
+  it 'should emit the "text_modified(KTextEditor::Range, KTextEditor::Range, QObject*)" signal in response to the underlying KTextEditor::Document "textChanged(KTextEditor::Document*, KTextEditor::Range, KTextEditor::Range)" signal' do
+    m = flexmock
+    m.should_receive( :text_modified).once.with(@doc.object_id)
+    @doc.connect(SIGNAL('text_modified(KTextEditor::Range, KTextEditor::Range, QObject*)')){|_r1, _r2, o| m.text_modified o.object_id}
+    d = @doc.instance_variable_get(:@doc)
+    d.instance_eval{emit textChanged(self, KTextEditor::Range.new(0,0,0,5), KTextEditor::Range.new(0,0,1,1))}
+  end
+
+  it 'should emit the "text_inserted(KTextEditor::Range, QObject*)" signal in response to the underlying KTextEditor::Document "textInserted(KTextEditor::Document*, KTextEditor::Range)" signal' do
+    m = flexmock
+    m.should_receive( :text_inserted).once.with(@doc.object_id)
+    @doc.connect(SIGNAL('text_inserted(KTextEditor::Range, QObject*)')){|_, o| m.text_inserted o.object_id}
+    d = @doc.instance_variable_get(:@doc)
+    d.instance_eval{emit textInserted(self, KTextEditor::Range.new(0,0,0,5))}
+  end
+
+  it 'should emit the "text_removed(KTextEditor::Range, QObject*)" signal in response to the underlying KTextEditor::Document "textRemoved(KTextEditor::Document*, KTextEditor::Range)" signal' do
+    m = flexmock
+    m.should_receive( :text_removed).once.with(@doc.object_id)
+    @doc.connect(SIGNAL('text_removed(KTextEditor::Range, QObject*)')){|_, o| m.text_removed o.object_id}
+    d = @doc.instance_variable_get(:@doc)
+    d.instance_eval{emit textRemoved(self, KTextEditor::Range.new(0,0,0,5))}
+  end
+
+  it 'emits the "view_created(QObject*, QObject*)" signal after creating a view' do
+    m = flexmock
+    m.should_receive( :view_created).once.with(@doc.object_id)
+    @doc.connect(SIGNAL('view_created(QObject*, QObject*)'))do |_, o| 
+      m.view_created o.object_id
+      @doc.view.should be_a(Ruber::EditorView)
+    end
+    @doc.create_view nil
+    @doc.view.close
+  end
+
+  it 'should return nil with the view method when a view has been closed' do
+    view = @doc.create_view
+    view.close
+    @doc.view.should be_nil
+  end
+
+  it 'should return true when close_url succeeds' do
+    doc = Ruber::Document.new nil, __FILE__
+    doc.close_url(false).should be_true
+  end
+  
+  it 'should call the update_project method of each component, passing it its project, when the name of the document changes, but before emitting the document_name_changed signal' do
+    3.times{@comp << flexmock{|m| m.should_receive(:update_project).once.with(Ruber::DocumentProject).globally.ordered} }
+    name_changed_rec = flexmock{|m| m.should_receive(:name_changed).once.globally.ordered}
+    internal = @doc.send :internal
+    @doc.connect(SIGNAL('document_name_changed(QString,QObject*)')){name_changed_rec.name_changed}
+    internal.instance_eval{emit documentNameChanged(self)}
+  end
+
+  after do
+    @doc.view.close if @doc.view
+    @doc.instance_variable_get(:@doc).closeUrl false
+    @doc.dispose
+  end
+
+end
+
+describe 'Ruber::Document#close' do
+  
+  before do
+    @app = KDE::Application.instance
+    @w = Qt::Widget.new
+    @comp = DocumentSpecComponentManager.new
+    flexmock(Ruber).should_receive(:[]).with(:components).and_return(@comp)
+    @doc = Ruber::Document.new @app
+    flexmock(@doc.instance_variable_get(:@project)).should_receive(:save).by_default
+  end
+  
+  it 'should return immediately if ask is true and query_close returns false' do
+    doc = Ruber::Document.new nil, __FILE__
+    exp = doc.object_id
+    m = flexmock('test'){|mk| mk.should_receive(:document_closing).never}
+    doc.connect(SIGNAL('closing(QObject*)')){|d| m.document_closing d.object_id}
+    flexmock(doc).should_receive(:query_close).and_return false
+    doc.close
+  end
+  
+  it 'calls the save method of the project after emitting the "closing" signal' do
+    @doc = Ruber::Document.new @app, __FILE__
+    m = flexmock{|mk| mk.should_receive(:document_closing).once.globally.ordered}
+    @doc.connect(SIGNAL('closing(QObject*)')){m.document_closing}
+    flexmock(@doc.instance_variable_get(:@project)).should_receive(:save).once.globally.ordered
+    @doc.close
+  end
+  
+  it 'doesn\'t call the save method of the project if the document isn\'t associated with a file' do
+    flexmock(@doc.instance_variable_get(:@project)).should_receive(:save).never
+    @doc.close
+  end
+  
+  it 'should call the "close_url", if closing is confirmed' do
+    doc = Ruber::Document.new nil, __FILE__
+    flexmock(doc).should_receive(:close_url).once.with(false)
+    doc.close
+    doc = Ruber::Document.new nil, __FILE__
+    flexmock(doc).should_receive(:close_url).once.with(false)
+    doc.close false
+  end
+  
+  it 'should emit the "closing(QObject*)" signal if closing is confirmed' do
+    doc = Ruber::Document.new nil, __FILE__
+    exp = doc.object_id
+    m = flexmock('test'){|mk| mk.should_receive(:document_closing).once.with(exp)}
+    flexmock(doc).should_receive(:close_url).and_return true
+    doc.connect(SIGNAL('closing(QObject*)')){|d| m.document_closing d.object_id}
+    flexmock(doc).should_receive(:query_close).and_return true
+    doc.close
+    doc = Ruber::Document.new nil, __FILE__
+    exp1 = doc.object_id
+    m.should_receive(:document_closing).with(exp1).once
+    flexmock(doc).should_receive(:query_close)
+    doc.connect(SIGNAL('closing(QObject*)')){|d| m.document_closing d.object_id}
+    doc.close false
+  end
+  
+  it 'should close the view, if there\'s one, after emitting the closing signal, if closing is confirmed' do
+    doc = Ruber::Document.new nil, __FILE__
+    v = doc.create_view
+    exp = doc.object_id
+    m = flexmock('test'){|mk| mk.should_receive(:document_closing).once.with(exp).globally.ordered}
+    flexmock(v).should_receive(:close).once.globally.ordered
+    flexmock(doc).should_receive(:close_url).and_return true
+    doc.connect(SIGNAL('closing(QObject*)')){|d| m.document_closing d.object_id}
+    flexmock(doc).should_receive(:query_close).and_return true
+    doc.close false
+  end
+  
+  it 'calls the #save method of the project if the document path is not empty' do
+    doc = Ruber::Document.new nil, __FILE__
+    exp = doc.object_id
+    flexmock(doc).should_receive(:close_url).and_return true
+    flexmock(doc.instance_variable_get(:@project)).should_receive(:save).once
+    doc.close false
+  end
+  
+  it 'doesn\'t call the #save method of the project if the document path is empty' do
+    doc = Ruber::Document.new nil
+    exp = doc.object_id
+    flexmock(doc).should_receive(:close_url).and_return true
+    flexmock(doc.instance_variable_get(:@project)).should_receive(:save).never
+    doc.close false
+  end
+  
+  it 'calls the #close method of the project passing false' do
+  doc = Ruber::Document.new nil
+  exp = doc.object_id
+  flexmock(doc).should_receive(:close_url).and_return true
+  flexmock(doc.instance_variable_get(:@project)).should_receive(:close).with(false).once
+  doc.close false
+end
+
+  
+  it 'should disconnect any slot/block connected to it after emitting the closing signal if closing is confirmed' do
+    doc = Ruber::Document.new nil, __FILE__
+    exp = doc.object_id
+    flexmock(doc).should_receive(:close_url).and_return true
+    def doc.disconnect *args;end
+    m = flexmock{|mk| mk.should_receive(:document_closing).with(exp).once.globally.ordered}
+    doc.connect(SIGNAL('closing(QObject*)')){|d| m.document_closing d.object_id}
+    flexmock(doc).should_receive(:disconnect).with_no_args.once.globally.ordered
+    doc.close false
+  end
+    
+  it 'should dispose of itself after emitting the closing signal, if closing is confirmed' do
+    doc = Ruber::Document.new nil, __FILE__
+    doc.close false
+    doc.should be_disposed
+  end
+  
+  it 'should return true, if closing is confirmed and successful and false otherwise' do
+    doc = Ruber::Document.new nil, __FILE__
+    flexmock(doc).should_receive(:close_url).once.and_return true
+    doc.close( false).should be_true
+    doc = Ruber::Document.new nil, __FILE__
+    flexmock(doc).should_receive(:close_url).once.and_return false
+    doc.close( false).should be_false
+    flexmock(doc).should_receive(:query_close).once.and_return false
+    doc.close(true).should be_false
+  end
+  
+end
+
+describe 'Ruber::Document#close_view' do
+  
+  before do
+    @app = KDE::Application.instance
+    @w = Qt::Widget.new
+    @comp = DocumentSpecComponentManager.new
+    flexmock(Ruber).should_receive(:[]).with(:components).and_return(@comp)
+    @doc = Ruber::Document.new @app
+    @view = @doc.create_view
+  end
+  
+  it 'should call the "close" method' do
+    flexmock(@doc).should_receive(:close).once.with(true)
+    flexmock(@doc).should_receive(:close).once.with(false)
+    @doc.close_view @view, true
+    @doc.close_view @view, false
+  end
+  
+end
+
+
+describe 'Ruber::Document#extension' do
+  
+  before do
+    @app = KDE::Application.instance
+    @comp = DocumentSpecComponentManager.new
+    flexmock(Ruber).should_receive(:[]).with(:components).and_return @comp
+    @doc = Ruber::Document.new @app
+  end
+
+  it 'calls the extension method of its project' do
+    ext = Qt::Object.new
+    flexmock(@doc.own_project).should_receive(:extension).once.with(:xyz).and_return ext
+    @doc.extension(:xyz).should equal(ext)
+  end
+  
+end
+
+describe 'Ruber::Document#file_type_match?' do
+  
+  before do
+    @app = KDE::Application.instance
+    @comp = DocumentSpecComponentManager.new
+    flexmock(Ruber).should_receive(:[]).with(:components).and_return( @comp).by_default
+    @doc = Ruber::Document.new @app, __FILE__
+  end
+  
+  it 'should return true if both arguments are empty' do
+    @doc.file_type_match?( [], []).should be_true
+  end
+  
+  it 'should return true if one of the mimetypes match the document\'s mimetype, according to KDE::MimeType#=~' do
+    @doc.file_type_match?( %w[image/png application/x-ruby], []).should be_true
+    @doc.file_type_match?( %w[image/png =application/x-ruby], []).should be_true
+    @doc.file_type_match?( %w[image/png !application/x-ruby], []).should be_false
+    @doc.file_type_match?( %w[image/png =text/plain], []).should be_false
+    @doc.file_type_match?( %w[image/png !=text/plain], []).should be_true
+  end
+  
+  it 'should return true if one of the file patterns specified in the second argument matches the path of the file and false otherwise if the first argument is empty' do
+    flexmock(@doc).should_receive(:path).and_return('xyz.rb')
+    @doc.file_type_match?([], %w[*.txt *.rb]).should be_true
+    @doc.file_type_match?([], %w[*.txt *.py]).should be_false
+    @doc.file_type_match?([], %w[*.txt xyz*]).should be_true
+  end
+  
+  it 'should do pattern matching even if the file starts with a dot' do
+    flexmock(@doc).should_receive(:path).and_return('.xyz.rb')
+    @doc.file_type_match?([], %w[*.txt *.rb]).should be_true
+    @doc.file_type_match?([], %w[*.txt *.py]).should be_false
+    @doc.file_type_match?([], %w[*.txt .xyz*]).should be_true
+  end
+  
+  it 'only considers the basename of the file for pattern matching, not the directory name' do
+    flexmock(@doc).should_receive(:path).and_return('/home/xyz.abc')
+    @doc.file_type_match?([], ['xyz.*']).should be_true
+    flexmock(File).should_receive(:fnmatch?).once.with('xyz.*', 'xyz.abc', Integer).and_return(true)
+    @doc.file_type_match?([], ['xyz.*'])
+  end
+  
+  it 'should always return false when doing pattern matching if the document is not associated with a file' do
+    @doc = Ruber::Document.new @app
+    @doc.file_type_match?([], %w[*.txt *.rb]).should be_false
+  end
+  
+  it 'should return true if at least the mime type or the file name matches and false if both don\'t match, if neither arguments is empty' do
+    @doc.file_type_match?(%w[image/png text/plain], %w[*.txt *.py]).should be_true
+    @doc.file_type_match?(%w[image/png text/x-python], %w[*.txt *.rb]).should be_true
+    @doc.file_type_match?(%w[image/png application/x-ruby], %w[*.txt *.rb]).should be_true
+    @doc.file_type_match?(%w[image/png =text/plain], %w[*.txt *.py]).should be_false
+  end
+  
+  it 'should accept a single string for any of the arguments, treating empty strings as empty arrays' do
+    @doc.file_type_match?( '', '').should be_true
+    @doc.file_type_match?( '','*.rb').should be_true
+    @doc.file_type_match?( '','*.py').should be_false
+    @doc.file_type_match?('application/x-ruby', '').should be_true
+    @doc.file_type_match?('text/x-python', '').should be_false
+    @doc.file_type_match?('application/x-ruby', '*.py').should be_true
+    @doc.file_type_match?('text/x-python', '*.rb').should be_true
+    @doc.file_type_match?('text/x-python', '*.png').should be_false
+  end 
+    
+end
+
+describe 'Ruber::Document#document_save_as' do
+  
+  before do
+    @app = KDE::Application.instance
+    @w = Qt::Widget.new
+    flexmock(Ruber).should_receive(:[]).with(:main_window).and_return(@w).by_default
+    @comp = DocumentSpecComponentManager.new
+    flexmock(Ruber).should_receive(:[]).with(:components).and_return(@comp).by_default
+    @projects = flexmock{|m| m.should_receive(:current).and_return(nil).by_default}
+    flexmock(Ruber).should_receive(:[]).with(:projects).and_return(@projects).by_default
+    @config = flexmock('config')
+    @config.should_receive(:[]).with(:general, :default_script_directory).and_return('/').by_default
+    flexmock(Ruber).should_receive(:[]).with(:config).and_return(@config).by_default
+    @doc = Ruber::Document.new
+    #to avoid actually writing the file
+    flexmock(@doc.send :internal).should_receive(:saveAs).by_default
+  end
+  
+  it 'calls KDE::EncodingFileDialog#get_save_file_name_and_encoding and saves the document with the url and encoding returned by it' do
+    # I can't use KDE::EncodingFileDialog::Result for testing because, in ruby,
+    # it doesn't allow to set its fields (in C++ it should work, but I didn't try)
+    res = OpenStruct.new(:file_names => ['/test.rb'], :encoding => 'UTF-16')
+    flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).once.and_return(res)
+    url = KDE::Url.new '/test.rb'
+    flexmock(@doc.send :internal).should_receive(:saveAs).once.with url
+    @doc.send :document_save_as
+    @doc.encoding.should == 'UTF-16'
+  end
+  
+  it 'uses the document\'s URL as default directory if the document is associated with a file' do
+    flexmock(@doc).should_receive(:path).and_return '/test/xyz'
+    res = OpenStruct.new(:file_names => ['/test.rb'], :encoding => 'UTF-16')
+    flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).once.with(String, '/test/xyz', String, Qt::Widget, String).and_return(res)
+    @doc.send :document_save_as
+  end
+  
+  it 'uses the current project\'s project directory as default directory if there is a current project' do
+    prj = flexmock(:project_directory => File.dirname(__FILE__))
+    @projects.should_receive(:current).once.and_return prj
+    res = OpenStruct.new(:file_names => ['/test.rb'], :encoding => 'UTF-16')
+    flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).once.with(String, File.dirname(__FILE__), String, Qt::Widget, String).and_return(res)
+    @doc.send :document_save_as
+  end
+  
+  it 'uses UTF-8 as default encoding if running under ruby 1.9 and ISO-8859-1 if running under ruby 1.8' do
+    res = OpenStruct.new(:file_names => ['/test.rb'], :encoding => 'UTF-16')
+    if RUBY_VERSION.include? '9'
+      flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).once.with('UTF-8', String, String, Qt::Widget, String).and_return(res)
+    else
+    flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).once.with('ISO-8859-1', String, String, Qt::Widget, String).and_return(res)
+    end
+    @doc.send :document_save_as
+  end
+  
+  it 'does nothing if the user dismisses the dialog' do
+    res = OpenStruct.new(:file_names => [], :encoding => '')
+    flexmock(@doc.send :internal).should_receive(:encoding=).never
+    flexmock(@doc.send :internal).should_receive(:saveAs).never
+    flexmock(@doc.own_project).should_receive(:save).never
+    flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).once.and_return(res)
+    @doc.send :document_save_as
+    res = OpenStruct.new(:file_names => [''], :encoding => '')
+    flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).once.and_return(res)
+    @doc.send :document_save_as
+  end
+  
+  it 'saves the document project' do
+    res = OpenStruct.new(:file_names => ['/test.rb'], :encoding => 'UTF-16')
+    flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).once.and_return(res)
+    flexmock(@doc.own_project).should_receive(:save).once
+    @doc.send :document_save_as
+  end
+  
+  it 'returns the value returned by the internal KTextEditor::Document saveAs method' do
+    res = OpenStruct.new(:file_names => ['/test.rb'], :encoding => 'UTF-16')
+    flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).twice.and_return(res)
+    flexmock(@doc.send :internal).should_receive(:saveAs).once.and_return true
+    @doc.send(:document_save_as).should == true
+    flexmock(@doc.send :internal).should_receive(:saveAs).once.and_return false
+    @doc.send(:document_save_as).should == false
+  end
+
+  describe 'if the file already exists' do
+    
+    it 'asks the user and does nothing and returns false if he chooses not to save the document' do
+      res = OpenStruct.new(:file_names => ['/test.rb'], :encoding => 'UTF-16')
+      flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).once.and_return(res)
+      flexmock(File).should_receive(:exist?).once.with('/test.rb').and_return true
+      flexmock(KDE::MessageBox).should_receive(:warning_continue_cancel).once.and_return KDE::MessageBox::Cancel
+      flexmock(@doc.send :internal).should_receive(:saveAs).never
+      flexmock(@doc.send :internal).should_receive(:encoding=).never
+      flexmock(@doc.own_project).should_receive(:save).never
+      @doc.send(:document_save_as).should == false
+    end
+    
+    it 'asks the user and saves the file if he chooses not to overwrite the existin file' do
+      res = OpenStruct.new(:file_names => ['/test.rb'], :encoding => 'UTF-16')
+      flexmock(KDE::EncodingFileDialog).should_receive(:get_save_file_name_and_encoding).once.and_return(res)
+      flexmock(File).should_receive(:exist?).once.with('/test.rb').and_return true
+      flexmock(KDE::MessageBox).should_receive(:warning_continue_cancel).once.and_return KDE::MessageBox::Continue
+      flexmock(@doc.send :internal).should_receive(:saveAs).once.with KDE::Url.new('/test.rb')
+      flexmock(@doc.send :internal).should_receive(:encoding=).with('UTF-16').once
+      @doc.send :document_save_as
+    end
+    
+  end
+  
+end
+
+describe Ruber::Document do
+  
+  before do
+    @app = KDE::Application.instance
+    @w = Qt::Widget.new
+    @comp = DocumentSpecComponentManager.new
+    flexmock(Ruber).should_receive(:[]).with(:components).and_return(@comp)
+  end
+  
+  describe '#save_settings' do
+        
+    it 'calls the #save method of the project if the document path is not empty' do
+      doc = Ruber::Document.new nil, __FILE__
+      exp = doc.object_id
+      flexmock(doc.own_project).should_receive(:save).once
+      doc.save_settings
+    end
+    
+    it 'doesn\'t call the #save method of the project if the document path is empty' do
+      doc = Ruber::Document.new nil
+      flexmock(doc.own_project).should_receive(:save).never
+      doc.save_settings
+    end
+    
+  end
+  
+#   describe '#shutdown' do
+#     
+#     before do
+#       @app = KDE::Application.instance
+#       @w = Qt::Widget.new
+#       @comp = DocumentSpecComponentManager.new
+#       flexmock(Ruber).should_receive(:[]).with(:components).and_return(@comp)
+#       @doc = Ruber::Document.new @app
+#     end
+#     
+#     it 'calls the close_url method passing false' do
+#       doc = Ruber::Document.new nil, __FILE__
+#       flexmock(doc).should_receive(:close_url).once.with(false)
+#       doc.shutdown
+#     end
+#     
+#     it 'emits the "closing(QObject*)" signal' do
+#       doc = Ruber::Document.new nil, __FILE__
+#       exp = doc.object_id
+#       m = flexmock('test'){|mk| mk.should_receive(:document_closing).once.with(exp)}
+#       doc.connect(SIGNAL('closing(QObject*)')){|d| m.document_closing d.object_id}
+#       doc.shutdown
+#     end
+#     
+#     it 'closes the view, if there\'s one, after emitting the closing signal' do
+#       doc = Ruber::Document.new nil, __FILE__
+#       v = doc.create_view
+#       exp = doc.object_id
+#       m = flexmock('test'){|mk| mk.should_receive(:document_closing).once.with(exp).ordered}
+#       flexmock(v).should_receive(:close).once.globally.ordered
+#       doc.connect(SIGNAL('closing(QObject*)')){|d| m.document_closing d.object_id}
+#       doc.shutdown
+#     end
+#     
+#     it 'calls the #shutdown method of the project' do
+#       doc = Ruber::Document.new nil
+#       exp = doc.object_id
+#       flexmock(doc).should_receive(:close_url)
+#       flexmock(doc.own_project).should_receive(:shutdown).once
+#       doc.shutdown
+#     end
+# 
+#     
+#     it 'disconnects any slot/block connected to it after emitting the closing signal' do
+#       doc = Ruber::Document.new nil, __FILE__
+#       exp = doc.object_id
+#       def doc.disconnect *args;end
+#       m = flexmock{|mk| mk.should_receive(:document_closing).with(exp).once.ordered}
+#       doc.connect(SIGNAL('closing(QObject*)')){|d| m.document_closing d.object_id}
+#       flexmock(doc).should_receive(:disconnect).with_no_args.once.ordered
+#       doc.shutdown
+#     end
+#       
+#     it 'disposes of itself after emitting the closing signal' do
+#       doc = Ruber::Document.new nil, __FILE__
+#       doc.shutdown
+#       doc.should be_disposed
+#     end
+#     
+#   end
+  
+end