codecov-cli 11.0.0__py3-none-any.whl

codecov_cli/helpers/ci_adapters/github_actions.py

@@ -0,0 +1,90 @@
+import os
+import re
+import subprocess
+
+from codecov_cli.helpers.ci_adapters.base import CIAdapterBase
+
+
+class GithubActionsCIAdapter(CIAdapterBase):
+    # https://docs.github.com/en/actions/learn-github-actions/environment-variables
+    def detect(self) -> bool:
+        return bool(os.getenv("GITHUB_ACTIONS"))
+
+    def _get_commit_sha(self):
+        pr = self._get_pull_request_number()
+        commit = os.getenv("GITHUB_SHA")
+
+        if not pr:
+            return commit
+
+        # actions/checkout should be run with fetch-depth > 1 or set to 0 for this to work
+        completed_subprocess = subprocess.run(
+            ["git", "rev-parse", "HEAD^@"], capture_output=True
+        )
+
+        parents_hash = completed_subprocess.stdout.decode().strip().splitlines()
+        if len(parents_hash) == 2:
+            return parents_hash[1]
+
+        return commit
+
+    def _get_build_url(self):
+        server_url = os.getenv("GITHUB_SERVER_URL")
+        slug = self._get_slug()
+        build_code = self._get_build_code()
+
+        if server_url and slug and build_code:
+            return f"{server_url}/{slug}/actions/runs/{build_code}"
+
+        return None
+
+    def _get_build_code(self):
+        return os.getenv("GITHUB_RUN_ID")
+
+    def _get_job_code(self):
+        return os.getenv("GITHUB_WORKFLOW")
+
+    def _get_pull_request_number(self):
+        if not os.getenv("GITHUB_HEAD_REF"):
+            return None
+
+        pr_ref = os.getenv("GITHUB_REF")
+
+        if not pr_ref:
+            return None
+
+        match = re.search(r"refs/pull/(\d+)/merge", pr_ref)
+
+        if match is None:
+            return None
+
+        pr = match.group(1)
+
+        return pr or None
+
+    def _get_slug(self):
+        return os.getenv("GITHUB_REPOSITORY")
+
+    def _get_branch(self):
+        branch = os.getenv("GITHUB_HEAD_REF")
+        if branch:
+            return branch
+
+        branch_ref = os.getenv("GITHUB_REF")
+
+        if not branch_ref:
+            return None
+
+        match = re.search(r"refs/heads/(.*)", branch_ref)
+
+        if match is None:
+            return None
+
+        branch = match.group(1)
+        return branch or None
+
+    def _get_service(self):
+        return "github-actions"
+
+    def get_service_name(self):
+        return "GithubActions"

codecov_cli/helpers/ci_adapters/gitlab_ci.py

@@ -0,0 +1,56 @@
+import os
+
+from codecov_cli.helpers.ci_adapters.base import CIAdapterBase
+from codecov_cli.helpers.git import parse_slug
+
+
+class GitlabCIAdapter(CIAdapterBase):
+    # https://docs.gitlab.com/ee/ci/variables/predefined_variables.html
+    def detect(self) -> bool:
+        return bool(os.getenv("GITLAB_CI"))
+
+    def _get_commit_sha(self):
+        return (
+            os.getenv("CI_MERGE_REQUEST_SOURCE_BRANCH_SHA")
+            or os.getenv("CI_BUILD_REF")
+            or os.getenv("CI_COMMIT_SHA")
+        )
+
+    def _get_build_url(self):
+        return os.getenv("CI_JOB_URL")
+
+    def _get_build_code(self):
+        return os.getenv("CI_BUILD_ID") or os.getenv("CI_JOB_ID")
+
+    def _get_job_code(self):
+        return os.getenv("CI_JOB_ID")
+
+    def _get_pull_request_number(self):
+        return os.getenv("CI_MERGE_REQUEST_IID")
+
+    def _get_slug(self):
+        slug = os.getenv("CI_PROJECT_PATH")
+        if slug:
+            return slug
+
+        owner = os.getenv("CI_PROJECT_NAMESPACE")
+        project_name = os.getenv("CI_PROJECT_NAME")
+
+        if owner and project_name:
+            return f"{owner}/{project_name}"
+
+        remote_address = os.getenv("CI_BUILD_REPO") or os.getenv("CI_REPOSITORY_URL")
+
+        if remote_address:
+            return parse_slug(remote_address)
+
+        return None
+
+    def _get_branch(self):
+        return os.getenv("CI_BUILD_REF_NAME") or os.getenv("CI_COMMIT_REF_NAME")
+
+    def _get_service(self):
+        return "gitlab"
+
+    def get_service_name(self):
+        return "GitlabCI"

