weft-qda 0.9.6 → 0.9.8

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

@@ -1,40 +1,27 @@
 require 'base64'
 
 module QDA::Backend::SQLite
-  class CategoryTreeNode
-    attr_reader :dbid, :children
-    attr_accessor :parent, :name
-    protected :parent=
-
+  class CategoryTreeNode < QDA::Category
     def initialize(parent, dbid, name)
-      @parent, @dbid, @name = parent, dbid, name
+      self.name = name 
+      @parent  = parent
+      @dbid = dbid
       @children = []
     end
-
+    
     def add(dbid, name)
-      append( CategoryTreeNode.new(@dbid, dbid, name) )
+      add_child( CategoryTreeNode.new(@dbid, dbid, name) )[-1]
     end
-
-    def append(child)
-      child.parent = @dbid
-      @children.push(child)[-1]
-    end
-
-    def remove(target)
-      @children.delete_if { | c | c.dbid == target.dbid }
+    
+    def move(parent)
+      @parent = parent.dbid
+      parent.add_child(self)
     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
+      "<CTNode '#{name}' [#{dbid}]>"
     end
+    alias :inspect :to_s
   end
 
   class CategoryTree
@@ -49,20 +36,9 @@ module QDA::Backend::SQLite
     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
+      @table[id] or raise QDA::NotFoundError.new("Unknown id #{id.inspect}")
     end
-
+    
     def add(parentid, dbid, name)
       if parentid
         @table[dbid] = @table[parentid].add(dbid, name)
@@ -73,19 +49,47 @@ module QDA::Backend::SQLite
     end
 
     def remove(dbid)
