The dynamic properties and methods are now added to filters via the

metaclass of FilterConfig. Extended the tests to make sure that the
dynamic methods 'redirect' and 'render' still work.


git-svn-id: https://svn.codehaus.org/grails/trunk@6483 1cfb16fd-6d17-0410-8ff1-b7e8e1e2867d

Author: pledbrook

src/groovy/org/codehaus/groovy/grails/plugins/web/filters/DefaultGrailsFiltersClass.groovy

@@ -17,6 +17,7 @@ package org.codehaus.groovy.grails.plugins.web.filters
 
 import org.codehaus.groovy.grails.commons.AbstractInjectableGrailsClass
 import org.codehaus.groovy.grails.web.filters.GrailsFiltersClass
+
 /**
  * Loads filter definitions into a set of FilterConfig instances
  *
@@ -35,24 +36,24 @@ class DefaultGrailsFiltersClass  extends AbstractInjectableGrailsClass implement
         if (!filters) return [];
 
         def loader = new Loader()
-        def filters_closure = filters.filters
-
-        filters_closure.delegate = loader
-        filters_closure.call()
+        def filtersClosure = filters.filters
+        filtersClosure.delegate = loader
+        filtersClosure.call()
 
         return loader.filters;
     }
 }
+
 class Loader {
-	def filters = []
+    def filters = []
 
 	def methodMissing(String methodName, args) {
         if(args) {
-
-            def fc = new FilterConfig(name:methodName)
+            def fc = new FilterConfig(name: methodName)
             filters << fc
 
             if(args[0] instanceof Closure) {
+                fc.scope = [ uri: '/**' ]
                 def closure = args[0]
                 closure.delegate = fc
                 closure.call()
@@ -70,6 +71,3 @@ class Loader {
         }		
 	}
 }
-
-
-

src/groovy/org/codehaus/groovy/grails/plugins/web/filters/FilterActionDelegate.groovy

@@ -15,26 +15,26 @@
  */
 package org.codehaus.groovy.grails.plugins.web.filters
 
-import org.apache.commons.logging.*
+import org.springframework.web.servlet.ModelAndView
 
 /**
  * @author mike
  * @author Graeme Rocher
  */
 class FilterConfig {
-    static final LOG = LogFactory.getLog(FilterConfig)
     String name
     Map scope
-    def filter
     Closure before
     Closure after
     Closure afterView
+    ModelAndView modelAndView
     boolean initialised = false
 
-    void propertyMissing(String name, value) {
+    void propertyMissing(String propertyName, value) {
         if(!initialised) {
-            LOG.warn "Setting $name is invalid for filter config $name"
+            log.warn "Setting $propertyName is invalid for filter config $name"
         }
     }
+    
     public String toString() {"FilterConfig[$name, scope=$scope]"}
-}
+}

src/groovy/org/codehaus/groovy/grails/plugins/web/filters/FilterConfig.groovy

@@ -18,7 +18,6 @@ package org.codehaus.groovy.grails.plugins.web.filters
 import java.util.regex.Pattern
 import javax.servlet.http.HttpServletRequest
 import javax.servlet.http.HttpServletResponse
-import org.apache.commons.logging.LogFactory
 import org.codehaus.groovy.grails.web.servlet.GrailsApplicationAttributes
 import org.codehaus.groovy.grails.web.util.WebUtils
 import org.springframework.web.servlet.HandlerInterceptor
@@ -28,6 +27,7 @@ import org.springframework.util.AntPathMatcher
 import org.codehaus.groovy.grails.web.servlet.view.NullView
 
 /**
+ * Adapter between a FilterConfig object and a Spring HandlerInterceptor.
  * @author mike
  * @author Graeme Rocher
  */