codecov_cli/helpers/ci_adapters/heroku.py

@@ -0,0 +1,36 @@
+import os
+
+from codecov_cli.helpers.ci_adapters.base import CIAdapterBase
+
+
+class HerokuCIAdapter(CIAdapterBase):
+    # https://devcenter.heroku.com/articles/heroku-ci#immutable-environment-variables
+    def detect(self) -> bool:
+        return bool(os.getenv("CI")) and bool(os.getenv("HEROKU_TEST_RUN_BRANCH"))
+
+    def _get_branch(self):
+        return os.getenv("HEROKU_TEST_RUN_BRANCH")
+
+    def _get_commit_sha(self):
+        return os.getenv("HEROKU_TEST_RUN_COMMIT_VERSION")
+
+    def _get_slug(self):
+        return None
+
+    def _get_service(self):
+        return "heroku"
+
+    def _get_build_url(self):
+        return None
+
+    def _get_build_code(self):
+        return os.getenv("HEROKU_TEST_RUN_ID")
+
+    def _get_job_code(self):
+        return None
+
+    def _get_pull_request_number(self):
+        return None
+
+    def get_service_name(self):
+        return "Heroku"

codecov_cli/helpers/ci_adapters/jenkins.py

@@ -0,0 +1,38 @@
+import os
+
+from codecov_cli.helpers.ci_adapters.base import CIAdapterBase
+
+
+class JenkinsAdapter(CIAdapterBase):
+    # https://www.jenkins.io/doc/book/pipeline/jenkinsfile/#using-environment-variables
+    # https://www.jenkins.io/doc/book/pipeline/multibranch/
+
+    def detect(self) -> bool:
+        return bool(os.getenv("JENKINS_URL"))
+
+    def _get_commit_sha(self):
+        return None
+
+    def _get_build_url(self):
+        return os.getenv("BUILD_URL")
+
+    def _get_build_code(self):
+        return os.getenv("BUILD_NUMBER")
+
+    def _get_job_code(self):
+        return None
+
+    def _get_pull_request_number(self):
+        return os.getenv("CHANGE_ID")
+
+    def _get_slug(self):
+        return None
+
+    def _get_branch(self):
+        return os.getenv("BRANCH_NAME")
+
+    def _get_service(self):
+        return "jenkins"
+
+    def get_service_name(self):
+        return "Jenkins"

codecov_cli/helpers/ci_adapters/local.py

@@ -0,0 +1,39 @@
+import os
+import subprocess
+
+from codecov_cli.helpers.ci_adapters.base import CIAdapterBase
+
+SUCCESS = 0
+
+
+class LocalAdapter(CIAdapterBase):
+    def detect(self) -> bool:
+        s = subprocess.run(["git", "help"], capture_output=True)
+        return s.returncode == SUCCESS
+
+    def _get_branch(self):
+        return os.getenv("GIT_BRANCH") or os.getenv("BRANCH_NAME")
+
+    def _get_build_code(self):
+        return None
+
+    def _get_build_url(self):
+        return None
+
+    def _get_commit_sha(self):
+        return os.getenv("GIT_COMMIT")
+
+    def _get_slug(self):
+        return None
+
+    def _get_service(self):
+        return "local"
+
+    def _get_pull_request_number(self):
+        return None
+
+    def _get_job_code(self):
+        return None
+
+    def get_service_name(self):
+        return "Local"

codecov_cli/helpers/ci_adapters/teamcity.py

