19381742489

Committed 15 Nov 2025 12:52AM UTC coverage: 49.706% (-30.6%) from 80.29%

Build # 19381742489

Build Type

Pull #22890

github

Committed by

web-flow

Commit Message

Merge d961abf79 into 42e1ebd41

Pull Request Pull Request #22890: Updated all python subsystem constraints to 3.14

Run Details

4 of 5 new or added lines in 5 files covered. (80.0%)

14659 existing lines in 485 files now uncovered.

31583 of 63540 relevant lines covered (49.71%)

0.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.64

/src/python/pants/backend/javascript/resolve.py

# Copyright 2023 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from __future__ import annotations

import os
from collections.abc import Iterable
from dataclasses import dataclass

from pants.backend.javascript import nodejs_project
from pants.backend.javascript.nodejs_project import AllNodeJSProjects, NodeJSProject
from pants.backend.javascript.package_json import (
    FirstPartyNodePackageTargets,
    NodePackageNameField,
    OwningNodePackageRequest,
    PackageJsonSourceField,
    find_owning_package,
)
from pants.backend.javascript.subsystems.nodejs import UserChosenNodeJSResolveAliases
from pants.build_graph.address import Address
from pants.engine.fs import PathGlobs
from pants.engine.internals.graph import resolve_target
from pants.engine.rules import Rule, collect_rules, implicitly, rule
from pants.engine.target import Target, WrappedTargetRequest
from pants.engine.unions import UnionRule
from pants.util.frozendict import FrozenDict


@dataclass(frozen=True)
class RequestNodeResolve:
    address: Address


@dataclass(frozen=True)
class ChosenNodeResolve:
    project: NodeJSProject

    @property
    def resolve_name(self) -> str:
        return self.project.default_resolve_name

    @property
    def file_path(self) -> str:
        return os.path.join(self.project.root_dir, self.project.lockfile_name)

    def get_lockfile_glob(self) -> PathGlobs:
        return PathGlobs([self.file_path])


async def _get_node_package_json_directory(req: RequestNodeResolve) -> str:
    wrapped = await resolve_target(
        WrappedTargetRequest(req.address, description_of_origin="the `ChosenNodeResolve` rule"),
        **implicitly(),
    )
    target: Target | None
    if wrapped.target.has_field(PackageJsonSourceField) and wrapped.target.has_field(
        NodePackageNameField
    ):
        target = wrapped.target
    else:
        owning_pkg = await find_owning_package(OwningNodePackageRequest(wrapped.target.address))
        target = owning_pkg.ensure_owner()
    return os.path.dirname(target[PackageJsonSourceField].file_path)


@rule
async def resolve_for_package(
    req: RequestNodeResolve, all_projects: AllNodeJSProjects
) -> ChosenNodeResolve:
    directory = await _get_node_package_json_directory(req)
    project = all_projects.project_for_directory(directory)
    return ChosenNodeResolve(project)


class NodeJSProjectResolves(FrozenDict[str, NodeJSProject]):
    pass


@rule
async def resolve_to_projects(
    all_projects: AllNodeJSProjects, user_chosen_resolves: UserChosenNodeJSResolveAliases
) -> NodeJSProjectResolves:
    def get_name(project: NodeJSProject) -> str:
        return user_chosen_resolves.get(
            os.path.join(project.root_dir, project.lockfile_name), project.default_resolve_name
        )

    return NodeJSProjectResolves((get_name(project), project) for project in all_projects)


class FirstPartyNodePackageResolves(FrozenDict[str, Target]):
    pass


@rule
async def resolve_to_first_party_node_package(
    resolves: NodeJSProjectResolves, all_first_party: FirstPartyNodePackageTargets
) -> FirstPartyNodePackageResolves:
    by_dir = {first_party.residence_dir: first_party for first_party in all_first_party}
    return FirstPartyNodePackageResolves(
        (resolve, by_dir[project.root_dir]) for resolve, project in resolves.items()
    )


def rules() -> Iterable[Rule | UnionRule]:
    return [*collect_rules(), *nodejs_project.rules()]

