def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
preserve_tmpdirs=True,
rules=[
*classpath.rules(),
*config_files.rules(),
*coursier_fetch_rules(),
*coursier_setup_rules(),
*jdk_util_rules(),
*non_jvm_dependencies_rules(),
*scalac_rules(),
*scalatest_rules(),
*scala_target_types_rules(),
*scalac_rules(),
*source_files.rules(),
*system_binaries.rules(),
*target_types_rules(),
*util_rules(),
QueryRule(CoarsenedTargets, (Addresses, )),
QueryRule(TestResult, (ScalatestTestFieldSet, )),
QueryRule(Scalatest, ()),
],
target_types=[
JvmArtifactTarget,
FileTarget,
FilesGeneratorTarget,
RelocatedFiles,
ScalaSourcesGeneratorTarget,
ScalatestTestsGeneratorTarget,
],
)
rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV)
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*scala_lockfile_rules(),
*scala_dep_inf_rules.rules(),
*jdk_rules.rules(),
*coursier_fetch_rules(),
*coursier_jvm_tool_rules(),
*lockfile.rules(),
*coursier_setup_rules(),
*external_tool.rules(),
*source_files.rules(),
*util_rules(),
*system_binaries.rules(),
*graph.rules(),
*build_files.rules(),
*target_types.rules(),
QueryRule(UserGenerateLockfiles, (RequestedJVMUserResolveNames,)),
QueryRule(GenerateLockfileResult, (GenerateJvmLockfile,)),
],
target_types=[JvmArtifactTarget, ScalaSourceTarget, ScalaSourcesGeneratorTarget],
)
rule_runner.set_options(
[
'--scala-version-for-resolve={"foo":"2.13.8"}',
'--jvm-resolves={"foo": "foo/foo.lock"}',
],
env_inherit={"PATH"},
)
return rule_runner
def rules():
return [
# goals
*check.rules(),
*export.rules(),
*fmt.rules(),
*generate_lockfiles.rules(),
*lint.rules(),
*update_build_files.rules(),
*package.rules(),
*publish.rules(),
*repl.rules(),
*run.rules(),
*tailor.rules(),
*test.rules(),
*bsp_rules(),
# util_rules
*anonymous_telemetry.rules(),
*archive.rules(),
*config_files.rules(),
*distdir.rules(),
*external_tool.rules(),
*git.rules(),
*source_files.rules(),
*source_root.rules(),
*stats_aggregator.rules(),
*stripped_source_files.rules(),
*subprocess_environment.rules(),
*system_binaries.rules(),
*target_type_rules(),
]
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*system_binaries.rules(),
*config_files.rules(),
*jvm_tool.rules(),
*source_files.rules(),
*javac_rules(),
*javac_check_rules(),
*util_rules(),
*target_types_rules(),
*lockfile.rules(),
*jdk_rules.rules(),
*java_dep_inf_rules(),
*source_files.rules(),
*testutil.rules(),
QueryRule(CheckResults, (JavacCheckRequest, )),
QueryRule(ClasspathEntry, (CompileJavaSourceRequest, )),
QueryRule(CoarsenedTargets, (Addresses, )),
QueryRule(FallibleClasspathEntry, (CompileJavaSourceRequest, )),
QueryRule(RenderedClasspath, (CompileJavaSourceRequest, )),
],
target_types=[JavaSourcesGeneratorTarget, JvmArtifactTarget],
)
rule_runner.set_options([], env_inherit=PYTHON_BOOTSTRAP_ENV)
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*config_files.rules(),
*jvm_tool.rules(),
*java_dep_inference_rules(),
*java_target_rules(),
*java_util_rules(),
*javac_rules(),
*java_symbol_mapper.rules(),
*source_files.rules(),
*scala_parser.rules(),
*scala_symbol_mapper.rules(),
*scala_dep_inference_rules.rules(),
*scala_target_types.rules(),
*system_binaries.rules(),
*util_rules(),
QueryRule(Addresses, (DependenciesRequest, )),
],
target_types=[
JavaSourcesGeneratorTarget,
JavaSourceTarget,
ScalaSourcesGeneratorTarget,
ScalaSourceTarget,
],
)
rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV)
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*coursier_fetch_rules(),
*coursier_setup_rules(),
*config_files.rules(),
*jvm_tool.rules(),
*system_binaries.rules(),
*jdk_rules.rules(),
*kotlin_check_rules(),
*kotlinc_rules(),
*kotlinc_plugins.rules(),
*kotlin_dep_inf_rules(),
*source_files.rules(),
*target_types_rules(),
*testutil.rules(),
*util_rules(),
QueryRule(CheckResults, (KotlincCheckRequest, )),
QueryRule(CoarsenedTargets, (Addresses, )),
QueryRule(FallibleClasspathEntry, (CompileKotlinSourceRequest, )),
QueryRule(RenderedClasspath, (CompileKotlinSourceRequest, )),
QueryRule(ClasspathEntry, (CompileKotlinSourceRequest, )),
],
target_types=[
JvmArtifactTarget, KotlinSourcesGeneratorTarget,
KotlincPluginTarget
],
)
rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV)
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*config_files.rules(),
*jvm_tool.rules(),
*dep_inference_rules(),
*java_target_rules(),
*java_util_rules(),
*javac_rules(),
*source_files.rules(),
*system_binaries.rules(),
*util_rules(),
QueryRule(Addresses, [DependenciesRequest]),
QueryRule(ThirdPartySymbolMapping, []),
],
objects={"parametrize": Parametrize},
target_types=[
JavaSourceTarget,
JavaSourcesGeneratorTarget,
JunitTestsGeneratorTarget,
JvmArtifactTarget,
],
)
rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV)
return rule_runner
def rules():
return [
*collect_rules(),
*system_binaries.rules(),
QueryRule(RenderedClasspath, (Classpath, )),
QueryRule(RenderedClasspath, (ClasspathEntry, )),
QueryRule(CoarsenedTargets, (Addresses, )),
]
def rule_runner() -> RuleRunner:
return RuleRunner(rules=[
*system_binaries.rules(),
python_binary_version,
QueryRule(PythonBinaryVersion, []),
QueryRule(BinaryPaths, [BinaryPathRequest]),
QueryRule(BinaryShims, [BinaryShimsRequest]),
QueryRule(DigestContents, [Digest]),
])
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*archive.rules(),
*system_binaries.rules(),
QueryRule(Digest, [CreateArchive]),
QueryRule(ExtractedArchive, [Digest]),
],
)
def test_python_interpreter_search_path_file_entries() -> None:
rule_runner = RuleRunner(rules=[
*system_binaries.rules(),
QueryRule(PythonBinary, input_types=())
])
current_python = os.path.realpath(sys.executable)
rule_runner.set_options(args=[
f"--python-bootstrap-search-path=[{current_python!r}]",
f"--python-bootstrap-names=[{os.path.basename(current_python)!r}]",
])
python_binary = rule_runner.request(PythonBinary, inputs=())
assert current_python == python_binary.path
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(rules=[
*config_files.rules(),
*source_files.rules(),
*coursier_setup_rules(),
*coursier_fetch_rules(),
*external_tool_rules(),
*util_rules(),
*jdk_rules(),
*system_binaries.rules(),
QueryRule(BashBinary, ()),
QueryRule(InternalJdk, ()),
QueryRule(ProcessResult, (JvmProcess, )),
], )
rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV)
return rule_runner
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 [
*kotlinc.rules(),
*kotlinc_plugins.rules(),
*check.rules(),
*tailor.rules(),
*classpath.rules(),
*lockfile.rules(),
*coursier_fetch.rules(),
*coursier_setup.rules(),
*dep_inf_rules(),
*jvm_util_rules.rules(),
*jdk_rules.rules(),
*target_types_rules(),
*jvm_tool.rules(),
*resources.rules(),
*system_binaries.rules(),
*source_files.rules(),
*deploy_jar.rules(),
*run_deploy_jar.rules(),
*war.rules(),
*jvm_junit_rules(),
*kotlin_junit_rules(),
]
def rules():
return [
*collect_rules(),
*system_binaries.rules(),
]
def setup_graph_extended(
build_configuration: BuildConfiguration,
execution_options: ExecutionOptions,
*,
executor: PyExecutor,
pants_ignore_patterns: list[str],
use_gitignore: bool,
local_store_options: LocalStoreOptions,
local_execution_root_dir: str,
named_caches_dir: str,
use_deprecated_python_macros: bool,
ca_certs_path: str | None = None,
build_root: str | None = None,
include_trace_on_error: bool = True,
engine_visualize_to: str | None = None,
watch_filesystem: bool = True,
) -> GraphScheduler:
build_root_path = build_root or get_buildroot()
rules = build_configuration.rules
union_membership: UnionMembership
registered_target_types = RegisteredTargetTypes.create(
build_configuration.target_types)
execution_options = execution_options or DEFAULT_EXECUTION_OPTIONS
@rule
def parser_singleton() -> Parser:
return Parser(
build_root=build_root_path,
target_type_aliases=registered_target_types.aliases,
object_aliases=build_configuration.registered_aliases,
use_deprecated_python_macros=use_deprecated_python_macros,
)
@rule
def build_configuration_singleton() -> BuildConfiguration:
return build_configuration
@rule
def registered_target_types_singleton() -> RegisteredTargetTypes:
return registered_target_types
@rule
def union_membership_singleton() -> UnionMembership:
return union_membership
@rule
def build_root_singleton() -> BuildRoot:
return cast(BuildRoot, BuildRoot.instance)
# Create a Scheduler containing graph and filesystem rules, with no installed goals.
rules = FrozenOrderedSet((
*collect_rules(locals()),
*build_files.rules(),
*fs.rules(),
*environment.rules(),
*desktop.rules(),
*graph.rules(),
*options_parsing.rules(),
*process.rules(),
*system_binaries.rules(),
*platform.rules(),
*changed_rules(),
*streaming_workunit_handler_rules(),
*specs_calculator.rules(),
*rules,
))
goal_map = EngineInitializer._make_goal_map_from_rules(rules)
union_membership = UnionMembership.from_rules((
*build_configuration.union_rules,
*(r for r in rules if isinstance(r, UnionRule)),
))
rules = FrozenOrderedSet((
*rules,
# Install queries for each Goal.
*(QueryRule(goal_type, GraphSession.goal_param_types)
for goal_type in goal_map.values()),
# Install queries for each request/response pair used by the BSP support.
# Note: These are necessary because the BSP support is a built-in goal that makes
# synchronous requests into the engine.
*(QueryRule(impl.response_type, (impl.request_type, Workspace))
for impl in union_membership.get(BSPHandlerMapping)),
QueryRule(Snapshot, [PathGlobs]), # Used by the SchedulerService.
))
def ensure_absolute_path(v: str) -> str:
return Path(v).resolve().as_posix()
def ensure_optional_absolute_path(v: str | None) -> str | None:
if v is None:
return None
return ensure_absolute_path(v)
scheduler = Scheduler(
ignore_patterns=pants_ignore_patterns,
use_gitignore=use_gitignore,
build_root=build_root_path,
local_execution_root_dir=ensure_absolute_path(
local_execution_root_dir),
named_caches_dir=ensure_absolute_path(named_caches_dir),
ca_certs_path=ensure_optional_absolute_path(ca_certs_path),
rules=rules,
union_membership=union_membership,
executor=executor,
execution_options=execution_options,
local_store_options=local_store_options,
include_trace_on_error=include_trace_on_error,
visualize_to_dir=engine_visualize_to,
watch_filesystem=watch_filesystem,
)
return GraphScheduler(scheduler, goal_map)
def rules():
return (
*collect_rules(),
*pex_rules(),
*system_binaries.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(),
*subprocess_environment.rules(),
*system_binaries.rules(),
]
