Source code
Revision control
Copy as Markdown
Other Tools
# 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
from six.moves.urllib.parse import urlparse
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
"""
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",
]