IncludeCPP 3.5.0__py3-none-any.whl → 3.7.1__py3-none-any.whl

includecpp/core/cssl/cssl_builtins.py

@@ -162,6 +162,10 @@ class CSSLBuiltins:
         self._functions['abspath'] = self.builtin_abspath
         self._functions['normpath'] = self.builtin_normpath
         # File I/O functions
+        self._functions['read'] = self.builtin_read
+        self._functions['readline'] = self.builtin_readline
+        self._functions['write'] = self.builtin_write
+        self._functions['writeline'] = self.builtin_writeline
         self._functions['readfile'] = self.builtin_readfile
         self._functions['writefile'] = self.builtin_writefile
         self._functions['appendfile'] = self.builtin_appendfile
@@ -177,6 +181,29 @@ class CSSLBuiltins:
         # JSON functions
         self._functions['tojson'] = self.builtin_tojson
         self._functions['fromjson'] = self.builtin_fromjson
+        # JSON namespace functions (json::read, json::write, etc.)
+        self._functions['json::read'] = self.builtin_json_read
+        self._functions['json::write'] = self.builtin_json_write
+        self._functions['json::parse'] = self.builtin_fromjson
+        self._functions['json::stringify'] = self.builtin_tojson
+        self._functions['json::pretty'] = self.builtin_json_pretty
+        self._functions['json::keys'] = self.builtin_json_keys
+        self._functions['json::values'] = self.builtin_json_values
+        self._functions['json::get'] = self.builtin_json_get
+        self._functions['json::set'] = self.builtin_json_set
+        self._functions['json::has'] = self.builtin_json_has
+        self._functions['json::merge'] = self.builtin_json_merge
+
+        # Instance introspection functions (instance::getMethods, etc.)
+        self._functions['instance::getMethods'] = self.builtin_instance_getMethods
+        self._functions['instance::getClasses'] = self.builtin_instance_getClasses
+        self._functions['instance::getVars'] = self.builtin_instance_getVars
+        self._functions['instance::getAll'] = self.builtin_instance_getAll
+        self._functions['instance::call'] = self.builtin_instance_call
+        self._functions['instance::has'] = self.builtin_instance_has
+        self._functions['instance::type'] = self.builtin_instance_type
+        self._functions['isavailable'] = self.builtin_isavailable
+        self._functions['instance::exists'] = self.builtin_isavailable  # Alias
 
         # Regex functions
         self._functions['match'] = self.builtin_match
@@ -801,6 +828,54 @@ class CSSLBuiltins:
 
     # ============= File I/O Functions =============
 
+    def builtin_read(self, path: str, encoding: str = 'utf-8') -> str:
+        """Read entire file content.
+        Usage: read('/path/to/file.txt')
+        """
+        with open(path, 'r', encoding=encoding) as f:
+            return f.read()
+
+    def builtin_readline(self, line: int, path: str, encoding: str = 'utf-8') -> str:
+        """Read specific line from file (1-indexed).
+        Usage: readline(5, '/path/to/file.txt')  -> returns line 5
+        """
+        with open(path, 'r', encoding=encoding) as f:
+            for i, file_line in enumerate(f, 1):
+                if i == line:
+                    return file_line.rstrip('\n\r')
+            return ""  # Line not found
+
+    def builtin_write(self, path: str, content: str, encoding: str = 'utf-8') -> int:
+        """Write content to file, returns chars written.
+        Usage: write('/path/to/file.txt', 'Hello World')
+        """
+        with open(path, 'w', encoding=encoding) as f:
+            return f.write(content)
+
+    def builtin_writeline(self, line: int, content: str, path: str, encoding: str = 'utf-8') -> bool:
+        """Write/replace specific line in file (1-indexed).
+        Usage: writeline(5, 'New content', '/path/to/file.txt')
+        """
+        # Read all lines
+        lines = []
+        if os.path.exists(path):
+            with open(path, 'r', encoding=encoding) as f:
+                lines = f.readlines()
+
+        # Ensure we have enough lines
+        while len(lines) < line:
+            lines.append('\n')
+
+        # Replace the specific line (1-indexed)
+        if not content.endswith('\n'):
+            content = content + '\n'
+        lines[line - 1] = content
+
+        # Write back
+        with open(path, 'w', encoding=encoding) as f:
+            f.writelines(lines)
+        return True
+
     def builtin_readfile(self, path: str, encoding: str = 'utf-8') -> str:
         """Read entire file content"""
         with open(path, 'r', encoding=encoding) as f:
@@ -862,6 +937,209 @@ class CSSLBuiltins:
     def builtin_fromjson(self, s: str) -> Any:
         return json.loads(s)
 
