weft-qda 0.9.6 → 0.9.8

data/test/005-query_review.rb

@@ -0,0 +1,139 @@
+require 'test-common'
+
+require 'weft'
+require 'test/unit'
+
+class TestCodeReview < Test::Unit::TestCase
+  include QDA
+  def test_to_query()
+    cr = CodeReview.new()
+	assert_equal(0, cr.number_rows)
+	assert_equal(0, cr.number_cols)
+	
+    cat1 = Category.new('foo')
+    cat1.code(1, 10, 40)
+    cat2 = Category.new('bar')
+    cat2.code(1, 70, 20)
+    cat3 = Category.new('baz')
+    cat3.code(1, 40, 40)
+    cat4 = Category.new('qux')
+    cat4.code(1, 100, 15)
+
+    cr.add_col( cat1 )
+    cr.add_col( cat2 )  
+    cr.add_row( cat3 )
+    cr.add_row( cat4 )
+    # invalid
+    assert_nil( cr.to_query(nil, 2,2) )
+    # valid
+    assert_kind_of( Query, cr.to_query(nil, 0, 1) )
+  end
+  
+  def test_basic
+    cr = CodeReview.new()
+	assert_equal(0, cr.number_rows)
+	assert_equal(0, cr.number_cols)
+	
+    cat1 = Category.new('foo')
+    cat1.code(1, 10, 40)
+    cat2 = Category.new('bar')
+    cat2.code(1, 70, 20)
+    cat3 = Category.new('baz')
+    cat3.code(1, 40, 40)
+    cat4 = Category.new('qux')
+    cat4.code(1, 100, 15)
+
+    cr.add_col( cat1 )
+    cr.add_col( cat2 )
+    assert_equal(0, cr.number_rows)
+	assert_equal(2, cr.number_cols)
+	
+    cr.add_row( cat3 )
+    cr.add_row( cat4 )
+    assert_equal(2, cr.number_rows)
+	assert_equal(2, cr.number_cols)
+	
+    
+  end
+end
+
+
+# for testing
+class NullFunction < QDA::Query::Function
+  def initialize(token)
+    @token = token
+  end
+  def calculate()
+    QDA::CodingTable.new()
+  end
+  def to_s()
+    "(NULL-#{@token})"
+  end
+end
+  
+class TestQuery < Test::Unit::TestCase
+  include QDA
+  
+  def test_query
+    q = Query.new( NullFunction.new('FOO') )
+    assert_equal(1, q.num_functions)
+    assert_equal(0, q.num_expressions)
+    assert_equal(QDA::CodingTable.new(), q.calculate)
+    assert_kind_of(NullFunction, q.root)
+    
+    q.add_expression( 'AND', NullFunction.new('BAR') )
+    assert_equal(2, q.num_functions)
+    assert_equal(1, q.num_expressions)
+    assert_equal(QDA::CodingTable.new(), q.calculate)    
+    assert_kind_of(Query::AND, q.root)
+    
+    q.add_expression( 'OR', NullFunction.new('BAZ') )
+    assert_equal(3, q.num_functions)
+    assert_equal(2, q.num_expressions)
+    assert_equal(QDA::CodingTable.new(), q.calculate)
+    assert_kind_of(Query::OR, q.root)
+    # a bad logical operator
+    assert_raises(ArgumentError) do 
+      q.add_expression('UG', NullFunction.new('QUX'))
+    end
+    
+  end
+
+  
+  
+  def test_or
+    cs_1 = CodingTable.new()
+    cs_2 = CodingTable.new()
+    cs_1.add( Code.new(3, 0, 4) )
+    cs_2.add( Code.new(3, 3, 5) )
+    expr = Query::AND.new(cs_1, cs_2)
+    result = expr.calculate()
+    assert_equal(1, result.num_of_docs)
+    assert_equal(1, result.num_of_chars)
+    assert_equal(1, result.num_of_passages)
+  end
+  
+  def test_and_not
+    cs_1 = CodingTable.new()
+    cs_2 = CodingTable.new()
+    cs_1.add( Code.new(3, 0, 4) )
+    cs_2.add( Code.new(3, 3, 5) )
+    expr = Query::AND_NOT.new(cs_1, cs_2)
+    result = expr.calculate()
+    assert_equal(1, result.num_of_docs)
+    assert_equal(3, result.num_of_chars)
+    assert_equal(1, result.num_of_passages)
+  end
+  
+  def test_or
+    cs_1 = CodingTable.new()
+    cs_2 = CodingTable.new()
+    cs_1.add( Code.new(3, 0, 4) )
+    cs_2.add( Code.new(3, 3, 5) )
+    expr = Query::OR.new(cs_1, cs_2)
+    result = expr.calculate()
+    assert_equal(1, result.num_of_docs)
+    assert_equal(8, result.num_of_chars)
+    assert_equal(1, result.num_of_passages)
+  end
+end

