fix for GRAILS-1686

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

Author: graeme

src/commons/org/codehaus/groovy/grails/commons/DefaultGrailsDomainClass.java

@@ -504,7 +504,7 @@ private void establishDomainClassRelationship(DefaultGrailsDomainClassProperty p
 
             // if there is only one property on many-to-one side of the relationship then
             // try to establish if it is bidirectional
-            if(descriptors.length == 1) {
+            if(descriptors.length == 1 && isNotMappedToDifferentProperty(property,relatedClassPropertyName, mappedBy)) {
                 if(!StringUtils.isBlank(relatedClassPropertyName)) {
                     property.setReferencePropertyName(relatedClassPropertyName);
                     // get the type of the property
@@ -545,8 +545,15 @@ else if(descriptors.length > 1) {
         //	establish relationship based on this type
         establishDomainClassRelationshipToType( property, relatedClassPropertyType );
     }
+  
+    private boolean isNotMappedToDifferentProperty(GrailsDomainClassProperty property, String relatedClassPropertyName, Map mappedBy) {
+        String mappedByForRelation = (String)mappedBy.get(relatedClassPropertyName);
+        if(mappedByForRelation == null) return true;
+        else if(!property.getName().equals(mappedByForRelation)) return false;
+        return true;
+    }
 
-	private String findOneToManyThatMatchesType(DefaultGrailsDomainClassProperty property, Map relatedClassRelationships) {
+    private String findOneToManyThatMatchesType(DefaultGrailsDomainClassProperty property, Map relatedClassRelationships) {
 		String relatedClassPropertyName = null;
 		for(Iterator i = relatedClassRelationships.keySet().iterator();i.hasNext();) {
 		    String currentKey = (String)i.next();
@@ -720,4 +727,8 @@ public Set getSubClasses() {
     public void refreshConstraints() {
         evaluateConstraints();
     }
+
+    public Map getMappedBy() {
+        return mappedBy;
+    }
 }

src/commons/org/codehaus/groovy/grails/commons/GrailsClassUtils.java

@@ -17,10 +17,7 @@
 
 import groovy.lang.*;
 import org.apache.commons.lang.StringUtils;
-import org.springframework.beans.BeanUtils;
-import org.springframework.beans.BeanWrapper;
-import org.springframework.beans.BeanWrapperImpl;
-import org.springframework.beans.BeansException;
+import org.springframework.beans.*;
 import org.springframework.util.Assert;
 
 import java.beans.PropertyDescriptor;
@@ -100,8 +97,14 @@ public static Object getPropertyValueOfNewInstance(Class clazz, String propertyN
         if(clazz == null || StringUtils.isBlank(propertyName))
             return null;
 
-        Object instance = BeanUtils.instantiateClass(clazz);
-        
+        Object instance = null;
+        try {
+            instance = BeanUtils.instantiateClass(clazz);
+        } catch (BeanInstantiationException e) {
+            return null;
+        }
+
+
         return getPropertyOrStaticPropertyOrFieldValue(instance, propertyName);
     }
 

src/commons/org/codehaus/groovy/grails/commons/GrailsDomainClass.java

@@ -178,4 +178,9 @@ public interface GrailsDomainClass extends GrailsClass {
      * @return True if it does
      */
     boolean hasSubClasses();
+
+    /**
+     * @return The map that defines association mappings
+     */
+    Map getMappedBy();
 }

src/commons/org/codehaus/groovy/grails/commons/GrailsDomainConfigurationUtil.java

@@ -99,10 +99,11 @@ public static void configureDomainClassRelationships(GrailsClass[] domainClasses
                             for (int k = 0; k < referencedProperties.length; k++) {
                             	// for bi-directional circular dependencies we don't want the other side 
                             	// to be equal to self 
-                            	if(prop.equals(referencedProperties[k]) && prop.isBidirectional())
+                                GrailsDomainClassProperty referencedProp = referencedProperties[k];
+                                if(prop.equals(referencedProp) && prop.isBidirectional())
                             		continue;
-                                if(domainClasses[i].getClazz().equals(referencedProperties[k].getReferencedPropertyType())) {
-                                    prop.setOtherSide(referencedProperties[k]);
+                                if(isCandidateForOtherSide(domainClass, prop, referencedProp)) {
+                                    prop.setOtherSide(referencedProp);
                                     break;
                                 }
                             }                    		
@@ -114,6 +115,15 @@ public static void configureDomainClassRelationships(GrailsClass[] domainClasses
         }
     }
 
+    private static boolean isCandidateForOtherSide(GrailsDomainClass domainClass, GrailsDomainClassProperty prop, GrailsDomainClassProperty referencedProp) {
+        boolean isTypeCompatible = domainClass.getClazz().equals(referencedProp.getReferencedPropertyType());
+        Map mappedBy = domainClass.getMappedBy();
+
+        Object propertyMapping = mappedBy.get(prop.getName());
+        return !(propertyMapping != null && !propertyMapping.equals(referencedProp.getName())) && isTypeCompatible;
+
+    }
+
     /**
      * Returns the ORM frameworks mapping file name for the specified class name
      * 

src/persistence/org/codehaus/groovy/grails/orm/hibernate/GrailsHibernateDomainClass.java

@@ -214,6 +214,10 @@ public boolean hasSubClasses() {
         return false;  
     }
 
+    public Map getMappedBy() {
+        return Collections.EMPTY_MAP;
+    }
+
     public boolean isOneToMany(String propertyName) {
 	GrailsDomainClassProperty prop = getPropertyByName(propertyName);
 	return prop != null && prop.isOneToMany();

test/groovy/org/codehaus/groovy/grails/orm/hibernate/ManyToManyAndOneToOneTests.groovy

@@ -0,0 +1,57 @@
+/**
+ * Tests a many-to-many and one-to-one relationship used together
+
+ * @author Graeme Rocher
+ * @since 1.0
+ * 
+ * Created: Oct 12, 2007
+ */
+package org.codehaus.groovy.grails.orm.hibernate
+
+import org.codehaus.groovy.grails.commons.GrailsDomainClass
+
+class ManyToManyAndOneToOneTests extends AbstractGrailsHibernateTests {
+
+    protected void onSetUp() {
+        gcl.parseClass('''
+class Book {
+    Long version
+    Long id
+    static belongsTo = Author
+    Set authors
+    
+    static hasMany = [authors:Author]
+    static mappedBy = [authors:"books"]
+    String title
+}
+class Author {
+    Long version
+    Long id
+
+    Set books
+    static hasMany = [books:Book]
+    static mappedBy = [books:"authors"]
+    String name
+    Book bookOther
+}
+        ''')
+    }
+
+    void testDomain() {
+        GrailsDomainClass bookClass = ga.getDomainClass("Book")
+        GrailsDomainClass authorClass = ga.getDomainClass("Author")
+        assert authorClass
+        assertTrue authorClass.getPropertyByName("bookOther").isOneToOne()
+        assertTrue authorClass.getPropertyByName("books").isManyToMany()
+        assertEquals "authors",authorClass.getPropertyByName("books").otherSide.name
+        assertFalse authorClass.getPropertyByName("bookOther").isBidirectional()
+
+        assert bookClass
+        assert bookClass.getPropertyByName("authors").isManyToMany()
+        assertEquals "books",bookClass.getPropertyByName("authors").otherSide.name
+
+
+
+    }
+
+}