pom_editor.py

#!/usr/bin/python

from xml.dom.minidom import parse
import argparse
import sys
import re
import os


class PomEditor():
    def __init__(self, pom_file):
        self.pom_file = pom_file
        self.parsed_pom = parse(self.pom_file)

    def getVersion(self):
        return(self._getTagValue('version'))

    def setVersion(self, new_version):
        if self._matchVersion(new_version):
            self._setTagValue('version', new_version)
            self._savePom()
        else:
            self._printError(new_version + "\" is not a valid version!")
            return(1)

    def getVersionNumber(self, version=None):
        if not version:
            version = self.getVersion()
        version_number = version.split('-')[0]
        return(version_number)

    def setVersionNumber(self, new_version_number):
        if re.match("^(\d+\.){2}\d+$",
                    new_version_number):
            self.setVersion(new_version_number + "-" + self.getVersionType())
            self._savePom()
        else:
            self._printError(new_version_number + " not valid version number!")
            return(1)

    def getVersionType(self, version=None):
        if not version:
            version = self.getVersion()
        version_type = version.split('-')
        version_type.pop(0)
        version_type = '-'.join(version_type)
        return(version_type)

    def setVersionType(self, new_type):
        match_expression = "^(\w+-)*(SNAPSHOT|RELEASE|RC\d*|HOTFIX)$"
        if re.match(match_expression, new_type):
            if self.getVersionType() != new_type:
                self.setVersion(self.getVersionNumber() + "-" + new_type)
                self._savePom()
        else:
            self._printError('Type must match /' + match_expression + '/!')
            return(1)

    def _isProperty(self, property_name):
        property_node = self \
            .parsed_pom \
            .getElementsByTagName(property_name)[0]

        if property_node.parentNode.nodeName == "properties":
            return(True)
        else:
            return(False)

    def _matchVersion(self, version):
        if re.match("^(\d+\.)+\d+(-.+)*-(SNAPSHOT|RELEASE|RC\d*|HOTFIX)$",
                    version):
            return(True)
        else:
            return(False)

    def getPropertyVersion(self, property_name):
        if self._isProperty(property_name):
            return(self._getTagValue(property_name))

    def setPropertyVersion(self, property_info):
        property_name = property_info.split(':')[0]
        property_version = property_info.split(':')[1]

        if self._matchVersion(property_version):
            if self._isProperty(property_name):
                self._setTagValue(property_name, property_version)
                self._savePom()
        else:
            self._printError('Invalid version!')

    def setPropertyVersionType(self, property_info):
        property_name = property_info.split(':')[0]
        property_version_type = property_info.split(':')[1]

        match_expression = "^(\w+-)*(SNAPSHOT|RELEASE|RC\d*|HOTFIX)$"
        if re.match(match_expression, property_version_type):
            if self.getVersionType(property_name) != property_version_type:
                self.setPropertyVersion(
                    property_name
                    + ":"
                    + self.getVersionNumber(
                        self.getPropertyVersion(property_name)
                    ) + "-" + property_version_type)
                self._savePom()
        else:
            self._printError('Type must match /' + match_expression + '/!')
            return(1)

    def updatePropertyVersion(self, property_info):
        property_name = property_info.split(':')[0]
        update_type = property_info.split(':')[1]

        version_number = self._updateVersionNumber(
            self.getVersionNumber(
                self.getPropertyVersion(property_name)
            ), update_type)

        if version_number:
            self.setPropertyVersion(
                property_name
                + ':'
                + version_number
                + '-'
                + self.getVersionType(self.getPropertyVersion(property_name))
            )
        else:
            self._printError("Unknown version type.")
            return(1)

    def updateVersion(self, update_type):
        version_number = self._updateVersionNumber(
            self.getVersionNumber(), update_type)

        if version_number:
            self.setVersionNumber(version_number)
        else:
            self._printError("Unknown version type.")
            return(1)

    def updateChildrenVersions(self):
        if self._tagExist('modules'):
            for child in self._getModulesList():
                for child_name in child.childNodes:
                    if os.path.isfile(child_name.nodeValue + "/pom.xml"):
                        child_pom = PomEditor(child_name.nodeValue
                                              + "/pom.xml")
                        child_pom.setVersion(self.getVersion())

    def _tagExist(self, tag_name):
        if len(self.parsed_pom.getElementsByTagName(tag_name)) > 0:
            return(True)
        else:
            return(False)

    def _getModulesList(self):
        return(self.parsed_pom.getElementsByTagName('modules')[0].childNodes)

    def _savePom(self):
        self.parsed_pom.writexml(open(self.pom_file, 'w'))

    def _printError(self, message):
        message = 'Error! ' + message
        print >>sys.stderr, message

    def _updateVersionNumber(self, version_number, update_type):
        if re.match("^(minor|major|revision)$", update_type):
            version_number = map(int,
                                 version_number.split('.'))
            if update_type == "revision":
                version_number[2] += 1
            elif update_type == "major":
                version_number[0] += 1
                version_number[1] = 0
                version_number[2] = 0
            elif update_type == "minor":
                version_number[1] += 1
                version_number[2] = 0
            version_number = '.'.join(map(str, version_number))
        else:
            version_number = None

        return(version_number)

    def _getTagValue(self, tag_name):
        return(
            self.parsed_pom.getElementsByTagName(tag_name)[0] \
            .firstChild.nodeValue
        )

    def _setTagValue(self, tag_name, tag_value):
        self.parsed_pom \
            .getElementsByTagName(tag_name)[0] \
            .firstChild.nodeValue = tag_value


