The Tor Browser: python/mozbuild/mozpack/packager/formats.py@7e26c7da4463 (annotated)

python/mozbuild/mozpack/packager/formats.py@7e26c7da4463 (annotated)

python/mozbuild/mozpack/packager/formats.py

Wed, 31 Dec 2014 06:55:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:55:50 +0100
changeset 2: 7e26c7da4463
permissions: -rw-r--r--

Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2

 # 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/.
 from mozpack.chrome.manifest import (
     Manifest,
     ManifestInterfaces,
     ManifestChrome,
     ManifestBinaryComponent,
     ManifestResource,
 )
 from urlparse import urlparse
 import mozpack.path
 from mozpack.files import (
     ManifestFile,
     XPTFile,
 )
 from mozpack.copier import (
     FileRegistry,
     Jarrer,
 )
 STARTUP_CACHE_PATHS = [
     'jsloader',
     'jssubloader',
 ]
 '''
 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)
         Register a base directory for an application or GRE. Base directories
         usually contain a root manifest (manifests not included in any other
         manifest) named chrome.manifest.
     - add(path, content)
         Add the given content (BaseFile instance) at the given virtual path
     - add_interfaces(path, content)
         Add the given content (BaseFile instance) and link it to other
         interfaces in the parent directory of the given virtual path.
     - 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 FlatFormatter(object):
     '''
     Formatter for the flat package format.
     '''
     def __init__(self, copier):
         assert isinstance(copier, FileRegistry)
         self.copier = copier
         self._bases = ['']
         self._frozen_bases = False
     def add_base(self, base):
         # Only allow to add a base directory before calls to _get_base()
         assert not self._frozen_bases
         if not base in self._bases:
             self._bases.append(base)
     def _get_base(self, path):
         '''
         Return the deepest base directory containing the given path.
         '''
         self._frozen_bases = True
         return mozpack.path.basedir(path, self._bases)
     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.
         base = self._get_base(entry.base)
         if entry.base == base:
             name = 'chrome'
         else:
             name = mozpack.path.basename(entry.base)
         path = mozpack.path.normpath(mozpack.path.join(entry.base,
                                                        '%s.manifest' % name))
         if not self.copier.contains(path):
             assert mozpack.path.basedir(entry.base, [base]) == base
             # Add a reference to the manifest file in the parent manifest, if
             # the manifest file is not a root manifest.
             if len(entry.base) > len(base):
                 parent = mozpack.path.dirname(entry.base)
                 relbase = mozpack.path.basename(entry.base)
                 relpath = mozpack.path.join(relbase,
                                             mozpack.path.basename(path))
                 FlatFormatter.add_manifest(self, Manifest(parent, relpath))
             self.copier.add(path, ManifestFile(entry.base))
         self.copier[path].add(entry)
     def add_interfaces(self, path, content):
         # Interfaces in the same directory are all linked together in an
         # interfaces.xpt file.
         interfaces_path = mozpack.path.join(mozpack.path.dirname(path),
                                             'interfaces.xpt')
         if not self.copier.contains(interfaces_path):
             FlatFormatter.add_manifest(self, ManifestInterfaces(
                 mozpack.path.dirname(path), 'interfaces.xpt'))
             self.copier.add(interfaces_path, XPTFile())
         self.copier[interfaces_path].add(content)
     def contains(self, path):
         assert '*' not in path
         return self.copier.contains(path)
 class JarFormatter(FlatFormatter):
     '''
     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, optimize=True):
         FlatFormatter.__init__(self, copier)
         self._chrome = set()
         self._frozen_chrome = False
         self._compress = compress
         self._optimize = optimize
     def _chromepath(self, path):
         '''
         Return the chrome base directory under which the given path is. Used to
         detect under which .jar (if any) the path should go.
         '''
         self._frozen_chrome = True
         return mozpack.path.basedir(path, self._chrome)
     def add(self, path, content):
         chrome = self._chromepath(path)
         if chrome:
             jar = chrome + '.jar'
             if not self.copier.contains(jar):
                 self.copier.add(jar, Jarrer(self._compress, self._optimize))
             if not self.copier[jar].contains(mozpack.path.relpath(path,
                                                                   chrome)):
                 self.copier[jar].add(mozpack.path.relpath(path, chrome),
                                      content)
         else:
             FlatFormatter.add(self, path, content)
     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 = mozpack.path.split(relpath)[0]
         chromepath = mozpack.path.join(base, basepath)
         entry = entry.rebase(chromepath) \
             .move(mozpack.path.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
             self._chrome.add(chromepath)
         elif isinstance(entry, ManifestResource) and \
                 not urlparse(entry.target).scheme:
             chromepath, new_entry = self._jarize(entry, entry.target)
             if chromepath in self._chrome:
                 entry = new_entry
         FlatFormatter.add_manifest(self, entry)
     def contains(self, path):
         assert '*' not in path
         chrome = self._chromepath(path)
         if not chrome:
             return self.copier.contains(path)
         if not self.copier.contains(chrome + '.jar'):
             return False
         return self.copier[chrome + '.jar']. \
             contains(mozpack.path.relpath(path, chrome))
 class OmniJarFormatter(FlatFormatter):
     '''
     Formatter for the omnijar package format.
     '''
     def __init__(self, copier, omnijar_name, compress=True, optimize=True,
                  non_resources=[]):
         FlatFormatter.__init__(self, copier)
         self.omnijars = {}
         self._omnijar_name = omnijar_name
         self._compress = compress
         self._optimize = optimize
         self._non_resources = non_resources
     def _get_omnijar(self, path, create=True):
         '''
         Return the omnijar corresponding to the given path, its base directory
         and the path translated to be under the omnijar..
         '''
         base = self._get_base(path)
         if not base in self.omnijars:
             if not create:
                 return None, '', path
             omnijar = Jarrer(self._compress, self._optimize)
             self.omnijars[base] = FlatFormatter(omnijar)
             self.copier.add(mozpack.path.join(base, self._omnijar_name),
                             omnijar)
         return self.omnijars[base], base, mozpack.path.relpath(path, base)
     def add(self, path, content):
         if self.is_resource(path):
             formatter, base, path = self._get_omnijar(path)
         else:
             formatter = self
         FlatFormatter.add(formatter, path, content)
     def add_manifest(self, entry):
         if isinstance(entry, ManifestBinaryComponent):
             formatter, base = self, ''
         else:
             formatter, base, path = self._get_omnijar(entry.base)
         entry = entry.move(mozpack.path.relpath(entry.base, base))
         FlatFormatter.add_manifest(formatter, entry)
     def add_interfaces(self, path, content):
         formatter, base, path = self._get_omnijar(path)
         FlatFormatter.add_interfaces(formatter, path, content)
     def contains(self, path):
         assert '*' not in path
         if self.copier.contains(path):
             return True
         for base, copier in self.omnijars.iteritems():
             if copier.contains(mozpack.path.relpath(path, base)):
                 return True
         return False
     def is_resource(self, path):
         '''
         Return whether the given path corresponds to a resource to be put in an
         omnijar archive.
         '''
         base = self._get_base(path)
         path = mozpack.path.relpath(path, base)
         if any(mozpack.path.match(path, p.replace('*', '**'))
                for p in self._non_resources):
             return False
         path = mozpack.path.split(path)
         if path[0] == 'chrome':
             return len(path) == 1 or path[1] != 'icons'
         if path[0] == 'components':
             return path[-1].endswith('.js')
         if path[0] == 'res':
             return len(path) == 1 or \
                 (path[1] != 'cursors' 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'])
         return path[0] in [
             'modules',
             'greprefs.js',
             'hyphenation',
             'update.locale',
         ] or path[0] in STARTUP_CACHE_PATHS

The Tor Browser / annotate

python/mozbuild/mozpack/packager/formats.py@7e26c7da4463 (annotated)

python/mozbuild/mozpack/packager/formats.py