@@ -0,0 +1,37 @@
+import os
+
+from codecov_cli.helpers.ci_adapters.base import CIAdapterBase
+
+
+class TeamcityAdapter(CIAdapterBase):
+    # https://www.jetbrains.com/help/teamcity/predefined-build-parameters.html#Predefined+Server+Build+Parameters
+
+    def detect(self) -> bool:
+        return bool(os.getenv("TEAMCITY_VERSION"))
+
+    def _get_branch(self):
+        return os.getenv("BRANCH_NAME")
+
+    def _get_build_code(self):
+        return os.getenv("BUILD_NUMBER")
+
+    def _get_build_url(self):
+        return None
+
+    def _get_commit_sha(self):
+        return os.getenv("BUILD_VCS_NUMBER")
+
+    def _get_slug(self):
+        return None
+
+    def _get_service(self):
+        return "teamcity"
+
+    def _get_pull_request_number(self):
+        return None
+
+    def _get_job_code(self):
+        return None
+
+    def get_service_name(self):
+        return "Teamcity"

codecov_cli/helpers/ci_adapters/travis_ci.py

@@ -0,0 +1,44 @@
+import os
+
+from codecov_cli.helpers.ci_adapters.base import CIAdapterBase
+
+
+class TravisCIAdapter(CIAdapterBase):
+    # https://docs.travis-ci.com/user/environment-variables/#default-environment-variables
+    def detect(self) -> bool:
+        return (
+            bool(os.getenv("CI"))
+            and bool(os.getenv("TRAVIS"))
+            and not bool(os.getenv("SHIPPABLE"))
+        )
+
+    def _get_commit_sha(self):
+        return os.getenv("TRAVIS_PULL_REQUEST_SHA") or os.getenv("TRAVIS_COMMIT")
+
+    def _get_build_url(self):
+        return os.getenv("TRAVIS_BUILD_WEB_URL")
+
+    def _get_build_code(self):
+        return os.getenv("TRAVIS_JOB_NUMBER")
+
+    def _get_job_code(self):
+        return os.getenv("TRAVIS_JOB_ID")
+
+    def _get_pull_request_number(self):
+        # The pull request number if the current job is a pull request, “false” if it’s not a pull request.
+        pr_num = os.getenv("TRAVIS_PULL_REQUEST")
+        return pr_num if pr_num != "false" else None
+
+    def _get_slug(self):
+        return os.getenv("TRAVIS_REPO_SLUG")
+
+    def _get_branch(self):
+        if os.getenv("TRAVIS_BRANCH") != os.getenv("TRAVIS_TAG"):
+            return os.getenv("TRAVIS_PULL_REQUEST_BRANCH") or os.getenv("TRAVIS_BRANCH")
+        return None
+
+    def _get_service(self):
+        return "travis"
+
+    def get_service_name(self):
+        return "Travis"

codecov_cli/helpers/ci_adapters/woodpeckerci.py

@@ -0,0 +1,36 @@
+import os
+
+from codecov_cli.helpers.ci_adapters.base import CIAdapterBase
+
+
+class WoodpeckerCIAdapter(CIAdapterBase):
+    # https://woodpecker-ci.org/docs/usage/environment
+    def detect(self) -> bool:
+        return os.getenv("CI") == "woodpecker"
+
+    def _get_branch(self):
+        return os.getenv("CI_COMMIT_SOURCE_BRANCH") or os.getenv("CI_COMMIT_BRANCH")
+
+    def _get_build_code(self):
+        return os.getenv("CI_BUILD_NUMBER")
+
+    def _get_build_url(self):
+        return os.getenv("CI_BUILD_LINK")
+
+    def _get_commit_sha(self):
+        return os.getenv("CI_COMMIT_SHA")
+
+    def _get_slug(self):
+        return os.getenv("CI_REPO")
+
+    def _get_service(self):
+        return "woodpecker"
+
+    def _get_pull_request_number(self):
+        return os.getenv("CI_COMMIT_PULL_REQUEST")
+
+    def _get_job_code(self):
+        return os.getenv("CI_JOB_NUMBER")
+
+    def get_service_name(self):
+        return "Woodpecker"

codecov_cli/helpers/config.py

