18252174847

Committed 05 Oct 2025 01:36AM UTC coverage: 43.382% (-36.9%) from 80.261%

Build # 18252174847

Build Type

push

github

Committed by

web-flow

Commit Message

run tests on mac arm (#22717)

Just doing the minimal to pull forward the x86_64 pattern.

ref #20993

Run Details

25776 of 59416 relevant lines covered (43.38%)

1.3 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	3✔
4
5	import os	3✔
6	from collections.abc import Iterable	3✔
7	from dataclasses import dataclass	3✔
8
9	from pants.backend.javascript import nodejs_project	3✔
10	from pants.backend.javascript.nodejs_project import AllNodeJSProjects, NodeJSProject	3✔
11	from pants.backend.javascript.package_json import (	3✔
12	FirstPartyNodePackageTargets,
13	NodePackageNameField,
14	OwningNodePackageRequest,
15	PackageJsonSourceField,
16	find_owning_package,
17	)
18	from pants.backend.javascript.subsystems.nodejs import UserChosenNodeJSResolveAliases	3✔
19	from pants.build_graph.address import Address	3✔
20	from pants.engine.fs import PathGlobs	3✔
21	from pants.engine.internals.graph import resolve_target	3✔
22	from pants.engine.rules import Rule, collect_rules, implicitly, rule	3✔
23	from pants.engine.target import Target, WrappedTargetRequest	3✔
24	from pants.engine.unions import UnionRule	3✔
25	from pants.util.frozendict import FrozenDict	3✔
26
27
28	@dataclass(frozen=True)	3✔
29	class RequestNodeResolve:	3✔
30	address: Address	3✔
31
32
33	@dataclass(frozen=True)	3✔
34	class ChosenNodeResolve:	3✔
35	project: NodeJSProject	3✔
36
37	@property	3✔
38	def resolve_name(self) -> str:	3✔
39	return self.project.default_resolve_name	×
40
41	@property	3✔
42	def file_path(self) -> str:	3✔
43	return os.path.join(self.project.root_dir, self.project.lockfile_name)	×
44
45	def get_lockfile_glob(self) -> PathGlobs:	3✔
46	return PathGlobs([self.file_path])	×
47
48
49	async def _get_node_package_json_directory(req: RequestNodeResolve) -> str:	3✔
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	3✔
66	async def resolve_for_package(	3✔
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]):	3✔
75	pass	3✔
76
77
78	@rule	3✔
79	async def resolve_to_projects(	3✔
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]):	3✔
91	pass	3✔
92
93
94	@rule	3✔
95	async def resolve_to_first_party_node_package(	3✔
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]:	3✔
105	return [collect_rules(), nodejs_project.rules()]	3✔

pantsbuild / pants / 18252174847

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