bkmk_objects.py

   1 """
   2    Objects to represent bookmarks.html structure
   3
   4    Written by BroytMann, Mar 2000 - Jul 2003. Copyright (C) 2000-2003 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 = ''):
  15       UserList.__init__(self)
  16       self.comment = comment
  17       self.add_date = add_date
  18
  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          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
  53
  54 class Ruler:
  55    isFolder = 0
  56    isBookmark = 0
  57
  58
  59 class Walker:
  60    """
  61       Interface class. Any instance that will be passed to Folder.walk_depth
  62       may be derived from this class. It is not mandatory - unlike Java
  63       Python does not require interface classes; but it is convenient to have
  64       some methods predefined to no-op, in case you do not want to
  65       provide end_folder etc.
  66    """
  67
  68    def root_folder(self, r):
  69       pass
  70
  71    def start_folder(self, f, level):
  72       pass
  73
  74    def end_folder(self, f, level):
  75       pass
  76
  77    def bookmark(self, b, level):
  78       pass
  79
  80    def ruler(self, r, level):
  81       pass
  82
  83    def prune_folder(self, folder):
  84       return 0
  85
  86
  87 class Writer(Walker):
  88    def __init__(self, outfile, prune=None):
  89       self.outfile = outfile
  90       self.prune = prune
  91
  92    def prune_folder(self, folder):
  93       return self.prune == folder.name
  94
  95
  96 class Robot:
  97    def __init__(self, tempfname, log):
  98       self.tempfname = tempfname
  99       self.log = log
 100
 101    def stop(self):
 102       pass # Nothing to do on cleanup
 103
 104
 105 # Helper class to make inverese links (nodes linked to their parent)
 106 class InverseLinker(Walker):
 107    def root_folder(self, r):
 108       self.parent_stack = [r]
 109
 110    def start_folder(self, f, level):
 111       f.parent = self.parent_stack[-1]
 112       self.parent_stack.append(f) # Push the folder onto the stack of parents
 113
 114    def end_folder(self, f, level):
 115       del self.parent_stack[-1]   # Pop off the stack
 116
 117    def bookmark(self, b, level):
 118       b.parent = self.parent_stack[-1]
 119
 120    def ruler(self, r, level):
 121       r.parent = self.parent_stack[-1]
 122
 123
 124 # Helper class to make linear represenatation of the tree
 125 class Linear(Walker):
 126    def root_folder(self, r):
 127       r.linear = [r]
 128       self.linear = r.linear
 129
 130    def add_object(self, object):
 131       self.linear.append(object)
 132
 133    def start_folder(self, f, level):
 134       self.add_object(f)
 135
 136    def bookmark(self, b, level):
 137       self.add_object(b)
 138
 139    def ruler(self, r, level):
 140       self.add_object(r)
 141
 142
 143 # Helper - make linked linear represenatation of the tree, suitable to be stored in sequential storage
 144 def make_linear(root_folder):
 145    linker = InverseLinker()
 146    root_folder.walk_depth(linker)
 147
 148    linear = Linear()
 149    root_folder.walk_depth(linear)
 150
 151
 152 # Helper, opposite of make_linear - make a tree from the linked linear representation
 153 def make_tree(linear):
 154    root_folder = linear[0]
 155    del linear[0]
 156
 157    for object in linear:
 158       object.parent.append(object)
 159
 160    return root_folder