@@ -0,0 +1,66 @@
+import logging
+import pathlib
+import typing as t
+
+import yaml
+
+from codecov_cli.helpers.versioning_systems import get_versioning_system
+
+logger = logging.getLogger("codecovcli")
+
+CODECOV_API_URL = "https://api.codecov.io"
+CODECOV_INGEST_URL = "https://ingest.codecov.io"
+LEGACY_CODECOV_API_URL = "https://codecov.io"
+
+# Relative to the project root
+CODECOV_YAML_RECOGNIZED_DIRECTORIES = [
+    "",
+    ".github/",
+    "dev/",
+]
+
+CODECOV_YAML_RECOGNIZED_FILENAMES = [
+    "codecov.yml",
+    "codecov.yaml",
+    ".codecov.yml",
+    ".codecov.yaml",
+]
+
+
+def _find_codecov_yamls():
+    vcs = get_versioning_system()
+    vcs_root = vcs.get_network_root() if vcs else None
+    project_root = vcs_root if vcs_root else pathlib.Path.cwd()
+
+    yamls = []
+    for directory in CODECOV_YAML_RECOGNIZED_DIRECTORIES:
+        dir_candidate = project_root / directory
+        if not dir_candidate.exists() or not dir_candidate.is_dir():
+            continue
+
+        for filename in CODECOV_YAML_RECOGNIZED_FILENAMES:
+            file_candidate = dir_candidate / filename
+            if file_candidate.exists() and file_candidate.is_file():
+                yamls.append(file_candidate)
+
+    return yamls
+
+
+def load_cli_config(codecov_yml_path: t.Optional[pathlib.Path]) -> t.Optional[dict]:
+    if not codecov_yml_path:
+        yamls = _find_codecov_yamls()
+        codecov_yml_path = yamls[0] if yamls else None
+
+    if not codecov_yml_path:
+        logger.warning("No config file could be found. Ignoring config.")
+        return None
+
+    if not codecov_yml_path.exists() or not codecov_yml_path.is_file():
+        logger.warning(
+            f"Config file {codecov_yml_path} not found, or is not a file. Ignoring config."
+        )
+        return None
+
+    logger.debug(f"Loading config from {codecov_yml_path}")
+    with open(codecov_yml_path, "r") as file_stream:
+        return yaml.safe_load(file_stream.read())

codecov_cli/helpers/encoder.py

@@ -0,0 +1,49 @@
+import re
+
+slug_without_subgroups_regex = re.compile(r"[^/\s]+\/[^/\s]+$")
+slug_with_subgroups_regex = re.compile(r"[^/\s]+(\/[^/\s]+)+$")
+encoded_slug_regex = re.compile(r"[^:\s]+(:::[^:\s]+)*(::::[^:\s]+){1}$")
+
+
+def encode_slug(slug: str):
+    if slug_with_subgroups_is_invalid(slug):
+        raise ValueError("The provided slug is invalid")
+    owner, repo = slug.rsplit("/", 1)
+    encoded_owner = ":::".join(owner.split("/"))
+    encoded_slug = "::::".join([encoded_owner, repo])
+    return encoded_slug
+
+
+def decode_slug(slug: str):
+    if slug_encoded_incorrectly(slug):
+        raise ValueError("The slug is not encoded correctly")
+
+    owner, repo = slug.split("::::", 1)
+    decoded_owner = "/".join(owner.split(":::"))
+    decoded_slug = "/".join([decoded_owner, repo])
+    return decoded_slug
+
+
+def slug_without_subgroups_is_invalid(slug: str):
+    """
+    Checks if slug is in the form of owner/repo
+    Returns True if it's invalid, otherwise return False
+    """
+    return not slug or not slug_without_subgroups_regex.match(slug)
+
+
+def slug_with_subgroups_is_invalid(slug: str):
+    """
+    Checks if slug is in the form of owner/repo or owner/subgroup/repo
+    Returns True if it's invalid, otherwise return False
+    """
+    return not slug or not slug_with_subgroups_regex.match(slug)
+
+
+def slug_encoded_incorrectly(slug: str):
+    """
+    Checks if slug is encoded incorrectly based on the encoding mechanism we use.
+    Checks if slug is in the form of owner:::subowner::::repo or owner::::repo
+    Returns True if invalid, otherwise returns False
+    """
+    return not slug or not encoded_slug_regex.match(slug)

