Replace invoke_method with get_attribute for language-agnostic proxy attribute access

Removes the now-unused invoke_method from ScriptSyntax and introduces
get_attribute to handle attribute access in a language-specific way.

Key changes:
- Added ScriptSyntax.get_attribute(obj, attr) method
- PythonSyntax: Returns "obj.attr" (gets field or bound method)
- GroovySyntax: Returns try/catch block that attempts field access
  first, falls back to method reference (&) on MissingPropertyException
- ProxyObject.__getattr__: Now uses syntax.get_attribute() instead of
  hardcoded string formatting
- Removed invoke_method from both PythonSyntax and GroovySyntax (dead code)

Groovy attribute access behavior:
- obj.field (field only) → returns field value
- obj.method (method only) → returns MethodClosure proxy
- obj.foo (both field and method) → returns field (method inaccessible)
- Workaround for conflicts: service.call("obj.method", args)

This design maintains the elegant chaining behavior for Python while
properly handling Groovy's different semantics for fields vs methods.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: ctrueden

src/appose/syntax.py

@@ -89,22 +89,20 @@ def call(self, function: str, arg_var_names: list[str]) -> str:
         ...
 
     @abstractmethod
-    def invoke_method(
-        self, object_var_name: str, method_name: str, arg_var_names: list[str]
-    ) -> str:
+    def get_attribute(self, object_var_name: str, attribute_name: str) -> str:
         """
-        Generate a script expression to invoke a method on an object.
+        Generate a script expression to retrieve a single attribute from an object.
 
-        The object must have been previously exported using task.export().
-        This is used by the proxy mechanism to forward method calls to remote objects.
+        This is used by proxy objects to implement __getattr__() for attribute access.
+        The implementation should handle both fields and methods appropriately for
+        the target language.
 
         Args:
             object_var_name: The name of the variable referencing the object.
-            method_name: The name of the method to invoke.
-            arg_var_names: The names of input variables containing the arguments.
+            attribute_name: The name of the attribute to retrieve.
 
         Returns:
-            A script expression that invokes the method and evaluates to its result.
+            A script expression that evaluates to the attribute value or method reference.
         """
         ...
 
@@ -148,11 +146,10 @@ def call(self, function: str, arg_var_names: list[str]) -> str:
         # Python function call syntax: function(arg0, arg1, ...)
         return f"{function}({', '.join(arg_var_names)})"
 
-    def invoke_method(
-        self, object_var_name: str, method_name: str, arg_var_names: list[str]
-    ) -> str:
-        # Python method invocation: object.method(arg0, arg1, ...)
-        return f"{object_var_name}.{method_name}({', '.join(arg_var_names)})"
+    def get_attribute(self, object_var_name: str, attribute_name: str) -> str:
+        # Python attribute access: object.attribute
+        # This returns either the field value or a bound method object.
+        return f"{object_var_name}.{attribute_name}"
 
     def get_attributes(self, object_var_name: str) -> str:
         # Return all attributes from dir(), including private ones.
@@ -185,11 +182,14 @@ def call(self, function: str, arg_var_names: list[str]) -> str:
         # Groovy function call syntax: function(arg0, arg1, ...)
         return f"{function}({', '.join(arg_var_names)})"
 
-    def invoke_method(
-        self, object_var_name: str, method_name: str, arg_var_names: list[str]
-    ) -> str:
-        # Groovy method invocation: object.method(arg0, arg1, ...)
-        return f"{object_var_name}.{method_name}({', '.join(arg_var_names)})"
+    def get_attribute(self, object_var_name: str, attribute_name: str) -> str:
+        # Groovy attribute access: try field first, then method reference.
+        # This handles the case where both field and method exist with same name:
+        # field access takes precedence (Groovy semantics).
+        return (
+            f"try {{ {object_var_name}.{attribute_name} }} "
+            f"catch (groovy.lang.MissingPropertyException e) {{ {object_var_name}.&{attribute_name} }}"
+        )
 
     def get_attributes(self, object_var_name: str) -> str:
         # Return all method names and property names from the object's metaclass.

src/appose/util/proxy.py

@@ -93,11 +93,13 @@ def __init__(self, service: Service, var: str, queue: str | None):
             self._queue = queue
 
         def __getattr__(self, name: str):
-            # Immediately evaluate the attribute access on the worker.
-            attr_expr = f"{self._var}.{name}"
+            # Use the service's ScriptSyntax to generate the attribute access script.
+            # This allows language-specific handling (e.g., Groovy's field vs method).
+            syntax.validate(self._service)
+            script = self._service._syntax.get_attribute(self._var, name)
 
             try:
-                task = self._service.task(attr_expr, queue=self._queue)
+                task = self._service.task(script, queue=self._queue)
                 task.wait_for()
                 result = task.result()
                 # If result is a worker_object, it will already be a ProxyObject