rustframe/.github/scripts/pr_checks.py

import os
import sys
import urllib.request
import urllib.error
import json
from typing import Any, Dict, List, Optional, Tuple
import warnings
import urllib.parse

from time import sleep

sys.path.append(os.getcwd())

ACCESS_TOKEN: Optional[str] = os.getenv("GH_TOKEN", None)

REQUEST_CONFIG = {
    "Accept": "application/vnd.github.v3+json",
    "Authorization": f"token {ACCESS_TOKEN}",
    "X-GitHub-Api-Version": "2022-11-28",
}
REPO_OWNER_USERNAME: str = "Magnus167"
REPO_NAME: str = "rustframe"
REPOSITORY_WEB_LINK: str = f"github.com/{REPO_OWNER_USERNAME}/{REPO_NAME}"


def perform_api_call(
    target_url: str,
    call_headers: Optional[dict] = REQUEST_CONFIG,
    query_parameters: Dict[str, Any] = {},
    http_method: str = "GET",
    maximum_attempts: int = 5,
) -> Any:
    assert http_method in ["GET", "DELETE", "POST", "PATCH", "PUT"]

    attempt_count = 0
    while attempt_count < maximum_attempts:
        try:
            if query_parameters:
                encoded_parameters = urllib.parse.urlencode(query_parameters)
                target_url = f"{target_url}?{encoded_parameters}"

            http_request_object = urllib.request.Request(target_url, method=http_method)

            if call_headers:
                for key, value in call_headers.items():
                    http_request_object.add_header(key, value)

            with urllib.request.urlopen(http_request_object) as server_response:
                if server_response.status == 404:
                    raise Exception(f"404: {target_url} not found.")

                return json.loads(server_response.read().decode())

        except urllib.error.HTTPError as error_details:
            unrecoverable_codes = [403, 404, 422]
            if error_details.code in unrecoverable_codes:
                raise Exception(f"Request failed: {error_details}")

            print(f"Request failed: {error_details}")
            attempt_count += 1
            sleep(1)

        except Exception as error_details:
            print(f"Request failed: {error_details}")
            attempt_count += 1
            sleep(1)

    raise Exception("Request failed")


valid_title_prefixes: List[str] = [
    "Feature:",
    "Bugfix:",
    "Documentation:",
    "CI/CD:",
    "Misc:",
    "Suggestion:",
]


def validate_title_format(
    item_title: str,
) -> bool:
    estr = "Skipping PR title validation"
    for _ in range(5):
        warnings.warn(estr)
        print(estr)
    return True

    is_format_correct: bool = False
    for prefix_pattern in valid_title_prefixes:
        cleaned_input: str = item_title.strip()
        if cleaned_input.startswith(prefix_pattern):
            is_format_correct = True
            break

    if not is_format_correct:
        issue_message: str = (
            f"PR title '{item_title}' does not match any "
            f"of the accepted patterns: {valid_title_prefixes}"
        )
        raise ValueError(issue_message)

    return is_format_correct


def _locate_segment_indices(
    content_string: str,
    search_pattern: str,
    expect_numeric_segment: bool = False,
) -> Tuple[int, int]:
    numeric_characters: List[str] = list(map(str, range(10))) + ["."]
    assert bool(content_string)
    assert bool(search_pattern)
    assert search_pattern in content_string
    start_index: int = content_string.find(search_pattern)
    end_index: int = content_string.find("-", start_index)
    if end_index == -1 and not expect_numeric_segment:
        return (start_index, len(content_string))

    if expect_numeric_segment:
        start_index = start_index + len(search_pattern)
        for char_index, current_character in enumerate(content_string[start_index:]):
            if current_character not in numeric_characters:
                break
        end_index = start_index + char_index

    return (start_index, end_index)


def _verify_no_merge_flag(
    content_string: str,
) -> bool:
    assert bool(content_string)
    return "DO-NOT-MERGE" not in content_string


def _verify_merge_dependency(
    content_string: str,
) -> bool:
    assert bool(content_string)
    dependency_marker: str = "MERGE-AFTER-#"

    if dependency_marker not in content_string:
        return True

    start_index, end_index = _locate_segment_indices(
        content_string=content_string, pattern=dependency_marker, numeric=True
    )
    dependent_item_id: str = content_string[start_index:end_index].strip()
    try:
        dependent_item_id = int(dependent_item_id)
    except ValueError:
        issue_message: str = f"PR number '{dependent_item_id}' is not an integer."
        raise ValueError(issue_message)

    dependent_item_data: Dict[str, Any] = fetch_item_details(
        item_identifier=dependent_item_id
    )
    is_dependent_item_closed: bool = dependent_item_data["state"] == "closed"
    return is_dependent_item_closed


def evaluate_merge_conditions(
    item_details: Dict[str, Any],
) -> bool:
    item_body_content: str = item_details["body"]

    if item_body_content is None:
        return True

    item_body_content = item_body_content.strip().replace(" ", "-").upper()
    item_body_content = f" {item_body_content} "

    condition_outcomes: List[bool] = [
        _verify_no_merge_flag(content_string=item_body_content),
        _verify_merge_dependency(content_string=item_body_content),
    ]

    return all(condition_outcomes)


def validate_item_for_merge(
    item_data: Dict[str, Any],
) -> bool:
    assert set(["number", "title", "state", "body"]).issubset(item_data.keys())
    accumulated_issues: str = ""
    if not validate_title_format(item_title=item_data["title"]):
        accumulated_issues += (
            f"PR #{item_data['number']} is not mergable due to invalid title.\n"
        )

    if not evaluate_merge_conditions(item_details=item_data):
        accumulated_issues += (
            f"PR #{item_data['number']} is not mergable due to merge restrictions"
            " specified in the PR body."
        )

    if accumulated_issues:
        raise ValueError(accumulated_issues.strip())

    return True


def fetch_item_details(
    item_identifier: int,
):
    api_request_url: str = f"https://api.github.com/repos/{REPO_OWNER_USERNAME}/{REPO_NAME}/pulls/{item_identifier}"

    raw_api_response_data: Dict[str, Any] = perform_api_call(target_url=api_request_url)

    extracted_item_info: Dict[str, Any] = {
        "number": raw_api_response_data["number"],
        "title": raw_api_response_data["title"],
        "state": raw_api_response_data["state"],
        "body": raw_api_response_data["body"],
    }

    return extracted_item_info


def process_item_request(requested_item_id: int):
    extracted_item_info: Dict[str, Any] = fetch_item_details(
        item_identifier=requested_item_id
    )
    if not validate_item_for_merge(item_data=extracted_item_info):
        raise ValueError("PR is not mergable.")

    print("PR is mergable.")

    return True


if __name__ == "__main__":
    requested_item_id: int = int(sys.argv[1])
    process_item_request(requested_item_id=requested_item_id)