metripy 0.2.7__py3-none-any.whl

metripy/Application/Analyzer.py

@@ -0,0 +1,106 @@
+from metripy.Application.Config.ProjectConfig import ProjectConfig
+from metripy.Component.Debug.Debugger import Debugger
+from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Component.Output.ProgressBar import ProgressBar
+from metripy.Dependency.Composer.Composer import Composer
+from metripy.Dependency.Dependency import Dependency
+from metripy.Dependency.Npm.Npm import Npm
+from metripy.Dependency.Pip.Pip import Pip
+from metripy.Git.GitAnalyzer import GitAnalyzer
+from metripy.LangAnalyzer.AbstractLangAnalyzer import AbstractLangAnalyzer
+from metripy.LangAnalyzer.Php.PhpAnalyzer import PhpAnalyzer
+from metripy.LangAnalyzer.Python.PythonAnalyzer import PythonAnalyzer
+from metripy.LangAnalyzer.Typescript.TypescriptAnalyzer import \
+    TypescriptAnalyzer
+from metripy.Metric.Code.FileMetrics import FileMetrics
+from metripy.Metric.Git.GitMetrics import GitMetrics
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+
+
+class Analyzer:
+    def __init__(self, config: ProjectConfig, output: CliOutput, debugger: Debugger):
+        self.config = config
+        self.output = output
+        self.debugger = debugger
+        self.runners: list[AbstractLangAnalyzer] = [
+            PythonAnalyzer(),
+            PhpAnalyzer(),
+            TypescriptAnalyzer(),
+        ]
+
+    def analyze_git(self) -> GitMetrics:
+        self.output.writeln("<info>Analyzing git history...</info>")
+        metrics = GitAnalyzer(self.config.git).analyze()
+        self.output.writeln("<success>Git history analyzed</success>")
+
+        return metrics
+
+    def analyze_code(self, files: list[str]) -> list[FileMetrics]:
+        file_metrics = []
+
+        # for multi language projects, register runner per language
+        runner_sizes = []
+        for runner in self.runners:
+            runner.set_files(files)
+            if not runner.is_needed():
+                continue
+            runner_sizes.append(len(runner.files))
+
+        self.debugger.debug(len(files))
+        self.output.writeln("<info>Analyzing code...</info>")
+        progress_bar = ProgressBar(self.output, sum(runner_sizes))
+        for runner in self.runners:
+            if not runner.is_needed():
+                continue
+            runner.before_run()
+            runner.run(progress_bar)
+            runner.after_run()
+
+            for metric in runner.get_metrics():
+                file_metrics.append(metric)
+
+        self.output.writeln("")
+        self.output.writeln("<success>Code analyzed</success>")
+
+        return file_metrics
+
+    def analyze_composer(self) -> list[Dependency]:
+        self.output.writeln("<info>Analyzing composer packages...</info>")
+        dependencies = Composer().get_composer_dependencies(self.config.base_path)
+        self.output.writeln("<success>Composer packages analyzed</success>")
+
+        return dependencies
+
+    def analyze_pip(self) -> list[Dependency]:
+        self.output.writeln("<info>Analyzing pip packages...</info>")
+        dependencies = Pip().get_dependencies(self.config.base_path)
+        self.output.writeln("<success>Pip packages analyzed</success>")
+
+        return dependencies
+
+    def analyze_npm(self) -> list[Dependency]:
+        self.output.writeln("<info>Analyzing npm packages...</info>")
+        dependencies = Npm().get_dependencies(self.config.base_path)
+        self.output.writeln("<success>Npm packages analyzed</success>")
+
+        return dependencies
+
+    def run(self, files: list[str]) -> ProjectMetrics:
+        git_stats = None
+        if self.config.git:
+            git_stats = self.analyze_git()
+
+        file_metrics = []
+        if True:
+            file_metrics = self.analyze_code(files)
+
+        # TODO: analyze dependencies: composer, pip, npm, etc etc
+        packages = None
+        if self.config.composer:
+            packages = self.analyze_composer()
+        elif self.config.pip:
+            packages = self.analyze_pip()
+        elif self.config.npm:
+            packages = self.analyze_npm()
+
+        return ProjectMetrics(file_metrics, git_stats, packages)

metripy/Application/Application.py

