summaryrefslogtreecommitdiffstats
path: root/python/mozbuild/mozpack/chrome
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /python/mozbuild/mozpack/chrome
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'python/mozbuild/mozpack/chrome')
-rw-r--r--python/mozbuild/mozpack/chrome/__init__.py0
-rw-r--r--python/mozbuild/mozpack/chrome/flags.py278
-rw-r--r--python/mozbuild/mozpack/chrome/manifest.py400
3 files changed, 678 insertions, 0 deletions
diff --git a/python/mozbuild/mozpack/chrome/__init__.py b/python/mozbuild/mozpack/chrome/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/python/mozbuild/mozpack/chrome/__init__.py
diff --git a/python/mozbuild/mozpack/chrome/flags.py b/python/mozbuild/mozpack/chrome/flags.py
new file mode 100644
index 0000000000..6b096c862a
--- /dev/null
+++ b/python/mozbuild/mozpack/chrome/flags.py
@@ -0,0 +1,278 @@
+# 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
+from collections import OrderedDict
+
+import six
+from packaging.version import Version
+
+from mozpack.errors import errors
+
+
+class Flag(object):
+ """
+ Class for flags in manifest entries in the form:
+ "flag" (same as "flag=true")
+ "flag=yes|true|1"
+ "flag=no|false|0"
+ """
+
+ def __init__(self, name):
+ """
+ Initialize a Flag with the given name.
+ """
+ self.name = name
+ self.value = None
+
+ def add_definition(self, definition):
+ """
+ Add a flag value definition. Replaces any previously set value.
+ """
+ if definition == self.name:
+ self.value = True
+ return
+ assert definition.startswith(self.name)
+ if definition[len(self.name)] != "=":
+ return errors.fatal("Malformed flag: %s" % definition)
+ value = definition[len(self.name) + 1 :]
+ if value in ("yes", "true", "1", "no", "false", "0"):
+ self.value = value
+ else:
+ return errors.fatal("Unknown value in: %s" % definition)
+
+ def matches(self, value):
+ """
+ Return whether the flag value matches the given value. The values
+ are canonicalized for comparison.
+ """
+ if value in ("yes", "true", "1", True):
+ return self.value in ("yes", "true", "1", True)
+ if value in ("no", "false", "0", False):
+ return self.value in ("no", "false", "0", False, None)
+ raise RuntimeError("Invalid value: %s" % value)
+
+ def __str__(self):
+ """
+ Serialize the flag value in the same form given to the last
+ add_definition() call.
+ """
+ if self.value is None:
+ return ""
+ if self.value is True:
+ return self.name
+ return "%s=%s" % (self.name, self.value)
+
+ def __eq__(self, other):
+ return str(self) == other
+
+
+class StringFlag(object):
+ """
+ Class for string flags in manifest entries in the form:
+ "flag=string"
+ "flag!=string"
+ """
+
+ def __init__(self, name):
+ """
+ Initialize a StringFlag with the given name.
+ """
+ self.name = name
+ self.values = []
+
+ def add_definition(self, definition):
+ """
+ Add a string flag definition.
+ """
+ assert definition.startswith(self.name)
+ value = definition[len(self.name) :]
+ if value.startswith("="):
+ self.values.append(("==", value[1:]))
+ elif value.startswith("!="):
+ self.values.append(("!=", value[2:]))
+ else:
+ return errors.fatal("Malformed flag: %s" % definition)
+
+ def matches(self, value):
+ """
+ Return whether one of the string flag definitions matches the given
+ value.
+ For example,
+
+ flag = StringFlag('foo')
+ flag.add_definition('foo!=bar')
+ flag.matches('bar') returns False
+ flag.matches('qux') returns True
+ flag = StringFlag('foo')
+ flag.add_definition('foo=bar')
+ flag.add_definition('foo=baz')
+ flag.matches('bar') returns True
+ flag.matches('baz') returns True
+ flag.matches('qux') returns False
+ """
+ if not self.values:
+ return True
+ for comparison, val in self.values:
+ if eval("value %s val" % comparison):
+ return True
+ return False
+
+ def __str__(self):
+ """
+ Serialize the flag definitions in the same form given to each
+ add_definition() call.
+ """
+ res = []
+ for comparison, val in self.values:
+ if comparison == "==":
+ res.append("%s=%s" % (self.name, val))
+ else:
+ res.append("%s!=%s" % (self.name, val))
+ return " ".join(res)
+
+ def __eq__(self, other):
+ return str(self) == other
+
+
+class VersionFlag(object):
+ """
+ Class for version flags in manifest entries in the form:
+ "flag=version"
+ "flag<=version"
+ "flag<version"
+ "flag>=version"
+ "flag>version"
+ """
+
+ def __init__(self, name):
+ """
+ Initialize a VersionFlag with the given name.
+ """
+ self.name = name
+ self.values = []
+
+ def add_definition(self, definition):
+ """
+ Add a version flag definition.
+ """
+ assert definition.startswith(self.name)
+ value = definition[len(self.name) :]
+ if value.startswith("="):
+ self.values.append(("==", Version(value[1:])))
+ elif len(value) > 1 and value[0] in ["<", ">"]:
+ if value[1] == "=":
+ if len(value) < 3:
+ return errors.fatal("Malformed flag: %s" % definition)
+ self.values.append((value[0:2], Version(value[2:])))
+ else:
+ self.values.append((value[0], Version(value[1:])))
+ else:
+ return errors.fatal("Malformed flag: %s" % definition)
+
+ def matches(self, value):
+ """
+ Return whether one of the version flag definitions matches the given
+ value.
+ For example,
+
+ flag = VersionFlag('foo')
+ flag.add_definition('foo>=1.0')
+ flag.matches('1.0') returns True
+ flag.matches('1.1') returns True
+ flag.matches('0.9') returns False
+ flag = VersionFlag('foo')
+ flag.add_definition('foo>=1.0')
+ flag.add_definition('foo<0.5')
+ flag.matches('0.4') returns True
+ flag.matches('1.0') returns True
+ flag.matches('0.6') returns False
+ """
+ value = Version(value)
+ if not self.values:
+ return True
+ for comparison, val in self.values:
+ if eval("value %s val" % comparison):
+ return True
+ return False
+
+ def __str__(self):
+ """
+ Serialize the flag definitions in the same form given to each
+ add_definition() call.
+ """
+ res = []
+ for comparison, val in self.values:
+ if comparison == "==":
+ res.append("%s=%s" % (self.name, val))
+ else:
+ res.append("%s%s%s" % (self.name, comparison, val))
+ return " ".join(res)
+
+ def __eq__(self, other):
+ return str(self) == other
+
+
+class Flags(OrderedDict):
+ """
+ Class to handle a set of flags definitions given on a single manifest
+ entry.
+
+ """
+
+ FLAGS = {
+ "application": StringFlag,
+ "appversion": VersionFlag,
+ "platformversion": VersionFlag,
+ "contentaccessible": Flag,
+ "os": StringFlag,
+ "osversion": VersionFlag,
+ "abi": StringFlag,
+ "platform": Flag,
+ "xpcnativewrappers": Flag,
+ "tablet": Flag,
+ "process": StringFlag,
+ "backgroundtask": StringFlag,
+ }
+ RE = re.compile(r"([!<>=]+)")
+
+ def __init__(self, *flags):
+ """
+ Initialize a set of flags given in string form.
+ flags = Flags('contentaccessible=yes', 'appversion>=3.5')
+ """
+ OrderedDict.__init__(self)
+ for f in flags:
+ name = self.RE.split(f)
+ name = name[0]
+ if name not in self.FLAGS:
+ errors.fatal("Unknown flag: %s" % name)
+ continue
+ if name not in self:
+ self[name] = self.FLAGS[name](name)
+ self[name].add_definition(f)
+
+ def __str__(self):
+ """
+ Serialize the set of flags.
+ """
+ return " ".join(str(self[k]) for k in self)
+
+ def match(self, **filter):
+ """
+ Return whether the set of flags match the set of given filters.
+ flags = Flags('contentaccessible=yes', 'appversion>=3.5',
+ 'application=foo')
+
+ flags.match(application='foo') returns True
+ flags.match(application='foo', appversion='3.5') returns True
+ flags.match(application='foo', appversion='3.0') returns False
+
+ """
+ for name, value in six.iteritems(filter):
+ if name not in self:
+ continue
+ if not self[name].matches(value):
+ return False
+ return True
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"
+ )