+    # JSON namespace functions (json::read, json::write, etc.)
+    def builtin_json_read(self, path: str, encoding: str = 'utf-8') -> Any:
+        """Read and parse JSON file.
+        Usage: json::read('/path/to/file.json')
+        """
+        with open(path, 'r', encoding=encoding) as f:
+            return json.load(f)
+
+    def builtin_json_write(self, path: str, data: Any, indent: int = 2, encoding: str = 'utf-8') -> bool:
+        """Write data to JSON file.
+        Usage: json::write('/path/to/file.json', data)
+        """
+        with open(path, 'w', encoding=encoding) as f:
+            json.dump(data, f, indent=indent, ensure_ascii=False)
+        return True
+
+    def builtin_json_pretty(self, value: Any, indent: int = 2) -> str:
+        """Pretty print JSON.
+        Usage: json::pretty(data)
+        """
+        return json.dumps(value, indent=indent, ensure_ascii=False)
+
+    def builtin_json_keys(self, data: Any) -> list:
+        """Get all keys from JSON object.
+        Usage: json::keys(data)
+        """
+        if isinstance(data, dict):
+            return list(data.keys())
+        return []
+
+    def builtin_json_values(self, data: Any) -> list:
+        """Get all values from JSON object.
+        Usage: json::values(data)
+        """
+        if isinstance(data, dict):
+            return list(data.values())
+        return []
+
+    def builtin_json_get(self, data: Any, path: str, default: Any = None) -> Any:
+        """Get value by dot-path from JSON.
+        Usage: json::get(data, 'user.name')
+        """
+        if not isinstance(data, dict):
+            return default
+        keys = path.split('.')
+        current = data
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            elif isinstance(current, list):
+                try:
+                    current = current[int(key)]
+                except (ValueError, IndexError):
+                    return default
+            else:
+                return default
+        return current
+
+    def builtin_json_set(self, data: Any, path: str, value: Any) -> Any:
+        """Set value by dot-path in JSON object.
+        Usage: json::set(data, 'user.name', 'John')
+        """
+        if not isinstance(data, dict):
+            return data
+        data = dict(data)  # Copy
+        keys = path.split('.')
+        current = data
+        for i, key in enumerate(keys[:-1]):
+            if key not in current or not isinstance(current[key], dict):
+                current[key] = {}
+            current = current[key]
+        current[keys[-1]] = value
+        return data
+
+    def builtin_json_has(self, data: Any, path: str) -> bool:
+        """Check if path exists in JSON.
+        Usage: json::has(data, 'user.name')
+        """
+        result = self.builtin_json_get(data, path, _MISSING := object())
+        return result is not _MISSING
+
+    def builtin_json_merge(self, *dicts) -> dict:
+        """Deep merge multiple JSON objects.
+        Usage: json::merge(obj1, obj2, obj3)
+        """
+        def deep_merge(base, update):
+            result = dict(base)
+            for key, value in update.items():
+                if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                    result[key] = deep_merge(result[key], value)
+                else:
+                    result[key] = value
+            return result
+
+        result = {}
+        for d in dicts:
+            if isinstance(d, dict):
+                result = deep_merge(result, d)
+        return result
+
+    # ============= Instance Introspection Functions =============
+
+    def builtin_instance_getMethods(self, obj: Any) -> list:
+        """Get all methods from an object/module.
+        Usage: instance::getMethods(@module) or instance::getMethods($obj)
+        Returns list of method names.
+        """
+        import inspect
+        methods = []
+        for name in dir(obj):
+            if not name.startswith('_'):
+                attr = getattr(obj, name, None)
+                if callable(attr):
+                    methods.append(name)
+        return methods
+
+    def builtin_instance_getClasses(self, obj: Any) -> list:
+        """Get all classes from an object/module.
+        Usage: instance::getClasses(@module)
+        Returns list of class names.
+        """
+        import inspect
+        classes = []
+        for name in dir(obj):
+            if not name.startswith('_'):
+                attr = getattr(obj, name, None)
+                if inspect.isclass(attr):
+                    classes.append(name)
+        return classes
+
+    def builtin_instance_getVars(self, obj: Any) -> list:
+        """Get all variables/attributes (non-callable) from an object.
+        Usage: instance::getVars(@module)
+        Returns list of variable names.
+        """
+        vars_list = []
+        for name in dir(obj):
+            if not name.startswith('_'):
+                attr = getattr(obj, name, None)
+                if not callable(attr):
+                    vars_list.append(name)
+        return vars_list
+
+    def builtin_instance_getAll(self, obj: Any) -> dict:
+        """Get all attributes from an object, categorized.
+        Usage: instance::getAll(@module)
+        Returns dict with 'methods', 'classes', 'vars' keys.
+        """
+        import inspect
+        result = {
+            'methods': [],
+            'classes': [],
+            'vars': []
+        }
+        for name in dir(obj):
+            if not name.startswith('_'):
+                attr = getattr(obj, name, None)
+                if inspect.isclass(attr):
+                    result['classes'].append(name)
+                elif callable(attr):
+                    result['methods'].append(name)
+                else:
+                    result['vars'].append(name)
+        return result
+
+    def builtin_instance_call(self, obj: Any, method_name: str, *args, **kwargs) -> Any:
+        """Dynamically call a method on an object.
+        Usage: instance::call(@module, 'methodName', arg1, arg2)
+        """
+        method = getattr(obj, method_name, None)
+        if method and callable(method):
+            return method(*args, **kwargs)
+        raise RuntimeError(f"Method '{method_name}' not found on object")
+
+    def builtin_instance_has(self, obj: Any, name: str) -> bool:
+        """Check if object has an attribute.
+        Usage: instance::has(@module, 'methodName')
+        """
+        return hasattr(obj, name)
+
+    def builtin_instance_type(self, obj: Any) -> str:
+        """Get the type name of an object.
+        Usage: instance::type(@module)
+        """
+        return type(obj).__name__
+
+    def builtin_isavailable(self, name_or_obj: Any) -> bool:
+        """Check if a shared instance exists.
+        Usage:
+            isavailable("MyInstance")     - check by name string
+            isavailable($MyInstance)      - check shared ref (returns True if not None)
+            instance::exists("MyInstance") - alias
+        """
+        from ..cssl_bridge import _live_objects
+
+
+        # If it's a string, check by name
+        if isinstance(name_or_obj, str):
+            return name_or_obj in _live_objects
+
+        # Otherwise, check if the object is not None (for $name or instance<"name">)
+        return name_or_obj is not None
+
     # ============= Regex Functions =============
 
     def builtin_match(self, pattern: str, string: str) -> Optional[dict]:
