Simplify class interception

Author: Willem1987

src/main/groovy/com/lesfurets/jenkins/unit/InterceptingGCL.groovy

@@ -12,7 +12,7 @@ class InterceptingGCL extends GroovyClassLoader {
         metaClazz.static.invokeMethod = helper.getMethodInterceptor()
         metaClazz.methodMissing = helper.getMethodMissingInterceptor()
         metaClazz.propertyMissing = helper.getPropertyMissingInterceptor()
-        metaClazz.getEnv = {return binding.env}
+        metaClazz.getEnv = { return binding.env }
         // find and replace script method closure with any matching allowed method closure
         metaClazz.methods.forEach { scriptMethod ->
             def signature = method(scriptMethod.name, scriptMethod.nativeParameterTypes)
@@ -67,10 +67,7 @@ class InterceptingGCL extends GroovyClassLoader {
             return super.loadClass(name)
         }
 
-        // Copy from this.parseClass(GroovyCodeSource, boolean)
-        cls.metaClass.invokeMethod = helper.getMethodInterceptor()
-        cls.metaClass.static.invokeMethod = helper.getMethodInterceptor()
-        cls.metaClass.methodMissing = helper.getMethodMissingInterceptor()
+        interceptClassMethods(cls.metaClass, helper, binding)
 
         return cls;
     }

src/main/groovy/com/lesfurets/jenkins/unit/PipelineTestHelper.groovy

@@ -183,9 +183,9 @@ class PipelineTestHelper {
             return callClosure(intercepted.value, args)
         }
         // if not search for the method declaration
-        MetaMethod m = delegate.metaClass.getMetaMethod(name, args)
+        MetaMethod metaMethod = delegate.metaClass.getMetaMethod(name, args)
         // ...and call it. If we cannot find it, delegate call to methodMissing
-        def result = (m ? this.callMethod(m, delegate, args) : delegate.metaClass.invokeMissingMethod(delegate, name, args))
+         def result = (metaMethod ? this.callMethod(metaMethod, delegate, args) : delegate.metaClass.invokeMissingMethod(delegate, name, args))
         return result
     }
 
