bkmk_objects.py

   1 """
   2    Objects to represent bookmarks.html structure
   3
   4    Written by Oleg BroytMann. Copyright (C) 2000-2007 PhiloSoft Design.
   5 """
   6
   7
   8 class Folder(list):
   9    isFolder = 1
  10    isBookmark = 0
  11
  12    def __init__(self, add_date=None, comment='', last_modified=None):
  13       super(Folder, self).__init__()
  14       self.comment = comment
  15       self.add_date = add_date
  16       self.last_modified = last_modified
  17
  18    def walk_depth(self, walker, level=0):
  19       if hasattr(self, "header"): # root folder
  20          prune = 0
  21          walker.root_folder(self)
  22       else:
  23          prune = walker.prune_folder(self)
  24          if not prune:
  25             walker.start_folder(self, level)
  26
  27       if not prune:
  28          for object in self:
  29             if object.isFolder:
  30                object.walk_depth(walker, level+1)
  31             elif object.isBookmark:
  32                walker.bookmark(object, level)
  33             else:
  34                walker.ruler(object, level)
  35
  36          walker.end_folder(self, level)
  37
  38
  39 class Bookmark:
  40    isFolder = 0
  41    isBookmark = 1
  42
  43    def __init__(self, href, add_date, last_visit=None, last_modified=None,
  44          keyword=None, comment='', icon=None, charset=None):
  45       self.href = href
  46       self.add_date = add_date
  47       self.last_visit = last_visit
  48       self.last_modified = last_modified
  49       self.keyword = keyword
  50       self.comment = comment
  51       self.icon = icon
  52       self.charset = charset
  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