data/test/006-filters.rb

@@ -1,31 +1,33 @@
-require 'english' 
+require 'test-common'
 
-$:.push('../lib/')
-
-require 'weft/application'
-require 'weft/backend'
-require 'weft/document'
-require 'weft/filters'
+require 'weft'
 
 require 'test/unit'
 
 class TestFilter < Test::Unit::TestCase
-  def sample_file(filename)
-    File.join( File.dirname( __FILE__), 'testdata', filename)
+  include QDA
+  def test_filter_types()
+    import_filters = Filters::import_filters
+    assert_kind_of(Hash, import_filters)
+    assert_kind_of(Array, import_filters[QDA::Document])
+    assert(import_filters[Document].length > 0)
+    
+    export_filters = Filters::export_filters
+    assert_kind_of(Hash, export_filters)
+    assert_kind_of(Array, export_filters[Document])
   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")
+    textfile = sample_file('text1-unix-utf8.txt')
+    doc = Filters.import_file(Document, textfile) do | doc, filter |
+      str = "This is a text document\nin unix unicode.\n"
+      assert_equal(str, doc.text, "Document text read in")
+      doc.title = 'utf-8'
+    end
+    assert_equal('utf-8', doc.title)
   end
 
   def test_indexer
-    idx = QDA::Indexer.new()
-    idx.index('foo')
-    
     widx = QDA::WordIndexer.new()
     my_word = 'SOMETHING'
     widx.index(my_word)
@@ -34,34 +36,33 @@ class TestFilter < Test::Unit::TestCase
   end
 
   def test_dos_ascii()
-    filter = QDA::TextFilter.new()
-    doc = filter.read(sample_file('text1-dos-ascii.txt'), 'test-ascii')
+    text_filter = QDA::Filters.find_import_filter(QDA::Document, 'txt')
+    filter = text_filter.new()
+    doc = filter.run(sample_file('text1-dos-ascii.txt'))
 
     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
+    doc = Filters.import_file(Document, sample_file('simple.pdf') )
+    txt = "This is a simple unlocked PDF document. " << 
+          "It should import without problem into Weft QDA.\n\n"
+    assert_equal(txt, doc.text)
+    
+    doc = Filters.import_file(Document, sample_file('simple with space.pdf') )
+    txt = "This is a simple unlocked PDF document. " << 
+          "It should import without problem into Weft QDA.\n\n"
+    assert_equal(txt, doc.text, 'OK importing file with space in name')
   end
 
   def test_word_indexing()
-    filter = QDA::TextFilter.new()
+    text_filter = Filters.find_import_filter(Document, 'txt')
+    filter = text_filter.new()
+    
     windxr = QDA::WordIndexer.new()
     filter.add_indexer(windxr)
-    doc = filter.read(sample_file('autocoding-test.txt'),
-                      'word_indexing')
+    doc = filter.run( sample_file('autocoding-test.txt') )
     # ordinary, capitalised, short, apostrophe, longer
     test_words = [ 'the', 'Before', 'I', 'It\'s', 'opinions' ]
     test_words.each do | test_word |
@@ -71,25 +72,36 @@ class TestFilter < Test::Unit::TestCase
     end
   end
 
-  def test_indexing_iso_8859_1
-    filter = QDA::TextFilter.new()
-    windxr = QDA::WordIndexer.new()
+  def test_indexing_iso_8859_1()
+    text_filter = Filters.find_import_filter(Document, 'txt')
+    filter = text_filter.new()
+    
+    windxr = WordIndexer.new()
     filter.add_indexer(windxr)
