weft-qda 0.9.6

data/test/004-application.rb

@@ -0,0 +1,52 @@
+$:.push('../lib/')
+
+require 'weft/application'
+require 'test/unit'
+
+class DummyClient
+  attr_reader :state_display
+
+  def initialize(app = nil)
+    app.add_observer(self) if app
+    @state_display = "CLEAN"
+  end
+
+  def update(state)
+    @state_display = state ? "DIRTY" : "CLEAN"
+  end
+end
+
+class TestApplication < Test::Unit::TestCase
+  def setup
+
+  end
+  
+  def test_basic
+    app = QDA::Application.new()
+    client = DummyClient.new(app)
+    assert_equal("CLEAN", client.state_display,
+                  "Observer initially set to show clean")
+    app.dirty!
+    assert_equal("DIRTY", client.state_display,
+                  "Observer picks up dirtying")
+    app.undirty!
+    assert_equal("CLEAN", client.state_display,
+                  "Observer picks up saving")
+
+  end
+
+  def test_basic_w_initializer
+    client = DummyClient.new()
+    app = QDA::Application.new(client)
+
+    assert_equal("CLEAN", client.state_display,
+                  "Observer initially set to show clean")
+    app.dirty!
+    assert_equal("DIRTY", client.state_display,
+                  "Observer picks up dirtying")
+    app.undirty!
+    assert_equal("CLEAN", client.state_display,
+                  "Observer picks up saving")
+
+  end
+end

data/test/006-filters.rb

