weft-qda 0.9.6 → 0.9.8

data/lib/weft.rb

@@ -1,9 +1,24 @@
-require 'weft/filters'
+# maybe if running under rubygems
+if not defined?(WEFT_SHARE_DIR)
+  WEFT_SHAREDIR = File.join( File.dirname(__FILE__), '..', 'share')
+end
+
+# core classes
+
+require 'weft/exceptions'
 require 'weft/document'
 require 'weft/category'
+require 'weft/query'
+require 'weft/codereview'
+require 'weft/broadcaster' 
+
+# backend
 require 'weft/backend'
 require 'weft/application'
 
+# i/o
+require 'weft/filters'
+
 begin
   require 'weft/WEFT-VERSION-STRING'
   WEFT_VERSION = QDA::Version.new(WEFT_VERSION_STRING)

data/lib/weft/WEFT-VERSION-STRING.rb

@@ -1 +1 @@
-WEFT_VERSION_STRING = '0.9.6'
+WEFT_VERSION_STRING = '0.9.8a'

data/lib/weft/application.rb

@@ -1,5 +1,3 @@
-require 'observer'
-
 module QDA
   class Version
     attr_reader :major, :minor, :release
@@ -30,29 +28,24 @@ module QDA
   end
 
   class Application
-    include Observable
-    def initialize(observer = nil)
-      add_observer(observer) if observer
-      @dirty = false
-    end
+    include Broadcaster
 
+    SUBSCRIBABLE_EVENTS = [ :saved, :started, :ended,
+      :document_added, :document_changed, :document_deleted, 
+      :category_added, :category_changed, :category_deleted ]
+ 
     # creates a completely empty new application / project, using the
     # backend +backend+, to be intialized with args +args+
-	def Application::new_virgin(backend, args, observer = nil)
-	  app = new()
-	  app.extend( backend )
-	  app.start(args)
-	  app.install_clean()
-	  app
+	def initialize(backend_class = nil)
+      self.extend(backend_class) if backend_class
 	end
     
     # create some basic nodes
     def set_up()
-      save_category( Category.new('CATEGORIES', nil) )
-      save_category( Category.new('SEARCHES', nil) )
+      _save_category( Category.new('CATEGORIES', nil) )
+      _save_category( Category.new('SEARCHES', nil) )
       save_preference( 'CreateVersion', WEFT_VERSION )
       save_preference( 'CreateVersionString', WEFT_VERSION_STRING )
-      undirty!
     end
 
 	def each_doc()
@@ -64,67 +57,17 @@ module QDA
       @dirty
 	end
 
-    def dirty!()
-      changed if not dirty?
-      @dirty = true
-      notify_observers(@dirty)
-    end
-
-    def undirty!()
-      changed if dirty?
-      @dirty = false
-      notify_observers(@dirty)
-    end
-
-	# is it up and running
-	def started?
-	  true
-	end
-
-	# signal to clear up - should this be the level at which an exception
-	# is raised - no, should probably be at the gui level
-	def finish(force = false)
-	  if ! consistent? and ! force
-		raise "Not ready to be saved"
-	  end
-	end
-
-    def query_segment(function, *args)
-      case function
-      when "IS CODED BY"
-        category = get_category(args[0])
-        return get_text_at_category( category )
-      when "CONTAINS WORD"
-        return get_search_fragments( args[0], :wrap_both => 100 )
+    def broadcast(evt, content = nil)
+      super(evt, content)
+      if evt == :saved or evt == :started or evt == :ended
+        @dirty = false
       else
-        raise RuntimeError.new("Unknown function '#{function}' in query")
+        @dirty = true
       end
     end
-    private :query_segment
-
-    # executes a query, which is a series of descriptions of text
-    # functions (eg 'CODED BY "category x"') and operators describing
-    # how to combine them('AND', 'NOT', 'Or')
-    def do_query(*query)
-      text_1 = query_segment(query.shift, query.shift)
-
-      # work rightwards through the query, doing various kinds of
-      # combination of the result sets retrieved
-      while op = query.shift
-        return text_1 if op.empty?
-        text_2 = query_segment(query.shift, query.shift)
-        if op == 'AND'
-          text_1.join(text_2)
-        elsif op == 'OR'
-          text_1.merge(text_2)
-        elsif op =~ /(AND )?NOT/
-          text_1.remove(text_2)
-        else
-          raise RuntimeError.new("Unknown operator '#{op}' in query")
-        end
-      end
-
-      return text_1
+    
+    def inspect()
+      "<QDA::Application>"
     end
   end
 end

