def __init__(self, sources, address=None, exports=None, **kwargs):
payload = Payload()
payload.add_field('sources', self.create_sources_field(sources,
sources_rel_path=address.spec_path,
key_arg='sources'))
payload.add_field('exports', PrimitivesSetField(exports or []))
super(SourcesTarget, self).__init__(address=address, payload=payload, **kwargs)
def test_set_of_primitives_field(self):
# Should preserve `None` values.
self.assertEqual(PrimitivesSetField(None).value, None)
def sopf(underlying):
return PrimitivesSetField(underlying).fingerprint()
self.assertEqual(
sopf({'one', 'two'}),
sopf({'two', 'one'}),
)
self.assertEqual(
sopf(['one', 'two']),
sopf(['two', 'one']),
)
self.assertEqual(
sopf(None),
sopf(None),
)
self.assertNotEqual(
sopf(None),
sopf(['one']),
)
self.assertNotEqual(
sopf(None),
sopf([]),
)
def test_set_of_primitives_field(self):
# Should preserve `None` values.
self.assertEqual(PrimitivesSetField(None).value, None)
def sopf(underlying):
return PrimitivesSetField(underlying).fingerprint()
self.assertEqual(
sopf({"one", "two"}),
sopf({"two", "one"}),
)
self.assertEqual(
sopf(["one", "two"]),
sopf(["two", "one"]),
)
self.assertEqual(
sopf(None),
sopf(None),
)
self.assertNotEqual(
sopf(None),
sopf(["one"]),
)
self.assertNotEqual(
sopf(None),
sopf([]),
)
def __init__(self, address=None, payload=None, **kwargs):
self.address = address # Set in case a TargetDefinitionException is thrown early
payload = payload or Payload()
payload.add_fields(
{"platform": PrimitiveField(None), "compiler_option_sets": PrimitivesSetField(None)}
)
super().__init__(address=address, payload=payload, **kwargs)
def __init__(self, sources, address=None, exports=None, **kwargs):
payload = Payload()
payload.add_field(
"sources",
self.create_sources_field(
sources, sources_rel_path=address.spec_path, key_arg="sources"
),
)
payload.add_field("exports", PrimitivesSetField(exports or []))
super().__init__(address=address, payload=payload, **kwargs)
def __init__(self,
address,
payload=None,
sources=None,
ctypes_native_library=None,
strict_deps=None,
fatal_warnings=None,
compiler_option_sets=None,
toolchain_variant=None,
**kwargs):
if not payload:
payload = Payload()
sources_field = self.create_sources_field(sources,
address.spec_path,
key_arg="sources")
payload.add_fields({
"sources":
sources_field,
"ctypes_native_library":
ctypes_native_library,
"strict_deps":
PrimitiveField(strict_deps),
"fatal_warnings":
PrimitiveField(fatal_warnings),
"compiler_option_sets":
PrimitivesSetField(compiler_option_sets),
"toolchain_variant":
PrimitiveField(toolchain_variant),
})
if ctypes_native_library and not isinstance(ctypes_native_library,
NativeArtifact):
raise TargetDefinitionException(
"Target must provide a valid pants '{}' object. Received an object with type '{}' "
"and value: {}.".format(
NativeArtifact.alias(),
type(ctypes_native_library).__name__,
ctypes_native_library,
))
super().__init__(address=address, payload=payload, **kwargs)
def __init__(self,
address=None,
payload=None,
sources=None,
protoc_plugins=None,
**kwargs):
"""
:param sources: protobuf source files
:type sources: :class:`pants.source.wrapped_globs.FilesetWithSpec` or list of strings. Paths
are relative to the BUILD file's directory.
"""
payload = payload or Payload()
payload.add_field(
'sources',
self.create_sources_field(sources,
address.spec_path,
key_arg='sources'))
payload.add_field('protoc_plugins',
PrimitivesSetField(protoc_plugins or []))
super().__init__(payload=payload, address=address, **kwargs)
def __init__(self, address, payload=None, sources=None, include_relpath=None, lib_relpath=None,
native_lib_names=None, **kwargs):
"""
:param sources: Files owned by this target.
:param str include_relpath: The path where C/C++ headers are located, relative to this target's
directory. Libraries depending on this target will be able to
#include files relative to this directory.
:param str lib_relpath: The path where native libraries are located, relative to this target's
directory.
:param list native_lib_names: Strings containing the libraries to add to the linker command
line. These libraries become `-l<name>` arguments, so they must
exist and be named `lib<name>.so` (or `lib<name>.dylib` depending
on the platform) or the linker will exit with an error.
"""
if not payload:
payload = Payload()
payload.add_fields({
'sources': self.create_sources_field(sources, address.spec_path, key_arg='sources'),
'include_relpath': PrimitiveField(include_relpath),
'lib_relpath': PrimitiveField(lib_relpath),
'native_lib_names': PrimitivesSetField(native_lib_names),
})
super().__init__(address=address, payload=payload, **kwargs)
def sopf(underlying):
return PrimitivesSetField(underlying).fingerprint()
def __init__(self,
address=None,
payload=None,
sources=None,
provides=None,
excludes=None,
services=None,
platform=None,
strict_deps=None,
exports=None,
compiler_option_sets=None,
zinc_file_manager=None,
# Some subclasses can have both .java and .scala sources
# (e.g., JUnitTests, JvmBinary, even ScalaLibrary), so it's convenient
# to have both plugins settings here, even though for other subclasses
# (e.g., JavaLibrary) only one will be relevant.
javac_plugins=None,
javac_plugin_args=None,
scalac_plugins=None,
scalac_plugin_args=None,
**kwargs):
"""
:API: public
:param excludes: List of `exclude <#exclude>`_\\s to filter this target's
transitive dependencies against.
:param sources: Source code files to build. Paths are relative to the BUILD
file's directory.
:type sources: ``Fileset`` (from globs or rglobs) or list of strings
:param services: A dict mapping service interface names to the classes owned by this target
that implement them. Keys are fully qualified service class names, values are
lists of strings, each string the fully qualified class name of a class owned
by this target that implements the service interface and should be
discoverable by the jvm service provider discovery mechanism described here:
https://docs.oracle.com/javase/6/docs/api/java/util/ServiceLoader.html
:param str platform: The name of the platform (defined under the jvm-platform subsystem) to use
for compilation (that is, a key into the --jvm-platform-platforms
dictionary). If unspecified, the platform will default to the first one of
these that exist: (1) the default_platform specified for jvm-platform,
(2) a platform constructed from whatever java version is returned by
DistributionLocator.cached().version.
:param bool strict_deps: When True, only the directly declared deps of the target will be used
at compilation time. This enforces that all direct deps of the target
are declared, and can improve compilation speed due to smaller
classpaths. Transitive deps are always provided at runtime.
:param list exports: A list of exported targets, which will be accessible to dependents even
with strict_deps turned on. A common use case is for library targets to
to export dependencies that it knows its dependents will need. Then any
dependents of that library target will have access to those dependencies
even when strict_deps is True. Note: exports is transitive, which means
dependents have access to the closure of exports. An example will be that
if A exports B, and B exports C, then any targets that depends on A will
have access to both B and C.
:param list compiler_option_sets: A list of compiler_option_sets keys for the target. Platform
dependent.
:param bool zinc_file_manager: Whether to use zinc provided file manager that allows
transactional rollbacks, but in certain cases may conflict with
user libraries.
:param javac_plugins: names of compiler plugins to use when compiling this target with javac.
:param dict javac_plugin_args: Map from javac plugin name to list of arguments for that plugin.
:param scalac_plugins: names of compiler plugins to use when compiling this target with scalac.
:param dict scalac_plugin_args: Map from scalac plugin name to list of arguments for that plugin.
"""
self.address = address # Set in case a TargetDefinitionException is thrown early
payload = payload or Payload()
excludes = ExcludesField(self.assert_list(excludes, expected_type=Exclude, key_arg='excludes'))
payload.add_fields({
'sources': self.create_sources_field(sources, address.spec_path, key_arg='sources'),
'provides': provides,
'excludes': excludes,
'platform': PrimitiveField(platform),
'strict_deps': PrimitiveField(strict_deps),
'exports': PrimitivesSetField(exports or []),
'compiler_option_sets': PrimitivesSetField(compiler_option_sets),
'zinc_file_manager': PrimitiveField(zinc_file_manager),
'javac_plugins': PrimitivesSetField(javac_plugins or []),
'javac_plugin_args': PrimitiveField(javac_plugin_args),
'scalac_plugins': PrimitivesSetField(scalac_plugins or []),
'scalac_plugin_args': PrimitiveField(scalac_plugin_args),
})
super(JvmTarget, self).__init__(address=address, payload=payload, **kwargs)
# Service info is only used when generating resources, it should not affect, for example, a
# compile fingerprint or javadoc fingerprint. As such, its not a payload field.
self._services = services or {}