@@ -0,0 +1,139 @@
+require 'english' 
+
+$:.push('../lib/')
+
+require 'weft/application'
+require 'weft/backend'
+require 'weft/document'
+require 'weft/filters'
+
+require 'test/unit'
+
+class TestFilter < Test::Unit::TestCase
+  def sample_file(filename)
+    File.join( File.dirname( __FILE__), 'testdata', filename)
+  end
+
+  def test_unix_utf8()
+    filter = QDA::TextFilter.new()
+    doc = filter.read(sample_file('text1-unix-utf8.txt'), 'test-unix-utf8')
+
+    str = "This is a text document\nin unix unicode.\n"
+    assert_equal(str, doc.text, "Document text read in")
+  end
+
+  def test_indexer
+    idx = QDA::Indexer.new()
+    idx.index('foo')
+    
+    widx = QDA::WordIndexer.new()
+    my_word = 'SOMETHING'
+    widx.index(my_word)
+    assert_equal(1, widx.words.keys.length)
+    assert_equal(1, widx.words[my_word].length)
+  end
+
+  def test_dos_ascii()
+    filter = QDA::TextFilter.new()
+    doc = filter.read(sample_file('text1-dos-ascii.txt'), 'test-ascii')
+
+    str = "This is a text document\nin dos ascii.\n"
+    assert_equal(str, doc.text, "Document text read in")
+  end
+
+  def test_pdf
+    filter = QDA::PDFFilter.new()
+    windxr = QDA::WordIndexer.new()
+    filter.add_indexer(windxr)
+    doc = filter.read('testdata/emacs-refcard-a4.pdf', 'i')
+
+    doc.title = 'Acknowledgments'
+    word = 'moving'
+    windxr.words.each do | word, offsets |
+      offsets.each do | offset |
+        assert_equal( word, doc[offset, word.length] )
+      end
+    end
+  end
+
+  def test_word_indexing()
+    filter = QDA::TextFilter.new()
+    windxr = QDA::WordIndexer.new()
+    filter.add_indexer(windxr)
+    doc = filter.read(sample_file('autocoding-test.txt'),
+                      'word_indexing')
+    # ordinary, capitalised, short, apostrophe, longer
+    test_words = [ 'the', 'Before', 'I', 'It\'s', 'opinions' ]
+    test_words.each do | test_word |
+      windxr.words[test_word].each  do | loc |
+        assert_equal(test_word, doc.text[loc, test_word.length].to_s)
+      end
+    end
+  end
+
+  def test_indexing_iso_8859_1
+    filter = QDA::TextFilter.new()
+    windxr = QDA::WordIndexer.new()
+    filter.add_indexer(windxr)
+    doc = filter.read(sample_file('iso-8859-1.txt'), 'iso-8859-1')
+    word_rx = /[\w\xC0-\xD6\xD8-\xF6\xF8-\xFF][\w\xC0-\xD6\xD8-\xF6\xF8-\xFF\']+/
+    windxr.words.each_key do | word |
+      assert_match(word_rx, word)
+    end
+  end
+
+  def test_autocoding
+    filter = QDA::TextFilter.new()
+    autocoder = QDA::AutoCoder.new(/^\*\*(.*)\*\*\s*$/ => 'Heading', 
+                                   /^(.*)\:\s*$/ => 'Speaker')
+    filter.add_indexer(autocoder)
+
+    doc = filter.read(sample_file('autocoding-test.txt'),
+                      'autocoding')
+
+    str = "Before any autocoding\n\nSpeakerA:\nI am the first speaker.\nThis is what I say.\n\n**A TEXT HEADER**\n\nSpeakerB:\nI am the second speaker.\n\nThis is what I say. It's my opinions.\n\nSpeakerA:\nMe again.\n"
+    assert_equal(str, doc.text)
+    autocodes = autocoder.codes
+    assert_equal(2, autocodes.keys.length, 
+                 "Number of autocode types created")
+    
+    speaker_a = autocodes['Speaker']['SpeakerA']
+    assert_instance_of(QDA::CodeSet, speaker_a, 
+                       "Autocode speaker A category created")
+    assert_equal(2, speaker_a.length, "Multiple passages coded")
+    # assert_equal(1, speaker_a.num_of_docs, "Single document coded")
+    content_a_1 =
+    "SpeakerA:
+I am the first speaker.
+This is what I say.
+
+**A TEXT HEADER**
+
+"
+    assert_equal(content_a_1, 
+                 doc.text[speaker_a[0].offset, speaker_a[0].length], 
+                 "Document text retrievable by code" )
+                                                       
+    speaker_b = autocodes['Speaker']['SpeakerB']
+    assert_instance_of(QDA::CodeSet, speaker_b, 
+                       "Autocode speaker B category created")
+
+    heading_1 = autocodes['Heading']['A TEXT HEADER']            
+    assert_instance_of(QDA::CodeSet, heading_1, 
+                       "Autocode heading category created")
+
+    header_extract = "**A TEXT HEADER**
+
+SpeakerB:
+I am the second speaker.
+
+This is what I say. It's my opinions.
+
+SpeakerA:
+Me again.
+"
+    assert_equal(header_extract,
+                 doc.text[heading_1[0].offset, heading_1[0].length], 
+                 "Document text retrievable by code" )
+  end
+end

data/test/009a-backend_sqlite_basic.rb

@@ -0,0 +1,280 @@
+require 'english'
+$:.push('../lib/')
+
+require 'weft'
+require 'test/unit'
+
+class TestSQLiteBasic < Test::Unit::TestCase
+  def sample_file(filename)
+    File.join( File.dirname( __FILE__), 'testdata', filename)
+  end
+
+  def setup
+	@dbfile = nil
+	@app = QDA::Application.new()
+	@app.extend(QDA::Backend::SQLite)
+  end
+
+  # delete any files hanging around
+  def teardown()
+	if @app.started?
+      # p @app
+	  # @app.end()
+      if @app.dbfile and File.exist?(@app.dbfile)
+        File.delete(@app.dbfile)
+      end
+	end
+  end
+
+  # test save & revert
+  def test_statefulness
+	@app.start(:dbfile => @dbfile)
+	@app.install_clean()
+	doc = QDA::Document.new('Doc-1')
+	@app.save_document(doc)
+
+	assert_raises(RuntimeError, "Cannot save without a filename") do
+      doc = @app.save()
+    end
+
+    @dbfile = 'foo.db'
+
+    @app.save(@dbfile)
+    assert(File.exist?(@dbfile), "File created after save")
+    assert(@app.get_doc('Doc-1'), "Still has saved content - new filename")
+
+	doc = QDA::Document.new('Doc-2')
+	@app.save_document(doc)
+    @app.save
+	assert(@app.get_doc('Doc-2'), "Still has saved content - re-use filename")
+
+	doc = QDA::Document.new('Doc-3')
+	@app.save_document(doc)	
+    @app.revert
+    assert(File.exist?(@dbfile), "File exists after revert")
+
+    assert(@app.get_doc('Doc-1'), "Still has last-saved content")
+    assert(@app.get_doc('Doc-2'), "Still has last-saved content")
+	assert_raises(RuntimeError, "Lost unsaved content") do
+      doc = @app.get_doc('Doc-3')
+    end
+  end
+
+  def test_open_file
+	@app.start(:dbfile => @dbfile)
+    @app.install_clean()
+    @app.set_up()
+
+    # this will save in current working directory
+    @app.save('foo.db')
+    @app.end
+
+    @app.start(:dbfile => File::join(Dir.pwd, 'foo.db') )
+    File.unlink(File::join(Dir.pwd, 'foo.db'))
+  end
+
+  def test_basic_save_and_get_document()
+	@app.start(:dbfile => @dbfile)
+	@app.install_clean()
+	doc = QDA::Document.new('About Something')
+	assert_nil(doc.dbid, "No DBID set")
+	@app.save_document(doc)
+	assert(doc.dbid, 'Got a DBID set')
+
+	fetch_doc = @app.get_doc(doc.dbid)
+	assert(fetch_doc, "Got something back")
+
+	assert_equal(doc.dbid, fetch_doc.dbid,
+				 "Fetched back thing has the same dbid")
+	assert_equal(doc.title, fetch_doc.title,
+				 "Fetched back thing has the same dbid")
+
+	fetch_doc = @app.get_doc(doc.title)
+	assert(fetch_doc, "Got something back")
+
+	assert_equal(doc.dbid, fetch_doc.dbid,
+				 "Fetched back thing has the same dbid")
+	assert_equal(doc.title, fetch_doc.title,
+				 "Fetched back thing has the same dbid")
+  end
+
+  def test_save_and_get_document_content()
+	@app.start(:dbfile => @dbfile)
+	@app.install_clean()
+	doc = QDA::Document.new('About Something')
+	str1 = 'fo"o'
+	doc.append(str1)
+	str2 = "fo'o"
+	doc.append(str2)
+
+	@app.save_document(doc)
+	assert(doc.dbid, 'Got a DBID set')
+
+	fetch_doc = @app.get_doc(doc.dbid)
+	assert(fetch_doc, "Got something back")
+	assert_equal("fo\"o", fetch_doc[0,4], 
+				 "Got some fragments back")
+	assert_equal("fo'o\n", fetch_doc[5,5], 
+				 "Got some fragments back")
+
+	#assert_equal(2, fetch_doc.fragments.length, 
+	#"Got some fragments back")
+	#assert_equal(str1, fetch_doc.fragments[0].text,
+	#"Got single-quote fragment back")
+	#assert_equal(str2, fetch_doc.fragments[1].text, 
+	#"Got double-quote fragment back")
+	@app.save_document(doc)
+  end
+
+  def test_save_category_with_code()
+	@app.start(:dbfile => @dbfile)
+	@app.install_clean()
+	cat1 = QDA::Category.new("About 'Something'", nil, 'A memo')
+
+	doc = QDA::Document.new('Hello')
+	doc.append('this')
+	doc.append('that')
+	@app.save_document(doc)
+	
+	# code 6 characters starting at index 1
+	cat1.code(doc.dbid, 1, 6)
+
+	@app.save_category(cat1)
+	
+	f_cat1 = @app.get_category(cat1.dbid)
+	assert_equal(1, f_cat1.num_of_docs,
+				 'Have coded 1 doc')
+	assert_equal(1, f_cat1.num_of_codes,
+				 'Have applied one vector')
+	assert_equal(6, f_cat1.num_of_chars,
+				 'Have coded 6 characters')
+
+	texts = @app.get_text_at_category(cat1)
+
+	assert_equal(1, texts.keys.length,
+				 'Have stored one vector')
+	assert_equal("his\nth", texts[doc.title][0],
+				 'Have retrieved text')
+	assert_equal(1, texts[doc.title][0].offset,
+				 'Have retrieved text offset')
+	assert_equal(6, texts[doc.title][0].length,
+				 'Have retrieved text length')
+	assert(texts[doc.title][0].docid,
+				 'Have retrieved docid')
+
+
+  end
+
+  def test_basic_save_category
+	@app.start(:dbfile => @dbfile)
+	@app.install_clean()
+	cat1 = QDA::Category.new("About 'Something'", nil, 'the "memo"')
+
+	@app.save_category(cat1)
+	assert(cat1.dbid, 'Category was assigned a database id')
+
+	f_cat1 = @app.get_category(cat1.dbid)
+	assert_equal(cat1.name, f_cat1.name,
+				 "Name retrieved successfully")
+	assert_equal(cat1.memo, f_cat1.memo,
+				 "Memo retrieved successfully")
+	
+	# test some parent-child stuff
+	cat2 = QDA::Category.new('Something "Specific"', cat1)
+	@app.save_category(cat2)
+	assert(cat2.dbid, 'Category was assigned a database id')
+
+	cat2a = QDA::Category.new('Something "Specific" & Detailed', cat2)
+	@app.save_category(cat2a)
+
+	cat3 = QDA::Category.new('Something "Else"', cat1)
+	@app.save_category(cat3)
+
+	# @app.dbh.execute("SELECT * FROM category") { | r | p r }
+	f_cat2 = @app.get_category(cat2.dbid)
+	assert_equal(cat2.name, f_cat2.name,
+				 "Name retrieved successfully")
+
+	assert_equal(cat2.dbid, f_cat2.dbid,
+				 "DBID retrieved successfully")
+
+	p_cat = @app.get_category(cat2.parent.dbid)
+	assert_equal(p_cat.dbid, cat1.dbid,
+				 "Parent retrieved successfully")
+
+	assert_nil(@app.get_category_parent(p_cat.dbid),
+				 "Nil retrieved for root node's parent")
+
+	roots = @app.get_all_categories()
+
+	assert_equal(1, roots.length,
+				 "Root elements retrieved successfully")
+	assert_equal("About 'Something'", roots[0].name,
+				 "Root element retrieved successfully")
+	assert_equal(2, roots[0].children.length,
+				 "Root element children retrieved successfully")
+
+	cat3 = QDA::Category.new("NEw root node", nil)
+	@app.save_category(cat3)
+
+	roots = @app.get_all_categories()
+	assert_equal(2, roots.length,
+				 "Multiple Root elements retrieved successfully")
+	
+    new_root = @app.get_root_category("NEw root node")
+    assert_equal(QDA::Category, new_root.class)
+    assert_equal("NEw root node", new_root.name)
+    assert_equal(nil, new_root.parent)
+	assert_raises(RuntimeError) { @app.get_root_category("Doesn't exist") }
+
+
+	finds = @app.get_categories_by_path('Something')
+	assert_equal(3, finds.length, 'Normal name/path search')
+
+	finds = @app.get_categories_by_path('something')
+	assert_equal(3, finds.length, 'Case insensitive name/path search')
+
+	finds = @app.get_categories_by_path('Something/Something')
+	assert_equal(1, finds.length)
+
+	finds = @app.get_categories_by_path('Fake/Bad')
+	assert_equal(0, finds.length)
+  end
+
+  def test_cut_paste_category
+	@app.start(:dbfile => @dbfile)
+	@app.install_clean()
+	cat1 = QDA::Category.new("About 'Something'", nil)
+	@app.save_category(cat1)
+	
+	cat2 = QDA::Category.new('Something "Specific"', cat1)
+	@app.save_category(cat2)
+	cat2a = QDA::Category.new('Something "Specific" & Detailed', cat2)
+	@app.save_category(cat2a)
+	cat3 = QDA::Category.new('Something "Else"', cat1)
+	@app.save_category(cat3)
+	cat4 = QDA::Category.new('Something "Again"', cat1)
+	@app.save_category(cat4)
+
+
+    cat2.parent = cat3
+    @app.save_category(cat2)
+    
+
+    cat4.parent = cat3
+    @app.save_category(cat4)
+
+    cat2.parent = cat1
+    @app.save_category(cat2)
+
+    deletions = @app.delete_category(cat3)
+    assert_kind_of(Array, deletions)
+    assert_equal(2, deletions.length)
+  end
+
+  def test_install()
+	@app.start(:dbfile => @dbfile)
+	@app.install_clean()
+	assert_raises(RuntimeError) { doc = @app.get_doc('foo') }
+  end
+end