def prepOutputDirectory(self):
os.makedirs(self.base, exist_ok=True)
shutil.copyfile(templatefile('apidocs.css'),
os.path.join(self.base, 'apidocs.css'))
shutil.copyfile(templatefile('bootstrap.min.css'),
os.path.join(self.base, 'bootstrap.min.css'))
shutil.copyfile(templatefile('pydoctor.js'),
os.path.join(self.base, 'pydoctor.js'))
def prepOutputDirectory(self):
if not os.path.exists(self.base):
os.mkdir(self.base)
shutil.copyfile(templatefile('apidocs.css'),
os.path.join(self.base, 'apidocs.css'))
shutil.copyfile(templatefile('bootstrap.min.css'),
os.path.join(self.base, 'bootstrap.min.css'))
shutil.copyfile(templatefile('pydoctor.js'),
os.path.join(self.base, 'pydoctor.js'))
def prepOutputDirectory(self):
if not os.path.exists(self.base):
os.mkdir(self.base)
shutil.copyfile(templatefile('apidocs.css'),
os.path.join(self.base, 'apidocs.css'))
shutil.copyfile(templatefile('bootstrap.min.css'),
os.path.join(self.base, 'bootstrap.min.css'))
shutil.copyfile(templatefile('pydoctor.js'),
os.path.join(self.base, 'pydoctor.js'))
def prepOutputDirectory(self):
if not os.path.exists(self.base):
os.mkdir(self.base)
shutil.copyfile(templatefile("apidocs.css"),
os.path.join(self.base, "apidocs.css"))
shutil.copyfile(
templatefile("bootstrap.min.css"),
os.path.join(self.base, "bootstrap.min.css"),
)
shutil.copyfile(templatefile("pydoctor.js"),
os.path.join(self.base, "pydoctor.js"))
def prepOutputDirectory(self):
if not os.path.exists(self.base):
os.mkdir(self.base)
shutil.copyfile(templatefile('apidocs.css'),
os.path.join(self.base, 'apidocs.css'))
if self.system.options.htmlusesorttable:
shutil.copyfile(templatefile('sorttable.js'),
os.path.join(self.base, 'sorttable.js'))
if self.system.options.htmlusesplitlinks or self.system.options.htmlshortenlists:
shutil.copyfile(templatefile('pydoctor.js'),
os.path.join(self.base, 'pydoctor.js'))
def prepOutputDirectory(self):
if not os.path.exists(self.base):
os.mkdir(self.base)
shutil.copyfile(templatefile('apidocs.css'),
os.path.join(self.base, 'apidocs.css'))
if self.system.options.htmlusesorttable:
shutil.copyfile(templatefile('sorttable.js'),
os.path.join(self.base, 'sorttable.js'))
if self.system.options.htmlusesplitlinks or self.system.options.htmlshortenlists:
shutil.copyfile(templatefile('pydoctor.js'),
os.path.join(self.base, 'pydoctor.js'))
def __init__(self, system):
resource.Resource.__init__(self)
self.system = system
self.putChild('apidocs.css', File(util.templatefile('apidocs.css')))
self.putChild('sorttable.js', File(util.templatefile('sorttable.js')))
self.putChild('pydoctor.js', File(util.templatefile('pydoctor.js')))
self.index = WrapperPage(self.indexPage())
self.putChild('', self.index)
self.putChild('index.html', self.index)
self.putChild('moduleIndex.html',
WrapperPage(summary.ModuleIndexPage(self.system)))
self.putChild('classIndex.html',
WrapperPage(summary.ClassIndexPage(self.system)))
self.putChild('nameIndex.html',
WrapperPage(summary.NameIndexPage(self.system)))
class NameIndexPage(Element):
filename = 'nameIndex.html'
loader = XMLFile(templatefile('nameIndex.html'))
def __init__(self, system):
self.system = system
self.initials = {}
for ob in self.system.orderedallobjects:
if ob.isVisible:
self.initials.setdefault(ob.name[0].upper(), []).append(ob)
@renderer
def title(self, request, tag):
return tag.clear()("Index Of Names")
@renderer
def heading(self, request, tag):
return tag.clear()("Index Of Names")
@renderer
def index(self, request, tag):
r = []
for i in sorted(self.initials):
r.append(LetterElement(TagLoader(tag), self.initials, i))
return r
class DiffElement(Element):
def __init__(self, root, ob, origob, editA, editB):
self.root = root
self.ob = ob
self.origob = origob
self.editA = editA
self.editB = editB
@renderer
def title(self, request, tag):
return tag("Viewing differences between revisions ",
str(self.editA.rev), " and ", str(self.editB.rev), " of ",
u"\N{LEFT DOUBLE QUOTATION MARK}" +
self.origob.fullName() +
u"\N{RIGHT DOUBLE QUOTATION MARK}")
@renderer
def diff(self, request, tag):
fd = FileDiff(self.ob.parentMod)
fd.apply_edit(self.root.editsbyob[self.ob][0], self.editA)
fd.reset()
fd.apply_edit(self.editA, self.editB)
return tags.pre(fd.diff())
loader = XMLFile(util.templatefile('diff.html'))
class ClassIndexPage(Element):
filename = 'classIndex.html'
loader = XMLFile(templatefile('summary.html'))
def __init__(self, system):
self.system = system
@renderer
def title(self, request, tag):
return tag.clear()("Class Hierarchy")
@renderer
def stuff(self, request, tag):
t = tag
anchors = set()
for b, o in findRootClasses(self.system):
if isinstance(o, model.Class):
t(subclassesFrom(self.system, o, anchors))
else:
item = tags.li(b)
if o:
ul = tags.ul()
for sc in sorted(o, key=_lckey):
ul(subclassesFrom(self.system, sc, anchors))
item(ul)
t(item)
return t
@renderer
def heading(self, request, tag):
return tag.clear()("Class Hierarchy")
class UndocumentedSummaryPage(Element):
filename = 'undoccedSummary.html'
loader = XMLFile(templatefile('summary.html'))
def __init__(self, system):
self.system = system
@renderer
def title(self, request, tag):
return tag.clear()("Summary of Undocumented Objects")
@renderer
def heading(self, request, tag):
return tag.clear()("Summary of Undocumented Objects")
@renderer
def stuff(self, request, tag):
undoccedpublic = [
o for o in self.system.orderedallobjects
if o.isVisible and not hasdocstring(o)
]
undoccedpublic.sort(key=lambda o: o.fullName())
for o in undoccedpublic:
tag(tags.li(o.kind, " - ", taglink(o)))
return tag
class IndexPage(Element):
filename = 'index.html'
loader = XMLFile(templatefile('index.html'))
def __init__(self, system):
self.system = system
@renderer
def project_link(self, request, tag):
if self.system.options.projecturl:
return tags.a(href=self.system.options.projecturl)(
self.system.projectname)
else:
return self.system.projectname
@renderer
def project(self, request, tag):
return self.system.projectname
@renderer
def recentChanges(self, request, tag):
return ()
@renderer
def problemObjects(self, request, tag):
return ()
@renderer
def onlyIfOneRoot(self, request, tag):
if len(self.system.rootobjects) != 1:
return []
else:
root, = self.system.rootobjects
return tag.clear()("Start at ", taglink(root), ", the root ",
root.kind.lower(), ".")
@renderer
def onlyIfMultipleRoots(self, request, tag):
if len(self.system.rootobjects) == 1:
return []
else:
return tag
@renderer
def roots(self, request, tag):
r = []
for o in self.system.rootobjects:
r.append(tag.clone().fillSlots(root=taglink(o)))
return r
@renderer
def rootkind(self, request, tag):
rootkinds = {}
for o in self.system.rootobjects:
rootkinds[o.kind.lower() + 's'] = 1
return tag.clear()('/'.join(sorted(rootkinds)))
@renderer
def buildtime(self, request, tag):
return self.system.buildtime.strftime("%Y-%m-%d %H:%M:%S")
class AttributeChild(Element):
loader = XMLFile(util.templatefile('attribute-child.html'))
def __init__(self, docgetter, ob):
self.docgetter = docgetter
self.ob = ob
@renderer
def class_(self, request, tag):
class_ = self.ob.css_class
if self.ob.parent is not self.ob:
class_ = 'base' + class_
return class_
@renderer
def functionAnchor(self, request, tag):
return self.ob.fullName()
@renderer
def shortFunctionAnchor(self, request, tag):
return self.ob.name
@renderer
def attribute(self, request, tag):
return self.ob.name
@renderer
def functionBody(self, request, tag):
return self.docgetter.get(self.ob)
class FunctionChild(Element):
loader = XMLFile(util.templatefile('function-child.html'))
def __init__(self, docgetter, ob, functionExtras):
self.docgetter = docgetter
self.ob = ob
self._functionExtras = functionExtras
@renderer
def functionAnchor(self, request, tag):
return self.ob.fullName()
@renderer
def shortFunctionAnchor(self, request, tag):
return self.ob.name
@renderer
def decorator(self, request, tag):
if self.ob.decorators:
decorators = [ast_pp.pp(dec) for dec in self.ob.decorators]
else:
decorators = []
if self.ob.kind == "Class Method" \
and 'classmethod' not in decorators:
decorators.append('classmethod')
elif self.ob.kind == "Static Method" \
and 'staticmethod' not in decorators:
decorators.append('staticmethod')
if decorators:
decorator = [('@' + dec, tags.br()) for dec in decorators]
else:
decorator = ()
return decorator
@renderer
def functionName(self, request, tag):
return [self.ob.name, '(', signature(self.ob.argspec), '):']
@renderer
def sourceLink(self, request, tag):
if self.ob.sourceHref:
return tag.fillSlots(sourceHref=self.ob.sourceHref)
else:
return ()
@renderer
def functionExtras(self, request, tag):
return self._functionExtras
@renderer
def functionBody(self, request, tag):
return self.docgetter.get(self.ob)
class ProblemObjectsElement(Element):
def __init__(self, system):
self.system = system
@renderer
def problemObjects(self, request, tag):
r = []
for fn in sorted(self.system.epytextproblems):
o = self.system.allobjects[fn]
r.append(tag.clone().fillSlots(link=util.taglink(o)))
return r
loader = XMLFile(util.templatefile('problemObjects.html'))
class ModuleIndexPage(Element):
filename = 'moduleIndex.html'
loader = XMLFile(templatefile('summary.html'))
def __init__(self, system):
self.system = system
@renderer
def title(self, request, tag):
return tag.clear()("Module Index")
@renderer
def stuff(self, request, tag):
r = []
for o in self.system.rootobjects:
r.append(moduleSummary(o))
return tag.clear()(r)
@renderer
def heading(self, request, tag):
return tag().clear()("Module Index")
class ChildTable(Element):
loader = XMLFile(util.templatefile('table.html'))
last_id = 0
def __init__(self, docgetter, ob, has_lineno_col, children):
self.docgetter = docgetter
self.system = ob.system
self.has_lineno_col = has_lineno_col
self.children = children
ChildTable.last_id += 1
self._id = ChildTable.last_id
self.ob = ob
@renderer
def id(self, request, tag):
return 'id' + str(self._id)
@renderer
def header(self, request, tag):
if self.system.options.htmlusesorttable:
return tag
else:
return ()
@renderer
def linenohead(self, request, tag):
if self.has_lineno_col:
return tag
else:
return ()
@renderer
def rows(self, request, tag):
return [
TableRow(TagLoader(tag), self.docgetter, self.has_lineno_col,
self.ob, child) for child in self.children
]
class ChildTable(Element):
loader = XMLFile(util.templatefile('table.html'))
last_id = 0
def __init__(self, docgetter, ob, children):
self.docgetter = docgetter
self.system = ob.system
self.children = children
ChildTable.last_id += 1
self._id = ChildTable.last_id
self.ob = ob
@renderer
def id(self, request, tag):
return 'id' + str(self._id)
@renderer
def rows(self, request, tag):
return [
TableRow(TagLoader(tag), self.docgetter, self.ob, child)
for child in self.children
]
class BigDiffElement(Element):
def __init__(self, system, root):
self.system = system
self.root = root
@renderer
def bigDiff(self, request, tag):
mods = {}
for m in self.root.editsbymod:
l = [e for e in self.root.editsbymod[m]
if e is self.root.editsbyob[e.obj.doctarget][-1]]
l.sort(key=lambda x:x.obj.linenumber, reverse=True)
mods[m] = FileDiff(m)
for e in l:
edit0 = self.root.editsbyob[e.obj][0]
mods[m].apply_edit(edit0, e)
r = []
for mod in sorted(mods, key=lambda x:x.filepath):
r.append(tags.pre(mods[mod].diff()))
return r
loader = XMLFile(util.templatefile('bigDiff.html'))
def loader(self):
return XMLFile(util.templatefile('common.html'))
class CommonPage(Element):
loader = XMLFile(templatefile('common.html'))
def __init__(self, ob, docgetter=None):
self.ob = ob
if docgetter is None:
docgetter = DocGetter()
self.docgetter = docgetter
self.usesorttable = ob.system.options.htmlusesorttable
self.usesplitlinks = ob.system.options.htmlusesplitlinks
self.shortenlists = ob.system.options.htmlshortenlists
def title(self):
return self.ob.fullName()
def mediumName(self, obj):
fn = obj.fullName()
if '.' not in fn:
return fn
path, name = fn.rsplit('.', 1)
def process(part):
return obj.system.abbrevmapping.get(part, part[0])
return '.'.join([process(p) for p in path.split('.')]) + '.' + name
def heading(self):
return tags.h1(class_=self.ob.css_class)(self.mediumName(self.ob),
" : ", self.ob.kind.lower(),
" documentation")
def part(self):
if self.ob.parent:
parent = self.ob.parent
if isinstance(parent, model.Module) and parent.name == '__init__':
parent = parent.parent
parts = []
while parent.parent:
parts.append(taglink(parent, parent.name))
parts.append('.')
parent = parent.parent
parts.append(taglink(parent, parent.name))
parts.reverse()
return 'Part of ', parts
else:
return []
def project(self):
if self.ob.system.options.projecturl:
return tags.a(href=self.ob.system.options.projecturl)(
self.ob.system.projectname)
else:
return self.ob.system.projectname
@renderer
def source(self, request, tag):
sourceHref = srclink(self.ob)
if not sourceHref:
return ()
return tag(href=sourceHref)
@renderer
def inhierarchy(self, request, tag):
return ()
def extras(self):
return []
def docstring(self):
return self.docgetter.get(self.ob)
def children(self):
return sorted([o for o in self.ob.orderedcontents if o.isVisible],
key=lambda o: -o.privacyClass)
def packageInitTable(self):
return ()
@renderer
def baseTables(self, request, tag):
return ()
@renderer
def bigTable(self, request, tag):
return ()
def mainTable(self):
children = self.children()
if children:
return ChildTable(self.docgetter, self.ob, self.has_lineno_col(),
children)
else:
return ()
def has_lineno_col(self):
if not self.usesorttable:
return False
return isinstance(self.ob, (model.Class, model.Module))
@renderer
def ifusesorttable(self, request, tag):
if self.usesorttable:
return tag
else:
return ()
def methods(self):
return [
o for o in self.ob.orderedcontents
if o.documentation_location == model.DocLocation.PARENT_PAGE
and o.isVisible
]
def childlist(self):
from pydoctor.templatewriter.pages.attributechild import AttributeChild
from pydoctor.templatewriter.pages.functionchild import FunctionChild
r = []
for c in self.methods():
if isinstance(c, model.Function):
r.append(
FunctionChild(self.docgetter, c, self.functionExtras(c)))
else:
r.append(AttributeChild(self.docgetter, c))
return r
def functionExtras(self, data):
return []
def functionBody(self, data):
return self.docgetter.get(data)
@renderer
def splittingLinks(self, request, tag):
return ()
@renderer
def pydoctorjs(self, request, tag):
if self.usesplitlinks or self.shortenlists:
return tag
else:
return ()
@renderer
def all(self, request, tag):
return tag.fillSlots(
title=self.title(),
heading=self.heading(),
part=self.part(),
extras=self.extras(),
docstring=self.docstring(),
mainTable=self.mainTable(),
packageInitTable=self.packageInitTable(),
childlist=self.childlist(),
project=self.project(),
buildtime=self.ob.system.buildtime.strftime("%Y-%m-%d %H:%M:%S"))
def loader(self):
return XMLFile(util.templatefile('index.html'))
def loader(self):
return XMLFile(util.templatefile('summary.html'))
class EditElement(Element):
def __init__(self, root, ob, docstring, isPreview, initialWhitespace):
self.root = root
self.ob = ob
self.lines = open(
self.ob.doctarget.parentMod.filepath, 'rU').readlines()
self.docstring = docstring
self.isPreview = isPreview
self._initialWhitespace = initialWhitespace
@renderer
def title(self, request, tag):
return tag.clear()(
u"Editing docstring of \N{LEFT DOUBLE QUOTATION MARK}",
self.ob.fullName(),
u"\N{RIGHT DOUBLE QUOTATION MARK}")
@renderer
def preview(self, request, tag):
docstring = parse_str(self.docstring)
stan, errors = epydoc2stan.doc2stan(
self.ob, docstring=docstring)
if self.isPreview or errors:
if errors:
#print stan, errors
#assert isinstance(stan, tags.pre)
[text] = stan.children
lines = text.replace('\r\n', '\n').split('\n')
line2err = {}
for err in errors:
if isinstance(err, str):
ln = None
else:
ln = err.linenum()
line2err.setdefault(ln, []).append(err)
w = len(str(len(lines)))
for i, line in enumerate(lines):
i += 1
cls = "preview"
if i in line2err:
cls += " error"
tag(tags.pre(class_=cls)("%*s"%(w, i), ' ', line))
for err in line2err.get(i, []):
tag(tags.p(class_="errormessage")(err.descr()))
i += 1
for err in line2err.get(i, []):
tag(tags.p(class_="errormessage")(err.descr()))
items = []
for err in line2err.get(None, []):
items.append(tags.li(str(err)))
if items:
tag(tags.ul(items))
else:
tag = tag(stan)
return tag(tags.h2("Edit"))
else:
return ()
@renderer
def fullName(self, request, tag):
return self.ob.fullName()
@renderer
def initialWhitespace(self, request, tag):
return self._initialWhitespace
@renderer
def before(self, request, tag):
tob = self.ob.doctarget
if tob.docstring:
docstring_line_count = len(tob.docstring.orig.splitlines())
lineno = tob.docstring.linenumber - docstring_line_count
else:
lineno = tob.linenumber
firstlineno = max(0, lineno-6)
lines = self.lines[firstlineno:lineno]
if not lines:
return ()
if firstlineno > 0:
lines.insert(0, '...\n')
return tag(lines)
@renderer
def divIndent(self, request, tag):
return 'margin-left: %dex;'%(indentationAmount(self.ob),)
@renderer
def rows(self, request, tag):
return str(len(self.docstring.splitlines()) + 1)
@renderer
def textarea(self, request, tag):
return tag.clear()(self.docstring)
@renderer
def after(self, request, tag):
tob = self.ob.doctarget
if tob.docstring:
lineno = tob.docstring.linenumber
else:
lineno = tob.linenumber
lastlineno = lineno + 6
lines = self.lines[lineno:lastlineno]
if not lines:
return ()
if lastlineno < len(self.lines):
lines.append('...\n')
return tag(lines)
@renderer
def url(self, request, tag):
return 'edit?ob=' + self.ob.fullName()
loader = XMLFile(util.templatefile("edit.html"))