codeguardian-cli 1.0.0__tar.gz

codeguardian_cli-1.0.0/CODEGUARDIAN/analyzers/circular_dependency_analyzer.py

@@ -0,0 +1,101 @@
+
+class CircularViolation:
+
+    def __init__(self, cycle):
+
+        self.cycle = cycle
+
+
+class CircularDependencyAnalyzer:
+
+    def __init__(self):
+
+        self.graph = {}
+
+    def build_graph(self, dependencies):
+
+        self.graph = {}
+
+        for dep in dependencies:
+
+            source = dep.source_file
+            target = dep.target_module
+
+            if source not in self.graph:
+                self.graph[source] = []
+
+            self.graph[source].append(target)
+
+    def dfs(
+        self,
+        node,
+        visited,
+        rec_stack,
+        path,
+        cycles
+    ):
+
+        visited.add(node)
+        rec_stack.add(node)
+        path.append(node)
+
+        for neighbor in self.graph.get(node, []):
+
+            if neighbor not in visited:
+
+                self.dfs(
+                    neighbor,
+                    visited,
+                    rec_stack,
+                    path,
+                    cycles
+                )
+
+            elif neighbor in rec_stack:
+
+                cycle_start = path.index(
+                    neighbor
+                )
+
+                cycle = (
+                    path[cycle_start:]
+                    + [neighbor]
+                )
+
+                cycle_tuple = tuple(cycle)
+
+                if cycle_tuple not in {
+
+                    tuple(c)
+
+                    for c in cycles
+                }:
+
+                    cycles.append(cycle)
+        rec_stack.remove(node)
+        path.pop()
+
+    def detect(self, dependencies):
+
+        self.build_graph(dependencies)
+
+        visited = set()
+        rec_stack = set()
+        cycles = []
+
+        for node in self.graph:
+
+            if node not in visited:
+
+                self.dfs(
+                    node,
+                    visited,
+                    rec_stack,
+                    [],
+                    cycles
+                )
+
+        return [
+            CircularViolation(cycle)
+            for cycle in cycles
+        ]

codeguardian_cli-1.0.0/CODEGUARDIAN/analyzers/db_access_analyzer.py

@@ -0,0 +1,55 @@
+from CODEGUARDIAN.utils.layer_utils import get_layer
+
+
+
+class DBAccessViolation:
+
+    def __init__(self, source_file, database_library):
+
+        self.source_file = source_file
+        self.database_library = database_library
+
+
+class DBAccessAnalyzer:
+
+    DB_LIBRARIES = {
+
+        "mongoose",
+        "sequelize",
+        "prisma"
+
+
+    }
+
+    def analyze(self, dependencies ):
+
+        violations = []
+
+        for dependency in dependencies:
+
+          source_layer = get_layer(dependency.source_file)
+
+          if source_layer != "controllers":
+
+              continue
+
+          for db_library in self.DB_LIBRARIES:
+
+            if db_library in dependency.target_module:
+
+                violations.append(
+
+                    DBAccessViolation(
+
+                        dependency.source_file,
+
+                        db_library
+                    )
+                )
+
+        return violations
+    
+
+            
+
+        

codeguardian_cli-1.0.0/CODEGUARDIAN/analyzers/dependency_analyzer.py