@@ -233,6 +233,9 @@ class PipelineTestHelper {
     }
 
     def propertyMissingInterceptor = { String propertyName ->
+        if(binding.hasVariable(propertyName)){
+            return binding.getVariable(propertyName)
+        }
         if (binding.hasVariable("params") && (binding.getVariable("params") as Map).containsKey(propertyName)) {
             return (binding.getVariable("params") as Map).get(propertyName)
         }

src/main/groovy/com/lesfurets/jenkins/unit/declarative/AgentDeclaration.groovy

@@ -4,9 +4,7 @@ import com.lesfurets.jenkins.unit.declarative.agent.DockerAgentDeclaration
 import com.lesfurets.jenkins.unit.declarative.agent.KubernetesAgentDeclaration
 import groovy.transform.ToString
 
-import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.createComponent
 import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.executeWith
-import static groovy.lang.Closure.DELEGATE_FIRST
 
 @ToString(includePackage = false, includeNames = true, ignoreNulls = true)
 class AgentDeclaration {
@@ -23,7 +21,7 @@ class AgentDeclaration {
         this.label = label
     }
 
-    def node(@DelegatesTo(AgentDeclaration) Closure closure) {
+    def node(Closure closure) {
         closure.call()
     }
 
@@ -36,34 +34,37 @@ class AgentDeclaration {
     }
 
     def docker(String image) {
-        this.docker({ -> this.image = image })
+        this.docker = new DockerAgentDeclaration().with{  da -> da.image = image; da }
     }
 
-    def docker(@DelegatesTo(strategy = DELEGATE_FIRST, value = DockerAgentDeclaration) Closure closure) {
-        this.docker = createComponent(DockerAgentDeclaration, closure)
+    def docker(Closure closure) {
+        this.docker = new DockerAgentDeclaration();
+        executeWith(this.docker, closure);
     }
 
     def kubernetes(Object kubernetesAgent) {
         this.@kubernetes = kubernetesAgent as KubernetesAgentDeclaration
     }
 
-    def kubernetes(@DelegatesTo(strategy = DELEGATE_FIRST, value = KubernetesAgentDeclaration) Closure closure) {
-        this.@kubernetes = createComponent(KubernetesAgentDeclaration, closure)
+    def kubernetes(Closure closure) {
+        this.@kubernetes = new KubernetesAgentDeclaration();
+        def kubernetesDecl = this.@kubernetes
+        executeWith(kubernetesDecl, closure)
     }
 
     def dockerfile(boolean dockerfile) {
         this.dockerfile = dockerfile
     }
 
-    def dockerfile(@DelegatesTo(AgentDeclaration) Closure closure) {
+    def dockerfile(Closure closure) {
         closure.call()
     }
 
     def dir(String dir) {
         this.dockerfileDir = dir
     }
 
-    def execute(Object delegate) {
+    def execute(Script script) {
         def agentDesc = null
 
         if (label) {
@@ -84,6 +85,6 @@ class AgentDeclaration {
         else {
             throw new IllegalStateException("No agent description found")
         }
-        executeWith(delegate, { echo "Executing on agent $agentDesc" })
+        executeWith(script, { echo "Executing on agent $agentDesc" })
     }
 }

src/main/groovy/com/lesfurets/jenkins/unit/declarative/AnyOfDeclaration.groovy

@@ -1,7 +1,5 @@
 package com.lesfurets.jenkins.unit.declarative
 
-import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.executeWith
-
 class AnyOfDeclaration extends WhenDeclaration {
 
     List<String> branches = []
@@ -18,24 +16,24 @@ class AnyOfDeclaration extends WhenDeclaration {
     def expressions(delegate) {
         def exp_result;
         for (def exp in this.expressions) {
-            exp_result = executeWith(delegate, exp)
+            exp_result = exp.call()
             if (exp_result) {
                 return true
             }
         }
         return false
     }
 
-    Boolean execute(Object delegate) {
+    Boolean execute(Script script) {
         boolean br = false;
         boolean exp = false;
 
         if (this.branches.size() > 0) {
-            br = this.branches.contains(delegate.env.BRANCH_NAME)
+            br = this.branches.contains(script.env.BRANCH_NAME)
         }
 
         if (this.expressions.size() > 0) {
-            exp = expressions(delegate)
+            exp = expressions(script)
         }
 
         return exp || br

src/main/groovy/com/lesfurets/jenkins/unit/declarative/DeclarativePipeline.groovy

@@ -1,7 +1,5 @@
 package com.lesfurets.jenkins.unit.declarative
 
-import static groovy.lang.Closure.*
-
 class DeclarativePipeline extends GenericPipelineDeclaration {
 
     def properties = [:]
@@ -24,33 +22,37 @@ class DeclarativePipeline extends GenericPipelineDeclaration {
         }
     }
 
-    def options(@DelegatesTo(DeclarativePipeline) Closure closure) {
+    def options(Closure closure) {
         options.add(closure)
     }
 
-    def triggers(@DelegatesTo(DeclarativePipeline) Closure closure) {
+    def triggers(Closure closure) {
         this.triggers = closure
     }
 
     def parameters(Object o) {
         this.parameters = new ParametersDeclaration().with { it.label = o; it }
     }
 
-    def parameters(@DelegatesTo(strategy=DELEGATE_FIRST, value=ParametersDeclaration) Closure closure) {
-        this.parameters = createComponent(ParametersDeclaration, closure)
+    def parameters(Closure closure) {
+        this.parameters = new ParametersDeclaration()
+        this.parameters.binding = closure.binding;
+        executeWith(this.parameters, closure)
     }
 
-    def execute(Object delegate) {
-        super.execute(delegate)
+    def execute(Script script) {
+        super.execute(script)
         this.options.forEach {
-            executeWith(delegate, it)
+            executeWith(script, it)
+        }
+        this.agent?.execute(script)
+        if (this.triggers) {
+            executeWith(script, this.triggers)
         }
-        this.agent?.execute(delegate)
-        executeWith(delegate, this.triggers)
         this.stages.entrySet().forEach { e ->
-            e.value.execute(delegate)
+            e.value.execute(script)
         }
-        this.post?.execute(delegate)
+        this.post?.execute(script)
     }
 
 }

src/main/groovy/com/lesfurets/jenkins/unit/declarative/DeclarativePipelineTest.groovy

@@ -8,22 +8,25 @@ import static com.lesfurets.jenkins.unit.MethodSignature.method
 abstract class DeclarativePipelineTest extends BasePipelineTest {
 
     def pipelineInterceptor = { Closure closure ->
-        GenericPipelineDeclaration.binding = binding
-        GenericPipelineDeclaration.createComponent(DeclarativePipeline, closure).execute(delegate)
+        def declarativePipeline = new DeclarativePipeline()
+        def rehydratedPipelineCl = closure.rehydrate(declarativePipeline, closure.owner, closure)
+        rehydratedPipelineCl.resolveStrategy
+        rehydratedPipelineCl.call();
+        declarativePipeline.execute(closure.owner)
     }
 
     def paramInterceptor = { Map desc ->
         addParam(desc.name, desc.defaultValue, false)
     }
 
-    def stringInterceptor = { Map desc->
+    def stringInterceptor = { Map desc ->
         if (desc) {
             // we are in context of paremetes { string(...)}
             if (desc.name) {
                 addParam(desc.name, desc.defaultValue, false)
             }
             // we are in context of withCredentaials([string()..]) { }
-            if(desc.variable) {
+            if (desc.variable) {
                 return desc.variable
             }
         }

src/main/groovy/com/lesfurets/jenkins/unit/declarative/GenericPipelineDeclaration.groovy

@@ -1,34 +1,20 @@
 package com.lesfurets.jenkins.unit.declarative
 
-
-import static groovy.lang.Closure.DELEGATE_FIRST
-
 abstract class GenericPipelineDeclaration {
 
     AgentDeclaration agent
     Closure environment
     Closure tools
     PostDeclaration post
     Map<String, StageDeclaration> stages = [:]
-    static def binding = null
-
-    static <T> T createComponent(Class<T> componentType, @DelegatesTo(strategy = DELEGATE_FIRST) Closure<T> closure) {
-        // declare componentInstance as final to prevent any multithreaded issues, since it is used inside closure
-        final def componentInstance = componentType.newInstance()
-        def rehydrate = closure.rehydrate(closure, componentInstance, componentInstance)
-        if (binding && componentInstance.hasProperty('binding') && componentInstance.binding != binding) {
-            componentInstance.binding = binding
-        }
-        rehydrate.call()
-        return componentInstance
-    }
 
-    static <T> T executeWith(@DelegatesTo.Target Object delegate,
-                             @DelegatesTo(strategy = DELEGATE_FIRST) Closure<T> closure) {
+    static <T> T executeWith(Object delegate, Closure<T> closure, Integer resolveStrategy = Closure.DELEGATE_FIRST) {
         if (closure) {
-            def cl = closure.rehydrate(delegate, delegate, delegate)
-            cl.resolveStrategy = DELEGATE_FIRST
-            return cl.call()
+            closure.delegate = delegate;
+            if(resolveStrategy) {
+                closure.resolveStrategy = resolveStrategy
+            }
+            closure.call()
         }
         return null
     }
@@ -37,8 +23,9 @@ abstract class GenericPipelineDeclaration {
         this.agent = new AgentDeclaration().with { it.label = o; it }
     }
 
-    def agent(@DelegatesTo(strategy = DELEGATE_FIRST, value = AgentDeclaration) Closure closure) {
-        this.agent = createComponent(AgentDeclaration, closure)
+    def agent(Closure closure) {
+        this.@agent = new AgentDeclaration();
+        executeWith(this.@agent, closure)
     }
 
     def environment(Closure closure) {
@@ -49,27 +36,29 @@ abstract class GenericPipelineDeclaration {
         this.tools = closure
     }
 
-    def post(@DelegatesTo(strategy = DELEGATE_FIRST, value = PostDeclaration) Closure closure) {
-        this.post = createComponent(PostDeclaration, closure)
+    def post(Closure closure) {
+        this.post = new PostDeclaration();
+        executeWith(this.post, closure)
     }
 
-    def stages(@DelegatesTo(DeclarativePipeline) Closure closure) {
+    def stages(Closure closure) {
         closure.call()
     }
 
-    def stage(String stageName,
-              @DelegatesTo(strategy = DELEGATE_FIRST, value = StageDeclaration) Closure closure) {
-        this.stages.put(stageName, createComponent(StageDeclaration, closure).with { it.name = stageName; it })
+    def stage(String stageName, Closure closure) {
+        def stageDeclaration = new StageDeclaration(stageName)
+        executeWith(stageDeclaration, closure);
+        this.stages.put(stageName, stageDeclaration)
     }
 
-    def execute(Object delegate) {
+    def execute(Script script) {
         Map envValuestoRestore = [:]
 
         // set environment
         if (this.environment) {
-            envValuestoRestore = initEnvironment(this.environment, delegate)
+            envValuestoRestore = initEnvironment(this.environment, script)
         }
-        resetEnvironment(envValuestoRestore, delegate)
+        resetEnvironment(envValuestoRestore, script)
     }
 
     public static Map initEnvironment(Closure environment, Object delegate) {
@@ -85,12 +74,12 @@ abstract class GenericPipelineDeclaration {
             (delegate.env as Map).put(propertyName, newValue)
         }
         def envClosure = environment.rehydrate(subBinding, delegate, this)
-        envClosure.resolveStrategy = DELEGATE_FIRST
+        envClosure.resolveStrategy = Closure.DELEGATE_FIRST
         envClosure.call()
         return envValuestoRestore
     }
 
-    public static resetEnvironment(LinkedHashMap envValuestoRestore, delegate) {
+    public static resetEnvironment(Map envValuestoRestore, Object delegate) {
         envValuestoRestore.entrySet().forEach { entry ->
             def envMap = delegate.env as Map
             envMap.put(entry.getKey(), entry.getValue())

src/main/groovy/com/lesfurets/jenkins/unit/declarative/NotDeclaration.groovy

@@ -2,8 +2,8 @@ package com.lesfurets.jenkins.unit.declarative
 
 class NotDeclaration extends WhenDeclaration {
 
-    Boolean execute(Object delegate) {
-        return !super.execute(delegate)
+    Boolean execute(Script script) {
+        return !super.execute(script)
     }
 }
 

src/main/groovy/com/lesfurets/jenkins/unit/declarative/ParallelDeclaration.groovy

@@ -1,8 +1,5 @@
 package com.lesfurets.jenkins.unit.declarative
 
-import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.createComponent
-import static groovy.lang.Closure.DELEGATE_FIRST
-
 class ParallelDeclaration {
 
     Map<String, StageDeclaration> stages = [:]
@@ -16,14 +13,15 @@ class ParallelDeclaration {
         this.failFast = false
     }
 
-    def stage(String name,
-              @DelegatesTo(strategy = DELEGATE_FIRST, value = StageDeclaration) Closure closure) {
-        this.stages.put(name, createComponent(StageDeclaration, closure).with{it.name = name;it} )
+    def stage(String name, Closure closure) {
+        def stageDeclaration = new StageDeclaration(name);
+        GenericPipelineDeclaration.executeWith(stageDeclaration, closure);
+        this.stages.put(name, stageDeclaration)
     }
 
-    def execute(Object delegate) {
+    def execute(Script script) {
         this.stages.entrySet().forEach { e ->
-            e.value.execute(delegate)
+            e.value.execute(script)
         }
     }