def getOptions():
    parser = argparse.ArgumentParser(description='manage pom attributes')

    group = parser.add_mutually_exclusive_group(required=True)

    getters_group = group.add_mutually_exclusive_group()
    setters_group = group.add_mutually_exclusive_group()

    getters_group.add_argument('--get-version', action='store_true',
                               help='Print pom\'s version.')

    getters_group \
        .add_argument('--get-version-type', action='store_true',
                      help='Print pom\'s version type (SNAPSHOT, RELEASE).')

    getters_group.add_argument('--get-version-number', action='store_true',
                               help='Print just pom\'s version number.')

    getters_group.add_argument('--get-property-version', action='store',
                               help='Print dependency version.')

    getters_group.add_argument('--get-property-version-type', action='store',
                               help='Print dependency version.')

    setters_group.add_argument('--set-version', action='store',
                               help='Set pom\'s version')

    setters_group.add_argument('--set-version-type', action='store',
                               help='Set pom\'s version type. \
                               Example: RELEASE')

    setters_group.add_argument('--set-property-version', action='store',
                               help='Set property version. \
                               Format: property_name:version. \
                               Example: \
                               ptp-library-version:1.64.0-SNAPSHOT.')

    setters_group.add_argument('--set-property-version-type', action='store',
                               help='Set property version type. \
                               Format: property_name:version_type. \
                               Example: \
                               ptp-library-version:HOTFIX.')

    setters_group.add_argument('--update-property', action='store',
                               help='Update property version. \
                               Format: property:update_type. \
                               Allowed update_type: {minor,major,revision}. \
                               Example: \
                               ptp-library-version:major')

    setters_group.add_argument('--update-version', action='store',
                               choices=['minor', 'major', 'revision'])

    return(parser.parse_args())


def main():
    options = getOptions()
    pom = PomEditor('pom.xml')

    if options.get_version:
        print(pom.getVersion())

    elif options.get_version_type:
        print(pom.getVersionType())

    elif options.get_version_number:
        print(pom.getVersionNumber())

    elif options.get_property_version_type:
        print(pom.getVersionType(
            pom.getPropertyVersion(options.get_property_version_type)))

    elif options.set_version:
        if pom.setVersion(options.set_version) == 1:
            return(1)
        pom.updateChildrenVersions()

    elif options.set_version_type:
        if pom.setVersionType(options.set_version_type) == 1:
            return(1)
        pom.updateChildrenVersions()

    elif options.set_property_version:
        if pom.setPropertyVersion(options.set_property_version) == 1:
            return(1)

    elif options.set_property_version_type:
        if pom.setPropertyVersionType(options.set_property_version_type) == 1:
            return(1)

    elif options.get_property_version:
        print(pom.getPropertyVersion(options.get_property_version))

    elif options.update_version:
        pom.updateVersion(options.update_version)
        pom.updateChildrenVersions()
        print(pom.getVersion())

    elif options.update_property:
        pom.updatePropertyVersion(options.update_property)

    return(0)

if __name__ == '__main__':
    sys.exit(main())