yore ¤

def __call__(self) -> int:
    """Check Yore comments."""
    ok = True
    paths = self.paths or [Path(".")]
    for path in paths:
        for comment in yield_path_comments(path, prefix=self.prefix):
            ok &= comment.check(bump=self.bump, eol_within=self.eol_within, bol_within=self.bol_within)
    return 0 if ok else 1

def __call__(self) -> int:
    """Diff Yore comments."""
    lines = self._diff_paths(self.paths or [Path(".")])
    if self.highlight:
        process = subprocess.Popen(self.highlight, shell=True, text=True, stdin=subprocess.PIPE)  # noqa: S602
        for line in lines:
            process.stdin.write(line)  # type: ignore[union-attr]
        process.stdin.close()  # type: ignore[union-attr]
        process.wait()
        return int(process.returncode)
    for line in lines:
        print(line, end="")
    return 0

def __call__(self) -> int:
    """Fix Yore comments."""
    paths = self.paths or [Path(".")]
    for path in paths:
        if path.is_file():
            self._fix(path)
        else:
            for file in yield_files(path):
                self._fix(file)
    return 0

@classmethod
def from_data(
    cls,
    data: An[Mapping[str, Any], Doc("Data to load configuration from.")],
) -> An[Config, Doc("Loaded configuration.")]:
    """Load configuration from data."""
    # Check for unknown configuration keys.
    field_keys = [field.default.key for field in fields(cls)]  # type: ignore[union-attr]
    unknown_keys = []
    for top_level_key, top_level_value in data.items():
        if isinstance(top_level_value, dict):
            for key in top_level_value.keys():  # noqa: SIM118
                final_key = f"{top_level_key}.{key}"
                if final_key not in field_keys:
                    unknown_keys.append(final_key)
        elif top_level_key not in field_keys:
            unknown_keys.append(top_level_key)
    if unknown_keys:
        _logger.warning(f"Unknown configuration keys: {', '.join(unknown_keys)}")

    # Create a configuration instance.
    return cls(
        **{
            field.name: cls._get(
                data,
                *field.default.key.split("."),  # type: ignore[union-attr]
                default=field.default,  # type: ignore[arg-type]
                transform=getattr(cls, field.default.transform or "", None),  # type: ignore[union-attr]
            )
            for field in fields(cls)
        },
    )

@classmethod
def from_default_locations(cls) -> An[Config, Doc("Loaded configuration.")]:
    """Load configuration from the default locations."""
    paths = ("config/yore.toml", "yore.toml", "pyproject.toml")
    cwd = Path.cwd()
    while True:
        for path in paths:
            if (cwd / path).exists():
                if path == "pyproject.toml":
                    return cls.from_pyproject(cwd / path)
                return cls.from_file(cwd / path)
        if cwd == cwd.parent:
            break
        cwd = cwd.parent
    return cls()

@classmethod
def from_file(
    cls,
    path: An[str | Path, Doc("Path to the configuration file.")],
) -> An[Config, Doc("Loaded configuration.")]:
    """Load configuration from a file."""
    with open(path, "rb") as file:
        return cls.from_data(tomllib.load(file))

@classmethod
def from_pyproject(
    cls,
    path: An[str | Path, Doc("Path to the pyproject.toml file.")],
) -> An[Config, Doc("Loaded configuration.")]:
    """Load configuration from pyproject.toml."""
    with open(path, "rb") as file:
        return cls.from_data(tomllib.load(file).get("tool", {}).get("yore", {}))

def __bool__(self) -> bool:
    """An unset value always evaluates to False."""
    return False

