author Ryan VanderMeulen <>
Tue, 19 Feb 2013 05:43:46 -0500
changeset 132160 a0c57dffd179b3718e696579cc14dd10d408a591
parent 132158 0577eb1893c44ccce6f6085603f4b12021c01d5f
child 132249 16d994cc562c0094f68ed38b5bf25918240bf5c6
permissions -rw-r--r--
Backed out changeset 0577eb1893c4 (bug 840094) for orange++

# 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

import re
import os
from urlparse import urlparse
import mozpack.path
from 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
        - 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
    localized = False
    type = None
    allowed_flags = [

    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:
        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
        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

    def path(self):
        return mozpack.path.normpath(mozpack.path.join(self.base,

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) = name

    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 + [

    def __str__(self):
        return self.serialize(, 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) = id

    def __str__(self):
        return self.serialize(,, 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)

    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 \
    type = 'overlay'

class ManifestStyle(ManifestOverload):
    Class for 'style' entries.
        style chrome://global/content/customizeToolbar.xul \
    type = 'style'

class ManifestOverride(ManifestOverload):
    Class for 'override' entries.
        override chrome://global/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) = name = target

    def __str__(self):
        return self.serialize(,

    def rebase(self, base):
        u = urlparse(
        if u.scheme and u.scheme != 'jar':
            return ManifestEntry.rebase(self, base)
        clone = ManifestEntry.rebase(self, base) = mozpack.path.rebase(self.base, base,
        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;
    type = 'category'

    def __init__(self, base, category, name, value, *flags):
        ManifestEntry.__init__(self, base, *flags)
        self.category = category = name
        self.value = value

    def __str__(self):
        return self.serialize(self.category,, self.value)

class ManifestContract(ManifestEntry):
    Class for 'contract' entries.
        contract;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.readlines():
        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')