Merge pull request #453 from Alex-Weatherhead/feature/452

Add support for branch/tag comparators in when block

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

@@ -1,18 +1,41 @@
 package com.lesfurets.jenkins.unit.declarative
 
-import org.springframework.util.AntPathMatcher
-
 import static groovy.lang.Closure.DELEGATE_FIRST
 
 class AllOfDeclaration extends WhenDeclaration {
 
-    List<String> branches = []
+    List<Tuple2<String,ComparatorEnum>> tags = []
+    List<Tuple2<String,ComparatorEnum>> branches = []
     List<ChangeRequestDeclaration> changeRequests = []
     List<Boolean> expressions = []
     List<AnyOfDeclaration> anyOfs = []
 
-    def branch(String name) {
-        this.branches.add(name)
+    def tag(String pattern) {
+        tags.add(new Tuple2(pattern, ComparatorEnum.GLOB))
+    }
+
+    def tag(Map args) {
+        if (args.comparator) {
+            ComparatorEnum comparator = ComparatorEnum.getComparator(args.comparator as String)
+            this.tags.add(new Tuple2(args.pattern as String, comparator))
+        }
+        else {
+            tag(args.pattern)
+        }
+    }
+
+    def branch(String pattern) {
+        branches.add(new Tuple2(pattern, ComparatorEnum.GLOB))
+    }
+
+    def branch(Map args) {
+        if (args.comparator) {
+            ComparatorEnum comparator = ComparatorEnum.getComparator(args.comparator as String)
+            this.branches.add(new Tuple2(args.pattern as String, comparator))
+        }
+        else {
+            branch(args.pattern)
+        }
     }
 
     def changeRequest(Object val) {
@@ -38,28 +61,33 @@ class AllOfDeclaration extends WhenDeclaration {
     Boolean execute(Object delegate) {
         def results = []
 
-        AntPathMatcher antPathMatcher = new AntPathMatcher()
+        if (tags) {
+            tags.each { tag ->
+                results.add(compareStringToPattern(delegate.env.TAG_NAME, tag))
+            }
+        }
 
-        if (this.branches.size() > 0) {
+        if (branches) {
             branches.each { branch ->
-                results.add(antPathMatcher.match(branch, delegate.env.BRANCH_NAME))
+                results.add(compareStringToPattern(delegate.env.BRANCH_NAME, branch))
             }
         }
 
-        if (this.changeRequests.size() > 0) {
+        if (changeRequests) {
             changeRequests.each { changeRequest ->
                 results.add(changeRequest.execute(delegate))
             }
         }
 
-        if (this.expressions.size() > 0) {
+        if (expressions) {
             results.add(expressions(delegate))
         }
 
-        if (this.anyOfs.size() > 0) {
+        if (anyOfs) {
             results.addAll(anyOf(delegate))
         }
 
         return results.every()
     }
+
 }

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

@@ -1,25 +1,43 @@
 package com.lesfurets.jenkins.unit.declarative
 
 import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.executeWith
-import org.springframework.util.AntPathMatcher
 
 import static groovy.lang.Closure.DELEGATE_FIRST
 
-
 class AnyOfDeclaration extends WhenDeclaration {
 
-    List<String> tags = []
-    List<String> branches = []
+    List<Tuple2<String,ComparatorEnum>> tags = []
+    List<Tuple2<String,ComparatorEnum>> branches = []
     List<ChangeRequestDeclaration> changeRequests = []
     List<Boolean> expressions = []
     List<AllOfDeclaration> allOfs = []
 
-    def tag(String name) {
-        this.tags.add(name)
+    def tag(String pattern) {
+        this.tags.add(new Tuple2(pattern, ComparatorEnum.GLOB))
+    }
+
+    def tag(Map args) {
+        if (args.comparator) {
+            ComparatorEnum comparator = ComparatorEnum.getComparator(args.comparator as String)
+            this.tags.add(new Tuple2(args.pattern as String, comparator))
+        }
+        else {
+            tag(args.pattern)
+        }
     }
 
-    def branch(String name) {
-        this.branches.add(name)
+    def branch(String pattern) {
+        this.branches.add(new Tuple2(pattern, ComparatorEnum.GLOB))
+    }
+
+    def branch(Map args) {
+        if (args.comparator) {
+            ComparatorEnum comparator = ComparatorEnum.getComparator(args.comparator as String)
+            this.branches.add(new Tuple2(args.pattern as String, comparator))
+        }
+        else {
+            branch(args.pattern)
+        }
     }
 
     def changeRequest(Object val) {
@@ -45,34 +63,33 @@ class AnyOfDeclaration extends WhenDeclaration {
     Boolean execute(Object delegate) {
         def results = []
 
-        AntPathMatcher antPathMatcher = new AntPathMatcher()
-
-        if (this.tags.size() > 0) {
+        if (tags) {
             tags.each { tag ->
-                results.add(antPathMatcher.match(tag, delegate.env.TAG_NAME))
+                results.add(compareStringToPattern(delegate.env.TAG_NAME, tag))
             }
         }
 
-        if (this.branches.size() > 0) {
+        if (branches) {
             branches.each { branch ->
-                results.add(antPathMatcher.match(branch, delegate.env.BRANCH_NAME))
+                results.add(compareStringToPattern(delegate.env.BRANCH_NAME, branch))
             }
         }
 
-        if (this.changeRequests.size() > 0) {
+        if (changeRequests) {
             changeRequests.each { changeRequest ->
                 results.add(changeRequest.execute(delegate))
             }
         }
 
-        if (this.expressions.size() > 0) {
+        if (expressions) {
             results.add(expressions(delegate))
         }
 
-        if (this.allOfs.size() > 0) {
+        if (allOfs) {
             results.addAll(allOf(delegate))
         }
 
         return results.any()
     }
+
 }

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

@@ -5,95 +5,84 @@ import java.util.regex.Pattern
 class ChangeRequestDeclaration extends WhenDeclaration {
 
     boolean all
-    String id
-    String target
-    String branch
-    String fork
-    String url
-    String title
-    String author
-    String authorDisplayName
-    String authorEmail
-    String comparator
+    Tuple2<String,ComparatorEnum> id
+    Tuple2<String,ComparatorEnum> target
+    Tuple2<String,ComparatorEnum> branch
+    Tuple2<String,ComparatorEnum> fork
+    Tuple2<String,ComparatorEnum> url
+    Tuple2<String,ComparatorEnum> title
+    Tuple2<String,ComparatorEnum> author
+    Tuple2<String,ComparatorEnum> authorDisplayName
+    Tuple2<String,ComparatorEnum> authorEmail
 
     def ChangeRequestDeclaration (Map val) {
         if (val) {
-            this.all = false
-            this.id = val.id
-            this.target = val.target
-            this.branch = val.branch
-            this.fork = val.fork
-            this.title = val.title
-            this.url = val.url
-            this.author = val.author
-            this.authorDisplayName = val.authorDisplayName
-            this.authorEmail = val.authorEmail
-            this.comparator = val.comparator
-        }
-        else {
-            this.all = true
-        }
-    }
+            all = false
 
-    Boolean compare(String expected, String actual) {
-        Boolean result
-        if (!this.comparator || this.comparator == "EQUALS") {
-            result = actual == expected
-        }
-        else if (this.comparator == "GLOB") {
-            Pattern expectedPattern = getPatternFromGlob(expected)
-            result = actual ==~ expectedPattern.pattern()
-        }
-        else if (this.comparator == "REGEXP") {
-            result = actual ==~ expected
+            ComparatorEnum comparator = null
+            if (val.comparator == null) {
+                comparator = ComparatorEnum.EQUALS
+            }
+            else {
+                comparator = ComparatorEnum.getComparator(val.comparator)
+            }
+
+            id = val.id ? new Tuple2(val.id, comparator) : null
+            target = val.target ? new Tuple2(val.target, comparator) : null
+            branch = val.branch ? new Tuple2(val.branch, comparator) : null
+            fork = val.fork ? new Tuple2(val.fork, comparator) : null
+            title = val.title ? new Tuple2(val.title, comparator) : null
+            url = val.url ? new Tuple2(val.url, comparator) : null
+            author = val.author ? new Tuple2(val.author, comparator) : null
+            authorDisplayName = val.authorDisplayName ? new Tuple2(val.authorDisplayName, comparator) : null
+            authorEmail = val.authorEmail ? new Tuple2(val.authorEmail, comparator) : null
         }
         else {
-            throw new IllegalArgumentException("Invalid comparator for changeRequest '${this.comparator}'")
+            all = true
         }
-        return result
     }
 
     Boolean execute(Object delegate) {
         def results = []
 
-        if (this.all) {
-            results.add(delegate?.env?.containsKey("CHANGE_ID"))
+        if (all) {
+            results.add(delegate?.env?.containsKey('CHANGE_ID'))
         }
         else {
-            if (this.id) {
-                results.add(compare(this.id, delegate.env.CHANGE_ID))
+            if (id) {
+                results.add(compareStringToPattern(delegate.env.CHANGE_ID, id))
             }
 
-            if (this.target) {
-                results.add(compare(this.target, delegate.env.CHANGE_TARGET))
+            if (target) {
+                results.add(compareStringToPattern(delegate.env.CHANGE_TARGET, target))
             }
 
-            if (this.branch) {
-                results.add(compare(this.branch, delegate.env.CHANGE_BRANCH))
+            if (branch) {
+                results.add(compareStringToPattern(delegate.env.CHANGE_BRANCH, branch))
             }
 
-            if (this.fork) {
-                results.add(compare(this.fork, delegate.env.CHANGE_FORK))
+            if (fork) {
+                results.add(compareStringToPattern(delegate.env.CHANGE_FORK, fork))
             }
 
-            if (this.url) {
-                results.add(compare(this.url, delegate.env.CHANGE_URL))
+            if (url) {
+                results.add(compareStringToPattern(delegate.env.CHANGE_URL, url))
             }
 
-            if (this.title) {
-                results.add(compare(this.title, delegate.env.CHANGE_TITLE))
+            if (title) {
+                results.add(compareStringToPattern(delegate.env.CHANGE_TITLE, title))
             }
 
-            if (this.author) {
-                results.add(compare(this.author, delegate.env.CHANGE_AUTHOR))
+            if (author) {
+                results.add(compareStringToPattern(delegate.env.CHANGE_AUTHOR, author))
             }
 
-            if (this.authorDisplayName) {
-                results.add(compare(this.authorDisplayName, delegate.env.CHANGE_AUTHOR_DISPLAY_NAME))
+            if (authorDisplayName) {
+                results.add(compareStringToPattern(delegate.env.CHANGE_AUTHOR_DISPLAY_NAME, authorDisplayName))
             }
 
-            if (this.authorEmail) {
-                results.add(compare(this.authorEmail, delegate.env.CHANGE_AUTHOR_EMAIL))
+            if (authorEmail) {
+                results.add(compareStringToPattern(delegate.env.CHANGE_AUTHOR_EMAIL, authorEmail))
             }
         }
 

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

@@ -0,0 +1,33 @@
+package com.lesfurets.jenkins.unit.declarative
+
+enum ComparatorEnum {
+
+    EQUALS ('EQUALS'),
+    GLOB ('GLOB'),
+    REGEXP ('REGEXP')
+
+    private static Map map
+
+    static {
+        map = [:]
+        values().each { comparator ->
+            map.put(comparator.name, comparator)
+        }
+    }
+
+    static ComparatorEnum getComparator(String name) {
+        return map.get(name)
+    }
+
+    private final String name
+
+    private ComparatorEnum(String name) {
+        this.name = name
+    }
+
+    @Override
+    String toString() {
+        return this.name
+    }
+
+}