From f2969aa21bef84b0ee3b398e797b23c689628997 Mon Sep 17 00:00:00 2001 From: Burt Beckwith Date: Wed, 9 Jun 2010 14:46:43 -0400 Subject: [PATCH] GRAILS-6341 avoiding access to constrainedProperties when Hibernate isn't installed --- src/grails/templates/scaffolding/create.gsp | 9 +++- src/grails/templates/scaffolding/edit.gsp | 9 +++- src/grails/templates/scaffolding/list.gsp | 3 +- .../DefaultGrailsTemplateGenerator.groovy | 32 +++++++------ .../SimpleDomainClassPropertyComparator.java | 46 +++++++++++++++++++ 5 files changed, 78 insertions(+), 21 deletions(-) create mode 100644 src/java/org/codehaus/groovy/grails/scaffolding/SimpleDomainClassPropertyComparator.java diff --git a/src/grails/templates/scaffolding/create.gsp b/src/grails/templates/scaffolding/create.gsp index a0f7f502383..9a153900dc4 100644 --- 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%> @@ -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) { %> diff --git a/src/grails/templates/scaffolding/edit.gsp b/src/grails/templates/scaffolding/edit.gsp index 0cc67f59249..f5d6239e207 100644 --- 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%> @@ -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) { %> diff --git a/src/grails/templates/scaffolding/list.gsp b/src/grails/templates/scaffolding/list.gsp index df2777d1c14..6d20bced219 100644 --- a/src/grails/templates/scaffolding/list.gsp +++ b/src/grails/templates/scaffolding/list.gsp @@ -28,7 +28,7 @@ if (i < 6) { if (p.isAssociation()) { %> - <% } else { %> + <% } else { %> <% } } } %> @@ -37,7 +37,6 @@ <% props.eachWithIndex { p, i -> - cp = domainClass.constrainedProperties[p.name] if (i == 0) { %> \${fieldValue(bean: ${propertyName}, field: "${p.name}")} <% } 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 index e3896151606..8e2f8afba9f 100644 --- a/src/java/org/codehaus/groovy/grails/scaffolding/DefaultGrailsTemplateGenerator.groovy +++ b/src/java/org/codehaus/groovy/grails/scaffolding/DefaultGrailsTemplateGenerator.groovy @@ -22,8 +22,6 @@ 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 @@ -31,6 +29,7 @@ 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 new file mode 100644 index 00000000000..ca9d29c5c36 --- /dev/null +++ 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; + } +}