summaryrefslogtreecommitdiffstats
path: root/python/mozbuild/mozpack/chrome/manifest.py
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--python/mozbuild/mozpack/chrome/manifest.py400
1 files changed, 400 insertions, 0 deletions
diff --git a/python/mozbuild/mozpack/chrome/manifest.py b/python/mozbuild/mozpack/chrome/manifest.py
new file mode 100644
index 0000000000..14c11d4c1d
--- /dev/null
+++ b/python/mozbuild/mozpack/chrome/manifest.py
@@ -0,0 +1,400 @@
+# 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 os
+import re
+
+import six
+from six.moves.urllib.parse import urlparse
+
+import mozpack.path as mozpath
+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",
+ "process",
+ "contentaccessible",
+ "backgroundtask",
+ ]
+
+ 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 f not 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 = mozpath.rebase(self.base, base, self.relpath)
+ return clone
+
+ @property
+ def path(self):
+ return mozpath.normpath(mozpath.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 mozpath.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)
+
+
+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/viewSource.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 = mozpath.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"^#.*$")
+
+
+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 = mozpath.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:
+ line = six.ensure_text(line)
+ 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")
+ and os.path.basename(path) != "cose.manifest"
+ )