@@ -40,12 +40,16 @@ class FilterToHandlerAdapter implements HandlerInterceptor {
     def uriPattern;
     def urlPathHelper = new UrlPathHelper()
 
-    private static final LOG = LogFactory.getLog(FilterToHandlerAdapter)
-
+    /**
+     * Returns the name of the controller targeted by the given request.
+     */
     String controllerName(request) {
         return request.getAttribute(GrailsApplicationAttributes.CONTROLLER_NAME_ATTRIBUTE).toString()
     }
 
+    /**
+     * Returns the name of the action targeted by the given request.
+     */
     String actionName(request) {
         return request.getAttribute(GrailsApplicationAttributes.ACTION_NAME_ATTRIBUTE).toString()
     }
@@ -66,13 +70,10 @@ class FilterToHandlerAdapter implements HandlerInterceptor {
             if (!accept(controllerName, actionName, uri)) return true;
 
             def callable = filterConfig.before.clone()
-            FilterActionDelegate delegate = new FilterActionDelegate()
-            callable.delegate = delegate
-            callable.resolveStrategy = Closure.DELEGATE_FIRST
             def result = callable.call();
             if(result instanceof Boolean) {
-                if(!result && delegate.modelAndView) {
-                    renderModelAndView(delegate, request, response, controllerName)
+                if(!result && filterConfig.modelAndView) {
+                    renderModelAndView(filterConfig, request, response, controllerName)
                 }
                 return result
             }
@@ -91,26 +92,22 @@ class FilterToHandlerAdapter implements HandlerInterceptor {
             if (!accept(controllerName, actionName, uri)) return;
 
             def callable = filterConfig.after.clone()
-            FilterActionDelegate delegate = new FilterActionDelegate()
-            callable.delegate = delegate
-            callable.resolveStrategy = Closure.DELEGATE_FIRST
-
-            def result = callable.call(modelAndView?.getModel());
+            def result = callable.call(modelAndView?.model);
             if(result instanceof Boolean) {
                 // if false is returned don't render a view
                 if(!result) {
                     modelAndView.viewName = null
                     modelAndView.view = new NullView(response.contentType)
                 }
             }
-            else if(delegate.modelAndView && modelAndView) {
-                if(delegate.modelAndView.viewName) {
-                    modelAndView.viewName = delegate.modelAndView.viewName
+            else if(filterConfig.modelAndView && modelAndView) {
+                if(filterConfig.modelAndView.viewName) {
+                    modelAndView.viewName = filterConfig.modelAndView.viewName
                 }
-                modelAndView.getModel().putAll(delegate.modelAndView.getModel())
+                modelAndView.model.putAll(filterConfig.modelAndView.model)
             }
-            else if(delegate.modelAndView?.viewName) {
-                renderModelAndView(delegate, request, response, controllerName)
+            else if(filterConfig.modelAndView?.viewName) {
+                renderModelAndView(filterConfig, request, response, controllerName)
             }
 
         }
@@ -124,7 +121,7 @@ class FilterToHandlerAdapter implements HandlerInterceptor {
             view = WebUtils.resolveView(request, modelAndView.viewName, controllerName, viewResolver)
         else if (modelAndView.view)
             view = modelAndView.view
-        view?.render(modelAndView.getModel(), request, response)
+        view?.render(modelAndView.model, request, response)
     }
 
     void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object o, Exception e) throws java.lang.Exception {
@@ -136,9 +133,6 @@ class FilterToHandlerAdapter implements HandlerInterceptor {
 
             if (!accept(controllerName, actionName, uri)) return;
             def callable = filterConfig.afterView.clone()
-            callable.delegate = new FilterActionDelegate()
-            callable.resolveStrategy = Closure.DELEGATE_FIRST
-            
             callable.call(e);
         }
     }

src/groovy/org/codehaus/groovy/grails/plugins/web/filters/FilterToHandlerAdapter.groovy

@@ -20,6 +20,8 @@ import org.apache.commons.logging.LogFactory
 import org.codehaus.groovy.grails.commons.GrailsApplication
 import org.springframework.beans.factory.config.MethodInvokingFactoryBean
 import org.codehaus.groovy.grails.web.plugins.support.WebMetaUtils
+import org.codehaus.groovy.grails.web.metaclass.RedirectDynamicMethod
+import org.codehaus.groovy.grails.web.metaclass.RenderDynamicMethod
 
 /**
  * @author Mike
@@ -61,15 +63,57 @@ class FiltersGrailsPlugin {
         }
 	}
 
+    def doWithDynamicMethods = { applicationContext ->
+        def mc = FilterConfig.metaClass
+
+        // Add the standard dynamic properties for web requests to all
+        // the filters, i.e. 'params', 'flash', 'request', etc.
+        WebMetaUtils.registerCommonWebProperties(mc, application)
+
+        // Also make the application context available.
+        mc.getApplicationContext = {-> applicationContext }
+
+        // Add redirect and render methods (copy and pasted from the
+        // controllers plugin).
+        def redirect = new RedirectDynamicMethod(applicationContext)
+        def render = new RenderDynamicMethod()
+
+        mc.redirect = {Map args ->
+            redirect.invoke(delegate, "redirect", args)
+        }
+
+        mc.render = {Object o ->
+            render.invoke(delegate, "render", [o?.inspect()] as Object[])
+        }
+
+        mc.render = {String txt ->
+            render.invoke(delegate, "render", [txt] as Object[])
+        }
+
+        mc.render = {Map args ->
+            render.invoke(delegate, "render", [args] as Object[])
+        }
+
+        mc.render = {Closure c ->
+            render.invoke(delegate, "render", [c] as Object[])
+        }
+
+        mc.render = {Map args, Closure c ->
+            render.invoke(delegate, "render", [args, c] as Object[])
+        }
+    }
+
 	def doWithApplicationContext = { applicationContext ->
         reloadFilters(application, applicationContext)
 	}
+
 	def onChange = { event ->
-	    if (log.isDebugEnabled()) log.debug("onChange: ${event}")
+	    if (log.debugEnabled) log.debug("onChange: ${event}")
+
+        // Get the new or modified filter and (re-)register the associated
+        // beans.
         def newFilter = event.application.addArtefact(TYPE, event.source)
-        def ctx = event.ctx
         beans(BEANS.curry(newFilter)).registerBeans(event.ctx)
-        
         reloadFilters(event.application, event.ctx)
 	}