Merge branch '2.3.x' of github.com:grails/grails-core into 2.3.x

Author: graemerocher

grails-bootstrap/src/main/groovy/org/codehaus/groovy/grails/cli/support/GrailsRootLoader.java

@@ -50,8 +50,12 @@ protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundE
             }
             return super.loadClass(name, resolve);
         }
-        catch (LinkageError e) {
-            return getParent().loadClass(name);
+        catch (LinkageError primary) {
+            try {
+                return getParent().loadClass(name);
+            } catch (ClassNotFoundException secondary) {
+                throw primary;
+            }
         }
     }
 }

grails-bootstrap/src/test/groovy/org/codehaus/groovy/grails/cli/support/GrailsRootLoaderSpec.groovy

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2012 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.codehaus.groovy.grails.cli.support
+
+import org.apache.tools.ant.BuildLogger
+import org.apache.tools.ant.Project
+import spock.lang.Specification
+
+/**
+ * @author [email protected]
+ */
+class GrailsRootLoaderSpec extends Specification {
+
+    def "NoClassDefFoundError is not obscured by ClassNotFoundException"() {
+        // i.e., GrailsRootLoader does not throw ClassNotFoundException for a class that it actually did find.
+
+        setup: "tmp dir for the isolated classpath"
+        File tmpDir = createTempDir("GrailsRootLoaderSpec", ".tmp")
+
+        and: "cut off class file A from its dependency B by copying only A to the tmp dir"
+        copyClassFileToClasspath(A, tmpDir)
+
+        and: "parent ClassLoader has neither A nor B"
+        def parent = createClassLoaderExcluding([A.name, B.name])
+
+        and: "GrailsRootLoader with just the tmp dir containing A"
+        def grl = new GrailsRootLoader([tmpDir.toURI().toURL()] as URL[], parent)
+
+        when: "loading A"
+        grl.loadClass(A.name)
+
+        then: "throws NoClassDefFoundError for B (not the parent's ClassNotFoundException for A)"
+        NoClassDefFoundError e = thrown()
+        e.message == B.name.replace('.', '/')
+
+        cleanup:
+        tmpDir.deleteDir()
+    }
+
+    static class A implements B {}
+
+    static interface B {}
+
+    private static File createTempDir(String prefix, String suffix) {
+        File tmpDir = File.createTempFile(prefix, suffix)
+        assert tmpDir.delete()
+        assert tmpDir.mkdir()
+        tmpDir
+    }
+
+    private static void copyClassFileToClasspath(Class c, File baseDir) {
+        String classFilePath = c.name.replace('.', '/').concat('.class')
+        def source = new File(c.classLoader.getResource(classFilePath).path)
+        def dest = new File(baseDir, classFilePath)
+
+        def quiet = new AntBuilder()
+        quiet.antProject.buildListeners.find {it instanceof BuildLogger}?.messageOutputLevel = Project.MSG_WARN
+        quiet.copy(file: source, tofile: dest)  // also creates intervening package dirs
+    }
+
+
+    private static ClassLoader createClassLoaderExcluding(classNames) {
+        new ClassLoader() {
+            @Override
+            protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+                if (name in classNames) {
+                    throw new ClassNotFoundException(name)
+                } else {
+                    super.loadClass(name, resolve)
+                }
+            }
+        }
+    }
+}

grails-core/src/main/groovy/org/codehaus/groovy/grails/commons/DomainClassArtefactHandler.java

