| #!/usr/bin/env python |
| # |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| from glob import glob |
| from optparse import OptionParser |
| from time import gmtime, strftime |
| from distutils.version import LooseVersion |
| import os |
| import re |
| import sys |
| import urllib |
| import urllib2 |
| try: |
| import json |
| except ImportError: |
| import simplejson as json |
| try: |
| set |
| except NameError: |
| from sets import Set as set |
| |
| RELEASE_VERSION = {} |
| NAME_PATTERN = re.compile(r' \([0-9]+\)') |
| RELNOTE_PATTERN = re.compile('^\<\!\-\- ([a-z]+) \-\-\>') |
| JIRA_BASE_URL = "https://issues.apache.org/jira" |
| |
| ASF_LICENSE = ''' |
| <!--- |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| --> |
| ''' |
| |
| def clean(_str): |
| return markdownsanitize(re.sub(NAME_PATTERN, "", _str)) |
| |
| def format_components(_str): |
| _str = re.sub(NAME_PATTERN, '', _str).replace("'", "") |
| if _str != "": |
| ret = _str |
| else: |
| # some markdown parsers don't like empty tables |
| ret = "." |
| return clean(ret) |
| |
| # convert to utf-8 |
| def markdownsanitize(_str): |
| _str = _str.encode('utf-8') |
| _str = _str.replace("\r", "") |
| _str = _str.rstrip() |
| return _str |
| |
| # same thing as markdownsanitize, |
| # except markdown metachars are also |
| # escaped as well as more |
| # things we don't want doxia, etc, to |
| # screw up |
| def textsanitize(_str): |
| _str = markdownsanitize(_str) |
| _str = _str.replace("_", r"\_") |
| _str = _str.replace("|", r"\|") |
| _str = _str.replace("<", r"\<") |
| _str = _str.replace(">", r"\>") |
| _str = _str.replace("*", r"\*") |
| _str = _str.rstrip() |
| return _str |
| |
| # if release notes have a special marker, |
| # we'll treat them as already in markdown format |
| def processrelnote(_str): |
| fmt = RELNOTE_PATTERN.match(_str) |
| if fmt is None: |
| return textsanitize(_str) |
| else: |
| return { |
| 'markdown' : markdownsanitize(_str), |
| }.get(fmt.group(1),textsanitize(_str)) |
| |
| # clean output dir |
| def clean_output_dir(directory): |
| files = os.listdir(directory) |
| for name in files: |
| os.remove(os.path.join(directory, name)) |
| os.rmdir(directory) |
| |
| def mstr(obj): |
| if obj is None: |
| return "" |
| return unicode(obj) |
| |
| def buildindex(title, asf_license): |
| """Write an index file for later conversion using mvn site""" |
| versions = glob("[0-9]*.[0-9]*.[0-9]*") |
| versions.sort(key=LooseVersion, reverse=True) |
| with open("index.md", "w") as indexfile: |
| if asf_license is True: |
| indexfile.write(ASF_LICENSE) |
| for version in versions: |
| indexfile.write("* %s v%s\n" % (title, version)) |
| for k in ("Changes", "Release Notes"): |
| indexfile.write(" * [%s](%s/%s.%s.html)\n" \ |
| % (k, version, k.upper().replace(" ", ""), version)) |
| |
| def buildreadme(title, asf_license): |
| """Write an index file for Github using README.md""" |
| versions = glob("[0-9]*.[0-9]*.[0-9]*") |
| versions.sort(key=LooseVersion, reverse=True) |
| with open("README.md", "w") as indexfile: |
| if asf_license is True: |
| indexfile.write(ASF_LICENSE) |
| for version in versions: |
| indexfile.write("* %s v%s\n" % (title, version)) |
| for k in ("Changes", "Release Notes"): |
| indexfile.write(" * [%s](%s/%s.%s.md)\n" \ |
| % (k, version, k.upper().replace(" ", ""), version)) |
| |
| class GetVersions(object): |
| """ List of version strings """ |
| def __init__(self, versions, projects): |
| versions = versions |
| projects = projects |
| self.newversions = [] |
| versions.sort(key=LooseVersion) |
| print "Looking for %s through %s"%(versions[0], versions[-1]) |
| newversions = set() |
| for project in projects: |
| url = JIRA_BASE_URL + "/rest/api/2/project/%s/versions" % project.upper() |
| resp = urllib2.urlopen(url) |
| datum = json.loads(resp.read()) |
| for data in datum: |
| newversions.add(data['name']) |
| newversions.add(versions[0]) |
| newversions.add(versions[-1]) |
| newlist = newversions.copy() |
| newlist = list(newlist) |
| newlist.sort(key=LooseVersion) |
| for newversion in newlist[newlist.index(versions[0]):newlist.index(versions[-1])+1]: |
| if newversion in newversions: |
| print "Adding %s to the list" % newversion |
| self.newversions.append(newversion) |
| |
| def getlist(self): |
| return self.newversions |
| |
| class Version(object): |
| """Represents a version number""" |
| def __init__(self, data): |
| self.mod = False |
| self.data = data |
| found = re.match(r'^((\d+)(\.\d+)*).*$', data) |
| if found: |
| self.parts = [int(p) for p in found.group(1).split('.')] |
| else: |
| self.parts = [] |
| # backfill version with zeroes if missing parts |
| self.parts.extend((0,) * (3 - len(self.parts))) |
| |
| def __str__(self): |
| if self.mod: |
| return '.'.join([str(p) for p in self.parts]) |
| return self.data |
| |
| def __cmp__(self, other): |
| return cmp(self.parts, other.parts) |
| |
| class Jira(object): |
| """A single JIRA""" |
| |
| def __init__(self, data, parent): |
| self.key = data['key'] |
| self.fields = data['fields'] |
| self.parent = parent |
| self.notes = None |
| self.incompat = None |
| self.reviewed = None |
| self.important = None |
| |
| def get_id(self): |
| return mstr(self.key) |
| |
| def get_description(self): |
| return mstr(self.fields['description']) |
| |
| def get_release_note(self): |
| if self.notes is None: |
| field = self.parent.field_id_map['Release Note'] |
| if self.fields.has_key(field): |
| self.notes = mstr(self.fields[field]) |
| elif self.get_incompatible_change() or self.get_important(): |
| self.notes = self.get_description() |
| else: |
| self.notes = "" |
| return self.notes |
| |
| def get_priority(self): |
| ret = "" |
| pri = self.fields['priority'] |
| if pri is not None: |
| ret = pri['name'] |
| return mstr(ret) |
| |
| def get_assignee(self): |
| ret = "" |
| mid = self.fields['assignee'] |
| if mid is not None: |
| ret = mid['displayName'] |
| return mstr(ret) |
| |
| def get_components(self): |
| if len(self.fields['components']) > 0: |
| return ", ".join([comp['name'] for comp in self.fields['components']]) |
| else: |
| return "" |
| |
| def get_summary(self): |
| return self.fields['summary'] |
| |
| def get_type(self): |
| ret = "" |
| mid = self.fields['issuetype'] |
| if mid is not None: |
| ret = mid['name'] |
| return mstr(ret) |
| |
| def get_reporter(self): |
| ret = "" |
| mid = self.fields['reporter'] |
| if mid is not None: |
| ret = mid['displayName'] |
| return mstr(ret) |
| |
| def get_project(self): |
| ret = "" |
| mid = self.fields['project'] |
| if mid is not None: |
| ret = mid['key'] |
| return mstr(ret) |
| |
| def __cmp__(self, other): |
| selfsplit = self.get_id().split('-') |
| othersplit = other.get_id().split('-') |
| result = cmp(selfsplit[0], othersplit[0]) |
| if result != 0: |
| return result |
| else: |
| if selfsplit[1] < othersplit[1]: |
| return True |
| elif selfsplit[1] > othersplit[1]: |
| return False |
| return False |
| |
| def get_incompatible_change(self): |
| if self.incompat is None: |
| field = self.parent.field_id_map['Hadoop Flags'] |
| self.reviewed = False |
| self.incompat = False |
| if self.fields.has_key(field): |
| if self.fields[field]: |
| for flag in self.fields[field]: |
| if flag['value'] == "Incompatible change": |
| self.incompat = True |
| if flag['value'] == "Reviewed": |
| self.reviewed = True |
| return self.incompat |
| |
| def get_important(self): |
| if self.important is None: |
| field = self.parent.field_id_map['Flags'] |
| self.important = False |
| if self.fields.has_key(field): |
| if self.fields[field]: |
| for flag in self.fields[field]: |
| if flag['value'] == "Important": |
| self.important = True |
| return self.important |
| |
| def check_missing_component(self): |
| if len(self.fields['components']) > 0: |
| return False |
| return True |
| |
| def check_missing_assignee(self): |
| if self.fields['assignee'] is not None: |
| return False |
| return True |
| |
| def check_version_string(self): |
| field = self.parent.field_id_map['Fix Version/s'] |
| for ver in self.fields[field]: |
| found = re.match(r'^((\d+)(\.\d+)*).*$|^(\w+\-\d+)$', ver['name']) |
| if not found: |
| return True |
| return False |
| |
| def get_release_date(self, version): |
| fix_versions = self.fields['fixVersions'] |
| for j in range(len(fix_versions)): |
| if fix_versions[j] == version: |
| return fix_versions[j]['releaseDate'] |
| return None |
| |
| class JiraIter(object): |
| """An Iterator of JIRAs""" |
| |
| @staticmethod |
| def collect_fields(): |
| """send a query to JIRA and collect field-id map""" |
| resp = urllib2.urlopen(JIRA_BASE_URL + "/rest/api/2/field") |
| data = json.loads(resp.read()) |
| field_id_map = {} |
| for part in data: |
| field_id_map[part['name']] = part['id'] |
| return field_id_map |
| |
| @staticmethod |
| def query_jira(ver, projects, pos): |
| """send a query to JIRA and collect a certain number of issue information""" |
| count = 100 |
| pjs = "','".join(projects) |
| jql = "project in ('%s') and fixVersion in ('%s') and resolution = Fixed" % (pjs, ver) |
| params = urllib.urlencode({'jql':jql, 'startAt':pos, 'maxResults':count}) |
| try: |
| resp = urllib2.urlopen(JIRA_BASE_URL + "/rest/api/2/search?%s" % params) |
| except urllib2.HTTPError, err: |
| code = err.code |
| print "JIRA returns HTTP error %d: %s. Aborting." % (code, err.msg) |
| if code == 400: |
| print "Please make sure the specified projects are correct." |
| sys.exit(1) |
| data = json.loads(resp.read()) |
| return data |
| |
| @staticmethod |
| def collect_jiras(ver, projects): |
| """send queries to JIRA and collect all issues that belongs to given version and projects""" |
| jiras = [] |
| pos = 0 |
| end = 1 |
| while pos < end: |
| data = JiraIter.query_jira(ver, projects, pos) |
| if data.has_key('error_messages'): |
| print "JIRA returns error message: %s" % data['error_messages'] |
| sys.exit(1) |
| pos = data['startAt'] + data['maxResults'] |
| end = data['total'] |
| jiras.extend(data['issues']) |
| |
| if ver not in RELEASE_VERSION: |
| for issue in data['issues']: |
| for fix_version in issue['fields']['fixVersions']: |
| if 'releaseDate' in fix_version: |
| RELEASE_VERSION[fix_version['name']] = fix_version['releaseDate'] |
| return jiras |
| |
| def __init__(self, version, projects): |
| self.version = version |
| self.projects = projects |
| self.field_id_map = JiraIter.collect_fields() |
| ver = str(version).replace("-SNAPSHOT", "") |
| self.jiras = JiraIter.collect_jiras(ver, projects) |
| self.iter = self.jiras.__iter__() |
| |
| def __iter__(self): |
| return self |
| |
| def next(self): |
| data = self.iter.next() |
| j = Jira(data, self) |
| return j |
| |
| class Outputs(object): |
| """Several different files to output to at the same time""" |
| |
| def __init__(self, base_file_name, file_name_pattern, keys, params=None): |
| if params is None: |
| params = {} |
| self.params = params |
| self.base = open(base_file_name%params, 'w') |
| self.others = {} |
| for key in keys: |
| both = dict(params) |
| both['key'] = key |
| self.others[key] = open(file_name_pattern%both, 'w') |
| |
| def write_all(self, pattern): |
| both = dict(self.params) |
| both['key'] = '' |
| self.base.write(pattern%both) |
| for key in self.others.keys(): |
| both = dict(self.params) |
| both['key'] = key |
| self.others[key].write(pattern%both) |
| |
| def write_key_raw(self, key, _str): |
| self.base.write(_str) |
| if self.others.has_key(key): |
| self.others[key].write(_str) |
| |
| def close(self): |
| self.base.close() |
| for value in self.others.values(): |
| value.close() |
| |
| def write_list(self, mylist): |
| for jira in sorted(mylist): |
| line = '| [%s](' + JIRA_BASE_URL + '/browse/%s) | %s | %s | %s | %s | %s |\n' |
| line = line % (textsanitize(jira.get_id()), |
| textsanitize(jira.get_id()), |
| textsanitize(jira.get_summary()), |
| textsanitize(jira.get_priority()), |
| format_components(jira.get_components()), |
| textsanitize(jira.get_reporter()), |
| textsanitize(jira.get_assignee())) |
| self.write_key_raw(jira.get_project(), line) |
| |
| def main(): |
| usage = "usage: %prog --project PROJECT [--project PROJECT] --version VERSION [--version VERSION2 ...]" |
| parser = OptionParser(usage=usage, |
| epilog="Markdown-formatted CHANGES and RELEASENOTES files will be stored" |
| "in a directory named after the highest version provided.") |
| parser.add_option("-i", "--index", dest="index", action="store_true", |
| default=False, help="build an index file") |
| parser.add_option("-l", "--license", dest="license", action="store_true", |
| default=False, help="Add an ASF license") |
| parser.add_option("-n", "--lint", dest="lint", action="store_true", |
| help="use lint flag to exit on failures") |
| parser.add_option("-p", "--project", dest="projects", |
| action="append", type="string", |
| help="projects in JIRA to include in releasenotes", metavar="PROJECT") |
| parser.add_option("-r", "--range", dest="range", action="store_true", |
| default=False, help="Given versions are a range") |
| parser.add_option("-t", "--projecttitle", dest="title", type="string", |
| help="Title to use for the project (default is Apache PROJECT)") |
| parser.add_option("-u", "--usetoday", dest="usetoday", action="store_true", |
| default=False, help="use current date for unreleased versions") |
| parser.add_option("-v", "--version", dest="versions", action="append", type="string", |
| help="versions in JIRA to include in releasenotes", metavar="VERSION") |
| parser.add_option("-V", dest="release_version", action="store_true", default=False, |
| help="display version information for releasedocmaker and exit.") |
| parser.add_option("-O", "--outputdir", dest="output_directory", action="append", type="string", |
| help="specify output directory to put release docs to.") |
| parser.add_option("-B", "--baseurl", dest="base_url", action="append", type="string", |
| help="specify base URL of the JIRA instance.") |
| (options, _) = parser.parse_args() |
| |
| if options.release_version: |
| with open(os.path.join(os.path.dirname(__file__), "../VERSION"), 'r') as ver_file: |
| print ver_file.read() |
| sys.exit(0) |
| |
| if options.versions is None: |
| parser.error("At least one version needs to be supplied") |
| |
| if options.output_directory is not None: |
| if len(options.output_directory) > 1: |
| parser.error("Only one output directory should be given") |
| if not os.path.isdir(options.output_directory[0]): |
| try: |
| os.makedirs(options.output_directory[0]) |
| except OSError: |
| parser.error("Unable to create output directory that does not exist") |
| os.chdir(options.output_directory[0]) |
| |
| if options.base_url is not None: |
| if len(options.base_url) > 1: |
| parser.error("Only one base URL should be given") |
| global JIRA_BASE_URL |
| JIRA_BASE_URL = options.base_url[0] |
| |
| proxy = urllib2.ProxyHandler() |
| opener = urllib2.build_opener(proxy) |
| urllib2.install_opener(opener) |
| |
| projects = options.projects |
| if projects is None: |
| parser.error("At least one project needs to be supplied") |
| |
| if options.range is True: |
| versions = [Version(v) for v in GetVersions(options.versions, projects).getlist()] |
| else: |
| versions = [Version(v) for v in options.versions] |
| versions.sort() |
| |
| if options.title is None: |
| title = projects[0] |
| else: |
| title = options.title |
| |
| haderrors = False |
| |
| for version in versions: |
| vstr = str(version) |
| jlist = sorted(JiraIter(vstr, projects)) |
| if len(jlist) == 0: |
| print "There is no issue which has the specified version: %s" % version |
| continue |
| |
| if vstr in RELEASE_VERSION: |
| reldate = RELEASE_VERSION[vstr] |
| elif options.usetoday: |
| reldate = strftime("%Y-%m-%d", gmtime()) |
| else: |
| reldate = "Unreleased (as of %s)" % strftime("%Y-%m-%d", gmtime()) |
| |
| if not os.path.exists(vstr): |
| os.mkdir(vstr) |
| |
| reloutputs = Outputs("%(ver)s/RELEASENOTES.%(ver)s.md", |
| "%(ver)s/RELEASENOTES.%(key)s.%(ver)s.md", |
| [], {"ver":version, "date":reldate, "title":title}) |
| choutputs = Outputs("%(ver)s/CHANGES.%(ver)s.md", |
| "%(ver)s/CHANGES.%(key)s.%(ver)s.md", |
| [], {"ver":version, "date":reldate, "title":title}) |
| |
| if options.license is True: |
| reloutputs.write_all(ASF_LICENSE) |
| choutputs.write_all(ASF_LICENSE) |
| |
| relhead = '# %(title)s %(key)s %(ver)s Release Notes\n\n' \ |
| 'These release notes cover new developer and user-facing ' \ |
| 'incompatibilities, important issues, features, and major improvements.\n\n' |
| chhead = '# %(title)s Changelog\n\n' \ |
| '## Release %(ver)s - %(date)s\n'\ |
| '\n' |
| |
| reloutputs.write_all(relhead) |
| choutputs.write_all(chhead) |
| error_count = 0 |
| warning_count = 0 |
| lint_message = "" |
| incompatlist = [] |
| importantlist = [] |
| buglist = [] |
| improvementlist = [] |
| newfeaturelist = [] |
| subtasklist = [] |
| tasklist = [] |
| testlist = [] |
| otherlist = [] |
| |
| for jira in jlist: |
| if jira.get_incompatible_change(): |
| incompatlist.append(jira) |
| elif jira.get_important(): |
| importantlist.append(jira) |
| elif jira.get_type() == "Bug": |
| buglist.append(jira) |
| elif jira.get_type() == "Improvement": |
| improvementlist.append(jira) |
| elif jira.get_type() == "New Feature": |
| newfeaturelist.append(jira) |
| elif jira.get_type() == "Sub-task": |
| subtasklist.append(jira) |
| elif jira.get_type() == "Task": |
| tasklist.append(jira) |
| elif jira.get_type() == "Test": |
| testlist.append(jira) |
| else: |
| otherlist.append(jira) |
| |
| line = '* [%s](' % (textsanitize(jira.get_id())) + JIRA_BASE_URL + \ |
| '/browse/%s) | *%s* | **%s**\n' \ |
| % (textsanitize(jira.get_id()), |
| textsanitize(jira.get_priority()), textsanitize(jira.get_summary())) |
| |
| if jira.get_incompatible_change() and len(jira.get_release_note()) == 0: |
| warning_count += 1 |
| reloutputs.write_key_raw(jira.get_project(), "\n---\n\n") |
| reloutputs.write_key_raw(jira.get_project(), line) |
| line = '\n**WARNING: No release note provided for this incompatible change.**\n\n' |
| lint_message += "\nWARNING: incompatible change %s lacks release notes." % \ |
| (textsanitize(jira.get_id())) |
| reloutputs.write_key_raw(jira.get_project(), line) |
| |
| if jira.get_important() and len(jira.get_release_note()) == 0: |
| warning_count += 1 |
| reloutputs.write_key_raw(jira.get_project(), "\n---\n\n") |
| reloutputs.write_key_raw(jira.get_project(), line) |
| line = '\n**WARNING: No release note provided for this important issue.**\n\n' |
| lint_message += "\nWARNING: important issue %s lacks release notes." % \ |
| (textsanitize(jira.get_id())) |
| reloutputs.write_key_raw(jira.get_project(), line) |
| |
| if jira.check_version_string(): |
| warning_count += 1 |
| lint_message += "\nWARNING: Version string problem for %s " % jira.get_id() |
| |
| if jira.check_missing_component() or jira.check_missing_assignee(): |
| error_count += 1 |
| error_message = [] |
| if jira.check_missing_component(): |
| error_message.append("component") |
| if jira.check_missing_assignee(): |
| error_message.append("assignee") |
| lint_message += "\nERROR: missing %s for %s " \ |
| % (" and ".join(error_message), jira.get_id()) |
| |
| if len(jira.get_release_note()) > 0: |
| reloutputs.write_key_raw(jira.get_project(), "\n---\n\n") |
| reloutputs.write_key_raw(jira.get_project(), line) |
| line = '\n%s\n\n' % (processrelnote(jira.get_release_note())) |
| reloutputs.write_key_raw(jira.get_project(), line) |
| |
| if options.lint is True: |
| print lint_message |
| print "=======================================" |
| print "%s: Error:%d, Warning:%d \n" % (vstr, error_count, warning_count) |
| if error_count > 0: |
| haderrors = True |
| clean_output_dir(vstr) |
| continue |
| |
| reloutputs.write_all("\n\n") |
| reloutputs.close() |
| |
| choutputs.write_all("### INCOMPATIBLE CHANGES:\n\n") |
| choutputs.write_all("| JIRA | Summary | Priority | Component | Reporter | Contributor |\n") |
| choutputs.write_all("|:---- |:---- | :--- |:---- |:---- |:---- |\n") |
| choutputs.write_list(incompatlist) |
| |
| choutputs.write_all("\n\n### IMPORTANT ISSUES:\n\n") |
| choutputs.write_all("| JIRA | Summary | Priority | Component | Reporter | Contributor |\n") |
| choutputs.write_all("|:---- |:---- | :--- |:---- |:---- |:---- |\n") |
| choutputs.write_list(importantlist) |
| |
| choutputs.write_all("\n\n### NEW FEATURES:\n\n") |
| choutputs.write_all("| JIRA | Summary | Priority | Component | Reporter | Contributor |\n") |
| choutputs.write_all("|:---- |:---- | :--- |:---- |:---- |:---- |\n") |
| choutputs.write_list(newfeaturelist) |
| |
| choutputs.write_all("\n\n### IMPROVEMENTS:\n\n") |
| choutputs.write_all("| JIRA | Summary | Priority | Component | Reporter | Contributor |\n") |
| choutputs.write_all("|:---- |:---- | :--- |:---- |:---- |:---- |\n") |
| choutputs.write_list(improvementlist) |
| |
| choutputs.write_all("\n\n### BUG FIXES:\n\n") |
| choutputs.write_all("| JIRA | Summary | Priority | Component | Reporter | Contributor |\n") |
| choutputs.write_all("|:---- |:---- | :--- |:---- |:---- |:---- |\n") |
| choutputs.write_list(buglist) |
| |
| choutputs.write_all("\n\n### TESTS:\n\n") |
| choutputs.write_all("| JIRA | Summary | Priority | Component | Reporter | Contributor |\n") |
| choutputs.write_all("|:---- |:---- | :--- |:---- |:---- |:---- |\n") |
| choutputs.write_list(testlist) |
| |
| choutputs.write_all("\n\n### SUB-TASKS:\n\n") |
| choutputs.write_all("| JIRA | Summary | Priority | Component | Reporter | Contributor |\n") |
| choutputs.write_all("|:---- |:---- | :--- |:---- |:---- |:---- |\n") |
| choutputs.write_list(subtasklist) |
| |
| choutputs.write_all("\n\n### OTHER:\n\n") |
| choutputs.write_all("| JIRA | Summary | Priority | Component | Reporter | Contributor |\n") |
| choutputs.write_all("|:---- |:---- | :--- |:---- |:---- |:---- |\n") |
| choutputs.write_list(otherlist) |
| choutputs.write_list(tasklist) |
| |
| choutputs.write_all("\n\n") |
| choutputs.close() |
| |
| if options.index: |
| buildindex(title, options.license) |
| buildreadme(title, options.license) |
| |
| if haderrors is True: |
| sys.exit(1) |
| |
| if __name__ == "__main__": |
| main() |
