Add autoupdate command

planemo/autoupdate.py

@@ -0,0 +1,131 @@
+"""Autoupdate older conda dependencies in the requirements section."""
+from __future__ import absolute_import
+
+import re
+import xml.etree.ElementTree as ET
+import planemo.conda
+
+from planemo.io import error, info
+
+def autoupdate(tool_path, dry_run=False):
+    """
+    Autoupdate an XML file
+    """
+    xml_tree = ET.parse(tool_path)
+    requirements = find_requirements(xml_tree)
+
+    for macro_import in requirements['imports']:
+        # recursively check macros
+        macro_requirements = autoupdate('/'.join(tool_path.split('/')[:-1] + [macro_import]), dry_run)
+        for requirement in macro_requirements:
+            if requirement not in requirements:
+                requirements[requirement] = macro_requirements[requirement]
+
+    if not requirements.get('@TOOL_VERSION@'):
+        # if tool_version is not specified, finish without changes
+        error("The @TOOL_VERSION@ token is not specified in {}. This is required for autoupdating.".format(tool_path))
+        return requirements
+    updated_main_req = get_latest_versions({requirements.get('main_req'): requirements.get('@TOOL_VERSION@')})
+    if updated_main_req[requirements.get('main_req')] == requirements.get('@TOOL_VERSION@'):
+        # check main_req is up-to-date; if so, finish without changes
+        info("No updates required or madeto {}.".format(tool_path))
+        return requirements
+
+    if dry_run:
+        error("Update required to {}! Tool main requirement has version {}, newest conda version is {}".format(tool_path, requirements.get('@TOOL_VERSION@'), updated_main_req[requirements.get('main_req')]))
+        return requirements
+
+    # if main_req is not up-to-date, update everything
+    updated_version_dict = get_latest_versions(requirements.get('other_reqs'))
+    update_requirements(tool_path, xml_tree, updated_version_dict, updated_main_req)
+    info("Tool {} updated.".format(tool_path))
+    return requirements
+
+def find_requirements(xml_tree):
+    """
+    Get all requirements with versions as a dictionary of the form
+    {'main_req': main requirement, 'other_reqs': {req1: version, ... },
+        'imports: ['macros.xml'], '*VERSION@': '...'}
+    """
+    requirements = {'other_reqs': {}, 'imports': []}
+
+    # get tokens
+    for token in xml_tree.iter("token"):
+        if 'VERSION@' in token.attrib.get('name', ''):
+            requirements[token.attrib['name']] = token.text
+    for macro_import in xml_tree.iter("import"):
+        requirements['imports'].append(macro_import.text)
+
+    # get requirements
+    for requirement in xml_tree.iter("requirement"):
+        if requirement.attrib.get('version') == '@TOOL_VERSION@':
+            requirements['main_req'] = requirement.text
+        else:
+            requirements['other_reqs'][requirement.text] = requirement.attrib.get('version')
+    return requirements
+
+
+def get_latest_versions(version_dict):
+    """
+    Update a dict with current conda versions for tool requirements
+    """
+    for package in version_dict.keys():
+        target = planemo.conda.conda_util.CondaTarget(package)
+        search_results = planemo.conda.best_practice_search(target)
+        version_dict[package] = search_results[0]['version']
+    return version_dict
+
+
+def update_requirements(tool_path, xml_tree, updated_version_dict, updated_main_req):
+    """
+    Update requirements to latest conda versions
+    and update version tokens
+    """
+
+    tags_to_update = {'tokens': [], 'requirements': []}
+
+    for token in xml_tree.iter("token"):
+        if token.attrib.get('name') == '@TOOL_VERSION@':
+            #  check this
+            token.text = list(updated_main_req.values())[0]
+        elif token.attrib.get('name') == '@GALAXY_VERSION@':
+            token.text = '0'
+        else:
+            continue
+        tags_to_update['tokens'].append(ET.tostring(token, encoding="unicode").strip())
+
+    if '@GALAXY_VERSION@' not in [n.attrib.get('name') for n in xml_tree.iter('token')]:
+        tags_to_update['update_tool'] = True
+
+    for requirement in xml_tree.iter("requirement"):
+        if requirement.text not in updated_main_req:
+            requirement.set('version', updated_version_dict[requirement.text])
+        tags_to_update['requirements'].append(ET.tostring(requirement, encoding="unicode").strip())
+    write_to_xml(tool_path, xml_tree, tags_to_update)
+    return xml_tree
+
+
+def write_to_xml(tool_path, xml_tree, tags_to_update):
+    """
+    Write modified XML to tool_path
+    """
+    with open(tool_path, 'r+') as f:
+        xml_text = f.read()
+        for token in tags_to_update['tokens']:
+            xml_text = re.sub('{}>.*<{}'.format(*re.split('>.*<', token)), token, xml_text)
+
+        for requirement in tags_to_update['requirements']:
+            xml_text = re.sub('{}version=".*"{}'.format(*re.split('version=".*"', requirement)), requirement, xml_text)
+
+        # if '@GALAXY_VERSION@' not in tags_to_update['tokens']:
+        if tags_to_update.get('update_tool'):
+            # update the version directly in the tool tag
+            xml_text = re.sub('version="@TOOL_VERSION@\+galaxy.*"', 'version="@TOOL_VERSION@+galaxy0"', xml_text)
+
+        f.seek(0)
+        f.truncate()
+        f.write(xml_text)
+
+__all__ = (
+    "autoupdate"
+)