@@ -74,7 +74,17 @@ public boolean isArtefactClass(Class clazz) {
 
     static final Map<Integer, Boolean> DOMAIN_CLASS_CHECK_CACHE = new ConcurrentHashMap<Integer, Boolean>();
 
+    public static boolean isDomainClass(Class<?> clazz, boolean allowProxyClass) {
+        boolean retval = isDomainClass(clazz);
+        if(!retval && allowProxyClass && clazz != null && clazz.getSimpleName().contains("$")) {
+            retval = isDomainClass(clazz.getSuperclass());
+        }
+        return retval;
+    }
+    
     public static boolean isDomainClass(Class<?> clazz) {
+        if (clazz == null) return false;
+
         Integer cacheKey = System.identityHashCode(clazz);
 
         Boolean retval = DOMAIN_CLASS_CHECK_CACHE.get(cacheKey);
@@ -83,6 +93,7 @@ public static boolean isDomainClass(Class<?> clazz) {
         }
 
         retval = doIsDomainClassCheck(clazz);
+        
         if (!developmentMode) {
             DOMAIN_CLASS_CHECK_CACHE.put(cacheKey, retval);
         }
@@ -91,8 +102,6 @@ public static boolean isDomainClass(Class<?> clazz) {
 
     private static boolean doIsDomainClassCheck(Class<?> clazz) {
         // it's not a closure
-        if (clazz == null) return false;
-
         if (Closure.class.isAssignableFrom(clazz)) {
             return false;
         }

grails-core/src/main/groovy/org/codehaus/groovy/grails/support/encoding/CodecMetaClassSupport.groovy

@@ -20,6 +20,7 @@ import groovy.transform.CompileStatic
 
 import org.codehaus.groovy.grails.commons.GrailsCodecClass
 import org.codehaus.groovy.runtime.GStringImpl
+import org.codehaus.groovy.runtime.NullObject
 
 /**
  * Helper methods for Codec metaclass operations.
@@ -53,7 +54,7 @@ class CodecMetaClassSupport {
                 ->
                 def encoder = codecClass.getEncoder()
                 if (encoder) {
-                    return encoder.encode(delegate)
+                    return encoder.encode(delegate != NullObject.NullObject ? delegate : null)
                 }
 
                 // note the call to delegate.getClass() instead of the more groovy delegate.class.
@@ -66,7 +67,7 @@ class CodecMetaClassSupport {
                 ->
                 def decoder = codecClass.getDecoder()
                 if (decoder) {
-                    return decoder.decode(delegate)
+                    return decoder.decode(delegate != NullObject.NullObject ? delegate : null)
                 }
 
                 // note the call to delegate.getClass() instead of the more groovy delegate.class.
@@ -79,13 +80,13 @@ class CodecMetaClassSupport {
             // Resolve codec methods once only at startup
             def encoder = codecClass.getEncoder()
             if (encoder) {
-                encoderClosure = { -> encoder.encode(delegate) }
+                encoderClosure = { -> encoder.encode(delegate != NullObject.NullObject ? delegate : null) }
             } else {
                 encoderClosure = { -> throw new MissingMethodException(encodeMethodName, delegate.getClass(), EMPTY_ARGS) }
             }
             def decoder = codecClass.getDecoder()
             if (decoder) {
-                decoderClosure = { -> decoder.decode(delegate) }
+                decoderClosure = { -> decoder.decode(delegate != NullObject.NullObject ? delegate : null) }
             } else {
                 decoderClosure = { -> throw new MissingMethodException(decodeMethodName, delegate.getClass(), EMPTY_ARGS) }
             }

grails-databinding/src/main/groovy/org/grails/databinding/SimpleDataBinder.groovy

@@ -318,6 +318,9 @@ class SimpleDataBinder implements DataBinder {
                         indexedInstance = genericType.newInstance()
                         bind indexedInstance, val, listener
                         addElementToCollectionAt obj, propName, collectionInstance, index, indexedInstance
+                    } else if(genericType.isEnum() && val instanceof CharSequence) {
+                        def enumValue = convertStringToEnum(genericType, val.toString())
+                        addElementToCollectionAt obj, propName, collectionInstance, index, enumValue
                     }
                 } else {
                     addElementToCollectionAt obj, propName, collectionInstance, index, val

grails-databinding/src/test/groovy/org/grails/databinding/SimpleDataBinderEnumBindingSpec.groovy

@@ -0,0 +1,30 @@
+package org.grails.databinding
+
+import spock.lang.Issue
+import spock.lang.Specification
+
+class SimpleDataBinderEnumBindingSpec extends Specification {
+    @Issue('GRAILS-10979')
+    void 'Test binding to a List of enum'() {
+        given:
+        def binder = new SimpleDataBinder()
+        def holder = new HatSizeHolder()
+        
+        when:
+        binder.bind holder, ['sizes[0]': 'LARGE', 'sizes[1]': 'SMALL'] as SimpleMapDataBindingSource
+        
+        then:
+        holder.sizes?.size() == 2
+        holder.sizes[0] == HatSize.LARGE
+        holder.sizes[1] == HatSize.SMALL
+    }
+
+}
+
+enum HatSize {
+    SMALL, MEDIUM, LARGE
+}
+
+class HatSizeHolder {
+    List<HatSize> sizes
+}

grails-plugin-codecs/build.gradle

@@ -1,4 +1,4 @@
 dependencies {
     compile 'commons-codec:commons-codec:1.6'
-    compile project(":grails-web")
-}
+    compile project(":grails-web"), project(":grails-plugin-converters")
+}

grails-plugin-codecs/src/main/groovy/org/codehaus/groovy/grails/plugins/CodecsGrailsPlugin.groovy

@@ -33,6 +33,7 @@ import org.codehaus.groovy.grails.plugins.codecs.SHA256BytesCodec
 import org.codehaus.groovy.grails.plugins.codecs.SHA256Codec
 import org.codehaus.groovy.grails.plugins.codecs.URLCodec
 import org.codehaus.groovy.grails.plugins.codecs.XMLCodec
+import org.codehaus.groovy.grails.plugins.codecs.JSONCodec
 
 /**
  * Configures pluggable codecs.
@@ -48,6 +49,7 @@ class CodecsGrailsPlugin {
         HTMLCodec,
         HTML4Codec,
         XMLCodec,
+        JSONCodec,
         JavaScriptCodec,
         URLCodec,
         Base64Codec,

grails-plugin-codecs/src/main/groovy/org/codehaus/groovy/grails/plugins/codecs/AbstractCharReplacementEncoder.java

@@ -54,6 +54,10 @@ public AbstractCharReplacementEncoder(CodecIdentifier codecIdentifier) {
      * @see org.codehaus.groovy.grails.support.encoding.Encoder#encode(java.lang.Object)
      */
     public Object encode(Object o) {
+        return doCharReplacementEncoding(o);
+    }
+
+    protected final Object doCharReplacementEncoding(Object o) {
         if (o == null) {
             return null;
         }
@@ -72,9 +76,17 @@ else if (o instanceof Character) {
             }
         }
         else {
-            str = String.valueOf(o);
+            str = convertToString(o);
         }
 
+        return escapeCharSequence(str);
+    }
+
+    protected String convertToString(Object o) {
+        return String.valueOf(o);
+    }
+
+    protected Object escapeCharSequence(CharSequence str) {
         if (str == null || str.length() == 0) {
             return str;
         }

grails-plugin-codecs/src/main/groovy/org/codehaus/groovy/grails/plugins/codecs/HTMLEncoder.java

@@ -32,4 +32,8 @@ public class HTMLEncoder extends XMLEncoder {
     public HTMLEncoder() {
         super(HTML_CODEC_IDENTIFIER);
     }
+    
+    protected Object doEncode(Object o) {
+        return doCharReplacementEncoding(o);
+    }    
 }