def test_target_invalid(self): self.add_to_build_file('a/BUILD', 'target(name="a")') with self.assertRaises(AddressLookupError): self.build_graph.inject_address_closure(SyntheticAddress.parse('a:nope')) self.add_to_build_file('b/BUILD', 'target(name="a")') with self.assertRaises(AddressLookupError): self.build_graph.inject_address_closure(SyntheticAddress.parse('b')) with self.assertRaises(AddressLookupError): self.build_graph.inject_address_closure(SyntheticAddress.parse('b:b'))
def _synthesize_resources_target(self): # Create an address for the synthetic target. spec = self.address.spec + '_synthetic_resources' synthetic_address = SyntheticAddress.parse(spec=spec) # For safety, ensure an address that's not used already, even though that's highly unlikely. while self._build_graph.contains_address(synthetic_address): spec += '_' synthetic_address = SyntheticAddress.parse(spec=spec) self._build_graph.inject_synthetic_target(synthetic_address, Resources, sources=self.payload.resources.source_paths, derived_from=self) return self._build_graph.get_target(synthetic_address)
def test_inject_then_inject_closure(self): self.add_to_build_file('BUILD', 'target(name="a", ' ' dependencies=[' ' "other:b",' '])') self.add_to_build_file('other/BUILD', 'target(name="b")') self.build_graph.inject_address(SyntheticAddress.parse('//:a')) self.build_graph.inject_address_closure(SyntheticAddress.parse('//:a')) a = self.build_graph.get_target_from_spec('//:a') b = self.build_graph.get_target_from_spec('//other:b') self.assertIn(b, a.dependencies)
def java_sources(self): for spec in self._java_sources_specs: address = SyntheticAddress.parse(spec, relative_to=self.address.spec_path) target = self._build_graph.get_target(address) if target is None: raise TargetDefinitionException(self, 'No such java target: %s' % spec) yield target
def imports(self): """Returns the set of JarDependencys to be included when compiling this target.""" if self._imports is None: import_jars = set() for spec in self.payload.raw_imports: if not isinstance(spec, six.string_types): raise self.ExpectedAddressError( "{address}: expected imports to contain string addresses, got {found_class}." .format(address=self.address.spec, found_class=spec.__class__.__name__)) address = SyntheticAddress.parse(spec, relative_to=self.address.spec_path) target = self._build_graph.get_target(address) if isinstance(target, JarLibrary): import_jars.update(target.jar_dependencies) elif target is None: # TODO(pl, zundel): Not sure if we can ever reach this case. An address that # can't be resolved is caught when resolving the build graph. raise self.PrematureImportPokeError( "Internal Error: {address}: Failed to resolve import '{spec}'".format( address=self.address.spec, spec=address.spec)) else: raise self.WrongTargetTypeError( "{address}: expected {spec} to be jar_library target type, got {found_class}" .format(address=self.address.spec, spec=address.spec, found_class=target.__class__.__name__)) self._imports = list(import_jars) return self._imports
def __init__(self, name, build_file, build_file_source_lines, target_source_lines, target_interval, dependencies, dependencies_interval): """See BuildFileManipulator.load() for how to construct one as a user.""" self.name = name self.build_file = build_file self.target_address = BuildFileAddress(build_file, name) self._build_file_source_lines = build_file_source_lines self._target_source_lines = target_source_lines self._target_interval = target_interval self._dependencies_interval = dependencies_interval self._dependencies_by_address = {} for dep in dependencies: dep_address = SyntheticAddress.parse(dep.spec, relative_to=build_file.spec_path) if dep_address in self._dependencies_by_address: raise BuildTargetParseError('The address {dep_address} occurred multiple times in the ' 'dependency specs for target {name} in {build_file}. ' .format(dep_address=dep_address.spec, name=name, build_file=build_file)) self._dependencies_by_address[dep_address] = dep
def test_jar_dependencies(self): jar1 = JarDependency(org='testOrg1', name='testName1', rev='123') jar2 = JarDependency(org='testOrg2', name='testName2', rev='456') lib = JarLibrary(name='foo', address=SyntheticAddress.parse('//:foo'), build_graph=self.build_graph, jars=[jar1, jar2]) self.assertEquals((jar1, jar2), lib.jar_dependencies)
def test_register_bad_target_alias(self): with self.assertRaises(TypeError): self.build_configuration.register_target_alias('fred', object()) target = Target('fred', SyntheticAddress.parse('a:b'), BuildGraph(address_mapper=None)) with self.assertRaises(TypeError): self.build_configuration.register_target_alias('fred', target)
def create_sources_field(self, sources, sources_rel_path, address=None): """Factory method to create a SourcesField appropriate for the type of the sources object. Note that this method is called before the call to Target.__init__ so don't expect fields to be populated! :return: a payload field object representing the sources parameter :rtype: SourcesField """ if isinstance(sources, Addresses): # Currently, this is only created by the result of from_target() which takes a single argument if len(sources.addresses) != 1: raise self.WrongNumberOfAddresses( "Expected a single address to from_target() as argument to {spec}" .format(spec=address.spec)) referenced_address = SyntheticAddress.parse(sources.addresses[0], relative_to=sources.rel_path) return DeferredSourcesField(ref_address=referenced_address) elif isinstance(sources, FilesetWithSpec): filespec = sources.filespec else: sources = sources or [] assert_list(sources) filespec = {'globs' : [os.path.join(sources_rel_path, src) for src in (sources or [])]} return SourcesField(sources=sources, sources_rel_path=sources_rel_path, filespec=filespec)
def test_ragel_gen(self): self.create_file(relpath='test_ragel_gen/atoi.rl', contents=ragel_file_contents) self.add_to_build_file('test_ragel_gen', dedent(""" java_ragel_library(name='atoi', sources=['atoi.rl'], dependencies=[] ) """)) task = prepare_task(RagelGen, build_graph=self.build_graph, targets=[self.target('test_ragel_gen:atoi')], build_file_parser=self.build_file_parser) task._ragel_binary = 'ragel' task.invalidate_for_files = lambda: [] task._java_out = self.task_outdir sources = [os.path.join(self.task_outdir, 'com/example/atoi/Parser.java')] try: saved_add_new_target = Context.add_new_target Context.add_new_target = MagicMock() task.execute() relative_task_outdir = os.path.relpath(self.task_outdir, get_buildroot()) spec = '{spec_path}:{name}'.format(spec_path=relative_task_outdir, name='test_ragel_gen.atoi') address = SyntheticAddress.parse(spec=spec) Context.add_new_target.assert_called_once_with(address, JavaRagelLibrary, sources=sources, excludes=OrderedSet(), dependencies=OrderedSet(), provides=None) finally: Context.add_new_target = saved_add_new_target
def test_target_insertion_middle(self): expected_build_string = dedent( """\ # This comment should stay target_type( name = 'target_top', dependencies = [ ':dep_a', ] ) target_type( name = 'target_middle', dependencies = [ ':dep_b', ':new_dep', ], ) # This comment should be okay target_type( name = 'target_bottom', ) # Also this one though it's weird""" ) build_file = self.add_to_build_file('BUILD', self.multi_target_build_string) multi_targ_bfm = BuildFileManipulator.load(build_file, 'target_middle', set(['target_type'])) multi_targ_bfm.add_dependency(SyntheticAddress.parse(':new_dep')) build_file_str = '\n'.join(multi_targ_bfm.build_file_lines()) self.assertEqual(build_file_str, expected_build_string)
def resolve_spec(self, spec): """Converts a spec to an address and maps it using `resolve`""" try: address = SyntheticAddress.parse(spec) except ValueError as e: raise self.InvalidAddressError(e) return self.resolve(address)
def traversable_specs(self): for spec in super(PythonTarget, self).traversable_specs: yield spec if self._provides: for spec in self._provides._binaries.values(): address = SyntheticAddress.parse(spec, relative_to=self.address.spec_path) yield address.spec
def test_transitive_closure_spec(self): with self.workspace('./BUILD', 'a/BUILD', 'a/b/BUILD') as root_dir: with open(os.path.join(root_dir, './BUILD'), 'w') as build: build.write(dedent(''' fake(name="foo", dependencies=[ 'a', ]) ''')) with open(os.path.join(root_dir, 'a/BUILD'), 'w') as build: build.write(dedent(''' fake(name="a", dependencies=[ 'a/b:bat', ]) ''')) with open(os.path.join(root_dir, 'a/b/BUILD'), 'w') as build: build.write(dedent(''' fake(name="bat") ''')) build_configuration = BuildConfiguration() build_configuration.register_target_alias('fake', Target) parser = BuildFileParser(build_configuration, root_dir=root_dir) build_graph = BuildGraph(self.address_mapper) parser.inject_spec_closure_into_build_graph(':foo', build_graph) self.assertEqual(len(build_graph.dependencies_of(SyntheticAddress.parse(':foo'))), 1)
def to_jar_dependencies(self, jar_library_specs): """Convenience method to resolve a list of specs to JarLibraries and return its jars attributes. Expects that the jar_libraries are declared relative to this target. :param Address relative_to: Address that references library_specs, for error messages :param library_specs: string specs to JavaLibrary targets. Note, this list should be returned by the caller's traversable_specs() implementation to make sure that the jar_dependency jars have been added to the build graph. :param build_graph: build graph instance used to search for specs :return: list of JarDependency instances represented by the library_specs """ jar_deps = set() for spec in jar_library_specs: if not isinstance(spec, six.string_types): raise self.ExpectedAddressError( "{address}: expected imports to contain string addresses, got {found_class}." .format(address=self.address.spec, found_class=type(spec).__name__)) address = SyntheticAddress.parse(spec, relative_to=self.address.spec_path) target = self._build_graph.get_target(address) if isinstance(target, JarLibrary): jar_deps.update(target.jar_dependencies) else: raise self.WrongTargetTypeError( "{address}: expected {spec} to be jar_library target type, got {found_class}" .format(address=self.address.spec, spec=address.spec, found_class=type(target).__name__)) return list(jar_deps)
def test_synthetic_forms(self): self.assert_address('a/b', 'target', SyntheticAddress.parse('a/b:target')) self.assert_address('a/b', 'target', SyntheticAddress.parse('//a/b:target')) self.assert_address('a/b', 'b', SyntheticAddress.parse('a/b')) self.assert_address('a/b', 'b', SyntheticAddress.parse('//a/b')) self.assert_address('a/b', 'target', SyntheticAddress.parse(':target', relative_to='a/b')) self.assert_address('', 'target', SyntheticAddress.parse('//:target', relative_to='a/b')) self.assert_address('', 'target', SyntheticAddress.parse(':target')) self.assert_address('a/b', 'target', SyntheticAddress.parse(':target', relative_to='a/b'))
def test_simple_targets(self): simple_targets = dedent( """ target_type( name = 'no_deps', ) target_type( name = 'empty_deps', dependencies = [ ] ) target_type( name = 'empty_deps_inline', dependencies = [] ) """ ) build_file = self.add_to_build_file('BUILD', simple_targets) for no_deps_name in ['no_deps', 'empty_deps', 'empty_deps_inline']: no_deps = BuildFileManipulator.load(build_file, no_deps_name, set(['target_type'])) self.assertEqual(tuple(no_deps.dependency_lines()), tuple()) no_deps.add_dependency(SyntheticAddress.parse(':fake_dep')) self.assertEqual(tuple(no_deps.dependency_lines()), tuple([' dependencies = [', " ':fake_dep',", ' ],'])) no_deps.add_dependency(SyntheticAddress.parse(':b_fake_dep')) no_deps.add_dependency(SyntheticAddress.parse(':a_fake_dep')) self.assertEqual(tuple(no_deps.dependency_lines()), tuple([' dependencies = [', " ':a_fake_dep',", " ':b_fake_dep',", " ':fake_dep',", ' ],'])) self.assertEqual(tuple(no_deps.target_lines()), tuple(['target_type(', " name = '{0}',".format(no_deps_name), ' dependencies = [', " ':a_fake_dep',", " ':b_fake_dep',", " ':fake_dep',", ' ],', ')']))
def test_contains_address(self): a = SyntheticAddress.parse('a') self.assertFalse(self.build_graph.contains_address(a)) target = Target(name='a', address=a, build_graph=self.build_graph) self.build_graph.inject_target(target) self.assertTrue(self.build_graph.contains_address(a))
def test_targets_synthetic(self): a = self.make_target('a') b = self.make_target('b', dependencies=[a]) c = self.make_target('c', dependencies=[b]) d = self.make_target('d', dependencies=[c, a]) context = self.context(target_roots=[c]) self.assertEquals([c, b, a], context.targets()) syn_b = context.add_new_target(SyntheticAddress.parse('syn_b'), Target, derived_from=b) context.add_new_target(SyntheticAddress.parse('syn_d'), Target, derived_from=d) # We expect syn_b to be included now since it has been synthesized during this run from an # in-play target. self.assertEquals([c, b, a, syn_b], context.targets()) # And verify the predicate operates over both normal and synthetic targets. self.assertEquals([syn_b], context.targets(lambda t: t.derived_from != t)) self.assertEquals([c, b, a], context.targets(lambda t: t.derived_from == t))
def assert_parsed_list(self, cmdline_spec_list, expected): def sort(addresses): return sorted(addresses, key=lambda address: address.spec) self.assertEqual( sort(SyntheticAddress.parse(addr) for addr in expected), sort(self.spec_parser.parse_addresses(cmdline_spec_list)), )
def _get_target(spec, build_graph): try: address = SyntheticAddress.parse(spec) except IOError as e: raise TaskError('Failed to parse address: %s: %s' % (address, e)) match = build_graph.get_target(address) if not match: raise TaskError('Invalid target address: %s' % address) return match
def create_target(files, deps, target_type): spec = '{spec_path}:{name}'.format(spec_path=outdir, name=gentarget.id) address = SyntheticAddress.parse(spec=spec) return self.context.add_new_target(address, target_type, sources=files, provides=gentarget.provides, dependencies=deps, excludes=gentarget.excludes)
def create_target(files, deps): spec_path = os.path.join(self.combined_relpath, 'gen-py') spec = '{spec_path}:{name}'.format(spec_path=spec_path, name=target.id) address = SyntheticAddress.parse(spec=spec) return self.context.add_new_target(address, PythonLibrary, derived_from=target, sources=files, dependencies=deps)
def test_smoke(self): contents = dedent( """namespace java com.pants.example struct Example { 1: optional i64 number } """ ) self.create_file(relpath="test_smoke/a.thrift", contents=contents) self.add_to_build_file( "test_smoke", dedent( """ java_thrift_library(name='a', sources=['a.thrift'], dependencies=[], compiler='scrooge', language='scala', rpc_style='finagle' ) """ ), ) target = self.target("test_smoke:a") task = prepare_task( ScroogeGen, build_graph=self.build_graph, targets=[target], build_file_parser=self.build_file_parser ) with patch("pants.backend.codegen.tasks.scrooge_gen.calculate_services"): task._outdir = MagicMock() task._outdir.return_value = self.task_outdir task.gen = MagicMock() sources = [os.path.join(self.task_outdir, "com/pants/example/Example.scala")] task.gen.return_value = {"test_smoke/a.thrift": sources} try: saved_add_new_target = Context.add_new_target Context.add_new_target = MagicMock() task.execute() relative_task_outdir = os.path.relpath(self.task_outdir, get_buildroot()) spec = "{spec_path}:{name}".format(spec_path=relative_task_outdir, name="test_smoke.a") address = SyntheticAddress.parse(spec=spec) Context.add_new_target.assert_called_once_with( address, ScalaLibrary, sources=sources, excludes=OrderedSet(), dependencies=OrderedSet(), provides=None, derived_from=target, ) finally: Context.add_new_target = saved_add_new_target
def provides(self): if not self._provides: return None # TODO(pl): This is an awful hack for key, binary in self._provides._binaries.iteritems(): if isinstance(binary, Compatibility.string): address = SyntheticAddress.parse(binary, relative_to=self.address.spec_path) self._provides._binaries[key] = self._build_graph.get_target(address) return self._provides
def make_target(self, spec="", target_type=Target, dependencies=None, resources=None, derived_from=None, **kwargs): address = SyntheticAddress.parse(spec) target = target_type(name=address.target_name, address=address, build_graph=self.build_graph, **kwargs) dependencies = dependencies or [] dependencies.extend(resources or []) self.build_graph.inject_target( target, dependencies=[dep.address for dep in dependencies], derived_from=derived_from ) return target
def target(self, spec): """Resolves the given target address to a Target object. address: The BUILD target address to resolve. Returns the corresponding Target or else None if the address does not point to a defined Target. """ address = SyntheticAddress.parse(spec) self.build_graph.inject_address_closure(address) return self.build_graph.get_target(address)
def setUp(self): super(JavaWireLibraryTest, self).setUp() self.build_file_parser._build_configuration.register_target_alias('java_wire_library', JavaWireLibrary) self.add_to_build_file('BUILD', dedent(''' java_wire_library(name='foo', sources=[], service_writer='com.squareup.wire.RetrofitServiceWriter' )''')) self.build_graph.inject_spec_closure('//:foo') self.target = self.build_graph.get_target(SyntheticAddress.parse('//:foo'))
def provides(self): if not self.payload.provides: return None # TODO(pl): This is an awful hack if isinstance(self.payload.provides.repo, Compatibility.string): address = SyntheticAddress.parse( self.payload.provides.repo, relative_to=self.address.spec_path) repo_target = self._build_graph.get_target(address) self.payload.provides.repo = repo_target return self.payload.provides
def create_target(files, deps, target_type): spec = '{spec_path}:{name}'.format(spec_path=outdir, name=gentarget.id) address = SyntheticAddress.parse(spec=spec) return self.context.add_new_target(address, target_type, sources=files, provides=gentarget.provides, dependencies=deps, excludes=gentarget.excludes, derived_from=gentarget)
def provides(self): if not self.payload.provides: return None # TODO(pl): This is an awful hack if isinstance(self.payload.provides.repo, Compatibility.string): address = SyntheticAddress.parse(self.payload.provides.repo, relative_to=self.address.spec_path) repo_target = self._build_graph.get_target(address) self.payload.provides.repo = repo_target return self.payload.provides
def create_target(files, deps): spec_path = os.path.join(self.combined_relpath, 'gen-java') spec = '{spec_path}:{name}'.format(spec_path=spec_path, name=target.id) address = SyntheticAddress.parse(spec=spec) return self.context.add_new_target(address, JavaLibrary, derived_from=target, sources=files, provides=target.provides, dependencies=deps, excludes=target.payload.excludes)
def create_target(files, deps): spec_path = os.path.join(self.combined_relpath, 'gen-java') spec = '{spec_path}:{name}'.format(spec_path=spec_path, name=target.id) address = SyntheticAddress.parse(spec=spec) return self.context.add_new_target(address, JavaLibrary, derived_from=target, sources=files, provides=target.provides, dependencies=deps, excludes=target.payload.get_field_value('excludes'))
def setUp(self): super(JavaWireLibraryTest, self).setUp() self.build_file_parser._build_configuration.register_target_alias( 'java_wire_library', JavaWireLibrary) self.add_to_build_file( 'BUILD', dedent(''' java_wire_library(name='foo', sources=[], service_writer='com.squareup.wire.RetrofitServiceWriter' )''')) self.build_graph.inject_spec_closure('//:foo') self.target = self.build_graph.get_target( SyntheticAddress.parse('//:foo'))
def test_empty_traversable_properties(self): build_file = self.add_to_build_file( 'BUILD', dedent(''' java_library( name='foo', sources=["foo.java"], ) ''')) self.build_graph.inject_address_closure( BuildFileAddress(build_file, 'foo')) target = self.build_graph.get_target(SyntheticAddress.parse('//:foo')) self.assertSequenceEqual([], list(target.traversable_specs)) self.assertSequenceEqual([], list(target.traversable_dependency_specs))
def test_traversable_dependency_specs(self): build_file = self.add_to_build_file('BUILD', dedent(''' jvm_target(name='foo', resources=[':resource_target'], ) resources(name='resource_target', sources=['foo.txt'], ) ''')) self.build_graph.inject_address_closure(BuildFileAddress(build_file, 'foo')) target = self.build_graph.get_target(SyntheticAddress.parse('//:foo')) self.assertSequenceEqual([], list(target.traversable_specs)) self.assertSequenceEqual([':resource_target'], list(target.traversable_dependency_specs))
def test_synthetic_forms(self): self.assert_address('a/b', 'target', SyntheticAddress.parse('a/b:target')) self.assert_address('a/b', 'target', SyntheticAddress.parse('//a/b:target')) self.assert_address('a/b', 'b', SyntheticAddress.parse('a/b')) self.assert_address('a/b', 'b', SyntheticAddress.parse('//a/b')) self.assert_address( 'a/b', 'target', SyntheticAddress.parse(':target', relative_to='a/b')) self.assert_address( '', 'target', SyntheticAddress.parse('//:target', relative_to='a/b')) self.assert_address('', 'target', SyntheticAddress.parse(':target')) self.assert_address( 'a/b', 'target', SyntheticAddress.parse(':target', relative_to='a/b'))
def provides(self): if not self.payload.provides: return None # TODO(pl): This is an awful hack if isinstance(self.payload.provides.repo, Compatibility.string): repo_spec = self.payload.provides.repo address = SyntheticAddress.parse( repo_spec, relative_to=self.address.spec_path) repo_target = self._build_graph.get_target(address) if repo_target is None: raise TargetDefinitionException( self, 'No such repo target: %s' % repo_spec) self.payload.provides.repo = repo_target return self.payload.provides
def test_smoke(self): contents = dedent('''namespace java com.pants.example struct Example { 1: optional i64 number } ''') self.create_file(relpath='test_smoke/a.thrift', contents=contents) self.add_to_build_file('test_smoke', dedent(''' java_thrift_library(name='a', sources=['a.thrift'], dependencies=[], compiler='scrooge', language='scala', rpc_style='finagle' ) ''')) target = self.target('test_smoke:a') task = prepare_task(ScroogeGen, build_graph=self.build_graph, targets=[target], build_file_parser=self.build_file_parser) with patch('pants.backend.codegen.tasks.scrooge_gen.calculate_services'): task._outdir = MagicMock() task._outdir.return_value = self.task_outdir task.gen = MagicMock() sources = [os.path.join(self.task_outdir, 'com/pants/example/Example.scala')] task.gen.return_value = {'test_smoke/a.thrift': sources} try: saved_add_new_target = Context.add_new_target Context.add_new_target = MagicMock() task.execute() relative_task_outdir = os.path.relpath(self.task_outdir, get_buildroot()) spec = '{spec_path}:{name}'.format(spec_path=relative_task_outdir, name='test_smoke.a') address = SyntheticAddress.parse(spec=spec) Context.add_new_target.assert_called_once_with(address, ScalaLibrary, sources=sources, excludes=OrderedSet(), dependencies=OrderedSet(), provides=None, derived_from=target) finally: Context.add_new_target = saved_add_new_target
def _create_python_target(self, target, dependees): genfiles = [] for source in target.sources_relative_to_source_root(): path = os.path.join(target.target_base, source) genfiles.extend(calculate_genfiles(path, source).get('py', [])) spec_path = os.path.relpath(self.py_out, get_buildroot()) spec = '{spec_path}:{name}'.format(spec_path=spec_path, name=target.id) address = SyntheticAddress.parse(spec=spec) tgt = self.context.add_new_target(address, PythonLibrary, derived_from=target, sources=genfiles, dependencies=self.pythondeps) for dependee in dependees: dependee.inject_dependency(tgt.address) return tgt
def parse_url(spec): match = MarkdownToHtml.PANTS_LINK.match(spec) if match: address = SyntheticAddress.parse(match.group(1), relative_to=get_buildroot()) page = self.context.build_graph.get_target(address) anchor = match.group(2) or '' if not page: raise TaskError( 'Invalid markdown link to pants target: "%s". ' % match.group(1) + 'Is your page missing a dependency on this target?') alias, url = url_builder(page, config=get_config(page)) return alias, url + anchor else: return spec, spec
def imports(self): """Returns the set of JarDependencys to be included when compiling this target.""" if self._imports is None: libraries = OrderedSet(self._library_imports) import_jars = self.raw_imports - libraries for spec in libraries: address = SyntheticAddress.parse( spec, relative_to=self.address.spec_path) target = self._build_graph.get_target(address) if isinstance(target, (JarLibrary, JvmTarget)): import_jars.update(target.jar_dependencies) else: raise self.PrematureImportPokeError( "{address}: Failed to resolve import '{spec}'.".format( address=self.address.spec, spec=address.spec)) self._imports = import_jars return self._imports
def provides(self): if not self.payload.provides: return None for p in self.payload.provides: if isinstance(p.wiki, Wiki): # We have already resolved this string into an object, so skip it. continue if isinstance(p.wiki, Compatibility.string): address = SyntheticAddress.parse( p.wiki, relative_to=self.address.spec_path) repo_target = self._build_graph.get_target(address) p.wiki = repo_target else: raise ValueError( 'A WikiArtifact must depend on a string pointer to a Wiki. Found %s instead.' % p.wiki) return self.payload.provides
def test_to_jar_dependencies(self): def assert_dep(dep, org, name, rev): self.assertTrue(isinstance(dep, JarDependency)) self.assertEquals(org, dep.org) self.assertEquals(name, dep.name) self.assertEquals(rev, dep.rev) self.add_to_build_file( 'BUILD', dedent(''' jar_library(name='lib1', jars=[ jar(org='testOrg1', name='testName1', rev='123'), ], ) jar_library(name='lib2', jars=[ jar(org='testOrg2', name='testName2', rev='456'), jar(org='testOrg3', name='testName3', rev='789'), ], ) ''')) lib1 = self.target('//:lib1') self.assertIsInstance(lib1, JarLibrary) self.assertEquals(1, len(lib1.jar_dependencies)) assert_dep(lib1.jar_dependencies[0], 'testOrg1', 'testName1', '123') lib2 = self.target('//:lib2') self.assertIsInstance(lib2, JarLibrary) self.assertEquals(2, len(lib2.jar_dependencies)) assert_dep(lib2.jar_dependencies[0], 'testOrg2', 'testName2', '456') assert_dep(lib2.jar_dependencies[1], 'testOrg3', 'testName3', '789') jvm_target = JarLibrary(name='dummy', address=SyntheticAddress.parse("//:dummy"), build_graph=self.build_graph) deps = jvm_target.to_jar_dependencies(jvm_target.address, [':lib1', ':lib2'], self.build_graph) self.assertEquals(3, len(deps)) assert_dep(lib1.jar_dependencies[0], 'testOrg1', 'testName1', '123') assert_dep(lib2.jar_dependencies[0], 'testOrg2', 'testName2', '456') assert_dep(lib2.jar_dependencies[1], 'testOrg3', 'testName3', '789')
def _create_java_target(self, target, dependees): genfiles = [] for source in target.sources_relative_to_source_root(): path = os.path.join(get_buildroot(), target.target_base, source) genfile = calculate_genfile(path) genfiles.append(os.path.join(self._java_out, genfile)) spec_path = os.path.relpath(self._java_out, get_buildroot()) spec = '{spec_path}:{name}'.format(spec_path=spec_path, name=target.id) address = SyntheticAddress.parse(spec=spec) tgt = self.context.add_new_target(address, JavaRagelLibrary, sources=genfiles, provides=target.provides, dependencies=self.javadeps, excludes=target.payload.excludes) for dependee in dependees: dependee.inject_dependency(tgt.address) return tgt
def _test_help(self, build_string, library_type, sources): contents = dedent('''#@namespace android org.pantsbuild.android_example namespace java org.pantsbuild.example struct Example { 1: optional i64 number } ''') self.create_file(relpath='test_smoke/a.thrift', contents=contents) self.add_to_build_file('test_smoke', dedent(build_string)) target = self.target('test_smoke:a') context = self.context(target_roots=[target]) task = self.create_task(context) task._declares_service = lambda source: False task._outdir = MagicMock() task._outdir.return_value = self.task_outdir task.gen = MagicMock() task.gen.return_value = {'test_smoke/a.thrift': sources} saved_add_new_target = Context.add_new_target try: Context.add_new_target = MagicMock() task.execute() relative_task_outdir = os.path.relpath(self.task_outdir, get_buildroot()) spec = '{spec_path}:{name}'.format(spec_path=relative_task_outdir, name='test_smoke.a') address = SyntheticAddress.parse(spec=spec) Context.add_new_target.assert_called_once_with(address, library_type, sources=sources, excludes=OrderedSet(), dependencies=OrderedSet(), provides=None, derived_from=target) finally: Context.add_new_target = saved_add_new_target
def create_sources_field(self, sources, sources_rel_path, address=None, build_graph=None): """Factory method to create a SourcesField appropriate for the type of the sources object. Note that this method is called before the call to Target.__init__ so don't expect fields to be populated! :return: a payload field object representing the sources parameter :rtype: SourcesField """ if isinstance(sources, Addresses): # Currently, this is only created by the result of from_target() which takes a single argument if len(sources.addresses) != 1: raise self.WrongNumberOfAddresses( "Expected a single address to from_target() as argument to {spec}" .format(spec=address.spec)) referenced_address = SyntheticAddress.parse( sources.addresses[0], relative_to=sources.rel_path) return DeferredSourcesField(ref_address=referenced_address) return SourcesField(sources=sources, sources_rel_path=sources_rel_path)