"""

License GPLv3 or higher.

(C) 2025 Created by Maikel Mardjan - https://nocomplexity.com/

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.

Issue validation functions for codeaudit

"""

import ast

import warnings

from collections import defaultdict

from codeaudit.checkmodules import get_imported_modules

def get_full_attr_name(node):

"""Recursively builds full dotted name from Attribute/Name nodes."""

parts = []

while isinstance(node, ast.Attribute):

parts.append(node.attr)

node = node.value

if isinstance(node, ast.Name):

parts.append(node.id)

return ".".join(reversed(parts))

def find_constructs(source_code, constructs_to_detect):

"""

Detects specified constructs (e.g., 'os', 'os.access', 'eval') in the code.

Handles aliases, from-imports, deep nesting, and avoids double-counting.

"""

with warnings.catch_warnings(): # Suppression of warnings

warnings.simplefilter("ignore", category=SyntaxWarning)

tree = ast.parse(source_code)

results = defaultdict(list)

seen = set() # (construct, lineno) pairs already counted

# step 0: Create a module list - needed for some checks

imported_modules = get_imported_modules(source_code)

core_modules = imported_modules[

"core_modules"

] # Only interested in core modules that are imported

# Step 1: Build alias map

alias_map = {}

for node in ast.iter_child_nodes(tree):

if isinstance(node, ast.Import):

for alias in node.names:

alias_map[alias.asname or alias.name] = alias.name

elif isinstance(node, ast.ImportFrom):

module = node.module

for alias in node.names:

full_name = f"{module}.{alias.name}"

alias_map[alias.asname or alias.name] = full_name

# Step 2: Walk the AST

for node in ast.walk(tree):

lineno = getattr(node, "lineno", None)

construct = None

if isinstance(node, ast.Call):

func = node.func

if isinstance(func, ast.Attribute):

full = get_full_attr_name(func)

prefix = full.split(".")[0]

resolved_prefix = alias_map.get(prefix, prefix)

full_resolved = resolved_prefix + full[len(prefix) :]

if full_resolved in constructs_to_detect:

construct = full_resolved

elif (

node.func.attr in ("extractall", "extract")

and "tarfile" in core_modules

): # note only in combination with tarfile module or alias,see step1

construct = "tarfile.TarFile"

elif (

node.func.attr in ("eval") and "builtins" in core_modules

): # catch obfuscating eval construct with builtins module

construct = "eval"

elif (

node.func.attr in ("exec") and "builtins" in core_modules

): # catch obfuscating exec construct with builtins module

construct = "exec"

elif (

node.func.attr in ("input") and "builtins" in core_modules

): # catch obfuscating construct with builtins module

construct = "input"

elif (

node.func.attr in ("compile") and "builtins" in core_modules

): # catch obfuscating construct with builtins module

construct = "compile"

elif isinstance(func, ast.Name):

resolved = alias_map.get(func.id, func.id)

if resolved in constructs_to_detect:

construct = resolved

# Attribute usage: path.exists

elif isinstance(node, ast.Attribute):

full = get_full_attr_name(node)

prefix = full.split(".")[0]

resolved_prefix = alias_map.get(prefix, prefix)

full_resolved = resolved_prefix + full[len(prefix) :]

if full_resolved in constructs_to_detect:

construct = full_resolved

# Name usage: e.g. eval, os

elif isinstance(node, ast.Name):

resolved = alias_map.get(node.id, node.id)

if resolved in constructs_to_detect:

construct = resolved

# ast.Assert node ,to check on assert - assert is the only valid ast.Assert node!

elif isinstance(node, ast.Assert):

if "assert" in constructs_to_detect:

construct = "assert"

# ast.ExceptHandler — detect use of bare `pass` inside body

elif isinstance(node, ast.ExceptHandler):

if "pass" in constructs_to_detect:

for stmt in node.body:

if isinstance(stmt, ast.Pass):

construct = "pass"

# ast.ExceptHandler — detect use of bare `continue` inside body

if "continue" in constructs_to_detect:

for stmt in node.body:

if isinstance(stmt, ast.Continue):

construct = "continue"

# If valid construct and not yet seen at this line

if construct and lineno and (construct, lineno) not in seen:

results[construct].append(lineno)

seen.add((construct, lineno))

# sort the results by line number

data = dict(results)

sorted_results = {k: sorted(v) for k, v in data.items()}

return dict(sorted_results)