data/lib/weft/backend.rb

@@ -1,39 +1,13 @@
 module QDA
   module Backend
-	autoload :MySQL, 'weft/backend/mysql'
-	# autoload :SQLite, 'backend/sqlite'
 	require 'weft/backend/sqlite'
-	# autoload :N6, 'backend/n6'
 	require 'weft/backend/n6'
-	autoload :RubyNative, 'weft/backend/marshal'
-
-	module Abstract
-	  # receive arguments and make any connection required to the
-	  # storage source
-	  def start(args = {})
-		# raise "virtual"
-	  end
-	  
-	  # load a specific document
-	  def get_doc(doctitle)
-		raise "virtual"	
-	  end
-
-	  # an array of all the documents - should this include TEXT
-	  def get_all_docs()
-		[]
-	  end
 
-	  # all categories in a tree structure, the root nodes are returned
-	  def get_all_categories()
-		[ Category.new('') ]
-	  end
-
-	  # save changes
-	  def save()
-		raise "virtual"	
-	  end
-
-	end
+    # autoload :MySQL, 'weft/backend/mysql'
+	# autoload :SQLite, 'backend/sqlite'
+	# autoload :N6, 'backend/n6'
+	# autoload :RubyNative, 'weft/backend/marshal' 
+    class BackendError < StandardError
+    end
   end
 end

data/lib/weft/backend/sqlite.rb

@@ -12,130 +12,106 @@ module QDA
 # currently problems with SQLite 3 and non-ASCII characters. Will pick
 # up whether sqlite or sqlite3 is available.
 module Backend::SQLite
-
+  include Backend
+  require 'weft/backend/sqlite/database.rb'  
   require 'weft/backend/sqlite/schema.rb'
   require 'weft/backend/sqlite/upgradeable.rb'
   require 'weft/backend/sqlite/category_tree.rb'
