The Tor Browser: python/mozbuild/mozpack/chrome/manifest.py@925c144e1f1f (annotated)

python/mozbuild/mozpack/chrome/manifest.py@925c144e1f1f (annotated)

python/mozbuild/mozpack/chrome/manifest.py

Fri, 16 Jan 2015 18:13:44 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 18:13:44 +0100
branch: TOR_BUG_9701
changeset 14: 925c144e1f1f
permissions: -rw-r--r--

Integrate suggestion from review to improve consistency with existing code.

 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 import re
 import os
 from urlparse import urlparse
 import mozpack.path
 from mozpack.chrome.flags import Flags
 from mozpack.errors import errors
 class ManifestEntry(object):
     '''
     Base class for all manifest entry types.
     Subclasses may define the following class or member variables:
         - localized: indicates whether the manifest entry is used for localized
           data.
         - type: the manifest entry type (e.g. 'content' in
           'content global content/global/')
         - allowed_flags: a set of flags allowed to be defined for the given
           manifest entry type.
     A manifest entry is attached to a base path, defining where the manifest
     entry is bound to, and that is used to find relative paths defined in
     entries.
     '''
     localized = False
     type = None
     allowed_flags = [
         'application',
         'platformversion',
         'os',
         'osversion',
         'abi',
         'xpcnativewrappers',
         'tablet',
     ]
     def __init__(self, base, *flags):
         '''
         Initialize a manifest entry with the given base path and flags.
         '''
         self.base = base
         self.flags = Flags(*flags)
         if not all(f in self.allowed_flags for f in self.flags):
             errors.fatal('%s unsupported for %s manifest entries' %
                          (','.join(f for f in self.flags
                           if not f in self.allowed_flags), self.type))
     def serialize(self, *args):
         '''
         Serialize the manifest entry.
         '''
         entry = [self.type] + list(args)
         flags = str(self.flags)
         if flags:
             entry.append(flags)
         return ' '.join(entry)
     def __eq__(self, other):
         return self.base == other.base and str(self) == str(other)
     def __ne__(self, other):
         return not self.__eq__(other)
     def __repr__(self):
         return '<%s@%s>' % (str(self), self.base)
     def move(self, base):
         '''
         Return a new manifest entry with a different base path.
         '''
         return parse_manifest_line(base, str(self))
     def rebase(self, base):
         '''
         Return a new manifest entry with all relative paths defined in the
         entry relative to a new base directory.
         The base class doesn't define relative paths, so it is equivalent to
         move().
         '''
         return self.move(base)
 class ManifestEntryWithRelPath(ManifestEntry):
     '''
     Abstract manifest entry type with a relative path definition.
     '''
     def __init__(self, base, relpath, *flags):
         ManifestEntry.__init__(self, base, *flags)
         self.relpath = relpath
     def __str__(self):
         return self.serialize(self.relpath)
     def rebase(self, base):
         '''
         Return a new manifest entry with all relative paths defined in the
         entry relative to a new base directory.
         '''
         clone = ManifestEntry.rebase(self, base)
         clone.relpath = mozpack.path.rebase(self.base, base, self.relpath)
         return clone
     @property
     def path(self):
         return mozpack.path.normpath(mozpack.path.join(self.base,
                                                        self.relpath))
 class Manifest(ManifestEntryWithRelPath):
     '''
     Class for 'manifest' entries.
         manifest some/path/to/another.manifest
     '''
     type = 'manifest'
 class ManifestChrome(ManifestEntryWithRelPath):
     '''
     Abstract class for chrome entries.
     '''
     def __init__(self, base, name, relpath, *flags):
         ManifestEntryWithRelPath.__init__(self, base, relpath, *flags)
         self.name = name
     @property
     def location(self):
         return mozpack.path.join(self.base, self.relpath)
 class ManifestContent(ManifestChrome):
     '''
     Class for 'content' entries.
         content global content/global/
     '''
     type = 'content'
     allowed_flags = ManifestChrome.allowed_flags + [
         'contentaccessible',
         'platform',
     ]
     def __str__(self):
         return self.serialize(self.name, self.relpath)
 class ManifestMultiContent(ManifestChrome):
     '''
     Abstract class for chrome entries with multiple definitions.
     Used for locale and skin entries.
     '''
     type = None
     def __init__(self, base, name, id, relpath, *flags):
         ManifestChrome.__init__(self, base, name, relpath, *flags)
         self.id = id
     def __str__(self):
         return self.serialize(self.name, self.id, self.relpath)
 class ManifestLocale(ManifestMultiContent):
     '''
     Class for 'locale' entries.
         locale global en-US content/en-US/
         locale global fr content/fr/
     '''
     localized = True
     type = 'locale'
 class ManifestSkin(ManifestMultiContent):
     '''
     Class for 'skin' entries.
         skin global classic/1.0 content/skin/classic/
     '''
     type = 'skin'
 class ManifestOverload(ManifestEntry):
     '''
     Abstract class for chrome entries defining some kind of overloading.
     Used for overlay, override or style entries.
     '''
     type = None
     def __init__(self, base, overloaded, overload, *flags):
         ManifestEntry.__init__(self, base, *flags)
         self.overloaded = overloaded
         self.overload = overload
     def __str__(self):
         return self.serialize(self.overloaded, self.overload)
     @property
     def localized(self):
         u = urlparse(self.overload)
         return u.scheme == 'chrome' and \
                u.path.split('/')[0:2] == ['', 'locale']
 class ManifestOverlay(ManifestOverload):
     '''
     Class for 'overlay' entries.
         overlay chrome://global/content/viewSource.xul \
             chrome://browser/content/viewSourceOverlay.xul
     '''
     type = 'overlay'
 class ManifestStyle(ManifestOverload):
     '''
     Class for 'style' entries.
         style chrome://global/content/customizeToolbar.xul \
             chrome://browser/skin/
     '''
     type = 'style'
 class ManifestOverride(ManifestOverload):
     '''
     Class for 'override' entries.
         override chrome://global/locale/netError.dtd \
             chrome://browser/locale/netError.dtd
     '''
     type = 'override'
 class ManifestResource(ManifestEntry):
     '''
     Class for 'resource' entries.
         resource gre-resources toolkit/res/
         resource services-sync resource://gre/modules/services-sync/
     The target may be a relative path or a resource or chrome url.
     '''
     type = 'resource'
     def __init__(self, base, name, target, *flags):
         ManifestEntry.__init__(self, base, *flags)
         self.name = name
         self.target = target
     def __str__(self):
         return self.serialize(self.name, self.target)
     def rebase(self, base):
         u = urlparse(self.target)
         if u.scheme and u.scheme != 'jar':
             return ManifestEntry.rebase(self, base)
         clone = ManifestEntry.rebase(self, base)
         clone.target = mozpack.path.rebase(self.base, base, self.target)
         return clone
 class ManifestBinaryComponent(ManifestEntryWithRelPath):
     '''
     Class for 'binary-component' entries.
         binary-component some/path/to/a/component.dll
     '''
     type = 'binary-component'
 class ManifestComponent(ManifestEntryWithRelPath):
     '''
     Class for 'component' entries.
         component {b2bba4df-057d-41ea-b6b1-94a10a8ede68} foo.js
     '''
     type = 'component'
     def __init__(self, base, cid, file, *flags):
         ManifestEntryWithRelPath.__init__(self, base, file, *flags)
         self.cid = cid
     def __str__(self):
         return self.serialize(self.cid, self.relpath)
 class ManifestInterfaces(ManifestEntryWithRelPath):
     '''
     Class for 'interfaces' entries.
         interfaces foo.xpt
     '''
     type = 'interfaces'
 class ManifestCategory(ManifestEntry):
     '''
     Class for 'category' entries.
         category command-line-handler m-browser @mozilla.org/browser/clh;
     '''
     type = 'category'
     def __init__(self, base, category, name, value, *flags):
         ManifestEntry.__init__(self, base, *flags)
         self.category = category
         self.name = name
         self.value = value
     def __str__(self):
         return self.serialize(self.category, self.name, self.value)
 class ManifestContract(ManifestEntry):
     '''
     Class for 'contract' entries.
         contract @mozilla.org/foo;1 {b2bba4df-057d-41ea-b6b1-94a10a8ede68}
     '''
     type = 'contract'
     def __init__(self, base, contractID, cid, *flags):
         ManifestEntry.__init__(self, base, *flags)
         self.contractID = contractID
         self.cid = cid
     def __str__(self):
         return self.serialize(self.contractID, self.cid)
 # All manifest classes by their type name.
 MANIFESTS_TYPES = dict([(c.type, c) for c in globals().values()
                        if type(c) == type and issubclass(c, ManifestEntry)
                        and hasattr(c, 'type') and c.type])
 MANIFEST_RE = re.compile(r'\s*#.*$')
 def parse_manifest_line(base, line):
     '''
     Parse a line from a manifest file with the given base directory and
     return the corresponding ManifestEntry instance.
     '''
     # Remove comments
     cmd = MANIFEST_RE.sub('', line).strip().split()
     if not cmd:
         return None
     if not cmd[0] in MANIFESTS_TYPES:
         return errors.fatal('Unknown manifest directive: %s' % cmd[0])
     return MANIFESTS_TYPES[cmd[0]](base, *cmd[1:])
 def parse_manifest(root, path, fileobj=None):
     '''
     Parse a manifest file.
     '''
     base = mozpack.path.dirname(path)
     if root:
         path = os.path.normpath(os.path.abspath(os.path.join(root, path)))
     if not fileobj:
         fileobj = open(path)
     linenum = 0
     for line in fileobj:
         linenum += 1
         with errors.context(path, linenum):
             e = parse_manifest_line(base, line)
             if e:
                 yield e
 def is_manifest(path):
     '''
     Return whether the given path is that of a manifest file.
     '''
     return path.endswith('.manifest') and not path.endswith('.CRT.manifest') \
         and not path.endswith('.exe.manifest')

The Tor Browser / annotate

python/mozbuild/mozpack/chrome/manifest.py@925c144e1f1f (annotated)

python/mozbuild/mozpack/chrome/manifest.py