The Tor Browser: comparison testing/mozbase/setup

--1:000000000000
+:ba71e254fc82
+#!/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 / file comparison

comparison: testing/mozbase/setup_development.py

testing/mozbase/setup_development.py