Create JavaScriptToPythonConverter.py

tools/JavaScriptToPythonConverter.py

@@ -0,0 +1,207 @@
+import esprima  # For parsing JavaScript
+import ast      # For Python AST manipulation
+from typing import Union, Dict, List, Any
+
+class JavaScriptToPythonConverter:
+    def __init__(self):
+        self.variable_map: Dict[str, str] = {}
+        
+    def convert_js_to_python(self, js_code: str) -> str:
+        """
+        Convert JavaScript code to Python code.
+        
+        Args:
+            js_code (str): JavaScript code to convert
+            
+        Returns:
+            str: Converted Python code
+        """
+        try:
+            # Parse JavaScript code into AST
+            js_ast = esprima.parseScript(js_code)
+            
+            # Convert the AST to Python code
+            python_code = self._convert_node(js_ast)
+            
+            return python_code
+            
+        except Exception as e:
+            raise ValueError(f"Failed to convert JavaScript code: {str(e)}")
+    
+    def _convert_node(self, node: Any) -> str:
+        """Convert a JavaScript AST node to Python code."""
+        node_type = node.type if hasattr(node, 'type') else type(node).__name__
+        
+        # Map of JavaScript node types to conversion methods
+        converters = {
+            'Program': self._convert_program,
+            'VariableDeclaration': self._convert_variable_declaration,
+            'FunctionDeclaration': self._convert_function_declaration,
+            'ExpressionStatement': self._convert_expression_statement,
+            'BinaryExpression': self._convert_binary_expression,
+            'Identifier': self._convert_identifier,
+            'Literal': self._convert_literal,
+            'CallExpression': self._convert_call_expression,
+            'ReturnStatement': self._convert_return_statement,
+            'IfStatement': self._convert_if_statement,
+            'ForStatement': self._convert_for_statement,
+            'WhileStatement': self._convert_while_statement
+        }
+        
+        converter = converters.get(node_type)
+        if converter:
+            return converter(node)
+        else:
+            raise ValueError(f"Unsupported node type: {node_type}")
+    
+    def _convert_program(self, node: Any) -> str:
+        """Convert a JavaScript program node to Python code."""
+        return '\n'.join(self._convert_node(stmt) for stmt in node.body)
+    
+    def _convert_variable_declaration(self, node: Any) -> str:
+        """Convert JavaScript variable declarations to Python assignments."""
+        declarations = []
+        for decl in node.declarations:
+            var_name = decl.id.name
+            self.variable_map[var_name] = var_name
+            
+            if decl.init:
+                init = self._convert_node(decl.init)
+                declarations.append(f"{var_name} = {init}")
+            else:
+                declarations.append(f"{var_name} = None")
+        
+        return '\n'.join(declarations)
+    
+    def _convert_function_declaration(self, node: Any) -> str:
+        """Convert JavaScript function declarations to Python functions."""
+        func_name = node.id.name
+        params = [param.name for param in node.params]
+        body = self._convert_node(node.body)
+        
+        return f"def {func_name}({', '.join(params)}):\n{self._indent(body)}"
+    
+    def _convert_expression_statement(self, node: Any) -> str:
+        """Convert JavaScript expression statements to Python."""
+        return self._convert_node(node.expression)
+    
+    def _convert_binary_expression(self, node: Any) -> str:
+        """Convert JavaScript binary expressions to Python."""
+        operator_map = {
+            '===': '==',
+            '!==': '!=',
+            '&&': 'and',
+            '||': 'or'
+        }
+        
+        left = self._convert_node(node.left)
+        right = self._convert_node(node.right)
+        op = operator_map.get(node.operator, node.operator)
+        
+        return f"{left} {op} {right}"
+    
+    def _convert_identifier(self, node: Any) -> str:
+        """Convert JavaScript identifiers to Python."""
+        name = node.name
+        # Map JavaScript built-ins to Python equivalents
+        js_to_python_builtins = {
+            'console.log': 'print',
+            'undefined': 'None',
+            'null': 'None',
+            'true': 'True',
+            'false': 'False'
+        }
+        return js_to_python_builtins.get(name, name)
+    
+    def _convert_literal(self, node: Any) -> str:
+        """Convert JavaScript literals to Python literals."""
+        if node.value is None:
+            return 'None'
+        elif isinstance(node.value, (int, float)):
+            return str(node.value)
+        elif isinstance(node.value, str):
+            return repr(node.value)
+        elif isinstance(node.value, bool):
+            return str(node.value)
+        else:
+            raise ValueError(f"Unsupported literal type: {type(node.value)}")
+    
+    def _convert_call_expression(self, node: Any) -> str:
+        """Convert JavaScript function calls to Python."""
+        callee = self._convert_node(node.callee)
+        args = [self._convert_node(arg) for arg in node.arguments]
+        
+        # Handle special cases
+        if callee == 'console.log':
+            callee = 'print'
+        
+        return f"{callee}({', '.join(args)})"
+    
+    def _convert_return_statement(self, node: Any) -> str:
+        """Convert JavaScript return statements to Python."""
+        if node.argument:
+            return f"return {self._convert_node(node.argument)}"
+        return "return"
+    
+    def _convert_if_statement(self, node: Any) -> str:
+        """Convert JavaScript if statements to Python."""
+        test = self._convert_node(node.test)
+        consequent = self._convert_node(node.consequent)
+        
+        if_stmt = f"if {test}:\n{self._indent(consequent)}"
+        
+        if node.alternate:
+            alternate = self._convert_node(node.alternate)
+            if_stmt += f"\nelse:\n{self._indent(alternate)}"
+        
+        return if_stmt
+    
+    def _convert_for_statement(self, node: Any) -> str:
+        """Convert JavaScript for loops to Python."""
+        init = self._convert_node(node.init) if node.init else ""
+        test = self._convert_node(node.test) if node.test else "True"
+        update = self._convert_node(node.update) if node.update else ""
+        body = self._convert_node(node.body)
+        
+        # Convert C-style for loop to while loop
+        if init:
+            return f"{init}\nwhile {test}:\n{self._indent(body)}\n{self._indent(update)}"
+        else:
+            return f"while {test}:\n{self._indent(body)}"
+    
+    def _convert_while_statement(self, node: Any) -> str:
+        """Convert JavaScript while loops to Python."""
+        test = self._convert_node(node.test)
+        body = self._convert_node(node.body)
+        
+        return f"while {test}:\n{self._indent(body)}"
+    
+    def _indent(self, code: str, level: int = 1) -> str:
+        """Indent Python code by specified number of levels."""
+        lines = code.split('\n')
+        return '\n'.join('    ' * level + line for line in lines)
+
+
+# Example usage
+if __name__ == "__main__":
+    converter = JavaScriptToPythonConverter()
+    
+    # Example JavaScript code
+    js_code = """
+    function fibonacci(n) {
+        if (n <= 1) {
+            return n;
+        }
+        return fibonacci(n - 1) + fibonacci(n - 2);
+    }
+    
+    var result = fibonacci(10);
+    console.log("Fibonacci result:", result);
+    """
+    
+    try:
+        python_code = converter.convert_js_to_python(js_code)
+        print("Converted Python code:")
+        print(python_code)
+    except Exception as e:
+        print(f"Conversion error: {str(e)}")