[16.0][FEAT] cloc Implementation

Author: GarethGloSystems

glodo_client/__manifest__.py

@@ -7,7 +7,7 @@
     "version": "16.0.1.0.0",
     "depends": ["base"],
     "external_dependencies": {
-        "python": ["cryptography"],
+        "python": ["cryptography", "manifestoo_core"],
     },
     "license": "Other proprietary",
 }

glodo_client/controllers/main.py

@@ -17,8 +17,8 @@
 from odoo.http import Controller, request, route
 from odoo.modules.registry import Registry
 from odoo.service.db import list_dbs
-from odoo.tools import cloc
 
+from ..utils.cloc import CustomCloc
 from ..utils.crypto import (
     get_client_config,
     glodo_authenticated,
@@ -78,7 +78,7 @@ def info(self, **kwargs):
 
         Response includes:
         - Instance-level information (Odoo version, etc.)
-        - List of databases with CLOC and module info
+        - List of databases with module info and CLOC breakdown
         """
         # payload available via request.glodo_payload if needed
 
@@ -139,27 +139,22 @@ def _get_database_info(self, db_name: str) -> dict:
                     for m in modules
                 ]
 
+                try:
+                    cl = CustomCloc()
+                    cl.count_env(env)
+                    cloc_data = cl.summary()
+                except Exception as e:
+                    cloc_data = {"error": str(e)}
+
                 db_info = {
                     "name": db_name,
                     "user_count": user_count,
                     "expiration_date": expiration_date or None,
                     "expiration_reason": expiration_reason or None,
                     "installed_modules": module_list,
-                    "cloc": {},
+                    "cloc": cloc_data,
                 }
 
-                # Try to get CLOC
-                try:
-                    cl = cloc.Cloc()
-                    cl.count_customization(env)
-
-                    db_info["cloc"] = {
-                        "output": cl.report(),
-                        "returncode": cl.code,
-                    }
-                except Exception as e:
-                    db_info["cloc"] = {"error": str(e)}
-
                 return db_info
 
         except Exception as e:

glodo_client/utils/__init__.py

@@ -1 +1,2 @@
+from . import cloc
 from . import crypto

glodo_client/utils/cloc.py

@@ -0,0 +1,93 @@
+import ast
+import os
+import pathlib
+
+from manifestoo_core.core_addons import is_core_addon
+from manifestoo_core.odoo_series import OdooSeries, UnsupportedOdooSeries
+
+from odoo import release
+from odoo.modules import get_module_path
+from odoo.modules.module import MANIFEST_NAMES
+from odoo.tools.cloc import DEFAULT_EXCLUDE, MAX_FILE_SIZE, VALID_EXTENSION, Cloc
+
+DEFAULT_EXCLUDE_INCLUDE_TESTS = [
+    p for p in DEFAULT_EXCLUDE if not p.startswith(("tests/", "static/tests/"))
+]
+
+
+class CustomCloc(Cloc):
+    def summary(self):
+        return {
+            "code": dict(self.code),
+            "errors": {m: dict(files) for m, files in self.errors.items()},
+        }
+
+    def count_modules(self, env):
+        try:
+            major, minor = release.version_info[:2]
+            series = OdooSeries(f"{major}.{minor}")
+        except (ValueError, UnsupportedOdooSeries):
+            series = None
+
+        domain = [("state", "=", "installed")]
+        if env["ir.module.module"]._fields.get("imported"):
+            domain.append(("imported", "=", False))
+        module_list = env["ir.module.module"].search(domain).mapped("name")
+
+        for module_name in module_list:
+            if series and is_core_addon(module_name, series):
+                continue
+            module_path = os.path.realpath(get_module_path(module_name))
+            if module_path:
+                self.count_path(module_path)
+
+    # Exact copy of odoo.tools.cloc.Cloc.count_path with DEFAULT_EXCLUDE → DEFAULT_EXCLUDE_INCLUDE_TESTS
+
+    # fmt: off
+    # pylint: disable=broad-except,except-pass
+    # ruff: noqa: E501
+    def count_path(self, path, exclude=None):
+        path = path.rstrip('/')
+        exclude_list = []
+        for i in MANIFEST_NAMES:
+            manifest_path = os.path.join(path, i)
+            try:
+                with open(manifest_path, 'rb') as manifest:
+                    exclude_list.extend(DEFAULT_EXCLUDE_INCLUDE_TESTS)
+                    d = ast.literal_eval(manifest.read().decode('latin1'))
+                    for j in ['cloc_exclude', 'demo', 'demo_xml']:
+                        exclude_list.extend(d.get(j, []))
+                    break
+            except Exception:
+                pass
+        if not exclude:
+            exclude = set()
+        for i in filter(None, exclude_list):
+            assert '..' not in i, (
+                f"Invalid exclusion path '{i}': '..' is not allowed. Use a normalized path."
+            )
+            exclude.update(str(p) for p in pathlib.Path(path).glob(i))
+
+        module_name = os.path.basename(path)
+        self.book(module_name)
+        for root, _dirs, files in os.walk(path):
+            for file_name in files:
+                file_path = os.path.join(root, file_name)
+
+                if file_path in exclude:
+                    continue
+
+                ext = os.path.splitext(file_path)[1].lower()
+                if ext not in VALID_EXTENSION:
+                    continue
+
+                if os.path.getsize(file_path) > MAX_FILE_SIZE:
+                    self.book(module_name, file_path, (-1, "Max file size exceeded"))
+                    continue
+
+                with open(file_path, 'rb') as f:
+                    # Decode using latin1 to avoid error that may raise by decoding with utf8
+                    # The chars not correctly decoded in latin1 have no impact on how many lines will be counted
+                    content = f.read().decode('latin1')
+                self.book(module_name, file_path, self.parse(content, ext))
+    # fmt: on

requirements.txt

@@ -2,6 +2,7 @@
 cryptography
 human_readable
 lxml
+manifestoo_core
 mock
 oauthlib
 phonenumbers