weft-qda 0.9.6

data/lib/weft/backend/sqlite/category_tree.rb

@@ -0,0 +1,104 @@
+require 'base64'
+
+module QDA::Backend::SQLite
+  class CategoryTreeNode
+    attr_reader :dbid, :children
+    attr_accessor :parent, :name
+    protected :parent=
+
+    def initialize(parent, dbid, name)
+      @parent, @dbid, @name = parent, dbid, name
+      @children = []
+    end
+
+    def add(dbid, name)
+      append( CategoryTreeNode.new(@dbid, dbid, name) )
+    end
+
+    def append(child)
+      child.parent = @dbid
+      @children.push(child)[-1]
+    end
+
+    def remove(target)
+      @children.delete_if { | c | c.dbid == target.dbid }
+    end
+
+    def like(other)
+      name =~ /^#{other}/i
+    end
+
+    def to_s()
+      "<CategoryTreeNode #{dbid} '#{name}' parent=#{parent}>"
+    end
+
+    def descendants()
+      @children.map() { | c | [ c.dbid, c.descendants ] }.flatten
+    end
+  end
+
+  class CategoryTree
+    attr_reader :roots
+    def initialize()
+      @table = {}
+      @roots = []
+    end
+
+    def CategoryTree.load(str)
+      Marshal.load( Base64::decode64(str) )
+    end
+
+    def [](id)
+      @table[id] or raise "Unknown id #{id.inspect}"
+    end
+
+    def find(path)
+      points = path.split('/')
+      scope = points[0].empty? ? @roots : @table.values
+      points.delete('')
+      while elem = points.shift
+        scope = scope.find_all { | x | x.like(elem) }
+        scope.map! { | x | x.children }.flatten! unless points.empty?
+      end
+      scope
+    end
+
+    def add(parentid, dbid, name)
+      if parentid
+        @table[dbid] = @table[parentid].add(dbid, name)
+      else
+        @roots.push( CategoryTreeNode.new(nil, dbid, name) )
+        @table[dbid] = @roots[-1]
+      end
+    end
+
+    def remove(dbid)
+      child = @table.delete(dbid)
+      @table[child.parent].remove(child)
+    end
+
+    def move(dbid, new_parent)
+      child = @table[dbid]
+      old_parent = child.parent
+      @table[new_parent].append(child)
+      @table[old_parent].remove(child)
+    end
+
+    def is_descendant?(ancestor, descendant)
+      @table[ancestor].descendants.include?(descendant)
+    end
+
+    def serialise()
+      Base64::encode64( Marshal.dump(self) )
+    end
+
+    def pretty_print(out = STDOUT)
+      pp = Proc.new do | item, depth |
+        out << "-" * depth
+        out << " #{item.name} (#{item.dbid})\n"
+        item.children.each { | c | pp.call(c, depth + 1) }
+      end
+      roots.each { | r | pp.call(r, 0) }
+    end
+  end
+end

data/lib/weft/backend/sqlite/schema.rb