planemo/commands/cmd_autoupdate.py

@@ -0,0 +1,64 @@
+"""Module describing the planemo ``autoupdate`` command."""
+import click
+
+from planemo.exit_codes import (
+    EXIT_CODE_GENERIC_FAILURE,
+    EXIT_CODE_OK
+)
+from planemo.io import (
+    coalesce_return_codes,
+    info
+)
+from planemo.tools import (
+    is_tool_load_error,
+    yield_tool_sources_on_paths
+)
+
+from planemo import options, autoupdate
+from planemo.cli import command_function
+from planemo.config import planemo_option
+
+
+def dry_run_option():
+    """Perform a dry run autoupdate without modifying the XML files"""
+    return planemo_option(
+        "--dry-run",
+        is_flag=True,
+        help="Perform a dry run autoupdate without modifying the XML files."
+    )
+
+@click.command('autoupdate')
+@options.optional_tools_arg(multiple=True)
+@options.report_level_option()
+@options.report_xunit()
+@options.fail_level_option()
+@options.skip_option()
+@options.recursive_option()
+@dry_run_option()
+@command_function
+def cli(ctx, paths, **kwds):
+    """Auto-update requirements section if necessary"""
+    assert_tools = kwds.get("assert_tools", True)
+    recursive = kwds.get("recursive", False)
+    exit_codes = []
+    for (tool_path, tool_xml) in yield_tool_sources_on_paths(ctx, paths, recursive):
+        info("Auto-updating tool %s" % tool_path)
+        tool_xml = autoupdate.autoupdate(tool_path, kwds['dry_run'])
+        if handle_tool_load_error(tool_path, tool_xml):
+            exit_codes.append(EXIT_CODE_GENERIC_FAILURE)
+            continue
+        else:
+            exit_codes.append(EXIT_CODE_OK)
+    return coalesce_return_codes(exit_codes, assert_at_least_one=assert_tools)
+    ctx.exit()
+
+
+def handle_tool_load_error(tool_path, tool_xml):
+    """ Return True if tool_xml is tool load error (invalid XML), and
+    print a helpful error message.
+    """
+    is_error = False
+    if is_tool_load_error(tool_xml):
+        info("Could not update %s due to malformed xml." % tool_path)
+        is_error = True
+    return is_error