Improve binary compatibility

grails-compatibility/src/main/groovy/org/codehaus/groovy/grails/commons/spring/GrailsRuntimeConfigurator.groovy

@@ -15,10 +15,14 @@
  */
 package org.codehaus.groovy.grails.commons.spring
 
+import grails.spring.BeanBuilder
 import groovy.transform.CompileStatic
-import grails.core.GrailsApplication
 import grails.plugins.GrailsPluginManager
+import org.codehaus.groovy.grails.commons.GrailsApplication
+import org.grails.core.LegacyGrailsApplication
+import org.grails.spring.RuntimeSpringConfigUtilities
 import org.springframework.context.ApplicationContext
+import org.springframework.context.support.GenericApplicationContext
 
 /**
  * Handles the runtime configuration of the Grails ApplicationContext.
@@ -29,16 +33,45 @@ import org.springframework.context.ApplicationContext
  */
 @CompileStatic
 @Deprecated
-class GrailsRuntimeConfigurator extends org.grails.web.servlet.context.support.GrailsRuntimeConfigurator{
+class GrailsRuntimeConfigurator extends org.grails.web.servlet.context.support.GrailsRuntimeConfigurator {
     GrailsRuntimeConfigurator(GrailsApplication application) {
-        super(application)
+        super(((LegacyGrailsApplication)application).grailsApplication)
     }
 
     GrailsRuntimeConfigurator(GrailsApplication application, ApplicationContext parent) {
-        super(application, parent)
+        super((((LegacyGrailsApplication)application).grailsApplication), parent)
     }
 
     GrailsRuntimeConfigurator(GrailsApplication application, ApplicationContext parent, GrailsPluginManager pluginManager) {
-        super(application, parent, pluginManager)
+        super((((LegacyGrailsApplication)application).grailsApplication), parent, pluginManager)
     }
+
+    /**
+     * Loads any external Spring configuration into the given RuntimeSpringConfiguration object.
+     * @param config The config instance
+     */
+    public static void loadExternalSpringConfig(RuntimeSpringConfiguration config, final GrailsApplication application) {
+        RuntimeSpringConfigUtilities.loadExternalSpringConfig(config, (((LegacyGrailsApplication)application).grailsApplication));
+    }
+
+    public static BeanBuilder reloadSpringResourcesConfig(RuntimeSpringConfiguration config, GrailsApplication application, Class<?> groovySpringResourcesClass) throws InstantiationException, IllegalAccessException {
+        return RuntimeSpringConfigUtilities.reloadSpringResourcesConfig(config, (((LegacyGrailsApplication)application).grailsApplication), groovySpringResourcesClass);
+    }
+
+    public static void loadSpringGroovyResources(RuntimeSpringConfiguration config, GrailsApplication application) {
+        RuntimeSpringConfigUtilities.loadExternalSpringConfig(config, (((LegacyGrailsApplication)application).grailsApplication));
+    }
+
+    public static void loadSpringGroovyResourcesIntoContext(RuntimeSpringConfiguration config, GrailsApplication application,
+                                                            GenericApplicationContext context) {
+        RuntimeSpringConfigUtilities.loadSpringGroovyResourcesIntoContext(config, (((LegacyGrailsApplication)application).grailsApplication), context);
+    }
+
+    /**
+     * Resets the GrailsRumtimeConfigurator.
+     */
+    public static void reset() {
+        RuntimeSpringConfigUtilities.reset();
+    }
+
 }

grails-compatibility/src/main/groovy/org/codehaus/groovy/grails/validation/DefaultConstraintEvaluator.groovy

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2011 SpringSource
+ *
+ * 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.validation
+
+import groovy.transform.CompileStatic
+
+/**
+ * @author Graeme Rocher
+ * @deprecated Use {@link org.grails.validation.DefaultConstraintEvaluator} instead
+ */
+@CompileStatic
+@Deprecated
+class DefaultConstraintEvaluator extends org.grails.validation.DefaultConstraintEvaluator {
+
+    DefaultConstraintEvaluator(Map<String, Object> defaultConstraints) {
+        super(defaultConstraints)
+    }
+
+    DefaultConstraintEvaluator() {
+    }
+}

grails-core/src/main/groovy/org/grails/core/LegacyGrailsApplication.groovy

@@ -1,6 +1,7 @@
 package org.grails.core
 
 import grails.core.GrailsDomainClass
+import grails.util.GrailsNameUtils
 import grails.util.Metadata
 import groovy.transform.CompileStatic
 import org.codehaus.groovy.grails.commons.ArtefactHandler
@@ -11,21 +12,45 @@ import org.grails.core.artefact.DomainClassArtefactHandler
 import org.springframework.context.ApplicationContext
 import org.springframework.core.io.Resource
 
+import java.util.regex.Matcher
+import java.util.regex.Pattern
+
 /**
  * Legacy bridge for older GrailsApplication API
  *
  * @author Graeme Rocher
  * @since 3.0
  */
 @CompileStatic
-class LegacyGrailsApplication implements GrailsApplication {
+class LegacyGrailsApplication extends GroovyObjectSupport  implements GrailsApplication {
+
+    protected static final Pattern GETCLASSESPROP_PATTERN = Pattern.compile(/(\w+)(Classes)/);
+    protected static final Pattern GETCLASSESMETH_PATTERN = Pattern.compile(/(get)(\w+)(Classes)/);
+    protected static final Pattern ISCLASS_PATTERN = Pattern.compile(/(is)(\w+)(Class)/);
+    protected static final Pattern GETCLASS_PATTERN = Pattern.compile(/(get)(\w+)Class/);
+
 
     grails.core.GrailsApplication grailsApplication
 
     LegacyGrailsApplication(grails.core.GrailsApplication grailsApplication) {
         this.grailsApplication = grailsApplication
     }
 
+    @Override
+    Object getProperty(String property) {
+        // look for getXXXXClasses
+        final Matcher match = GETCLASSESPROP_PATTERN.matcher(property)
+        // find match
+        match.find()
+        if (match.matches()) {
+            def artefactName = GrailsNameUtils.getClassNameRepresentation(match.group(1))
+            if (getArtefactHandler(artefactName)) {
+                return getArtefacts(artefactName)
+            }
+        }
+        return super.getProperty(property)
+    }
+
     @Override
     ConfigObject getConfig() {
         grailsApplication.config

grails-core/src/main/groovy/org/grails/plugins/AbstractGrailsPlugin.java

@@ -27,6 +27,7 @@
 
 import org.grails.core.AbstractGrailsClass;
 import grails.core.GrailsApplication;
+import org.grails.core.LegacyGrailsApplication;
 import org.grails.plugins.support.WatchPattern;
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
@@ -46,7 +47,7 @@ public void refresh() {
         // do nothing
     }
 
-    protected GrailsApplication application;
+    protected org.codehaus.groovy.grails.commons.GrailsApplication application;
     protected boolean isBase = false;
     protected String version = "1.0";
     protected Map<String, Object> dependencies = new HashMap<String, Object>();
@@ -72,7 +73,7 @@ public AbstractGrailsPlugin(Class<?> pluginClass, GrailsApplication application)
         Assert.isTrue(pluginClass.getName().endsWith(TRAILING_NAME),
                 "Argument [pluginClass] with value [" + pluginClass +
                 "] is not a Grails plugin (class name must end with 'GrailsPlugin')");
-        this.application = application;
+        this.application = new LegacyGrailsApplication(application);
         this.pluginClass = pluginClass;
     }
 
@@ -156,7 +157,7 @@ public void setManager(GrailsPluginManager manager) {
      * @see grails.plugins.GrailsPlugin#setApplication(grails.core.GrailsApplication)
      */
     public void setApplication(GrailsApplication application) {
-        this.application = application;
+        this.application = new LegacyGrailsApplication(application);
     }
 
     public String[] getEvictionNames() {

grails-core/src/main/groovy/org/grails/plugins/AbstractGrailsPluginManager.java

@@ -39,14 +39,21 @@
 import grails.core.ArtefactHandler;
 import grails.core.GrailsApplication;
 import org.codehaus.groovy.grails.plugins.GrailsPluginUtils;
+import org.grails.core.LegacyGrailsApplication;
 import org.grails.core.cfg.ConfigurationHelper;
 import org.grails.spring.RuntimeSpringConfiguration;
 import org.codehaus.groovy.grails.io.support.GrailsResourceUtils;
 import org.codehaus.groovy.grails.plugins.exceptions.PluginException;
 import org.codehaus.groovy.runtime.DefaultGroovyMethods;
 import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.context.ApplicationContext;
 import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.convert.ConversionService;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.core.convert.converter.ConverterRegistry;
+import org.springframework.core.convert.support.GenericConversionService;
 import org.springframework.core.io.FileSystemResource;
 import org.springframework.core.io.Resource;
 import org.springframework.core.type.filter.TypeFilter;
@@ -120,6 +127,28 @@ public GrailsPlugin getFailedPlugin(String name) {
      * @param springConfig The RuntimeSpringConfiguration instance
      */
     public void doRuntimeConfiguration(RuntimeSpringConfiguration springConfig) {
+        ApplicationContext context = springConfig.getUnrefreshedApplicationContext();
+        AutowireCapableBeanFactory autowireCapableBeanFactory = context.getAutowireCapableBeanFactory();
+        if(autowireCapableBeanFactory instanceof ConfigurableListableBeanFactory) {
+            ConfigurableListableBeanFactory beanFactory = (ConfigurableListableBeanFactory)autowireCapableBeanFactory;
+            ConversionService existingConversionService = beanFactory.getConversionService();
+            ConverterRegistry converterRegistry;
+            if(existingConversionService == null) {
+                GenericConversionService conversionService = new GenericConversionService();
+                converterRegistry = conversionService;
+                beanFactory.setConversionService(conversionService);
+            }
+            else {
+                converterRegistry = (ConverterRegistry)existingConversionService;
+            }
+
+            converterRegistry.addConverter(new Converter<GrailsApplication, org.codehaus.groovy.grails.commons.GrailsApplication>() {
+                @Override
+                public org.codehaus.groovy.grails.commons.GrailsApplication convert(GrailsApplication source) {
+                    return new LegacyGrailsApplication(source);
+                }
+            });
+        }
         checkInitialised();
         for (GrailsPlugin plugin : pluginList) {
             if (plugin.supportsCurrentScopeAndEnvironment()) {

grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy

@@ -126,8 +126,8 @@ class CoreGrailsPlugin implements GrailsApplicationAware {
         }
 
         customEditors(CustomEditorConfigurer) {
-            customEditors = [(Class.name): ClassEditor.name,
-                             (Properties.name): PropertiesEditor.name]
+            customEditors = [(Class): ClassEditor,
+                             (Properties): PropertiesEditor]
         }
 
         proxyHandler(DefaultProxyHandler)

grails-core/src/main/groovy/org/grails/plugins/DefaultGrailsPlugin.java

@@ -44,6 +44,7 @@
 import grails.util.GrailsArrayUtils;
 import grails.util.GrailsClassUtils;
 import org.codehaus.groovy.grails.plugins.GrailsPluginUtils;
+import org.grails.core.LegacyGrailsApplication;
 import org.grails.core.io.SpringResource;
 import org.grails.core.exceptions.GrailsConfigurationException;
 import org.grails.spring.RuntimeSpringConfiguration;
@@ -151,7 +152,7 @@ private void initialisePlugin(Class<?> clazz) {
         pluginGrailsClass = new GrailsPluginClass(clazz);
         plugin = (GroovyObject)pluginGrailsClass.newInstance();
         if(plugin instanceof GrailsApplicationAware) {
-            ((GrailsApplicationAware)plugin).setGrailsApplication(this.application);
+            ((GrailsApplicationAware)plugin).setGrailsApplication(((LegacyGrailsApplication)this.application).getGrailsApplication());
         }
         pluginBean = new BeanWrapperImpl(plugin);
 
@@ -527,6 +528,7 @@ public void doWithRuntimeConfiguration(RuntimeSpringConfiguration springConfig)
         BeanBuilder bb = new BeanBuilder(getParentCtx(),springConfig, application.getClassLoader());
         Binding b = new Binding();
         b.setVariable("application", application);
+        b.setVariable(GrailsApplication.APPLICATION_ID, application);
         b.setVariable("manager", getManager());
         b.setVariable("plugin", this);
         b.setVariable("parentCtx", getParentCtx());
@@ -798,7 +800,7 @@ public void doArtefactConfiguration() {
                 Class artefactClass = (Class) artefact;
                 if (ArtefactHandler.class.isAssignableFrom(artefactClass)) {
                     try {
-                        application.registerArtefactHandler((ArtefactHandler) artefactClass.newInstance());
+                        ((LegacyGrailsApplication)application).getGrailsApplication().registerArtefactHandler((ArtefactHandler) artefactClass.newInstance());
                     }
                     catch (InstantiationException e) {
                         LOG.error("Cannot instantiate an Artefact Handler:" + e.getMessage(), e);
@@ -812,7 +814,7 @@ public void doArtefactConfiguration() {
                 }
             }
             else if (artefact instanceof ArtefactHandler) {
-                application.registerArtefactHandler((ArtefactHandler) artefact);
+                ((LegacyGrailsApplication)application).getGrailsApplication().registerArtefactHandler((ArtefactHandler) artefact);
             }
             else {
                 LOG.error("This object is not an ArtefactHandler:" + artefact + "[" + artefact.getClass().getName() + "]");

grails-plugin-converters/src/main/groovy/org/grails/plugins/converters/ConvertersGrailsPlugin.groovy

@@ -17,6 +17,8 @@ package org.grails.plugins.converters
 
 import grails.converters.JSON
 import grails.converters.XML
+import grails.core.GrailsApplication
+import grails.core.support.GrailsApplicationAware
 import grails.util.GrailsUtil
 
 import org.grails.plugins.converters.api.ConvertersControllersApi
@@ -33,7 +35,7 @@ import org.grails.web.converters.marshaller.xml.ValidationErrorsMarshaller as Xm
  *
  * @since 0.6
  */
-class ConvertersGrailsPlugin {
+class ConvertersGrailsPlugin implements GrailsApplicationAware {
 
     def version = GrailsUtil.getGrailsVersion()
 
@@ -47,6 +49,8 @@ class ConvertersGrailsPlugin {
 
     def dependsOn = [controllers: version, domainClass: version]
 
+    GrailsApplication grailsApplication
+
     def doWithSpring = {
         jsonErrorsMarshaller(JsonErrorsMarshaller)
 
@@ -68,7 +72,7 @@ class ConvertersGrailsPlugin {
     }
 
     def doWithDynamicMethods = {applicationContext ->
-
+        def application = grailsApplication
         applicationContext.getBean("convertersConfigurationInitializer").initialize(application)
 
         ConvertersPluginSupport.enhanceApplication(application, applicationContext)

grails-plugin-domain-class/src/main/groovy/org/codehaus/groovy/grails/plugins/DomainClassGrailsPlugin.groovy

@@ -20,6 +20,7 @@ import grails.core.support.GrailsApplicationAware
 import grails.util.GrailsUtil
 import grails.validation.ValidationErrors
 import grails.core.ComponentCapableDomainClass
+import groovy.transform.CompileStatic
 import org.grails.core.LegacyGrailsApplication
 import org.grails.core.artefact.DomainClassArtefactHandler
 
@@ -118,7 +119,7 @@ class DomainClassGrailsPlugin implements GrailsApplicationAware{
     static final PROPERTY_INSTANCE_MAP = new SoftThreadLocalMap()
 
     def doWithDynamicMethods = { ApplicationContext ctx->
-        enhanceDomainClasses(application, ctx)
+        enhanceDomainClasses(grailsApplication, ctx)
     }
 
     def onChange = { event ->
@@ -178,6 +179,12 @@ class DomainClassGrailsPlugin implements GrailsApplicationAware{
         event.application.refreshConstraints()
     }
 
+
+    @CompileStatic
+    static void enhanceDomainClasses(org.codehaus.groovy.grails.commons.GrailsApplication application, ApplicationContext ctx) {
+        enhanceDomainClasses(((LegacyGrailsApplication)application).grailsApplication, ctx)
+    }
+
     static  enhanceDomainClasses(GrailsApplication application, ApplicationContext ctx) {
         for (GrailsDomainClass dc in application.domainClasses) {
             def domainClass = dc

grails-plugin-rest/src/main/groovy/org/grails/plugins/web/rest/plugin/RestResponderGrailsPlugin.groovy

@@ -15,6 +15,7 @@
  */
 package org.grails.plugins.web.rest.plugin
 
+import grails.core.support.GrailsApplicationAware
 import grails.rest.Resource
 import grails.util.GrailsUtil
 import groovy.transform.CompileStatic
@@ -32,14 +33,16 @@ import org.grails.plugins.web.rest.render.DefaultRendererRegistry
  * @since 2.3
  * @author Graeme Rocher
  */
-class RestResponderGrailsPlugin {
+class RestResponderGrailsPlugin implements GrailsApplicationAware{
     private static final Log LOG = LogFactory.getLog(RestResponderGrailsPlugin)
     def version = GrailsUtil.getGrailsVersion()
     def loadBefore = ['controllers']
     def observe = ['domainClass']
 
+    GrailsApplication grailsApplication
+
     def doWithSpring = {
-        RestResponderGrailsPlugin.registryResourceControllers(application)
+        RestResponderGrailsPlugin.registryResourceControllers(grailsApplication)
 
         rendererRegistry(DefaultRendererRegistry) { bean ->
             modelSuffix = application.flatConfig.get('grails.scaffolding.templates.domainSuffix') ?: ''
@@ -48,7 +51,7 @@ class RestResponderGrailsPlugin {
     }
 
     def onChange = { event ->
-        RestResponderGrailsPlugin.registryResourceControllers(event.application)
+        RestResponderGrailsPlugin.registryResourceControllers(grailsApplication)
     }
 
     @CompileStatic