Simplify class interception

Willem1987 · Willem1987 · commit 6681845a0306 · 2021-06-07T20:24:41.000+02:00
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/InterceptingGCL.groovy b/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;
     }
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/AgentDeclaration.groovy b/src/main/groovy/com/lesfurets/jenkins/unit/declarative/AgentDeclaration.groovy
@@ -4,6 +4,8 @@ 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.executeWith
+
 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
@@ -63,7 +65,7 @@ class AgentDeclaration {
         this.dockerfileDir = dir
     }
 
-    def execute(Object delegate) {
+    def execute(Script script) {
         def agentDesc = null
 
         if (label) {
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/AnyOfDeclaration.groovy b/src/main/groovy/com/lesfurets/jenkins/unit/declarative/AnyOfDeclaration.groovy
@@ -26,16 +26,16 @@ class AnyOfDeclaration extends WhenDeclaration {
         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
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/DeclarativePipeline.groovy b/src/main/groovy/com/lesfurets/jenkins/unit/declarative/DeclarativePipeline.groovy
@@ -40,17 +40,17 @@ class DeclarativePipeline extends GenericPipelineDeclaration {
         this.parameters = createComponent(ParametersDeclaration, closure)
     }
 
-    def execute(Object delegate) {
-        super.execute(delegate)
+    def execute(Script script) {
+        super.execute(script)
         this.options.forEach {
             executeWith(delegate, it)
         }
         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)
     }
 
 }
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/GenericPipelineDeclaration.groovy b/src/main/groovy/com/lesfurets/jenkins/unit/declarative/GenericPipelineDeclaration.groovy
@@ -62,14 +62,14 @@ abstract class GenericPipelineDeclaration {
         this.stages.put(stageName, createComponent(StageDeclaration, closure).with { it.name = stageName; it })
     }
 
-    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) {
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/NotDeclaration.groovy b/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)
     }
 }
 
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/ParallelDeclaration.groovy b/src/main/groovy/com/lesfurets/jenkins/unit/declarative/ParallelDeclaration.groovy
@@ -21,9 +21,9 @@ class ParallelDeclaration {
         this.stages.put(name, createComponent(StageDeclaration, closure).with{it.name = name;it} )
     }
 