@@ -0,0 +1,54 @@
+import json
+
+from metripy.Application.Analyzer import Analyzer
+from metripy.Application.Config.Parser import Parser
+from metripy.Component.Debug.Debugger import Debugger
+from metripy.Component.File.Finder import Finder
+from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Report.ReporterFactory import ReporterFactory
+from metripy.Report.ReporterInterface import ReporterInterface
+
+
+class Application:
+    def run(self, argv) -> None:
+        output = CliOutput()
+
+        # issues and debug
+        debugger = Debugger(output).enable()
+
+        config = Parser().parse(argv)
+
+        finder = Finder()
+        files = finder.fetch(config.project_configs)
+
+        for project_config in config.project_configs:
+            debugger.debug(project_config.name)
+            project_files = files[project_config.name]
+            debugger.debug(f"Found {len(project_files)} files")
+            debugger.debug(json.dumps(project_files))
+
+            output.writeln(f"<info>Analying Project {project_config.name}...</info>")
+            project_metrics = Analyzer(project_config, output, debugger).run(
+                project_files
+            )
+            output.writeln(
+                f"<success>Done analying Project {project_config.name}</success>"
+            )
+
+            if not project_config.reports:
+                output.writeln(
+                    f"<success>Skipping reports of {project_config.name}!</success>"
+                )
+                continue
+
+            output.writeln(
+                f"<info>Generating reports for {project_config.name}...</info>"
+            )
+            for report_config in project_config.reports:
+                reporter: ReporterInterface = ReporterFactory.create(
+                    report_config, output
+                )
+                reporter.generate(project_metrics)
+            output.writeln(
+                f"<success>Reports generated for {project_config.name}</success>"
+            )

metripy/Application/Config/Config.py

@@ -0,0 +1,13 @@
+from metripy.Application.Config.ProjectConfig import ProjectConfig
+
+
+class Config:
+    def __init__(self):
+        self.project_configs: list[ProjectConfig] = []
+
+    def to_dict(self) -> dict:
+        return {
+            "project_configs": [
+                project_config.to_dict() for project_config in self.project_configs
+            ],
+        }

metripy/Application/Config/File/ConfigFileReaderFactory.py

@@ -0,0 +1,24 @@
+import os
+import pathlib
+
+from metripy.Application.Config.File.ConfigFileReaderInterface import \
+    ConfigFileReaderInterface
+from metripy.Application.Config.File.JsonConfigFileReader import \
+    JsonConfigFileReader
+
+
+class ConfigFileReaderFactory:
+    @staticmethod
+    def createFromFileName(filename: str) -> ConfigFileReaderInterface:
+        if not os.path.isfile(filename):
+            raise FileNotFoundError(f"File {filename} does not exist")
+
+        extension = pathlib.Path(filename).suffix
+        if extension == ".json":
+            return JsonConfigFileReader(filename)
+        elif extension == ".yaml" or extension == ".yml":
+            raise NotImplementedError("YAML support is not implemented yet")
+        elif extension == ".xml":
+            raise NotImplementedError("XML support is not implemented yet")
+        else:
+            raise NotImplementedError(f"Unsupported file type: {extension}")

metripy/Application/Config/File/ConfigFileReaderInterface.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+from metripy.Application.Config.Config import Config
+
+
+class ConfigFileReaderInterface(ABC):
+
+    @abstractmethod
+    def __init__(self, filename: str):
+        pass
+
+    @abstractmethod
+    def read(self, config: Config) -> None:
+        pass

metripy/Application/Config/File/JsonConfigFileReader.py