@@ -913,6 +1191,29 @@ class CSSLBuiltins:
         else:
             raise SystemExit(code)
 
+    def builtin_original(self, func_name: str, *args) -> Any:
+        """Call the original version of a replaced function.
+
+        Usage:
+            exit <<== { printl("custom exit"); }
+            original("exit");  // Calls the ORIGINAL exit, not the replacement
+
+            // In an injection that was defined BEFORE replacement:
+            old_exit <<== { original("exit"); }  // Calls original exit
+        """
+        if self.runtime and hasattr(self.runtime, '_original_functions'):
+            original_func = self.runtime._original_functions.get(func_name)
+            if original_func is not None:
+                if callable(original_func):
+                    return original_func(*args)
+                elif isinstance(original_func, type(lambda: None).__class__.__bases__[0]):  # Check if bound method
+                    return original_func(*args)
+        # Fallback: try to call builtin directly
+        builtin_method = getattr(self, f'builtin_{func_name}', None)
+        if builtin_method:
+            return builtin_method(*args)
+        raise CSSLBuiltinError(f"No original function '{func_name}' found")
+
     def builtin_env(self, name: str, default: str = None) -> Optional[str]:
         return os.environ.get(name, default)
 
@@ -1902,15 +2203,54 @@ class CSSLBuiltins:
         from .cssl_types import OpenQuote
         return OpenQuote(db_ref)
 
-    def builtin_openfind(self, combo_or_type: Any, index: int = 0) -> Any:
+    def builtin_openfind(self, combo_or_type: Any, index: int = 0, params: list = None) -> Any:
         """Find open parameter by type or combo space.
 
-        Usage: OpenFind<string>(0) or OpenFind(&@comboSpace)
+        Usage:
+            OpenFind<string>(0)  # Find first string at position 0
+            OpenFind(&@comboSpace)  # Find using combo filter
+
+        When using with open parameters:
+            open define myFunc(open Params) {
+                string name = OpenFind<string>(0);  // Find nearest string at index 0
+                int age = OpenFind<int>(1);  // Find nearest int at index 1
+            }
         """
         from .cssl_types import Combo
 
         if isinstance(combo_or_type, Combo):
+            # Find by combo space
+            if params:
+                return combo_or_type.find_match(params)
             return combo_or_type.find_match([])
+
+        # Type-based search
+        target_type = combo_or_type
+        if params is None:
+            params = []
+
+        # Map type names to Python types
+        type_map = {
+            'string': str, 'str': str,
+            'int': int, 'integer': int,
+            'float': float, 'double': float,
+            'bool': bool, 'boolean': bool,
+            'list': list, 'array': list,
+            'dict': dict, 'dictionary': dict
+        }
+
+        python_type = type_map.get(str(target_type).lower(), None)
+        if python_type is None:
+            return None
+
+        # Find the nearest matching type from index position
+        matches_found = 0
+        for i, param in enumerate(params):
+            if isinstance(param, python_type):
+                if matches_found == index:
+                    return param
+                matches_found += 1
+
         return None