-      child = @table.delete(dbid)
-      @table[child.parent].remove(child)
+      me = @table[dbid]
+      @table[me.parent].delete(me) if @table[me.parent]
+      dbids = []
+      me.children.each { | c | dbids += remove(c.dbid) }
+      @table.delete(dbid)
+      dbids.push(dbid)
+      dbids
+    end
+    
+    def find(path)
+      paths = QDA::Category.parse_path(path)
+      # if it's a path with "/" at the beginning, search among roots
+      if paths[0].empty?
+        # maybe a named root e.g. '/CATEORIES'
+        fixed_roots = @roots.find_all { | x | x.name =~ /^#{paths[1]}/ }
+        # no root category matched, so search starting from all root nodes
+        if fixed_roots.empty?
+          scope = @roots
+        # root matched, and the path is so short it is the root category itself
+        elsif paths.length < 3
+          return fixed_roots
+        # restrict the search to only the matching root categories
+        else
+          path  = paths[2 .. -1].map { | p | p.gsub(/\//, '//') }.join('/')
+          scope = fixed_roots
+        end
+      # if a relative path (not starting with '/'
+      else
+        scope = @table.values
+      end 
+      scope.inject([]) { | a, x | a + x.find(path) }
     end
-
-    def move(dbid, new_parent)
-      child = @table[dbid]
-      old_parent = child.parent
-      @table[new_parent].append(child)
-      @table[old_parent].remove(child)
+    
+    def move(dbid, new_parentid)
+      movee = @table[dbid]
+      @table[movee.parent].delete(movee)
+      movee.move(@table[new_parentid])
     end
 
     def is_descendant?(ancestor, descendant)
-      @table[ancestor].descendants.include?(descendant)
+      @table[ancestor].is_ancestor_of?(descendant)
     end
 
     def serialise()

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

@@ -0,0 +1,57 @@
+# mainly just utility code to handle transparent choice of sqlite v2 or v3 -
+# all deals diretly with ruby-sqlite module
+module QDA::Backend::SQLite
+
+  # 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 DatabaseBase < SQLITE_DB_CLASS
+    def initialize(*args)
+      super(*args)
+      self.results_as_hash = true
+      self.synchronous = 'OFF'
+    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
+  
+  # only for use in testing - this cannot be saved
+  class InMemoryDatabase < DatabaseBase
+    def initialize()
+      super(":memory:")
+    end
+  end
+  
+  # A class derived from a standard SQLite database with the ability to save
+  # and revert changes. Under the hood, when a database file is requested to be
+  # opened, a temporary copy of that file is used, and all changes are only
+  # written on a call to save().
+  class FileDatabase < DatabaseBase
+    def initialize(file)
+      super(file)
+    end
+  end
+end 

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

@@ -27,6 +27,13 @@ module QDA::Backend::SQLite
         legacy_category_tree_storage()
         save_preference('LastModifiedVersion', WEFT_VERSION)
       end
+      
+      begin
+        old_codes = get_root_category('CODES')
+        old_codes.name = 'CATEGORIES'
+        save_category(old_codes)
+      rescue QDA::NotFoundError
+      end
     end
 
     # This is a change from 0.9.5 -> 0.9.6; Category tree structure

data/lib/weft/broadcaster.rb

@@ -0,0 +1,90 @@
+module QDA
+
+  # Allows an object such as the global Wx App to broadcast messages
+  # about changes in the database and other application states that
+  # might require the child to update its appearance.
+  module Broadcaster
+    # intended to be module private variables to managed which widgets
+    # are subscribing to which events
+    attr_accessor :bc__subscribers, :bc__subscriptions
+	
+	
+	def event_types()
+      self.class.const_get('SUBSCRIBABLE_EVENTS')
+	end
+	
+    # broadcast an event to all subscribers to event of type
+    # +event_type+, optionally including +content+
+    def broadcast(event_type, content = nil)
+      return unless bc__subscriptions
+      for subscriber in bc__subscriptions[event_type]
+        subscriber.notify(event_type, content)
+      end
+    end
+    
+    # subscribe the widget +subscriber+ to receive notification of
+    # app event types +*events+ (which should be a set of symbols)
+    def add_subscriber(subscriber, *events)
+      reset_subscriptions if not bc__subscriptions
+      if events.length == 1 and events[0] == :all
+        events = self.event_types()
+      end
+      
+      events.each do | e |
+        bc__subscriptions[e].push(subscriber)
+      end
+    end
+
+    # accepts a ruby item
+    def delete_subscriber(subscriber)
+      if subscriber.respond_to?(:associated_subscribers)
+        subscriber.associated_subscribers.each do | child |
+          delete_subscriber(child)
+        end
+      end
+      bc__subscribers.delete(subscriber)
+      bc__subscriptions.each_value do | subscriber_set |
+        subscriber_set.delete(subscriber)
+      end
+    end
+
+    def reset_subscriptions()
+      self.bc__subscribers = []
+      self.bc__subscriptions = Hash.new do | ev | 
+        raise "Cannot subscribe to unknown event #{ev}"
+      end
+      event_types.each { | ev | self.bc__subscriptions[ev] = [] }
+    end
+  end
+
+  # Any gui element that may need to modify its appearance in response
+  # to application updates may include the subscriber module. Instances
+  # of the class may then call the +subscribe+ method to receive
+  # notification of changes.
+  module Subscriber
+    # receive notification that an event of type +ev+ has been called,
+    # optionally passing +content+ for additional information about the
+    # object the event concerned.
+    def notify(ev, content = nil)
+      receiver = "receive_#{ev}".intern
+      if respond_to?(receiver)
+        send(receiver, content)
+      else
+        warn "#{self} received unhandled event #{ev}"
+      end
+    end
+
+    # Subscribe this object to the events +events+, which should be a
+    # list of symbols. For example, to receive notification of category
+    # changes and additions, the recipient shoudl call
+    #  subscribe(:category_changed, :category_added)
+    # 
+    # For every event type to which a subscriber subscribes, it should
+    # implement a corresponding receive_xxx method, where xxx is the
+    # name of the event type. To act upon category changes, the
+    # subscriber should implement +receive_category_changed+
+    def subscribe(broadcaster, *events)
+      broadcaster.add_subscriber(self, *events)
+    end
+  end
+end

data/lib/weft/category.rb

@@ -2,39 +2,108 @@ 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
+	attr_reader :children, :codes, :reader, :parent, :name
+	attr_accessor :dbid, :text, :meta, :memo
+
+    def Category.parse_path(path)
+      bits = path.scan(/(?:[^\/]|\/\/)+/)
+      bits.map! { | x | x.gsub(/\/\//, '/') }
+      bits.unshift('') if path =~ /\A\/(?!\/)/
+      bits
+    end
+    
+	def initialize(a_name, a_parent = nil, a_memo = '')
 	  @children = []
-	  @codes = QDA::CodingTable.new()
-	  @parent.add_child(self) if @parent
-	end
-	
-	def add_child(child)
-	  @children.push(child)
-      child.parent = self
+	  self.name = a_name
+      self.memo = a_memo
+	  self.parent = a_parent
+	  # @codes    = QDA::CodingTable.new()
+	  @codes = nil
 	end
 	
-	def append_to(parent)
-	  parent.add_child(self)
-      @parent = parent
-	end
+    def name=(a_name)
+      case a_name
+      when /(\A\/|\/\z)/
+        raise BadNameError.new('Category name cannot have the "/" character' +
+                                ' at beginning or end')
+      when /[\n\t]/
+        raise BadNameError.new('Category name cannot contain newline or tab' + 
+                               ' characters')
+      when String
+        @name = a_name
+      else
+        raise BadNameError.new('Category name must be a string')
+      end
+    end
 
+    def escape_name()
+      name.gsub(/\//, '//')
+    end
+    
     def ==(other)
       if other.respond_to?(:dbid)
-        return self.dbid == other.dbid
+        if self.dbid.nil? and other.dbid.nil?
+          return self.name == other.name && self.parent == other.parent
+        else
+          return self.dbid == other.dbid && self.parent == other.parent
+        end
       elsif other.nil?
         return false
       else
         raise "No comparison of Category with #{other.inspect}"
       end        
     end
-
+    
+    def add_child(child)
+      if self[ child.name ]
+        raise NotUniqueNameError.new("Child with the name '#{child.name}'" +
+                                     "is already attached to '#{self.name}'")
+      end
+	  @children.push(child)
+	end
+	protected :add_child
+	
+	# set the parent of this category to be +new_parent+, deleting from old 
+	# parent if necessary.
+	def parent=(new_parent)
+      if is_ancestor_of?(new_parent)
+        raise BadStructureError.new("Cannot make category a child of " +
+                                    "#{new_parent.path} as it is an ancestor")
+      end
+	  parent.delete(self) if parent
+	  @parent = new_parent
+	  new_parent.add_child(self) if new_parent
+	end
+    
+    # returns all the children who match +idx+
+    def [](idx)
+      case idx
+        when Fixnum, Range
+          return @children[idx]
+        when Regexp
+          return @children.find { | c | c.name =~ idx}
+        when String
+          patt = /\A#{Regexp.escape(idx)}\z/i
+          return @children.find { | c | c.name =~ patt }
+        else
+          raise ArgumentError.new("Bad index #{idx}")
+      end
+    end
+        
+    def delete(target)
+      @children.delete(target)
+    end
+    
     # number of separate documents coded by this category
+    def unique_name(name)
+      while self[ name ]
+        puts "#{name} exists"
+        name.sub!(/(?:\s*\((\d+)\))?$/) { " (#{$1.to_i.succ})" }
+        puts "trying #{name}"
+      end
+      name
+    end
+    
 	def num_of_docs
       @codes.num_of_docs
     end
@@ -47,51 +116,74 @@ module QDA
       @codes.num_of_chars
     end
 
-    def codetable=(codetable)
-      @codes = codetable
+    def each_child
+      children.each { | c | yield c }
+    end
+    def path()
+      ancestors.inject("/" << escape_name) do | path, anc |
+        "/" << anc.escape_name << path
+      end
+    end
+    
+    def ancestors()
+      ancestor, ancestors = self, []
+      ancestors.push(ancestor) while ancestor = ancestor.parent
+      ancestors
+    end
+    
+    def descendants()
+      @children.map() { | c | [ c, c.descendants ] }.flatten
     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
+    def find(path)
+      points = Category.parse_path(path)
+      scope = @children
+      points.delete('')
+      while point = points.shift
+        scope = scope.find_all { | x | x.name =~ /^#{point}/ }
+        scope.map! { | x | x.children }.flatten! unless points.empty?
       end
-      return result
+      scope
+    end
+    
+    # returns true if +cat+ is a Category located below self
+    def is_ancestor_of?(cat)
+      descendants.include?(cat)
+    end
+    
+    
+    def is_descendant_of?(cat)
+      ancestors.include?(cat)
+    end
+    
+    def codetable=(codetable)
+      @codes = codetable
     end
 
+    def codetable_init()
+      @codes ||= QDA::CodingTable.new()
+    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
+      codetable_init()
       new_code = QDA::Code.new(docid, offset, length)
       @codes.add(new_code)
 	end
 
 	def uncode(docid, offset, length)
+      @codes ||= QDA::CodingTable.new()
 	  # 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]
+    
+    def to_s()
+      "<Category '#{path}' [#{dbid}]>"
     end
+    alias :inspect :to_s
   end
 
   # object representing a particular application of a code to a
@@ -125,7 +217,7 @@ module QDA
 	  @length = length
 	end
 
-    # a Code is already it's own simplest representation, so never
+    # a Code is already its own simplest representation, so never
     # needs to be modified to work with another code-like object.
     def coerce(other)
       self