GRAILS-6341 avoiding access to constrainedProperties when Hibernate i…

…sn't installed
grails · Jun 10, 2010 · f2969aa · f2969aa
1 parent aa0e8a8
commit f2969aa
Show file tree

Hide file tree

Showing 5 changed files with 78 additions and 21 deletions.
diff --git a/src/grails/templates/scaffolding/create.gsp b/src/grails/templates/scaffolding/create.gsp
@@ -1,4 +1,5 @@
 <% import grails.persistence.Event %>
+<% import org.codehaus.groovy.grails.plugins.PluginManagerHolder %>
 <%=packageName%>
 <html>
     <head>
@@ -29,10 +30,14 @@
                         <%  excludedProps = Event.allEvents.toList() << 'version' << 'id'
                             props = domainClass.properties.findAll { !excludedProps.contains(it.name) }
                             Collections.sort(props, comparator.constructors[0].newInstance([domainClass] as Object[]))
+                            display = true
+                            boolean hasHibernate = PluginManagerHolder.pluginManager.hasGrailsPlugin('hibernate')
                             props.each { p ->
                                 if (!Collection.class.isAssignableFrom(p.type)) {
-                                    cp = domainClass.constrainedProperties[p.name]
-                                    display = (cp ? cp.display : true)        
+                                    if (hasHibernate) {
+                                        cp = domainClass.constrainedProperties[p.name]
+                                        display = (cp ? cp.display : true)
+                                    }
                                     if (display) { %>
                             <tr class="prop">
                                 <td valign="top" class="name">

diff --git a/src/grails/templates/scaffolding/edit.gsp b/src/grails/templates/scaffolding/edit.gsp
@@ -1,4 +1,5 @@
 <% import grails.persistence.Event %>
+<% import org.codehaus.groovy.grails.plugins.PluginManagerHolder %>
 <%=packageName%>
 <html>
     <head>
@@ -32,9 +33,13 @@
                         <%  excludedProps = Event.allEvents.toList() << 'version' << 'id'
                             props = domainClass.properties.findAll { !excludedProps.contains(it.name) }
                             Collections.sort(props, comparator.constructors[0].newInstance([domainClass] as Object[]))
+                            display = true
+                            boolean hasHibernate = PluginManagerHolder.pluginManager.hasGrailsPlugin('hibernate')
                             props.each { p ->
-                                cp = domainClass.constrainedProperties[p.name]
-                                display = (cp ? cp.display : true)        
+                                if (hasHibernate) {
+                                    cp = domainClass.constrainedProperties[p.name]
+                                    display = (cp ? cp.display : true)        
+                                }
                                 if (display) { %>
                             <tr class="prop">
                                 <td valign="top" class="name">

diff --git a/src/grails/templates/scaffolding/list.gsp b/src/grails/templates/scaffolding/list.gsp
@@ -28,7 +28,7 @@
                                 if (i < 6) {
                                     if (p.isAssociation()) { %>
                             <th><g:message code="${domainClass.propertyName}.${p.name}.label" default="${p.naturalName}" /></th>
-                   	    <%      } else { %>
+                        <%      } else { %>
                             <g:sortableColumn property="${p.name}" title="\${message(code: '${domainClass.propertyName}.${p.name}.label', default: '${p.naturalName}')}" />
                         <%  }   }   } %>
                         </tr>
@@ -37,7 +37,6 @@
                     <g:each in="\${${propertyName}List}" status="i" var="${propertyName}">
                         <tr class="\${(i % 2) == 0 ? 'odd' : 'even'}">
                         <%  props.eachWithIndex { p, i ->
-                                cp = domainClass.constrainedProperties[p.name]
                                 if (i == 0) { %>
                             <td><g:link action="show" id="\${${propertyName}.id}">\${fieldValue(bean: ${propertyName}, field: "${p.name}")}</g:link></td>
                         <%      } else if (i < 6) {

diff --git a/src/java/org/codehaus/groovy/grails/scaffolding/DefaultGrailsTemplateGenerator.groovy b/src/java/org/codehaus/groovy/grails/scaffolding/DefaultGrailsTemplateGenerator.groovy
@@ -22,15 +22,14 @@ import org.apache.commons.logging.Log
 import org.apache.commons.logging.LogFactory
 import org.codehaus.groovy.grails.commons.ApplicationHolder
 import org.codehaus.groovy.grails.commons.GrailsDomainClass
-import org.codehaus.groovy.grails.scaffolding.DomainClassPropertyComparator
-import org.codehaus.groovy.grails.scaffolding.GrailsTemplateGenerator
 import org.springframework.context.ResourceLoaderAware
 import org.springframework.core.io.ClassPathResource
 import org.springframework.core.io.FileSystemResource
 import org.springframework.core.io.ResourceLoader
 import org.springframework.core.io.support.PathMatchingResourcePatternResolver
 import org.codehaus.groovy.grails.cli.CommandLineHelper
 import org.codehaus.groovy.grails.commons.ConfigurationHolder
+import org.codehaus.groovy.grails.plugins.PluginManagerHolder
 
 /**
  * Default implementation of the generator that generates grails artifacts (controllers, views etc.)
@@ -79,7 +78,10 @@ class DefaultGrailsTemplateGenerator implements GrailsTemplateGenerator, Resourc
     // a closure that uses the type to render the appropriate editor
     def renderEditor = {property ->
         def domainClass = property.domainClass
-        def cp = domainClass.constrainedProperties[property.name]
+        def cp
+        if (PluginManagerHolder.pluginManager.hasGrailsPlugin('hibernate')) {
+            cp = domainClass.constrainedProperties[property.name]
+        }
 
         if (!renderEditorTemplate) {
             // create template once for performance
@@ -191,27 +193,27 @@ class DefaultGrailsTemplateGenerator implements GrailsTemplateGenerator, Resourc
         def t = engine.createTemplate(templateText)
         def multiPart = domainClass.properties.find {it.type == ([] as Byte[]).class || it.type == ([] as byte[]).class}
 
+        boolean hasHibernate = PluginManagerHolder.pluginManager.hasGrailsPlugin('hibernate')
         def packageName = domainClass.packageName ? "<%@ page import=\"${domainClass.fullName}\" %>" : ""
         def binding = [packageName: packageName,
-                domainClass: domainClass,
-                multiPart: multiPart,
-                className: domainClass.shortName,
-                propertyName:  getPropertyName(domainClass),
-                renderEditor: renderEditor,
-                comparator: org.codehaus.groovy.grails.scaffolding.DomainClassPropertyComparator.class]
-
+                       domainClass: domainClass,
+                       multiPart: multiPart,
+                       className: domainClass.shortName,
+                       propertyName:  getPropertyName(domainClass),
+                       renderEditor: renderEditor,
+                       comparator: hasHibernate ? DomainClassPropertyComparator : SimpleDomainClassPropertyComparator]
         t.make(binding).writeTo(out)
     }
 
     void generateController(GrailsDomainClass domainClass, Writer out) {
         def templateText = getTemplateText("Controller.groovy")
 
+        boolean hasHibernate = PluginManagerHolder.pluginManager.hasGrailsPlugin('hibernate')
         def binding = [packageName: domainClass.packageName,
-                domainClass: domainClass,
-                className: domainClass.shortName,
-                propertyName: getPropertyName(domainClass),
-                comparator: org.codehaus.groovy.grails.scaffolding.DomainClassPropertyComparator.class]
-
+                       domainClass: domainClass,
+                       className: domainClass.shortName,
+                       propertyName: getPropertyName(domainClass),
+                       comparator: hasHibernate ? DomainClassPropertyComparator : SimpleDomainClassPropertyComparator]
         def t = engine.createTemplate(templateText)
         t.make(binding).writeTo(out)
     }

diff --git a/src/java/org/codehaus/groovy/grails/scaffolding/SimpleDomainClassPropertyComparator.java b/src/java/org/codehaus/groovy/grails/scaffolding/SimpleDomainClassPropertyComparator.java
@@ -0,0 +1,46 @@
+/* Copyright 2004-2005 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.scaffolding;
+
+import java.util.Comparator;
+
+import org.codehaus.groovy.grails.commons.GrailsDomainClass;
+import org.springframework.util.Assert;
+
+/**
+ * Comparator used when Hibernate isn't installed.
+ *
+ * @author Burt Beckwith
+ */
+@SuppressWarnings("unchecked")
+public class SimpleDomainClassPropertyComparator implements Comparator {
+
+	private GrailsDomainClass domainClass;
+
+	public SimpleDomainClassPropertyComparator(GrailsDomainClass domainClass) {
+		Assert.notNull(domainClass, "Argument 'domainClass' is required!");
+		this.domainClass = domainClass;
+	}
+
+	public int compare(Object o1, Object o2) {
+		if (o1.equals(domainClass.getIdentifier())) {
+			return -1;
+		}
+		if (o2.equals(domainClass.getIdentifier())) {
+			return 1;
+		}
+		return 0;
+	}
+}