bkmk_objects.py

   1 """Objects to represent bookmarks.html structure
   2
   3 This file is a part of Bookmarks database and Internet robot.
   4
   5 """
   6
   7 __author__ = "Oleg Broytman <phd@phdru.name>"
   8 __copyright__ = "Copyright (C) 2000-2023 PhiloSoft Design"
   9 __license__ = "GNU GPL"
  10
  11 __all__ = ['Folder', 'Bookmark', 'Ruler', 'Walker', 'Writer', 'Robot',
  12            'InverseLinker', 'Linear', 'make_linear', 'make_tree', 'break_tree',
  13            'quote_title', 'unquote_title', 'parse_params', 'set_params',
  14            ]
  15
  16
  17 import os
  18 import urllib
  19
  20 BKMK_FORMAT = os.environ.get("BKMK_FORMAT", "MOZILLA")
  21
  22
  23 class Folder(list):
  24     isFolder = 1
  25     isBookmark = 0
  26
  27     def __init__(self, add_date=None, comment='', last_modified=None):
  28         super(Folder, self).__init__()
  29         self.comment = comment
  30         self.add_date = add_date
  31         self.last_modified = last_modified
  32
  33     def walk_depth(self, walker, level=0):
  34         if hasattr(self, "header"):  # root folder
  35             prune = 0
  36             walker.root_folder(self)
  37         else:
  38             prune = walker.prune_folder(self)
  39             if not prune:
  40                 walker.start_folder(self, level)
  41
  42         if not prune:
  43             for object in self:
  44                 if object.isFolder:
  45                     object.walk_depth(walker, level+1)
  46                 elif object.isBookmark:
  47                     walker.bookmark(object, level)
  48                 else:
  49                     walker.ruler(object, level)
  50
  51             walker.end_folder(self, level)
  52
  53
  54 class Bookmark(object):
  55     isFolder = 0
  56     isBookmark = 1
  57
  58     def __init__(self, href, add_date, last_visit=None, last_modified=None,
  59                  keyword=None, comment='', icon_href=None, icon=None,
  60                  charset=None, parser_charset=None):
  61         protocol, request = urllib.splittype(href)
  62         user, password, port = None, None, None
  63         host, path = urllib.splithost(request)
  64         if host:
  65             user, host = urllib.splituser(host)
  66             if user:
  67                 user, password = urllib.splitpasswd(user)
  68             host, port = urllib.splitport(host)
  69             if port: port = int(port)
  70
  71         if protocol == 'place':
  72             href = protocol + ":"
  73         else:
  74             href = protocol + "://"
  75         if user:
  76             href += urllib.quote(user)
  77             if password:
  78                 href += ':' + urllib.quote(password)
  79             href += '@'
  80         if host:
  81             href += host.decode(parser_charset or 'utf-8').encode('idna')
  82             if port:
  83                 href += ':%d' % port
  84         if path:
  85             href += path
  86
  87         self.href = href
  88         self.add_date = add_date
  89         self.last_visit = last_visit
  90         self.last_modified = last_modified
  91         self.keyword = keyword
  92         self.comment = comment
  93         self.icon_href = icon_href
  94         self.icon = icon
  95         self.charset = charset
  96
  97
  98 class Ruler(object):
  99     isFolder = 0
 100     isBookmark = 0
 101
 102
 103 class Walker(object):
 104     """
 105        Interface class. Any instance that will be passed to Folder.walk_depth
 106        may be derived from this class. It is not mandatory - unlike Java
 107        Python does not require interface classes; but it is convenient to have
 108        some methods predefined to no-op, in case you do not want to
 109        provide end_folder etc.
 110     """
 111
 112     def root_folder(self, r):
 113         pass
 114
 115     def start_folder(self, f, level):
 116         pass
 117
 118     def end_folder(self, f, level):
 119         pass
 120
 121     def bookmark(self, b, level):
 122         pass
 123
 124     def ruler(self, r, level):
 125         pass
 126
 127     def prune_folder(self, folder):
 128         return 0
 129
 130
 131 class Writer(Walker):
 132     def __init__(self, outfile, prune=None):
 133         self.outfile = outfile
 134         self.prune = prune
 135
 136     def prune_folder(self, folder):
 137         return self.prune == folder.name
 138
 139
 140 class Robot(object):
 141     def __init__(self, log):
 142         self.log = log
 143
 144     def stop(self):
 145         pass  # Nothing to do on cleanup
 146
 147
 148 # Helper class to make inverese links (nodes linked to their parent)
 149 class InverseLinker(Walker):
 150     def root_folder(self, r):
 151         self.parent_stack = [r]
 152
 153     def start_folder(self, f, level):
 154         f.parent = self.parent_stack[-1]
 155         # Push the folder onto the stack of parents
 156         self.parent_stack.append(f)
 157
 158     def end_folder(self, f, level):
 159         del self.parent_stack[-1]   # Pop off the stack
 160
 161     def bookmark(self, b, level):
 162         b.parent = self.parent_stack[-1]
 163
 164     def ruler(self, r, level):
 165         r.parent = self.parent_stack[-1]
 166
 167
 168 # Helper class to make linear represenatation of the tree
 169 class Linear(Walker):
 170     def root_folder(self, r):
 171         r.linear = [r]
 172         self.linear = r.linear
 173
 174     def add_object(self, object):
 175         self.linear.append(object)
 176
 177     def start_folder(self, f, level):
 178         self.add_object(f)
 179
 180     def bookmark(self, b, level):
 181         self.add_object(b)
 182
 183     def ruler(self, r, level):
 184         self.add_object(r)
 185
 186
 187 # Helper - make linked linear represenatation of the tree,
 188 # suitable to be stored in sequential storage.
 189 def make_linear(root_folder):
 190     linker = InverseLinker()
 191     root_folder.walk_depth(linker)
 192
 193     linear = Linear()
 194     root_folder.walk_depth(linear)
 195
 196
 197 # Helper, opposite of make_linear -
 198 # make a tree from the linked linear representation.
 199 def make_tree(linear):
 200     root_folder = linear[0]
 201     del linear[0]
 202
 203     for object in linear:
 204         object.parent.append(object)
 205
 206     return root_folder
 207
 208
 209 def break_tree(linear):
 210     del linear[0]
 211
 212     for object in linear:
 213         del object.parent
 214
 215
 216 def quote_title(title):
 217     if BKMK_FORMAT == "MOZILLA":
 218         title = title.replace("'", "&#39;")
 219     return title
 220
 221
 222 def unquote_title(title):
 223     if BKMK_FORMAT == "MOZILLA":
 224         from HTMLParser import HTMLParser
 225         title = HTMLParser().unescape(
 226             title.replace("&amp;", '&').decode('utf-8'))
 227         title = title.encode('utf-8').replace("&#39;", "'")
 228     return title
 229
 230
 231 def parse_params(param_str):
 232     params = param_str.split(':')
 233     main_param = params.pop(0)
 234     param_list = {}
 235     for param in params:
 236         key, value = param.split('=', 1)
 237         param_list[key] = value
 238     return main_param, param_list
 239
 240
 241 def set_params(obj, params):
 242     if hasattr(params, "items"):
 243         params = params.items()
 244     for key, value in params:
 245         setattr(obj, key, value)