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