def test_exclude_pattern(self):
"""Test that targets are filtered based on exclude patterns."""
specs = Specs([SiblingAddresses('root')], exclude_patterns=tuple(['.exclude*']))
address_family = AddressFamily('root',
{'exclude_me': ('root/BUILD', TargetAdaptor()),
'not_me': ('root/BUILD', TargetAdaptor()),
}
)
targets = self._resolve_build_file_addresses(
specs, address_family, self._snapshot(), self._address_mapper())
self.assertEqual(len(targets.dependencies), 1)
self.assertEqual(targets.dependencies[0].spec, 'root:not_me')
def test_tag_filter(self):
"""Test that targets are filtered based on `tags`."""
specs = Specs([SiblingAddresses('root')], tags=['+integration'])
address_family = AddressFamily('root',
{'a': ('root/BUILD', TargetAdaptor()),
'b': ('root/BUILD', TargetAdaptor(tags={'integration'})),
'c': ('root/BUILD', TargetAdaptor(tags={'not_integration'}))
}
)
targets = self._resolve_build_file_addresses(
specs, address_family, self._snapshot(), self._address_mapper())
self.assertEqual(len(targets.dependencies), 1)
self.assertEqual(targets.dependencies[0].spec, 'root:b')
def run_black(
self,
source_files: List[FileContent],
*,
config: Optional[str] = None,
passthrough_args: Optional[str] = None,
skip: bool = False,
) -> Tuple[LintResult, FmtResult]:
args = ["--backend-packages2=pants.backend.python.lint.black"]
if config is not None:
self.create_file(relpath="pyproject.toml", contents=config)
args.append("--black-config=pyproject.toml")
if passthrough_args:
args.append(f"--black-args='{passthrough_args}'")
if skip:
args.append(f"--black-skip")
input_snapshot = self.request_single_product(Snapshot, InputFilesContent(source_files))
target_adaptor = TargetAdaptor(
sources=EagerFilesetWithSpec('test', {'globs': []}, snapshot=input_snapshot),
address=Address.parse("test:target"),
)
lint_target = BlackTarget(target_adaptor)
fmt_target = BlackTarget(target_adaptor, prior_formatter_result_digest=input_snapshot.directory_digest)
options_bootstrapper = create_options_bootstrapper(args=args)
lint_result = self.request_single_product(LintResult, Params(lint_target, options_bootstrapper))
fmt_result = self.request_single_product(FmtResult, Params(fmt_target, options_bootstrapper))
return lint_result, fmt_result
def hydrate_target(target_adaptor, hydrated_fields):
"""Construct a HydratedTarget from a TargetAdaptor and hydrated versions of its adapted fields."""
# Hydrate the fields of the adaptor and re-construct it.
kwargs = target_adaptor.kwargs()
for field in hydrated_fields:
kwargs[field.name] = field.value
return HydratedTarget(TargetAdaptor(**kwargs), tuple(target_adaptor.dependencies))
def test_fails_on_nonexistent_specs(self) -> None:
"""Test that address specs referring to nonexistent targets raise a ResolveError."""
address_family = AddressFamily('root',
{'a': ('root/BUILD', TargetAdaptor())})
address_specs = AddressSpecs(
[SingleAddress('root', 'b'),
SingleAddress('root', 'a')])
expected_rx_str = re.escape(
""""b" was not found in namespace "root". Did you mean one of:
:a""")
with self.assertRaisesRegex(ResolveError, expected_rx_str):
self._resolve_build_file_addresses(address_specs, address_family,
self._snapshot(),
self._address_mapper())
# Ensure that we still catch nonexistent targets later on in the list of command-line
# address specs.
address_specs = AddressSpecs(
[SingleAddress('root', 'a'),
SingleAddress('root', 'b')])
with self.assertRaisesRegex(ResolveError, expected_rx_str):
self._resolve_build_file_addresses(address_specs, address_family,
self._snapshot(),
self._address_mapper())
def make_ht(nm: str) -> HydratedTarget:
if nm not in name_to_ht:
dep_hts = tuple(make_ht(dep) for dep in name_to_deps[nm])
name_to_ht[nm] = HydratedTarget(address=nm,
adaptor=TargetAdaptor(),
dependencies=dep_hts)
return name_to_ht[nm]
def reify_legacy_graph(target_adaptor, dependencies, hydrated_fields):
"""Construct a LegacyTarget from a TargetAdaptor, its deps, and hydrated versions of its adapted fields."""
kwargs = target_adaptor.kwargs()
for field in hydrated_fields:
kwargs[field.name] = field.value
return LegacyTarget(TargetAdaptor(**kwargs),
[d.adaptor.address for d in dependencies])
def test_exclude_pattern(self) -> None:
"""Test that targets are filtered based on exclude patterns."""
address_specs = AddressSpecs([SiblingAddresses("root")],
exclude_patterns=tuple([".exclude*"]))
address_family = AddressFamily(
"root",
{
"exclude_me": ("root/BUILD", TargetAdaptor()),
"not_me": ("root/BUILD", TargetAdaptor()),
},
)
targets = self._resolve_addresses(address_specs, address_family,
self._snapshot(),
self._address_mapper())
assert len(targets) == 1
assert targets[0].spec == "root:not_me"
def test_exclude_pattern(self):
"""Test that targets are filtered based on exclude patterns."""
spec = SiblingAddresses('root')
address_mapper = AddressMapper(JsonParser(TestTable()))
snapshot = Snapshot(DirectoryDigest(str('xx'), 2), (Path('root/BUILD', File('root/BUILD')),))
address_family = AddressFamily('root',
{'exclude_me': ('root/BUILD', TargetAdaptor()),
'not_me': ('root/BUILD', TargetAdaptor()),
}
)
targets = run_rule(
addresses_from_address_families, address_mapper, Specs([spec], exclude_patterns=tuple(['.exclude*'])),{
(Snapshot, PathGlobs): lambda _: snapshot,
(AddressFamily, Dir): lambda _: address_family,
})
self.assertEquals(len(targets.dependencies), 1)
self.assertEquals(targets.dependencies[0].spec, 'root:not_me')
def test_tag_filter(self) -> None:
"""Test that targets are filtered based on `tags`."""
address_specs = AddressSpecs([SiblingAddresses("root")], tags=["+integration"])
address_family = AddressFamily(
"root",
{
"a": ("root/BUILD", TargetAdaptor()),
"b": ("root/BUILD", TargetAdaptor(tags={"integration"})),
"c": ("root/BUILD", TargetAdaptor(tags={"not_integration"})),
},
)
targets = self._resolve_addresses(
address_specs, address_family, self._snapshot(), self._address_mapper()
)
assert len(targets) == 1
assert targets[0].spec == "root:b"
def test_tag_filter(self):
"""Test that targets are filtered based on `tags`."""
spec = SiblingAddresses('root')
address_mapper = AddressMapper(JsonParser(TestTable()))
snapshot = Snapshot(DirectoryDigest(str('xx'), 2), (Path('root/BUILD', File('root/BUILD')),))
address_family = AddressFamily('root',
{'a': ('root/BUILD', TargetAdaptor()),
'b': ('root/BUILD', TargetAdaptor(tags={'integration'})),
'c': ('root/BUILD', TargetAdaptor(tags={'not_integration'}))
}
)
targets = run_rule(
addresses_from_address_families, address_mapper, Specs([spec], tags=['+integration']), {
(Snapshot, PathGlobs): lambda _: snapshot,
(AddressFamily, Dir): lambda _: address_family,
})
self.assertEquals(len(targets.dependencies), 1)
self.assertEquals(targets.dependencies[0].spec, 'root:b')
def make_target_with_origin(
self, source_files: List[FileContent], *, origin: Optional[OriginSpec] = None,
) -> TargetAdaptorWithOrigin:
input_snapshot = self.request_single_product(Snapshot, InputFilesContent(source_files))
adaptor = TargetAdaptor(
sources=EagerFilesetWithSpec("test", {"globs": []}, snapshot=input_snapshot),
address=Address.parse("test:target"),
)
if origin is None:
origin = SingleAddress(directory="test", name="target")
return TargetAdaptorWithOrigin(adaptor, origin)
def test_exclude_pattern_with_single_address(self) -> None:
"""Test that single address targets are filtered based on exclude patterns."""
address_specs = AddressSpecs(
[SingleAddress("root", "not_me")], exclude_patterns=tuple(["root.*"])
)
address_family = AddressFamily("root", {"not_me": ("root/BUILD", TargetAdaptor())})
targets = self._resolve_addresses(
address_specs, address_family, self._snapshot(), self._address_mapper()
)
assert len(targets.dependencies) == 0
def hydrate_target(target_adaptor_container):
target_adaptor = target_adaptor_container.value
"""Construct a HydratedTarget from a TargetAdaptor and hydrated versions of its adapted fields."""
# Hydrate the fields of the adaptor and re-construct it.
hydrated_fields = yield [Get(HydratedField, HydrateableField, fa)
for fa in target_adaptor.field_adaptors]
kwargs = target_adaptor.kwargs()
for field in hydrated_fields:
kwargs[field.name] = field.value
yield HydratedTarget(target_adaptor.address,
TargetAdaptor(**kwargs),
tuple(target_adaptor.dependencies))
def hydrate_target(target_adaptor):
"""Construct a HydratedTarget from a TargetAdaptor and hydrated versions of its adapted fields."""
# Hydrate the fields of the adaptor and re-construct it.
hydrated_fields = yield [
(Get(HydratedField, BundlesField, fa)
if type(fa) is BundlesField else Get(HydratedField, SourcesField, fa))
for fa in target_adaptor.field_adaptors
]
kwargs = target_adaptor.kwargs()
for field in hydrated_fields:
kwargs[field.name] = field.value
yield HydratedTarget(target_adaptor.address, TargetAdaptor(**kwargs),
tuple(target_adaptor.dependencies))
def test_exclude_pattern_with_single_address(self):
"""Test that single address targets are filtered based on exclude patterns."""
specs = Specs([SingleAddress('root', 'not_me')], exclude_patterns=tuple(['root.*']))
address_family = AddressFamily('root',
{
'not_me': ('root/BUILD', TargetAdaptor()),
}
)
targets = self._resolve_build_file_addresses(
specs, address_family, self._snapshot(), self._address_mapper())
self.assertEqual(len(targets.dependencies), 0)
def mock_target(
self,
sources: TargetSources,
*,
origin: Optional[OriginSpec] = None,
include_sources: bool = True,
type_alias: Optional[str] = None,
) -> TargetAdaptorWithOrigin:
sources_field = Mock()
sources_field.snapshot = self.make_snapshot_of_empty_files(
sources.source_file_absolute_paths if include_sources else []
)
adaptor = TargetAdaptor(
address=Address.parse(f"{sources.source_root}:lib"),
type_alias=type_alias,
sources=sources_field,
)
if origin is None:
origin = SiblingAddresses(sources.source_root)
return TargetAdaptorWithOrigin(adaptor, origin)
def run_black(
self,
source_files: List[FileContent],
*,
config: Optional[str] = None,
passthrough_args: Optional[Sequence[str]] = None,
) -> Tuple[LintResult, FmtResult]:
if config is not None:
self.create_file(relpath="pyproject.toml", contents=config)
input_snapshot = self.request_single_product(
Snapshot, InputFilesContent(source_files))
target = FormattablePythonTarget(
TargetAdaptor(
sources=EagerFilesetWithSpec('test', {'globs': []},
snapshot=input_snapshot),
address=Address.parse("test:target"),
))
black_subsystem = global_subsystem_instance(
Black,
options={
Black.options_scope: {
"config": "pyproject.toml" if config else None,
"args": passthrough_args or [],
}
})
black_setup = self.request_single_product(
BlackSetup,
Params(
black_subsystem,
PythonNativeCode.global_instance(),
PythonSetup.global_instance(),
SubprocessEnvironment.global_instance(),
))
fmt_and_lint_params = Params(target, black_setup,
PythonSetup.global_instance(),
SubprocessEnvironment.global_instance())
lint_result = self.request_single_product(LintResult,
fmt_and_lint_params)
fmt_result = self.request_single_product(FmtResult,
fmt_and_lint_params)
return lint_result, fmt_result
def run_isort(
self,
source_files: List[FileContent],
*,
config: Optional[str] = None,
passthrough_args: Optional[Sequence[str]] = None,
skip: bool = False,
) -> Tuple[LintResult, FmtResult]:
if config is not None:
self.create_file(relpath=".isort.cfg", contents=config)
input_snapshot = self.request_single_product(Snapshot, InputFilesContent(source_files))
target_adaptor = TargetAdaptor(
sources=EagerFilesetWithSpec('test', {'globs': []}, snapshot=input_snapshot),
address=Address.parse("test:target"),
)
lint_target = IsortTarget(target_adaptor)
fmt_target = IsortTarget(target_adaptor, prior_formatter_result_digest=input_snapshot.directory_digest)
isort_subsystem = global_subsystem_instance(
Isort, options={Isort.options_scope: {
"config": [".isort.cfg"] if config else None,
"args": passthrough_args or [],
"skip": skip,
}}
)
python_subsystems = [
PythonNativeCode.global_instance(),
PythonSetup.global_instance(),
SubprocessEnvironment.global_instance(),
]
isort_setup = self.request_single_product(
IsortSetup, Params(isort_subsystem, *python_subsystems)
)
lint_result = self.request_single_product(
LintResult, Params(lint_target, isort_setup, *python_subsystems)
)
fmt_result = self.request_single_product(
FmtResult, Params(fmt_target, isort_setup, *python_subsystems)
)
return lint_result, fmt_result
def run_black_and_isort(
self,
source_files: List[FileContent],
) -> AggregatedFmtResults:
input_snapshot = self.request_single_product(Snapshot, InputFilesContent(source_files))
target = _ConcretePythonFormatTarget(
TargetAdaptor(
sources=EagerFilesetWithSpec('test', {'globs': []}, snapshot=input_snapshot),
address=Address.parse("test:target"),
),
)
results = self.request_single_product(
AggregatedFmtResults,
Params(
target,
create_options_bootstrapper(
args=[
"--backend-packages2=['pants.backend.python.lint.black', 'pants.backend.python.lint.isort']"
],
)
)
)
return results
def get_stripped_files_for_target(
*,
source_paths: Optional[List[str]],
type_alias: Optional[str] = None,
specified_sources: Optional[List[str]] = None,
) -> List[str]:
address = (Address(spec_path=PurePath(
source_paths[0]).parent.as_posix(),
target_name="target") if source_paths else
Address.parse("src/python/project:target"))
sources = Mock()
sources.snapshot = self.make_snapshot_of_empty_files(source_paths
or [])
specified_sources_snapshot = (
None if not specified_sources else
self.make_snapshot_of_empty_files(specified_sources))
return self.get_stripped_files(
LegacyStripTargetRequest(
TargetAdaptor(address=address,
type_alias=type_alias,
sources=sources),
specified_files_snapshot=specified_sources_snapshot,
))
def run_black_and_isort(
self,
source_files: List[FileContent],
*,
extra_args: Optional[List[str]] = None) -> LanguageFmtResults:
input_snapshot = self.request_single_product(
Snapshot, InputFilesContent(source_files))
adaptor = TargetAdaptor(
sources=EagerFilesetWithSpec("test", {"globs": []},
snapshot=input_snapshot),
address=Address.parse("test:target"),
)
origin = SingleAddress(directory="test", name="target")
formatters = PythonFormatters(
(TargetAdaptorWithOrigin(adaptor, origin), ))
args = [
"--backend-packages2=['pants.backend.python.lint.black', 'pants.backend.python.lint.isort']",
*(extra_args or []),
]
results = self.request_single_product(
LanguageFmtResults,
Params(formatters, create_options_bootstrapper(args=args)),
)
return results
def _make_target(self, address: str, **kwargs) -> TargetAdaptor:
return TargetAdaptor(address=Address.parse(address), **kwargs)