@@ -0,0 +1,82 @@
+import json
+import os
+
+from metripy.Application.Config.Config import Config
+from metripy.Application.Config.File.ConfigFileReaderInterface import \
+    ConfigFileReaderInterface
+from metripy.Application.Config.GitConfig import GitConfig
+from metripy.Application.Config.ProjectConfig import ProjectConfig
+from metripy.Application.Config.ReportConfig import ReportConfig
+
+
+class JsonConfigFileReader(ConfigFileReaderInterface):
+    def __init__(self, filename: str):
+        self.filename = filename
+
+    def read(self, config: Config) -> None:
+        with open(self.filename, "r") as file:
+            json_data = json.load(file)
+
+        self.parse_json(json_data, config)
+
+    def resolve_path(self, path: str) -> str:
+        return os.path.join(os.path.dirname(self.filename), path)
+
+    def parse_json(self, json_data: dict, config: Config) -> None:
+
+        # configs
+        if configs := json_data.get("configs"):
+            for project_name, project_config in configs.items():
+                project_config = self.parse_config_json(project_name, project_config)
+                config.project_configs.append(project_config)
+
+    def parse_config_json(self, project_name: str, json_data: dict) -> ProjectConfig:
+        project_config = ProjectConfig(project_name)
+
+        # extensions
+        if base_path := json_data.get("base_path"):
+            project_config.base_path = base_path
+
+        # includes
+        if includes := json_data.get("includes"):
+            files = []
+            # with config file, includes are relative to the config file
+            for include in includes:
+                include = self.resolve_path(include)
+                files.append(include)
+
+            project_config.includes = files
+
+        # extensions
+        if extensions := json_data.get("extensions"):
+            project_config.extensions = extensions
+
+        # excludes
+        if excludes := json_data.get("excludes"):
+            project_config.excludes = excludes
+
+        # reports
+        if reports := json_data.get("reports"):
+            for report_type, path in reports.items():
+                path = self.resolve_path(path)
+                project_config.reports.append(ReportConfig(report_type, path))
+
+        # git
+        if git := json_data.get("git"):
+            project_config.git = GitConfig()
+            project_config.git.repo = project_config.base_path
+            project_config.git.branch = git.get("branch", project_config.git.branch)
+
+        # composer
+        if composer := json_data.get("composer"):
+            project_config.composer = composer
+
+        # pip
+        if pip := json_data.get("pip"):
+            project_config.pip = pip
+
+        # npm
+        if npm := json_data.get("npm"):
+            project_config.npm = npm
+
+        return project_config

metripy/Application/Config/GitConfig.py

@@ -0,0 +1,10 @@
+class GitConfig:
+    def __init__(self):
+        self.repo = "./"
+        self.branch = "main"
+
+    def to_dict(self) -> dict:
+        return {
+            "repo": self.repo,
+            "branch": self.branch,
+        }

metripy/Application/Config/Parser.py

@@ -0,0 +1,31 @@
+import re
+
+from metripy.Application.Config.Config import Config
+from metripy.Application.Config.File.ConfigFileReaderFactory import \
+    ConfigFileReaderFactory
+
+
+class Parser:
+    def parse(self, argv: list[str]) -> Config:
+        config = Config()
+
+        if argv[0] == "codemetrics.py" or argv[0] == "codemetrics":
+            # TODO, fix when path ends with codemetrics.py
+            pass
+        argv.pop(0)
+
+        # check for a config file
+        for key, arg in enumerate(argv):
+            if matches := re.search(r"^--config=(.+)$", arg):
+                fileReader = ConfigFileReaderFactory.createFromFileName(
+                    matches.group(1)
+                )
+                fileReader.read(config)
+                argv.pop(key)
+
+        # TODO: add the following
+        # arguments with options
+        # arguments without options
+        # last argument
+
+        return config

metripy/Application/Config/ProjectConfig.py

@@ -0,0 +1,27 @@
+from metripy.Application.Config.GitConfig import GitConfig
+from metripy.Application.Config.ReportConfig import ReportConfig
+
+
+class ProjectConfig:
+    def __init__(self, name: str):
+        self.name: str = name
+        self.base_path: str = "./"
+        self.includes: list[str] = []
+        self.excludes: list[str] = []
+        self.extensions: list[str] = []
+        self.git: GitConfig | None = None
+        self.composer: bool = False
+        self.pip: bool = False
+        self.npm: bool = False
+        self.reports: list[ReportConfig] = []
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "base_path": self.base_path,
+            "includes": self.includes,
+            "excludes": self.excludes,
+            "extensions": self.extensions,
+            "git": self.git.to_dict() if self.git else None,
+            "reports": [report.to_dict() for report in self.reports],
+        }

metripy/Application/Config/ReportConfig.py

@@ -0,0 +1,10 @@
+class ReportConfig:
+    def __init__(self, report_type: str, path: str) -> None:
+        self.type = report_type
+        self.path = path
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type,
+            "path": self.path,
+        }

metripy/Component/Debug/Debugger.py

@@ -0,0 +1,20 @@
+from typing import Self
+
+from metripy.Component.Output.CliOutput import CliOutput
+
+
+class Debugger:
+    def __init__(self, output: CliOutput):
+        self.enabled = False
+        self.output = output
+
+    def enable(self) -> Self:
+        self.enabled = True
+
+        return self
+
+    def debug(self, message: str):
+        if not self.enabled:
+            return
+
+        self.output.writeln(f"<debug>{message}</debug>")

metripy/Component/File/Finder.py

@@ -0,0 +1,37 @@
+import os
+
+from metripy.Application.Config.ProjectConfig import ProjectConfig
+
+
+class Finder:
+    def fetch(self, project_configs: list[ProjectConfig]) -> dict[str, list[str]]:
+        """returns a list of files per project project_name => [files,...]"""
+        project_files = {}
+        for project_config in project_configs:
+            files = []
+
+            paths = [
+                os.path.join(project_config.base_path, inc)
+                for inc in project_config.includes
+            ]
+            for path in paths:
+                if os.path.isdir(path):
+                    self._search(
+                        path, project_config.extensions, project_config.excludes, files
+                    )
+            project_files[project_config.name] = files
+
+        return project_files
+
+    def _search(
+        self, path: str, extensions: list[str], excludes: list[str], results: list[str]
+    ):
+        if not os.path.isdir(path):
+            if path not in excludes and path.endswith(tuple(extensions)):
+                results.append(path)
+
+        for file in os.listdir(path):
+            if os.path.isdir(os.path.join(path, file)) and file not in excludes:
+                self._search(os.path.join(path, file), extensions, excludes, results)
+            elif file not in excludes and file.endswith(tuple(extensions)):
+                results.append(os.path.join(path, file))

metripy/Component/Output/CliOutput.py

@@ -0,0 +1,49 @@
+import re
+import sys
+from typing import Self
+
+
+class CliOutput:
+    def __init__(self):
+        self.quiet_mode = False
+
+    def set_quiet_mode(self, quiet_mode: bool):
+        self.quiet_mode = quiet_mode
+
+    def writeln(self, message: str) -> Self:
+        self.write(str(message), end="\n")
+
+        return self
+
+    def write(self, message: str, end="") -> Self:
+        if matches := re.search(r"<([a-z]+)>(.*?)</([a-z]+)>", message):
+            type = matches.group(1)
+            message = matches.group(2)
+            color = {
+                "error": "\033[31m",
+                "warning": "\033[33m",
+                "success": "\033[32m",
+                "info": "\033[34m",
+                "debug": "\033[95m",
+            }
+            message = color[type] + message + "\033[0m"
+
+        if not self.quiet_mode:
+            print(message, end=end)
+
+        return self
+
+    def err(self, message: str) -> Self:
+        sys.stderr.write(message)
+
+        return self
+
+    def clearln(self) -> Self:
+        if self.has_ansi():
+            self.write("\x0d")
+            self.write("\x1b[2K")
+
+        return self
+
+    def has_ansi(self) -> bool:
+        return sys.stdout.isatty()

metripy/Component/Output/ProgressBar.py

@@ -0,0 +1,27 @@
+from metripy.Component.Output.CliOutput import CliOutput
+
+
+class ProgressBar:
+    def __init__(self, output: CliOutput, total: int):
+        self.output = output
+        self.total = total
+        self.current = 0
+
+    def start(self):
+        self.current = 0
+
+    def advance(self):
+        self.current += 1
+
+        if self.output.has_ansi():
+            percent = round(self.current / self.total * 100)
+            self.output.write("\x0d")
+            self.output.write("\x1b[2K")
+            self.output.write(f"... {percent}% ...")
+        else:
+            self.output.write(".")
+
+    def clear(self):
+        if self.output.has_ansi():
+            self.output.write("\x0d")
+            self.output.write("\x1b[2K")

metripy/Dependency/Composer/Composer.py

