bkmk_objects.py

   1 """
   2    Objects to represent bookmarks.html structure
   3
   4    Written by BroytMann, Mar 2000 - Sep 2007. Copyright (C) 2000-2007 PhiloSoft Design
   5 """
   6
   7
   8 from UserList import UserList
   9
  10 class Folder(UserList):
  11    isFolder = 1
  12    isBookmark = 0
  13
  14    def __init__(self, add_date = None, comment = '', last_modified=None):
  15       UserList.__init__(self)
  16       self.comment = comment
  17       self.add_date = add_date
  18       self.last_modified = last_modified
  19
  20    def walk_depth(self, walker, level=0):
  21       if hasattr(self, "header"): # root folder
  22          prune = 0
  23          walker.root_folder(self)
  24       else:
  25          prune = walker.prune_folder(self)
  26          if not prune:
  27             walker.start_folder(self, level)
  28
  29       if not prune:
  30          for object in self.data:
  31             if object.isFolder:
  32                object.walk_depth(walker, level+1)
  33             elif object.isBookmark:
  34                walker.bookmark(object, level)
  35             else:
  36                walker.ruler(object, level)
  37
  38          walker.end_folder(self, level)
  39
  40
  41 class Bookmark:
  42    isFolder = 0
  43    isBookmark = 1
  44
  45    def __init__(self, href, add_date, last_visit=None, last_modified=None,
  46          keyword=None, comment = ''):
  47       self.comment = comment
  48       self.href = href
  49       self.add_date = add_date
  50       self.last_visit = last_visit
  51       self.last_modified = last_modified
  52       self.keyword = keyword
  53
  54
  55 class Ruler:
  56    isFolder = 0
  57    isBookmark = 0
  58
  59
  60 class Walker:
  61    """
  62       Interface class. Any instance that will be passed to Folder.walk_depth
  63       may be derived from this class. It is not mandatory - unlike Java
  64       Python does not require interface classes; but it is convenient to have
  65       some methods predefined to no-op, in case you do not want to
  66       provide end_folder etc.
  67    """
  68
  69    def root_folder(self, r):
  70       pass
  71
  72    def start_folder(self, f, level):
  73       pass
  74
  75    def end_folder(self, f, level):
  76       pass
  77
  78    def bookmark(self, b, level):
  79       pass
  80
  81    def ruler(self, r, level):
  82       pass
  83
  84    def prune_folder(self, folder):
  85       return 0
  86
  87
  88 class Writer(Walker):
  89    def __init__(self, outfile, prune=None):
  90       self.outfile = outfile
  91       self.prune = prune
  92
  93    def prune_folder(self, folder):
  94       return self.prune == folder.name
  95
  96
  97 class Robot:
  98    def __init__(self, tempfname, log):
  99       self.tempfname = tempfname
 100       self.log = log
 101
 102    def stop(self):
 103       pass # Nothing to do on cleanup
 104
 105
 106 # Helper class to make inverese links (nodes linked to their parent)
 107 class InverseLinker(Walker):
 108    def root_folder(self, r):
 109       self.parent_stack = [r]
 110
 111    def start_folder(self, f, level):
 112       f.parent = self.parent_stack[-1]
 113       self.parent_stack.append(f) # Push the folder onto the stack of parents
 114
 115    def end_folder(self, f, level):
 116       del self.parent_stack[-1]   # Pop off the stack
 117
 118    def bookmark(self, b, level):
 119       b.parent = self.parent_stack[-1]
 120
 121    def ruler(self, r, level):
 122       r.parent = self.parent_stack[-1]
 123
 124
 125 # Helper class to make linear represenatation of the tree
 126 class Linear(Walker):
 127    def root_folder(self, r):
 128       r.linear = [r]
 129       self.linear = r.linear
 130
 131    def add_object(self, object):
 132       self.linear.append(object)
 133
 134    def start_folder(self, f, level):
 135       self.add_object(f)
 136
 137    def bookmark(self, b, level):
 138       self.add_object(b)
 139
 140    def ruler(self, r, level):
 141       self.add_object(r)
 142
 143
 144 # Helper - make linked linear represenatation of the tree, suitable to be stored in sequential storage
 145 def make_linear(root_folder):
 146    linker = InverseLinker()
 147    root_folder.walk_depth(linker)
 148
 149    linear = Linear()
 150    root_folder.walk_depth(linear)
 151
 152
 153 # Helper, opposite of make_linear - make a tree from the linked linear representation
 154 def make_tree(linear):
 155    root_folder = linear[0]
 156    del linear[0]
 157
 158    for object in linear:
 159       object.parent.append(object)
 160
 161    return root_folder