@@ -0,0 +1,259 @@
+import ast
+import os
+
+from CODEGUARDIAN.config.config_loader import ConfigLoader
+
+from CODEGUARDIAN.src.parser.ts_parser import (
+    parse_typescript
+)
+
+from CODEGUARDIAN.src.tree.Walker import walk
+
+from CODEGUARDIAN.utils.ast_cache import ASTCache
+class Dependency:
+
+    def __init__(
+        self,
+        source_file,
+        target_module
+    ):
+
+        self.source_file = source_file
+        self.target_module = target_module
+
+
+class DependencyAnalyzer:
+
+    def __init__(self):
+
+        self.config = ConfigLoader.load()
+
+        self.supported_extensions = set(
+            self.config["supported_extensions"]
+        )
+
+    def analyze_python_file(
+        self,
+        file_path,
+        project_root
+    ):
+
+        dependencies = []
+
+        relative_path = os.path.relpath(
+            file_path,
+            project_root
+        )
+
+        module_name = (
+            relative_path
+            .replace(".py", "")
+            .replace(os.sep, ".")
+        )
+
+        with open(
+            file_path,
+            "r",
+            encoding="utf-8"
+        ) as file:
+
+            source = file.read()
+        try:
+           tree = ASTCache.get_tree(
+           file_path,
+           source
+           )
+        except SyntaxError:
+            return []
+
+        for node in ast.walk(tree):
+
+            if isinstance(
+                node,
+                ast.ImportFrom
+            ):
+
+                if node.module:
+
+                    dependencies.append(
+
+                        Dependency(
+                            module_name,
+                            node.module
+                        )
+                    )
+
+            elif isinstance(
+                node,
+                ast.Import
+            ):
+
+                for imported in node.names:
+
+                    dependencies.append(
+
+                        Dependency(
+                            module_name,
+                            imported.name
+                        )
+                    )
+
+        return dependencies
+
+    def analyze_ts_js_file(
+        self,
+        file_path,
+        project_root
+    ):
+
+        dependencies = []
+
+        relative_path = os.path.relpath(
+            file_path,
+            project_root
+        )
+
+        module_name = (
+            relative_path
+            .replace(".ts", "")
+            .replace(".js", "")
+            .replace(os.sep, ".")
+        )
+
+        with open(
+            file_path,
+            "r",
+            encoding="utf-8"
+        ) as file:
+
+            source = file.read()
+        try:
+            tree = ASTCache.get_tree(
+             file_path,
+             source
+            )
+        except Exception:
+            return []
+        
+        if tree.root_node.has_error:
+            return []
+
+        def visit(node):
+
+            if node.type != "import_statement":
+
+                return
+
+            source_node = node.child_by_field_name(
+                "source"
+            )
+
+            if not source_node:
+
+                return
+
+            imported_module = (
+                source_node.text
+                .decode("utf8")
+                .replace('"', "")
+                .replace("'", "")
+            )
+            if imported_module.startswith("./"):
+
+                current_directory = ".".join(
+                    module_name.split(".")[:-1]
+                )
+
+                imported_module = (
+                    current_directory
+                    + "."
+                    + imported_module[2:]
+                )
+
+                imported_module = imported_module.replace(
+                    "/",
+                    "."
+                )
+
+            dependencies.append(
+
+                Dependency(
+                    module_name,
+                    imported_module
+                )
+            )
+
+        walk(
+            tree.root_node,
+            visit
+        )
+
+        return dependencies
+
+    def analyze_project(
+        self,
+        project_path
+    ):
+
+        dependencies = []
+
+       
+
+        ignore_dirs = set(
+            self.config[
+                "ignored_directories"
+            ]
+        )
+
+        for root, dirs, files in os.walk(project_path):
+
+            dirs[:] = [
+
+                d for d in dirs
+
+                if d not in ignore_dirs
+            ]
+
+            for file in files:
+
+                extension = os.path.splitext(
+                    file
+                )[1]
+
+                if (
+                    extension
+                    not in self.supported_extensions
+                ):
+
+                    continue
+
+                file_path = os.path.join(
+                    root,
+                    file
+                )
+
+                if extension == ".py":
+
+                    dependencies.extend(
+
+                        self.analyze_python_file(
+                            file_path,
+                            project_path
+                        )
+                    )
+
+                elif extension in {
+
+                    ".ts",
+                    ".js"
+                }:
+
+                    dependencies.extend(
+
+                        self.analyze_ts_js_file(
+                            file_path,
+                            project_path
+                        )
+                    )
+
+        return dependencies

codeguardian_cli-1.0.0/CODEGUARDIAN/analyzers/file_analyzer.py

