http://git-wip-us.apache.org/repos/asf/groovy/blob/10110145/src/main/groovy/groovy/lang/ExpandoMetaClass.java ---------------------------------------------------------------------- diff --git a/src/main/groovy/groovy/lang/ExpandoMetaClass.java b/src/main/groovy/groovy/lang/ExpandoMetaClass.java new file mode 100644 index 0000000..d56f738 --- /dev/null +++ b/src/main/groovy/groovy/lang/ExpandoMetaClass.java @@ -0,0 +1,1510 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 groovy.lang; + +import org.codehaus.groovy.reflection.CachedClass; +import org.codehaus.groovy.reflection.MixinInMetaClass; +import org.codehaus.groovy.runtime.DefaultCachedMethodKey; +import org.codehaus.groovy.runtime.DefaultGroovyMethods; +import org.codehaus.groovy.runtime.InvokerHelper; +import org.codehaus.groovy.runtime.MetaClassHelper; +import org.codehaus.groovy.runtime.MethodKey; +import org.codehaus.groovy.runtime.callsite.CallSite; +import org.codehaus.groovy.runtime.callsite.ConstructorMetaMethodSite; +import org.codehaus.groovy.runtime.callsite.PogoMetaClassSite; +import org.codehaus.groovy.runtime.callsite.PojoMetaClassSite; +import org.codehaus.groovy.runtime.callsite.StaticMetaClassSite; +import org.codehaus.groovy.runtime.metaclass.ClosureMetaMethod; +import org.codehaus.groovy.runtime.metaclass.ClosureStaticMetaMethod; +import org.codehaus.groovy.runtime.metaclass.DefaultMetaClassInfo; +import org.codehaus.groovy.runtime.metaclass.MethodSelectionException; +import org.codehaus.groovy.runtime.metaclass.MixedInMetaClass; +import org.codehaus.groovy.runtime.metaclass.MixinInstanceMetaMethod; +import org.codehaus.groovy.runtime.metaclass.OwnedMetaClass; +import org.codehaus.groovy.runtime.metaclass.ThreadManagedMetaBeanProperty; +import org.codehaus.groovy.util.FastArray; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantReadWriteLock; + +/** + * ExpandoMetaClass is a MetaClass that behaves like an Expando, allowing the addition or replacement + * of methods, properties and constructors on the fly. + * <p> + * Some examples of usage: + * <pre> + * // defines or replaces instance method: + * metaClass.myMethod = { args -> } + * + * // defines a new instance method + * metaClass.myMethod << { args -> } + * + * // creates multiple overloaded methods of the same name + * metaClass.myMethod << { String s -> } << { Integer i -> } + * + * // defines or replaces a static method with the 'static' qualifier + * metaClass.'static'.myMethod = { args -> } + * + * // defines a new static method with the 'static' qualifier + * metaClass.'static'.myMethod << { args -> } + * + * // defines a new constructor + * metaClass.constructor << { String arg -> } + * + * // defines or replaces a constructor + * metaClass.constructor = { String arg -> } + * + * // defines a new property with an initial value of "blah" + * metaClass.myProperty = "blah" + * </pre> + * <p> + * ExpandoMetaClass also supports a DSL/builder like notation to combine multiple definitions together. So instead of this: + * <pre> + * Number.metaClass.multiply = { Amount amount -> amount.times(delegate) } + * Number.metaClass.div = { Amount amount -> amount.inverse().times(delegate) } + * </pre> + * You can also now do this: + * <pre> + * Number.metaClass { + * multiply { Amount amount -> amount.times(delegate) } + * div { Amount amount -> amount.inverse().times(delegate) } + * } + * </pre> + * <p> + * ExpandoMetaClass also supports runtime mixins. While {@code @Mixin} allows you to mix in new behavior + * to classes you own and are designing, you can not easily mixin anything to types you didn't own, e.g. + * from third party libraries or from JDK library classes. + * Runtime mixins let you add a mixin on any type at runtime. + * <pre> + * interface Vehicle { + * String getName() + * } + * + * // Category annotation style + * {@code @Category}(Vehicle) class FlyingAbility { + * def fly() { "I'm the ${name} and I fly!" } + * } + * + * // traditional category style + * class DivingAbility { + * static dive(Vehicle self) { "I'm the ${self.name} and I dive!" } + * } + * + * // provided by a third-party, so can't augment using Mixin annotation + * class JamesBondVehicle implements Vehicle { + * String getName() { "James Bond's vehicle" } + * } + * + * // Can be added via metaClass, e.g.: + * // JamesBondVehicle.metaClass.mixin DivingAbility, FlyingAbility + * // Or using shorthand through DGM method on Class + * JamesBondVehicle.mixin DivingAbility, FlyingAbility + * + * assert new JamesBondVehicle().fly() == + * "I'm the James Bond's vehicle and I fly!" + * assert new JamesBondVehicle().dive() == + * "I'm the James Bond's vehicle and I dive!" + * </pre> + * As another example, consider the following class definitions: + * <pre> + * class Student { + * List<String> schedule = [] + * def addLecture(String lecture) { schedule << lecture } + * } + * + * class Worker { + * List<String> schedule = [] + * def addMeeting(String meeting) { schedule << meeting } + * } + * </pre> + * We can mimic a form of multiple inheritance as follows: + * <pre> + * class CollegeStudent { + * static { mixin Student, Worker } + * } + * new CollegeStudent().with { + * addMeeting('Performance review with Boss') + * addLecture('Learn about Groovy Mixins') + * println schedule + * println mixedIn[Student].schedule + * println mixedIn[Worker].schedule + * } + * </pre> + * Which outputs these lines when run: + * <pre> + * [Performance review with Boss] + * [Learn about Groovy Mixins] + * [Performance review with Boss] + * </pre> + * Perhaps some explanation is required here. The methods and properties of Student and Worker are + * added to CollegeStudent. Worker is added last, so for overlapping methods, its methods will + * be used, e.g. when calling <code>schedule</code>, it will be the schedule property (getSchedule method) + * from Worker that is used. The schedule property from Student will be shadowed but the <code>mixedIn</code> + * notation allows us to get to that too if we need as the last two lines show. + * <p> + * We can also be a little more dynamic and not require the CollegeStudent class to + * be defined at all, e.g.: + * <pre> + * def cs = new Object() + * cs.metaClass { + * mixin Student, Worker + * getSchedule { + * mixedIn[Student].schedule + mixedIn[Worker].schedule + * } + * } + * cs.with { + * addMeeting('Performance review with Boss') + * addLecture('Learn about Groovy Mixins') + * println schedule + * } + * </pre> + * Which outputs this line when run: + * <pre> + * [Learn about Groovy Mixins, Performance review with Boss] + * </pre> + * As another example, we can also define a no dup queue by mixing in some + * Queue and Set functionality as follows: + * <pre> + * def ndq = new Object() + * ndq.metaClass { + * mixin ArrayDeque + * mixin HashSet + * leftShift = { Object o -> + * if (!mixedIn[Set].contains(o)) { + * mixedIn[Queue].push(o) + * mixedIn[Set].add(o) + * } + * } + * } + * ndq << 1 + * ndq << 2 + * ndq << 1 + * assert ndq.size() == 2 + * </pre> + * As a final example, we sometimes need to pass such mixed in classes or objects + * into Java methods which require a given static type but the ExpandoMetaClass mixin approach uses a very dynamic + * approach based on duck typing rather than static interface definitions, so doesn't by default + * produce objects matching the required static type. Luckily, there is a mixins capability + * within ExpandoMetaClass which supports the use of Groovy's common 'as StaticType' notation to produce an object + * having the correct static type so that it can be passed to the Java method call in question. + * A slightly contrived example illustrating this feature: + * <pre> + * class CustomComparator implements Comparator { + * int compare(Object a, b) { return a.size() - b.size() } + * } + * + * class CustomCloseable implements Closeable { + * void close() { println 'Lights out - I am closing' } + * } + * + * import static mypackage.IOUtils.closeQuietly + * import static java.util.Collections.sort + * def o = new Object() + * o.metaClass.mixin CustomComparator, CustomCloseable + * def items = ['a', 'bbb', 'cc'] + * sort(items, o as Comparator) + * println items // => [a, cc, bbb] + * closeQuietly(o as Closeable) // => Lights out - I am closing + * </pre> + * <p> + * <b>Further details</b> + * <p> + * When using the default implementations of MetaClass, methods are only allowed to be added before initialize() is called. + * In other words you create a new MetaClass, add some methods and then call initialize(). If you attempt to add new methods + * after initialize() has been called, an error will be thrown. This is to ensure that the MetaClass can operate appropriately + * in multi-threaded environments as it forces you to do all method additions at the beginning, before using the MetaClass. + * <p> + * ExpandoMetaClass differs here from the default in that it allows you to add methods after initialize has been called. + * This is done by setting the initialize flag internally to false and then add the methods. Since this is not thread + * safe it has to be done in a synchronized block. The methods to check for modification and initialization are + * therefore synchronized as well. Any method call done through this meta class will first check if the it is + * synchronized. Should this happen during a modification, then the method cannot be selected or called unless the + * modification is completed. + * <p> + * + * @author Graeme Rocher + * @since 1.5 + */ +public class ExpandoMetaClass extends MetaClassImpl implements GroovyObject { + + private static final Class[] EMPTY_CLASS_ARRAY = new Class[0]; + private static final String META_CLASS = "metaClass"; + private static final String CLASS = "class"; + private static final String META_METHODS = "metaMethods"; + private static final String METHODS = "methods"; + private static final String PROPERTIES = "properties"; + public static final String STATIC_QUALIFIER = "static"; + public static final String CONSTRUCTOR = "constructor"; + + private static final String CLASS_PROPERTY = "class"; + private static final String META_CLASS_PROPERTY = "metaClass"; + private static final String GROOVY_CONSTRUCTOR = "<init>"; + + // These two properties are used when no ExpandoMetaClassCreationHandle is present + + private MetaClass myMetaClass; + private boolean initialized; + private volatile boolean modified; + + private boolean initCalled; + private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); + private final Lock readLock = rwl.readLock(); + private final Lock writeLock = rwl.writeLock(); + + private final boolean allowChangesAfterInit; + public boolean inRegistry; + + private final Set<MetaMethod> inheritedMetaMethods = new HashSet<MetaMethod>(); + private final Map<String, MetaProperty> beanPropertyCache = new ConcurrentHashMap<String, MetaProperty>(16, 0.75f, 1); + private final Map<String, MetaProperty> staticBeanPropertyCache = new ConcurrentHashMap<String, MetaProperty>(16, 0.75f, 1); + private final Map<MethodKey, MetaMethod> expandoMethods = new ConcurrentHashMap<MethodKey, MetaMethod>(16, 0.75f, 1); + + public Collection getExpandoSubclassMethods() { + return expandoSubclassMethods.values(); + } + + private final ConcurrentHashMap expandoSubclassMethods = new ConcurrentHashMap(16, 0.75f, 1); + private final Map<String, MetaProperty> expandoProperties = new ConcurrentHashMap<String, MetaProperty>(16, 0.75f, 1); + private ClosureStaticMetaMethod invokeStaticMethodMethod; + private final Set<MixinInMetaClass> mixinClasses = new LinkedHashSet<MixinInMetaClass>(); + + public ExpandoMetaClass(Class theClass, boolean register, boolean allowChangesAfterInit, MetaMethod[] add) { + this(GroovySystem.getMetaClassRegistry(), theClass, register, allowChangesAfterInit, add); + } + + public ExpandoMetaClass(MetaClassRegistry registry, Class theClass, boolean register, boolean allowChangesAfterInit, MetaMethod[] add) { + super(registry, theClass, add); + this.myMetaClass = InvokerHelper.getMetaClass(getClass()); + this.inRegistry = register; + this.allowChangesAfterInit = allowChangesAfterInit; + } + + /** + * Constructs a new ExpandoMetaClass instance for the given class + * + * @param theClass The class that the MetaClass applies to + */ + public ExpandoMetaClass(Class theClass) { + this(theClass,false,false,null); + } + + public ExpandoMetaClass(Class theClass, MetaMethod [] add) { + this(theClass,false,false,add); + } + + /** + * Constructs a new ExpandoMetaClass instance for the given class optionally placing the MetaClass + * in the MetaClassRegistry automatically + * + * @param theClass The class that the MetaClass applies to + * @param register True if the MetaClass should be registered inside the MetaClassRegistry. This defaults to true and ExpandoMetaClass will effect all instances if changed + */ + public ExpandoMetaClass(Class theClass, boolean register) { + this(theClass,register,false,null); + } + + public ExpandoMetaClass(Class theClass, boolean register, MetaMethod [] add) { + this(theClass, register, false, add); + } + + /** + * Constructs a new ExpandoMetaClass instance for the given class optionally placing the MetaClass + * in the MetaClassRegistry automatically + * + * @param theClass The class that the MetaClass applies to + * @param register True if the MetaClass should be registered inside the MetaClassRegistry. This defaults to true and ExpandoMetaClass will effect all instances if changed + * @param allowChangesAfterInit Should the meta class be modifiable after initialization. Default is false. + */ + public ExpandoMetaClass(Class theClass, boolean register, boolean allowChangesAfterInit) { + this(theClass, register, allowChangesAfterInit, null); + } + + public MetaMethod findMixinMethod(String methodName, Class[] arguments) { + for (MixinInMetaClass mixin : mixinClasses) { + final CachedClass mixinClass = mixin.getMixinClass(); + MetaClass metaClass = mixinClass.classInfo.getMetaClassForClass(); + if (metaClass == null) { + metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(mixinClass.getTheClass()); + } + + MetaMethod metaMethod = metaClass.pickMethod(methodName, arguments); + if (metaMethod == null && metaClass instanceof MetaClassImpl) { + MetaClassImpl mc = (MetaClassImpl) metaClass; + for (CachedClass cl = mc.getTheCachedClass().getCachedSuperClass(); cl != null; cl = cl.getCachedSuperClass()) { + metaMethod = mc.getMethodWithoutCaching(cl.getTheClass(), methodName, arguments, false); + if (metaMethod != null) + break; + } + } + if (metaMethod != null) { + MetaMethod method = new MixinInstanceMetaMethod(metaMethod, mixin); + + if (method.getParameterTypes().length == 1 && !method.getParameterTypes()[0].isPrimitive) { + MetaMethod noParam = pickMethod(methodName, EMPTY_CLASS_ARRAY); + // if the current call itself is with empty arg class array, no need to recurse with 'new Class[0]' + if (noParam == null && arguments.length != 0) { + try { + findMixinMethod(methodName, EMPTY_CLASS_ARRAY); + } catch (MethodSelectionException msex) { + /* + * Here we just additionally tried to find another no-arg mixin method of the same name and register that as well, if found. + * Safe to ignore a MethodSelectionException in this additional exercise. (GROOVY-4999) + */ + } + } + } + + registerInstanceMethod(method); + return method; + } + } + return null; + } + + protected void onInvokeMethodFoundInHierarchy(MetaMethod method) { + this.invokeMethodMethod = method; + } + + protected void onSuperMethodFoundInHierarchy(MetaMethod method) { + addSuperMethodIfNotOverridden(method); + } + + protected void onSuperPropertyFoundInHierarchy(MetaBeanProperty property) { + addMetaBeanProperty(property); + } + + protected void onSetPropertyFoundInHierarchy(MetaMethod method) { + this.setPropertyMethod = method; + } + + protected void onGetPropertyFoundInHierarchy(MetaMethod method) { + this.getPropertyMethod = method; + } + + public boolean isModified() { + return this.modified; + } + + public void registerSubclassInstanceMethod(String name, Class klazz, Closure closure) { + final List<MetaMethod> list = ClosureMetaMethod.createMethodList(name, klazz, closure); + for (MetaMethod metaMethod : list) { + registerSubclassInstanceMethod(metaMethod); + } + } + + public void registerSubclassInstanceMethod(MetaMethod metaMethod) { + modified = true; + + final String name = metaMethod.getName(); + Object methodOrList = expandoSubclassMethods.get(name); + if (methodOrList == null) { + expandoSubclassMethods.put(name, metaMethod); + } else { + if (methodOrList instanceof MetaMethod) { + FastArray arr = new FastArray(2); + arr.add(methodOrList); + arr.add(metaMethod); + expandoSubclassMethods.put(name, arr); + } else { + ((FastArray) methodOrList).add(metaMethod); + } + } + } + + public void addMixinClass(MixinInMetaClass mixin) { + mixinClasses.add(mixin); + } + + public Object castToMixedType(Object obj, Class type) { + for (MixinInMetaClass mixin : mixinClasses) { + if (type.isAssignableFrom(mixin.getMixinClass().getTheClass())) + return mixin.getMixinInstance(obj); + } + return null; + } + + /** + * For simulating closures in Java + */ + private interface Callable { + void call(); + } + + /** + * Call to enable global use of ExpandoMetaClass within the registry. + * This has the advantage that inheritance will function correctly and + * metaclass modifications will also apply to existing objects, + * but has a higher memory usage on the JVM than normal Groovy + */ + public static void enableGlobally() { + DefaultMetaClassInfo.setWithoutCustomMetaclassCreationHandle(false); + ExpandoMetaClassCreationHandle.enable(); + } + + /** + * Call to disable the global use of ExpandoMetaClass + */ + public static void disableGlobally() { + DefaultMetaClassInfo.setWithoutCustomMetaclassCreationHandle(true); + ExpandoMetaClassCreationHandle.disable(); + } + + /* (non-Javadoc) + * @see groovy.lang.MetaClassImpl#initialize() + */ + + public void initialize() { + try { + writeLock.lock(); + if (!isInitialized()) { + super.initialize(); + setInitialized(true); + this.initCalled = true; + } + } finally { + // downgrade to readlock before releasing just in case + readLock.lock(); + writeLock.unlock(); + readLock.unlock(); + } + } + + /** + * Checks if the meta class is initialized. + * @see groovy.lang.MetaClassImpl#isInitialized() + */ + protected boolean isInitialized() { + try { + readLock.lock(); + return this.initialized; + } finally { + readLock.unlock(); + } + } + + protected void setInitialized(boolean b) { + this.initialized = b; + } + + private void addSuperMethodIfNotOverridden(final MetaMethod metaMethodFromSuper) { + performOperationOnMetaClass(new Callable() { + public void call() { + + MetaMethod existing = null; + try { + existing = pickMethod(metaMethodFromSuper.getName(), metaMethodFromSuper.getNativeParameterTypes()); + } catch ( GroovyRuntimeException e) { + // ignore, this happens with overlapping method definitions + } + + if (existing == null) { + addMethodWithKey(metaMethodFromSuper); + } else { + boolean isGroovyMethod = getMetaMethods().contains(existing); + + if (isGroovyMethod) { + addMethodWithKey(metaMethodFromSuper); + } else if (inheritedMetaMethods.contains(existing)) { + inheritedMetaMethods.remove(existing); + addMethodWithKey(metaMethodFromSuper); + } + } + } + + private void addMethodWithKey(final MetaMethod metaMethodFromSuper) { + inheritedMetaMethods.add(metaMethodFromSuper); + if (metaMethodFromSuper instanceof ClosureMetaMethod) { + ClosureMetaMethod closureMethod = (ClosureMetaMethod)metaMethodFromSuper; + String name = metaMethodFromSuper.getName(); + final Class declaringClass = metaMethodFromSuper.getDeclaringClass().getTheClass(); + ClosureMetaMethod localMethod = ClosureMetaMethod.copy(closureMethod); + addMetaMethod(localMethod); + + MethodKey key = new DefaultCachedMethodKey(declaringClass, name, localMethod.getParameterTypes(), false); + + checkIfGroovyObjectMethod(localMethod); + expandoMethods.put(key, localMethod); + + } + } + }); + } + + /** + * Instances of this class are returned when using the << left shift operator. + * <p> + * Example: + * <p> + * metaClass.myMethod << { String args -> } + * <p> + * This allows callbacks to the ExpandoMetaClass for registering appending methods + * + * @author Graeme Rocher + */ + protected class ExpandoMetaProperty extends GroovyObjectSupport { + + protected String propertyName; + protected boolean isStatic; + + protected ExpandoMetaProperty(String name) { + this(name, false); + } + + protected ExpandoMetaProperty(String name, boolean isStatic) { + this.propertyName = name; + this.isStatic = isStatic; + } + + public String getPropertyName() { + return this.propertyName; + } + + public boolean isStatic() { + return this.isStatic; + } + + public Object leftShift(Object arg) { + registerIfClosure(arg, false); + return this; + } + + private void registerIfClosure(Object arg, boolean replace) { + if (arg instanceof Closure) { + Closure callable = (Closure) arg; + final List<MetaMethod> list = ClosureMetaMethod.createMethodList(propertyName, theClass, callable); + if (list.isEmpty() && this.isStatic) { + Class[] paramTypes = callable.getParameterTypes(); + registerStatic(callable, replace, paramTypes); + return; + } + for (MetaMethod method : list) { + Class[] paramTypes = method.getNativeParameterTypes(); + if (this.isStatic) { + registerStatic(callable, replace, paramTypes); + } else { + registerInstance(method, replace, paramTypes); + } + } + } + } + + private void registerStatic(Closure callable, boolean replace, Class[] paramTypes) { + Method foundMethod = checkIfMethodExists(theClass, propertyName, paramTypes, true); + if (foundMethod != null && !replace) + throw new GroovyRuntimeException("Cannot add new static method [" + propertyName + "] for arguments [" + DefaultGroovyMethods.inspect(paramTypes) + "]. It already exists!"); + registerStaticMethod(propertyName, callable, paramTypes); + } + + private void registerInstance(MetaMethod method, boolean replace, Class[] paramTypes) { + Method foundMethod = checkIfMethodExists(theClass, propertyName, paramTypes, false); + if (foundMethod != null && !replace) + throw new GroovyRuntimeException("Cannot add new method [" + propertyName + "] for arguments [" + DefaultGroovyMethods.inspect(paramTypes) + "]. It already exists!"); + registerInstanceMethod(method); + } + + private Method checkIfMethodExists(Class methodClass, String methodName, Class[] paramTypes, boolean staticMethod) { + Method foundMethod = null; + Method[] methods = methodClass.getMethods(); + for (Method method : methods) { + if (method.getName().equals(methodName) && Modifier.isStatic(method.getModifiers()) == staticMethod) { + if (MetaClassHelper.parametersAreCompatible(paramTypes, method.getParameterTypes())) { + foundMethod = method; + break; + } + } + } + return foundMethod; + } + + /* (non-Javadoc) + * @see groovy.lang.GroovyObjectSupport#getProperty(java.lang.String) + */ + + public Object getProperty(String property) { + this.propertyName = property; + return this; + } + /* (non-Javadoc) + * @see groovy.lang.GroovyObjectSupport#setProperty(java.lang.String, java.lang.Object) + */ + + public void setProperty(String property, Object newValue) { + this.propertyName = property; + registerIfClosure(newValue, true); + } + } + + /* (non-Javadoc) + * @see groovy.lang.MetaClassImpl#invokeConstructor(java.lang.Object[]) + */ + + public Object invokeConstructor(Object[] arguments) { + + // TODO This is the only area where this MetaClass needs to do some interception because Groovy's current + // MetaClass uses hard coded references to the java.lang.reflect.Constructor class so you can't simply + // inject Constructor like you can do properties, methods and fields. When Groovy's MetaClassImpl is + // refactored we can fix this + Class[] argClasses = MetaClassHelper.convertToTypeArray(arguments); + MetaMethod method = pickMethod(GROOVY_CONSTRUCTOR, argClasses); + if (method != null && method.getParameterTypes().length == arguments.length) { + return method.invoke(theClass, arguments); + } + return super.invokeConstructor(arguments); + } + + /** + * Handles the ability to use the left shift operator to append new constructors + * + * @author Graeme Rocher + */ + protected class ExpandoMetaConstructor extends GroovyObjectSupport { + public Object leftShift(Closure c) { + if (c != null) { + final List<MetaMethod> list = ClosureMetaMethod.createMethodList(GROOVY_CONSTRUCTOR, theClass, c); + for (MetaMethod method : list) { + Class[] paramTypes = method.getNativeParameterTypes(); + Constructor ctor = retrieveConstructor(paramTypes); + if (ctor != null) + throw new GroovyRuntimeException("Cannot add new constructor for arguments [" + DefaultGroovyMethods.inspect(paramTypes) + "]. It already exists!"); + + registerInstanceMethod(method); + } + } + + return this; + } + } + + /* (non-Javadoc) + * @see groovy.lang.GroovyObject#getMetaClass() + */ + + public MetaClass getMetaClass() { + return myMetaClass; + } + + /* (non-Javadoc) + * @see groovy.lang.GroovyObject#getProperty(java.lang.String) + */ + + public Object getProperty(String property) { + if (isValidExpandoProperty(property)) { + if (property.equals(STATIC_QUALIFIER)) { + return new ExpandoMetaProperty(property, true); + } else if (property.equals(CONSTRUCTOR)) { + return new ExpandoMetaConstructor(); + } else { + if (myMetaClass.hasProperty(this, property) == null) + return new ExpandoMetaProperty(property); + else + return myMetaClass.getProperty(this, property); + } + } else { + return myMetaClass.getProperty(this, property); + } + } + + public static boolean isValidExpandoProperty(String property) { + return !(property.equals(META_CLASS) || property.equals(CLASS) || property.equals(META_METHODS) || property.equals(METHODS) || property.equals(PROPERTIES)); + } + + /* (non-Javadoc) + * @see groovy.lang.GroovyObject#invokeMethod(java.lang.String, java.lang.Object) + */ + + public Object invokeMethod(String name, Object args) { + final Object[] argsArr = args instanceof Object[] ? (Object[]) args : new Object[]{args}; + MetaMethod metaMethod = myMetaClass.getMetaMethod(name, argsArr); + if (metaMethod != null) { + // we have to use doMethodInvoke here instead of simply invoke, + // because getMetaMethod may provide a method that can not be called + // without further argument transformation, which is done only in + // doMethodInvoke + return metaMethod.doMethodInvoke(this, argsArr); + } + + if (argsArr.length == 2 && argsArr[0] instanceof Class && argsArr[1] instanceof Closure) { + if (argsArr[0] == theClass) + registerInstanceMethod(name, (Closure) argsArr[1]); + else { + registerSubclassInstanceMethod(name, (Class) argsArr[0], (Closure) argsArr[1]); + } + return null; + } + + if (argsArr.length == 1 && argsArr[0] instanceof Closure) { + registerInstanceMethod(name, (Closure) argsArr[0]); + return null; + } + + throw new MissingMethodException(name, getClass(), argsArr); + } + + /* (non-Javadoc) + * @see groovy.lang.GroovyObject#setMetaClass(groovy.lang.MetaClass) + */ + + public void setMetaClass(MetaClass metaClass) { + this.myMetaClass = metaClass; + } + + /* (non-Javadoc) + * @see groovy.lang.GroovyObject#setProperty(java.lang.String, java.lang.Object) + */ + + public void setProperty(String property, Object newValue) { + if (newValue instanceof Closure) { + if (property.equals(CONSTRUCTOR)) { + property = GROOVY_CONSTRUCTOR; + } + Closure callable = (Closure) newValue; + final List<MetaMethod> list = ClosureMetaMethod.createMethodList(property, theClass, callable); + for (MetaMethod method : list) { + // here we don't care if the method exists or not we assume the + // developer is responsible and wants to override methods where necessary + registerInstanceMethod(method); + } + } else { + registerBeanProperty(property, newValue); + } + } + + public ExpandoMetaClass define(Closure closure) { + final DefiningClosure definer = new DefiningClosure(); + Object delegate = closure.getDelegate(); + closure.setDelegate(definer); + closure.setResolveStrategy(Closure.DELEGATE_ONLY); + closure.call((Object)null); + closure.setDelegate(delegate); + closure.setResolveStrategy(Closure.DELEGATE_FIRST); + definer.definition = false; + return this; + } + + protected synchronized void performOperationOnMetaClass(Callable c) { + try { + writeLock.lock(); + if (allowChangesAfterInit) { + setInitialized(false); + } + c.call(); + } + finally { + if (initCalled) { + setInitialized(true); + } + // downgrade to readlock before releasing just in case + readLock.lock(); + writeLock.unlock(); + readLock.unlock(); + } + } + + protected void checkInitalised() { + try { + readLock.lock(); + super.checkInitalised(); + } finally { + readLock.unlock(); + } + } + + /** + * Registers a new bean property + * + * @param property The property name + * @param newValue The properties initial value + */ + public void registerBeanProperty(final String property, final Object newValue) { + performOperationOnMetaClass(new Callable() { + public void call() { + Class type = newValue == null ? Object.class : newValue.getClass(); + + MetaBeanProperty mbp = newValue instanceof MetaBeanProperty ? (MetaBeanProperty) newValue : new ThreadManagedMetaBeanProperty(theClass, property, type, newValue); + + final MetaMethod getter = mbp.getGetter(); + final MethodKey getterKey = new DefaultCachedMethodKey(theClass, getter.getName(), CachedClass.EMPTY_ARRAY, false); + final MetaMethod setter = mbp.getSetter(); + final MethodKey setterKey = new DefaultCachedMethodKey(theClass, setter.getName(), setter.getParameterTypes(), false); + addMetaMethod(getter); + addMetaMethod(setter); + + expandoMethods.put(setterKey, setter); + expandoMethods.put(getterKey, getter); + expandoProperties.put(mbp.getName(), mbp); + + addMetaBeanProperty(mbp); + performRegistryCallbacks(); + } + + }); + } + + /** + * Registers a new instance method for the given method name and closure on this MetaClass + * + * @param metaMethod + */ + public void registerInstanceMethod(final MetaMethod metaMethod) { + final boolean inited = this.initCalled; + performOperationOnMetaClass(new Callable() { + public void call() { + String methodName = metaMethod.getName(); + checkIfGroovyObjectMethod(metaMethod); + MethodKey key = new DefaultCachedMethodKey(theClass, methodName, metaMethod.getParameterTypes(), false); + + if (isInitialized()) { + throw new RuntimeException("Already initialized, cannot add new method: " + metaMethod); + } + // we always adds meta methods to class itself + addMetaMethodToIndex(metaMethod, metaMethodIndex.getHeader(theClass)); + + dropMethodCache(methodName); + expandoMethods.put(key, metaMethod); + + if (inited && isGetter(methodName, metaMethod.getParameterTypes())) { + String propertyName = getPropertyForGetter(methodName); + registerBeanPropertyForMethod(metaMethod, propertyName, true, false); + + } else if (inited && isSetter(methodName, metaMethod.getParameterTypes())) { + String propertyName = getPropertyForSetter(methodName); + registerBeanPropertyForMethod(metaMethod, propertyName, false, false); + } + performRegistryCallbacks(); + } + + }); + } + + public void registerInstanceMethod(String name, Closure closure) { + final List<MetaMethod> list = ClosureMetaMethod.createMethodList(name, theClass, closure); + for (MetaMethod method : list) { + registerInstanceMethod(method); + } + } + + /** + * Overrides the behavior of parent getMethods() method to make MetaClass aware of added Expando methods + * + * @return A list of MetaMethods + * @see MetaObjectProtocol#getMethods() + */ + public List<MetaMethod> getMethods() { + List<MetaMethod> methodList = new ArrayList<MetaMethod>(); + methodList.addAll(this.expandoMethods.values()); + methodList.addAll(super.getMethods()); + return methodList; + } + + public List<MetaProperty> getProperties() { + List<MetaProperty> propertyList = new ArrayList<MetaProperty>(); + propertyList.addAll(super.getProperties()); + return propertyList; + } + + + private void performRegistryCallbacks() { + MetaClassRegistry registry = GroovySystem.getMetaClassRegistry(); + incVersion(); + if (!modified) { + modified = true; + // Implementation note: By default Groovy uses soft references to store MetaClass + // this insures the registry doesn't grow and get out of hand. By doing this we're + // saying this this EMC will be a hard reference in the registry. As we're only + // going have a small number of classes that have modified EMC this is ok + if (inRegistry) { + MetaClass currMetaClass = registry.getMetaClass(theClass); + if (!(currMetaClass instanceof ExpandoMetaClass) && currMetaClass instanceof AdaptingMetaClass) { + ((AdaptingMetaClass) currMetaClass).setAdaptee(this); + } else { + registry.setMetaClass(theClass, this); + } + } + + } + } + + private void registerBeanPropertyForMethod(MetaMethod metaMethod, String propertyName, boolean getter, boolean isStatic) { + Map<String, MetaProperty> propertyCache = isStatic ? staticBeanPropertyCache : beanPropertyCache; + MetaBeanProperty beanProperty = (MetaBeanProperty) propertyCache.get(propertyName); + if (beanProperty==null) { + MetaProperty metaProperty = super.getMetaProperty(propertyName); + if (metaProperty instanceof MetaBeanProperty) { + boolean staticProp = Modifier.isStatic(metaProperty.getModifiers()); + if (isStatic==staticProp) { + beanProperty = (MetaBeanProperty) metaProperty; + } + } + } + if (beanProperty == null) { + if (getter) + beanProperty = new MetaBeanProperty(propertyName, Object.class, metaMethod, null); + else + beanProperty = new MetaBeanProperty(propertyName, Object.class, null, metaMethod); + + propertyCache.put(propertyName, beanProperty); + } else { + if (getter) { + MetaMethod setterMethod = beanProperty.getSetter(); + Class type = setterMethod != null ? setterMethod.getParameterTypes()[0].getTheClass() : Object.class; + beanProperty = new MetaBeanProperty(propertyName, type, metaMethod, setterMethod); + propertyCache.put(propertyName, beanProperty); + } else { + MetaMethod getterMethod = beanProperty.getGetter(); + beanProperty = new MetaBeanProperty(propertyName, metaMethod.getParameterTypes()[0].getTheClass(), getterMethod, metaMethod); + propertyCache.put(propertyName, beanProperty); + } + } + expandoProperties.put(beanProperty.getName(), beanProperty); + addMetaBeanProperty(beanProperty); + } + + protected void registerStaticMethod(final String name, final Closure callable) { + registerStaticMethod(name, callable, null); + } + + /** + * Registers a new static method for the given method name and closure on this MetaClass + * + * @param name The method name + * @param callable The callable Closure + */ + protected void registerStaticMethod(final String name, final Closure callable, final Class[] paramTypes) { + performOperationOnMetaClass(new Callable() { + public void call() { + String methodName; + if (name.equals(METHOD_MISSING)) + methodName = STATIC_METHOD_MISSING; + else if (name.equals(PROPERTY_MISSING)) + methodName = STATIC_PROPERTY_MISSING; + else + methodName = name; + + ClosureStaticMetaMethod metaMethod = null; + + if (paramTypes != null) { + metaMethod = new ClosureStaticMetaMethod(methodName, theClass, callable, paramTypes); + } else { + metaMethod = new ClosureStaticMetaMethod(methodName, theClass, callable); + } + + if (methodName.equals(INVOKE_METHOD_METHOD) && callable.getParameterTypes().length == 2) { + invokeStaticMethodMethod = metaMethod; + } else { + if (methodName.equals(METHOD_MISSING)) { + methodName = STATIC_METHOD_MISSING; + } + MethodKey key = new DefaultCachedMethodKey(theClass, methodName, metaMethod.getParameterTypes(), false); + + addMetaMethod(metaMethod); + dropStaticMethodCache(methodName); +// cacheStaticMethod(key,metaMethod); + + if (isGetter(methodName, metaMethod.getParameterTypes())) { + String propertyName = getPropertyForGetter(methodName); + registerBeanPropertyForMethod(metaMethod, propertyName, true, true); + + } else if (isSetter(methodName, metaMethod.getParameterTypes())) { + String propertyName = getPropertyForSetter(methodName); + registerBeanPropertyForMethod(metaMethod, propertyName, false, true); + } + performRegistryCallbacks(); + expandoMethods.put(key, metaMethod); + } + } + + }); + } + + protected Object getSubclassMetaMethods(String methodName) { + if (!isModified()) + return null; + + return expandoSubclassMethods.get(methodName); + } + + /** + * @return The Java class enhanced by this MetaClass + */ + public Class getJavaClass() { + return theClass; + } + + /** + * Called from ExpandoMetaClassCreationHandle in the registry if it exists to + * set up inheritance handling + * + * @param modifiedSuperExpandos A list of modified super ExpandoMetaClass + */ + public void refreshInheritedMethods(Set modifiedSuperExpandos) { + for (Iterator i = modifiedSuperExpandos.iterator(); i.hasNext();) { + ExpandoMetaClass superExpando = (ExpandoMetaClass) i.next(); + if (superExpando != this) { + refreshInheritedMethods(superExpando); + } + } + } + + private void refreshInheritedMethods(ExpandoMetaClass superExpando) { + List<MetaMethod> metaMethods = superExpando.getExpandoMethods(); + for (MetaMethod metaMethod : metaMethods) { + if (metaMethod.isStatic()) { + if (superExpando.getTheClass() != getTheClass()) + continue; // don't inherit static methods except our own + registerStaticMethod(metaMethod.getName(), (Closure) ((ClosureStaticMetaMethod) metaMethod).getClosure().clone()); + } else + addSuperMethodIfNotOverridden(metaMethod); + } + Collection<MetaProperty> metaProperties = superExpando.getExpandoProperties(); + for (Object metaProperty : metaProperties) { + MetaBeanProperty property = (MetaBeanProperty) metaProperty; + expandoProperties.put(property.getName(), property); + addMetaBeanProperty(property); + } + } + + + /** + * Returns a list of expando MetaMethod instances added to this ExpandoMetaClass + * + * @return the expandoMethods + */ + public List<MetaMethod> getExpandoMethods() { + return Collections.unmodifiableList(DefaultGroovyMethods.toList(expandoMethods.values())); + } + + + /** + * Returns a list of MetaBeanProperty instances added to this ExpandoMetaClass + * + * @return the expandoProperties + */ + public Collection<MetaProperty> getExpandoProperties() { + return Collections.unmodifiableCollection(expandoProperties.values()); + } + + /** + * Overrides default implementation just in case invokeMethod has been overridden by ExpandoMetaClass + * + * @see groovy.lang.MetaClassImpl#invokeMethod(Class, Object, String, Object[], boolean, boolean) + */ + public Object invokeMethod(Class sender, Object object, String methodName, Object[] originalArguments, boolean isCallToSuper, boolean fromInsideClass) { + if (invokeMethodMethod != null) { + MetaClassHelper.unwrap(originalArguments); + return invokeMethodMethod.invoke(object, new Object[]{methodName, originalArguments}); + } + return super.invokeMethod(sender, object, methodName, originalArguments, isCallToSuper, fromInsideClass); + } + + /** + * Overrides default implementation just in case a static invoke method has been set on ExpandoMetaClass + * + * @see MetaClassImpl#invokeStaticMethod(Object, String, Object[]) + */ + public Object invokeStaticMethod(Object object, String methodName, Object[] arguments) { + if (invokeStaticMethodMethod != null) { + MetaClassHelper.unwrap(arguments); + return invokeStaticMethodMethod.invoke(object, new Object[]{methodName, arguments}); + } + return super.invokeStaticMethod(object, methodName, arguments); + } + + /** + * Overrides default implementation just in case getProperty method has been overridden by ExpandoMetaClass + * + * @see MetaClassImpl#getProperty(Class, Object, String, boolean, boolean) + */ + public Object getProperty(Class sender, Object object, String name, boolean useSuper, boolean fromInsideClass) { + if (hasOverrideGetProperty(name) && getJavaClass().isInstance(object)) { + return getPropertyMethod.invoke(object, new Object[]{name}); + } + + if ("mixedIn".equals(name)) { + return new MixedInAccessor(object, mixinClasses); + } + + return super.getProperty(sender, object, name, useSuper, fromInsideClass); + } + + /** + * Overrides default implementation just in case getProperty method has been overridden by ExpandoMetaClass + * + * @see MetaClassImpl#getProperty(Object, String) + */ + public Object getProperty(Object object, String name) { + if (hasOverrideGetProperty(name) && getJavaClass().isInstance(object)) { + return getPropertyMethod.invoke(object, new Object[]{name}); + } + return super.getProperty(object, name); + } + + private boolean hasOverrideGetProperty(String name) { + return getPropertyMethod != null && !name.equals(META_CLASS_PROPERTY) && !name.equals(CLASS_PROPERTY); + } + + /** + * Overrides default implementation just in case setProperty method has been overridden by ExpandoMetaClass + * + * @see MetaClassImpl#setProperty(Class, Object, String, Object, boolean, boolean) + */ + + public void setProperty(Class sender, Object object, String name, Object newValue, boolean useSuper, boolean fromInsideClass) { + if (setPropertyMethod != null && !name.equals(META_CLASS_PROPERTY) && getJavaClass().isInstance(object)) { + setPropertyMethod.invoke(object, new Object[]{name, newValue}); + return; + } + super.setProperty(sender, object, name, newValue, useSuper, fromInsideClass); + } + + /** + * Looks up an existing MetaProperty by name + * + * @param name The name of the MetaProperty + * @return The MetaProperty or null if it doesn't exist + */ + public MetaProperty getMetaProperty(String name) { + MetaProperty mp = this.expandoProperties.get(name); + if (mp != null) return mp; + return super.getMetaProperty(name); + } + + /** + * Returns true if the MetaClass has the given property + * + * @param name The name of the MetaProperty + * @return True it exists as a MetaProperty + */ + public boolean hasMetaProperty(String name) { + return getMetaProperty(name) != null; + } + + /** + * Checks whether a MetaMethod for the given name and arguments exists + * + * @param name The name of the MetaMethod + * @param args The arguments to the meta method + * @return True if the method exists otherwise null + */ + public boolean hasMetaMethod(String name, Class[] args) { + return super.pickMethod(name, args) != null; + } + + /** + * Determine if this method name suffix is a legitimate bean property name. + * Either the first or second letter must be upperCase for that to be true. + */ + private static boolean isPropertyName(String name) { + return ((name.length() > 0) && Character.isUpperCase(name.charAt(0))) || ((name.length() > 1) && Character.isUpperCase(name.charAt(1))); + } + + /** + * Returns true if the name of the method specified and the number of arguments make it a javabean property + * + * @param name True if its a Javabean property + * @param args The arguments + * @return True if it is a javabean property method + */ + private boolean isGetter(String name, CachedClass[] args) { + if (name == null || name.length() == 0 || args == null) return false; + if (args.length != 0) return false; + + if (name.startsWith("get")) { + name = name.substring(3); + return isPropertyName(name); + } else if (name.startsWith("is")) { + name = name.substring(2); + return isPropertyName(name); + } + return false; + } + + /** + * Returns a property name equivalent for the given getter name or null if it is not a getter + * + * @param getterName The getter name + * @return The property name equivalent + */ + private String getPropertyForGetter(String getterName) { + if (getterName == null || getterName.length() == 0) return null; + + if (getterName.startsWith("get")) { + String prop = getterName.substring(3); + return MetaClassHelper.convertPropertyName(prop); + } else if (getterName.startsWith("is")) { + String prop = getterName.substring(2); + return MetaClassHelper.convertPropertyName(prop); + } + return null; + } + + /** + * Returns a property name equivalent for the given setter name or null if it is not a getter + * + * @param setterName The setter name + * @return The property name equivalent + */ + public String getPropertyForSetter(String setterName) { + if (setterName == null || setterName.length() == 0) return null; + + if (setterName.startsWith("set")) { + String prop = setterName.substring(3); + return MetaClassHelper.convertPropertyName(prop); + } + return null; + } + + public boolean isSetter(String name, CachedClass[] args) { + if (name == null || name.length() == 0 || args == null) return false; + + if (name.startsWith("set")) { + if (args.length != 1) return false; + name = name.substring(3); + return isPropertyName(name); + } + + return false; + } + + public CallSite createPojoCallSite(CallSite site, Object receiver, Object[] args) { + if (invokeMethodMethod != null) + return new PojoMetaClassSite(site, this); + + return super.createPojoCallSite(site, receiver, args); + } + + public CallSite createStaticSite(CallSite site, Object[] args) { + if (invokeStaticMethodMethod != null) + return new StaticMetaClassSite(site, this); + + return super.createStaticSite(site, args); + } + + public boolean hasCustomStaticInvokeMethod() {return invokeStaticMethodMethod!=null; } + + public CallSite createPogoCallSite(CallSite site, Object[] args) { + if (invokeMethodMethod != null) + return new PogoMetaClassSite(site, this); + return super.createPogoCallSite(site, args); + } + + public CallSite createPogoCallCurrentSite(CallSite site, Class sender, String name, Object[] args) { + if (invokeMethodMethod != null) + return new PogoMetaClassSite(site, this); + return super.createPogoCallCurrentSite(site, sender, args); + } + + @Override + public MetaMethod retrieveConstructor(Object[] args) { + Class[] params = MetaClassHelper.convertToTypeArray(args); + MetaMethod method = pickMethod(GROOVY_CONSTRUCTOR, params); + if (method!=null) return method; + return super.retrieveConstructor(args); + } + + public CallSite createConstructorSite(CallSite site, Object[] args) { + Class[] params = MetaClassHelper.convertToTypeArray(args); + MetaMethod method = pickMethod(GROOVY_CONSTRUCTOR, params); + if (method != null && method.getParameterTypes().length == args.length) { + if (method.getDeclaringClass().getTheClass().equals(getTheClass())) { + return new ConstructorMetaMethodSite(site, this, method, params); + } + } + + return super.createConstructorSite(site, args); + } + + private class SubClassDefiningClosure extends GroovyObjectSupport { + private final Class klazz; + + public SubClassDefiningClosure(Class klazz) { + this.klazz = klazz; + } + + public Object invokeMethod(String name, Object obj) { + if (obj instanceof Object[]) { + Object args[] = (Object[]) obj; + if (args.length == 1 && args[0] instanceof Closure) { + registerSubclassInstanceMethod(name, klazz, (Closure) args[0]); + return null; + } + } + + throw new MissingMethodException(name, getClass(), new Object[]{obj}); + } + } + + private class DefiningClosure extends GroovyObjectSupport { + boolean definition = true; + + public void mixin(Class category) { + mixin(Collections.singletonList(category)); + } + + public void mixin(List categories) { + DefaultGroovyMethods.mixin(ExpandoMetaClass.this, categories); + } + + public void mixin(Class[] categories) { + DefaultGroovyMethods.mixin(ExpandoMetaClass.this, categories); + } + + public void define(Class subClass, Closure closure) { + final SubClassDefiningClosure definer = new SubClassDefiningClosure(subClass); + closure.setDelegate(definer); + closure.setResolveStrategy(Closure.DELEGATE_FIRST); + closure.call((Object)null); + } + + public Object invokeMethod(String name, Object obj) { + try { + return getMetaClass().invokeMethod(this, name, obj); + } + catch (MissingMethodException mme) { + if (obj instanceof Object[]) { + if (STATIC_QUALIFIER.equals(name)) { + final StaticDefiningClosure staticDef = new StaticDefiningClosure(); + Closure c = (Closure) ((Object[]) obj)[0]; + c.setDelegate(staticDef); + c.setResolveStrategy(Closure.DELEGATE_ONLY); + c.call((Object)null); + return null; + } + Object args[] = (Object[]) obj; + if (args.length == 1 && args[0] instanceof Closure) { + registerInstanceMethod(name, (Closure) args[0]); + } else if (args.length == 2 && args[0] instanceof Class && args[1] instanceof Closure) + registerSubclassInstanceMethod(name, (Class) args[0], (Closure) args[1]); + else + ExpandoMetaClass.this.setProperty(name, ((Object[]) obj)[0]); + + return null; + } + + throw mme; + } + } + + public void setProperty(String property, Object newValue) { + ExpandoMetaClass.this.setProperty(property, newValue); + } + + public Object getProperty(String property) { + if (STATIC_QUALIFIER.equals(property)) + return new StaticDefiningClosure(); + + if (definition) + return new ExpandoMetaProperty(property); + else + throw new MissingPropertyException(property, getClass()); + } + } + + private class StaticDefiningClosure extends ExpandoMetaProperty { + protected StaticDefiningClosure() { + super(STATIC_QUALIFIER, true); + } + + public Object invokeMethod(String name, Object obj) { + if (obj instanceof Object[]) { + final Object[] args = (Object[]) obj; + if (args.length == 1 && args[0] instanceof Closure) { + registerStaticMethod(name, (Closure) args[0]); + return null; + } + } + + throw new MissingMethodException(name, getClass(), obj instanceof Object[] ? (Object[]) obj : new Object[]{obj}); + } + } + + private static class MixedInAccessor { + private final Object object; + private final Set<MixinInMetaClass> mixinClasses; + + public MixedInAccessor(Object object, Set<MixinInMetaClass> mixinClasses) { + this.object = object; + this.mixinClasses = mixinClasses; + } + + public Object getAt(Class key) { + if (key.isAssignableFrom(object.getClass())) { + return new GroovyObjectSupport() { + { + final MetaClass ownMetaClass = InvokerHelper.getMetaClass(object.getClass()); + setMetaClass(new OwnedMetaClass(ownMetaClass) { + protected Object getOwner() { + return object; + } + + protected MetaClass getOwnerMetaClass(Object owner) { + return getAdaptee(); + } + }); + } + }; + } + + for (final MixinInMetaClass mixin : mixinClasses) { + if (key.isAssignableFrom(mixin.getMixinClass().getTheClass())) { + return new GroovyObjectSupport() { + { + final Object mixedInInstance = mixin.getMixinInstance(object); + setMetaClass(new OwnedMetaClass(InvokerHelper.getMetaClass(mixedInInstance)) { + @Override + protected Object getOwner() { + return mixedInInstance; + } + + @Override + protected MetaClass getOwnerMetaClass(Object owner) { + return ((MixedInMetaClass) getAdaptee()).getAdaptee(); + } + }); + } + }; + } + } + + throw new RuntimeException("Class " + key + " isn't mixed in " + object.getClass()); + } + + public void putAt(Class key, Object value) { + for (MixinInMetaClass mixin : mixinClasses) + if (mixin.getMixinClass().getTheClass() == key) { + mixin.setMixinInstance(object, value); + return; + } + + throw new RuntimeException("Class " + key + " isn't mixed in " + object.getClass()); + } + } +}
http://git-wip-us.apache.org/repos/asf/groovy/blob/10110145/src/main/groovy/groovy/lang/ExpandoMetaClassCreationHandle.java ---------------------------------------------------------------------- diff --git a/src/main/groovy/groovy/lang/ExpandoMetaClassCreationHandle.java b/src/main/groovy/groovy/lang/ExpandoMetaClassCreationHandle.java new file mode 100644 index 0000000..6e411a5 --- /dev/null +++ b/src/main/groovy/groovy/lang/ExpandoMetaClassCreationHandle.java @@ -0,0 +1,95 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 groovy.lang; + +import groovy.lang.MetaClassRegistry.MetaClassCreationHandle; +import org.codehaus.groovy.reflection.ClassInfo; + +/** + * <p>A handle for the MetaClassRegistry that changes all classes loaded into the Grails VM + * to use ExpandoMetaClass instances + * + * <p>The handle should be registered with the Groovy runtime <strong>before</strong> Groovy loads, for example + * in your main method. + * + * <code>GroovySystem.metaClassRegistry.metaClassCreationHandle = new ExpandoMetaClassCreationHandle()</code> + * + * @see groovy.lang.MetaClassRegistry + * @see groovy.lang.MetaClassRegistry.MetaClassCreationHandle + * @see org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl#setMetaClassCreationHandle(groovy.lang.MetaClassRegistry.MetaClassCreationHandle) + * + * @author Graeme Rocher + * @since 1.5 + */ +public class ExpandoMetaClassCreationHandle extends MetaClassCreationHandle { + + public static final ExpandoMetaClassCreationHandle instance = new ExpandoMetaClassCreationHandle(); + + /* (non-Javadoc) + * @see groovy.lang.MetaClassRegistry.MetaClassCreationHandle#create(java.lang.Class, groovy.lang.MetaClassRegistry) + */ + protected MetaClass createNormalMetaClass(Class theClass, MetaClassRegistry registry) { + if(theClass != ExpandoMetaClass.class) { + return new ExpandoMetaClass(theClass, true, true); + } + else { + return super.createNormalMetaClass(theClass, registry); + } + } + + /** + * Registers a modified ExpandoMetaClass with the creation handle + * + * @param emc The EMC + */ + public void registerModifiedMetaClass(ExpandoMetaClass emc) { + final Class klazz = emc.getJavaClass(); + GroovySystem.getMetaClassRegistry().setMetaClass(klazz,emc); + } + + public boolean hasModifiedMetaClass(ExpandoMetaClass emc) { + return emc.getClassInfo().getModifiedExpando() != null; + } + + /** + * <p>Enables the ExpandoMetaClassCreationHandle with the registry + * + * <code>ExpandoMetaClassCreationHandle.enable();</code> + * + */ + public static void enable() { + final MetaClassRegistry metaClassRegistry = GroovySystem.getMetaClassRegistry(); + synchronized (metaClassRegistry) { + if (metaClassRegistry.getMetaClassCreationHandler() != instance) { + ClassInfo.clearModifiedExpandos(); + metaClassRegistry.setMetaClassCreationHandle(instance); + } + } + } + + public static void disable() { + final MetaClassRegistry metaClassRegistry = GroovySystem.getMetaClassRegistry(); + synchronized (metaClassRegistry) { + if (metaClassRegistry.getMetaClassCreationHandler() == instance) { + ClassInfo.clearModifiedExpandos(); + metaClassRegistry.setMetaClassCreationHandle(new MetaClassCreationHandle()); + } + } + } +} http://git-wip-us.apache.org/repos/asf/groovy/blob/10110145/src/main/groovy/groovy/lang/GString.java ---------------------------------------------------------------------- diff --git a/src/main/groovy/groovy/lang/GString.java b/src/main/groovy/groovy/lang/GString.java new file mode 100644 index 0000000..8323bf2 --- /dev/null +++ b/src/main/groovy/groovy/lang/GString.java @@ -0,0 +1,245 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 groovy.lang; + +import org.codehaus.groovy.runtime.GStringImpl; +import org.codehaus.groovy.runtime.InvokerHelper; +import org.codehaus.groovy.runtime.StringGroovyMethods; + +import java.io.IOException; +import java.io.Serializable; +import java.io.StringWriter; +import java.io.UnsupportedEncodingException; +import java.io.Writer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.regex.Pattern; + +/** + * Represents a String which contains embedded values such as "hello there + * ${user} how are you?" which can be evaluated lazily. Advanced users can + * iterate over the text and values to perform special processing, such as for + * performing SQL operations, the values can be substituted for ? and the + * actual value objects can be bound to a JDBC statement. The lovely name of + * this class was suggested by Jules Gosnell and was such a good idea, I + * couldn't resist :) + * + * @author <a href="mailto:[email protected]";>James Strachan</a> + */ +public abstract class GString extends GroovyObjectSupport implements Comparable, CharSequence, Writable, Buildable, Serializable { + + static final long serialVersionUID = -2638020355892246323L; + + /** + * A GString containing a single empty String and no values. + */ + public static final GString EMPTY = new GString(new Object[0]) { + @Override + public String[] getStrings() { + return new String[]{""}; + } + }; + public static final String[] EMPTY_STRING_ARRAY = new String[0]; + public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0]; + + private final Object[] values; + + public GString(Object values) { + this.values = (Object[]) values; + } + + public GString(Object[] values) { + this.values = values; + } + + // will be static in an instance + + public abstract String[] getStrings(); + + /** + * Overloaded to implement duck typing for Strings + * so that any method that can't be evaluated on this + * object will be forwarded to the toString() object instead. + */ + @Override + public Object invokeMethod(String name, Object args) { + try { + return super.invokeMethod(name, args); + } + catch (MissingMethodException e) { + // lets try invoke the method on the real String + return InvokerHelper.invokeMethod(toString(), name, args); + } + } + + public Object[] getValues() { + return values; + } + + public GString plus(GString that) { + List<String> stringList = new ArrayList<String>(Arrays.asList(getStrings())); + List<Object> valueList = new ArrayList<Object>(Arrays.asList(getValues())); + + List<String> thatStrings = Arrays.asList(that.getStrings()); + + int stringListSize = stringList.size(); + if (stringListSize > valueList.size()) { + thatStrings = new ArrayList<String>(thatStrings); + // merge onto end of previous GString to avoid an empty bridging value + int lastIndexOfStringList = stringListSize - 1; + String s = stringList.get(lastIndexOfStringList); + s += thatStrings.remove(0); + stringList.set(lastIndexOfStringList, s); + } + + stringList.addAll(thatStrings); + valueList.addAll(Arrays.asList(that.getValues())); + + final String[] newStrings = stringList.toArray(EMPTY_STRING_ARRAY); + final Object[] newValues = valueList.toArray(); + + return new GStringImpl(newValues, newStrings); + } + + public GString plus(String that) { + return plus(new GStringImpl(EMPTY_OBJECT_ARRAY, new String[] { that })); + } + + public int getValueCount() { + return values.length; + } + + public Object getValue(int idx) { + return values[idx]; + } + + @Override + public String toString() { + StringWriter buffer = new StringWriter(); + try { + writeTo(buffer); + } + catch (IOException e) { + throw new StringWriterIOException(e); + } + return buffer.toString(); + } + + @Override + public Writer writeTo(Writer out) throws IOException { + String[] s = getStrings(); + int numberOfValues = values.length; + for (int i = 0, size = s.length; i < size; i++) { + out.write(s[i]); + if (i < numberOfValues) { + final Object value = values[i]; + + if (value instanceof Closure) { + final Closure c = (Closure) value; + + if (c.getMaximumNumberOfParameters() == 0) { + InvokerHelper.write(out, c.call()); + } else if (c.getMaximumNumberOfParameters() == 1) { + c.call(out); + } else { + throw new GroovyRuntimeException("Trying to evaluate a GString containing a Closure taking " + + c.getMaximumNumberOfParameters() + " parameters"); + } + } else { + InvokerHelper.write(out, value); + } + } + } + return out; + } + + /* (non-Javadoc) + * @see groovy.lang.Buildable#build(groovy.lang.GroovyObject) + */ + + @Override + public void build(final GroovyObject builder) { + final String[] s = getStrings(); + final int numberOfValues = values.length; + + for (int i = 0, size = s.length; i < size; i++) { + builder.getProperty("mkp"); + builder.invokeMethod("yield", new Object[]{s[i]}); + if (i < numberOfValues) { + builder.getProperty("mkp"); + builder.invokeMethod("yield", new Object[]{values[i]}); + } + } + } + + @Override + public int hashCode() { + return 37 + toString().hashCode(); + } + + @Override + public boolean equals(Object that) { + if (that instanceof GString) { + return equals((GString) that); + } + return false; + } + + public boolean equals(GString that) { + return toString().equals(that.toString()); + } + + @Override + public int compareTo(Object that) { + return toString().compareTo(that.toString()); + } + + @Override + public char charAt(int index) { + return toString().charAt(index); + } + + @Override + public int length() { + return toString().length(); + } + + @Override + public CharSequence subSequence(int start, int end) { + return toString().subSequence(start, end); + } + + /** + * Turns a String into a regular expression pattern + * + * @return the regular expression pattern + */ + public Pattern negate() { + return StringGroovyMethods.bitwiseNegate(toString()); + } + + public byte[] getBytes() { + return toString().getBytes(); + } + + public byte[] getBytes(String charset) throws UnsupportedEncodingException { + return toString().getBytes(charset); + } +} http://git-wip-us.apache.org/repos/asf/groovy/blob/10110145/src/main/groovy/groovy/lang/GeneratedGroovyProxy.java ---------------------------------------------------------------------- diff --git a/src/main/groovy/groovy/lang/GeneratedGroovyProxy.java b/src/main/groovy/groovy/lang/GeneratedGroovyProxy.java new file mode 100644 index 0000000..55b25b5 --- /dev/null +++ b/src/main/groovy/groovy/lang/GeneratedGroovyProxy.java @@ -0,0 +1,34 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 groovy.lang; + +/** + * An interface implemented by some Groovy proxies which gives access to the proxied object. In particular, dynamically + * generated proxies that implement traits will implement this interface in order to give access to the proxied + * instance. + * + * @author Cedric Champeau + * @since 2.3.0 + */ +public interface GeneratedGroovyProxy { + /** + * @return the proxy target. + */ + Object getProxyTarget(); +} http://git-wip-us.apache.org/repos/asf/groovy/blob/10110145/src/main/groovy/groovy/lang/Grab.java ---------------------------------------------------------------------- diff --git a/src/main/groovy/groovy/lang/Grab.java b/src/main/groovy/groovy/lang/Grab.java new file mode 100644 index 0000000..89be8b3 --- /dev/null +++ b/src/main/groovy/groovy/lang/Grab.java @@ -0,0 +1,143 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 groovy.lang; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Used to grab the referenced artifact and its dependencies and make it available on the Classpath. + * <p> + * Some examples: + * <pre> + * {@code @Grab}(group='commons-lang', module='commons-lang', version='2.4') + * import org.apache.commons.lang.WordUtils + * println "Hello ${WordUtils.capitalize('world')}" + * </pre> + * Or using the compact Gradle-inspired syntax: + * <pre> + * {@code @Grab}('commons-lang:commons-lang:2.4') + * import org.apache.commons.lang.WordUtils + * println "Hello ${WordUtils.capitalize('world')}" + * </pre> + * or the same thing again using the Ivy-inspired syntax variant: + * <pre> + * {@code @Grab}('commons-lang#commons-lang;2.4') + * import org.apache.commons.lang.WordUtils + * println "Hello ${WordUtils.capitalize('world')}" + * </pre> + * Further information such as where artifacts are downloaded to, how to add additional resolvers, + * how to customise artifact resolution etc., can be found on the Grape documentation page: + * <a href="http://groovy-lang.org/grape.html";>http://groovy-lang.org/grape.html</a>. + */ +@Retention(RetentionPolicy.SOURCE) +@Target({ + ElementType.CONSTRUCTOR, + ElementType.FIELD, + ElementType.LOCAL_VARIABLE, + ElementType.METHOD, + ElementType.PARAMETER, + ElementType.TYPE}) +public @interface Grab { + /** + * The organisation or group, e.g.: "org.apache.ant". A non-empty value is required unless value() is used. + */ + String group() default ""; + + /** + * The module or artifact, e.g.: "ant-junit". A non-empty value is required unless value() is used. + */ + String module() default ""; + + /** + * The revision or version, e.g.: "1.7.1". A non-empty value is required unless value() is used. + */ + String version() default ""; + + /** + * The classifier if in use, e.g.: "jdk14" + */ + String classifier() default ""; + + /** + * Defaults to {@code true} but set to {@code false} if you don't want transitive dependencies also to be downloaded. + * You may then need additional {@code @Grab} statements for any required dependencies. + */ + boolean transitive() default true; + + /** + * Defaults to {@code false} but set to {@code true} to indicate to the underlying Ivy conflict manager that this + * dependency should be forced to the given revision. Otherwise, depending on the conflict manager in play, a later + * compatible version might be used instead. + */ + boolean force() default false; + + /** + * Defaults to {@code false} but set to {@code true} if the dependency artifacts may change without a corresponding + * revision change. Not normally recommended but may be useful for certain kinds of snapshot artifacts. + * May reduce the amount of underlying Ivy caching. Proper behavior may be dependent on the resolver in use. + */ + boolean changing() default false; + + /** + * The configuration if in use (normally only used by internal ivy repositories). + * One or more comma separated values with or without square brackets, + * e.g. for hibernate you might have "default,proxool,oscache" or "[default,dbcp,swarmcache]". + * This last hibernate example assumes you have set up such configurations in your local Ivy repo + * and have changed your grape config (using grapeConfig.xml) or the {@code @GrabConfig} annotation + * to point to that repo. + */ + String conf() default ""; + + /** + * The extension of the artifact (normally safe to leave at default value of "jar" but other values like "zip" + * are sometimes useful). + */ + String ext() default ""; + + /** + * The type of the artifact (normally safe to leave at default value of "jar" but other values like "sources" and "javadoc" are sometimes useful). + * But see also the "classifier" attribute which is also sometimes used for "sources" and "javadoc". + */ + String type() default ""; + + /** + * Allows a more compact convenience form in one of two formats with optional appended attributes. + * Must not be used if group(), module() or version() are used. + * <p> + * You can choose either format but not mix-n-match:<br> + * {@code group:module:version:classifier@ext} (where only group and module are required)<br> + * {@code group#module;version[confs]} (where only group and module are required and confs, + * if used, is one or more comma separated configuration names)<br> + * In addition, you can add any valid Ivy attributes at the end of your string value using + * semi-colon separated name = value pairs, e.g.:<br> + * {@code @Grab('junit:junit:*;transitive=false')}<br> + * {@code @Grab('group=junit;module=junit;version=4.8.2;classifier=javadoc')}<br> + */ + String value() default ""; + + /** + * By default, when a {@code @Grab} annotation is used, a {@code Grape.grab()} call is added + * to the static initializers of the class the annotatable node appears in. + * If you wish to disable this, add {@code initClass=false} to the annotation. + */ + boolean initClass() default true; +} http://git-wip-us.apache.org/repos/asf/groovy/blob/10110145/src/main/groovy/groovy/lang/GrabConfig.java ---------------------------------------------------------------------- diff --git a/src/main/groovy/groovy/lang/GrabConfig.java b/src/main/groovy/groovy/lang/GrabConfig.java new file mode 100644 index 0000000..e6b8980 --- /dev/null +++ b/src/main/groovy/groovy/lang/GrabConfig.java @@ -0,0 +1,117 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 groovy.lang; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Used to modify the grape configuration for grab requests. + * <p> + * An example involving databases: + * <pre> + * {@code @Grab}('mysql:mysql-connector-java:5.1.6'), + * {@code @GrabConfig}(systemClassLoader=true) + * import groovy.sql.Sql + * + * def sql=Sql.newInstance("jdbc:mysql://localhost/test", "user", "password", "com.mysql.jdbc.Driver") + * println sql.firstRow('SELECT * FROM INFORMATION_SCHEMA.COLUMNS') + * </pre> + * Another example involving XStream: + * <pre> + * {@code @Grab}('com.thoughtworks.xstream:xstream:1.4.9'), + * {@code @Grab}('xpp3:xpp3_min:1.1.4c'), + * {@code @GrabConfig}(systemClassLoader=true, initContextClassLoader=true) + * import com.thoughtworks.xstream.* + * + * class Staff { + * String firstname, lastname, position + * } + * + * def xstream = new XStream() + * def john1 = new Staff(firstname:'John', + * lastname:'Connor', + * position:'Resistance Leader') + * + * // write out to XML file + * new File("john.xml").withOutputStream { out -> + * xstream.toXML(john1, out) + * } + * + * // now read back in + * def john2 + * new File("john.xml").withInputStream { ins -> + * john2 = xstream.fromXML(ins) + * } + * + * println john2.dump() + * </pre> + * <p> + * Further information about customising grape behavior can be found on the Grape documentation page: + * <a href="http://groovy-lang.org/grape.html";>http://groovy-lang.org/grape.html</a>. + */ +@Retention(RetentionPolicy.SOURCE) +@Target({ + ElementType.CONSTRUCTOR, + ElementType.FIELD, + ElementType.LOCAL_VARIABLE, + ElementType.METHOD, + ElementType.PARAMETER, + ElementType.TYPE}) +public @interface GrabConfig { + /** + * Set to true if you want to use the system classloader when loading the grape. + * This is normally only required when a core Java class needs to reference the grabbed + * classes, e.g. for a database driver accessed using DriverManager. + */ + boolean systemClassLoader() default false; + + /** + * Define any system properties which must be set before invoking the grab - useful for + * declaring SSL certificates or proxy settings. Currently, this only affects the generated + * class or script. You may need to also set those same properties for the Groovy compiler. + * For convenience, a String with comma separated name=value pairs + * can be used in addition to an array (using Groovy's literal list notation) of String name=value items. + * The single String shorthand form can't be used if value part of a property contains a comma. + * + * @since 2.4.5 + */ + String[] systemProperties() default ""; + + /** + * Set to true if you want the context classloader to be initialised to the classloader + * of the current class or script. This is useful for libraries or frameworks that assume + * that the context classloader has been set. But be careful when using this flag as your + * script or class might behave differently when called directly (from the command line or + * from an IDE) versus when called from within a container, e.g. a web container or a JEE container. + */ + boolean initContextClassLoader() default false; + + /** + * Set to false if you want to disable automatic downloading of locally missing jars. + */ + boolean autoDownload() default true; + + /** + * Set to true if you want to disable checksum checking. + */ + boolean disableChecksums() default false; +} \ No newline at end of file
