yetus-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a.@apache.org
Subject [01/14] yetus git commit: YETUS-6 Reoganize repository for split to TLP.
Date Wed, 28 Oct 2015 15:27:18 GMT
Repository: yetus
Updated Branches:
  refs/heads/YETUS-83 06655ab3d -> 67f42f1ae (forced update)


http://git-wip-us.apache.org/repos/asf/yetus/blob/6f38afa5/release-doc-maker/releasedocmaker.py
----------------------------------------------------------------------
diff --git a/release-doc-maker/releasedocmaker.py b/release-doc-maker/releasedocmaker.py
new file mode 100755
index 0000000..ae3ce45
--- /dev/null
+++ b/release-doc-maker/releasedocmaker.py
@@ -0,0 +1,642 @@
+#!/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
+
+RELEASE_VERSION = {}
+NAME_PATTERN = re.compile(r' \([0-9]+\)')
+RELNOTE_PATTERN = re.compile('^\<\!\-\- ([a-z]+) \-\-\>')
+
+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 tableclean(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
+# protect some known md metachars
+# or chars that screw up doxia
+def tableclean(_str):
+    _str = _str.encode('utf-8')
+    _str = _str.replace("_", r"\_")
+    _str = _str.replace("\r", "")
+    _str = _str.rstrip()
+    return _str
+
+# same thing as tableclean,
+# except table metachars are also
+# escaped as well as more
+# things we don't want doxia to
+# screw up
+def notableclean(_str):
+    _str = tableclean(_str)
+    _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 notableclean(_str)
+  else:
+      return {
+        'markdown' : tableclean(_str),
+      }.get(fmt.group(1),notableclean(_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])
+        for project in projects:
+            url = "https://issues.apache.org/jira/rest/api/2/project/%s/versions" % project
+            resp = urllib2.urlopen(url)
+            datum = json.loads(resp.read())
+            for data in datum:
+                name = data['name']
+                if name[0].isdigit and versions[0] <= name and name <= versions[-1]:
+                    print "Adding %s to the list" % name
+                    self.newversions.append(name)
+        newlist = list(set(self.newversions))
+        self.newversions = newlist
+
+    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"""
+
+    def __init__(self, version, projects):
+        self.version = version
+        self.projects = projects
+        ver = str(version).replace("-SNAPSHOT", "")
+
+        resp = urllib2.urlopen("https://issues.apache.org/jira/rest/api/2/field")
+        data = json.loads(resp.read())
+
+        self.field_id_map = {}
+        for part in data:
+            self.field_id_map[part['name']] = part['id']
+
+        self.jiras = []
+        pos = 0
+        end = 1
+        count = 100
+        while pos < end:
+            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})
+            resp = urllib2.urlopen("https://issues.apache.org/jira/rest/api/2/search?%s"
% params)
+            data = json.loads(resp.read())
+            if data.has_key('error_messages'):
+                raise Exception(data['error_messages'])
+            pos = data['startAt'] + data['maxResults']
+            end = data['total']
+            self.jiras.extend(data['issues'])
+
+            needaversion = False
+            if ver not in RELEASE_VERSION:
+                needaversion = True
+
+            if needaversion is True:
+                issues = data['issues']
+                for i in range(len(issues)):
+                    fix_versions = issues[i]['fields']['fixVersions']
+                    for j in range(len(fix_versions)):
+                        fields = fix_versions[j]
+                        if 'releaseDate' in fields:
+                            RELEASE_VERSION[fields['name']] = fields['releaseDate']
+
+        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](https://issues.apache.org/jira/browse/%s) | %s |  %s | %s | %s
| %s |\n'
+            line = line % (notableclean(jira.get_id()),
+                           notableclean(jira.get_id()),
+                           notableclean(jira.get_summary()),
+                           notableclean(jira.get_priority()),
+                           format_components(jira.get_components()),
+                           notableclean(jira.get_reporter()),
+                           notableclean(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_false",
+                      default=True, 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")
+    (options, _) = parser.parse_args()
+
+    if options.versions is None:
+        parser.error("At least one version needs to be supplied")
+
+    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 = JiraIter(vstr, projects)
+
+        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 sorted(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](https://issues.apache.org/jira/browse/%s) | *%s* | **%s**\n' \
+                   % (notableclean(jira.get_id()), notableclean(jira.get_id()),
+                      notableclean(jira.get_priority()), notableclean(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."
% \
+                                (notableclean(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." % \
+                                (notableclean(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()

http://git-wip-us.apache.org/repos/asf/yetus/blob/6f38afa5/shelldocs/shelldocs.py
----------------------------------------------------------------------
diff --git a/shelldocs/shelldocs.py b/shelldocs/shelldocs.py
new file mode 100755
index 0000000..7a1fe21
--- /dev/null
+++ b/shelldocs/shelldocs.py
@@ -0,0 +1,274 @@
+#!/usr/bin/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.
+
+import re
+import sys
+import string
+from optparse import OptionParser
+
+asflicense='''
+<!---
+# 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 docstrip(key,string):
+  string=re.sub("^## @%s " % key ,"",string)
+  string=string.lstrip()
+  string=string.rstrip()
+  return string
+
+def toc(list):
+  tocout=[]
+  header=()
+  for i in list:
+    if header != i.getinter():
+      header=i.getinter()
+      line="  * %s\n" % (i.headerbuild())
+      tocout.append(line)
+    line="    * [%s](#%s)\n" % (i.getname().replace("_","\_"),i.getname())
+    tocout.append(line)
+  return tocout
+
+class ShellFunction:
+  def __init__(self):
+    self.reset()
+
+  def __cmp__(self,other):
+    if (self.audience == other.audience):
+      if (self.stability == other.stability):
+        if (self.replaceb == other.replaceb):
+          return(cmp(self.name,other.name))
+        else:
+          if (self.replaceb == "Yes"):
+            return -1
+          else:
+            return 1
+      else:
+          if (self.stability == "Stable"):
+            return -1
+          else:
+            return 1
+    else:
+      if (self.audience == "Public"):
+        return -1
+      else:
+        return 1
+
+  def reset(self):
+    self.name=None
+    self.audience=None
+    self.stability=None
+    self.replaceb=None
+    self.returnt=None
+    self.desc=None
+    self.params=None
+
+  def setname(self,text):
+    definition=text.split();
+    self.name=definition[1]
+
+  def getname(self):
+    if (self.name is None):
+      return "None"
+    else:
+      return self.name
+
+  def setaudience(self,text):
+    self.audience=docstrip("audience",text)
+    self.audience=self.audience.capitalize()
+
+  def getaudience(self):
+    if (self.audience is None):
+      return "None"
+    else:
+      return self.audience
+
+  def setstability(self,text):
+    self.stability=docstrip("stability",text)
+    self.stability=self.stability.capitalize()
+
+  def getstability(self):
+    if (self.stability is None):
+      return "None"
+    else:
+      return self.stability
+
+  def setreplace(self,text):
+    self.replaceb=docstrip("replaceable",text)
+    self.replaceb=self.replaceb.capitalize()
+
+  def getreplace(self):
+    if (self.replaceb is None):
+      return "None"
+    else:
+      return self.replaceb
+
+  def getinter(self):
+    return( (self.getaudience(), self.getstability(), self.getreplace()))
+
+  def addreturn(self,text):
+    if (self.returnt is None):
+      self.returnt = []
+    self.returnt.append(docstrip("return",text))
+
+  def getreturn(self):
+    if (self.returnt is None):
+      return "Nothing"
+    else:
+      return "\n\n".join(self.returnt)
+
+  def adddesc(self,text):
+    if (self.desc is None):
+      self.desc = []
+    self.desc.append(docstrip("description",text))
+
+  def getdesc(self):
+    if (self.desc is None):
+      return "None"
+    else:
+      return " ".join(self.desc)
+
+  def addparam(self,text):
+    if (self.params is None):
+      self.params = []
+    self.params.append(docstrip("param",text))
+
+  def getparams(self):
+    if (self.params is None):
+      return ""
+    else:
+      return " ".join(self.params)
+
+  def getusage(self):
+    line="%s %s" % (self.name, self.getparams())
+    return line
+
+  def headerbuild(self):
+    if self.getreplace() == "Yes":
+      replacetext="Replaceable"
+    else:
+      replacetext="Not Replaceable"
+    line="%s/%s/%s" % (self.getaudience(), self.getstability(), replacetext)
+    return(line)
+
+  def getdocpage(self):
+    line="### `%s`\n\n"\
+         "* Synopsis\n\n"\
+         "```\n%s\n"\
+         "```\n\n" \
+         "* Description\n\n" \
+         "%s\n\n" \
+         "* Returns\n\n" \
+         "%s\n\n" \
+         "| Classification | Level |\n" \
+         "| :--- | :--- |\n" \
+         "| Audience | %s |\n" \
+         "| Stability | %s |\n" \
+         "| Replaceable | %s |\n\n" \
+         % (self.getname(),
+            self.getusage(),
+            self.getdesc(),
+            self.getreturn(),
+            self.getaudience(),
+            self.getstability(),
+            self.getreplace())
+    return line
+
+  def __str__(self):
+    line="{%s %s %s %s}" \
+      % (self.getname(),
+         self.getaudience(),
+         self.getstability(),
+         self.getreplace())
+    return line
+
+def main():
+  parser=OptionParser(usage="usage: %prog --skipprnorep --output OUTFILE --input INFILE [--input
INFILE ...]")
+  parser.add_option("-o","--output", dest="outfile",
+     action="store", type="string",
+     help="file to create", metavar="OUTFILE")
+  parser.add_option("-i","--input", dest="infile",
+     action="append", type="string",
+     help="file to read", metavar="INFILE")
+  parser.add_option("--skipprnorep", dest="skipprnorep",
+     action="store_true", help="Skip Private & Not Replaceable")
+
+  (options, args)=parser.parse_args()
+
+  allfuncs=[]
+  for filename in options.infile:
+    with open(filename,"r") as shellcode:
+      funcdef=ShellFunction()
+      for line in shellcode:
+        if line.startswith('## @description'):
+          funcdef.adddesc(line)
+        elif line.startswith('## @audience'):
+          funcdef.setaudience(line)
+        elif line.startswith('## @stability'):
+          funcdef.setstability(line)
+        elif line.startswith('## @replaceable'):
+          funcdef.setreplace(line)
+        elif line.startswith('## @param'):
+          funcdef.addparam(line)
+        elif line.startswith('## @return'):
+          funcdef.addreturn(line)
+        elif line.startswith('function'):
+          funcdef.setname(line)
+          if options.skipprnorep and \
+            funcdef.getaudience() == "Private" and \
+            funcdef.getreplace() == "No":
+               pass
+          else:
+            allfuncs.append(funcdef)
+          funcdef=ShellFunction()
+
+  allfuncs=sorted(allfuncs)
+
+  outfile=open(options.outfile, "w")
+  outfile.write(asflicense)
+  for line in toc(allfuncs):
+    outfile.write(line)
+
+  outfile.write("\n------\n\n")
+
+  header=[]
+  for funcs in allfuncs:
+    if header != funcs.getinter():
+      header=funcs.getinter()
+      line="## %s\n" % (funcs.headerbuild())
+      outfile.write(line)
+    outfile.write(funcs.getdocpage())
+  outfile.close()
+
+if __name__ == "__main__":
+  main()
+


Mime
View raw message