1 files changed, 210 insertions, 0 deletions
diff --git a/src/main/java/io/trygvis/esper/testing/jenkins/xml/JenkinsBuildXml.java b/src/main/java/io/trygvis/esper/testing/jenkins/xml/JenkinsBuildXml.java
new file mode 100755
index 0000000..506407e
--- /dev/null
+++ b/src/main/java/io/trygvis/esper/testing/jenkins/xml/JenkinsBuildXml.java
@@ -0,0 +1,210 @@
+package io.trygvis.esper.testing.jenkins.xml;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.jdom2.Document;
+import org.jdom2.Element;
+import org.joda.time.DateTime;
+import org.joda.time.format.DateTimeFormat;
+import org.joda.time.format.DateTimeFormatter;
+import org.joda.time.format.ISODateTimeFormat;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import fj.F;
+import fj.data.Option;
+import io.trygvis.esper.testing.Util;
+
+import static fj.data.List.iterableList;
+import static fj.data.Option.*;
+import static io.trygvis.esper.testing.Util.childText;
+import static io.trygvis.esper.testing.Util.parseInt;
+import static io.trygvis.esper.testing.jenkins.xml.JenkinsBuildXml.ChangeSetItemXml.parseChangeSetItem;
+import static io.trygvis.esper.testing.jenkins.xml.JenkinsBuildXml.RevisionXml.parseRevision;
+
+public class JenkinsBuildXml {
+    private static final Logger logger = LoggerFactory.getLogger(JenkinsBuildXml.class);
+
+    public final URI url;
+
+    public final int number;
+
+    public final Option<String> result;
+
+    public final int duration;
+
+    public final long timestamp;
+
+    public final Option<ChangeSetXml> changeSet;
+
+    JenkinsBuildXml(URI url, int number, Option<String> result, int duration, long timestamp, Option<ChangeSetXml> changeSet) {
+        this.url = url;
+        this.number = number;
+        this.result = result;
+        this.duration = duration;
+        this.timestamp = timestamp;
+        this.changeSet = changeSet;
+    }
+
+    public static F<Document, Option<JenkinsBuildXml>> parse = new F<Document, Option<JenkinsBuildXml>>() {
+        public Option<JenkinsBuildXml> f(Document document) {
+            return parse(document);
+        }
+    };
+
+    public static Option<JenkinsBuildXml> parse(Document doc) {
+        Element root = doc.getRootElement();
+
+        Option<URI> url = childText(root, "url").bind(Util.parseUri);
+        Option<Integer> number = childText(root, "number").bind(Util.parseInt);
+        Option<String> result = childText(root, "result");
+        Option<Integer> duration = childText(root, "duration").bind(Util.parseInt);
+        Option<Long> timestamp = childText(root, "timestamp").bind(Util.parseLong);
+
+        if (url.isNone()) {
+            logger.warn("Missing required field: <url>");
+            return none();
+        }
+        if (number.isNone()) {
+            logger.warn("Missing required field: <number>");
+            return none();
+        }
+        if (duration.isNone()) {
+            logger.warn("Missing required field: <duration>");
+            return none();
+        }
+        if (timestamp.isNone()) {
+            logger.warn("Missing required field: <timestamp>");
+            return none();
+        }
+
+        Option<ChangeSetXml> changeSet = none();
+        Element e = root.getChild("changeSet");
+        if (e != null) {
+            changeSet = ChangeSetXml.parse(e);
+        }
+
+        return some(new JenkinsBuildXml(url.some(), number.some(), result, duration.some(), timestamp.some(), changeSet));
+    }
+
+    public static class ChangeSetXml {
+        public final List<ChangeSetItemXml> items;
+
+        public final Option<RevisionXml> revision;
+
+        public ChangeSetXml(List<ChangeSetItemXml> items, Option<RevisionXml> revision) {
+            this.items = items;
+            this.revision = revision;
+        }
+
+        public static Option<ChangeSetXml> parse(Element changeSet) {
+
+            List<ChangeSetItemXml> items = new ArrayList<>(Option.somes(iterableList(changeSet.getChildren("item")).map(parseChangeSetItem)).toCollection());
+
+            Option<RevisionXml> revision = Option.fromNull(changeSet.getChild("revision")).bind(parseRevision);
+
+            return some(new ChangeSetXml(items, revision));
+        }
+    }
+
+    public static class ChangeSetItemXml {
+        public final String commitId;
+
+        public final DateTime date;
+
+        public final String msg;
+
+        public final Option<AuthorXml> author;
+
+        public ChangeSetItemXml(String commitId, DateTime date, String msg, Option<AuthorXml> author) {
+            this.commitId = commitId;
+            this.date = date;
+            this.msg = msg;
+            this.author = author;
+        }
+
+        private static final F<String, Option<DateTime>> parseDate = new F<String, Option<DateTime>>() {
+            // This variant is used by git
+            DateTimeFormatter parser = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss Z");
+            // and this by subversion
+            DateTimeFormatter parser2 = ISODateTimeFormat.dateTime();
+
+            public Option<DateTime> f(String s) {
+                try {
+                    return some(parser.parseDateTime(s));
+                } catch (IllegalArgumentException e) {
+                    try {
+                        return some(parser2.parseDateTime(s));
+                    } catch (IllegalArgumentException e2) {
+                        return none();
+                    }
+                }
+            }
+        };
+
+        public static final F<Element, Option<ChangeSetItemXml>> parseChangeSetItem = new F<Element, Option<ChangeSetItemXml>>() {
+            public Option<ChangeSetItemXml> f(Element item) {
+                Option<String> commitId = childText(item, "commitId");
+                Option<DateTime> date = childText(item, "date").bind(parseDate);
+                Option<String> msg = childText(item, "msg");
+
+                if (commitId.isNone() || date.isNone() || msg.isNone()) {
+                    return none();
+                }
+
+                Option<AuthorXml> author = fromNull(item.getChild("author")).bind(AuthorXml.parseAuthorXml);
+
+                return some(new ChangeSetItemXml(commitId.some(), date.some(), msg.some(), author));
+            }
+        };
+    }
+
+    public static class AuthorXml {
+        public final String absoluteUrl;
+        public final String fullName;
+
+        public AuthorXml(String absoluteUrl, String fullName) {
+            this.absoluteUrl = absoluteUrl;
+            this.fullName = fullName;
+        }
+
+        public static final F<Element, Option<AuthorXml>> parseAuthorXml = new F<Element, Option<AuthorXml>>() {
+            public Option<AuthorXml> f(Element element) {
+                Option<String> absoluteUrl = childText(element, "absoluteUrl");
+                Option<String> fullName = childText(element, "fullName");
+
+                if(absoluteUrl.isNone() || fullName.isNone()) {
+                    return none();
+                }
+
+                return some(new AuthorXml(absoluteUrl.some(), fullName.some()));
+            }
+        };
+    }
+
+    public static class RevisionXml {
+        public final String module;
+
+        public final int revision;
+
+        public RevisionXml(String module, int revision) {
+            this.module = module;
+            this.revision = revision;
+        }
+
+        public static final F<Element, Option<RevisionXml>> parseRevision = new F<Element, Option<RevisionXml>>() {
+            public Option<RevisionXml> f(Element e) {
+                Option<String> module = childText(e, "module");
+                Option<Integer> revision = childText(e, "revision").bind(parseInt);
+
+                if (module.isNone() || revision.isNone()) {
+                    return none();
+                }
+
+                return some(new RevisionXml(module.some(), revision.some()));
+            }
+        };
+    }
+}