AjmalCybro
1 week ago
8 changed files with 1473 additions and 34 deletions
@ -0,0 +1,711 @@ |
|||||
|
# -*- coding: utf-8 -*- |
||||
|
###################################################################################### |
||||
|
# |
||||
|
# Cybrosys Technologies Pvt. Ltd. |
||||
|
# |
||||
|
# Copyright (C) 2025-TODAY Cybrosys Technologies(<https://www.cybrosys.com>) |
||||
|
# Author: Cybrosys Techno Solutions(<https://www.cybrosys.com>) |
||||
|
# |
||||
|
# This program is under the terms of the Odoo Proprietary License v1.0 (OPL-1) |
||||
|
# It is forbidden to publish, distribute, sublicense, or sell copies of the Software |
||||
|
# or modified copies of the Software. |
||||
|
# |
||||
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
|
# FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. |
||||
|
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
||||
|
# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
||||
|
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
|
# DEALINGS IN THE SOFTWARE. |
||||
|
# |
||||
|
###################################################################################### |
||||
|
import ast |
||||
|
import os |
||||
|
import re |
||||
|
|
||||
|
results = [] |
||||
|
module_technical_name = ['no_module'] |
||||
|
|
||||
|
|
||||
|
def is_camel_case(name): |
||||
|
""" |
||||
|
Check if a given name follows CamelCase format. |
||||
|
|
||||
|
Args: |
||||
|
name (str): The variable or class name. |
||||
|
|
||||
|
Returns: |
||||
|
bool: True if name is CamelCase. |
||||
|
""" |
||||
|
return re.match(r'^[A-Z][a-zA-Z0-9]+$', name) |
||||
|
|
||||
|
def is_snake_case(name): |
||||
|
""" |
||||
|
Check if a given name follows snake_case format. |
||||
|
|
||||
|
Args: |
||||
|
name (str): The variable or function name. |
||||
|
|
||||
|
Returns: |
||||
|
bool: True if name is snake_case. |
||||
|
""" |
||||
|
return re.match(r'^[a-z_][a-z0-9_]*$', name) |
||||
|
|
||||
|
def check_class_name(node, file_path): |
||||
|
""" |
||||
|
Validate that the class name follows CamelCase. |
||||
|
|
||||
|
Args: |
||||
|
node (ast.ClassDef): The class node from AST. |
||||
|
file_path (str): The source file path. |
||||
|
""" |
||||
|
if not is_camel_case(node.name): |
||||
|
file_path_shorten = f"{module_technical_name[0]}/{file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Class name '{node.name}' is not CamelCase", |
||||
|
"suggestion": "Use CamelCase (e.g., MyClassName)" |
||||
|
}) |
||||
|
|
||||
|
def check_model_class(node, file_path): |
||||
|
""" |
||||
|
Check Odoo model class rules, including naming consistency. |
||||
|
|
||||
|
Args: |
||||
|
node (ast.ClassDef): The class node from AST. |
||||
|
file_path (str): The source file path. |
||||
|
""" |
||||
|
model_type = None |
||||
|
model_name = None |
||||
|
inherit_found = False |
||||
|
name_found = False |
||||
|
|
||||
|
for base in node.bases: |
||||
|
if isinstance(base, ast.Attribute) and base.attr in ["Model", "TransientModel"]: |
||||
|
model_type = base.attr |
||||
|
|
||||
|
for item in node.body: |
||||
|
if isinstance(item, ast.Assign): |
||||
|
for target in item.targets: |
||||
|
if isinstance(target, ast.Name): |
||||
|
if target.id == "_name": |
||||
|
name_found = True |
||||
|
if isinstance(item.value, ast.Constant) and isinstance(item.value.value, str): |
||||
|
model_name = item.value.value |
||||
|
elif target.id == "_inherit": |
||||
|
inherit_found = True |
||||
|
|
||||
|
file_path_shorten = f"{module_technical_name[0]}/{file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
|
||||
|
# Check if _name or _inherit is present |
||||
|
if model_type and not (name_found or inherit_found): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Class '{node.name}' is missing both '_name' and '_inherit'", |
||||
|
"suggestion": "Add either _name (for new model) or _inherit (for extending existing model)" |
||||
|
}) |
||||
|
|
||||
|
# Consistency Check |
||||
|
filename = os.path.basename(file_path).replace(".py", "") |
||||
|
expected_class_name = "".join(part.capitalize() for part in filename.split("_")) |
||||
|
expected_model_name = filename.replace("_", ".") |
||||
|
|
||||
|
if node.name != expected_class_name: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Class name '{node.name}' does not match file name '{filename}.py'", |
||||
|
"suggestion": f"Rename class to '{expected_class_name}' to match file name" |
||||
|
}) |
||||
|
|
||||
|
if model_name and model_type == "Model": |
||||
|
if model_name != expected_model_name: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"_name '{model_name}' does not match file-based model name '{expected_model_name}'", |
||||
|
"suggestion": f"Use _name = '{expected_model_name}'" |
||||
|
}) |
||||
|
|
||||
|
if model_name: |
||||
|
if "." not in model_name: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Model name '{model_name}' should use dot notation", |
||||
|
"suggestion": "Use format: <module>.<model> (e.g., res.partner)" |
||||
|
}) |
||||
|
|
||||
|
if model_type == "TransientModel" and "wizard" in model_name: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Transient model name '{model_name}' contains 'wizard'", |
||||
|
"suggestion": "Avoid using 'wizard'; use format: <related_model>.<action>" |
||||
|
}) |
||||
|
|
||||
|
if ".report." in model_name and len(model_name.split(".")) < 3: |
||||
|
parts = model_name.split(".") |
||||
|
if len(parts) < 3: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Report model name '{model_name}' should follow '<model>.report.<action>'", |
||||
|
"suggestion": "Ensure full dot-notation like 'sale.report.invoice'" |
||||
|
}) |
||||
|
|
||||
|
if model_type == "Model": |
||||
|
last_part = model_name.split(".")[-1] |
||||
|
if last_part.endswith("s"): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Model name '{model_name}' seems plural", |
||||
|
"suggestion": "Use singular form (e.g., 'res.partner', not 'res.partners')" |
||||
|
}) |
||||
|
|
||||
|
def check_missing_docstring(node, file_path, type="function"): |
||||
|
""" |
||||
|
Check whether a class or function has a docstring. |
||||
|
|
||||
|
Args: |
||||
|
node (ast.AST): The node (ClassDef or FunctionDef). |
||||
|
file_path (str): File path. |
||||
|
type (str): Either 'function' or 'class'. |
||||
|
""" |
||||
|
file_path_shorten = f"{module_technical_name[0]}/{file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
if not ast.get_docstring(node): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"{type.capitalize()} '{node.name}' is missing a docstring", |
||||
|
"suggestion": f"Add a docstring to the {type}" |
||||
|
}) |
||||
|
|
||||
|
def check_function_name(node, file_path): |
||||
|
""" |
||||
|
Check function or method names for snake_case and method type prefixes. |
||||
|
|
||||
|
Args: |
||||
|
node (ast.FunctionDef): The function node. |
||||
|
file_path (str): Path to the source file. |
||||
|
""" |
||||
|
file_path_shorten = f"{module_technical_name[0]}/{file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
if not is_snake_case(node.name): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Function name '{node.name}' is not snake_case", |
||||
|
"suggestion": "Use snake_case (e.g., my_function_name)" |
||||
|
}) |
||||
|
|
||||
|
for decorator in node.decorator_list: |
||||
|
if isinstance(decorator, ast.Attribute): |
||||
|
if decorator.attr in ["multi", "one"]: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Decorator '@api.{decorator.attr}' is deprecated", |
||||
|
"suggestion": "Remove it; use '@api.model' or '@api.depends' based on logic" |
||||
|
}) |
||||
|
check_method_prefix(node, file_path) |
||||
|
|
||||
|
def check_method_prefix(node, file_path): |
||||
|
""" |
||||
|
Check method prefix based on decorators like @api.depends, @api.onchange, etc. |
||||
|
|
||||
|
Args: |
||||
|
node (ast.FunctionDef): The method definition. |
||||
|
file_path (str): Path to the Python file. |
||||
|
""" |
||||
|
method_prefix_map = { |
||||
|
'depends': '_compute_', |
||||
|
'onchange': '_onchange_', |
||||
|
'constrains': '_check_', |
||||
|
} |
||||
|
file_path_shorten = f"{module_technical_name[0]}/{file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
|
||||
|
for decorator in node.decorator_list: |
||||
|
if isinstance(decorator, ast.Call) and isinstance(decorator.func, ast.Attribute): |
||||
|
deco_name = decorator.func.attr |
||||
|
expected_prefix = method_prefix_map.get(deco_name) |
||||
|
if expected_prefix and not node.name.startswith(expected_prefix): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Method '{node.name}' uses @{deco_name} but doesn't start with '{expected_prefix}'", |
||||
|
"suggestion": f"Prefix method name with '{expected_prefix}'" |
||||
|
}) |
||||
|
|
||||
|
if 'default_' in node.name and not node.name.startswith('_default_'): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Default method '{node.name}' should start with '_default_'", |
||||
|
"suggestion": "Rename method to start with '_default_'" |
||||
|
}) |
||||
|
|
||||
|
if 'selection' in node.name and not node.name.startswith('_selection_'): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Selection method '{node.name}' should start with '_selection_'", |
||||
|
"suggestion": "Rename method to start with '_selection_'" |
||||
|
}) |
||||
|
|
||||
|
if node.name.startswith('do_'): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Action method '{node.name}' should start with 'action_'", |
||||
|
"suggestion": "Rename method to start with 'action_'" |
||||
|
}) |
||||
|
|
||||
|
def check_field_suffix(node, file_path): |
||||
|
""" |
||||
|
Ensure field names have correct suffixes based on field type. |
||||
|
|
||||
|
Args: |
||||
|
node (ast.Assign): The field definition node. |
||||
|
file_path (str): Path to the Python file. |
||||
|
""" |
||||
|
file_path_shorten = f"{module_technical_name[0]}/{file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
if isinstance(node.value, ast.Call) and isinstance(node.value.func, ast.Attribute): |
||||
|
field_type = node.value.func.attr |
||||
|
if field_type in ['Many2one', 'One2many', 'Many2many']: |
||||
|
target = node.targets[0] |
||||
|
name = target.id if isinstance(target, ast.Name) else getattr(target, 'attr', None) |
||||
|
if name: |
||||
|
correct_suffix = '_id' if field_type == 'Many2one' else '_ids' |
||||
|
if not name.endswith(correct_suffix): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"{field_type} field '{name}' should end with '{correct_suffix}'", |
||||
|
"suggestion": f"Rename variable to end with '{correct_suffix}'" |
||||
|
}) |
||||
|
|
||||
|
def check_variable_naming(node, file_path): |
||||
|
""" |
||||
|
Check local variable naming conventions and suffixes for record/recordsets. |
||||
|
|
||||
|
Args: |
||||
|
node (ast.Assign): The assignment statement node. |
||||
|
file_path (str): Source file path. |
||||
|
""" |
||||
|
if not isinstance(node, ast.Assign) or not isinstance(node.value, ast.Call): |
||||
|
return |
||||
|
|
||||
|
targets = node.targets |
||||
|
if not targets: |
||||
|
return |
||||
|
|
||||
|
var_name = targets[0].id if isinstance(targets[0], ast.Name) else None |
||||
|
if not var_name: |
||||
|
return |
||||
|
|
||||
|
call_func = node.value.func |
||||
|
call_attr = call_func.attr if isinstance(call_func, ast.Attribute) else '' |
||||
|
|
||||
|
file_path_shorten = f"{module_technical_name[0]}/{file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
|
||||
|
if isinstance(call_func, ast.Subscript): |
||||
|
if isinstance(call_func.value, ast.Attribute) and call_func.value.attr == 'env': |
||||
|
if not is_camel_case(var_name): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Model variable '{var_name}' is not CamelCase", |
||||
|
"suggestion": "Use CamelCase (e.g., MyModelVariable)" |
||||
|
}) |
||||
|
|
||||
|
if call_attr in ['browse', 'search', 'search_read']: |
||||
|
if call_attr == 'browse' and not var_name.endswith('_id'): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Variable '{var_name}' may represent a single record, use _id suffix", |
||||
|
"suggestion": "Rename variable to end with '_id'" |
||||
|
}) |
||||
|
elif call_attr in ['search', 'search_read'] and not var_name.endswith('_ids'): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Variable '{var_name}' may represent multiple records, use _ids suffix", |
||||
|
"suggestion": "Rename variable to end with '_ids'" |
||||
|
}) |
||||
|
|
||||
|
if not is_snake_case(var_name): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Variable name '{var_name}' is not snake_case", |
||||
|
"suggestion": "Use snake_case (e.g., my_variable)" |
||||
|
}) |
||||
|
|
||||
|
def check_python_file_name(file_path): |
||||
|
""" |
||||
|
Check if the Python file name follows snake_case convention. |
||||
|
|
||||
|
Args: |
||||
|
file_path (str): Full path to the Python file. |
||||
|
""" |
||||
|
filename = os.path.basename(file_path) |
||||
|
if not filename.endswith(".py") or filename in {"__init__.py", "__manifest__.py"}: |
||||
|
return |
||||
|
|
||||
|
name_without_ext = filename[:-3] # Remove .py |
||||
|
file_path_shorten = f"{module_technical_name[0]}/{file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
|
||||
|
if not re.fullmatch(r"[a-z0-9_]+", name_without_ext): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": 0, |
||||
|
"issue": f"File name '{filename}' does not follow snake_case", |
||||
|
"suggestion": "Rename file using lowercase and underscores (e.g., my_model.py)" |
||||
|
}) |
||||
|
|
||||
|
if name_without_ext in {"temp", "test", "test1", "new", "misc"}: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": 0, |
||||
|
"issue": f"File name '{filename}' is too generic or non-descriptive", |
||||
|
"suggestion": "Use meaningful file names related to model or logic" |
||||
|
}) |
||||
|
|
||||
|
def check_manifest_file(file_path): |
||||
|
""" |
||||
|
Check the manifest file for any standard issues. |
||||
|
|
||||
|
Args: |
||||
|
file_path (str): Full path to the Python file. |
||||
|
""" |
||||
|
file_path_shorten = f"{module_technical_name[0]}/{file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
with open(file_path, "r", encoding="utf-8") as f: |
||||
|
source = f.read() |
||||
|
try: |
||||
|
tree = ast.parse(source) |
||||
|
except SyntaxError: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": 0, |
||||
|
"issue": "Invalid Python syntax in __manifest__.py", |
||||
|
"suggestion": "Fix the syntax error" |
||||
|
}) |
||||
|
return |
||||
|
|
||||
|
manifest_data = {} |
||||
|
seen_keys = set() |
||||
|
|
||||
|
for node in ast.walk(tree): |
||||
|
if isinstance(node, ast.Dict): |
||||
|
for k_node, v_node in zip(node.keys, node.values): |
||||
|
if isinstance(k_node, ast.Str): |
||||
|
key = k_node.s |
||||
|
if key in seen_keys: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": k_node.lineno if hasattr(k_node, "lineno") else 1, |
||||
|
"issue": f"Duplicate field '{key}' in manifest", |
||||
|
"suggestion": "Remove the duplicate entry" |
||||
|
}) |
||||
|
seen_keys.add(key) |
||||
|
manifest_data[key] = v_node |
||||
|
break # Assume top-level dict is the manifest |
||||
|
|
||||
|
required_fields = {"name", "version", "depends", "author", "category", "summary", "data", "installable", "license"} |
||||
|
for field in required_fields: |
||||
|
if field not in manifest_data: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": 1, |
||||
|
"issue": f"Missing required field '{field}' in manifest", |
||||
|
"suggestion": f"Add '{field}' to the manifest dictionary" |
||||
|
}) |
||||
|
|
||||
|
# Version check |
||||
|
version = manifest_data.get("version") |
||||
|
if isinstance(version, ast.Constant): |
||||
|
version_val = version.value |
||||
|
if not re.fullmatch(r"\d+\.\d+\.\d+\.\d+\.\d+", version_val): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": version.lineno if hasattr(version, "lineno") else 1, |
||||
|
"issue": f"Version '{version_val}' does not follow '16.0.1.0.0' format", |
||||
|
"suggestion": "Use 5-level semantic versioning like '16.0.1.0.0'" |
||||
|
}) |
||||
|
|
||||
|
# Depends check |
||||
|
depends = manifest_data.get("depends") |
||||
|
if isinstance(depends, ast.List): |
||||
|
for d in depends.elts: |
||||
|
if isinstance(d, ast.Constant) and not d.value.strip(): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": d.lineno if hasattr(d, "lineno") else 1, |
||||
|
"issue": "Empty string in 'depends'", |
||||
|
"suggestion": "Remove empty string or specify actual dependency" |
||||
|
}) |
||||
|
|
||||
|
# Maintainer email format check |
||||
|
maintainer = manifest_data.get("maintainer") |
||||
|
if maintainer and isinstance(maintainer, ast.Constant): |
||||
|
email = maintainer.value |
||||
|
# Use this if not worked properly: r".*<[^@]+@[^@]+\.[^@]+>" |
||||
|
if "@" not in email or not re.match(r"[^@]+@[^@]+\.[^@]+", email): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": maintainer.lineno if hasattr(maintainer, "lineno") else 1, |
||||
|
"issue": f"Invalid email format for 'maintainer': '{email}'", |
||||
|
"suggestion": "Use a valid email address (e.g., john@example.com)" |
||||
|
}) |
||||
|
|
||||
|
# Check license |
||||
|
valid_licenses = {"LGPL-3", "AGPL-3", "OEEL-1", "OPL-1", "GPL-3", "MIT"} |
||||
|
license_node = manifest_data.get("license") |
||||
|
if isinstance(license_node, ast.Constant): |
||||
|
license_val = license_node.value |
||||
|
if license_val not in valid_licenses: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": license_node.lineno if hasattr(license_node, "lineno") else 1, |
||||
|
"issue": f"License '{license_val}' is not a recognized Odoo-compatible license", |
||||
|
"suggestion": f"Use one of the valid licenses: {', '.join(valid_licenses)}" |
||||
|
}) |
||||
|
# Data file order check: security/ files must come first |
||||
|
data_node = manifest_data.get("data") |
||||
|
if isinstance(data_node, ast.List): |
||||
|
found_non_security = False |
||||
|
for file_node in data_node.elts: |
||||
|
if isinstance(file_node, ast.Constant): |
||||
|
file_value = file_node.value |
||||
|
if not file_value.startswith("security/"): |
||||
|
found_non_security = True |
||||
|
elif found_non_security: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": file_node.lineno if hasattr(file_node, "lineno") else 1, |
||||
|
"issue": f"'security' file '{file_value}' appears after non-security files", |
||||
|
"suggestion": "Move all 'security/' files to the top of the 'data' list" |
||||
|
}) |
||||
|
|
||||
|
|
||||
|
def check_transient_model_location(py_file_path): |
||||
|
""" |
||||
|
Check the transient model is in the wizard folder. |
||||
|
|
||||
|
Args: |
||||
|
file_path (str): Full path to the Python file. |
||||
|
""" |
||||
|
file_path_shorten = f"{module_technical_name[0]}/{py_file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
with open(py_file_path, "r", encoding="utf-8") as f: |
||||
|
source = f.read() |
||||
|
|
||||
|
try: |
||||
|
tree = ast.parse(source) |
||||
|
except SyntaxError: |
||||
|
return |
||||
|
|
||||
|
for node in ast.walk(tree): |
||||
|
if isinstance(node, ast.ClassDef): |
||||
|
for base in node.bases: |
||||
|
if isinstance(base, ast.Attribute) and base.attr == "TransientModel": |
||||
|
if "wizard" not in py_file_path.replace("\\", "/").split("/"): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"TransientModel class '{node.name}' is not in a 'wizard/' directory", |
||||
|
"suggestion": "Move the file to a 'wizard/' folder to follow Odoo best practices" |
||||
|
}) |
||||
|
|
||||
|
|
||||
|
def check_report_model_location(py_file_path): |
||||
|
""" |
||||
|
Check the report model is in the report folder. |
||||
|
|
||||
|
Args: |
||||
|
file_path (str): Full path to the Python file. |
||||
|
""" |
||||
|
file_path_shorten = f"{module_technical_name[0]}/{py_file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
with open(py_file_path, "r", encoding="utf-8") as f: |
||||
|
source = f.read() |
||||
|
|
||||
|
try: |
||||
|
tree = ast.parse(source) |
||||
|
except SyntaxError: |
||||
|
return |
||||
|
|
||||
|
for node in ast.walk(tree): |
||||
|
if isinstance(node, ast.ClassDef): |
||||
|
is_abstract_model = any( |
||||
|
isinstance(base, ast.Attribute) and base.attr == "AbstractModel" |
||||
|
for base in node.bases |
||||
|
) |
||||
|
|
||||
|
if is_abstract_model: |
||||
|
for body_item in node.body: |
||||
|
if isinstance(body_item, ast.Assign): |
||||
|
for target in body_item.targets: |
||||
|
if isinstance(target, ast.Name) and target.id == "_name": |
||||
|
if isinstance(body_item.value, ast.Constant): |
||||
|
model_name = body_item.value.value |
||||
|
if (model_name.startswith("report.") and |
||||
|
"report" not in py_file_path.replace("\\", "/").split("/")): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": node.lineno, |
||||
|
"issue": f"Report model '{model_name}' is not in a 'report/' directory", |
||||
|
"suggestion": "Move the report model to a 'report/' folder" |
||||
|
}) |
||||
|
|
||||
|
|
||||
|
def check_controller_naming(module_path, module_name): |
||||
|
""" |
||||
|
Check the controller file naming. |
||||
|
|
||||
|
Args: |
||||
|
module_path (str): Full path to the Python file. |
||||
|
module_name (str): Module technical name. |
||||
|
""" |
||||
|
controller_dir = os.path.join(module_path, "controllers") |
||||
|
file_path_shorten = f"{module_technical_name[0]}/{module_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
if not os.path.isdir(controller_dir): |
||||
|
return |
||||
|
|
||||
|
for filename in os.listdir(controller_dir): |
||||
|
filepath = os.path.join(controller_dir, filename) |
||||
|
|
||||
|
if not filename.endswith(".py"): |
||||
|
continue |
||||
|
|
||||
|
if filename == "main.py": |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": 1, |
||||
|
"issue": "'main.py' is deprecated for controller files", |
||||
|
"suggestion": f"Rename to '{module_name}.py' or the name of the inherited module" |
||||
|
}) |
||||
|
|
||||
|
if filename != f"{module_name}.py" and not filename.startswith("portal") and not filename.startswith("website"): |
||||
|
with open(filepath, "r", encoding="utf-8") as f: |
||||
|
content = f.read() |
||||
|
if "http.Controller" in content and f"{module_name}.py" not in os.listdir(controller_dir): |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": 1, |
||||
|
"issue": f"'{filename}' may not follow the controller naming convention", |
||||
|
"suggestion": f"Use '{module_name}.py' for your base controller, " |
||||
|
f"or name after the module you're inheriting" |
||||
|
}) |
||||
|
|
||||
|
|
||||
|
def check_compute_method_exact_naming(py_file_path): |
||||
|
""" |
||||
|
Check the compute function naming. |
||||
|
|
||||
|
Args: |
||||
|
file_path (str): Full path to the Python file. |
||||
|
""" |
||||
|
file_path_shorten = f"{module_technical_name[0]}/{py_file_path.split(f'/{module_technical_name[0]}/')[1]}" |
||||
|
with open(py_file_path, "r", encoding="utf-8") as f: |
||||
|
source = f.read() |
||||
|
try: |
||||
|
tree = ast.parse(source) |
||||
|
except SyntaxError: |
||||
|
return |
||||
|
|
||||
|
for node in ast.walk(tree): |
||||
|
if isinstance(node, ast.Assign): |
||||
|
for target in node.targets: |
||||
|
if isinstance(target, ast.Name): |
||||
|
field_name = target.id |
||||
|
for value in ast.walk(node.value): |
||||
|
if isinstance(value, ast.Call) and isinstance(value.func, ast.Attribute): |
||||
|
if value.func.attr in { |
||||
|
"Char", "Text", "Integer", "Float", "Boolean", "Date", "Datetime", |
||||
|
"Many2one", "One2many", "Many2many", "Html", "Binary", "Selection" |
||||
|
}: |
||||
|
for keyword in value.keywords: |
||||
|
if keyword.arg == "compute" and isinstance(keyword.value, ast.Constant): |
||||
|
compute_func = keyword.value.value |
||||
|
expected_name = f"_compute_{field_name}" |
||||
|
if compute_func != expected_name: |
||||
|
results.append({ |
||||
|
"file": file_path_shorten, |
||||
|
"line": keyword.lineno, |
||||
|
"issue": f"Compute method should be named '{expected_name}' for " |
||||
|
f"field '{field_name}', found '{compute_func}'", |
||||
|
"suggestion": f"Rename compute method to '{expected_name}'" |
||||
|
}) |
||||
|
|
||||
|
|
||||
|
def analyze_file(file_path): |
||||
|
""" |
||||
|
Analyze a Python file using AST and apply all naming rules. |
||||
|
|
||||
|
Args: |
||||
|
file_path (str): Full path to the .py file. |
||||
|
""" |
||||
|
module_name = os.path.basename(file_path.rstrip("/\\")) # Get folder name |
||||
|
|
||||
|
check_python_file_name(file_path) |
||||
|
check_transient_model_location(file_path) |
||||
|
check_report_model_location(file_path) |
||||
|
check_controller_naming(file_path, module_name) |
||||
|
check_compute_method_exact_naming(file_path) |
||||
|
|
||||
|
try: |
||||
|
with open(file_path, "r", encoding="utf-8") as f: |
||||
|
tree = ast.parse(f.read(), filename=file_path) |
||||
|
except SyntaxError: |
||||
|
return |
||||
|
|
||||
|
for node in ast.walk(tree): |
||||
|
if isinstance(node, ast.ClassDef): |
||||
|
check_class_name(node, file_path) |
||||
|
check_model_class(node, file_path) |
||||
|
check_missing_docstring(node, file_path, type="class") |
||||
|
elif isinstance(node, ast.FunctionDef): |
||||
|
check_function_name(node, file_path) |
||||
|
check_missing_docstring(node, file_path, type="function") |
||||
|
elif isinstance(node, ast.Assign): |
||||
|
check_field_suffix(node, file_path) |
||||
|
check_variable_naming(node, file_path) |
||||
|
|
||||
|
|
||||
|
def scan_directory(directory): |
||||
|
""" |
||||
|
Recursively scan a directory and analyze all .py files, skipping __init__.py and __manifest__.py. |
||||
|
|
||||
|
Args: |
||||
|
directory (str): Path to the root directory. |
||||
|
""" |
||||
|
for root, _, files in os.walk(directory): |
||||
|
for file in files: |
||||
|
if file == "__manifest__.py": |
||||
|
check_manifest_file(os.path.join(root, file)) |
||||
|
if file.endswith(".py") and file not in {"__init__.py", "__manifest__.py"}: |
||||
|
analyze_file(os.path.join(root, file)) |
||||
|
|
||||
|
|
||||
|
def check_odoo_python_standards(name, path): |
||||
|
""" |
||||
|
Perform a scan of Python files in the given directory to check for Odoo-specific coding standard violations. |
||||
|
|
||||
|
This function clears previous results, sets the current module's technical name, and recursively scans the |
||||
|
given directory for Python files. Each file is analyzed for adherence to Odoo's Python coding standards, |
||||
|
and the results are accumulated. |
||||
|
|
||||
|
Args: |
||||
|
name (str): The technical name of the Odoo module being checked. |
||||
|
path (str): The absolute or relative file path to the directory containing the module's Python code. |
||||
|
|
||||
|
Returns: |
||||
|
list: A list of dictionaries containing information about detected coding standard violations. |
||||
|
""" |
||||
|
results.clear() |
||||
|
module_technical_name[0] = name |
||||
|
scan_directory(path) |
||||
|
return results |
||||
Binary file not shown.
@ -0,0 +1,316 @@ |
|||||
|
# -*- coding: utf-8 -*- |
||||
|
###################################################################################### |
||||
|
# |
||||
|
# Cybrosys Technologies Pvt. Ltd. |
||||
|
# |
||||
|
# Copyright (C) 2025-TODAY Cybrosys Technologies(<https://www.cybrosys.com>) |
||||
|
# Author: Cybrosys Techno Solutions(<https://www.cybrosys.com>) |
||||
|
# |
||||
|
# This program is under the terms of the Odoo Proprietary License v1.0 (OPL-1) |
||||
|
# It is forbidden to publish, distribute, sublicense, or sell copies of the Software |
||||
|
# or modified copies of the Software. |
||||
|
# |
||||
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
|
# FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. |
||||
|
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
||||
|
# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
||||
|
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
|
# DEALINGS IN THE SOFTWARE. |
||||
|
# |
||||
|
###################################################################################### |
||||
|
import json |
||||
|
import re |
||||
|
import subprocess |
||||
|
|
||||
|
import sys |
||||
|
|
||||
|
from odoo.modules import get_module_path |
||||
|
from . import check_odoo_python_guidelines |
||||
|
|
||||
|
|
||||
|
def violations_report(self, module): |
||||
|
""" |
||||
|
Check the violations for selected modules for PDF report. |
||||
|
|
||||
|
Args: |
||||
|
self (obj): The odoo ClassDef. |
||||
|
module (str): The module technical name. |
||||
|
|
||||
|
Returns: |
||||
|
dict: Module name and its violations |
||||
|
""" |
||||
|
violations = get_violations(module) |
||||
|
report_dict = { |
||||
|
'module': self.env.ref(f'base.module_{module}').display_name, |
||||
|
'violations': { |
||||
|
"odoo_standards": violations.get('odoo_standards_check'), |
||||
|
"style_lint": violations.get('style_lint_check'), |
||||
|
"code_quality": violations.get('code_quality_check'), |
||||
|
"maintainability_index": violations.get('mi_check'), |
||||
|
"import_sort": violations.get('import_sort_check'), |
||||
|
"code_format": violations.get('code_format_check'), |
||||
|
"code_complexity": violations.get('cc_check'), |
||||
|
"security_scan": violations.get('security_scan') |
||||
|
} |
||||
|
} |
||||
|
return report_dict |
||||
|
|
||||
|
def get_violations(module): |
||||
|
""" |
||||
|
Check the violations for selected module. |
||||
|
|
||||
|
Args: |
||||
|
module (str): The module technical name. |
||||
|
|
||||
|
Returns: |
||||
|
dict: Selected module violations |
||||
|
""" |
||||
|
return { |
||||
|
"style_lint_check": check_style_lint(module), |
||||
|
"code_quality_check": check_code_quality(module), |
||||
|
"mi_check": check_maintainability_index(module), |
||||
|
"import_sort_check": check_import_sort(module), |
||||
|
"code_format_check": check_code_format(module), |
||||
|
"cc_check": check_code_complexity(module), |
||||
|
"security_scan": scan_code_security(module), |
||||
|
"odoo_standards_check": check_odoo_python_guidelines.check_odoo_python_standards( |
||||
|
name=module, path=get_module_path(module)) |
||||
|
} |
||||
|
|
||||
|
def check_style_lint(module): |
||||
|
""" |
||||
|
Check the style and lint for selected module . |
||||
|
|
||||
|
Args: |
||||
|
module (str): The module technical name. |
||||
|
|
||||
|
Returns: |
||||
|
list of dictionaries for the violations with the file name and line number. |
||||
|
""" |
||||
|
excluded_files = ['__init__.py', '__manifest__.py', '__pycache__', '*.pyc', '.git'] |
||||
|
ignored_violations = ['E501', 'E301', 'E302'] |
||||
|
|
||||
|
venv_python = sys.executable |
||||
|
exclude_param = f"--exclude={','.join(excluded_files)}" |
||||
|
ignore_param = f"--ignore={','.join(ignored_violations)}" |
||||
|
module_path = get_module_path(module) |
||||
|
|
||||
|
result = subprocess.run( |
||||
|
[venv_python, '-m', 'flake8', '--select=D', exclude_param, ignore_param, module_path], |
||||
|
stdout=subprocess.PIPE, |
||||
|
stderr=subprocess.PIPE, |
||||
|
text=True |
||||
|
) |
||||
|
violations = result.stdout.strip().splitlines() |
||||
|
|
||||
|
violations_list = [] |
||||
|
for violation in violations: |
||||
|
parts = violation.split(":", 3) |
||||
|
if len(parts) >= 4: |
||||
|
file_path = f"{module}/{parts[0].split(f'/{module}/')[1]}" |
||||
|
violations_list.append({ |
||||
|
'file_name': file_path, |
||||
|
'line_number': parts[1], |
||||
|
'violation_message': parts[3] |
||||
|
}) |
||||
|
return violations_list |
||||
|
|
||||
|
def check_code_quality(module): |
||||
|
""" |
||||
|
Check the code quality for selected module . |
||||
|
|
||||
|
Args: |
||||
|
module (str): The module technical name. |
||||
|
|
||||
|
Returns: |
||||
|
list of dictionaries for the violations with the file name, code, line and column number. |
||||
|
""" |
||||
|
pylint_result = subprocess.run([ |
||||
|
sys.executable, '-m', 'pylint', |
||||
|
'--load-plugins=pylint_odoo', |
||||
|
'-d all', |
||||
|
'-e odoolint', |
||||
|
'--ignore-patterns=__init__.py,__manifest__.py', |
||||
|
get_module_path(module) |
||||
|
], |
||||
|
stdout=subprocess.PIPE, |
||||
|
stderr=subprocess.PIPE, |
||||
|
text=True |
||||
|
) |
||||
|
output = pylint_result.stdout.strip().splitlines() |
||||
|
result = [] |
||||
|
for rec in output: |
||||
|
if rec.startswith(('*', '-')) or rec == '': |
||||
|
continue |
||||
|
else: |
||||
|
rec = rec.split(':') |
||||
|
if len(rec) >= 5: |
||||
|
file_path = f"{module}/{rec[0].split(f'/{module}/')[1]}" |
||||
|
result.append({ |
||||
|
'file': file_path, |
||||
|
'line': rec[1], |
||||
|
'column': rec[2], |
||||
|
'code': rec[3].strip(), |
||||
|
'message': rec[4].strip(), |
||||
|
}) |
||||
|
return result |
||||
|
|
||||
|
def check_maintainability_index(module): |
||||
|
""" |
||||
|
Check the maintainability index for selected module . |
||||
|
|
||||
|
Args: |
||||
|
module (str): The module technical name. |
||||
|
|
||||
|
Returns: |
||||
|
list of dictionaries for the file name and grade. |
||||
|
""" |
||||
|
result = subprocess.run([ |
||||
|
sys.executable, '-m', 'radon', |
||||
|
'mi', |
||||
|
get_module_path(module), |
||||
|
], |
||||
|
stdout=subprocess.PIPE, |
||||
|
stderr=subprocess.PIPE, |
||||
|
text=True |
||||
|
) |
||||
|
excluded_files = ("__init__.py", "__manifest__.py") |
||||
|
mi_list = [] |
||||
|
for rec in result.stdout.splitlines(): |
||||
|
if not any(exclude in rec for exclude in excluded_files): |
||||
|
rec = rec.split(' - ') |
||||
|
if len(rec) >= 2: |
||||
|
file_path = f"{module}/{rec[0].split(f'/{module}/')[1]}" |
||||
|
mi_list.append({'file': file_path, 'grade': rec[1]}) |
||||
|
return mi_list |
||||
|
|
||||
|
def check_import_sort(module): |
||||
|
""" |
||||
|
Check the import sorting for selected module . |
||||
|
|
||||
|
Args: |
||||
|
module (str): The module technical name. |
||||
|
|
||||
|
Returns: |
||||
|
list of dictionaries for the file name and message. |
||||
|
""" |
||||
|
result = subprocess.run([ |
||||
|
sys.executable, '-m', 'isort', |
||||
|
'--check-only', |
||||
|
'--skip', '__init__.py', |
||||
|
'--skip', '__manifest__.py', |
||||
|
get_module_path(module), |
||||
|
], |
||||
|
stdout=subprocess.PIPE, |
||||
|
stderr=subprocess.PIPE, |
||||
|
text=True, |
||||
|
) |
||||
|
import_sort_list = [] |
||||
|
for rec in result.stderr.splitlines(): |
||||
|
rec = rec.replace("ERROR: ", "") |
||||
|
parts = rec.split(" ", 1) |
||||
|
if len(parts) >= 2: |
||||
|
file_path = f"{module}/{parts[0].split(f'/{module}/')[1]}" |
||||
|
import_sort_list.append({'file': file_path, 'message': parts[1]}) |
||||
|
return import_sort_list |
||||
|
|
||||
|
def parse_black_output_simple(line): |
||||
|
"""Simple parsing for all Black output types""" |
||||
|
actions = ['would reformat ', 'reformatted ', 'formatted ', 'would format '] |
||||
|
for action in actions: |
||||
|
if line.startswith(action): |
||||
|
filename = line[len(action):] |
||||
|
return action.strip(), filename |
||||
|
return None, None |
||||
|
|
||||
|
def is_file_line(line): |
||||
|
"""Check if line is a file entry (not summary)""" |
||||
|
skip_patterns = ['💥', '💔', '!', 'files would be', 'file would be', 'All done'] |
||||
|
actions = ['would reformat ', 'reformatted ', 'formatted ', 'would format '] |
||||
|
if any(pattern in line for pattern in skip_patterns): |
||||
|
return False |
||||
|
return any(line.startswith(action) for action in actions) |
||||
|
|
||||
|
def check_code_format(module): |
||||
|
""" |
||||
|
Check the code format for selected module . |
||||
|
|
||||
|
Args: |
||||
|
module (str): The module technical name. |
||||
|
|
||||
|
Returns: |
||||
|
list of dictionaries for the file name and action. |
||||
|
""" |
||||
|
result = subprocess.run([ |
||||
|
sys.executable, '-m', 'black', |
||||
|
'--check', |
||||
|
'--exclude', '__init__.py|__manifest__.py', |
||||
|
get_module_path(module), |
||||
|
], |
||||
|
stdout=subprocess.PIPE, |
||||
|
stderr=subprocess.PIPE, |
||||
|
text=True, |
||||
|
) |
||||
|
|
||||
|
code_format_list = [] |
||||
|
for line in result.stderr.strip().split('\n'): |
||||
|
line = line.strip() |
||||
|
if not line or not is_file_line(line): |
||||
|
continue |
||||
|
parsed = parse_black_output_simple(line) |
||||
|
if parsed[0] is not None: |
||||
|
code_format_list.append(parsed) |
||||
|
|
||||
|
return code_format_list |
||||
|
|
||||
|
def check_code_complexity(module): |
||||
|
""" |
||||
|
Check the code complexity for selected module . |
||||
|
|
||||
|
Args: |
||||
|
module (str): The module technical name. |
||||
|
|
||||
|
Returns: |
||||
|
list of dictionaries for the file name and grade. |
||||
|
""" |
||||
|
result = subprocess.run([ |
||||
|
sys.executable, '-m', 'radon', |
||||
|
'cc', |
||||
|
'--json', |
||||
|
get_module_path(module), |
||||
|
], |
||||
|
capture_output=True, |
||||
|
text=True |
||||
|
) |
||||
|
|
||||
|
if result.returncode == 0 and result.stdout: |
||||
|
clean_stdout = re.sub(r'\x1b\[[0-9;]*m', '', result.stdout) |
||||
|
cc_dict = json.loads(clean_stdout.strip()) |
||||
|
return cc_dict |
||||
|
return {} |
||||
|
|
||||
|
def scan_code_security(module): |
||||
|
""" |
||||
|
Scan the code security for selected module . |
||||
|
|
||||
|
Args: |
||||
|
module (str): The module technical name. |
||||
|
|
||||
|
Returns: |
||||
|
list of dictionaries of the security scan. |
||||
|
""" |
||||
|
result = subprocess.run([ |
||||
|
sys.executable, '-m', 'bandit', |
||||
|
'-r', get_module_path(module), |
||||
|
'-x', '__init__.py,__manifest__.py', |
||||
|
'-f', 'json' |
||||
|
], |
||||
|
stdout=subprocess.PIPE, |
||||
|
stderr=subprocess.PIPE, |
||||
|
text=True) |
||||
|
|
||||
|
if result.stdout: |
||||
|
security_list = json.loads(result.stdout).get('results', []) |
||||
|
return security_list |
||||
|
return [] |
||||
Loading…
Reference in new issue