@@ -0,0 +1,152 @@
+module QDA::Backend::SQLite::Schema
+  SCHEMA_TABLES = <<'SCHEMA_TABLES'
+CREATE TABLE category (
+  catid INTEGER PRIMARY KEY,
+  catname VARCHAR(255) DEFAULT NULL,
+  catdesc TEXT,
+  parent INTEGER,
+  created_date TIMESTAMP,
+  modified_date TIMESTAMP );
+
+CREATE TABLE category_structure ( xml TEXT );
+
+INSERT INTO category_structure VALUES ('');
+
+CREATE TABLE code (
+  catid INT(11) default NULL,
+  docid INT(11) default NULL,
+  offset INT(11) default NULL,
+  length INT(11) default NULL );
+
+CREATE TABLE docmeta (
+  docid INT(11) default NULL,
+  metaname VARCHAR(100) default NULL,
+  metavalue TEXT );
+
+CREATE TABLE document (
+  docid INTEGER PRIMARY KEY,
+  doctitle VARCHAR(255) default NULL,
+  doctext TEXT,
+  docmemo TEXT,
+  created_date TIMESTAMP,
+  modified_date TIMESTAMP);
+
+CREATE TABLE app_preference ( 
+  name VARCHAR(255) NOT NULL PRIMARY KEY ON CONFLICT REPLACE,
+  value TEXT);
+SCHEMA_TABLES
+
+  SCHEMA_TRIGGERS = <<'SCHEMA_TRIGGERS'
+CREATE TRIGGER insert_category
+  INSERT ON category
+  BEGIN
+END;
+
+CREATE TRIGGER delete_category
+  DELETE ON category
+  BEGIN
+    DELETE FROM code WHERE catid = old.catid;
+END;
+
+CREATE TRIGGER insert_doc
+  INSERT ON document
+  BEGIN
+END;
+
+CREATE TRIGGER delete_doc DELETE ON document
+BEGIN
+  DELETE FROM docmeta WHERE docid = old.docid;
+  DELETE FROM code WHERE docid = old.docid;
+END;
+
+SCHEMA_TRIGGERS
+
+  # This is here because it's written, but it's not in use yet.
+  SCHEMA_UNDO = <<'SCHEMA_UNDO'
+CREATE TABLE undoable ( 
+  actionid INTEGER PRIMARY KEY,
+  step INT(255) DEFAULT 0,
+  sql TEXT );
+
+CREATE TRIGGER undo_insert_category INSERT ON category
+BEGIN
+    INSERT INTO undoable VALUES(NULL, 0, 'DELETE FROM category ' ||
+                                         'WHERE docid = ' || 
+                                         LAST_INSERT_ROWID() );
+END;
+
+CREATE TRIGGER undo_delete_category DELETE ON category
+  BEGIN
+    INSERT INTO undoable VALUES(NULL, 0,
+								'INSERT INTO category
+								 VALUES (' ||
+								 old.catid || ', ' ||
+								 QUOTE(old.catname) || ' ,' ||
+								 QUOTE(old.catdesc)  || ', ' ||
+								 old.parent || ', ' ||
+								 QUOTE(old.created_date) || ', ' ||
+								 QUOTE(old.modified_date) || ')' );
+
+CREATE TRIGGER undo_insert_document INSERTO ON document
+BEGIN
+END;
+
+CREATE TRIGGER undo_delete_document DELETE ON document
+BEGIN
+END;
+
+CREATE TRIGGER undo_insert_code INSERT ON code
+BEGIN
+END;
+
+CREATE TRIGGER undo_delete_code DELETE ON code
+BEGIN
+END;
+
+CREATE TRIGGER undo_insert_docmeta INSERT ON docmeta
+BEGIN
+END;
+
+CREATE TRIGGER undo_delete_docmeta DELETE ON docmeta
+BEGIN
+END;
+
+CREATE TRIGGER undo_update_category_structure 
+UPDATE ON category_structure
+BEGIN
+END;
+SCHEMA_UNDO
+
+  SCHEMA_INDEXES = <<'SCHEMA_INDEXES'
+
+CREATE INDEX document_idx
+ON document(doctitle);
+
+CREATE INDEX code_idx 
+ON code(docid, catid);
+
+CREATE INDEX docmeta_idx
+ON docmeta(metaname, docid);
+
+SCHEMA_INDEXES
+
+  RINDEX_SEARCH_MODEL_QUERY = <<'RINDEX_SEARCH_MODEL_QUERY'
+SELECT document.docid AS docid, document.doctitle AS doctitle,
+MAX( 0, code.offset - ?)
+AS start_at,
+SUBSTR(document.doctext, 
+  MAX( 0, code.offset - ?) + 1,
+  MIN( code.length + ( ? * 2 ),
+       LENGTH(document.doctext) - MAX(1, code.offset - ?) - 1 ) )
+AS snip
+FROM document, code
+WHERE code.docid = document.docid
+AND code.catid IN (
+  SELECT catid
+  FROM category
+  WHERE parent = ?
+  AND LOWER(category.catname) LIKE ?)
+ORDER BY code.catid, code.offset
+RINDEX_SEARCH_MODEL_QUERY
+
+end

data/lib/weft/backend/sqlite/upgradeable.rb

@@ -0,0 +1,55 @@
+require 'rexml/document'
+
+module QDA::Backend::SQLite
+
+  # This module provides support for opening projects created in older
+  # versions of Weft.
+  module Upgradeable
+    # This is called when a project is opened. It checks whether any
+    # changes need to be made to the storage format.
+    def do_version_format_upgrading()
+      version = get_preference('LastModifiedVersion') || 
+        get_preference('CreateVersion')
+
+      # don't do anything to those created in testing versions, just
+      # mark as last-opened in this version.
+      if version == QDA::Version.default_version()
+        save_preference('LastModifiedVersion', WEFT_VERSION)
+      end
+
+      # 0.9.4 and earlier - add indexes to tables
+      if version.nil?
+        @dbh.execute_batch(QDA::Backend::SQLite::Schema::SCHEMA_INDEXES)
+      end
+
+      # 0.9.5 and earlier - upgrade the category tree storage format
+      if version.nil? || version == '0.9.5'
+        legacy_category_tree_storage()
+        save_preference('LastModifiedVersion', WEFT_VERSION)
+      end
+    end
+
+    # This is a change from 0.9.5 -> 0.9.6; Category tree structure
+    # used to be stored in XML in the database, is now stored as a
+    # marshalled CategoryTree pure ruby object.
+    def legacy_category_tree_storage()
+      @cat_tree = CategoryTree.new()
+
+      build_cat = Proc.new do | elem, parent |
+        cat =  @cat_tree.add( parent,
+                              elem.attributes['dbid'].to_i,
+                              elem.attributes['name'] )
+        elem.each_child { | kid | build_cat.call(kid, cat.dbid) }
+      end
+
+      xml  = @dbh.get_first_value("SELECT xml FROM category_structure")
+      doc = REXML::Document.new(xml)
+      doc.root.each_child { | elem | build_cat.call(elem, nil) }
+
+      @dbh.transaction do
+        xml = @cat_tree.serialise
+        @dbh.execute("UPDATE category_structure SET xml = ? ", xml )
+      end
+    end
+  end
+end

data/lib/weft/category.rb

@@ -0,0 +1,157 @@
+require 'weft/coding'
+
+module QDA
+  class Category
+	attr_reader :children, :codes
+	attr_accessor :dbid, :text, :name, :meta, :parent, :memo
+
+	def initialize(name, parent = nil, memo = '')
+	  @name = name
+      @memo  = memo
+	  @parent = parent
+	  @children = []
+	  @codes = QDA::CodingTable.new()
+	  @parent.add_child(self) if @parent
+	end
+	
+	def add_child(child)
+	  @children.push(child)
+      child.parent = self
+	end
+	
+	def append_to(parent)
+	  parent.add_child(self)
+      @parent = parent
+	end
+
+    def ==(other)
+      if other.respond_to?(:dbid)
+        return self.dbid == other.dbid
+      elsif other.nil?
+        return false
+      else
+        raise "No comparison of Category with #{other.inspect}"
+      end        
+    end
+
+    # number of separate documents coded by this category
+	def num_of_docs
+      @codes.num_of_docs
+    end
+
+    def num_of_codes
+      @codes.num_of_codes
+    end
+
+    def num_of_chars
+      @codes.num_of_chars
+    end
+
+    def codetable=(codetable)
+      @codes = codetable
+    end
+
+    # returns a new category with codes representing all the text by
+    # +self+ and +other+.
+    def intersection(other, new_name = 'INTERSECTION', 
+                     new_parent = nil, new_memo = '')
+      result  = Category.new(new_name, new_parent, new_memo)
+      @codes.each do | docid, codes |
+        if other.codes.include?[docid]
+          result.codes[docid] = codes.intersect( other.codes[docid] )
+        end
+      end
+      return result
+    end
+
+	# apply a code to a document; returns the new set of codes applied
+    # to that document. +docid+ should be the database id of the
+    # document to be retrieved (a string)
+	def code(docid, offset, length)
+      unless docid.nil? || docid.kind_of?(Fixnum)
+        raise ArgumentError, 
+          "Docid should be an integer or nil, got #{docid.inspect}"
+      end
+      unless offset >= 0
+        raise ArgumentError, "Offset should be an integer >= 0, got #{offset}" 
+      end
+      unless length > 0
+        raise ArgumentError, "Length should be an integer > 0, got #{length}" 
+      end
+      new_code = QDA::Code.new(docid, offset, length)
+      @codes.add(new_code)
+	end
+
+	def uncode(docid, offset, length)
+	  # raise "docid should be an integer > 0, is #{docid}" if docid == 0
+      c = Code.new(docid, offset, length)
+      @codes.subtract(c)
+    end
+
+    # return the vector set associated with +docid+
+    def [](docid)
+      @codes[docid]
+    end
+  end
+
+  # object representing a particular application of a code to a
+  # document. Not sure entirely what the use of this class is at the
+  # moment - have moved over to using Fragment in preference to save
+  # lots of round trips to the database when calculating intersections
+  # and so on. All the functionality originally developed in this class
+  # now moved to Module +Coding+, mixed-in here and by +Fragment+. That
+  # defines all the union, intersection and exclusion operators
+  # (+, %, -)
+  class Code
+    include Coding
+	attr_accessor :docid, :offset, :length
+    # Create a code applied to the document identified by +docid+,
+    # starting at point +offset+ and running for +length+ characters
+	def initialize(docid, offset, length)
+      unless docid.is_a?(Integer)
+        raise ArgumentError, 
+              "Bad docid value #{docid} expected integer"
+      end
+      unless offset.is_a?(Integer) and offset >= 0
+        raise ArgumentError, 
+              "Bad offset value #{offset} expected integer >= 0"
+      end
+      unless length.is_a?(Integer) and length > 0
+        raise ArgumentError, 
+              "Bad length value #{length}, should be an integer > 0"
+      end
+	  @docid  = docid
+	  @offset = offset
+	  @length = length
+	end
+
+    # a Code is already it's own simplest representation, so never
+    # needs to be modified to work with another code-like object.
+    def coerce(other)
+      self
+    end
+
+    # A +code+ is equal to +other+ if applied to the same document
+    # starts at the same point and runs for the same number of characters
+	def ==(other)
+      @docid == other.docid and
+        @offset == other.offset and
+        @length == other.length
+    end
+
+    # 
+    def <<(other)
+      @length += other.length
+    end
+
+    # returns a new code starting from +point+ within the whole
+    # document and +length+ characters long.
+    def [](point, length)
+      Code.new(@docid, point, length)
+    end
+
+	def inspect
+	  "#<QDA::Code [#{@docid}]: #{@offset}-#{self.end}>"
+	end
+  end
+end