-  include Upgradeable
-
-  # if working with sqlite v2 with the sqlite-ruby v2, we need a
-  # couple of compatibility tweaks.
-  if defined?(::SQLite)
-    SQLITE_DB_CLASS = ::SQLite::Database
-    # Ruby-SQLite3 statements have a close() method, but Ruby-SQLite
-    # v 2 don't - so we supply a dummy method for when using v2
-    class ::SQLite::Statement
-      def close(); end
-    end
-    # SQLite3 introduced this more ruby-ish notation
-    class ::SQLite::Database::FunctionProxy
-      alias :result= :set_result
-    end
-  elsif defined?(::SQLite3)
-    SQLITE_DB_CLASS = ::SQLite3::Database
-  else
-    raise LoadError, "No SQlite database class loaded"
-  end
-
-  class Database < SQLITE_DB_CLASS
-    def initialize(file)
-      # super(file, :driver => "Native")
-      super(file)
-      self.results_as_hash = true
-      # self.type_translation = true
-    end
-
-    def undo_action()
-      @dbh.transaction do 
-        @dbh.execute("SELECT * FROM undoable WHERE step = 1
-                     ORDER BY step, actionid DESC") do | task |
-          @dbh.execute(task[0])
-        end
-        @dbh.execute("UPDATE undoable SET step = step -1")
-        @dbh.execute("DELETE FROM undoable WHERE step = 0")
-      end
-    end
-
-    def redo_action()
-      transaction do 
-        execute("SELECT * FROM undoable WHERE step = -1
-                     ORDER BY step, actionid DESC") do | task |
-          execute(task[0])
-        end
-        execute("DELETE FROM undoable WHERE step = -1")
-        execute("UPDATE undoable SET step = step + 1")
-      end
-    end
-
-    def date_freeze(date)
-      date ? date.strftime('%Y-%m-%d %H:%M:%S') : ''
-    end
 
-    def date_thaw(str)
-      return nil if str.empty?
-      return Time.local( *str.split(/[- :]/) )
-    end
-  end
+  include Upgradeable
 
   attr_reader :dbh, :dbfile
 
-  # load up the database connection. A hash argument containing the
+  # Makes the database connection. A hash argument containing the
   # key :dbfile should be supplied. If this is +nil+, then a
-  # temporary storage will be used
+  # temporary storage will be used. Alternately, the key :in_memory may
+  # supplied with any true value, and a new in-memory database will be created.
+  # This is normally only useful for testing, as these databases can't currenly
+  # be saved. They are, however, fast and straightforward.
   def start(args)
-    if ! args.key?(:dbfile)
+    return start_in_memory() if args.key?(:memory)
+    unless args.key?(:dbfile)
       raise ArgumentError, "Must specify SQLite dbfile to load from"
     end
-
+    
     @dbfile  = args[:dbfile]
     if @dbfile and ! File.exists?(@dbfile)
-      raise RuntimeError, "Tried to open an non-existent database"
+      raise ArgumentError, "Tried to open an non-existent database"
     end
 
+    # create an empty temporary file
     tmp_fname = @dbfile ? File::basename(@dbfile) : 'Weft'
-    tmpfile   = Tempfile.new(tmp_fname || 'Weft')
-    tmpfile.close(false) # don't delete
-
-    @tmpfile = tmpfile.path
-    if @dbfile
-      FileUtils.copy(@dbfile, @tmpfile)
-    end
-    @dbh = Database.new(@tmpfile)
+    @tmp_tmp   = Tempfile.new(tmp_fname)
+    @tmp_tmp.close(false) # don't delete
+
+    # copy the existing file being opened to the tempfile
+    @tmpfile = @tmp_tmp.path
+    FileUtils.copy(@dbfile, @tmpfile) if @dbfile
+    @dbh = FileDatabase.new( @tmpfile )
+        
     # if opening from an existing file, check and do any upgrding
     # required from older versions
     do_version_format_upgrading() if @dbfile
-    undirty!
+    broadcast(:started)
   end
-
+  
+  def start_in_memory()
+    @dbh = InMemoryDatabase.new()
+    broadcast(:started)
+  end
+  
   def connect(args)
     @dbh = args[:dbh]
   end
 
-  def end(force = false)
+  def end()
     @cat_tree = nil
-    @dbh.close()
-  end
-
-  def save(target = @dbfile)
-    if target.nil?
-      raise RuntimeError,
-      "No previously saved file, and no named supplied for save"
+    if @dbh
+      @dbh.close() 
+      @dbh = nil
+    end
+    
+    # seem to be ending up with a lot of tempfiles left over .. but unlink
+    # gives 'Permission denied'
+    # File.unlink(@tmpfile) if @tmpfile
+    @tmp_tmp = @tmpfile = nil 
+
+    broadcast(:ended)
+  end
+
+  # Saves all changes since the file was either newly opened or saved. May
+  # optionally specify +target+ as the file to save changes to. If no +target+
+  # is specified, changes are saved to the file from which the database was
+  # first opened. An error will be raised if this is a previously unsaved
+  # project and no save destination is specified.
+  def save(target = nil)
+    if @dbh.is_a?(InMemoryDatabase)
+      raise QDA::Backend::BackendError,
+        "Cannot save an in-memory database"
+    end
+    
+    unless ( target && @dbfile = target ) or @dbfile
+      raise QDA::Backend::BackendError,
+        "No previously saved file, and no named supplied for save"
     end
-    @dbh.close
-    @dbfile = target
+      
+    @dbh.close() if not @dbh.closed?
     FileUtils.copy(@tmpfile, @dbfile)
-    @dbh = Database.new(@tmpfile)
-    undirty!
+    @dbh = FileDatabase.new(@tmpfile)
+    broadcast(:saved)
   end
 
   # roll the current state back to the last-saved state.
   def revert()
-    @dbh.close()
+    unless @dbfile
+      raise QDA::Backend::BackendError, "No previously saved file to revert to"
+    end
+    @dbh.close() if not @dbh.closed?
     FileUtils.copy(@dbfile, @tmpfile)
-    @dbh = Database.new(@tmpfile)
+    @dbh = FileDatabase.new(@tmpfile)
+    broadcast(:saved)
   end
 
-
   # hint to do the next series of actions as a batch
   def batch
     @dbh.transaction { yield }
@@ -164,7 +140,7 @@ module Backend::SQLite
   end
 
   # fetch the document identified by the string ident
-  def get_doc(ident)
+  def get_document(ident)
     doc = nil
     @dbh.transaction do 
       stmt = nil
@@ -187,8 +163,19 @@ module Backend::SQLite
     end
     return doc
   end
-  alias :get_document :get_doc
-
+  alias :get_doc :get_document
+  
+  # Replaces +string+ (in place) with a numeric bracketed suffix, incrementing 
+  # the integer each time.
+  # e.g.
+  #  name
+  #  name (1)
+  #  name (2)
+  #  name (3)
+  def magic_rename(str)
+     str.sub!(/(?:\s*\((\d+)\))?$/) { " (#{$1.to_i.succ})" }
+  end
+  
   def save_preference(pref_name, pref_value)
     frozen_value = Base64.encode64( Marshal.dump( pref_value) )
     @dbh.transaction do
@@ -196,7 +183,6 @@ module Backend::SQLite
                         VALUES (?, ?)",
                     pref_name, frozen_value )
     end
-    dirty!
   end
 
   def get_preference(pref_name)
@@ -211,14 +197,27 @@ module Backend::SQLite
     return Marshal.load( Base64.decode64(frozen_pref) )
   end
 
-  def save_document(doc)
+  # saves the document +doc+ to the database; if the document already has a dbid
+  # it will be treated as an existing document 
+  def save_document(doc, rename_magic = false)
     raise TypeError unless doc.kind_of? QDA::Document
+    new = doc.dbid ? false : true
     @dbh.transaction { _save_document(doc) }
-    dirty!
+    if new
+      broadcast(:document_added, doc)
+    else
+      broadcast(:document_changed, doc)
+    end
     doc
+  rescue NotUniqueNameError
+    raise unless rename_magic
+    magic_rename(doc.title)
+    retry
   end
-
+  alias :save_doc :save_document
+  
   def _save_document(doc)
+    # if we are saving changes to an already-saved document
     if doc.dbid
       @dbh.execute("UPDATE document 
                         SET doctitle = ?, doctext = ?, 
@@ -227,7 +226,9 @@ module Backend::SQLite
                     doc.title, doc.text, doc.memo, 
                     @dbh.date_freeze( Time.now() ),
                     doc.dbid)
+    # a new document is being saved
     else
+      raise NotUniqueNameError if doc_exists(doc.title)
       @dbh.execute("INSERT INTO document 
                         VALUES(NULL, ?, ?, ?, ?, ?)", 
                     doc.title, doc.text, doc.memo, 
@@ -236,21 +237,42 @@ module Backend::SQLite
       doc.dbid = @dbh.last_insert_row_id().to_i
     end
   end
-
-  # delete teh document identified by +dbid+ from the database
-  def delete_document(dbid)
+  
+  # returns the dbid for the document titled +title+, or nil if no such
+  # document exists.
+  def doc_exists(title)
+    @dbh.execute("SELECT docid 
+                  FROM document 
+                  WHERE doctitle = ?", title) { | r | return r[0].to_i }
+  end
+  
+  # delete the document identified by +dbid+ from the database
+  def delete_document(doc)
     @dbh.transaction do
-      @dbh.execute("DELETE FROM document WHERE docid = ?", dbid)
+      @dbh.execute("DELETE FROM document WHERE docid = ?", doc.dbid)
     end
-    dirty!
+    broadcast(:document_deleted, doc)
   end
 
   # retrieve the category with the internal id +catid+, along with
   # its codes. If +get_structure+ is set to a true value then the
   # category's children will also be retrieved from the database
-  def get_category(catid, get_structure = false)
+  
+  def get_category(identifier, get_struct = false)
+    case identifier
+    when Fixnum
+      return get_category_by_id(identifier, get_struct)
+     when String
+      return get_category_by_path(identifier, get_struct)
+    when QDA::Category
+      return get_category_by_id(identifier.dbid, get_struct)
+    else
+      raise "Invalid identifier #{catid.inspect}"
+    end
+  end
+  
+  def get_category_by_id(catid, get_structure = false)
     catid = catid.to_i if catid =~ /^\d+$/
-    raise "Invalid id #{catid.inspect}" unless catid.kind_of?(Fixnum)
 
     category = nil
     stmt = @dbh.prepare("SELECT * FROM category WHERE catid = ?")
@@ -259,28 +281,49 @@ module Backend::SQLite
       category = Category.new(r['catname'], parent, r['catdesc'])
       category.dbid = catid
     end
-    raise "No category found matching id '#{catid}'" unless category
     stmt.close()
+    
+    if not category
+      raise NotFoundError.new("No category found matching id '#{catid}'")
+    end
 
     get_codes_for_category(category)
     get_and_build_children(category) if get_structure
     category
   end
-
+  
+  # returns the dbid of the category named +name+ attached to the parent
+  # category +parent+, or nil if no such category exists
+  def category_exists?(parent, name)
+    if parent
+      x = cat_tree[parent.dbid][name]
+    else
+      x = cat_tree.roots.find { | r | r.name == name }
+    end
+    x ? x.dbid : nil
+  end
+  
   # gets the root category named +name+
-  def get_root_category(name)
+  def get_root_category(name, get_structure = false)
     root = cat_tree.roots.find { | r | r.name == name }
-    raise "Not found, root category #{name.inspect}" unless root
-    return get_category(root.dbid)
+    unless root
+      raise NotFoundError.new("Not found, root category #{name.inspect}")
+    end
+    return get_category(root.dbid, get_structure)
   end
 
+  
+  def get_category_by_path(path, get_struct)
+    get_categories_by_path(path, get_struct)[0]
+  end
+  
   # fetch categories by relative or absolute paths. Returns an 
   # array of categories
-  def get_categories_by_path(path)
+  def get_categories_by_path(path, get_struct = false)
     # cos it should be quicker ...
     if path =~ /\//
       return cat_tree.find(path).map do | found |
-        get_category(found.dbid)
+        get_category(found.dbid, get_struct)
       end
     else
       return get_categories_by_name(path)
@@ -296,17 +339,17 @@ module Backend::SQLite
       stmt = @dbh.prepare("SELECT catid FROM category 
                    WHERE UPPER(catname) LIKE ?
                    AND parent >= 0" )
-      namebit = namebit.upcase
+      namebit = namebit.upcase + "%"
     else
       stmt = @dbh.prepare("SELECT catid FROM category 
                    WHERE catname GLOB ?
                    AND parent >= 0" )
-      
+      namebit = namebit + "*"
     end
     categories = []
     @dbh.transaction do
-      stmt.execute!(namebit + "%") do | r |
-        categories.push( get_category( r['catid'] ) )
+      stmt.execute!(namebit) do | r |
+        categories.push( get_category( r['catid'].to_i, true ) )
       end
       stmt.close()
     end
@@ -320,22 +363,22 @@ module Backend::SQLite
   # builds the tree structure below +category+, modifying
   # +category+ in place. After this call, the retrieved structure
   # is available as the +children+ property of the category.
-  def get_and_build_children(category)
+  def get_and_build_children(base)
     # this duplicates stuff below
     append_f = Proc.new do | parent, elem |
       cat = Category.new(elem.name, parent) 
       cat.dbid = elem.dbid
-      elem.children { | c | append_f.call(cat, c) }
+      elem.each_child { | c | append_f.call(cat, c) }
     end
-
-    cat_tree[category.dbid].children do | first_child |
-      append_f.call(category, first_child)
+    cat_tree[base.dbid].each_child do | kid |
+      append_f.call(base, kid)
     end
   end
   private :get_and_build_children
 
   # applies the codes to category +cat+
   def get_codes_for_category(cat)
+    cat.codetable = QDA::CodingTable.new
     @dbh.execute("SELECT docid, offset, length
                       FROM code
                       WHERE catid = ? ", cat.dbid) do | row |
@@ -391,31 +434,44 @@ module Backend::SQLite
   end
 
   # saves the category
-  def save_category(cat)
+  def save_category(cat, rename_magic = false)
+    new = cat.dbid ? false : true
     @dbh.transaction { _save_category(cat) }
-    dirty!
+    if new
+      broadcast(:category_added, cat)
+    else
+      broadcast(:category_changed, cat)
+    end
     cat
+  rescue NotUniqueNameError
+    raise unless rename_magic
+    magic_rename(cat.name)
+    retry
   end
 
   def _save_category(cat)
-    # only resave the tree structure if nec,
+    # only resave the tree structure if necessary
     xml_needs_update = false
-
+ 
     # updating an existing category
     if cat.dbid
+      # fetch the corresponding node from the tree
+      node = cat_tree[cat.dbid]
+      
       # check for re-parenting or renaming
-      child = cat_tree[cat.dbid]
-
-      if child.parent != cat.parent.dbid
-        cat_tree.move(child.dbid, cat.parent.dbid)
+      if cat.parent and node.parent != cat.parent.dbid
+        raise NotUniqueNameError if category_exists?(cat.parent, cat.name)
+        cat_tree.move(node.dbid, cat.parent.dbid)
         xml_needs_update = true
       end
-
-      if child.name != cat.name
-        child.name = cat.name
+      
+      # check for name change
+      if node.name != cat.name
+        raise NotUniqueNameError if category_exists?(cat.parent, cat.name)
+        node.name = cat.name
         xml_needs_update = true
       end
-      @dbh.execute("DELETE FROM code WHERE catid = ?", cat.dbid)
+      
       @dbh.execute("UPDATE category 
                           SET catname = ?,
                               catdesc = ?,
@@ -429,6 +485,7 @@ module Backend::SQLite
                     cat.dbid)
       # adding a new category
     else
+      raise NotUniqueNameError if category_exists?(cat.parent, cat.name)
       parentid = cat.parent ? cat.parent.dbid : nil
       @dbh.execute("INSERT INTO category 
                         VALUES(NULL, ?, ?, ?, ?, ?)",
@@ -436,56 +493,57 @@ module Backend::SQLite
                     @dbh.date_freeze( Time.now ),
                     @dbh.date_freeze( Time.now ) )
       cat.dbid = @dbh.last_insert_row_id().to_i
-
-      if cat.parent
-        cat_tree.add(cat.parent.dbid, cat.dbid, cat.name)
-      else
-        cat_tree.add(nil, cat.dbid, cat.name)
-      end
+      cat_tree.add(parentid, cat.dbid, cat.name)
+      
       xml_needs_update = true
     end
-
-    stmt_code = @dbh.prepare("INSERT INTO code VALUES(?, ?, ?, ?)")
-    cat.codes.each do | docid, vecs |
-      vecs.each do | vec |
-        stmt_code.execute( cat.dbid, vec.docid, vec.offset, vec.length )
-      end
+    
+    if cat.codes
+      _save_codingtable(cat.dbid, cat.codes)
     end
-    stmt_code.close()
 
     if xml_needs_update
       @dbh.execute( "UPDATE category_structure SET xml = ? ", 
                     cat_tree.serialise())
     end
   end
-
+  
+  # save all the codes in the table +codingtable+ to the database, associating
+  # them with the category id +dbid+. Deletes all previous coding associated
+  # with that category.
+  def _save_codingtable(dbid, codingtable)
+    @dbh.execute("DELETE FROM code WHERE catid = ?", dbid)
+    stmt_code = @dbh.prepare("INSERT INTO code VALUES(?, ?, ?, ?)")
+    codingtable.each do | docid, vecs |
+      vecs.each do | vec |
+        stmt_code.execute( dbid, vec.docid, vec.offset, vec.length )
+      end
+    end
+    stmt_code.close()  
+  end
+  
   # deletes the category +category+. If +recursive+ is false then
   # any children of +category+ will be reattached to the deleted
   # category's parent. If +recursive+ is true (default), then all
   # descendants will be deleted. 
   # Returns a list of categories that were actually deleted.
   def delete_category(cat, recursive = true)
+    if not recursive
+        raise NotImplementedError.new('Non-recursive deletion not implemented')
+    end
     return unless cat.dbid
-    deleted_items = []
-    # TODO not all items being returned in list
-    if recursive
-      me = cat_tree[cat.dbid]
-      me.children.each do | child |
-        deleted_items += delete_category(child, true)
+    deleted_items = cat_tree.remove(cat.dbid)
+    @dbh.transaction do
+      deleted_items.each do | dbid | 
+        @dbh.execute("DELETE FROM category WHERE catid = ? ", dbid)
       end
-      cat_tree.remove(cat.dbid)
-      deleted_items << cat
-    else
-      raise NotImplementedError, 
-      'Non-recursive deletion not implemented'
+      @dbh.execute("UPDATE category_structure SET xml = ?", 
+                   cat_tree.serialise())
     end
-    @dbh.transaction do
-      @dbh.execute("DELETE FROM category WHERE catid = ? ", cat.dbid)
-      xml = cat_tree.serialise()
-      @dbh.execute("UPDATE category_structure SET xml = ?", xml)
+    [ cat, *cat.descendants ].each do | deletion |
+      broadcast(:category_deleted, deletion)
     end
-    dirty!
-    return deleted_items
+    return cat
   end
 
   MAGIC_REV_INDEX_ID = -2 
@@ -514,7 +572,7 @@ module Backend::SQLite
         locations.each do | loc |
           stmt_code.execute(wordid, docid, loc, word.length)
         end
-        prog_bar.next() if prog_bar
+        prog_bar.step() if prog_bar
       end
     end # transaction
     [stmt_wordid, stmt_insert, stmt_code].each { | s | s.close() }