def check(
    self,
    *,
    bump: str | None = None,
    eol_within: TimeDelta | None = None,
    bol_within: TimeDelta | None = None,
) -> bool:
    """Check the comment.

    Parameters:
        bump: The next version of the project.
        eol_within: The time delta to start warning before the End of Life of a Python version.
        bol_within: The time delta to start warning before the Beginning of Life of a Python version.

    Returns:
        True when there is nothing to do, False otherwise.
    """
    msg_location = f"{self.file}:{self.lineno}:"
    if self.is_eol:
        try:
            eol = self.eol
        except KeyError:
            # Unknown version, skip.
            return True
        if eol_within and _within(eol_within, eol):
            delta = f"since {eol}" if _past(eol) else f"in ~{naturaldelta(_delta(eol))}"
            _logger.warning(f"{msg_location} {delta} {self.comment}")
        elif _within(TimeDelta(days=0), eol):
            _logger.error(f"{msg_location} since {eol} {self.comment}")
        else:
            return True
    elif self.is_bol:
        try:
            bol = self.bol
        except KeyError:
            # Unknown version, skip.
            return True
        if bol_within and _within(bol_within, bol):
            delta = f"since {bol}" if _past(bol) else f"in ~{naturaldelta(_delta(bol))}"
            _logger.warning(f"{msg_location} {delta} {self.comment}")
        elif _within(TimeDelta(days=0), bol):
            _logger.error(f"{msg_location} since {bol} {self.comment}")
        else:
            return True
    elif self.is_bump and bump and Version(bump) >= Version(self.version):
        _logger.error(f"{msg_location} version {self.version} >= {self.comment}")
    else:
        return True
    return False

def fix(
    self,
    buffer: list[str] | None = None,
    *,
    bump: str | None = None,
    eol_within: TimeDelta | None = None,
    bol_within: TimeDelta | None = None,
) -> bool:
    """Fix the comment and code below it.

    Parameters:
        buffer: The buffer to fix. If not provided, read from and write to the file.
        bump: The next version of the project.
        eol_within: The time delta to start fixing before the End of Life of a Python version.
        bol_within: The time delta to start fixing before the Beginning of Life of a Python version.

    Returns:
        Whether the comment was fixed.
    """
    write = buffer is None
    buffer = buffer or self.file.read_text(encoding="utf8").splitlines(keepends=True)

    # Check if the fix should be applied.
    if (
        (self.is_eol and ((eol_within and _within(eol_within, self.eol)) or _within(TimeDelta(days=0), self.eol)))
        or (
            self.is_bol and ((bol_within and _within(bol_within, self.bol)) or _within(TimeDelta(days=0), self.bol))
        )
        or (self.is_bump and bump and Version(bump) >= Version(self.version))
    ):
        # Start at the commnent line, immediately remove it.
        start = self.lineno - 1
        del buffer[start]

        if self.remove:
            start, end = _scope_range(self.remove, buffer, start)
            del buffer[start:end]
            if write and self.remove == "file":
                self.file.unlink()

        elif self.replace:
            # Line numbers/ranges are relative to block starts, absolute for the "file" scope.
            start, end = _scope_range(self.replace, buffer, start)
            if self.line:
                replacement = [buffer[start + self.line - 1]]
            elif self.lines:
                replacement = [buffer[start + line] for line in self.lines]
            elif self.string:
                replacement = [self.string + "\n"]
            else:
                raise RuntimeError("No replacement specified")
            replacement = _reindent(replacement, _indent(buffer[start]))
            buffer[start:end] = replacement

        elif self.within:
            # Line numbers/ranges are relative to block starts, absolute for the "file" scope.
            start, end = _scope_range(self.within, buffer, start)
            block = buffer[start:end]
            if self.regex:
                pattern1: Pattern = re.compile(self.pattern1)
                replacement = [pattern1.sub(self.pattern2, line) for line in block]
            else:
                replacement = [line.replace(self.pattern1, self.pattern2) for line in block]  # type: ignore[arg-type]
            replacement = _reindent(replacement, _indent(buffer[start]))
            buffer[start:end] = replacement

        if write and buffer:
            self.file.write_text("".join(buffer))

        return True
    return False