def test_gen(self):
build_request = self.request(['gen'], self.thrift)
root, = self.build(build_request)
# Root: expect the synthetic GenGoal product.
self.assert_root(root, self.thrift, GenGoal("non-empty input to satisfy the Goal constructor"))
variants = {'thrift': 'apache_java'}
# Expect ThriftSources to have been selected.
self.assert_select_for_subjects(walk, Select(ThriftSources), [self.thrift], variants=variants)
# Expect an ApacheThriftJavaConfiguration to have been used via the default Variants.
self.assert_select_for_subjects(walk, SelectVariant(ApacheThriftJavaConfiguration,
variant_key='thrift'),
[self.thrift],
variants=variants)
def setup_json_scheduler(build_root, native):
"""Return a build graph and scheduler configured for BLD.json files under the given build root.
:rtype :class:`pants.engine.scheduler.LocalScheduler`
"""
symbol_table_cls = ExampleTable
# Register "literal" subjects required for these tasks.
# TODO: Replace with `Subsystems`.
address_mapper = AddressMapper(symbol_table_cls=symbol_table_cls,
build_patterns=('BLD.json',),
parser_cls=JsonParser)
source_roots = SourceRoots(('src/java','src/scala'))
scrooge_tool_address = Address.parse('src/scala/scrooge')
goals = {
'compile': Classpath,
# TODO: to allow for running resolve alone, should split out a distinct 'IvyReport' product.
'resolve': Classpath,
'list': Address,
GenGoal.name(): GenGoal,
'ls': Files,
'cat': FilesContent,
}
tasks = [
# Codegen
GenGoal.signature(),
(JavaSources,
[Select(ThriftSources),
SelectVariant(ApacheThriftJavaConfiguration, 'thrift')],
gen_apache_thrift),
(PythonSources,
[Select(ThriftSources),
SelectVariant(ApacheThriftPythonConfiguration, 'thrift')],
gen_apache_thrift),
(ScalaSources,
[Select(ThriftSources),
SelectVariant(ScroogeScalaConfiguration, 'thrift'),
SelectLiteral(scrooge_tool_address, Classpath)],
gen_scrooge_thrift),
(JavaSources,
[Select(ThriftSources),
SelectVariant(ScroogeJavaConfiguration, 'thrift'),
SelectLiteral(scrooge_tool_address, Classpath)],
gen_scrooge_thrift),
] + [
# scala dependency inference
(ScalaSources,
[Select(ScalaInferredDepsSources),
SelectDependencies(Address, ImportedJVMPackages, field_types=(JVMPackageName,))],
reify_scala_sources),
(ImportedJVMPackages,
[SelectProjection(FilesContent, PathGlobs, ('path_globs',), ScalaInferredDepsSources)],
extract_scala_imports),
(Address,
[Select(JVMPackageName),
SelectDependencies(AddressFamily, Dirs, field='stats', field_types=(Dir,))],
select_package_address),
(PathGlobs,
[Select(JVMPackageName),
SelectLiteral(source_roots, SourceRoots)],
calculate_package_search_path),
] + [
# Remote dependency resolution
(Classpath,
[Select(Jar)],
ivy_resolve),
(Jar,
[Select(ManagedJar),
SelectVariant(ManagedResolve, 'resolve')],
select_rev),
] + [
# Compilers
(Classpath,
[Select(ResourceSources)],
isolate_resources),
(Classpath,
[Select(BuildPropertiesConfiguration)],
write_name_file),
# NB: Not sure these SelectDependencies should allow Jar, but they currently produce jars.
(Classpath,
[Select(JavaSources),
SelectDependencies(Classpath, JavaSources, field_types=(Address, Jar))],
javac),
(Classpath,
[Select(ScalaSources),
SelectDependencies(Classpath, ScalaSources, field_types=(Address, Jar))],
scalac),
] + (
create_graph_tasks(address_mapper, symbol_table_cls)
) + (
create_fs_tasks()
)
project_tree = FileSystemProjectTree(build_root)
return LocalScheduler(goals,
tasks,
project_tree,
native,
graph_lock=None)
def test_select_variant_requires_string_key(self):
with self.assertRaises(ValueError):
SelectVariant(AClass, None)
def test_variant_repr(self):
self.assert_repr("SelectVariant(AClass, u'field')",
SelectVariant(AClass, 'field'))
class ManagedJar(Struct):
"""A java jar template, which can be merged with a ManagedResolve to determine a concrete version."""
def __init__(self, org, name, **kwargs):
"""
:param string org: The Maven ``groupId`` of this dependency.
:param string name: The Maven ``artifactId`` of this dependency; also serves as the name portion
of the address of this jar if defined at the top level of a BUILD file.
"""
super(ManagedJar, self).__init__(org=org, name=name, **kwargs)
@printing_func
@rule(Jar, [Select(ManagedJar), SelectVariant(ManagedResolve, 'resolve')])
def select_rev(managed_jar, managed_resolve):
(org, name) = (managed_jar.org, managed_jar.name)
rev = managed_resolve.revs.get('{}#{}'.format(org, name), None)
if not rev:
raise TaskError('{} does not have a managed version in {}.'.format(managed_jar, managed_resolve))
return Jar(org=managed_jar.org, name=managed_jar.name, rev=rev)
@printing_func
@rule(Classpath, [Select(Jar)])
def ivy_resolve(jars):
return Classpath(creator='ivy_resolve')
@printing_func
def test_variant_repr(self):
self.assert_repr(
"SelectVariant(AClass, {unicode_literal}'field')".format(
unicode_literal='' if PY3 else 'u'),
SelectVariant(AClass, 'field'))