@@ -0,0 +1,96 @@
+import os
+
+from CODEGUARDIAN.config.config_loader import ConfigLoader
+
+
+from CODEGUARDIAN.utils.file_cache import FileCache
+
+
+from CODEGUARDIAN.src.discovery.finder import discover_files
+
+
+class FileViolation:
+
+    def __init__(
+        self,
+        file_path,
+        line_count
+    ):
+
+        self.file_path = str(file_path)
+        self.line_count = line_count
+
+
+class FileAnalyzer:
+
+    def __init__(
+        self,
+        max_lines=None
+    ):
+
+        config = ConfigLoader.load()
+
+        if max_lines is None:
+
+            max_lines = config[
+                "max_file_lines"
+            ]
+
+        self.max_lines = max_lines
+       
+
+        self.supported_extensions = set(
+
+            config[
+                "supported_extensions"
+            ]
+        )
+
+    def analyze(
+        self,
+        project_path
+    ):
+
+        violations = []
+
+        files = FileCache.get_files(
+         project_path,
+         self.supported_extensions
+        )
+
+        for file_path in files:
+
+         
+
+                try:
+
+                    with open(
+                        file_path,
+                        "r",
+                        encoding="utf-8"
+                    ) as f:
+
+                        line_count = len(
+                            f.readlines()
+                        )
+
+                    if (
+
+                        line_count
+                        > self.max_lines
+
+                    ):
+
+                        violations.append(
+
+                            FileViolation(
+                                str(file_path),
+                                line_count
+                            )
+                        )
+
+                except UnicodeDecodeError:
+
+                    continue
+
+        return violations

codeguardian_cli-1.0.0/CODEGUARDIAN/analyzers/function_analyzer.py

@@ -0,0 +1,199 @@
+import ast
+
+
+from CODEGUARDIAN.config.config_loader import ConfigLoader
+
+
+
+from CODEGUARDIAN.src.tree.Walker import walk
+from CODEGUARDIAN.utils.file_cache import FileCache
+from CODEGUARDIAN.utils.ast_cache import ASTCache
+
+
+class FunctionViolation:
+
+    def __init__(
+        self,
+        function_name,
+        line_count
+    ):
+
+        self.function_name = function_name
+        self.line_count = line_count
+
+
+class FunctionAnalyzer:
+
+    def __init__(
+        self,
+        max_lines=None
+    ):
+
+        config = ConfigLoader.load()
+
+        if max_lines is None:
+
+            max_lines = config[
+                "max_function_lines"
+            ]
+
+        self.max_lines = max_lines
+
+        self.supported_extensions = set(
+            config[
+                "supported_extensions"
+            ]
+        )
+
+    def analyze_python_file(
+        self,
+        file_path
+    ):
+
+        violations = []
+
+        with open(
+            file_path,
+            "r",
+            encoding="utf-8"
+        ) as f:
+
+            source = f.read()
+        try:
+
+            tree = ASTCache.get_tree(
+            file_path,
+            source
+            )
+        except SyntaxError:
+            return []
+
+        for node in ast.walk(tree):
+
+            if isinstance(
+                node,
+                ast.FunctionDef
+            ):
+
+                line_count = (
+                    node.end_lineno
+                    - node.lineno
+                    + 1
+                )
+
+                if line_count > self.max_lines:
+
+                    violations.append(
+
+                        FunctionViolation(
+                            node.name,
+                            line_count
+                        )
+                    )
+
+        return violations
+
+    def analyze_ts_js_file(
+        self,
+        file_path
+    ):
+
+        violations = []
+
+        with open(
+            file_path,
+            "r",
+            encoding="utf-8"
+        ) as file:
+
+            source = file.read()
+
+
+        try:
+            tree = ASTCache.get_tree(
+             file_path,
+             source
+            )
+        except Exception:
+            return []
+        
+        if tree.root_node.has_error:
+           return []
+
+        def visit(node):
+
+            if node.type != "function_declaration":
+
+                return
+
+            name_node = node.child_by_field_name(
+                "name"
+            )
+
+            if not name_node:
+
+                return
+
+            function_name = (
+                name_node.text.decode("utf8")
+            )
+
+            line_count = (
+                node.end_point[0]
+                - node.start_point[0]
+                + 1
+            )
+
+            if line_count > self.max_lines:
+
+                violations.append(
+
+                    FunctionViolation(
+                        function_name,
+                        line_count
+                    )
+                )
+
+        walk(
+            tree.root_node,
+            visit
+        )
+
+        return violations
+
+    def analyze_project(
+      self,
+      project_path 
+      ):
+
+      violations = []
+
+      files = FileCache.get_files(
+        project_path,
+        self.supported_extensions
+        )    
+
+      for file_path in files:
+
+        extension = file_path.suffix
+
+        if extension == ".py":
+
+            violations.extend(
+                self.analyze_python_file(
+                    file_path
+                )
+            )
+
+        elif extension in {
+            ".ts",
+            ".js"
+        }:
+
+            violations.extend(
+                self.analyze_ts_js_file(
+                    file_path
+                )
+            )
+
+      return violations