@@ -0,0 +1,30 @@
+import json
+import os
+
+from metripy.Dependency.Composer.Packegist import Packegist
+from metripy.Dependency.Dependency import Dependency
+
+
+class Composer:
+    def get_composer_dependencies(self, composer_json_path: str):
+        requirements = self.get_composer_json_requirements(composer_json_path)
+
+        packegist = Packegist()
+        packages = []
+        for dependency in requirements:
+            package = packegist.get_info(dependency)
+            packages.append(package)
+
+        return [item for item in packages if item is not None]
+
+    def get_composer_json_requirements(self, composer_json_path) -> list:
+        requirements = []
+        with open(os.path.join(composer_json_path, "composer.json"), "r") as file:
+            composer_json = json.load(file)
+            require = composer_json.get("require", None)
+            if require is None:
+                return []
+            for name, version in require.items():
+                requirements.append(Dependency(name, version))
+
+        return requirements

metripy/Dependency/Composer/Packegist.py

@@ -0,0 +1,55 @@
+import re
+
+import requests
+from packaging import version
+
+from metripy.Dependency.Dependency import Dependency
+
+
+class Packegist:
+    def get_info(self, dependency: Dependency) -> Dependency | None:
+        if "/" not in dependency.name:
+            return None
+        [user, name] = dependency.name.split("/", 2)
+        uri = f"https://packagist.org/packages/{user}/{name}.json"
+
+        x = requests.get(uri)
+        d = x.json()
+
+        package_info = d.get("package", None)
+        if package_info is None:
+            print(f"package of {dependency.name} has no package info")
+            return dependency
+
+        dependency.type = package_info["type"]
+        dependency.description = package_info["description"]
+        dependency.repository = package_info["repository"]
+        dependency.github_stars = package_info["github_stars"]
+        dependency.downloads_total = package_info["downloads"]["total"]
+        dependency.downloads_monthly = package_info["downloads"]["monthly"]
+        dependency.downloads_daily = package_info["downloads"]["daily"]
+
+        latest = version.parse("0.0.0")
+        versions = package_info["versions"]
+        for ver_str, datas in versions.items():
+            # Strip leading 'v' if present
+            if ver_str.startswith("v"):
+                ver_str = ver_str[1:]
+
+            # Skip non-semver strings
+            if not re.match(r"^[\d.]+$", ver_str):
+                continue
+
+            current_version = version.parse(ver_str)
+            if current_version > latest:
+                latest = current_version
+                dependency.latest = ver_str
+                dependency.license = datas.get("license", [])
+                dependency.homepage = datas.get("homepage")
+                dependency.zip = datas.get("dist", {}).get("url")
+
+        if dependency.version == dependency.latest:
+            dependency.status = "latest"
+        else:
+            dependency.status = "outdated"
+        return dependency

metripy/Dependency/Dependency.py

@@ -0,0 +1,30 @@
+class Dependency:
+    def __init__(self, name: str, version: str):
+        self.name = name
+        self.version = version
+        self.latest: str = ""
+        self.status: str = "unknown"
+        self.type: str = ""
+        self.description: str = ""
+        self.repository: str = ""
+        self.github_stars: int = 0
+        self.downloads_total: int = 0
+        self.downloads_monthly: int = 0
+        self.downloads_daily: int = 0
+        self.license: list[str] = []
+        self.homepage: str = ""
+        self.zip: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "version": self.version,
+            "latest": self.latest,
+            "status": self.status,
+            "type": self.type,
+            "description": self.description,
+            "repository": self.repository,
+            "github_stars": self.github_stars,
+            "downloads_monthly": self.downloads_monthly,
+            "licenses": ",".join(self.license),
+        }

metripy/Dependency/Npm/Npm.py

@@ -0,0 +1,30 @@
+import json
+import os
+
+from metripy.Dependency.Dependency import Dependency
+from metripy.Dependency.Npm.NpmOrg import NpmOrg
+
+
+class Npm:
+    def get_dependencies(self, path: str) -> list[Dependency]:
+        requirements = self._get_requirements(path)
+
+        npm_org = NpmOrg()
+        packages = []
+        for dependency in requirements:
+            package = npm_org.get_info(dependency)
+            packages.append(package)
+
+        return [item for item in packages if item is not None]
+
+    def _get_requirements(self, path: str) -> list[Dependency]:
+        requirements = []
+        with open(os.path.join(path, "package.json"), "r") as file:
+            package_json = json.load(file)
+            dependencies = package_json.get("dependencies", None)
+            if dependencies is None:
+                return None
+            for name, version in dependencies.items():
+                requirements.append(Dependency(name, version))
+
+        return requirements