-    doc = filter.read(sample_file('iso-8859-1.txt'), 'iso-8859-1')
+    
+    doc = filter.run( sample_file('iso-8859-1.txt') )
     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
+    
+    windxr2 = WordIndexer.new()
+    windxr2.feed(doc)
+    windxr.words.each do | word, offsets|
+      assert_equal(offsets, windxr2.words[word])
+    end
+    
   end
 
   def test_autocoding
-    filter = QDA::TextFilter.new()
+    text_filter = QDA::Filters.find_import_filter(QDA::Document, 'txt')
+    filter = text_filter.new()
+
     autocoder = QDA::AutoCoder.new(/^\*\*(.*)\*\*\s*$/ => 'Heading', 
                                    /^(.*)\:\s*$/ => 'Speaker')
     filter.add_indexer(autocoder)
 
-    doc = filter.read(sample_file('autocoding-test.txt'),
-                      'autocoding')
+    doc = filter.run( sample_file('autocoding-test.txt') )
 
     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)

data/test/007-output_filters.rb

@@ -0,0 +1,113 @@
+require 'test-common'
+
+require 'weft'
+require 'tempfile' # so we can test output
+
+require 'test/unit'
+
+class TestFilter < Test::Unit::TestCase
+  include QDA
+  
+  def run_filter(obj, filter)
+    tmp = Tempfile.new('output')
+    filter.write(obj, tmp)
+    tmp.rewind()
+    tmp.read()  
+  end
+  
+  def test_filter_types()
+    import_filters = Filters::import_filters
+    assert_kind_of(Hash, import_filters)
+    assert_kind_of(Array, import_filters[QDA::Document])
+    assert(import_filters[Document].length > 0)
+    
+    export_filters = Filters::export_filters
+    assert_kind_of(Hash, export_filters)
+    assert_kind_of(Array, export_filters[Category])
+    assert(export_filters[Category].length > 0)
+    assert(export_filters[Document].length > 0)
+    assert(export_filters[CodeReview].length > 0)
+
+    assert( Filters.can_export?(Category) )
+    assert( Filters.can_export?(Document) )
+    assert( Filters.can_export?(CodeReview) )
+    assert( ! Filters.can_export?(Query) )
+    
+  end
+  
+  def test_export_document()
+    doc = Document.new('foo')
+    doc.append('blah blah blah')
+    filter = Filters::DocumentTextOutput.new()
+    
+    tmp = Tempfile.new('doc_text')
+    filter.write(doc, tmp)
+    tmp.rewind()
+    contents = tmp.read()
+    # Proper template not written yet
+    # assert_match(/blah/m, contents, 'Looks a bit like the document')
+  end
+  
+  def test_export_category()
+	@app = QDA::Application.new()
+	@app.extend(QDA::Backend::SQLite)
+	@app.start(:memory => true)
+	@app.install_clean()
+	
+	doc = Document.new('My Document')
+	doc.append('This is some text in the document')
+	@app.save_doc(doc)
+	
+    cat = Category.new('foo & bar')
+    cat.code(doc.dbid, 13, 7)
+    @app.save_category(cat)
+
+    contents = run_filter( cat, Filters::CategoryHTMLOutput.new(@app) )
+    assert_match(/<html>.*<\/html>/m, contents, "Sort of looks like HTML")
+    assert_match(/foo &amp; bar/, contents, "Title's mentioned somewhere")
+    assert_match(/foo/, contents, "Category name's mentioned somewhere")
+    assert_match(/text in/, contents, "Document text is included")
+  end
+  
+  def test_export_codereview_csv()
+    @app = QDA::Application.new()
+	@app.extend(QDA::Backend::SQLite)
+	@app.start(:memory => true)
+	@app.install_clean()
+    cr = mock_codereview()
+    tmp = Tempfile.new('codereview_csv')
+    
+    filter = Filters::CodeReviewCSVOutput.new(@app)
+    filter.write(cr, tmp)
+    tmp.rewind()
+    lines = tmp.read().split("\n")
+    assert_match(/foo,bar/, lines[0])
+    assert_equal('baz,10,10', lines[1])
+  end
+  
+  def mock_codereview()
+    cr = CodeReview.new()
+    cr.count_method = :num_of_chars
+    cat1 = Category.new('foo')
+    cat1.code(1, 10, 40)
+    cat2 = Category.new('bar')
+    cat2.code(1, 70, 20)
+    cat3 = Category.new('baz')
+    cat3.code(1, 40, 40)
+    cat4 = Category.new('qux')
+    cat4.code(1, 85, 15)
+
+    cr.add_col( cat1 )
+    cr.add_col( cat2 )
+
+    cr.add_row( cat3 )
+    cr.add_row( cat4 )
+    cr  
+  end
+  
+  def test_export_codereview_html
+    cr = mock_codereview()
+    contents = run_filter(cr, Filters::CodeReviewHTMLOutput.new() )
+    assert_match(/<table/, contents, "There's a table in there somewhere")
+  end
+end

