Skrypt do ustawiania wersji pom.xml w Groovy

Może komuś się przyda prosty skrypcior do ustawiania wersji w pom.xml w Groovy, który bardzo łatwo można podpiąć pod cokolwiek z naszego CDI, np. aliasy git'a, jenkins, itp.

import groovy.xml.XmlUtil
import groovy.xml.dom.DOMCategory
import groovy.xml.DOMBuilder
def rootPath = System.getProperty("rootPath")
def newVersion = System.getProperty("newVersion")
def rootPomPath = "${rootPath}/pom.xml";
 
def allPoms = [];
def rootPom = new XmlParser().parse(new File(rootPomPath));
def currentVersion = rootPom.version.text();
 
VersionUpdater.update(rootPath, newVersion, allPoms)
 
class VersionUpdater{
 
    static update(path, newVersion, allPoms){
        def pomPath = Paths.pomPath(path);
        allPoms.add(pomPath)
        def pomXml = new PomXml(path);
        pomXml.changeVersion(newVersion);
        save(pomXml);
        println "zmienilem wersje w ${pomPath} na ${newVersion}"       
        if (pomXml.hasModules()){
            pomXml.modulesPaths().each{
                subModulePath -> update(subModulePath, newVersion,allPoms)
            }
        }
    }
   
    static save(pomXml){
        def result = XmlUtil.serialize(pomXml.xml())
        //serializacja powoduje, że root jest w tej samej linice co  dlatego sztucznie dodaje \n
                               if (result.readLines()[0].contains("\\?><")){
                                               result = result.replaceFirst("\\?>", "?>\n");
                               }       
        new File(pomXml.path()).setText(result,'UTF-8');
    }
}
 
class Paths{
    static pomPath(path){
        return "${path}/pom.xml"
    }
}
 
class PomXml {
 
    private path;
    private pomXml;
 
    PomXml(path){
        InputStream inputStream = new FileInputStream(Paths.pomPath(path));
        Reader reader = new InputStreamReader(inputStream, 'UTF-8');
        def doc = DOMBuilder.parse(reader, false, false);
        pomXml = doc.documentElement;
        this.path = path;
    }   
    public void changeVersion(newVersion){
        use(DOMCategory) {
            if (pomXml.version[0]){
                pomXml.version[0].value = newVersion                  
            }
            else{
                pomXml.parent.version[0].value = newVersion 
            }
        }
    }   
    public hasModules(){
        use(DOMCategory) {
            return !modules().isEmpty();
        }
    }   
    private modules(){
        use(DOMCategory) {
            return pomXml.modules.module;
        }   
    }   
    public modulesPaths(){
        use(DOMCategory) {
            return modules().collect{module -> path + "/" + module.text()}
        }
    }   
    public version(){
        use(DOMCategory) {
            if (pomXml.version[0]){
                return pomXml.version[0].text()
            }
            else{
                return pomXml.parent.version[0].text()
            }
        }
    }   
    public path(){
        return Paths.pomPath(path)
    }
    public xml(){
        return pomXml
    }
}

I samo uruchomienie:

java -jar -DrootPath=/path/to/root -DnewVersion=1.2.3-SNAPSHOT groovy-all-2.2.1.jar UpdatePomVersion.groovy

Przekazując bezpośrednio jara groovy-all nie musimy instalować Grooviego w żaden sposób i wystarczy sama Java do odpalenia skryptu. Skrypt pewnie można o wiele lepiej napisać, ale to moje pierwsze cokolwiek w Groovim. Nigdy nie myślałem, że to powiem, ale Java... zaczęła mnie nudzić. I nie chodzi o to, że poznałem ją już w 100% (daleko mi do tego). Nie chodzi też o to, że przesiadam się na F#, Railsy, albo coś innego. Tłucze ostatnio swoją głowę "mądrymi" książkami/blogami/itp o tym, co powinien robić porządny programista i wychodzi na to że ich wspólnym mianownikiem, nie jest opanowywanie czegoś do perfekcji, tylko ciągłe poszukiwanie innych "ścieżek". Nawet jeśli rozwiązują one ten sam, dawno rozwiązany, problem.

Będąc pod wpływem chwili, doszedłem do wniosku, że w końcu trzeba poznać inne języki bazujące na JVM. Przekornie do obecnego nurtu nie rzuciłem się na Scalę, o której teraz wszyscy piszą. Wyszło na to, że bardziej przyda mi się Groovy (którego chyba lubią ludzie z Pivotala), bo w końcu trzeba poznać kiedyś Graidla, a testy z wykorzystaniem Spocka, też wyglądają kusząco. 

Niestety nie znalazłem żadnego darmowego kursidła, które wymuszałoby jakąś systematyczność w nauce, więc postanowiłem zrobić coś przydatnego, żeby zapał nie wyparował po 2 dniach. Wyszło na to, że Groovy ma rewelacyjne wsparcie do czytania jak i edytowania xmlów.