All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.springframework.scripting.jruby.JRubyScriptUtils Maven / Gradle / Ivy

There is a newer version: 5.3.39
Show newest version
/*
 * Copyright 2002-2007 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.scripting.jruby;

import java.lang.reflect.Array;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collections;
import java.util.List;

import org.jruby.Ruby;
import org.jruby.RubyArray;
import org.jruby.RubyException;
import org.jruby.RubyNil;
import org.jruby.ast.ClassNode;
import org.jruby.ast.Colon2Node;
import org.jruby.ast.NewlineNode;
import org.jruby.ast.Node;
import org.jruby.exceptions.JumpException;
import org.jruby.exceptions.RaiseException;
import org.jruby.javasupport.JavaEmbedUtils;
import org.jruby.runtime.DynamicScope;
import org.jruby.runtime.builtin.IRubyObject;

import org.springframework.aop.support.AopUtils;
import org.springframework.core.NestedRuntimeException;
import org.springframework.util.ClassUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;

/**
 * Utility methods for handling JRuby-scripted objects.
 *
 * 

Note: As of Spring 2.0.4, this class requires JRuby 0.9.8 or 0.9.9. * As of Spring 2.0.6, it supports JRuby 1.0 as well. * * @author Rob Harrop * @author Juergen Hoeller * @author Rick Evans * @since 2.0 */ public abstract class JRubyScriptUtils { // Determine whether the new JRuby 1.0 parse method is available (incompatible with 0.9) private final static Method newParseMethod = ClassUtils.getMethodIfAvailable( Ruby.class, "parse", new Class[] {String.class, String.class, DynamicScope.class, int.class}); /** * Create a new JRuby-scripted object from the given script source, * using the default {@link ClassLoader}. * @param scriptSource the script source text * @param interfaces the interfaces that the scripted Java object is to implement * @return the scripted Java object * @throws JumpException in case of JRuby parsing failure * @see ClassUtils#getDefaultClassLoader() */ public static Object createJRubyObject(String scriptSource, Class[] interfaces) throws JumpException { return createJRubyObject(scriptSource, interfaces, ClassUtils.getDefaultClassLoader()); } /** * Create a new JRuby-scripted object from the given script source. * @param scriptSource the script source text * @param interfaces the interfaces that the scripted Java object is to implement * @param classLoader the {@link ClassLoader} to create the script proxy with * @return the scripted Java object * @throws JumpException in case of JRuby parsing failure */ public static Object createJRubyObject(String scriptSource, Class[] interfaces, ClassLoader classLoader) { Ruby ruby = initializeRuntime(); Node scriptRootNode = (newParseMethod != null ? (Node) ReflectionUtils.invokeMethod(newParseMethod, ruby, new Object[] {scriptSource, "", null, new Integer(0)}) : ruby.parse(scriptSource, "", null)); IRubyObject rubyObject = ruby.eval(scriptRootNode); if (rubyObject instanceof RubyNil) { String className = findClassName(scriptRootNode); rubyObject = ruby.evalScript("\n" + className + ".new"); } // still null? if (rubyObject instanceof RubyNil) { throw new IllegalStateException("Compilation of JRuby script returned RubyNil: " + rubyObject); } return Proxy.newProxyInstance(classLoader, interfaces, new RubyObjectInvocationHandler(rubyObject, ruby)); } /** * Initializes an instance of the {@link org.jruby.Ruby} runtime. */ private static Ruby initializeRuntime() { return JavaEmbedUtils.initialize(Collections.EMPTY_LIST); } /** * Given the root {@link Node} in a JRuby AST will locate the name of the * class defined by that AST. * @throws IllegalArgumentException if no class is defined by the supplied AST */ private static String findClassName(Node rootNode) { ClassNode classNode = findClassNode(rootNode); if (classNode == null) { throw new IllegalArgumentException("Unable to determine class name for root node '" + rootNode + "'"); } Colon2Node node = (Colon2Node) classNode.getCPath(); return node.getName(); } /** * Find the first {@link ClassNode} under the supplied {@link Node}. * @return the found ClassNode, or null * if no {@link ClassNode} is found */ private static ClassNode findClassNode(Node node) { if (node instanceof ClassNode) { return (ClassNode) node; } List children = node.childNodes(); for (int i = 0; i < children.size(); i++) { Node child = (Node) children.get(i); if (child instanceof ClassNode) { return (ClassNode) child; } else if (child instanceof NewlineNode) { NewlineNode nn = (NewlineNode) child; Node found = findClassNode(nn.getNextNode()); if (found instanceof ClassNode) { return (ClassNode) found; } } } for (int i = 0; i < children.size(); i++) { Node child = (Node) children.get(i); Node found = findClassNode(child); if (found instanceof ClassNode) { return (ClassNode) found; } } return null; } /** * InvocationHandler that invokes a JRuby script method. */ private static class RubyObjectInvocationHandler implements InvocationHandler { private final IRubyObject rubyObject; private final Ruby ruby; public RubyObjectInvocationHandler(IRubyObject rubyObject, Ruby ruby) { this.rubyObject = rubyObject; this.ruby = ruby; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (AopUtils.isEqualsMethod(method)) { return (isProxyForSameRubyObject(args[0]) ? Boolean.TRUE : Boolean.FALSE); } if (AopUtils.isHashCodeMethod(method)) { return new Integer(this.rubyObject.hashCode()); } if (AopUtils.isToStringMethod(method)) { String toStringResult = this.rubyObject.toString(); if (!StringUtils.hasText(toStringResult)) { toStringResult = ObjectUtils.identityToString(this.rubyObject); } return "JRuby object [" + toStringResult + "]"; } try { IRubyObject[] rubyArgs = convertToRuby(args); IRubyObject rubyResult = this.rubyObject.callMethod(this.ruby.getCurrentContext(), method.getName(), rubyArgs); return convertFromRuby(rubyResult, method.getReturnType()); } catch (RaiseException ex) { throw new JRubyExecutionException(ex); } } private boolean isProxyForSameRubyObject(Object other) { if (!Proxy.isProxyClass(other.getClass())) { return false; } InvocationHandler ih = Proxy.getInvocationHandler(other); return (ih instanceof RubyObjectInvocationHandler && this.rubyObject.equals(((RubyObjectInvocationHandler) ih).rubyObject)); } private IRubyObject[] convertToRuby(Object[] javaArgs) { if (javaArgs == null || javaArgs.length == 0) { return new IRubyObject[0]; } IRubyObject[] rubyArgs = new IRubyObject[javaArgs.length]; for (int i = 0; i < javaArgs.length; ++i) { rubyArgs[i] = JavaEmbedUtils.javaToRuby(this.ruby, javaArgs[i]); } return rubyArgs; } private Object convertFromRuby(IRubyObject rubyResult, Class returnType) { Object result = JavaEmbedUtils.rubyToJava(this.ruby, rubyResult, returnType); if (result instanceof RubyArray && returnType.isArray()) { result = convertFromRubyArray(((RubyArray) result).toJavaArray(), returnType); } return result; } private Object convertFromRubyArray(IRubyObject[] rubyArray, Class returnType) { Class targetType = returnType.getComponentType(); Object javaArray = Array.newInstance(targetType, rubyArray.length); for (int i = 0; i < rubyArray.length; i++) { IRubyObject rubyObject = rubyArray[i]; Array.set(javaArray, i, convertFromRuby(rubyObject, targetType)); } return javaArray; } } /** * Exception thrown in response to a JRuby {@link RaiseException} * being thrown from a JRuby method invocation. *

Introduced because the RaiseException class does not * have useful {@link Object#toString()}, {@link Throwable#getMessage()}, * and {@link Throwable#printStackTrace} implementations. */ public static class JRubyExecutionException extends NestedRuntimeException { /** * Create a new JRubyException, * wrapping the given JRuby RaiseException. * @param ex the cause (must not be null) */ public JRubyExecutionException(RaiseException ex) { super(buildMessage(ex), ex); } private static String buildMessage(RaiseException ex) { RubyException rubyEx = ex.getException(); return (rubyEx != null && rubyEx.message != null) ? rubyEx.message.toString() : "Unexpected JRuby error"; } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy