update_versions Namespace Reference

Functions
def	extract_version (path)
def	change_cml_version (cml, newversion)
def	change_version (packagedir, newversion)
def	extract_recent_rel_notes (filename)
def	add_release_separator_bar (filename, pkg, version)
def	main ()

Variables
string	__author__ = "Marco Clemencic <Marco.Clemencic@cern.ch>"
string	__version__ = "$Id: update_versions.py,v 1.3 2008/11/10 19:43:31 marcocle Exp $"
tuple	_req_version_pattern = re.compile(r"^\s*version\s*(v[0-9]+r[0-9]+(?:p[0-9]+)?)\s*$")
tuple	_cml_version_pattern = re.compile(r"^\s*gaudi_subdir\s*\(\s*\S+\s+(v[0-9]+r[0-9]+(?:p[0-9]+)?)\)\s*$")

Function Documentation

def update_versions.add_release_separator_bar	(		filename,
			pkg,
			version
	)

Definition at line 94 of file update_versions.py.

def add_release_separator_bar(filename, pkg, version):
    changelog_entry = re.compile(r'^(! [0-9]{4}-[0-9]{2}-[0-9]{2} -)|============')
    title = " %s %s " % (pkg, version)
    letf_chars = (78 - len(title)) / 2
    right_chars = 78 - letf_chars - len(title)
    separator = ("=" * letf_chars) + title + ("=" * right_chars) + "\n"
    out = []
    found = False
    for l in open(filename):
        # looking for the first changelog entry
        if not found:
            if changelog_entry.match(l):
                out.append(separator)
                found = True
        # if found, just go on appending lines
        out.append(l)
    if found:
        open(filename,"w").writelines(out)
    else:
        print "Warning: could not update release.notes in %s" % pkg

def update_versions.change_cml_version	(		cml,
			newversion
	)

Definition at line 25 of file update_versions.py.

def change_cml_version(cml, newversion):
    if os.path.exists(cml):
        out = []
        changed = False
        for l in open(cml):
            m = _cml_version_pattern.match(l)
            if m and m.group(1) != newversion:
                print "%s: %s -> %s"%(cml, m.group(1), newversion)
                l = l.replace(m.group(1), newversion)
                changed = True
            out.append(l)
        if changed:
            open(cml, "w").writelines(out)

def update_versions.change_version	(		packagedir,
			newversion
	)

Compare the version of the package with the new one and update the package if
needed.

Returns true if the package have been modified.

Definition at line 39 of file update_versions.py.

def change_version(packagedir, newversion):
    """
    Compare the version of the package with the new one and update the package if
    needed.

    Returns true if the package have been modified.
    """
    global _req_version_pattern
    changed = False
    out = []
    req = os.path.join(packagedir, 'cmt', 'requirements')
    for l in open(req):
        m = _req_version_pattern.match(l)
        if m:
            if m.group(1) != newversion:
                print "%s: %s -> %s"%(packagedir,m.group(1),newversion)
                l = l.replace(m.group(1),newversion)
                changed = True
        out.append(l)
    if changed:
        open(req,"w").writelines(out)
    # verify the version.cmt file
    ver = os.path.join(packagedir,"version.cmt")
    if os.path.exists(ver):
        current = open(ver).read().strip()
        if current != newversion:
            open(ver,"w").write(newversion + "\n")
    # update CMakeLists.txt
    cml = os.path.normpath(os.path.join(packagedir, 'CMakeLists.txt'))
    change_cml_version(cml, newversion)
    if 'GaudiKernel' in packagedir:
        cml = os.path.normpath(os.path.join(packagedir, 'src', 'Util', 'CMakeLists.txt'))
        change_cml_version(cml, newversion)
    return changed

def update_versions.extract_recent_rel_notes

(

filename

)

Definition at line 74 of file update_versions.py.

def extract_recent_rel_notes(filename):
    changelog_entry = re.compile(r'^(! [0-9]{4}-[0-9]{2}-[0-9]{2} -)|!?============')
    separator_entry = re.compile(r'^!?============')
    notes = []
    state = "searching"
    for l in open(filename):
        # looking for the first changelog entry
        if state == "searching":
            if changelog_entry.match(l):
                state = "found"
        # when found, we start collecting lines until the next separator
        if state == "found":
            if not separator_entry.match(l):
                notes.append(l)
            else:
                break
    # remove trailing empty lines
    while notes and not notes[-1].strip(): notes.pop()
    return "".join(notes)

def update_versions.extract_version

(

path

)

Find the version number of a subdirectory.

Definition at line 14 of file update_versions.py.

def extract_version(path):
    """
    Find the version number of a subdirectory.
    """
    global _cml_version_pattern
    for l in open(os.path.join(path, 'CMakeLists.txt')):
        m = _cml_version_pattern.match(l)
        if m:
            return m.group(1)
    return None

def update_versions.main

(

)

Definition at line 115 of file update_versions.py.

