forked from mirrors/gecko-dev
c1b52fd95e
Backed out changeset e8fcfc7f8108 (bug 1811850) Backed out changeset f8950d716c9e (bug 1811850) Backed out changeset f650123cc188 (bug 1811850) Backed out changeset d96f90c2c58b (bug 1811850) Backed out changeset c3b0f9666183 (bug 1811850)
353 lines
13 KiB
Python
353 lines
13 KiB
Python
# 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 mozpack.path as mozpath
|
|
from mozpack.chrome.manifest import (
|
|
Manifest,
|
|
ManifestBinaryComponent,
|
|
ManifestChrome,
|
|
ManifestInterfaces,
|
|
ManifestMultiContent,
|
|
ManifestResource,
|
|
)
|
|
from mozpack.copier import FileRegistry, FileRegistrySubtree, Jarrer
|
|
from mozpack.errors import errors
|
|
from mozpack.files import ManifestFile
|
|
from six.moves.urllib.parse import urlparse
|
|
|
|
"""
|
|
Formatters are classes receiving packaging instructions and creating the
|
|
appropriate package layout.
|
|
|
|
There are three distinct formatters, each handling one of the different chrome
|
|
formats:
|
|
- flat: essentially, copies files from the source with the same file system
|
|
layout. Manifests entries are grouped in a single manifest per directory,
|
|
as well as XPT interfaces.
|
|
- jar: chrome content is packaged in jar files.
|
|
- omni: chrome content, modules, non-binary components, and many other
|
|
elements are packaged in an omnijar file for each base directory.
|
|
|
|
The base interface provides the following methods:
|
|
- add_base(path [, addon])
|
|
Register a base directory for an application or GRE, or an addon.
|
|
Base directories usually contain a root manifest (manifests not
|
|
included in any other manifest) named chrome.manifest.
|
|
The optional addon argument tells whether the base directory
|
|
is that of a packed addon (True), unpacked addon ('unpacked') or
|
|
otherwise (False).
|
|
The method may only be called in sorted order of `path` (alphanumeric
|
|
order, parents before children).
|
|
- add(path, content)
|
|
Add the given content (BaseFile instance) at the given virtual path
|
|
- add_interfaces(path, content)
|
|
Add the given content (BaseFile instance) as an interface. Equivalent
|
|
to add(path, content) with the right add_manifest().
|
|
- add_manifest(entry)
|
|
Add a ManifestEntry.
|
|
- contains(path)
|
|
Returns whether the given virtual path is known of the formatter.
|
|
|
|
The virtual paths mentioned above are paths as they would be with a flat
|
|
chrome.
|
|
|
|
Formatters all take a FileCopier instance they will fill with the packaged
|
|
data.
|
|
"""
|
|
|
|
|
|
class PiecemealFormatter(object):
|
|
"""
|
|
Generic formatter that dispatches across different sub-formatters
|
|
according to paths.
|
|
"""
|
|
|
|
def __init__(self, copier):
|
|
assert isinstance(copier, (FileRegistry, FileRegistrySubtree))
|
|
self.copier = copier
|
|
self._sub_formatter = {}
|
|
self._frozen_bases = False
|
|
|
|
def add_base(self, base, addon=False):
|
|
# Only allow to add a base directory before calls to _get_base()
|
|
assert not self._frozen_bases
|
|
assert base not in self._sub_formatter
|
|
assert all(base > b for b in self._sub_formatter)
|
|
self._add_base(base, addon)
|
|
|
|
def _get_base(self, path):
|
|
"""
|
|
Return the deepest base directory containing the given path.
|
|
"""
|
|
self._frozen_bases = True
|
|
base = mozpath.basedir(path, self._sub_formatter.keys())
|
|
relpath = mozpath.relpath(path, base) if base else path
|
|
return base, relpath
|
|
|
|
def add(self, path, content):
|
|
base, relpath = self._get_base(path)
|
|
if base is None:
|
|
return self.copier.add(relpath, content)
|
|
return self._sub_formatter[base].add(relpath, content)
|
|
|
|
def add_manifest(self, entry):
|
|
base, relpath = self._get_base(entry.base)
|
|
assert base is not None
|
|
return self._sub_formatter[base].add_manifest(entry.move(relpath))
|
|
|
|
def add_interfaces(self, path, content):
|
|
base, relpath = self._get_base(path)
|
|
assert base is not None
|
|
return self._sub_formatter[base].add_interfaces(relpath, content)
|
|
|
|
def contains(self, path):
|
|
assert "*" not in path
|
|
base, relpath = self._get_base(path)
|
|
if base is None:
|
|
return self.copier.contains(relpath)
|
|
return self._sub_formatter[base].contains(relpath)
|
|
|
|
|
|
class FlatFormatter(PiecemealFormatter):
|
|
"""
|
|
Formatter for the flat package format.
|
|
"""
|
|
|
|
def _add_base(self, base, addon=False):
|
|
self._sub_formatter[base] = FlatSubFormatter(
|
|
FileRegistrySubtree(base, self.copier)
|
|
)
|
|
|
|
|
|
class FlatSubFormatter(object):
|
|
"""
|
|
Sub-formatter for the flat package format.
|
|
"""
|
|
|
|
def __init__(self, copier):
|
|
assert isinstance(copier, (FileRegistry, FileRegistrySubtree))
|
|
self.copier = copier
|
|
self._chrome_db = {}
|
|
|
|
def add(self, path, content):
|
|
self.copier.add(path, content)
|
|
|
|
def add_manifest(self, entry):
|
|
# Store manifest entries in a single manifest per directory, named
|
|
# after their parent directory, except for root manifests, all named
|
|
# chrome.manifest.
|
|
if entry.base:
|
|
name = mozpath.basename(entry.base)
|
|
else:
|
|
name = "chrome"
|
|
path = mozpath.normpath(mozpath.join(entry.base, "%s.manifest" % name))
|
|
if not self.copier.contains(path):
|
|
# Add a reference to the manifest file in the parent manifest, if
|
|
# the manifest file is not a root manifest.
|
|
if entry.base:
|
|
parent = mozpath.dirname(entry.base)
|
|
relbase = mozpath.basename(entry.base)
|
|
relpath = mozpath.join(relbase, mozpath.basename(path))
|
|
self.add_manifest(Manifest(parent, relpath))
|
|
self.copier.add(path, ManifestFile(entry.base))
|
|
|
|
if isinstance(entry, ManifestChrome):
|
|
data = self._chrome_db.setdefault(entry.name, {})
|
|
if isinstance(entry, ManifestMultiContent):
|
|
entries = data.setdefault(entry.type, {}).setdefault(entry.id, [])
|
|
else:
|
|
entries = data.setdefault(entry.type, [])
|
|
for e in entries:
|
|
# Ideally, we'd actually check whether entry.flags are more
|
|
# specific than e.flags, but in practice the following test
|
|
# is enough for now.
|
|
if entry == e:
|
|
errors.warn('"%s" is duplicated. Skipping.' % entry)
|
|
return
|
|
if not entry.flags or e.flags and entry.flags == e.flags:
|
|
errors.fatal('"%s" overrides "%s"' % (entry, e))
|
|
entries.append(entry)
|
|
|
|
self.copier[path].add(entry)
|
|
|
|
def add_interfaces(self, path, content):
|
|
self.copier.add(path, content)
|
|
self.add_manifest(
|
|
ManifestInterfaces(mozpath.dirname(path), mozpath.basename(path))
|
|
)
|
|
|
|
def contains(self, path):
|
|
assert "*" not in path
|
|
return self.copier.contains(path)
|
|
|
|
|
|
class JarFormatter(PiecemealFormatter):
|
|
"""
|
|
Formatter for the jar package format. Assumes manifest entries related to
|
|
chrome are registered before the chrome data files are added. Also assumes
|
|
manifest entries for resources are registered after chrome manifest
|
|
entries.
|
|
"""
|
|
|
|
def __init__(self, copier, compress=True):
|
|
PiecemealFormatter.__init__(self, copier)
|
|
self._compress = compress
|
|
|
|
def _add_base(self, base, addon=False):
|
|
if addon is True:
|
|
jarrer = Jarrer(self._compress)
|
|
self.copier.add(base + ".xpi", jarrer)
|
|
self._sub_formatter[base] = FlatSubFormatter(jarrer)
|
|
else:
|
|
self._sub_formatter[base] = JarSubFormatter(
|
|
FileRegistrySubtree(base, self.copier), self._compress
|
|
)
|
|
|
|
|
|
class JarSubFormatter(PiecemealFormatter):
|
|
"""
|
|
Sub-formatter for the jar package format. It is a PiecemealFormatter that
|
|
dispatches between further sub-formatter for each of the jar files it
|
|
dispatches the chrome data to, and a FlatSubFormatter for the non-chrome
|
|
files.
|
|
"""
|
|
|
|
def __init__(self, copier, compress=True):
|
|
PiecemealFormatter.__init__(self, copier)
|
|
self._frozen_chrome = False
|
|
self._compress = compress
|
|
self._sub_formatter[""] = FlatSubFormatter(copier)
|
|
|
|
def _jarize(self, entry, relpath):
|
|
"""
|
|
Transform a manifest entry in one pointing to chrome data in a jar.
|
|
Return the corresponding chrome path and the new entry.
|
|
"""
|
|
base = entry.base
|
|
basepath = mozpath.split(relpath)[0]
|
|
chromepath = mozpath.join(base, basepath)
|
|
entry = (
|
|
entry.rebase(chromepath)
|
|
.move(mozpath.join(base, "jar:%s.jar!" % basepath))
|
|
.rebase(base)
|
|
)
|
|
return chromepath, entry
|
|
|
|
def add_manifest(self, entry):
|
|
if isinstance(entry, ManifestChrome) and not urlparse(entry.relpath).scheme:
|
|
chromepath, entry = self._jarize(entry, entry.relpath)
|
|
assert not self._frozen_chrome
|
|
if chromepath not in self._sub_formatter:
|
|
jarrer = Jarrer(self._compress)
|
|
self.copier.add(chromepath + ".jar", jarrer)
|
|
self._sub_formatter[chromepath] = FlatSubFormatter(jarrer)
|
|
elif isinstance(entry, ManifestResource) and not urlparse(entry.target).scheme:
|
|
chromepath, new_entry = self._jarize(entry, entry.target)
|
|
if chromepath in self._sub_formatter:
|
|
entry = new_entry
|
|
PiecemealFormatter.add_manifest(self, entry)
|
|
|
|
|
|
class OmniJarFormatter(JarFormatter):
|
|
"""
|
|
Formatter for the omnijar package format.
|
|
"""
|
|
|
|
def __init__(self, copier, omnijar_name, compress=True, non_resources=()):
|
|
JarFormatter.__init__(self, copier, compress)
|
|
self._omnijar_name = omnijar_name
|
|
self._non_resources = non_resources
|
|
|
|
def _add_base(self, base, addon=False):
|
|
if addon:
|
|
# Because add_base is always called with parents before children,
|
|
# all the possible ancestry of `base` is already present in
|
|
# `_sub_formatter`.
|
|
parent_base = mozpath.basedir(base, self._sub_formatter.keys())
|
|
rel_base = mozpath.relpath(base, parent_base)
|
|
# If the addon is under a resource directory, package it in the
|
|
# omnijar.
|
|
parent_sub_formatter = self._sub_formatter[parent_base]
|
|
if parent_sub_formatter.is_resource(rel_base):
|
|
omnijar_sub_formatter = parent_sub_formatter._sub_formatter[
|
|
self._omnijar_name
|
|
]
|
|
self._sub_formatter[base] = FlatSubFormatter(
|
|
FileRegistrySubtree(rel_base, omnijar_sub_formatter.copier)
|
|
)
|
|
return
|
|
JarFormatter._add_base(self, base, addon)
|
|
else:
|
|
self._sub_formatter[base] = OmniJarSubFormatter(
|
|
FileRegistrySubtree(base, self.copier),
|
|
self._omnijar_name,
|
|
self._compress,
|
|
self._non_resources,
|
|
)
|
|
|
|
|
|
class OmniJarSubFormatter(PiecemealFormatter):
|
|
"""
|
|
Sub-formatter for the omnijar package format. It is a PiecemealFormatter
|
|
that dispatches between a FlatSubFormatter for the resources data and
|
|
another FlatSubFormatter for the other files.
|
|
"""
|
|
|
|
def __init__(self, copier, omnijar_name, compress=True, non_resources=()):
|
|
PiecemealFormatter.__init__(self, copier)
|
|
self._omnijar_name = omnijar_name
|
|
self._compress = compress
|
|
self._non_resources = non_resources
|
|
self._sub_formatter[""] = FlatSubFormatter(copier)
|
|
jarrer = Jarrer(self._compress)
|
|
self._sub_formatter[omnijar_name] = FlatSubFormatter(jarrer)
|
|
|
|
def _get_base(self, path):
|
|
base = self._omnijar_name if self.is_resource(path) else ""
|
|
# Only add the omnijar file if something ends up in it.
|
|
if base and not self.copier.contains(base):
|
|
self.copier.add(base, self._sub_formatter[base].copier)
|
|
return base, path
|
|
|
|
def add_manifest(self, entry):
|
|
base = ""
|
|
if not isinstance(entry, ManifestBinaryComponent):
|
|
base = self._omnijar_name
|
|
formatter = self._sub_formatter[base]
|
|
return formatter.add_manifest(entry)
|
|
|
|
def is_resource(self, path):
|
|
"""
|
|
Return whether the given path corresponds to a resource to be put in an
|
|
omnijar archive.
|
|
"""
|
|
if any(mozpath.match(path, p.replace("*", "**")) for p in self._non_resources):
|
|
return False
|
|
path = mozpath.split(path)
|
|
if path[0] == "chrome":
|
|
return len(path) == 1 or path[1] != "icons"
|
|
if path[0] == "components":
|
|
return path[-1].endswith((".js", ".xpt"))
|
|
if path[0] == "res":
|
|
return len(path) == 1 or (
|
|
path[1] != "cursors"
|
|
and path[1] != "touchbar"
|
|
and path[1] != "MainMenu.nib"
|
|
)
|
|
if path[0] == "defaults":
|
|
return len(path) != 3 or not (
|
|
path[2] == "channel-prefs.js" and path[1] in ["pref", "preferences"]
|
|
)
|
|
if len(path) <= 2 and path[-1] == "greprefs.js":
|
|
# Accommodate `greprefs.js` and `$ANDROID_CPU_ARCH/greprefs.js`.
|
|
return True
|
|
return path[0] in [
|
|
"modules",
|
|
"actors",
|
|
"dictionaries",
|
|
"hyphenation",
|
|
"localization",
|
|
"update.locale",
|
|
"contentaccessible",
|
|
]
|