25350464842

Committed 05 May 2026 12:06AM UTC coverage: 92.923% (-0.002%) from 92.925%

Build # 25350464842

Build Type

push

github

Committed by

web-flow

Commit Message

Differentiate types of git changes (Cherry-pick of #23309) (#23313)

When interrogating git to compute `--changed-*`
specs, we now record the type of git change 
(add, modify, delete).

We don't yet do anything with this information.
This is initial work towards fixing #17512/#23240.

Co-authored-by: Benjy Weinberger <benjyw@gmail.com>

Coverage Stats

54 of 59 new or added lines in 4 files covered. (91.53%)

1 existing line in 1 file now uncovered.

91716 of 98701 relevant lines covered (92.92%)

4.04 hits per line

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

73.61

/src/python/pants/vcs/changed.py

# Copyright 2016 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).

from __future__ import annotations

from collections.abc import Iterable
from dataclasses import dataclass
from enum import Enum

from pants.backend.project_info import dependents
from pants.backend.project_info.dependents import DependentsRequest, find_dependents
from pants.base.build_environment import get_buildroot
from pants.engine.addresses import Address, Addresses
from pants.engine.collection import Collection
from pants.engine.internals.graph import OwnersRequest, find_owners, resolve_unexpanded_targets
from pants.engine.internals.mapper import SpecsFilter
from pants.engine.rules import collect_rules, implicitly, rule
from pants.option.option_types import EnumOption, StrOption
from pants.option.option_value_container import OptionValueContainer
from pants.option.subsystem import Subsystem
from pants.util.docutil import doc_url
from pants.util.frozendict import FrozenDict
from pants.util.ordered_set import FrozenOrderedSet
from pants.util.strutil import help_text
from pants.vcs.git import GitWorktree
from pants.vcs.hunk import Hunk, TextBlocks


class DependentsOption(Enum):
    NONE = "none"
    DIRECT = "direct"
    TRANSITIVE = "transitive"


@dataclass(frozen=True)
class ChangedRequest:
    sources: tuple[str, ...]
    sources_blocks: FrozenDict[str, TextBlocks]
    dependents: DependentsOption


class ChangedAddresses(Collection[Address]):
    pass


@rule
async def find_changed_owners(
    request: ChangedRequest,
    specs_filter: SpecsFilter,
) -> ChangedAddresses:
    no_dependents = request.dependents == DependentsOption.NONE
    owners = await find_owners(
        OwnersRequest(
            request.sources,
            # If `--changed-dependents` is used, we cannot eagerly filter out root targets. We
            # need to first find their dependents, and only then should we filter. See
            # https://github.com/pantsbuild/pants/issues/15544
            filter_by_global_options=no_dependents,
            # Changing a BUILD file might impact the targets it defines.
            match_if_owning_build_file_included_in_sources=True,
            sources_blocks=request.sources_blocks,
        ),
        **implicitly(),
    )

    if no_dependents:
        return ChangedAddresses(owners)

    # See https://github.com/pantsbuild/pants/issues/15313. We filter out target generators because
    # they are not useful as aliases for their generated targets in the context of
    # `--changed-since`. Including them makes it look like all sibling targets from the same
    # target generator have also changed.
    #
    # However, we also must be careful to preserve if target generators are direct owners, which
    # happens when a generated file is deleted.
    owner_target_generators = FrozenOrderedSet(
        addr.maybe_convert_to_target_generator() for addr in owners if addr.is_generated_target
    )
    dependents = await find_dependents(
        DependentsRequest(
            owners,
            transitive=request.dependents == DependentsOption.TRANSITIVE,
            include_roots=False,
        ),
        **implicitly(),
    )
    result = FrozenOrderedSet(owners) | (dependents - owner_target_generators)
    if specs_filter.is_specified:
        # Finally, we must now filter out the result to only include what matches our tags, as the
        # last step of https://github.com/pantsbuild/pants/issues/15544.
        #
        # Note that we use `UnexpandedTargets` rather than `Targets` or `FilteredTargets` so that
        # we preserve target generators.
        result_as_tgts = await resolve_unexpanded_targets(Addresses(result))
        result = FrozenOrderedSet(
            tgt.address for tgt in result_as_tgts if specs_filter.matches(tgt)
        )

    return ChangedAddresses(result)


@dataclass(frozen=True)
class ChangedOptions:
    """A wrapper for the options from the `Changed` Subsystem.

    This is necessary because parsing of these options happens before conventional subsystems are
    configured, so the normal mechanisms like `Subsystem.rules()` would not work properly.
    """

    since: str | None
    diffspec: str | None
    dependents: DependentsOption

    @classmethod
    def from_options(cls, options: OptionValueContainer) -> ChangedOptions:
        return cls(options.since, options.diffspec, options.dependents)

    @property
    def provided(self) -> bool:
        return bool(self.since) or bool(self.diffspec)

    def changed_files(self, git_worktree: GitWorktree) -> set[str]:
        """Determines the files changed according to SCM/workspace and options."""
        if self.diffspec:
            return {
                cf.path
                for cf in git_worktree.changes_in(self.diffspec, relative_to=get_buildroot())
            }

        changes_since = self.since or git_worktree.current_rev_identifier
        return {
            cf.path
            for cf in git_worktree.changed_files(
                from_commit=changes_since,
                include_untracked=True,
                relative_to=get_buildroot(),
            )
        }

    def diff_hunks(
        self, git_worktree: GitWorktree, paths: Iterable[str]
    ) -> dict[str, tuple[Hunk, ...]]:
        """Determines the unified diff hunks changed according to SCM/workspace and options.

        More info on unified diff: https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html
        """
        changes_since = self.since or git_worktree.current_rev_identifier
        return git_worktree.changed_files_lines(
            paths,
            from_commit=changes_since,
            include_untracked=True,
            relative_to=get_buildroot(),
        )


class Changed(Subsystem):
    options_scope = "changed"
    help = help_text(
        f"""
        Tell Pants to detect what files and targets have changed from Git.

        See {doc_url("docs/using-pants/advanced-target-selection")}.
        """
    )

    since = StrOption(
        default=None,
        help="Calculate changes since this Git spec (commit range/SHA/ref).",
    )
    diffspec = StrOption(
        default=None,
        help="Calculate changes contained within a given Git spec (commit range/SHA/ref).",
    )
    dependents = EnumOption(
        default=DependentsOption.NONE,
        help="Include direct or transitive dependents of changed targets.",
    )


def rules():
    return [*collect_rules(), *dependents.rules()]

1	# Copyright 2016 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3
4	from __future__ import annotations	12✔
5
6	from collections.abc import Iterable	12✔
7	from dataclasses import dataclass	12✔
8	from enum import Enum	12✔
9
10	from pants.backend.project_info import dependents	12✔
11	from pants.backend.project_info.dependents import DependentsRequest, find_dependents	12✔
12	from pants.base.build_environment import get_buildroot	12✔
13	from pants.engine.addresses import Address, Addresses	12✔
14	from pants.engine.collection import Collection	12✔
15	from pants.engine.internals.graph import OwnersRequest, find_owners, resolve_unexpanded_targets	12✔
16	from pants.engine.internals.mapper import SpecsFilter	12✔
17	from pants.engine.rules import collect_rules, implicitly, rule	12✔
18	from pants.option.option_types import EnumOption, StrOption	12✔
19	from pants.option.option_value_container import OptionValueContainer	12✔
20	from pants.option.subsystem import Subsystem	12✔
21	from pants.util.docutil import doc_url	12✔
22	from pants.util.frozendict import FrozenDict	12✔
23	from pants.util.ordered_set import FrozenOrderedSet	12✔
24	from pants.util.strutil import help_text	12✔
25	from pants.vcs.git import GitWorktree	12✔
26	from pants.vcs.hunk import Hunk, TextBlocks	12✔
27
28
29	class DependentsOption(Enum):	12✔
30	NONE = "none"	12✔
31	DIRECT = "direct"	12✔
32	TRANSITIVE = "transitive"	12✔
33
34
35	@dataclass(frozen=True)	12✔
36	class ChangedRequest:	12✔
37	sources: tuple[str, ...]	12✔
38	sources_blocks: FrozenDict[str, TextBlocks]	12✔
39	dependents: DependentsOption	12✔
40
41
42	class ChangedAddresses(Collection[Address]):	12✔
43	pass	12✔
44
45
46	@rule	12✔
47	async def find_changed_owners(	12✔
48	request: ChangedRequest,
49	specs_filter: SpecsFilter,
50	) -> ChangedAddresses:
51	no_dependents = request.dependents == DependentsOption.NONE	×
52	owners = await find_owners(	×
53	OwnersRequest(
54	request.sources,
55	# If `--changed-dependents` is used, we cannot eagerly filter out root targets. We
56	# need to first find their dependents, and only then should we filter. See
57	# https://github.com/pantsbuild/pants/issues/15544
58	filter_by_global_options=no_dependents,
59	# Changing a BUILD file might impact the targets it defines.
60	match_if_owning_build_file_included_in_sources=True,
61	sources_blocks=request.sources_blocks,
62	),
63	**implicitly(),
64	)
65
66	if no_dependents:	×
67	return ChangedAddresses(owners)	×
68
69	# See https://github.com/pantsbuild/pants/issues/15313. We filter out target generators because
70	# they are not useful as aliases for their generated targets in the context of
71	# `--changed-since`. Including them makes it look like all sibling targets from the same
72	# target generator have also changed.
73	#
74	# However, we also must be careful to preserve if target generators are direct owners, which
75	# happens when a generated file is deleted.
76	owner_target_generators = FrozenOrderedSet(	×
77	addr.maybe_convert_to_target_generator() for addr in owners if addr.is_generated_target
78	)
79	dependents = await find_dependents(	×
80	DependentsRequest(
81	owners,
82	transitive=request.dependents == DependentsOption.TRANSITIVE,
83	include_roots=False,
84	),
85	**implicitly(),
86	)
87	result = FrozenOrderedSet(owners) \| (dependents - owner_target_generators)	×
88	if specs_filter.is_specified:	×
89	# Finally, we must now filter out the result to only include what matches our tags, as the
90	# last step of https://github.com/pantsbuild/pants/issues/15544.
91	#
92	# Note that we use `UnexpandedTargets` rather than `Targets` or `FilteredTargets` so that
93	# we preserve target generators.
94	result_as_tgts = await resolve_unexpanded_targets(Addresses(result))	×
95	result = FrozenOrderedSet(	×
96	tgt.address for tgt in result_as_tgts if specs_filter.matches(tgt)
97	)
98
99	return ChangedAddresses(result)	×
100
101
102	@dataclass(frozen=True)	12✔
103	class ChangedOptions:	12✔
104	"""A wrapper for the options from the `Changed` Subsystem.
105
106	This is necessary because parsing of these options happens before conventional subsystems are
107	configured, so the normal mechanisms like `Subsystem.rules()` would not work properly.
108	"""
109
110	since: str \| None	12✔
111	diffspec: str \| None	12✔
112	dependents: DependentsOption	12✔
113
114	@classmethod	12✔
115	def from_options(cls, options: OptionValueContainer) -> ChangedOptions:	12✔
116	return cls(options.since, options.diffspec, options.dependents)	×
117
118	@property	12✔
119	def provided(self) -> bool:	12✔
120	return bool(self.since) or bool(self.diffspec)	×
121
122	def changed_files(self, git_worktree: GitWorktree) -> set[str]:	12✔
123	"""Determines the files changed according to SCM/workspace and options."""
124	if self.diffspec:	×
NEW 125	return {	×
126	cf.path
127	for cf in git_worktree.changes_in(self.diffspec, relative_to=get_buildroot())
128	}
129
130	changes_since = self.since or git_worktree.current_rev_identifier	×
NEW 131	return {	×
132	cf.path
133	for cf in git_worktree.changed_files(
134	from_commit=changes_since,
135	include_untracked=True,
136	relative_to=get_buildroot(),
137	)
138	}
139
140	def diff_hunks(	12✔
141	self, git_worktree: GitWorktree, paths: Iterable[str]
142	) -> dict[str, tuple[Hunk, ...]]:
143	"""Determines the unified diff hunks changed according to SCM/workspace and options.
144
145	More info on unified diff: https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html
146	"""
147	changes_since = self.since or git_worktree.current_rev_identifier	×
148	return git_worktree.changed_files_lines(	×
149	paths,
150	from_commit=changes_since,
151	include_untracked=True,
152	relative_to=get_buildroot(),
153	)
154
155
156	class Changed(Subsystem):	12✔
157	options_scope = "changed"	12✔
158	help = help_text(	12✔
159	f"""
160	Tell Pants to detect what files and targets have changed from Git.
161
162	See {doc_url("docs/using-pants/advanced-target-selection")}.
163	"""
164	)
165
166	since = StrOption(	12✔
167	default=None,
168	help="Calculate changes since this Git spec (commit range/SHA/ref).",
169	)
170	diffspec = StrOption(	12✔
171	default=None,
172	help="Calculate changes contained within a given Git spec (commit range/SHA/ref).",
173	)
174	dependents = EnumOption(	12✔
175	default=DependentsOption.NONE,
176	help="Include direct or transitive dependents of changed targets.",
177	)
178
179
180	def rules():	12✔
181	return [collect_rules(), dependents.rules()]	12✔

pantsbuild / pants / 25350464842

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