Create smell_detector.py

smell_detector.py

@@ -0,0 +1,179 @@
+import ast
+import hashlib
+import datetime
+
+class CodeSmellDetector:
+    """Main class to detect various code smells in Python code."""
+    
+    def __init__(self, function_length_limit=10, param_limit=5):
+        """
+        Initialize the code smell detector with configurable thresholds.
+        
+        Args:
+            function_length_limit (int): Maximum acceptable function length in lines
+            param_limit (int): Maximum acceptable number of parameters for a function
+        """
+        self.function_length_limit = function_length_limit
+        self.param_limit = param_limit
+        
+    def analyze_code(self, code_string, block_size=3):
+        """
+        Analyze Python code for various code smells.
+        
+        Args:
+            code_string (str): Python code as a string
+            block_size (int): Size of code blocks to check for duplication
+            
+        Returns:
+            dict: Results containing detected smells and duplicate blocks
+        """
+        # Parse the code into an AST
+        try:
+            tree = ast.parse(code_string)
+        except SyntaxError as e:
+            return {
+                "error": f"Syntax error in the provided code: {str(e)}",
+                "function_smells": [],
+                "duplicate_blocks": []
+            }
+            
+        # Detect function-level code smells
+        function_visitor = FunctionSmellVisitor(self.function_length_limit, self.param_limit)
+        function_visitor.visit(tree)
+        
+        # Detect duplicate code blocks
+        duplicate_blocks = self.find_duplicate_blocks(code_string, block_size)
+        
+        return {
+            "function_smells": function_visitor.smells,
+            "duplicate_blocks": duplicate_blocks
+        }
+    
+    def find_duplicate_blocks(self, source_code, block_size):
+        """
+        Find duplicate blocks of code.
+        
+        Args:
+            source_code (str): The source code to analyze
+            block_size (int): Size of blocks to check for duplication
+            
+        Returns:
+            list: List of tuples containing (line1, line2, block_content)
+        """
+        lines = [line.strip() for line in source_code.splitlines()]
+        hashes = {}
+        duplicates = []
+        
+        for i in range(len(lines) - block_size + 1):
+            block = "\n".join(lines[i:i+block_size])
+            # Skip empty blocks
+            if not block.strip():
+                continue
+                
+            h = hashlib.md5(block.encode()).hexdigest()
+            
+            if h in hashes:
+                duplicates.append((i + 1, hashes[h] + 1, block))
+            else:
+                hashes[h] = i
+        
+        return duplicates
+    
+    def generate_report(self, filename, results):
+        """
+        Generate a markdown report for the analysis results.
+        
+        Args:
+            filename (str): The name of the analyzed file
+            results (dict): Analysis results
+            
+        Returns:
+            str: Markdown formatted report
+        """
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        
+        report = f"""# Code Smell Analysis Report
+Generated: {now}
+File: {filename}
+
+## Analysis Settings
+- Function length limit: {self.function_length_limit} lines
+- Parameter limit: {self.param_limit}
+- Duplicate block size: {len(results['duplicate_blocks'][0][2].splitlines()) if results['duplicate_blocks'] else 'N/A'} lines
+
+## Function-level Code Smells
+"""
+        if results.get("function_smells"):
+            for smell in results["function_smells"]:
+                report += f"- {smell}\n"
+        else:
+            report += "No function-level code smells detected.\n"
+        
+        report += "\n## Duplicate Code Blocks\n"
+        if results.get("duplicate_blocks"):
+            for idx, dup in enumerate(results["duplicate_blocks"]):
+                report += f"### Duplicate Block #{idx+1}\n"
+                report += f"- Found at lines {dup[0]} and {dup[1]}\n"
+                report += "```python\n"
+                report += dup[2] + "\n"
+                report += "```\n\n"
+        else:
+            report += "No duplicate blocks detected.\n"
+            
+        return report
+
+
+class FunctionSmellVisitor(ast.NodeVisitor):
+    """AST visitor to detect function-related code smells."""
+    
+    def __init__(self, function_length_limit, param_limit):
+        """
+        Initialize with thresholds for function smells.
+        
+        Args:
+            function_length_limit (int): Maximum acceptable function length
+            param_limit (int): Maximum acceptable parameter count
+        """
+        self.function_length_limit = function_length_limit
+        self.param_limit = param_limit
+        self.smells = []
+        
+    def visit_FunctionDef(self, node):
+        """
+        Visit a function definition and check for smells.
+        
+        Args:
+            node (ast.FunctionDef): The function node to analyze
+        """
+        # Check function length
+        start_line = node.lineno
+        end_line = 0
+        
+        # Find the last line in the function body
+        for item in node.body:
+            if hasattr(item, 'lineno'):
+                end_line = max(end_line, item.lineno)
+                
+                # If the item has an end_lineno attribute (Python 3.8+), use it
+                if hasattr(item, 'end_lineno') and item.end_lineno is not None:
+                    end_line = max(end_line, item.end_lineno)
+        
+        # Fall back if we couldn't determine end line
+        if end_line == 0:
+            end_line = start_line + len(node.body)
+            
+        length = end_line - start_line + 1
+        
+        if length > self.function_length_limit:
+            self.smells.append(
+                f"🔴 Long function '{node.name}' ({length} lines) at line {start_line}"
+            )
+        
+        # Check parameter count
+        if len(node.args.args) > self.param_limit:
+            self.smells.append(
+                f"🟠 Function '{node.name}' has too many parameters ({len(node.args.args)}) at line {start_line}"
+            )
+        
+        # Continue visiting child nodes
+        self.generic_visit(node)