1	# Copyright 2023 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3	from __future__ import annotations	2✔
4
5	import os	2✔
6	from collections.abc import Iterable	2✔
7	from dataclasses import dataclass	2✔
8
9	from pants.backend.javascript import nodejs_project	2✔
10	from pants.backend.javascript.nodejs_project import AllNodeJSProjects, NodeJSProject	2✔
11	from pants.backend.javascript.package_json import (	2✔
12	FirstPartyNodePackageTargets,
13	NodePackageNameField,
14	OwningNodePackageRequest,
15	PackageJsonSourceField,
16	find_owning_package,
17	)
18	from pants.backend.javascript.subsystems.nodejs import UserChosenNodeJSResolveAliases	2✔
19	from pants.build_graph.address import Address	2✔
20	from pants.engine.fs import PathGlobs	2✔
21	from pants.engine.internals.graph import resolve_target	2✔
22	from pants.engine.rules import Rule, collect_rules, implicitly, rule	2✔
23	from pants.engine.target import Target, WrappedTargetRequest	2✔
24	from pants.engine.unions import UnionRule	2✔
25	from pants.util.frozendict import FrozenDict	2✔
26
27
28	@dataclass(frozen=True)	2✔
29	class RequestNodeResolve:	2✔
30	address: Address	2✔
31
32
33	@dataclass(frozen=True)	2✔
34	class ChosenNodeResolve:	2✔
35	project: NodeJSProject	2✔
36
37	@property	2✔
38	def resolve_name(self) -> str:	2✔
UNCOV 39	return self.project.default_resolve_name	×
40
41	@property	2✔
42	def file_path(self) -> str:	2✔
UNCOV 43	return os.path.join(self.project.root_dir, self.project.lockfile_name)	×
44
45	def get_lockfile_glob(self) -> PathGlobs:	2✔
46	return PathGlobs([self.file_path])	×
47
48
49	async def _get_node_package_json_directory(req: RequestNodeResolve) -> str:	2✔
50	wrapped = await resolve_target(	×
51	WrappedTargetRequest(req.address, description_of_origin="the `ChosenNodeResolve` rule"),
52	**implicitly(),
53	)
54	target: Target \| None
55	if wrapped.target.has_field(PackageJsonSourceField) and wrapped.target.has_field(	×
56	NodePackageNameField
57	):
58	target = wrapped.target	×
59	else:
60	owning_pkg = await find_owning_package(OwningNodePackageRequest(wrapped.target.address))	×
61	target = owning_pkg.ensure_owner()	×
62	return os.path.dirname(target[PackageJsonSourceField].file_path)	×
63
64
65	@rule	2✔
66	async def resolve_for_package(	2✔
67	req: RequestNodeResolve, all_projects: AllNodeJSProjects
68	) -> ChosenNodeResolve:
69	directory = await _get_node_package_json_directory(req)	×
70	project = all_projects.project_for_directory(directory)	×
71	return ChosenNodeResolve(project)	×
72
73
74	class NodeJSProjectResolves(FrozenDict[str, NodeJSProject]):	2✔
75	pass	2✔
76
77
78	@rule	2✔
79	async def resolve_to_projects(	2✔
80	all_projects: AllNodeJSProjects, user_chosen_resolves: UserChosenNodeJSResolveAliases
81	) -> NodeJSProjectResolves:
82	def get_name(project: NodeJSProject) -> str:	×
83	return user_chosen_resolves.get(	×
84	os.path.join(project.root_dir, project.lockfile_name), project.default_resolve_name
85	)
86
87	return NodeJSProjectResolves((get_name(project), project) for project in all_projects)	×
88
89
90	class FirstPartyNodePackageResolves(FrozenDict[str, Target]):	2✔
91	pass	2✔
92
93
94	@rule	2✔
95	async def resolve_to_first_party_node_package(	2✔
96	resolves: NodeJSProjectResolves, all_first_party: FirstPartyNodePackageTargets
97	) -> FirstPartyNodePackageResolves:
98	by_dir = {first_party.residence_dir: first_party for first_party in all_first_party}	×
99	return FirstPartyNodePackageResolves(	×
100	(resolve, by_dir[project.root_dir]) for resolve, project in resolves.items()
101	)
102
103
104	def rules() -> Iterable[Rule \| UnionRule]:	2✔
105	return [collect_rules(), nodejs_project.rules()]	2✔

pantsbuild / pants / 19381742489

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous