Add getAttribute for language-agnostic proxy attribute access

See also apposed/appose-python@93d1813.

Unlike that commit, though, we do not get rid of ScriptSyntax's
invokeMethod, because here in Java it is still important for method
calls via type-safe proxy objects.

Co-authored-by: Claude <[email protected]>

Author: ctrueden

src/main/java/org/apposed/appose/ScriptSyntax.java

@@ -104,4 +104,30 @@ public interface ScriptSyntax {
 	 * @see Service#proxy
 	 */
 	String invokeMethod(String objectVarName, String methodName, List<String> argVarNames);
+
+	/**
+	 * Generates a script expression to retrieve an attribute from an object.
+	 * <p>
+	 * The object must have been previously exported using {@code task.export()}.
+	 * This is used to access fields or obtain method references from remote objects.
+	 * </p>
+	 * <p>
+	 * The behavior depends on the language:
+	 * </p>
+	 * <ul>
+	 * <li><strong>Python:</strong> Returns the attribute value (field) or bound method object.</li>
+	 * <li><strong>Groovy:</strong> Tries field access first; if no such field exists,
+	 *     returns a method reference using {@code .&} syntax.</li>
+	 * </ul>
+	 * <p>
+	 * If the result is a method reference, it will be auto-proxied as a {@link WorkerObject}
+	 * that can be called using {@link WorkerObject#call(Object...)}.
+	 * </p>
+	 *
+	 * @param objectVarName The name of the variable referencing the object.
+	 * @param attributeName The name of the attribute to retrieve.
+	 * @return A script expression that evaluates to the attribute value or method reference.
+	 * @see WorkerObject#getAttribute(String)
+	 */
+	String getAttribute(String objectVarName, String attributeName);
 }

src/main/java/org/apposed/appose/WorkerObject.java

