python/mozbuild/mozpack/chrome/manifest.py
author Ryan VanderMeulen <ryanvm@gmail.com>
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 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.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')