The Tor Browser: testing/mozbase/setup_development.py@6474c204b198 (annotated)

testing/mozbase/setup_development.py@6474c204b198 (annotated)

testing/mozbase/setup_development.py

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rwxr-xr-x

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 #!/usr/bin/env 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/.
 """
 Setup mozbase packages for development.
 Packages may be specified as command line arguments.
 If no arguments are given, install all packages.
 See https://wiki.mozilla.org/Auto-tools/Projects/Mozbase
 """
 import os
 import subprocess
 import sys
 from optparse import OptionParser
 from subprocess import PIPE
 try:
     from subprocess import check_call as call
 except ImportError:
     from subprocess import call
 # directory containing this file
 here = os.path.dirname(os.path.abspath(__file__))
 # all python packages
 mozbase_packages = [i for i in os.listdir(here)
                     if os.path.exists(os.path.join(here, i, 'setup.py'))]
 test_packages = [ "mock" # testing: https://wiki.mozilla.org/Auto-tools/Projects/Mozbase#Tests
                   ]
 extra_packages = [ "sphinx" # documentation: https://wiki.mozilla.org/Auto-tools/Projects/Mozbase#Documentation
                   ]
 def cycle_check(order, dependencies):
     """ensure no cyclic dependencies"""
     order_dict = dict([(j, i) for i, j in enumerate(order)])
     for package, deps in dependencies.items():
         index = order_dict[package]
         for d in deps:
             assert index > order_dict[d], "Cyclic dependencies detected"
 def info(directory):
     "get the package setup.py information"
     assert os.path.exists(os.path.join(directory, 'setup.py'))
     # setup the egg info
     try:
         call([sys.executable, 'setup.py', 'egg_info'], cwd=directory, stdout=PIPE)
     except subprocess.CalledProcessError:
         print "Error running setup.py in %s" % directory
         raise
     # get the .egg-info directory
     egg_info = [entry for entry in os.listdir(directory)
                 if entry.endswith('.egg-info')]
     assert len(egg_info) == 1, 'Expected one .egg-info directory in %s, got: %s' % (directory, egg_info)
     egg_info = os.path.join(directory, egg_info[0])
     assert os.path.isdir(egg_info), "%s is not a directory" % egg_info
     # read the package information
     pkg_info = os.path.join(egg_info, 'PKG-INFO')
     info_dict = {}
     for line in file(pkg_info).readlines():
         if not line or line[0].isspace():
             continue # XXX neglects description
         assert ':' in line
         key, value = [i.strip() for i in line.split(':', 1)]
         info_dict[key] = value
     return info_dict
 def get_dependencies(directory):
     "returns the package name and dependencies given a package directory"
     # get the package metadata
     info_dict = info(directory)
     # get the .egg-info directory
     egg_info = [entry for entry in os.listdir(directory)
                 if entry.endswith('.egg-info')][0]
     # read the dependencies
     requires = os.path.join(directory, egg_info, 'requires.txt')
     if os.path.exists(requires):
         dependencies = [line.strip()
                         for line in file(requires).readlines()
                         if line.strip()]
     else:
         dependencies = []
     # return the information
     return info_dict['Name'], dependencies
 def dependency_info(dep):
     "return dictionary of dependency information from a dependency string"
     retval = dict(Name=None, Type=None, Version=None)
     for joiner in ('==', '<=', '>='):
         if joiner in dep:
             retval['Type'] = joiner
             name, version = [i.strip() for i in dep.split(joiner, 1)]
             retval['Name'] = name
             retval['Version'] = version
             break
     else:
         retval['Name'] = dep.strip()
     return retval
 def unroll_dependencies(dependencies):
     """
     unroll a set of dependencies to a flat list
     dependencies = {'packageA': set(['packageB', 'packageC', 'packageF']),
                     'packageB': set(['packageC', 'packageD', 'packageE', 'packageG']),
                     'packageC': set(['packageE']),
                     'packageE': set(['packageF', 'packageG']),
                     'packageF': set(['packageG']),
                     'packageX': set(['packageA', 'packageG'])}
     """
     order = []
     # flatten all
     packages = set(dependencies.keys())
     for deps in dependencies.values():
         packages.update(deps)
     while len(order) != len(packages):
         for package in packages.difference(order):
             if set(dependencies.get(package, set())).issubset(order):
                 order.append(package)
                 break
         else:
             raise AssertionError("Cyclic dependencies detected")
     cycle_check(order, dependencies) # sanity check
     return order
 def main(args=sys.argv[1:]):
     # parse command line options
     usage = '%prog [options] [package] [package] [...]'
     parser = OptionParser(usage=usage, description=__doc__)
     parser.add_option('-d', '--dependencies', dest='list_dependencies',
                       action='store_true', default=False,
                       help="list dependencies for the packages")
     parser.add_option('--list', action='store_true', default=False,
                       help="list what will be installed")
     parser.add_option('--extra', '--install-extra-packages', action='store_true', default=False,
                       help="installs extra supporting packages as well as core mozbase ones")
     options, packages = parser.parse_args(args)
     if not packages:
         # install all packages
         packages = sorted(mozbase_packages)
     # ensure specified packages are in the list
     assert set(packages).issubset(mozbase_packages), "Packages should be in %s (You gave: %s)" % (mozbase_packages, packages)
     if options.list_dependencies:
         # list the package dependencies
         for package in packages:
             print '%s: %s' % get_dependencies(os.path.join(here, package))
         parser.exit()
     # gather dependencies
     # TODO: version conflict checking
     deps = {}
     alldeps = {}
     mapping = {} # mapping from subdir name to package name
     # core dependencies
     for package in packages:
         key, value = get_dependencies(os.path.join(here, package))
         deps[key] = [dependency_info(dep)['Name'] for dep in value]
         mapping[package] = key
         # keep track of all dependencies for non-mozbase packages
         for dep in value:
             alldeps[dependency_info(dep)['Name']] = ''.join(dep.split())
     # indirect dependencies
     flag = True
     while flag:
         flag = False
         for value in deps.values():
             for dep in value:
                 if dep in mozbase_packages and dep not in deps:
                     key, value = get_dependencies(os.path.join(here, dep))
                     deps[key] = [sanitize_dependency(dep) for dep in value]
                     for dep in value:
                         alldeps[sanitize_dependency(dep)] = ''.join(dep.split())
                     mapping[package] = key
                     flag = True
                     break
             if flag:
                 break
     # get the remaining names for the mapping
     for package in mozbase_packages:
         if package in mapping:
             continue
         key, value = get_dependencies(os.path.join(here, package))
         mapping[package] = key
     # unroll dependencies
     unrolled = unroll_dependencies(deps)
     # make a reverse mapping: package name -> subdirectory
     reverse_mapping = dict([(j,i) for i, j in mapping.items()])
     # we only care about dependencies in mozbase
     unrolled = [package for package in unrolled if package in reverse_mapping]
     if options.list:
         # list what will be installed
         for package in unrolled:
             print package
         parser.exit()
     # set up the packages for development
     for package in unrolled:
         call([sys.executable, 'setup.py', 'develop', '--no-deps'],
              cwd=os.path.join(here, reverse_mapping[package]))
     # add the directory of sys.executable to path to aid the correct
     # `easy_install` getting called
     # https://bugzilla.mozilla.org/show_bug.cgi?id=893878
     os.environ['PATH'] = '%s%s%s' % (os.path.dirname(os.path.abspath(sys.executable)),
                                      os.path.pathsep,
                                      os.environ.get('PATH', '').strip(os.path.pathsep))
     # install non-mozbase dependencies
     # these need to be installed separately and the --no-deps flag
     # subsequently used due to a bug in setuptools; see
     # https://bugzilla.mozilla.org/show_bug.cgi?id=759836
     pypi_deps = dict([(i, j) for i,j in alldeps.items()
                       if i not in unrolled])
     for package, version in pypi_deps.items():
         # easy_install should be available since we rely on setuptools
         call(['easy_install', version])
     # install packages required for unit testing
     for package in test_packages:
         call(['easy_install', package])
     # install extra non-mozbase packages if desired
     if options.extra:
         for package in extra_packages:
             call(['easy_install', package])
 if __name__ == '__main__':
     main()

The Tor Browser / annotate

testing/mozbase/setup_development.py@6474c204b198 (annotated)

testing/mozbase/setup_development.py