codecov_cli/helpers/folder_searcher.py

@@ -0,0 +1,114 @@
+import functools
+import logging
+import os
+import pathlib
+import re
+from typing import Generator, List, Optional, Pattern
+
+from codecov_cli.helpers.glob import translate
+
+logger = logging.getLogger("codecovcli")
+
+
+def _is_included(
+    filename_include_regex: Pattern,
+    multipart_include_regex: Optional[Pattern],
+    path: pathlib.Path,
+):
+    return filename_include_regex.match(path.name) and (
+        multipart_include_regex is None
+        or multipart_include_regex.match(path.resolve().as_posix())
+    )
+
+
+def _is_excluded(
+    filename_exclude_regex: Optional[Pattern],
+    multipart_exclude_regex: Optional[Pattern],
+    path: pathlib.Path,
+):
+    return (
+        filename_exclude_regex is not None and filename_exclude_regex.match(path.name)
+    ) or (
+        multipart_exclude_regex is not None
+        and multipart_exclude_regex.match(path.as_posix())
+    )
+
+
+def search_files(
+    folder_to_search: pathlib.Path,
+    folders_to_ignore: List[str],
+    *,
+    filename_include_regex: Pattern,
+    filename_exclude_regex: Optional[Pattern] = None,
+    multipart_include_regex: Optional[Pattern] = None,
+    multipart_exclude_regex: Optional[Pattern] = None,
+    search_for_directories: bool = False,
+) -> Generator[pathlib.Path, None, None]:
+    """ "
+    Searches for files or directories in a given folder
+
+    Parameters:
+        folder_to_search (pathlib.Path): in which folder you want the search to be
+        folders_to_ignore (list of str): what folders inside the folder_to_search to ignore and not search inside
+        filename_include_regex (regex): Regex for filenames only, this does not include the full path of the file
+        filename_exclude_regex (regex): Regex for filenames only, this does not include the full path of the file
+        multipart_include_regex (regex): Regex for full path of the files you want to include
+        multipart_exclude_regex (regex): Regex for full path of the files you want to exclude
+        search_for_directories (bool)
+
+    """
+    this_is_included = functools.partial(
+        _is_included, filename_include_regex, multipart_include_regex
+    )
+    this_is_excluded = functools.partial(
+        _is_excluded, filename_exclude_regex, multipart_exclude_regex
+    )
+    for dirpath, dirnames, filenames in os.walk(folder_to_search):
+        dirs_to_remove = set(d for d in dirnames if d in folders_to_ignore)
+
+        if multipart_exclude_regex is not None:
+            dirs_to_remove.union(
+                directory
+                for directory in dirnames
+                if multipart_exclude_regex.match(
+                    (pathlib.Path(dirpath) / directory).as_posix()
+                )
+            )
+
+        for directory in dirs_to_remove:
+            # Removing to ensure we don't even try to search those
+            # This is the documented way of doing this on python docs
+            dirnames.remove(directory)
+
+        if search_for_directories:
+            for directory in dirnames:
+                dir_path = pathlib.Path(dirpath) / directory
+                if not this_is_excluded(dir_path) and this_is_included(dir_path):
+                    yield dir_path
+        else:
+            for single_filename in filenames:
+                file_path = pathlib.Path(dirpath) / single_filename
+                if not this_is_excluded(file_path) and this_is_included(file_path):
+                    yield file_path
+
+
+def globs_to_regex(patterns: List[str]) -> Optional[Pattern]:
+    """
+    Converts a list of glob patterns to a combined ORed regex
+
+    Parameters:
+        patterns (List[str]): a list of globs, possibly empty
+
+    Returns:
+        (Pattern): a combined ORed regex, or None if patterns is an empty list
+    """
+    # if patterns is an empty list, avoid returning re.compile("") since it matches everything
+    if not patterns:
+        return None
+
+    regex_patterns = []
+    for pattern in patterns:
+        regex_pattern = translate(pattern, recursive=True, include_hidden=True)
+        logger.debug(f"Translating `{pattern}` into `{regex_pattern}`")
+        regex_patterns.append(regex_pattern)
+    return re.compile("|".join(regex_patterns))