daktari 0.0.236__py3-none-any.whl → 0.0.254__py3-none-any.whl

daktari/checks/git.py

@@ -1,198 +0,0 @@
-import logging
-from typing import Optional
-
-from daktari.check import Check, CheckResult
-from daktari.command_utils import can_run_command, get_stdout
-from daktari.file_utils import file_contains_text, is_ascii
-from daktari.os import OS
-from daktari.version_utils import get_simple_cli_version
-
-
-class GitInstalled(Check):
-    name = "git.installed"
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install git</cmd>",
-        OS.UBUNTU: "<cmd>sudo apt install git</cmd>",
-        OS.GENERIC: "Install Git: https://git-scm.com/downloads",
-    }
-
-    def check(self) -> CheckResult:
-        if can_run_command("git version"):
-            return self.passed("Git is installed")
-        else:
-            return self.failed("Could not find git on the path")
-
-
-class GitLfsInstalled(Check):
-    name = "git.lfs.installed"
-    depends_on = [GitInstalled]
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install git-lfs</cmd>",
-        OS.UBUNTU: "<cmd>sudo apt install git-lfs</cmd>",
-        OS.GENERIC: "Install Git LFS: https://github.com/git-lfs/git-lfs/wiki/Installation",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify(can_run_command("git lfs version"), "Git LFS is <not/> installed")
-
-
-class GitLfsSetUpForUser(Check):
-    name = "git.lfs.setUpForUser"
-    depends_on = [GitLfsInstalled]
-
-    suggestions = {
-        OS.GENERIC: """
-            Set up Git LFS for your user account:
-            <cmd>git lfs install</cmd>
-            """
-    }
-
-    def check(self) -> CheckResult:
-        output = get_stdout("git lfs env")
-        passed = bool(output and "git-lfs filter-process" in output)
-        return self.verify(passed, "Git LFS is <not/> set up for the current user")
-
-
-class GitLfsFilesDownloaded(Check):
-    name = "git.lfs.filesDownloaded"
-    depends_on = [GitLfsSetUpForUser]
-
-    suggestions = {
-        OS.GENERIC: """
-            Download all Git LFS files and update working copy with the downloaded content:
-            <cmd>git lfs pull</cmd>
-            """
-    }
-
-    def check(self) -> CheckResult:
-        output = get_stdout("git lfs ls-files") or ""
-        files_not_downloaded = [line.split()[2] for line in output.splitlines() if line.split()[1] == "-"]
-        for file in files_not_downloaded:
-            logging.info(f"Git LFS file not downloaded: {file}")
-        passed = len(files_not_downloaded) == 0
-        return self.verify(passed, "Git LFS files have <not/> been downloaded")
-
-
-class GitCryptInstalled(Check):
-    name = "git.crypt.installed"
-    depends_on = [GitInstalled]
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install git-crypt</cmd>",
-        OS.UBUNTU: "<cmd>sudo apt install git-crypt</cmd>",
-        OS.GENERIC: "Install git-crypt: https://www.agwa.name/projects/git-crypt/",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify(can_run_command("git crypt version"), "git-crypt is <not/> installed")
-
-
-class GitCryptUnlocked(Check):
-    name = "git.crypt.unlocked"
-    depends_on = [GitCryptInstalled]
-
-    def __init__(self, fileToCheck: str):
-        self.fileToCheck = fileToCheck
-
-    suggestions = {
-        OS.GENERIC: """
-            Unlock this repository with:
-            <cmd>git-crypt unlock</cmd>
-            """,
-    }
-
-    def check(self) -> CheckResult:
-        is_unlocked = is_ascii(self.fileToCheck)
-        return self.verify(is_unlocked, "Encrypted files have <not/> been unlocked")
-
-
-class PreCommitInstalled(Check):
-    name = "preCommit.installed"
-    depends_on = [GitInstalled]
-
-    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install pre-commit</cmd>",
-        OS.GENERIC: "Install pre-commit: https://pre-commit.com/#installation",
-    }
-
-    def check(self) -> CheckResult:
-        installed_version = get_simple_cli_version("pre-commit")
-        return self.validate_semver_expression(
-            "pre-commit", installed_version, self.required_version, self.recommended_version
-        )
-
-
-class PreCommitGitHooksInstalled(Check):
-    name = "preCommit.gitHooksInstalled"
-    depends_on = [PreCommitInstalled]
-
-    suggestions = {
-        OS.GENERIC: "<cmd>pre-commit install</cmd>",
-    }
-
-    def check(self) -> CheckResult:
-        git_hooks_installed = file_contains_text(".git/hooks/pre-commit", "pre-commit.com")
-        return self.verify(git_hooks_installed, "pre-commit Git hooks are <not/> installed")
-
-
-class GpgInstalled(Check):
-    name = "gpg.installed"
-
-    suggestions = {
-        OS.OS_X: "<cmd>brew install gpg2 gnupg pinentry-mac</cmd>",
-        OS.UBUNTU: "<cmd>sudo apt install gpg</cmd>",
-        OS.GENERIC: "Install gpg: https://gnupg.org/",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify_install("gpg")
-
-
-class GitCommitSigningSetUp(Check):
-    name = "git.commitSigningSetUp"
-
-    suggestions = {
-        OS.OS_X: "Follow instructions to set up commit signing: "
-        "https://gist.github.com/troyfontaine/18c9146295168ee9ca2b30c00bd1b41e#file-2-using-gpg-md",
-        OS.UBUNTU: "Follow instructions to set up commit signing: "
-        "https://brain2life.hashnode.dev/how-to-sign-your-git-commits-in-ubuntu-2004-and-why-you-need-it",
-    }
-
-    def check(self) -> CheckResult:
-        key = get_stdout("git config user.signingkey")
-        passed = key is not None and key != ""
-        return self.verify(passed, "user.signingkey is <not/> set")
-
-
-class GitCommitAutoSigningEnabled(Check):
-    name = "git.commitAutoSigningEnabled"
-    depends_on = [GitCommitSigningSetUp]
-
-    suggestions = {OS.GENERIC: "<cmd>git config commit.gpgsign true</cmd>"}
-
-    def check(self) -> CheckResult:
-        setting = get_stdout("git config commit.gpgsign")
-        passed = setting == "true"
-        return self.verify(passed, "commit.gpgsign is <not/> enabled")
-
-
-class GitCommitSigningFormat(Check):
-    name = "git.commitSigningFormat"
-
-    def __init__(self, required_format: str, suggestion: str):
-        self.required_format = required_format
-        self.suggestions = {OS.GENERIC: suggestion}
-
-    def check(self) -> CheckResult:
-        format_setting = get_stdout("git config gpg.format")
-        return self.verify(
-            format_setting == self.required_format,
-            f"gpg.format is {self.required_format}",
-            f"gpg.format is not {self.required_format}: {format_setting}",
-        )

daktari/checks/google.py

@@ -1,113 +0,0 @@
-import json
-import logging
-import os.path
-from json import JSONDecodeError
-from typing import Optional
-
-from daktari.check import Check, CheckResult
-from daktari.command_utils import can_run_command
-from daktari.file_utils import file_exists
-from daktari.os import OS
-from daktari.version_utils import get_simple_cli_version
-
-
-class GoogleCloudSdkInstalled(Check):
-    name = "google.cloudSdkInstalled"
-
-    suggestions = {
-        OS.OS_X: """<cmd>brew install --cask google-cloud-sdk</cmd>
-
-Then, add the gcloud components to your PATH.
-
-For bash users, add this to ~/.bashrc:
-source "$(brew --prefix)/Caskroom/google-cloud-sdk/latest/google-cloud-sdk/path.bash.inc"
-
-For zsh users, add this to ~/.zhsrc:
-source "$(brew --prefix)/Caskroom/google-cloud-sdk/latest/google-cloud-sdk/path.zsh.inc\" """,
-        OS.UBUNTU: "<cmd>sudo snap install google-cloud-sdk --classic</cmd>",
-        OS.GENERIC: "Install gcloud: https://cloud.google.com/sdk/docs/quickstart",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify(can_run_command("gcloud --version"), "Google Cloud SDK is <not/> installed and on $PATH")
-
-
-class CloudSqlProxyInstalled(Check):
-    name = "google.cloudSqlProxyInstalled"
-
-    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-
-    suggestions = {
-        OS.GENERIC: "Install Cloud SQL Proxy: <cmd>gcloud components install cloud_sql_proxy</cmd>",
-    }
-
-    def check(self) -> CheckResult:
-        installed_version = get_simple_cli_version("cloud_sql_proxy")
-        return self.validate_semver_expression(
-            "cloud_sql_proxy", installed_version, self.required_version, self.recommended_version
-        )
-
-
-class GkeGcloudAuthPluginInstalled(Check):
-    name = "google.gkeGcloudAuthPluginInstalled"
-    depends_on = [GoogleCloudSdkInstalled]
-
-    suggestions = {
-        OS.UBUNTU: "<cmd>sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin</cmd>",
-        OS.GENERIC: "<cmd>gcloud components install gke-gcloud-auth-plugin</cmd>",
-    }
-
-    def check(self) -> CheckResult:
-        return self.verify(can_run_command("gke-gcloud-auth-plugin --version "), "GKE auth plugin is <not/> installed")
-
-
-class DockerGoogleCloudAuthConfigured(Check):
-    name = "google.dockerGCloudAuthConfigured"
-    depends_on = [GoogleCloudSdkInstalled]
-
-    def __init__(self, cloud_project, region, registry):
-        self.registry = registry
-        self.suggestions = {
-            OS.GENERIC: f"""
-                Setup gcloud authentication and docker credential helper for gcloud.
-                The following commands will open your browser and ask you to login and approve.
-                Run:
-                <cmd>rm -r ~/.config/gcloud</cmd>
-                <cmd>gcloud auth login</cmd>
-                <cmd>gcloud config set project {cloud_project}</cmd>
-                <cmd>gcloud config set --quiet compute/zone {region}</cmd>
-                <cmd>gcloud auth application-default login</cmd>
-                <cmd>gcloud auth configure-docker {registry}</cmd>
-                """
-        }
-
-    def check(self) -> CheckResult:
-        # Logged in with gcloud
-        google_config_path = os.path.expanduser("~/.config/gcloud/application_default_credentials.json")
-        if not file_exists(google_config_path):
-            return self.failed(f"{google_config_path} does not exist")
-
-        if not can_run_command("gcloud auth application-default print-access-token"):
-            return self.failed("Application Default Credentials are not correctly set up")
-
-        # Docker configured correctly
-        docker_config_path = os.path.expanduser("~/.docker/config.json")
-        if not file_exists(docker_config_path):
-            return self.failed(f"{docker_config_path} does not exist")
-
-        try:
-            with open(docker_config_path, "rb") as docker_config_file:
-                docker_config = json.load(docker_config_file)
-        except IOError:
-            logging.error(f"Exception reading {docker_config_path}", exc_info=True)
-            return self.failed(f"Failed to read {docker_config_path}")
-        except JSONDecodeError:
-            logging.error(f"Exception parsing {docker_config_path}", exc_info=True)
-            return self.failed(f"Failed to parse {docker_config_path}")
-
-        if docker_config.get("credHelpers", {}).get(self.registry) != "gcloud":
-            return self.failed("docker gcloud auth for {self.registry} not configured")
-
-        return self.passed("docker gcloud auth configured")

daktari/checks/intellij_idea.py

@@ -1,248 +0,0 @@
-import json
-import logging
-import os
-from json.decoder import JSONDecodeError
-from pathlib import Path
-from typing import Optional
-from xml.etree.ElementTree import Element
-
-import dpath.util
-from semver import VersionInfo
-
-from daktari.check import Check, CheckResult
-from daktari.checks.files import FilesExist
-from daktari.checks.xml import XmlFileXPathCheck
-from daktari.command_utils import get_stdout
-from daktari.os import OS, detect_os
-from daktari.version_utils import try_parse_semver, sanitise_version_string
-
-BUNDLE_ID_INTELLIJ_IDEA = "com.jetbrains.intellij"
-BUNDLE_ID_INTELLIJ_IDEA_CE = "com.jetbrains.intellij.ce"
-
-SNAP_NAME_INTELLIJ_IDEA = "intellij-idea-ultimate"
-SNAP_NAME_INTELLIJ_IDEA_CE = "intellij-idea-community"
-
-
-def locate_intellij_idea_mac():
-    from AppKit import NSWorkspace
-
-    for bundle_id in (BUNDLE_ID_INTELLIJ_IDEA, BUNDLE_ID_INTELLIJ_IDEA_CE):
-        url = NSWorkspace.sharedWorkspace().URLForApplicationWithBundleIdentifier_(bundle_id)
-        if url is not None:
-            logging.debug(f"IntelliJ IDEA location (via NSWorkspace): {url}")
-            return url
-
-    logging.debug("Could not find IntelliJ IDEA (via NSWorkspace)")
-    return None
-
-
-def get_intellij_idea_version_mac() -> Optional[VersionInfo]:
-    intellij_url = locate_intellij_idea_mac()
-    if intellij_url is None:
-        return None
-    else:
-        from Foundation import NSBundle
-
-        version_str = NSBundle.bundleWithURL_(intellij_url).objectForInfoDictionaryKey_("CFBundleShortVersionString")
-
-        version_str = sanitise_version_string(version_str)
-        version = try_parse_semver(version_str)
-
-        logging.debug(f"IntelliJ IDEA version (via NSBundle): {version} ({version_str})")
-        return version
-
-
-def get_intellij_idea_version_snap() -> Optional[VersionInfo]:
-    if not Path("/run/snapd.socket").is_socket():
-        logging.debug("/run/snapd.socket does not exist, not querying snapd")
-        return None
-
-    from requests_unixsocket import Session
-
-    session = Session()
-    snaps_req = session.get(
-        f"http+unix://%2Frun%2Fsnapd.socket/v2/snaps?snaps={SNAP_NAME_INTELLIJ_IDEA},{SNAP_NAME_INTELLIJ_IDEA_CE}"
-    )
-    snaps_info = snaps_req.json()
-    logging.debug(f"response from snapd: {snaps_info}")
-    version_str = dpath.util.get(snaps_info, "/result/0/version", default=None)
-    logging.debug(f"raw snapd version: {version_str}")
-    if not isinstance(version_str, str):
-        return None
-    version_str = sanitise_version_string(version_str)
-
-    version = try_parse_semver(version_str)
-    logging.debug(f"IntelliJ IDEA version (via snapd): {version}")
-    return version
-
-
-def get_intellij_idea_version_tarball() -> Optional[VersionInfo]:
-    idea_bin_path = get_stdout(["sh", "-c", "which idea.sh"])
-    if idea_bin_path is None:
-        return None
-
-    product_info_path = os.path.join(os.path.dirname(idea_bin_path), "..", "product-info.json")
-    return get_intellij_version_from_product_info(product_info_path)
-
-
-def get_intellij_idea_toolbox_version() -> Optional[VersionInfo]:
-    idea_bin_path = get_stdout(["sh", "-c", "which idea"])
-    if idea_bin_path is None:
-        return None
-
-    apps_dir = os.path.join(os.path.dirname(idea_bin_path), "..", "apps")
-    toolbox_apps = os.listdir(apps_dir)
-    logging.debug(f"Toolbox apps found: {toolbox_apps}", exc_info=True)
-    intellij_installs = [app for app in toolbox_apps if "intellij-idea" in app]
-    if len(intellij_installs) == 0:
-        logging.debug("No IntelliJ IDEA installs found")
-        return None
-
-    product_info_path = os.path.join(apps_dir, intellij_installs[0], "product-info.json")
-    return get_intellij_version_from_product_info(product_info_path)
-
-
-def get_intellij_version_from_product_info(product_info_path: str) -> Optional[VersionInfo]:
-    try:
-        with open(product_info_path, "rb") as product_info_file:
-            product_info = json.load(product_info_file)
-    except IOError:
-        logging.debug("Failed to read IntelliJ IDEA product-info.json", exc_info=True)
-        return None
-    except JSONDecodeError:
-        logging.debug("Failed to parse IntelliJ IDEA product-info.json", exc_info=True)
-        return None
-
-    version_str = product_info.get("version", None)
-    version = try_parse_semver(version_str)
-    logging.debug(f"IntelliJ IDEA version (via product-info.json): {version}")
-    return version
-
-
-def get_intellij_idea_version() -> Optional[VersionInfo]:
-    os = detect_os()
-    if os == OS.OS_X:
-        return get_intellij_idea_version_mac()
-    elif os == OS.UBUNTU:
-        return (
-            get_intellij_idea_version_snap()
-            or get_intellij_idea_version_tarball()
-            or get_intellij_idea_toolbox_version()
-        )
-    else:
-        return get_intellij_idea_version_tarball() or get_intellij_idea_toolbox_version()
-
-
-class IntelliJIdeaInstalled(Check):
-    name = "intellij.installed"
-
-    suggestions = {OS.GENERIC: "Install IntelliJ Ultimate: https://www.jetbrains.com/idea/download/"}
-
-    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-
-    def check(self) -> CheckResult:
-        intellij_version = get_intellij_idea_version()
-        return self.validate_semver_expression(
-            "IntelliJ IDEA", intellij_version, self.required_version, self.recommended_version
-        )
-
-
-class IntelliJProjectImported(FilesExist):
-    name = "intellij.projectImported"
-    file_paths = [".idea/workspace.xml"]
-    pass_fail_message = "Project <not/> imported into IntelliJ"
-    depends_on = [IntelliJIdeaInstalled]
-    suggestions = {
-        OS.GENERIC: """
-            From the IntelliJ start screen, click 'Open or Import' and choose the repository root directory
-            """
-    }
-
-
-class IntelliJNodePackageManagerConfigured(XmlFileXPathCheck):
-    name = "intellij.nodePackageManagerConfigured"
-    file_path = ".idea/workspace.xml"
-    xpath_query = "./component[@name='PropertiesComponent']"
-    depends_on = [IntelliJProjectImported]
-
-    def __init__(self, package_manager_path: str):
-        self.package_manager_path = package_manager_path
-        self.pass_fail_message = f"IntelliJ package manager has <not/> been set to {package_manager_path}"
-
-        self.suggestions = {
-            OS.GENERIC: f"""
-                Follow the steps to configure {self.package_manager_path} as your package manager:
-                https://www.jetbrains.com/help/idea/installing-and-removing-external-software-using-node-package-manager.html#ws_npm_yarn_configure_package_manager
-                """
-        }
-
-    def validate_query_result(self, result):
-        key_json = None if result is None else json.loads(result.text)
-        logging.debug(f"Raw properties json: {key_json}")
-        current_package_manager = str(key_json["keyToString"]["nodejs_package_manager_path"])
-        logging.debug(f"IntelliJ node package manager set to: {current_package_manager}")
-        return current_package_manager.__contains__(self.package_manager_path)
-
-
-class IntelliJTypescriptCompilerPathConfigured(XmlFileXPathCheck):
-    name = "intellij.typescriptCompilerPathConfigured"
-    file_path = ".idea/compiler.xml"
-    xpath_query = "./component[@name='TypeScriptCompiler']/option[@name='typeScriptServiceDirectory']"
-    depends_on = [IntelliJProjectImported]
-
-    def __init__(self, typescript_compiler_path: str):
-        self.typescript_compiler_path = typescript_compiler_path
-        resolved_path = typescript_compiler_path.replace("$PROJECT_DIR$", os.getcwd())
-        self.pass_fail_message = f"IntelliJ typescript compiler path has <not/> been set to {resolved_path}"
-
-        self.suggestions = {
-            OS.GENERIC: f"""
-                Follow the steps to set {resolved_path} as your typescript compiler path:
-                https://www.jetbrains.com/help/idea/typescript-support.html#ws_ts_use_ts_service_checkbox
-                """
-        }
-
-    def validate_query_result(self, result):
-        if result is None:
-            self.pass_fail_message = "IntelliJ typescript compiler path is <not/> set"
-            return False
-        current_typescript_compiler_path = result.get("value")
-        logging.debug(f"IntelliJ typescript compiler set to: {current_typescript_compiler_path}")
-        return current_typescript_compiler_path == self.typescript_compiler_path
-
-
-class IntelliJProjectSdkJavaVersion(XmlFileXPathCheck):
-    name = "intellij.jdkVersionConfigured"
-    file_path = ".idea/misc.xml"
-    xpath_query = "./component[@name='ProjectRootManager']"
-    depends_on = [IntelliJProjectImported]
-
-    def __init__(self, jdk_version: int):
-        self.jdk_version = jdk_version
-
-        self.suggestions = {
-            OS.GENERIC: f"""
-                Follow the steps to configure JDK {jdk_version}:
-                https://www.jetbrains.com/help/idea/sdk.html#change-project-sdk
-                """
-        }
-
-    def validate_query_result(self, result: Optional[Element]):
-        if result is None:
-            self.pass_fail_message = "IntelliJ Project SDK is not set"
-            return False
-
-        try:
-            jdk_type = result.attrib["project-jdk-type"]
-            if jdk_type != "JavaSDK":
-                self.pass_fail_message = f"IntelliJ Project SDK is not a Java JDK: {jdk_type}"
-                return False
-        except KeyError:
-            self.pass_fail_message = "IntelliJ Project SDK is not a Java JDK"
-            return False
-
-        language_level = result.attrib["languageLevel"]
-        self.pass_fail_message = f"IntelliJ Project SDK is <not/> set to Java {self.jdk_version}: {language_level}"
-        return language_level == f"JDK_{self.jdk_version}"

daktari/checks/java.py

@@ -1,104 +0,0 @@
-import logging
-import re
-from typing import Optional
-
-from semver import VersionInfo
-
-from daktari.check import Check, CheckResult
-from daktari.command_utils import get_stderr, run_command
-from daktari.os import OS
-
-java_version_pattern = re.compile('^.*version "(.*?)".*$', re.MULTILINE)
-javac_version_pattern = re.compile("^javac (.*)$", re.MULTILINE)
-
-one_dot_pattern = re.compile("1\\.([0-9]+)")
-other_pattern = re.compile("([0-9]+)")
-
-
-def get_java_version() -> Optional[VersionInfo]:
-    version_output = get_stderr("java -version")
-    return parse_java_version_output(version_output)
-
-
-def get_jdk_version() -> Optional[VersionInfo]:
-    try:
-        version_output = run_command("javac -version")
-    except Exception:
-        return None
-
-    return parse_javac_version_output(version_output.stdout + version_output.stderr)
-
-
-def parse_java_version_output(version_output: Optional[str]) -> Optional[VersionInfo]:
-    if version_output:
-        match = java_version_pattern.search(version_output)
-        if match:
-            version_string = match.group(1)
-            logging.debug(f"Java version string: {version_string}")
-            return parse_java_version_string(version_string)
-    return None
-
-
-def parse_javac_version_output(version_output: Optional[str]) -> Optional[VersionInfo]:
-    if version_output:
-        match = javac_version_pattern.search(version_output)
-        if match:
-            version_string = match.group(1)
-            logging.debug(f"JDK version string: {version_string}")
-            return parse_java_version_string(version_string)
-    return None
-
-
-def parse_java_version_string(version_string: str) -> Optional[VersionInfo]:
-    try:
-        return VersionInfo.parse(version_string)
-    except ValueError:
-        return parse_alternative_java_version_numbers(version_string)
-
-
-def parse_alternative_java_version_numbers(version_string: str) -> Optional[VersionInfo]:
-    one_dot_match = one_dot_pattern.search(version_string)
-    if one_dot_match:
-        return VersionInfo(int(one_dot_match.group(1)))
-    other_pattern_match = other_pattern.search(version_string)
-    if other_pattern_match:
-        return VersionInfo(int(other_pattern_match.group(1)))
-    return None
-
-
-class JavaVersion(Check):
-    name = "java.version"
-
-    def __init__(
-        self,
-        required_version: Optional[str] = None,
-        recommended_version: Optional[str] = None,
-        java_instructions: Optional[str] = None,
-    ):
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-
-        java_instructions = f"\n\n{java_instructions}" if java_instructions else ""
-        self.suggestions = {OS.GENERIC: f"""Install Java{java_instructions}"""}
-
-    def check(self) -> CheckResult:
-        java_version = get_java_version()
-        logging.info(f"Java version: {java_version}")
-        return self.validate_semver_expression("Java", java_version, self.required_version, self.recommended_version)
-
-
-class JdkVersion(Check):
-    name = "jdk.version"
-
-    def __init__(self, required_version: str, recommended_version: Optional[str] = None):
-        self.required_version = required_version
-        self.recommended_version = recommended_version
-
-    suggestions = {
-        OS.GENERIC: "Install Java JDK",
-    }
-
-    def check(self) -> CheckResult:
-        jdk_version = get_jdk_version()
-        logging.info(f"JDK version: {jdk_version}")
-        return self.validate_semver_expression("JDK", jdk_version, self.required_version, self.recommended_version)