def __init__(self, name, dependencies, is_meta):
Target.__init__(self, name, is_meta)
self._injected_deps = []
self.processed_dependencies = resolve(dependencies)
self.add_label('internal')
self.dependency_addresses = OrderedSet()
self.dependencies = OrderedSet()
self.internal_dependencies = OrderedSet()
self.jar_dependencies = OrderedSet()
# TODO(John Sirois): if meta targets were truly built outside parse contexts - we could instead
# just use the more general check: if parsing: delay(doit) else: doit()
# Fix how target _ids are built / addresses to not require a BUILD file - ie: support anonymous,
# non-addressable targets - which is what meta-targets really are once created.
if is_meta:
# Meta targets are built outside any parse context - so update dependencies immediately
self.update_dependencies(self.processed_dependencies)
else:
# Defer dependency resolution after parsing the current BUILD file to allow for forward
# references
self._post_construct(self.update_dependencies,
self.processed_dependencies)
self._post_construct(self.inject_dependencies)
def __init__(self, name, binary, bundles, basename=None):
"""
:param string name: The name of this target, which combined with this
build file defines the target :class:`twitter.pants.base.address.Address`.
:param binary: The :class:`twitter.pants.targets.jvm_binary.JvmBinary`,
or a :class:`twitter.pants.targets.pants_target.Pants` pointer to one.
:param bundles: One or more :class:`twitter.pants.targets.jvm_binary.Bundle`'s
describing "extra files" that should be included with this app
(e.g.: config files, startup scripts).
:param string basename: Name of this application, if different from the
``name``. Pants uses this in the ``bundle`` goal to name the distribution
artifact. In most cases this parameter is not necessary.
"""
super(JvmApp, self).__init__(name, dependencies=[])
self._binaries = maybe_list(
util.resolve(binary),
expected_type=(Pants, JarLibrary, JvmBinary),
raise_type=partial(TargetDefinitionException, self))
self._bundles = maybe_list(bundles, expected_type=Bundle,
raise_type=partial(TargetDefinitionException, self))
if name == basename:
raise TargetDefinitionException(self, 'basename must not equal name.')
self.basename = basename or name
self._resolved_binary = None
self._resolved_bundles = []
def __init__(self, name, dependencies, is_meta):
Target.__init__(self, name, is_meta)
self._injected_deps = []
self.processed_dependencies = resolve(dependencies)
self.add_label('internal')
self.dependency_addresses = OrderedSet()
self.dependencies = OrderedSet()
self.internal_dependencies = OrderedSet()
self.jar_dependencies = OrderedSet()
# TODO(John Sirois): if meta targets were truly built outside parse contexts - we could instead
# just use the more general check: if parsing: delay(doit) else: doit()
# Fix how target _ids are built / addresses to not require a BUILD file - ie: support anonymous,
# non-addressable targets - which is what meta-targets really are once created.
if is_meta:
# Meta targets are built outside any parse context - so update dependencies immediately
self.update_dependencies(self.processed_dependencies)
else:
# Defer dependency resolution after parsing the current BUILD file to allow for forward
# references
self._post_construct(self.update_dependencies, self.processed_dependencies)
self._post_construct(self.inject_dependencies)
def __init__(self, name, binary, bundles, basename=None):
"""
:param string name: The name of this target, which combined with this
build file defines the target :class:`twitter.pants.base.address.Address`.
:param binary: The :class:`twitter.pants.targets.jvm_binary.JvmBinary`,
or a :class:`twitter.pants.targets.pants_target.Pants` pointer to one.
:param bundles: One or more :class:`twitter.pants.targets.jvm_binary.Bundle`'s
describing "extra files" that should be included with this app
(e.g.: config files, startup scripts).
:param string basename: Name of this application, if different from the
``name``. Pants uses this in the ``bundle`` goal to name the distribution
artifact. In most cases this parameter is not necessary.
"""
super(JvmApp, self).__init__(name, dependencies=[])
self._binaries = maybe_list(
util.resolve(binary),
expected_type=(Pants, JarLibrary, JvmBinary),
raise_type=partial(TargetDefinitionException, self))
self._bundles = maybe_list(bundles,
expected_type=Bundle,
raise_type=partial(
TargetDefinitionException, self))
if name == basename:
raise TargetDefinitionException(self,
'basename must not equal name.')
self.basename = basename or name
self._resolved_binary = None
self._resolved_bundles = []
def testMixedList(self):
self.assertEquals(
resolve([MockPantsTarget("1"), "2", MockPantsTarget("3"), "4", "5"], clazz=MockPantsTarget),
[MockPantsTarget("1"),
MockPantsTarget("2"),
MockPantsTarget("3"),
MockPantsTarget("4"),
MockPantsTarget("5")])
def __init__(self, name, sources, resources=None, dependencies=None):
TargetWithSources.__init__(self, name)
processed_dependencies = resolve(dependencies)
self.add_label('python')
self.sources = self._resolve_paths(self.target_base, sources)
self.resources = self._resolve_paths(self.target_base, resources) if resources else OrderedSet()
self.dependencies = OrderedSet(processed_dependencies) if processed_dependencies else OrderedSet()
def __init__(self, name, dependencies):
"""name: The name of this module target, addressable via pants via the portion of the spec
following the colon
dependencies: one or more JarDependencies this JarLibrary bundles or Pants pointing to other
JarLibraries or JavaTargets"""
assert len(dependencies) > 0, "At least one dependency must be specified"
Target.__init__(self, name, False)
self.add_label('jars')
self.dependencies = resolve(dependencies)
def testNonTarget(self):
self.assertEquals(
resolve([
MockPantsTarget(1),
[4, 'asdf'],
"qwer",
],
clazz=MockPantsTarget), [
MockPantsTarget(1), [4, MockPantsTarget('asdf')],
MockPantsTarget('qwer')
])
def testMixedList(self):
self.assertEquals(
resolve(
[MockPantsTarget("1"), "2",
MockPantsTarget("3"), "4", "5"],
clazz=MockPantsTarget), [
MockPantsTarget("1"),
MockPantsTarget("2"),
MockPantsTarget("3"),
MockPantsTarget("4"),
MockPantsTarget("5")
])
def __init__(self, name, sources, resources=None, dependencies=None):
TargetWithSources.__init__(self, name)
processed_dependencies = resolve(dependencies)
self.add_label('python')
self.sources = self._resolve_paths(self.target_base, sources)
self.resources = self._resolve_paths(
self.target_base, resources) if resources else OrderedSet()
self.dependencies = OrderedSet(
processed_dependencies) if processed_dependencies else OrderedSet(
)
def __init__(self, name, dependencies):
"""name: The name of this module target, addressable via pants via the portion of the spec
following the colon
dependencies: one or more JarDependencies this JarLibrary bundles or Pants pointing to other
JarLibraries or JavaTargets"""
assert len(
dependencies) > 0, "At least one dependency must be specified"
Target.__init__(self, name, False)
self.add_label('jars')
self.dependencies = resolve(dependencies)
self.dependency_addresses = set()
for dependency in self.dependencies:
if hasattr(dependency, 'address'):
self.dependency_addresses.add(dependency.address)
def __init__(self,
name,
sources=None,
java_sources=None,
provides=None,
dependencies=None,
excludes=None,
resources=None,
exclusives=None):
"""
:param string name: The name of this target, which combined with this
build file defines the target :class:`twitter.pants.base.address.Address`.
:param sources: A list of filenames representing the source code
this library is compiled from.
:type sources: list of strings
:param java_sources:
:class:`twitter.pants.targets.java_library.JavaLibrary` or list of
JavaLibrary targets this library has a circular dependency on.
Prefer using dependencies to express non-circular dependencies.
:param Artifact provides:
The :class:`twitter.pants.targets.artifact.Artifact`
to publish that represents this target outside the repo.
:param dependencies: List of :class:`twitter.pants.base.target.Target` instances
this target depends on.
:type dependencies: list of targets
:param excludes: List of :class:`twitter.pants.targets.exclude.Exclude` instances
to filter this target's transitive dependencies against.
:param resources: An optional list of paths (DEPRECATED) or ``resources``
targets containing resources that belong on this library's classpath.
:param exclusives: An optional list of exclusives tags.
"""
super(ScalaLibrary, self).__init__(name,
sources,
provides,
dependencies,
excludes,
exclusives=exclusives)
if (sources is None) and (resources is None):
raise TargetDefinitionException(
self, 'Must specify sources and/or resources.')
self.resources = resources
self._java_sources = []
self._raw_java_sources = util.resolve(java_sources)
self.add_labels('scala')
def __init__(self,
name,
sources=None,
java_sources=None,
provides=None,
dependencies=None,
excludes=None,
resources=None,
exclusives=None):
"""
:param string name: The name of this target, which combined with this
build file defines the target :class:`twitter.pants.base.address.Address`.
:param sources: A list of filenames representing the source code
this library is compiled from.
:type sources: list of strings
:param java_sources:
:class:`twitter.pants.targets.java_library.JavaLibrary` or list of
JavaLibrary targets this library has a circular dependency on.
Prefer using dependencies to express non-circular dependencies.
:param Artifact provides:
The :class:`twitter.pants.targets.artifact.Artifact`
to publish that represents this target outside the repo.
:param dependencies: List of :class:`twitter.pants.base.target.Target` instances
this target depends on.
:type dependencies: list of targets
:param excludes: List of :class:`twitter.pants.targets.exclude.Exclude` instances
to filter this target's transitive dependencies against.
:param resources: An optional list of paths (DEPRECATED) or ``resources``
targets containing resources that belong on this library's classpath.
:param exclusives: An optional list of exclusives tags.
"""
super(ScalaLibrary, self).__init__(
name,
sources,
provides,
dependencies,
excludes,
exclusives=exclusives)
if (sources is None) and (resources is None):
raise TargetDefinitionException(self, 'Must specify sources and/or resources.')
self.resources = resources
self._java_sources = []
self._raw_java_sources = util.resolve(java_sources)
self.add_labels('scala')
def __init__(self, org, name, repo, description=None):
"""
:org the originization of this artifact, the group id in maven parlance
:name the name of the artifact
:repo the repository this artifact is published to
:description a description of this artifact
"""
self.org = org
self.name = name
self.rev = None
repos = list(resolve(repo).resolve())
if len(repos) != 1:
raise Exception("An artifact must have exactly 1 repo, given: %s" % repos)
self.repo = repos[0]
self.description = description
def __init__(self, org, name, repo, description=None):
"""
:org the originization of this artifact, the group id in maven parlance
:name the name of the artifact
:repo the repository this artifact is published to
:description a description of this artifact
"""
self.org = org
self.name = name
self.rev = None
repos = list(resolve(repo).resolve())
if len(repos) != 1:
raise Exception("An artifact must have exactly 1 repo, given: %s" %
repos)
self.repo = repos[0]
self.description = description
def __init__(self, name, binary, bundles, basename=None):
InternalTarget.__init__(self, name, dependencies=[])
if not binary:
raise TargetDefinitionException(self, 'binary is required')
binaries = list(filter(is_concrete, util.resolve(binary).resolve()))
if len(binaries) != 1 or not isinstance(binaries[0], JvmBinary):
raise TargetDefinitionException(
self, 'must supply exactly 1 JvmBinary, got %s' % binary)
self.binary = binaries[0]
self._post_construct(self.update_dependencies, binaries)
if not bundles:
raise TargetDefinitionException(self, 'bundles must be specified')
def is_resolvable(item):
return hasattr(item, 'resolve')
def is_bundle(bundle):
return isinstance(bundle, Bundle)
def resolve(item):
return list(item.resolve()) if is_resolvable(item) else [None]
if is_resolvable(bundles):
bundles = resolve(bundles)
self.bundles = []
try:
for item in iter(bundles):
for bundle in resolve(item):
if not is_bundle(bundle):
raise TypeError()
self.bundles.append(bundle)
except TypeError:
raise TargetDefinitionException(
self, 'bundles must be one or more Bundle objects, '
'got %s' % bundles)
self.basename = basename or name
def __init__(self, name, binary, bundles, basename=None):
InternalTarget.__init__(self, name, dependencies=[])
if not binary:
raise TargetDefinitionException(self, 'binary is required')
binaries = [t for t in util.resolve(binary).resolve() if t.is_concrete]
if len(binaries) != 1 or not isinstance(binaries[0], JvmBinary):
raise TargetDefinitionException(self, 'must supply exactly 1 JvmBinary, got %s' % binary)
self.binary = binaries[0]
self._post_construct(self.update_dependencies, binaries)
if not bundles:
raise TargetDefinitionException(self, 'bundles must be specified')
def is_resolvable(item):
return hasattr(item, 'resolve')
def is_bundle(bundle):
return isinstance(bundle, Bundle)
def resolve(item):
return list(item.resolve()) if is_resolvable(item) else [None]
if is_resolvable(bundles):
bundles = resolve(bundles)
self.bundles = []
try:
for item in iter(bundles):
for bundle in resolve(item):
if not is_bundle(bundle):
raise TypeError()
self.bundles.append(bundle)
except TypeError:
raise TargetDefinitionException(self, 'bundles must be one or more Bundle objects, '
'got %s' % bundles)
self.basename = basename or name
def __init__(self, name, dependencies, overrides=None, exclusives=None):
"""
:param string name: The name of this target, which combined with this
build file defines the target :class:`twitter.pants.base.address.Address`.
:param dependencies: List of :class:`twitter.pants.base.target.Target` instances
this target depends on.
:param overrides: List of strings, each of which will be recursively resolved to
any targets that provide artifacts. Those artifacts will override corresponding
direct/transitive dependencies in the dependencies list.
:param exclusives: An optional map of exclusives tags. See CheckExclusives for details.
"""
super(JarLibrary, self).__init__(name, exclusives=exclusives)
self._pre_override_dependencies = OrderedSet(
maybe_list(util.resolve(dependencies),
expected_type=(ExternalDependency, AnonymousDeps, Target),
raise_type=partial(TargetDefinitionException, self)))
self._dependencies = None
self._dependency_addresses = None
self.override_targets = set(map(Pants, overrides or []))
self.add_labels('jars')
def __init__(self, name, dependencies, overrides=None, exclusives=None):
"""
:param string name: The name of this target, which combined with this
build file defines the target :class:`twitter.pants.base.address.Address`.
:param dependencies: List of :class:`twitter.pants.base.target.Target` instances
this target depends on.
:param overrides: List of strings, each of which will be recursively resolved to
any targets that provide artifacts. Those artifacts will override corresponding
direct/transitive dependencies in the dependencies list.
:param exclusives: An optional map of exclusives tags. See CheckExclusives for details.
"""
super(JarLibrary, self).__init__(name, exclusives=exclusives)
self._pre_override_dependencies = OrderedSet(
maybe_list(util.resolve(dependencies),
expected_type=(ExternalDependency, AnonymousDeps,
Target),
raise_type=partial(TargetDefinitionException, self)))
self._dependencies = None
self._dependency_addresses = None
self.override_targets = set(map(Pants, overrides or []))
self.add_labels('jars')
def resources(self, resources): self._resources = [] self._raw_resources = util.resolve(resources)
def testUnicodeString(self): self.assertEquals(resolve(u"asdf", clazz=MockPantsTarget).foo, u"asdf")
def inject_dependencies(self): self.update_dependencies(resolve(self._injected_deps))
def testNone(self):
self.assertEquals(resolve(None, clazz=MockPantsTarget), None)
def resources(self, resources):
self._resources = []
self._raw_resources = util.resolve(resources)
def testNonTarget(self):
self.assertEquals(
resolve([MockPantsTarget(1), [4, 'asdf'], "qwer",], clazz=MockPantsTarget),
[MockPantsTarget(1), [4, MockPantsTarget('asdf')], MockPantsTarget('qwer')])
def testNone(self): self.assertEquals(resolve(None, clazz=MockPantsTarget), None)
def testPantsTarget(self):
self.assertEquals(resolve(MockPantsTarget("asdf"), clazz=MockPantsTarget).foo, "asdf")
def testPantsTarget(self):
self.assertEquals(
resolve(MockPantsTarget("asdf"), clazz=MockPantsTarget).foo,
"asdf")
def testString(self):
self.assertEquals(resolve("asdf", clazz=MockPantsTarget).foo, "asdf")
def testString(self):
self.assertEquals(resolve("asdf", clazz=MockPantsTarget).foo, "asdf")
def testUnicodeString(self):
self.assertEquals(resolve(u"asdf", clazz=MockPantsTarget).foo, u"asdf")
def inject_dependencies(self):
self.update_dependencies(resolve(self._injected_deps))