-    def execute(Object delegate) {
+    def execute(Script script) {
         this.stages.entrySet().forEach { e ->
-            e.value.execute(delegate)
+            e.value.execute(script)
         }
     }
 
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/PostDeclaration.groovy b/src/main/groovy/com/lesfurets/jenkins/unit/declarative/PostDeclaration.groovy
@@ -1,5 +1,7 @@
 package com.lesfurets.jenkins.unit.declarative
 
+import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.executeWith
+
 import static com.lesfurets.jenkins.unit.declarative.DeclarativePipeline.executeWith
 
 class PostDeclaration {
@@ -55,9 +57,9 @@ class PostDeclaration {
         this.regression = closure
     }
 
-    def execute(Object delegate) {
-        def currentBuild = delegate.currentBuild.result
-        def previousBuild = delegate.currentBuild?.previousBuild?.result
+    def execute(Script script) {
+        def currentBuild = script.currentBuild.result
+        def previousBuild = script.currentBuild?.previousBuild?.result
         if (this.always) {
             executeWith(delegate, this.always)
         }
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/StageDeclaration.groovy b/src/main/groovy/com/lesfurets/jenkins/unit/declarative/StageDeclaration.groovy
@@ -37,7 +37,7 @@ class StageDeclaration extends GenericPipelineDeclaration {
         options.add(closure)
     }
 
-    def execute(Object delegate) {
+    def execute(Script script) {
         String name = this.name
         this.options.each {
             executeWith(delegate, it)
@@ -51,27 +51,33 @@ class StageDeclaration extends GenericPipelineDeclaration {
             return
         }
 
-        if (!when || when.execute(delegate)) {
+        if (!when || when.execute(script)) {
             Map envValuestoRestore = [:]
 
             // set environment
             if (this.environment) {
-                envValuestoRestore = initEnvironment(this.environment, delegate)
+                envValuestoRestore = initEnvironment(this.environment, script)
             }
 
             // TODO handle credentials
             this.stages.entrySet().forEach { stageEntry ->
-                stageEntry.value.execute(delegate)
+                stageEntry.value.execute(script)
             }
-            if(steps) {
-                Closure stageBody = { agent?.execute(delegate) } >> steps.rehydrate(delegate, this, this)
-                Closure cl = { stage("$name", stageBody) }
-                executeWith(delegate, cl)
+            if (steps) {
+                Closure rehydratedSteps = steps.rehydrate(script, this, steps);
+                rehydratedSteps.setResolveStrategy(Closure.DELEGATE_FIRST)
+                Closure stageBody = {
+                    agent?.execute(script)
+                } >> rehydratedSteps
+                Closure cl = {
+                    stage("$name", stageBody)
+                }
+                executeWith(script, cl, Closure.DELEGATE_ONLY)
             }
             if (post) {
-                this.post.execute(delegate)
+                this.post.execute(script)
             }
-            resetEnvironment(envValuestoRestore, delegate)
+            resetEnvironment(envValuestoRestore, script)
         } else {
             executeWith(delegate, { echo "Skipping stage $name" })
         }
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/WhenDeclaration.groovy b/src/main/groovy/com/lesfurets/jenkins/unit/declarative/WhenDeclaration.groovy
@@ -2,6 +2,8 @@ package com.lesfurets.jenkins.unit.declarative
 
 import java.util.regex.Pattern
 
+import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.executeWith
+
 import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.createComponent
 import static groovy.lang.Closure.DELEGATE_FIRST
 
@@ -48,7 +50,7 @@ class WhenDeclaration {
         this.expressionCondition = closure
     }
 
-    Boolean execute(Object delegate) {
+    Boolean execute(Script script) {
         boolean expressionCheck = true
         boolean branchCheck = true
         boolean tagCheck = true
@@ -57,26 +59,26 @@ class WhenDeclaration {
         boolean notCheck = true
 
         if (anyOfCondition) {
-            anyOfCheck = anyOfCondition.execute(delegate)
+            anyOfCheck = anyOfCondition.execute(script)
         }
         if (notCondition) {
-            notCheck = notCondition.execute(delegate)
+            notCheck = notCondition.execute(script)
         }
         if (expressionCondition) {
             expressionCheck = executeWith(delegate, expressionCondition)
         }
         if (branchCondition) {
-            branchCheck = this.branchCondition == delegate.env.BRANCH_NAME
+            branchCheck = this.branchCondition == script.env.BRANCH_NAME
         }
         if (buildingTagCondition) {
-            tagCheck = delegate.env.containsKey(TAG_NAME)
+            tagCheck = script.env.containsKey(TAG_NAME)
         }
         if (tagCondition) {
-            tagCheck = delegate.env.TAG_NAME =~ tagCondition
+            tagCheck = script.env.TAG_NAME =~ tagCondition
         }
         if (environmentCondition && !(environmentCondition as Map)?.isEmpty()) {
             environmentCondition.entrySet().forEach { e ->
-                envCheck = envCheck && (delegate.env."${e.key}" == e.value)
+                envCheck = envCheck && (script.env."${e.key}" == e.value)
             }
         }
 
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/agent/KubernetesAgentDeclaration.groovy b/src/main/groovy/com/lesfurets/jenkins/unit/declarative/agent/KubernetesAgentDeclaration.groovy
@@ -6,9 +6,8 @@ import com.lesfurets.jenkins.unit.declarative.kubernetes.WorkspaceVolumeDeclarat
 import groovy.transform.Memoized
 import groovy.transform.ToString
 
-import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.createComponent
+import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.executeWith
 import static com.lesfurets.jenkins.unit.declarative.ObjectUtils.printNonNullProperties
-import static groovy.lang.Closure.DELEGATE_FIRST
 
 @ToString(includePackage = false, includeNames = true, ignoreNulls = true)
 class KubernetesAgentDeclaration {
@@ -87,13 +86,16 @@ class KubernetesAgentDeclaration {
         this.podRetention = podRetention
     }
 
-    def containerTemplate(@DelegatesTo(strategy = DELEGATE_FIRST, value = ContainerTemplateDeclaration) Closure closure) {
-        this.containerTemplate = createComponent(ContainerTemplateDeclaration, closure)
+    def containerTemplate(Closure closure) {
+        this.containerTemplate = new ContainerTemplateDeclaration();
+        executeWith(this.containerTemplate, closure)
     }
 
-    def containerTemplates(@DelegatesTo(strategy = DELEGATE_FIRST, value = ContainerTemplateDeclaration) List<Closure> closures) {
-        this.containerTemplates = closures.each { ct ->
-            return createComponent(ContainerTemplateDeclaration, ct)
+    def containerTemplates(List<Closure> closures) {
+        this.containerTemplates = closures.collect { ctClosure ->
+            def containerTemplateDeclaration = new ContainerTemplateDeclaration();
+            executeWith(containerTemplateDeclaration, ctClosure)
+            return containerTemplateDeclaration;
         } as List<ContainerTemplateDeclaration>
     }
 
@@ -113,8 +115,9 @@ class KubernetesAgentDeclaration {
         this.yamlMergeStrategy = yamlMergeStrategy
     }
 
-    def workspaceVolume(@DelegatesTo(strategy = DELEGATE_FIRST, value = WorkspaceVolumeDeclaration) Closure closure) {
-        this.workspaceVolume = createComponent(WorkspaceVolumeDeclaration, closure)
+    def workspaceVolume(Closure closure) {
+        this.workspaceVolume = new WorkspaceVolumeDeclaration();
+        executeWith(this.workspaceVolume, closure)
     }
 
     def supplementalGroups(final String supplementalGroups) {
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/kubernetes/ContainerTemplateDeclaration.groovy b/src/main/groovy/com/lesfurets/jenkins/unit/declarative/kubernetes/ContainerTemplateDeclaration.groovy
@@ -4,9 +4,8 @@ package com.lesfurets.jenkins.unit.declarative.kubernetes
 import groovy.transform.Memoized
 import groovy.transform.ToString
 
-import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.createComponent
+import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.executeWith
 import static com.lesfurets.jenkins.unit.declarative.ObjectUtils.printNonNullProperties
-import static groovy.lang.Closure.DELEGATE_FIRST
 
 @ToString(includePackage = false, includeNames = true, ignoreNulls = true)
 class ContainerTemplateDeclaration {
@@ -96,8 +95,9 @@ class ContainerTemplateDeclaration {
         } as List<PortMappingDeclaration>
     }
 
-    def livenessProbe(@DelegatesTo(strategy = DELEGATE_FIRST, value = ContainerLivenessProbeDeclaration) Closure closure) {
-        this.livenessProbe = createComponent(ContainerLivenessProbeDeclaration, ct)
+    def livenessProbe(Closure closure) {
+        this.livenessProbe = new ContainerLivenessProbeDeclaration();
+        executeWith(this.livenessProbe, closure)
     }
 
     @Memoized
diff --git a/src/main/groovy/com/lesfurets/jenkins/unit/declarative/kubernetes/WorkspaceVolumeDeclaration.groovy b/src/main/groovy/com/lesfurets/jenkins/unit/declarative/kubernetes/WorkspaceVolumeDeclaration.groovy
@@ -16,24 +16,29 @@ class WorkspaceVolumeDeclaration {
     NfsWorkspaceVolume nfsWorkspaceVolume
     PersistentVolumeClaimWorkspaceVolume persistentVolumeClaimWorkspaceVolume
 
-    void dynamicPVC(@DelegatesTo(strategy = DELEGATE_FIRST, value = DynamicWorkspaceVolume) Closure closure) {
-        this.dynamicPVC = createComponent(DynamicWorkspaceVolume, closure)
+    void dynamicPVC(Closure closure) {
+        this.dynamicPVC = new DynamicWorkspaceVolume();
+        GenericPipelineDeclaration.executeWith(this.dynamicPVC, closure);
     }
 
     void emptyDirWorkspaceVolume(@DelegatesTo(strategy = DELEGATE_FIRST, value = EmptyDirWorkspaceVolume) Closure closure) {
         this.emptyDirWorkspaceVolume = createComponent(EmptyDirWorkspaceVolume, closure)
     }
 
-    void hostPathWorkspaceVolume(@DelegatesTo(strategy = DELEGATE_FIRST, value = HostPathWorkspaceVolume) Closure closure) {
-        this.hostPathWorkspaceVolume = createComponent(HostPathWorkspaceVolume, closure)
+    void hostPathWorkspaceVolume(Closure closure) {
+        this.hostPathWorkspaceVolume = new HostPathWorkspaceVolume();
+        GenericPipelineDeclaration.executeWith(this.hostPathWorkspaceVolume, closure);
+
     }
 
-    void nfsWorkspaceVolume(@DelegatesTo(strategy = DELEGATE_FIRST, value = NfsWorkspaceVolume) Closure closure) {
-        nfsWorkspaceVolume = createComponent(NfsWorkspaceVolume, closure)
+    void nfsWorkspaceVolume(Closure closure) {
+        nfsWorkspaceVolume = new NfsWorkspaceVolume();
+        GenericPipelineDeclaration.executeWith(this.nfsWorkspaceVolume, closure);
     }
 
-    void persistentVolumeClaimWorkspaceVolume(@DelegatesTo(strategy = DELEGATE_FIRST, value = PersistentVolumeClaimWorkspaceVolume) Closure closure) {
-        persistentVolumeClaimWorkspaceVolume = createComponent(PersistentVolumeClaimWorkspaceVolume, closure)
+    void persistentVolumeClaimWorkspaceVolume(Closure closure) {
+        persistentVolumeClaimWorkspaceVolume = new PersistentVolumeClaimWorkspaceVolume();
+        GenericPipelineDeclaration.executeWith(this.persistentVolumeClaimWorkspaceVolume, closure);
     }
 
     @Memoized
diff --git a/src/test/groovy/com/lesfurets/jenkins/unit/declarative/TestDeclarativeWithCredentials.groovy b/src/test/groovy/com/lesfurets/jenkins/unit/declarative/TestDeclarativeWithCredentials.groovy
@@ -6,7 +6,7 @@ import org.junit.Test
 
 import static org.junit.Assert.assertTrue
 
-class TestDeclaraticeWithCredentials extends DeclarativePipelineTest {
+class TestDeclarativeWithCredentials extends DeclarativePipelineTest {
 
     @Override
     @Before

Original file line number	Diff line number	Diff line change
`@@ -26,16 +26,16 @@ class AnyOfDeclaration extends WhenDeclaration {`
`26`	`26`	`return false`
`27`	`27`	`}`
`28`	`28`
`29`		`- Boolean execute(Object delegate) {`
	`29`	`+ Boolean execute(Script script) {`
`30`	`30`	`boolean br = false;`
`31`	`31`	`boolean exp = false;`
`32`	`32`
`33`	`33`	`if (this.branches.size() > 0) {`
`34`		`- br = this.branches.contains(delegate.env.BRANCH_NAME)`
	`34`	`+ br = this.branches.contains(script.env.BRANCH_NAME)`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`if (this.expressions.size() > 0) {`
`38`		`- exp = expressions(delegate)`
	`38`	`+ exp = expressions(script)`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`return exp \|\| br`
Original file line number	Diff line number	Diff line change
`@@ -40,17 +40,17 @@ class DeclarativePipeline extends GenericPipelineDeclaration {`
`40`	`40`	`this.parameters = createComponent(ParametersDeclaration, closure)`
`41`	`41`	`}`
`42`	`42`
`43`		`- def execute(Object delegate) {`
`44`		`- super.execute(delegate)`
	`43`	`+ def execute(Script script) {`
	`44`	`+ super.execute(script)`
`45`	`45`	`this.options.forEach {`
`46`	`46`	`executeWith(delegate, it)`
`47`	`47`	`}`
`48`	`48`	`this.agent?.execute(delegate)`
`49`	`49`	`executeWith(delegate, this.triggers)`
`50`	`50`	`this.stages.entrySet().forEach { e ->`
`51`		`- e.value.execute(delegate)`
	`51`	`+ e.value.execute(script)`
`52`	`52`	`}`
`53`		`- this.post?.execute(delegate)`
	`53`	`+ this.post?.execute(script)`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,14 +62,14 @@ abstract class GenericPipelineDeclaration {`
`62`	`62`	`this.stages.put(stageName, createComponent(StageDeclaration, closure).with { it.name = stageName; it })`
`63`	`63`	`}`
`64`	`64`
`65`		`- def execute(Object delegate) {`
	`65`	`+ def execute(Script script) {`
`66`	`66`	`Map envValuestoRestore = [:]`
`67`	`67`
`68`	`68`	`// set environment`
`69`	`69`	`if (this.environment) {`
`70`		`- envValuestoRestore = initEnvironment(this.environment, delegate)`
	`70`	`+ envValuestoRestore = initEnvironment(this.environment, script)`
`71`	`71`	`}`
`72`		`- resetEnvironment(envValuestoRestore, delegate)`
	`72`	`+ resetEnvironment(envValuestoRestore, script)`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`public static Map initEnvironment(Closure environment, Object delegate) {`
Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,8 @@ package com.lesfurets.jenkins.unit.declarative`
`2`	`2`
`3`	`3`	`class NotDeclaration extends WhenDeclaration {`
`4`	`4`
`5`		`- Boolean execute(Object delegate) {`
`6`		`- return !super.execute(delegate)`
	`5`	`+ Boolean execute(Script script) {`
	`6`	`+ return !super.execute(script)`
`7`	`7`	`}`
`8`	`8`	`}`
`9`	`9`
Original file line number	Diff line number	Diff line change
`@@ -21,9 +21,9 @@ class ParallelDeclaration {`
`21`	`21`	`this.stages.put(name, createComponent(StageDeclaration, closure).with{it.name = name;it} )`
`22`	`22`	`}`
`23`	`23`
`24`		`- def execute(Object delegate) {`
	`24`	`+ def execute(Script script) {`
`25`	`25`	`this.stages.entrySet().forEach { e ->`
`26`		`- e.value.execute(delegate)`
	`26`	`+ e.value.execute(script)`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,8 @@ package com.lesfurets.jenkins.unit.declarative`
`2`	`2`
`3`	`3`	`import java.util.regex.Pattern`
`4`	`4`
	`5`	`+import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.executeWith`
	`6`	`+`
`5`	`7`	`import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.createComponent`
`6`	`8`	`import static groovy.lang.Closure.DELEGATE_FIRST`
`7`	`9`
`@@ -48,7 +50,7 @@ class WhenDeclaration {`
`48`	`50`	`this.expressionCondition = closure`
`49`	`51`	`}`
`50`	`52`
`51`		`- Boolean execute(Object delegate) {`
	`53`	`+ Boolean execute(Script script) {`
`52`	`54`	`boolean expressionCheck = true`
`53`	`55`	`boolean branchCheck = true`
`54`	`56`	`boolean tagCheck = true`
`@@ -57,26 +59,26 @@ class WhenDeclaration {`
`57`	`59`	`boolean notCheck = true`
`58`	`60`
`59`	`61`	`if (anyOfCondition) {`
`60`		`- anyOfCheck = anyOfCondition.execute(delegate)`
	`62`	`+ anyOfCheck = anyOfCondition.execute(script)`
`61`	`63`	`}`
`62`	`64`	`if (notCondition) {`
`63`		`- notCheck = notCondition.execute(delegate)`
	`65`	`+ notCheck = notCondition.execute(script)`
`64`	`66`	`}`
`65`	`67`	`if (expressionCondition) {`
`66`	`68`	`expressionCheck = executeWith(delegate, expressionCondition)`
`67`	`69`	`}`
`68`	`70`	`if (branchCondition) {`
`69`		`- branchCheck = this.branchCondition == delegate.env.BRANCH_NAME`
	`71`	`+ branchCheck = this.branchCondition == script.env.BRANCH_NAME`
`70`	`72`	`}`
`71`	`73`	`if (buildingTagCondition) {`
`72`		`- tagCheck = delegate.env.containsKey(TAG_NAME)`
	`74`	`+ tagCheck = script.env.containsKey(TAG_NAME)`
`73`	`75`	`}`
`74`	`76`	`if (tagCondition) {`
`75`		`- tagCheck = delegate.env.TAG_NAME =~ tagCondition`
	`77`	`+ tagCheck = script.env.TAG_NAME =~ tagCondition`
`76`	`78`	`}`
`77`	`79`	`if (environmentCondition && !(environmentCondition as Map)?.isEmpty()) {`
`78`	`80`	`environmentCondition.entrySet().forEach { e ->`
`79`		`- envCheck = envCheck && (delegate.env."${e.key}" == e.value)`
	`81`	`+ envCheck = envCheck && (script.env."${e.key}" == e.value)`
`80`	`82`	`}`
`81`	`83`	`}`
`82`	`84`