plugins {
    id 'groovy'
}

repositories {
    jcenter()
}

dependencies {
    implementation 'org.codenarc:CodeNarc:1.4' (1)
    testCompile 'junit:junit:4.12'
}

codenarcMain.dependsOn ':codenarc-rule:jar' (1)

tasks.withType(CodeNarc) { (2)
    codenarcClasspath += files("${rootProject.projectDir}/codenarc-rule/build/libs/codenarc-rule.jar")
}

package org.codenarc.rule.grails

import groovy.transform.CompileStatic
import org.codehaus.groovy.ast.AnnotatedNode
import org.codehaus.groovy.ast.AnnotationNode
import org.codehaus.groovy.ast.ImportNode
import org.codehaus.groovy.ast.ModuleNode
import org.codenarc.rule.AbstractAstVisitor
import org.codenarc.rule.AbstractAstVisitorRule

@CompileStatic
class GrailsTransactionalRule extends AbstractAstVisitorRule { (1)
    int priority = 2 (2)
    String name = 'GrailsTransactional' (3)
    Class astVisitorClass = GrailsTransactionalVisitor (4)
}

@CompileStatic
class GrailsTransactionalVisitor extends AbstractAstVisitor { (5)

    private static final String SPRING_TRANSACTIONAL = 'org.springframework.transaction.annotation.Transactional'
    private static final String ERROR_MSG = 'Do not use Spring @Transactional, use @grails.gorm.transactions.Transactional instead'

    @Override
    void visitAnnotations(AnnotatedNode node) { (6)
        node.annotations.each { AnnotationNode annotationNode ->
            String annotation = annotationNode.classNode.text
            if (annotation == SPRING_TRANSACTIONAL) {
                addViolation(node, ERROR_MSG)
            }
        }

        super.visitAnnotations(node)
    }

    @Override
    void visitImports(ModuleNode node) { (7)
        node.imports.each { ImportNode importNode ->
            String importClass = importNode.className

            if (importClass == SPRING_TRANSACTIONAL) {
                node.lineNumber = importNode.lineNumber (8)
                addViolation(node, ERROR_MSG)
            }
        }

        super.visitImports(node)
    }
}

package org.codenarc.rule.grails

import org.codenarc.rule.AbstractRuleTestCase
import org.codenarc.rule.Rule
import org.codenarc.rule.Violation
import org.junit.Test

class GrailsTransactionalRuleTest extends AbstractRuleTestCase { (1)

    @Override
    protected Rule createRule() { (2)
        return new GrailsTransactionalRule()
    }

    @Test
    void testGrailsTransactionalIsAllowedOnClassWithImport() {
        final SOURCE = ''' (3)
            import grails.gorm.transactions.Transactional

            @Transactional
            class TestService {
            }
        '''

        assertNoViolations(SOURCE) (4)
    }

    @Test
    void testGrailsTransactionalIsAllowedOnClassWithFullpackageAnnotation() {
        final SOURCE = '''
            @grails.gorm.transactions.Transactional
            class TestService {
            }
        '''

        assertNoViolations(SOURCE)
    }

    @Test
    void testGrailsTransactionalIsAllowedOnMethodWithImport() {
        final SOURCE = '''
            import grails.gorm.transactions.Transactional

            class TestService {
                @Transactional
                void foo() {
                }
            }
        '''

        assertNoViolations(SOURCE)
    }

    @Test
    void testGrailsTransactionalIsAllowedOnMethodWithFullpackageAnnotation() {
        final SOURCE = '''
            class TestService {
                @grails.gorm.transactions.Transactional
                void foo() {
                }
            }
        '''

        assertNoViolations(SOURCE)
    }

    @Test
    void testSpringTransactionalIsNotAllowedOnClassWithImport() {
        final SOURCE = '''
            import org.springframework.transaction.annotation.Transactional

            @Transactional
            class TestService {
            }
        '''

        (5)
        assertSingleViolation(SOURCE) { Violation violation ->
            violation.rule.priority == 2 &&
            violation.rule.name == 'GrailsTransactional'
        }
    }

    @Test
    void testSpringTransactionalIsNotAllowedOnClassWithFullpackageAnnotation() {
        final SOURCE = '''
            @org.springframework.transaction.annotation.Transactional
            class TestService {
            }
        '''

        assertSingleViolation(SOURCE) { Violation violation ->
            violation.rule.priority == 2 &&
            violation.rule.name == 'GrailsTransactional'
        }
    }

    @Test
    void testSpringTransactionalIsNotAllowedOnMethodWithImport() {
        final SOURCE = '''
            import org.springframework.transaction.annotation.Transactional

            class TestService {
                @Transactional
                void foo() {
                }
            }
        '''

        assertSingleViolation(SOURCE) { Violation violation ->
            violation.rule.priority == 2 &&
                violation.rule.name == 'GrailsTransactional'
        }
    }

    @Test
    void testSpringTransactionalIsNotAllowedOnMethodWithFullpackageAnnotation() {
        final SOURCE = '''
            class TestService {
                @org.springframework.transaction.annotation.Transactional
                void foo() {
                }
            }
        '''

        assertSingleViolation(SOURCE) { Violation violation ->
            violation.rule.priority == 2 &&
                violation.rule.name == 'GrailsTransactional'
        }
    }
}