data/test/009a-backend_sqlite_basic.rb

@@ -1,8 +1,23 @@
-require 'english'
-$:.push('../lib/')
-
+require 'test-common'
 require 'weft'
-require 'test/unit'
+
+class DummyClient
+  attr_reader :event_log
+  include QDA::Subscriber
+  
+  def initialize(app = nil)
+    @event_log = []
+    subscribe(app, :all)
+  end
+  
+  def reset_log()
+    @event_log = []
+  end
+  
+  def notify(evt, data)
+    event_log.push( :evt => evt, :data => data )
+  end
+end
 
 class TestSQLiteBasic < Test::Unit::TestCase
   def sample_file(filename)
@@ -13,17 +28,15 @@ class TestSQLiteBasic < Test::Unit::TestCase
 	@dbfile = nil
 	@app = QDA::Application.new()
 	@app.extend(QDA::Backend::SQLite)
+	@client = DummyClient.new(@app)
   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
+    @app.end
+    if @app.dbfile and File.exist?(@app.dbfile)
+      File.delete(@app.dbfile)
+    end
   end
 
   # test save & revert
@@ -33,7 +46,7 @@ class TestSQLiteBasic < Test::Unit::TestCase
 	doc = QDA::Document.new('Doc-1')
 	@app.save_document(doc)
 
-	assert_raises(RuntimeError, "Cannot save without a filename") do
+	assert_raises(QDA::Backend::BackendError, "Cannot save without filename") do
       doc = @app.save()
     end
 
@@ -78,9 +91,14 @@ class TestSQLiteBasic < Test::Unit::TestCase
 	@app.install_clean()
 	doc = QDA::Document.new('About Something')
 	assert_nil(doc.dbid, "No DBID set")
+	assert_nil( @app.doc_exists(doc.title) )
+	
+	# test saving
 	@app.save_document(doc)
 	assert(doc.dbid, 'Got a DBID set')
-
+    assert_equal( doc.dbid, @app.doc_exists(doc.title) )
+    
+    # test fetching by document identifier
 	fetch_doc = @app.get_doc(doc.dbid)
 	assert(fetch_doc, "Got something back")
 
@@ -89,6 +107,7 @@ class TestSQLiteBasic < Test::Unit::TestCase
 	assert_equal(doc.title, fetch_doc.title,
 				 "Fetched back thing has the same dbid")
 
+    # test fetching by document title
 	fetch_doc = @app.get_doc(doc.title)
 	assert(fetch_doc, "Got something back")
 
@@ -96,8 +115,25 @@ class TestSQLiteBasic < Test::Unit::TestCase
 				 "Fetched back thing has the same dbid")
 	assert_equal(doc.title, fetch_doc.title,
 				 "Fetched back thing has the same dbid")
-  end
 
