#!/usr/bin/env python

"""

This script generates the footers for all markdown files. Rerun the script

after adding new books or chapters in order to update the footer sections on

each page with links to the next and previous chapters.

The script works by recursively parsing "## Index" sections in files, starting

with README.md. The footer is marked with an HTML comment, `automatically

generated footer`. Any text after this comment is destroyed by the script, so

all edits should be made above that point.

"""

import sys,os,re

class TutorialIndex(object):

footermark = u"<!--automatically generated footer-->"

def __init__(self,link,chapter=None,title=None,parent=None):

"""Create a new TutorialIndex

:param link: A link to this page, relative to parent's link

:param chapter: The chapter number, e.g. "Chapter 5"

:param title: The chapter title, e.g. "Writing Docstrings"

:param parent: The TutorialIndex which references this one

"""

self.link = link

self.chapter = chapter

self.title = title

self.parent = parent

self.children = []

def parse(self):

"""Parse the index, add a footer, and do the same for each child

found in the '# Index' section (if any).

Caution, this method overwrites any existing footer sections on this

file and all children!

"""

#Recognise and parse "<CHAPTER>: (<TITLE>)[<LINK>]"

indexentry = re.compile("^(.*)[:-].*\[([^]]*)\]\(([^)]*)\).*$")

filename = self.rootlink()

with open(filename,"r+") as file:

line = file.readline()

had_footer=False

# Parse file for index, truncate prior footer, and append footermark

in_index = False

while line:

if line[0] == u"#": #That's a header, not a comment

if u"index" in line.lower():

in_index = True

else:

in_index = False

elif line.strip() == TutorialIndex.footermark: # Footer already!

had_footer=True

file.truncate()

break

elif in_index:

# look for 'Chapter 1: [Title](link)'

result = indexentry.match(line)

if result:

chapter,title,link = result.groups()

child = TutorialIndex(link,chapter,title,self)

self.children.append(child)

line = file.readline()

# Append footer

if not had_footer:

file.write(u"\n")

file.write(TutorialIndex.footermark)

file.write(u"\n")

footer = self.makefooter()

file.write(footer)

# Recurse to children

for child in self.children:

child.parse()

def rootlink(self):

"""Convert self.link to an absolute path relative to the root TutorialIndex

:return: The path to this TutorialIndex relative to the root index

"""

if self.parent is None:

return self.link

parentlink = self.parent.rootlink()

return os.path.join(os.path.dirname(parentlink),self.link)

def makefooter(self):

""" makefooter() -> str

Creates the footer text (everything below the "automatically generated

footer" line)

"""

# Don't include footer on main page

if self.parent is None:

return ""

lines = ["","---","","Navigation:"]

# Iterate over parents

p = self.parent

linkmd = [self.makename()] #reverse order (self to root)

while p is not None:

name = p.makename()

# Get a path to p relative to our own path

link = os.path.relpath(p.rootlink(),os.path.dirname(self.rootlink()))

linkmd.append("[{}]({})".format(name,link))

p = p.parent

linkmd.reverse()

lines.append("\n| ".join(linkmd))

lines.append("")

if self.parent is not None:

pos = self.parent.children.index(self) #Should always work

if pos > 0:

prev = self.parent.children[pos-1]

name = prev.makename()

link = os.path.relpath(prev.rootlink(),os.path.dirname(self.rootlink()))

lines.append("Prev: [{}]({})".format(name,link))

lines.append("")

if pos < len(self.parent.children)-1:

next = self.parent.children[pos+1]

name = next.makename()

link = os.path.relpath(next.rootlink(),os.path.dirname(self.rootlink()))

lines.append("Next: [{}]({})".format(name,link))

lines.append("")

#lines.append(self.makename()+", "+self.link)

return "\n".join(lines)

def makename(self):

""" Return a name, like "<CHAPTER>: <TITLE>"

"""

if self.chapter:

name = self.chapter

if self.title:

name += ": " + self.title

elif self.title:

name = self.title

else:

name = self.link #last resort

return name

def __repr__(self):

return "TutorialIndex({self.link!r},{self.chapter!r},{self.title!r},{parent!r})" \

.format(self=self,parent=self.parent.title if self.parent else None)

if __name__ == "__main__":

# Set root index

root = TutorialIndex("README.md",title="Home")

# Rewrite headers

root.parse()

# Output tree

def pr(node,indent=""):

print "{}{}".format(indent,node.link,node.rootlink())

for n in node.children:

pr(n,indent+" ")

pr(root)