bkmk_objects.py

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