+  end
+  def test_magic_renaming_document()
+  	@app.start(:dbfile => @dbfile)
+	@app.install_clean()
+	
+	@app.save_document(QDA::Document.new('Foo'))
+    doc = QDA::Document.new('Foo')
+	assert_raises(QDA::NotUniqueNameError) { @app.save_doc(doc) }
+	# test duplicate magic renaming
+	@app.save_document(doc, true)
+    assert(doc.dbid)
+	assert_equal('Foo (1)', doc.title)
+	doc_1 = QDA::Document.new('Foo')
+	@app.save_document(doc_1, true)
+	assert(doc_1.dbid)
+	assert_equal('Foo (2)', doc_1.title)
+  end
+  
   def test_save_and_get_document_content()
 	@app.start(:dbfile => @dbfile)
 	@app.install_clean()
@@ -165,6 +201,24 @@ class TestSQLiteBasic < Test::Unit::TestCase
 
   end
 
+  
+  def test_root_category()
+	@app.start(:dbfile => @dbfile)
+	@app.install_clean()
+    root = QDA::Category.new("ROOT", nil, 'the "memo"')
+    @app.save_category(root)
+    f_root = @app.get_root_category('ROOT')
+    assert_equal(nil, f_root.parent)
+    assert_equal('ROOT', f_root.name)
+    f_root.name = 'RENAMED'
+    @app.save_category(f_root)
+    
+    assert_raises(QDA::NotFoundError) { @app.get_root_category('ROOT') }
+    f_root = @app.get_root_category('RENAMED')
+    assert_equal(nil, f_root.parent)
+    assert_equal('RENAMED', f_root.name)
+  end
+  
   def test_basic_save_category
 	@app.start(:dbfile => @dbfile)
 	@app.install_clean()
@@ -178,19 +232,29 @@ class TestSQLiteBasic < Test::Unit::TestCase
 				 "Name retrieved successfully")
 	assert_equal(cat1.memo, f_cat1.memo,
 				 "Memo retrieved successfully")
-	
+
+    f_cat1 = @app.get_category("/About 'Something'")
+    assert_equal(cat1, f_cat1)
+    	
 	# 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')
+    assert_equal(cat1, cat2.parent)
+    
+    f_cat1 = @app.get_category(cat1.dbid, true)
+    assert_equal(1, f_cat1.children.length)
 
+    f_cat2 = @app.get_category("/About 'Something'/Something")
+    assert_equal(cat2, f_cat2)
+
+    
 	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")
@@ -225,8 +289,7 @@ class TestSQLiteBasic < Test::Unit::TestCase
     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") }
-
+	assert_raises(QDA::NotFoundError) { @app.get_root_category("Doesn't exist") }
 
 	finds = @app.get_categories_by_path('Something')
 	assert_equal(3, finds.length, 'Normal name/path search')
@@ -244,7 +307,7 @@ class TestSQLiteBasic < Test::Unit::TestCase
   def test_cut_paste_category
 	@app.start(:dbfile => @dbfile)
 	@app.install_clean()
-	cat1 = QDA::Category.new("About 'Something'", nil)
+	cat1 = QDA::Category.new("Root", nil)
 	@app.save_category(cat1)
 	
 	cat2 = QDA::Category.new('Something "Specific"', cat1)
@@ -256,20 +319,28 @@ class TestSQLiteBasic < Test::Unit::TestCase
 	cat4 = QDA::Category.new('Something "Again"', cat1)
 	@app.save_category(cat4)
 
-
     cat2.parent = cat3
     @app.save_category(cat2)
+    assert_equal("/Root/Something \"Else\"/Something \"Specific\"",
+                 cat2.path)
     
-
     cat4.parent = cat3
     @app.save_category(cat4)
+    
 
+    cat4_x = @app.get_category(cat4.dbid)
+    assert_equal(cat3, cat4_x.parent)
+    
     cat2.parent = cat1
     @app.save_category(cat2)
 
-    deletions = @app.delete_category(cat3)
-    assert_kind_of(Array, deletions)
-    assert_equal(2, deletions.length)
+    @client.reset_log
+    deletion = @app.delete_category(cat3)
+    assert_kind_of(QDA::Category, deletion)
+    assert_equal(cat3, deletion)
+    assert_raises(QDA::NotFoundError) { @app.get_category(cat4.dbid) }
+    assert_raises(QDA::NotFoundError) { @app.get_category(cat3.dbid) }
+    assert_equal(2, @client.event_log.length)
   end
 
   def test_install()