GORM should not check Entity's dirtiness on formula and transient type of properties (#1697)

Author: aulea

grails-datastore-gorm-test/src/test/groovy/org/grails/datastore/gorm/DirtyCheckingSpec.groovy

@@ -0,0 +1,73 @@
+import grails.gorm.annotation.Entity
+import grails.gorm.tests.GormDatastoreSpec
+
+class DirtyCheckingSpec extends GormDatastoreSpec {
+    
+    void "When marking whole class dirty, then derived and transient properties are still not dirty"() {
+        when:
+        TestBook book = new TestBook()
+        book.title = "Test"
+        and: "mark class as not dirty - to clear previous dirty tracking"
+        book.trackChanges()
+
+        then:
+        !book.hasChanged()
+
+        when: "Mark whole class as dirty"
+        book.markDirty()
+
+        then: "whole class is dirty"
+        book.hasChanged()
+
+        and: "The formula and transient properties are not dirty"
+        !book.hasChanged('formulaProperty')
+        !book.hasChanged('transientProperty')
+        
+        and: "Other properties are"
+        book.hasChanged('id')
+        book.hasChanged('title')
+
+    }
+
+    void "Test that dirty tracking doesn't apply on Entity's transient properties"() {
+        when:
+        TestBook book = new TestBook()
+        book.title = "Test"
+        and: "mark class as not dirty, clear previous dirty tracking"
+        book.trackChanges()
+
+        then:
+        !book.hasChanged()
+
+        when: "update transient property"
+        book.transientProperty = "new transient value"
+
+        then: "class is not dirty"
+        !book.hasChanged()
+
+        and: "transient properties are not dirty"
+        !book.hasChanged('transientProperty')
+    }
+
+    @Override
+    List getDomainClasses() {
+        [TestBook]
+    }
+}
+
+@Entity
+class TestBook implements Serializable {
+
+    Long id
+    String title
+
+    String formulaProperty
+
+    String transientProperty
+    
+    static mapping = {
+        formulaProperty(formula: 'name || \' (formula)\'')
+    }
+    
+    static transients = ['transientProperty']
+}

grails-datastore-gorm/src/main/groovy/org/grails/compiler/gorm/DirtyCheckingTransformer.groovy

@@ -69,18 +69,24 @@ class DirtyCheckingTransformer implements CompilationUnitAware {
         this.compilationUnit = compilationUnit
     }
 
-    void performInjectionOnAnnotatedClass(SourceUnit source, ClassNode classNode) {
+    void performInjectionOnAnnotatedClass(SourceUnit source, ClassNode classNode, Class traitToInject = DirtyCheckable) {
         // First add a local field that will store the change tracking state. The field is a simple list of property names that have changed
         // the field is only added to root clauses that extend from java.lang.Object
-        final ClassNode changeTrackableClassNode = new ClassNode(DirtyCheckable).getPlainNodeReference()
+        final ClassNode changeTrackableClassNode = new ClassNode(traitToInject).getPlainNodeReference()
+        if (traitToInject != DirtyCheckable) {
+            changeTrackableClassNode.setSuperClass(new ClassNode(DirtyCheckable).getPlainNodeReference())
+        }
         final MethodNode markDirtyMethodNode = changeTrackableClassNode.getMethod(METHOD_NAME_MARK_DIRTY, new Parameter(ClassHelper.STRING_TYPE, "propertyName"), new Parameter(ClassHelper.OBJECT_TYPE, "newValue"))
 
 
         ClassNode superClass = classNode.getSuperClass()
         boolean shouldWeave = superClass.equals(OBJECT_CLASS_NODE)
 
-        ClassNode dirtyCheckableTrait = ClassHelper.make(DirtyCheckable).getPlainNodeReference()
-
+        ClassNode dirtyCheckableTrait = ClassHelper.make(traitToInject).getPlainNodeReference()
+        if (traitToInject != DirtyCheckable) {
+            dirtyCheckableTrait.setSuperClass(new ClassNode(DirtyCheckable).getPlainNodeReference())
+        }
+        
         while(!shouldWeave) {
             if(isDomainClass(superClass) || !superClass.getAnnotations(DIRTY_CHECK_CLASS_NODE).isEmpty()) {
                 break

grails-datastore-gorm/src/main/groovy/org/grails/compiler/gorm/GormEntityTransformation.groovy

@@ -56,6 +56,7 @@ import org.codehaus.groovy.transform.AbstractASTTransformation
 import org.codehaus.groovy.transform.GroovyASTTransformation
 import org.grails.datastore.gorm.GormEnhancer
 import org.grails.datastore.gorm.GormEntity
+import org.grails.datastore.gorm.GormEntityDirtyCheckable
 import org.grails.datastore.gorm.query.GormQueryOperations
 import org.grails.datastore.mapping.model.config.GormProperties
 import org.grails.datastore.mapping.reflect.AstUtils
@@ -240,7 +241,7 @@ class GormEntityTransformation extends AbstractASTTransformation implements Comp
 
         // now apply dirty checking behavior
         def dirtyCheckTransformer = new DirtyCheckingTransformer()
-        dirtyCheckTransformer.performInjectionOnAnnotatedClass(sourceUnit, classNode)
+        dirtyCheckTransformer.performInjectionOnAnnotatedClass(sourceUnit, classNode, GormEntityDirtyCheckable)
 
 
         // convert the methodMissing and propertyMissing implementations to $static_methodMissing and $static_propertyMissing for the static versions

grails-datastore-gorm/src/main/groovy/org/grails/datastore/gorm/GormEntityDirtyCheckable.groovy

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2014 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.grails.datastore.gorm
+
+import groovy.transform.CompileStatic
+import groovy.util.logging.Slf4j
+import org.grails.datastore.mapping.config.Property
+import org.grails.datastore.mapping.dirty.checking.DirtyCheckable
+import org.grails.datastore.mapping.model.PersistentEntity
+import org.grails.datastore.mapping.model.PersistentProperty
+
+import javax.annotation.Generated
+
+/**
+ *
+ * Special trait meant only for GORM entities to override default behaviour of DirtyCheckable.
+ * Applied manually during GormEntity transformation
+ *
+ * @since 7.3
+ */
+@CompileStatic
+trait GormEntityDirtyCheckable extends DirtyCheckable {
+    
+    @Override
+    @Generated
+    boolean hasChanged(String propertyName) {
+        PersistentEntity entity = currentGormInstanceApi().persistentEntity
+        
+        PersistentProperty persistentProperty = entity.getPropertyByName(propertyName)
+        if (!persistentProperty) {
+            // Not persistent property, transient. We don't track changes for transients 
+            return false
+        }
+        
+        Property propertyMapping = persistentProperty.getMapping().getMappedForm() 
+        if (propertyMapping.derived) {
+            // Derived property cannot be changed, ex. sql formula
+            return false
+        }
+
+        return super.hasChanged(propertyName)
+    }
+
+    @Generated
+    private GormInstanceApi currentGormInstanceApi() {
+        (GormInstanceApi) GormEnhancer.findInstanceApi(getClass())
+    }
+}