def main():

    # Find the version of HEPTools (LCG)
    for l in open('toolchain.cmake'):
        m = re.match(r'^\s*set\(\s*heptools_version\s+(\S*)\s*\)', l)
        if m:
            HEPToolsVers = m.group(1)
            print "Using HEPTools", HEPToolsVers
            break
    else:
        print "Cannot find HEPTools version"
        sys.exit(1)

    # Collect all the packages in the project with their directory
    def all_subdirs():
        for dirpath, dirnames, filenames in os.walk(os.curdir):
            if 'CMakeLists.txt' in filenames and dirpath != os.curdir:
                dirnames[:] = []
                yield dirpath
            else:
                dirnames[:] = [dirname for dirname in dirnames
                               if not dirname.startswith('build.') and
                                  dirname != 'cmake']

    # Packages which version must match the version of the project
    special_subdirs = ["Gaudi", "GaudiExamples", "GaudiSys", "GaudiRelease"]

    # Ask for the version of the project
    top_cml = ' '.join(l.strip().split('#', 1)[0]
                       for l in open('CMakeLists.txt').readlines())
    old_version = re.search(r'gaudi_project\(\s*\S+\s+(\S+)', top_cml).group(1)
    new_version = raw_input("The old version of the project is %s, which is the new one? " % old_version)

    old_versions = {}
    release_notes = {}
    new_versions = {}
    # for each package in the project check if there were changes and ask for the new version number
    for pkgdir in all_subdirs():
        relnotefile = os.path.join(pkgdir, 'doc', 'release.notes')
        cmlfile = os.path.join(pkgdir, 'CMakeLists.txt')
        reqfile = os.path.join(pkgdir, 'cmt', 'requirements')

        pkg = os.path.basename(pkgdir)
        old_versions[pkg] = extract_version(pkgdir)

        if os.path.exists(relnotefile): # ignore missing release.notes
            release_notes[pkg] = extract_recent_rel_notes(relnotefile)
        else:
            release_notes[pkg] = ''

        if pkg in special_subdirs:
            new_versions[pkg] = new_version
        else:
            if release_notes[pkg]:
                msg = ('\nThe old version of %s is %s, these are the changes:\n'
                       '%s\n'
                       'Which version you want (old is %s)? ') % \
                       (pkg, old_versions[pkg], release_notes[pkg],
                        old_versions[pkg])
                new_versions[pkg] = raw_input(msg)
            else:
                new_versions[pkg] = old_versions[pkg]
        # update infos
        if new_versions[pkg] != old_versions[pkg]:
            change_version(pkgdir, new_versions[pkg])
            if os.path.exists(relnotefile):
                add_release_separator_bar(relnotefile, pkg, new_versions[pkg])
        print "=" * 80
    # The changes in the GaudiRelease requirements for the other packages can be postponed to now
    reqfile = os.path.join('GaudiRelease', 'cmt', 'requirements')
    out = []
    for l in open(reqfile):
        sl = l.strip().split()
        if sl and sl[0] == "use":
            if sl[1] in new_versions:
                if sl[2] != new_versions[sl[1]]:
                    l = l.replace(sl[2], new_versions[sl[1]])
        out.append(l)
    open(reqfile, "w").writelines(out)
    # Update project.info
    config = ConfigParser.ConfigParser()
    config.optionxform = str # make the options case sensitive
    if os.path.exists('project.info'):
        config.read('project.info')
    if not config.has_section('Packages'):
        config.add_section('Packages')
    for pack_vers in sorted(new_versions.items()):
        config.set('Packages', *pack_vers)
    config.write(open('project.info', 'wb'))

    if new_version != old_version:
        # update the global release notes
        new_lines = []
        new_lines.append("<!-- ====================================================================== -->")
        data = { "vers": new_version, "date": time.strftime("%Y-%m-%d") }
        new_lines.append('<h2><a name="%(vers)s">Gaudi %(vers)s</a> (%(date)s)</h2>' % data)
        data = { "vers": HEPToolsVers }
        new_lines.append('<h3>Externals version: <a href="http://lcgsoft.cern.ch/index.py?page=cfg_overview&cfg=%(vers)s">LCG %(vers)s</a></h3>' % data)
        new_lines.append("<h3>General Changes</h3>")
        new_lines.append('<ul>\n<li><br/>\n    (<span class="author"></span>)</li>\n</ul>')
        new_lines.append("<h3>Packages Changes</h3>")
        new_lines.append("<ul>")
        for pkg in release_notes:
            if release_notes[pkg]:
                new_lines.append('<li>%s (%s):\n<ul>\n<li><br/>\n    (<span class="author"></span>)</li>\n</ul>\n<pre>'%(pkg,new_versions[pkg]))
                new_lines.append(release_notes[pkg].replace('&','&amp;') \
                                                   .replace('<','&lt;') \
                                                   .replace('>','&gt;') + "</pre>")
                new_lines.append("</li>")
        new_lines.append("</ul>")

        global_rel_notes = os.path.join("GaudiRelease", "doc", "release.notes.html")
        out = []
        separator = re.compile("<!-- =+ -->")
        block_added = False
        for l in open(global_rel_notes):
            if not block_added and separator.match(l.strip()):
                out.append("\n".join(new_lines) + "\n")
                block_added = True
            out.append(l)
        open(global_rel_notes, "w").writelines(out)

        # update the global CMakeLists.txt
        out = []
        for l in open('CMakeLists.txt'):
            if l.strip().startswith('gaudi_project'):
                l = 'gaudi_project(Gaudi %s)\n' % new_version
            out.append(l)
        open('CMakeLists.txt', "w").writelines(out)

Variable Documentation

string update_versions.__author__ = "Marco Clemencic <Marco.Clemencic@cern.ch>"

Definition at line 3 of file update_versions.py.

string update_versions.__version__ = "$Id: update_versions.py,v 1.3 2008/11/10 19:43:31 marcocle Exp $"

Definition at line 4 of file update_versions.py.

tuple update_versions._cml_version_pattern = re.compile(r"^\s*gaudi_subdir\s*\(\s*\S+\s+(v[0-9]+r[0-9]+(?:p[0-9]+)?)\)\s*$")

Definition at line 13 of file update_versions.py.

tuple update_versions._req_version_pattern = re.compile(r"^\s*version\s*(v[0-9]+r[0-9]+(?:p[0-9]+)?)\s*$")

Definition at line 12 of file update_versions.py.