@@ -112,9 +112,11 @@ public String varName() {
 	}
 
 	/**
-	 * Calls a method on the remote object.
+	 * Calls a method on the remote object by name.
 	 * <p>
 	 * This is a blocking operation that waits for the remote method to complete.
+	 * Uses {@link ScriptSyntax#invokeMethod(String, String, java.util.List)} to
+	 * generate the method invocation script.
 	 * </p>
 	 *
 	 * @param methodName The name of the method to invoke.
@@ -144,6 +146,106 @@ public Object call(String methodName, Object... args) throws InterruptedExceptio
 		return task.result();
 	}
 
+	/**
+	 * Invokes this remote object as a callable (function, method reference, or closure).
+	 * <p>
+	 * This is used when this WorkerObject represents a callable object, such as:
+	 * </p>
+	 * <ul>
+	 * <li>A method reference obtained via {@link #getAttribute(String)}</li>
+	 * <li>A function or closure</li>
+	 * <li>Any object with a {@code __call__} method (Python) or {@code call} method (Groovy)</li>
+	 * </ul>
+	 * <p>
+	 * This is a blocking operation that waits for the remote invocation to complete.
+	 * Uses {@link ScriptSyntax#call(String, java.util.List)} to generate the call script.
+	 * </p>
+	 * <p>
+	 * Example:
+	 * </p>
+	 * <pre>
+	 * WorkerObject obj = ...;
+	 * WorkerObject methodRef = (WorkerObject) obj.getAttribute("compute");
+	 * Object result = methodRef.invoke(arg1, arg2);  // Invokes the method reference
+	 * </pre>
+	 *
+	 * @param args The arguments to pass to the callable.
+	 * @return The result of invoking the remote object.
+	 * @throws InterruptedException If the calling thread is interrupted while waiting.
+	 * @throws TaskException If the invocation fails in the worker process.
+	 */
+	public Object invoke(Object... args) throws InterruptedException, TaskException {
+		// Build the call script using the service's syntax.
+		java.util.Map<String, Object> inputs = new java.util.HashMap<>();
+		java.util.List<String> argNames = new java.util.ArrayList<>();
+		for (int i = 0; i < args.length; i++) {
+			String argName = "arg" + i;
+			inputs.put(argName, args[i]);
+			argNames.add(argName);
+		}
+
+		org.apposed.appose.syntax.Syntaxes.validate(service);
+		String script = service.syntax().call(varName, argNames);
+
+		Service.Task task = service.task(script, inputs, queue);
+		task.waitFor();
+		if (task.status != Service.TaskStatus.COMPLETE) {
+			throw new TaskException("Task failed: " + task.error, task);
+		}
+		return task.result();
+	}
+
+	/**
+	 * Retrieves an attribute from the remote object.
+	 * <p>
+	 * The behavior depends on the worker language:
+	 * </p>
+	 * <ul>
+	 * <li><strong>Python:</strong> Returns the attribute value (field) or bound method object.</li>
+	 * <li><strong>Groovy:</strong> Tries field access first; if no such field exists,
+	 *     returns a method reference (closure).</li>
+	 * </ul>
+	 * <p>
+	 * If the result is a method reference or other non-JSON-serializable object,
+	 * it will be auto-proxied as a {@code WorkerObject} that can be called using
+	 * {@link #call(Object...)}.
+	 * </p>
+	 * <p>
+	 * This is a blocking operation that waits for the remote operation to complete.
+	 * Uses {@link ScriptSyntax#getAttribute(String, String)} to generate the attribute
+	 * access script.
+	 * </p>
+	 * <p>
+	 * Example:
+	 * </p>
+	 * <pre>
+	 * WorkerObject obj = ...;
+	 *
+	 * // Field access - returns value directly
+	 * String label = (String) obj.getAttribute("label");
+	 *
+	 * // Method reference - returns WorkerObject that can be invoked
+	 * WorkerObject methodRef = (WorkerObject) obj.getAttribute("compute");
+	 * Object result = methodRef.invoke(arg1, arg2);
+	 * </pre>
+	 *
+	 * @param attributeName The name of the attribute to retrieve.
+	 * @return The attribute value (field) or a WorkerObject (method reference).
+	 * @throws InterruptedException If the calling thread is interrupted while waiting.
+	 * @throws TaskException If the attribute access fails in the worker process.
+	 */
+	public Object getAttribute(String attributeName) throws InterruptedException, TaskException {
+		org.apposed.appose.syntax.Syntaxes.validate(service);
+		String script = service.syntax().getAttribute(varName, attributeName);
+
+		Service.Task task = service.task(script, queue);
+		task.waitFor();
+		if (task.status != Service.TaskStatus.COMPLETE) {
+			throw new TaskException("Task failed: " + task.error, task);
+		}
+		return task.result();
+	}
+
 	/**
 	 * Creates a strongly-typed proxy for this remote object.
 	 * <p>

src/main/java/org/apposed/appose/syntax/GroovySyntax.java

@@ -74,4 +74,15 @@ public String invokeMethod(String objectVarName, String methodName, List<String>
 		// Groovy method invocation: object.method(arg0, arg1, ...)
 		return objectVarName + "." + methodName + "(" + String.join(", ", argVarNames) + ")";
 	}
+
+	@Override
+	public String getAttribute(String objectVarName, String attributeName) {
+		// 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).
+		// The .& syntax creates a method reference (closure) that can be called later.
+		return "try { " + objectVarName + "." + attributeName + " } " +
+			"catch (groovy.lang.MissingPropertyException e) { " +
+			objectVarName + ".&" + attributeName + " }";
+	}
 }

src/main/java/org/apposed/appose/syntax/PythonSyntax.java

@@ -73,4 +73,11 @@ public String invokeMethod(String objectVarName, String methodName, List<String>
 		// Python method invocation: object.method(arg0, arg1, ...)
 		return objectVarName + "." + methodName + "(" + String.join(", ", argVarNames) + ")";
 	}
+
+	@Override
+	public String getAttribute(String objectVarName, String attributeName) {
+		// Python attribute access: object.attribute
+		// This returns either the field value or a bound method object.
+		return objectVarName + "." + attributeName;
+	}
 }

src/test/java/org/apposed/appose/SyntaxTest.java

@@ -290,6 +290,51 @@ public void testProxy() throws Exception {
 		}
 	}
 
+	/** Tests getAttribute and invoke for field and method access. */
+	@Test
+	public void testGetAttributeGroovy() throws Exception {
+		Environment env = Appose.system();
+		try (Service service = env.groovy()) {
+			maybeDebug(service);
+
+			// Create a class with both fields and methods
+			Task setup = service.task(
+				"class TestClass {\n" +
+				"  String fieldValue = 'field_data'\n" +
+				"  String methodValue() { return 'method_data' }\n" +
+				"  String compute(int x, int y) { return \"result: ${x + y}\" }\n" +
+				"}\n" +
+				"new TestClass()"
+			).waitFor();
+			assertComplete(setup);
+
+			// Get the WorkerObject
+			WorkerObject testObj = (WorkerObject) setup.result();
+
+			// Test 1: Field access via getAttribute - should return value directly
+			Object fieldResult = testObj.getAttribute("fieldValue");
+			assertInstanceOf(String.class, fieldResult);
+			assertEquals("field_data", fieldResult);
+
+			// Test 2: Method reference via getAttribute + invoke
+			// methodValue has no field, so getAttribute returns method reference
+			Object methodAttr = testObj.getAttribute("methodValue");
+			assertInstanceOf(WorkerObject.class, methodAttr);
+			Object methodResult = ((WorkerObject) methodAttr).invoke();
+			assertEquals("method_data", methodResult);
+
+			// Test 3: Method reference with arguments
+			Object computeAttr = testObj.getAttribute("compute");
+			assertInstanceOf(WorkerObject.class, computeAttr);
+			Object computeResult = ((WorkerObject) computeAttr).invoke(5, 7);
+			assertEquals("result: 12", computeResult);
+
+			// Test 4: Compare with direct method invocation (existing functionality)
+			Object directResult = testObj.call("compute", 3, 4);
+			assertEquals("result: 7", directResult);
+		}
+	}
+
 	/** Tests automatic proxying of non-serializable task outputs. */
 	@Test
 	public void testAutoProxyGroovy() throws Exception {