def rule_runner():
rule_runner = RuleRunner(
rules=[
*war.rules(),
*jvm_tool.rules(),
*classpath.rules(),
*javac_rules(),
*jdk_rules.rules(),
*java_dep_inf_rules(),
*target_types_rules(),
*core_target_types_rules(),
*util_rules(),
*archive.rules(),
QueryRule(BuiltPackage, (PackageWarFileFieldSet,)),
],
target_types=[
JvmArtifactTarget,
JvmWarTarget,
FileTarget,
FilesGeneratorTarget,
RelocatedFiles,
],
)
rule_runner.set_options([], env_inherit=PYTHON_BOOTSTRAP_ENV)
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*archive.rules(),
*config_files.rules(),
*coursier_fetch_rules(),
*coursier_setup_rules(),
*external_tool_rules(),
*source_files.rules(),
*javac_rules(),
*javac_check_rules(),
*util_rules(),
*target_types_rules(),
*coursier_rules(),
*jdk_rules.rules(),
*java_dep_inf_rules(),
*source_files.rules(),
*testutil.rules(),
QueryRule(CheckResults, (JavacCheckRequest, )),
QueryRule(FallibleClasspathEntry, (CompileJavaSourceRequest, )),
QueryRule(ClasspathEntry, (CompileJavaSourceRequest, )),
QueryRule(CoarsenedTargets, (Addresses, )),
],
target_types=[
JvmDependencyLockfile, JavaSourcesGeneratorTarget, JvmArtifact
],
bootstrap_args=[
NAMED_RESOLVE_OPTIONS,
DEFAULT_RESOLVE_OPTION,
],
)
rule_runner.set_options(
args=[NAMED_RESOLVE_OPTIONS, DEFAULT_RESOLVE_OPTION],
env_inherit=PYTHON_BOOTSTRAP_ENV)
return rule_runner
def rules():
return [
# goals
*check.rules(),
*export.rules(),
*fmt.rules(),
*lint.rules(),
*update_build_files.rules(),
*package.rules(),
*publish.rules(),
*repl.rules(),
*run.rules(),
*tailor.rules(),
*test.rules(),
# util_rules
*anonymous_telemetry.rules(),
*archive.rules(),
*config_files.rules(),
*python_binaries.rules(),
*distdir.rules(),
*external_tool.rules(),
*pants_bin.rules(),
*source_files.rules(),
*source_root.rules(),
*stats_aggregator.rules(),
*stripped_source_files.rules(),
*subprocess_environment.rules(),
*target_type_rules(),
]
def rules():
return [
# goals
*fmt.rules(),
*lint.rules(),
*package.rules(),
*repl.rules(),
*run.rules(),
*test.rules(),
*typecheck.rules(),
*tailor.rules(),
# util_rules
*config_files.rules(),
*distdir.rules(),
*filter_empty_sources.rules(),
*pants_bin.rules(),
*source_files.rules(),
*stripped_source_files.rules(),
*archive.rules(),
*external_tool.rules(),
*subprocess_environment.rules(),
*source_root.rules(),
*target_type_rules(),
*anonymous_telemetry.rules(),
*stats_aggregator.rules(),
]
def rules(cls):
return (
*super().rules(),
*pex.rules(),
*external_tool.rules(),
*archive.rules(),
RootRule(PexRequest),
)
def rule_runner() -> RuleRunner:
return RuleRunner(rules=[
*pex.rules(),
*external_tool.rules(),
*archive.rules(),
QueryRule(Pex, [PexRequest]),
QueryRule(Process, [PexProcess]),
QueryRule(ProcessResult, [Process]),
])
def rules(cls):
return (
*super().rules(),
*protobuf_rules(),
*archive.rules(),
*determine_source_files.rules(),
*external_tool.rules(),
RootRule(GeneratePythonFromProtobufRequest),
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*archive.rules(),
*system_binaries.rules(),
QueryRule(Digest, [CreateArchive]),
QueryRule(ExtractedArchive, [Digest]),
],
)
def rules(cls):
return (
*super().rules(),
*pex.rules(),
*external_tool.rules(),
*archive.rules(),
QueryRule(Pex, (PexRequest, OptionsBootstrapper)),
QueryRule(Process, (PexProcess, OptionsBootstrapper)),
QueryRule(ProcessResult, (Process, )),
)
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(rules=[
*pex.rules(),
*external_tool.rules(),
*archive.rules(),
QueryRule(Pex, [PexRequest]),
QueryRule(ProcessResult, [PexProcess]),
])
rule_runner.set_options(
["--backend-packages=pants.backend.python"],
env_inherit={"PATH", "PYENV_ROOT", "HOME"},
)
return rule_runner
def rules(cls):
return (
*super().rules(),
*repl_rules(),
*python_repl.rules(),
*pex.rules(),
*archive.rules(),
*external_tool.rules(),
*python_sources.rules(),
*pex_from_targets.rules(),
*strip_source_roots.rules(),
*ancestor_files.rules(),
RootRule(PythonRepl),
)
def rules(cls):
return (
*super().rules(),
*repl_rules(),
*python_repl.rules(),
*pex.rules(),
*archive.rules(),
*external_tool.rules(),
*python_sources.rules(),
*pex_from_targets.rules(),
*stripped_source_files.rules(),
*ancestor_files.rules(),
QueryRule(Process, (PexProcess, OptionsBootstrapper)),
)
def rules(cls):
return (
*super().rules(),
*repl_rules(),
*python_repl.rules(),
*pex.rules(),
*download_pex_bin.rules(),
*archive.rules(),
*external_tool.rules(),
*importable_python_sources.rules(),
*pex_from_targets.rules(),
*python_native_code.rules(),
*strip_source_roots.rules(),
*subprocess_environment.rules(),
RootRule(PythonRepl),
)
def rules():
return [
# goals
*binary.rules(),
*fmt.rules(),
*lint.rules(),
*repl.rules(),
*run.rules(),
*test.rules(),
# util_rules
*determine_source_files.rules(),
*distdir.rules(),
*filter_empty_sources.rules(),
*strip_source_roots.rules(),
*archive.rules(),
*external_tool.rules(),
]
def test_relocated_relocated_files() -> None:
rule_runner = RuleRunner(
rules=[
*target_type_rules(),
*archive.rules(),
*source_files.rules(),
*system_binaries.rules(),
QueryRule(GeneratedSources, [RelocateFilesViaCodegenRequest]),
QueryRule(TransitiveTargets, [TransitiveTargetsRequest]),
QueryRule(SourceFiles, [SourceFilesRequest]),
],
target_types=[FilesGeneratorTarget, RelocatedFiles],
)
rule_runner.write_files({
"original_prefix/file.txt":
"",
"BUILD":
dedent("""\
files(name="original", sources=["original_prefix/file.txt"])
relocated_files(
name="relocated",
files_targets=[":original"],
src="original_prefix",
dest="intermediate_prefix",
)
relocated_files(
name="double_relocated",
files_targets=[":relocated"],
src="intermediate_prefix",
dest="final_prefix",
)
"""),
})
tgt = rule_runner.get_target(Address("", target_name="double_relocated"))
result = rule_runner.request(
GeneratedSources,
[RelocateFilesViaCodegenRequest(EMPTY_SNAPSHOT, tgt)])
assert result.snapshot.files == ("final_prefix/file.txt", )
def rules():
return [
# goals
*binary.rules(),
*fmt.rules(),
*lint.rules(),
*repl.rules(),
*run.rules(),
*test.rules(),
*typecheck.rules(),
# util_rules
*distdir.rules(),
*filter_empty_sources.rules(),
*pants_bin.rules(),
*source_files.rules(),
*stripped_source_files.rules(),
*archive.rules(),
*external_tool.rules(),
*source_root.rules(),
]
def rules():
return [
*javac.rules(),
*check.rules(),
*classpath.rules(),
*junit.rules(),
*deploy_jar.rules(),
*lockfile.rules(),
*coursier_fetch.rules(),
*java_parser.rules(),
*resources.rules(),
*symbol_mapper.rules(),
*dependency_inference_rules.rules(),
*tailor.rules(),
*jvm_util_rules.rules(),
*jdk_rules.rules(),
*target_types_rules(),
*jvm_tool.rules(),
*run_deploy_jar.rules(),
*war_rules(),
*java_bsp_rules.rules(),
*archive.rules(),
]
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*archive.rules(),
*shell_command_rules(),
*source_files.rules(),
*core_target_type_rules(),
QueryRule(GeneratedSources,
[GenerateFilesFromShellCommandRequest]),
QueryRule(Process, [ShellCommandProcessRequest]),
QueryRule(RunRequest, [RunShellCommand]),
QueryRule(SourceFiles, [SourceFilesRequest]),
QueryRule(TransitiveTargets, [TransitiveTargetsRequest]),
],
target_types=[
ShellCommandTarget,
ShellCommandRunTarget,
ShellSourcesGeneratorTarget,
ArchiveTarget,
FilesGeneratorTarget,
],
)
rule_runner.set_options([], env_inherit={"PATH"})
return rule_runner
def rules(cls):
return [*super().rules(), *archive.rules(), *external_tool.rules()]
def rules():
return (*collect_rules(), *archive.rules())
def test_relocated_files() -> None:
rule_runner = RuleRunner(
rules=[
*target_type_rules(),
*archive.rules(),
*source_files.rules(),
*system_binaries.rules(),
QueryRule(GeneratedSources, [RelocateFilesViaCodegenRequest]),
QueryRule(TransitiveTargets, [TransitiveTargetsRequest]),
QueryRule(SourceFiles, [SourceFilesRequest]),
],
target_types=[FilesGeneratorTarget, RelocatedFiles],
)
def assert_prefix_mapping(
*,
original: str,
src: str,
dest: str,
expected: str,
) -> None:
rule_runner.write_files({
original:
"",
"BUILD":
dedent(f"""\
files(name="original", sources=[{repr(original)}])
relocated_files(
name="relocated",
files_targets=[":original"],
src={repr(src)},
dest={repr(dest)},
)
"""),
})
tgt = rule_runner.get_target(Address("", target_name="relocated"))
result = rule_runner.request(
GeneratedSources,
[RelocateFilesViaCodegenRequest(EMPTY_SNAPSHOT, tgt)])
assert result.snapshot.files == (expected, )
# We also ensure that when looking at the transitive dependencies of the `relocated_files`
# target and then getting all the code of that closure, we only end up with the relocated
# files. If we naively marked the original files targets as a typical `Dependencies` field,
# we would hit this issue.
transitive_targets = rule_runner.request(
TransitiveTargets, [TransitiveTargetsRequest([tgt.address])])
all_sources = rule_runner.request(
SourceFiles,
[
SourceFilesRequest(
(tgt.get(SourcesField)
for tgt in transitive_targets.closure),
enable_codegen=True,
for_sources_types=(FileSourceField, ),
)
],
)
assert all_sources.snapshot.files == (expected, )
# No-op.
assert_prefix_mapping(original="old_prefix/f.ext",
src="",
dest="",
expected="old_prefix/f.ext")
assert_prefix_mapping(
original="old_prefix/f.ext",
src="old_prefix",
dest="old_prefix",
expected="old_prefix/f.ext",
)
# Remove prefix.
assert_prefix_mapping(original="old_prefix/f.ext",
src="old_prefix",
dest="",
expected="f.ext")
assert_prefix_mapping(original="old_prefix/subdir/f.ext",
src="old_prefix",
dest="",
expected="subdir/f.ext")
# Add prefix.
assert_prefix_mapping(original="f.ext",
src="",
dest="new_prefix",
expected="new_prefix/f.ext")
assert_prefix_mapping(
original="old_prefix/f.ext",
src="",
dest="new_prefix",
expected="new_prefix/old_prefix/f.ext",
)
# Replace prefix.
assert_prefix_mapping(
original="old_prefix/f.ext",
src="old_prefix",
dest="new_prefix",
expected="new_prefix/f.ext",
)
assert_prefix_mapping(
original="old_prefix/f.ext",
src="old_prefix",
dest="new_prefix/subdir",
expected="new_prefix/subdir/f.ext",
)
# Replace prefix, but preserve a common start.
assert_prefix_mapping(
original="common_prefix/foo/f.ext",
src="common_prefix/foo",
dest="common_prefix/bar",
expected="common_prefix/bar/f.ext",
)
assert_prefix_mapping(
original="common_prefix/subdir/f.ext",
src="common_prefix/subdir",
dest="common_prefix",
expected="common_prefix/f.ext",
)
def rules():
return [
*collect_rules(),
*archive.rules(),
QueryRule(RenderedClasspath, (Digest, )),
]
