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 import os, cgi
   8 BKMK_FORMAT = os.environ.get("BKMK_FORMAT", "MOZILLA")
   9
  10
  11 class Folder(list):
  12    isFolder = 1
  13    isBookmark = 0
  14
  15    def __init__(self, add_date=None, comment='', last_modified=None):
  16       super(Folder, self).__init__()
  17       self.comment = comment
  18       self.add_date = add_date
  19       self.last_modified = last_modified
  20
  21    def walk_depth(self, walker, level=0):
  22       if hasattr(self, "header"): # root folder
  23          prune = 0
  24          walker.root_folder(self)
  25       else:
  26          prune = walker.prune_folder(self)
  27          if not prune:
  28             walker.start_folder(self, level)
  29
  30       if not prune:
  31          for object in self:
  32             if object.isFolder:
  33                object.walk_depth(walker, level+1)
  34             elif object.isBookmark:
  35                walker.bookmark(object, level)
  36             else:
  37                walker.ruler(object, level)
  38
  39          walker.end_folder(self, level)
  40
  41
  42 class Bookmark:
  43    isFolder = 0
  44    isBookmark = 1
  45
  46    def __init__(self, href, add_date, last_visit=None, last_modified=None,
  47          keyword=None, comment='', icon=None, charset=None):
  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       self.comment = comment
  54       self.icon = icon
  55       self.charset = charset
  56
  57
  58 class Ruler:
  59    isFolder = 0
  60    isBookmark = 0
  61
  62
  63 class Walker:
  64    """
  65       Interface class. Any instance that will be passed to Folder.walk_depth
  66       may be derived from this class. It is not mandatory - unlike Java
  67       Python does not require interface classes; but it is convenient to have
  68       some methods predefined to no-op, in case you do not want to
  69       provide end_folder etc.
  70    """
  71
  72    def root_folder(self, r):
  73       pass
  74
  75    def start_folder(self, f, level):
  76       pass
  77
  78    def end_folder(self, f, level):
  79       pass
  80
  81    def bookmark(self, b, level):
  82       pass
  83
  84    def ruler(self, r, level):
  85       pass
  86
  87    def prune_folder(self, folder):
  88       return 0
  89
  90
  91 class Writer(Walker):
  92    def __init__(self, outfile, prune=None):
  93       self.outfile = outfile
  94       self.prune = prune
  95
  96    def prune_folder(self, folder):
  97       return self.prune == folder.name
  98
  99
 100 class Robot:
 101    def __init__(self, tempfname, log):
 102       self.tempfname = tempfname
 103       self.log = log
 104
 105    def stop(self):
 106       pass # Nothing to do on cleanup
 107
 108
 109 # Helper class to make inverese links (nodes linked to their parent)
 110 class InverseLinker(Walker):
 111    def root_folder(self, r):
 112       self.parent_stack = [r]
 113
 114    def start_folder(self, f, level):
 115       f.parent = self.parent_stack[-1]
 116       self.parent_stack.append(f) # Push the folder onto the stack of parents
 117
 118    def end_folder(self, f, level):
 119       del self.parent_stack[-1]   # Pop off the stack
 120
 121    def bookmark(self, b, level):
 122       b.parent = self.parent_stack[-1]
 123
 124    def ruler(self, r, level):
 125       r.parent = self.parent_stack[-1]
 126
 127
 128 # Helper class to make linear represenatation of the tree
 129 class Linear(Walker):
 130    def root_folder(self, r):
 131       r.linear = [r]
 132       self.linear = r.linear
 133
 134    def add_object(self, object):
 135       self.linear.append(object)
 136
 137    def start_folder(self, f, level):
 138       self.add_object(f)
 139
 140    def bookmark(self, b, level):
 141       self.add_object(b)
 142
 143    def ruler(self, r, level):
 144       self.add_object(r)
 145
 146
 147 # Helper - make linked linear represenatation of the tree, suitable to be stored in sequential storage
 148 def make_linear(root_folder):
 149    linker = InverseLinker()
 150    root_folder.walk_depth(linker)
 151
 152    linear = Linear()
 153    root_folder.walk_depth(linear)
 154
 155
 156 # Helper, opposite of make_linear - make a tree from the linked linear representation
 157 def make_tree(linear):
 158    root_folder = linear[0]
 159    del linear[0]
 160
 161    for object in linear:
 162       object.parent.append(object)
 163
 164    return root_folder
 165
 166 def break_tree(linear):
 167    del linear[0]
 168
 169    for object in linear:
 170       del object.parent
 171
 172
 173 def quote_title(title):
 174    if BKMK_FORMAT == "MOZILLA":
 175       title = title.replace("'", "&#39;")
 176    return title
 177
 178 def unquote_title(title):
 179    if BKMK_FORMAT == "MOZILLA":
 180       from HTMLParser import HTMLParser
 181       title = HTMLParser().unescape(title.replace("&amp;", '&'))
 182    return title