git_changelog ¤

def get_refs(self, ref_type: str, text: str) -> list[Ref]:
    """Find all references in the given text.

    Arguments:
        ref_type: The reference type.
        text: The text in which to search references.

    Returns:
        A list of references (instances of [Ref][git_changelog.providers.Ref]).
    """
    return [
        Ref(ref=match.group().strip(), url=self.build_ref_url(ref_type, match.groupdict()))
        for match in self.parse_refs(ref_type, text)
    ]

def parse_refs(self, ref_type: str, text: str) -> list[Match]:
    """Parse references in the given text.

    Arguments:
        ref_type: The reference type.
        text: The text to parse.

    Returns:
        A list of regular expressions matches.
    """
    if ref_type not in self.REF:
        refs = [key for key in self.REF if key.startswith(ref_type)]
        return [match for ref in refs for match in self.REF[ref].regex.finditer(text)]
    return list(self.REF[ref_type].regex.finditer(text))

def get_log(self) -> str:
    """Get the `git log` output.

    Returns:
        The output of the `git log` command, with a particular format.
    """
    if self.filter_commits:
        try:
            return self.run_git("log", "--date=unix", "--format=" + self.FORMAT, self.filter_commits)
        except CalledProcessError as e:
            raise ValueError(
                f"An error ocurred. Maybe the provided git-log revision-range is not valid: '{self.filter_commits}'",
            ) from e

    # No revision-range provided. Call normally
    return self.run_git("log", "--date=unix", "--format=" + self.FORMAT)

def get_remote_url(self) -> str:
    """Get the git remote URL for the repository.

    Returns:
        The origin remote URL.
    """
    remote = "remote." + os.environ.get("GIT_CHANGELOG_REMOTE", "origin") + ".url"
    git_url = self.run_git("config", "--default", "", "--get", remote).rstrip("\n")
    if git_url.startswith("git@"):
        git_url = git_url.replace(":", "/", 1).replace("git@", "https://", 1)
    if git_url.endswith(".git"):
        git_url = git_url[:-4]

    # Remove credentials from the URL.
    if git_url.startswith(("http://", "https://")):
        # (addressing scheme, network location, path, query, fragment identifier)
        urlparts = list(urlsplit(git_url))
        urlparts[1] = urlparts[1].split("@", 1)[-1]
        git_url = urlunsplit(urlparts)

    return git_url

def parse_commits(self) -> list[Commit]:
    """Parse the output of 'git log' into a list of commits.

    The commits build a Git commit graph by referencing their parent commits.
    Commits are ordered from newest to oldest.

    Returns:
        The list of commits.
    """
    lines = self.raw_log.split("\n")
    size = len(lines) - 1  # Don't count last blank line.
    pos = 0

    commits_map: dict[str, Commit] = {}

    while pos < size:
        # Build message body.
        nbl_index = 10
        body = []
        while lines[pos + nbl_index] != self.MARKER:
            body.append(lines[pos + nbl_index].strip("\r"))
            nbl_index += 1

        # Build commit object.
        commit = Commit(
            commit_hash=lines[pos],
            author_name=lines[pos + 1],
            author_email=lines[pos + 2],
            author_date=lines[pos + 3],
            committer_name=lines[pos + 4],
            committer_email=lines[pos + 5],
            committer_date=lines[pos + 6],
            refs=lines[pos + 7],
            parent_hashes=lines[pos + 8],
            commits_map=commits_map,
            subject=lines[pos + 9],
            body=body,
            parse_trailers=self.parse_trailers,
            version_parser=self.version_parser,
        )

        pos += nbl_index + 1

        # Expand commit object with provider parsing.
        if self.provider:
            commit.update_with_provider(self.provider, parse_refs=self.parse_provider_refs)

        # Set the commit url based on remote_url (could be wrong).
        elif self.remote_url:
            commit.url = self.remote_url + "/commit/" + commit.hash

        # Expand commit object with convention parsing.
        if self.convention:
            commit.update_with_convention(self.convention)

        commits_map[commit.hash] = commit

    return list(commits_map.values())

def run_git(self, *args: str) -> str:
    """Run a git command in the chosen repository.

    Arguments:
        *args: Arguments passed to the git command.

    Returns:
        The git command output.
    """
    return check_output(["git", *args], cwd=self.repository).decode("utf8")  # noqa: S603,S607

def update_with_convention(self, convention: CommitConvention) -> None:
    """Apply the convention-parsed data to this commit.

    Arguments:
        convention: The convention to use.
    """
    self.convention.update(convention.parse_commit(self))

def update_with_provider(
    self,
    provider: ProviderRefParser,
    parse_refs: bool = True,  # noqa: FBT001,FBT002
) -> None:
    """Apply the provider-parsed data to this commit.

    Arguments:
        provider: The provider to use.
        parse_refs: Whether to parse references for this provider.
    """
    # set the commit url based on provider
    # FIXME: hardcoded 'commits'
    if "commits" in provider.REF:
        self.url = provider.build_ref_url("commits", {"ref": self.hash})
    else:
        # use default "commit" url (could be wrong)
        self.url = f"{provider.url}/{provider.namespace}/{provider.project}/commit/{self.hash}"

    # build commit text references from its subject and body
    if parse_refs:
        for ref_type in provider.REF:
            self.text_refs[ref_type] = provider.get_refs(
                ref_type,
                "\n".join([self.subject, *self.body]),
            )

        if "issues" in self.text_refs:
            self.text_refs["issues_not_in_subject"] = []
            for issue in self.text_refs["issues"]:
                if issue.ref not in self.subject:
                    self.text_refs["issues_not_in_subject"].append(issue)

def get_refs(self, ref_type: str, text: str) -> list[Ref]:
    """Find all references in the given text.

    Arguments:
        ref_type: The reference type.
        text: The text in which to search references.

    Returns:
        A list of references (instances of [Ref][git_changelog.providers.Ref]).
    """
    return [
        Ref(ref=match.group().strip(), url=self.build_ref_url(ref_type, match.groupdict()))
        for match in self.parse_refs(ref_type, text)
    ]

def parse_refs(self, ref_type: str, text: str) -> list[Match]:
    """Parse references in the given text.

    Arguments:
        ref_type: The reference type.
        text: The text to parse.

    Returns:
        A list of regular expressions matches.
    """
    if ref_type not in self.REF:
        refs = [key for key in self.REF if key.startswith(ref_type)]
        return [match for ref in refs for match in self.REF[ref].regex.finditer(text)]
    return list(self.REF[ref_type].regex.finditer(text))

def get_refs(self, ref_type: str, text: str) -> list[Ref]:
    """Find all references in the given text.

    Arguments:
        ref_type: The reference type.
        text: The text in which to search references.

    Returns:
        A list of references (instances of [Ref][git_changelog.providers.Ref]).
    """
    return [
        Ref(ref=match.group().strip(), url=self.build_ref_url(ref_type, match.groupdict()))
        for match in self.parse_refs(ref_type, text)
    ]

def parse_refs(self, ref_type: str, text: str) -> list[Match]:
    """Parse references in the given text.

    Arguments:
        ref_type: The reference type.
        text: The text to parse.

    Returns:
        A list of regular expressions matches.
    """
    if ref_type not in self.REF:
        refs = [key for key in self.REF if key.startswith(ref_type)]
        return [match for ref in refs for match in self.REF[ref].regex.finditer(text)]
    return list(self.REF[ref_type].regex.finditer(text))