| #!/usr/bin/python |
| # |
| # Licensed 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() |
| |
