'] class EmphaticText(TaggedText): "Text with emphatic mode" def process(self): self.output.tag = 'i' class ShapedText(TaggedText): "Text shaped (italic, slanted)" def process(self): self.type = self.header[1] if not self.type in TagConfig.shaped: Trace.error('Unrecognized shape ' + self.header[1]) self.output.tag = 'span' return self.output.tag = TagConfig.shaped[self.type] class VersalitasText(TaggedText): "Text in versalitas" def process(self): self.output.tag = 'span class="versalitas"' class ColorText(TaggedText): "Colored text" def process(self): self.color = self.header[1] self.output.tag = 'span class="' + self.color + '"' class SizeText(TaggedText): "Sized text" def process(self): self.size = self.header[1] self.output.tag = 'span class="' + self.size + '"' class BoldText(TaggedText): "Bold text" def process(self): self.output.tag = 'b' class TextFamily(TaggedText): "A bit of text from elyxer.a different family" def process(self): "Parse the type of family" self.type = self.header[1] if not self.type in TagConfig.family: Trace.error('Unrecognized family ' + type) self.output.tag = 'span' return self.output.tag = TagConfig.family[self.type] class Hfill(TaggedText): "Horizontall fill" def process(self): self.output.tag = 'span class="hfill"' class BarredText(TaggedText): "Text with a bar somewhere" def process(self): "Parse the type of bar" self.type = self.header[1] if not self.type in TagConfig.barred: Trace.error('Unknown bar type ' + self.type) self.output.tag = 'span' return self.output.tag = TagConfig.barred[self.type] class LangLine(BlackBox): "A line with language information" def process(self): self.lang = self.header[1] class InsetLength(BlackBox): "A length measure inside an inset." def process(self): self.length = self.header[1] class Space(Container): "A space of several types" def __init__(self): self.parser = InsetParser() self.output = FixedOutput() def process(self): self.type = self.header[2] if self.type not in StyleConfig.hspaces: Trace.error('Unknown space type ' + self.type) self.html = [' '] return self.html = [StyleConfig.hspaces[self.type]] length = self.getlength() if not length: return self.output = TaggedOutput().settag('span class="hspace"', False) ContainerSize().set(length).addstyle(self) def getlength(self): "Get the space length from elyxer.the contents or parameters." if len(self.contents) == 0 or not isinstance(self.contents[0], InsetLength): return None return self.contents[0].length class VerticalSpace(Container): "An inset that contains a vertical space." def __init__(self): self.parser = InsetParser() self.output = FixedOutput() def process(self): "Set the correct tag" self.type = self.header[2] if self.type not in StyleConfig.vspaces: self.output = TaggedOutput().settag('div class="vspace" style="height: ' + self.type + ';"', True) return self.html = [StyleConfig.vspaces[self.type]] class Align(Container): "Bit of aligned text" def __init__(self): self.parser = ExcludingParser() self.output = TaggedOutput().setbreaklines(True) def process(self): self.output.tag = 'div class="' + self.header[1] + '"' class Newline(Container): "A newline" def __init__(self): self.parser = LoneCommand() self.output = FixedOutput() def process(self): "Process contents" self.html = ['
\n'] class NewPage(Newline): "A new page" def process(self): "Process contents" self.html = ['
\n
\n')
if Options.jsmath or Options.mathjax:
if Options.mathjax:
html.append(u'\n')
html.append(u'\n')
return html
def getcss(self):
"Get the CSS headers, both linked and embedded."
html = []
for cssdoc in Options.css:
if cssdoc != '':
html.append(u'\n')
for cssfile in Options.embedcss:
html.append(u'\n')
return html
def getfooter(self):
"Get the default footer (after content)."
html = []
html.append('\n')
footer = self.createfooter()
if len(footer) > 0:
html.append('
\n') html += footer html.append('
\n')
html.append('\n')
html.append('\n')
return html
def createfooter(self):
"Create the footer proper."
html = []
if Options.copyright:
html.append('\n')
if Options.nofooter:
return html
html.append('\n')
return html
class VariableMap(object):
"A map with all replacement variables."
def __init__(self):
self.variables = dict()
self.variables['title'] = DocumentTitle().getvalue()
self.variables['author'] = DocumentAuthor().getvalue()
self.variables['version'] = GeneralConfig.version['number'] + ' (' \
+ GeneralConfig.version['date'] + ')'
self.variables['year'] = unicode(datetime.date.today().year)
self.variables['date'] = datetime.date.today().isoformat()
self.variables['datetime'] = datetime.datetime.now().isoformat()
self.variables['css'] = Options.css[0]
if Options.iso885915:
self.variables['encoding'] = 'ISO-8859-1'
else:
self.variables['encoding'] = 'UTF-8'
if Options.jsmath:
self.variables['jsmath'] = Options.jsmath
if Options.mathjax:
self.variables['mathjax'] = Options.mathjax
def replace(self, line):
"Replace all variables in a line."
result = ''
pos = TextPosition(line)
while not pos.finished():
if pos.checkskip(''):
Trace.error('Weird template format in ' + line)
return value
class DocumentTitle(object):
"The title of the whole document."
title = None
def getvalue(self):
"Return the correct title from elyxer.the option or the PDF title."
if Options.title:
return Options.title
if DocumentTitle.title:
return DocumentTitle.title
if DocumentParameters.pdftitle:
return DocumentParameters.pdftitle
return 'Converted document'
class DocumentAuthor(object):
"The author of the document."
author = ''
def appendauthor(cls, authorline):
"Append a line with author information."
cls.author += authorline
appendauthor = classmethod(appendauthor)
def getvalue(self):
"Get the document author."
return DocumentAuthor.author
class HeaderOutput(ContainerOutput):
"Returns the HTML headers"
def gethtml(self, container):
"Return a constant header"
return HTMLTemplate.get().convertheader()
class FooterOutput(ContentsOutput):
"Return the HTML code for the footer"
def gethtml(self, container):
"Footer HTML"
contents = ContentsOutput.gethtml(self, container)
return contents + HTMLTemplate.get().convertfooter()
class InsetText(Container):
"An inset of text in a lyx file"
def __init__(self):
self.parser = BoundedParser()
self.output = ContentsOutput()
class Inset(Container):
"A generic inset in a LyX document"
def __init__(self):
self.contents = list()
self.parser = InsetParser()
self.output = TaggedOutput().setbreaklines(True)
def process(self):
self.type = self.header[1]
self.output.tag = 'span class="' + self.type + '"'
def __unicode__(self):
return 'Inset of type ' + self.type
class NewlineInset(Newline):
"A newline or line break in an inset"
def __init__(self):
self.parser = InsetParser()
self.output = FixedOutput()
class NewPageInset(NewPage):
"A new page command."
def __init__(self):
self.parser = InsetParser()
self.output = FixedOutput()
class Branch(Container):
"A branch within a LyX document"
def __init__(self):
self.parser = InsetParser()
self.output = TaggedOutput().settag('span class="branch"', True)
def process(self):
"Disable inactive branches"
self.branch = self.header[2]
if not self.isactive():
Trace.debug('Branch ' + self.branch + ' not active')
self.output = EmptyOutput()
def isactive(self):
"Check if the branch is active"
if not self.branch in Options.branches:
Trace.error('Invalid branch ' + self.branch)
return True
branch = Options.branches[self.branch]
return branch.isselected()
class ShortTitle(Container):
"A short title to display (always hidden)"
def __init__(self):
self.parser = InsetParser()
self.output = EmptyOutput()
class FlexInset(Container):
"A flexible inset, generic version."
def __init__(self):
self.parser = InsetParser()
self.output = TaggedOutput().settag('span', False)
def process(self):
"Set the correct flex tag."
self.type = self.header[2]
if self.type in TagConfig.flex:
self.output.settag(TagConfig.flex[self.type], False)
else:
self.output.settag('span class="' + self.type + '"', False)
class InfoInset(Container):
"A LyX Info inset"
def __init__(self):
self.parser = InsetParser()
self.output = TaggedOutput().settag('span class="Info"', False)
def process(self):
"Set the shortcut as text"
self.type = self.getparameter('type')
self.contents = [Constant(self.getparameter('arg'))]
class BoxInset(Container):
"A box inset"
def __init__(self):
self.parser = InsetParser()
self.output = TaggedOutput().settag('div', True)
def process(self):
"Set the correct tag"
self.type = self.header[2]
self.output.settag('div class="' + self.type + '"', True)
ContainerSize().readparameters(self).addstyle(self)
class PhantomText(Container):
"A line of invisible text (white over white)."
def __init__(self):
self.parser = InsetParser()
self.output = TaggedOutput().settag('span class="phantom"', False)
class LineInset(LyXLine):
"A LaTeX ruler, but parsed as an inset."
def __init__(self):
self.parser = InsetParser()
self.output = FixedOutput()
class Caption(Container):
"A caption for a figure or a table"
def __init__(self):
self.parser = InsetParser()
self.output = TaggedOutput().settag('div class="caption"', True)
def create(self, message):
"Create a caption with a given message."
self.contents = [Constant(message)]
return self
class ScriptInset(Container):
"Sub- or super-script in an inset."
def __init__(self):
self.parser = InsetParser()
self.output = TaggedOutput().settag('span', False)
def process(self):
"Set the correct script tag."
self.type = self.header[2]
if not self.type in TagConfig.script:
Trace.error('Unknown script type ' + self.type)
return
self.output.settag(TagConfig.script[self.type], False)
class PartKey(object):
"A key to identify a given document part (chapter, section...)."
partkey = None
tocentry = None
anchortext = None
number = None
filename = None
titlecontents = None
header = False
def __init__(self):
self.level = 0
def createindex(self, partkey):
"Create a part key for an index page."
self.partkey = partkey
self.tocentry = partkey
self.filename = partkey
return self
def createfloat(self, float):
"Create a part key for a float."
self.number = NumberGenerator.chaptered.generate(float.type)
self.partkey = Translator.translate('float-' + float.type) + self.number
if Options.notoclabels:
self.tocentry = self.number
else:
self.tocentry = self.partkey
self.readtitle(float)
return self
def createsubfloat(self, number):
"Create the part key for a subfloat."
self.partkey = '(' + number + ')'
self.number = number
return self
def createformula(self, number):
"Create the part key for a formula."
self.number = number
self.partkey = 'formula-' + number
self.tocentry = '(' + number + ')'
return self
def createheader(self, headorfooter):
"Create the part key for a header or footer."
self.partkey = headorfooter
self.tocentry = None
self.header = True
return self
def createanchor(self, partkey):
"Create an anchor for the page."
self.partkey = partkey
self.tocentry = partkey
self.header = True
return self
def createmain(self):
"Create the part key for the main page."
self.partkey = ''
self.tocentry = DocumentTitle().getvalue()
return self
def addtoclabel(self, container):
"Create the label for the TOC, and add it to the container."
labeltext = ''
if self.anchortext:
labeltext = self.anchortext
container.contents.insert(0, Separator(u' '))
label = Label().create(labeltext, self.partkey, type='toc')
container.contents.insert(0, label)
def readtitle(self, container):
"Read the title of the TOC entry."
shorttitles = container.searchall(ShortTitle)
if len(shorttitles) > 0:
self.titlecontents = []
for shorttitle in shorttitles:
self.titlecontents += shorttitle.contents
return
extractor = ContainerExtractor(TOCConfig.extracttitle)
captions = container.searchall(Caption)
if len(captions) == 1:
self.titlecontents = extractor.extract(captions[0])
return
self.titlecontents = extractor.extract(container)
def __unicode__(self):
"Return a printable representation."
return 'Part key for ' + self.partkey
class LayoutPartKey(PartKey):
"The part key for a layout."
generator = NumberGenerator()
def create(self, layout):
"Set the layout for which we are creating the part key."
self.processtype(layout.type)
self.readtitle(layout)
return self
def processtype(self, type):
"Process the layout type."
self.level = self.generator.getlevel(type)
self.number = self.generator.generate(type)
anchortype = self.getanchortype(type)
self.partkey = 'toc-' + anchortype + '-' + self.number
self.tocentry = self.gettocentry(type)
self.filename = self.getfilename(type)
if self.generator.isnumbered(type):
if not self.tocentry:
self.tocentry = ''
else:
self.tocentry += ' '
self.tocentry += self.number
self.anchortext = self.getanchortext(type)
def getanchortype(self, type):
"Get the type for the anchor."
parttype = self.generator.getparttype(type)
if self.generator.isunordered(type):
parttype += '-'
return parttype
def gettocentry(self, type):
"Get the entry for the TOC: Chapter, Section..."
if Options.notoclabels:
return ''
return Translator.translate(self.generator.getparttype(type))
def addtotocentry(self, text):
"Add some text to the tocentry; create if None."
if not self.tocentry:
self.tocentry = ''
self.tocentry += text
def getanchortext(self, type):
"Get the text for the anchor given to a layout type."
if self.generator.isunique(type):
return self.tocentry + '.'
return self.number
def getfilename(self, type):
"Get the filename to be used if splitpart is active."
if self.level == Options.splitpart and self.generator.isnumbered(type):
return self.number
if self.level <= Options.splitpart:
return self.partkey.replace('toc-', '')
return None
def needspartkey(self, layout):
"Find out if a layout needs a part key."
if self.generator.isunique(layout.type):
return True
return self.generator.isinordered(layout.type)
def __unicode__(self):
"Get a printable representation."
return 'Part key for layout ' + self.tocentry
class PartKeyGenerator(object):
"Number a layout with the relevant attributes."
partkeyed = []
layoutpartkey = LayoutPartKey()
def forlayout(cls, layout):
"Get the part key for a layout."
if layout.hasemptyoutput():
return None
if not cls.layoutpartkey.needspartkey(layout):
return None
Label.lastlayout = layout
cls.partkeyed.append(layout)
return LayoutPartKey().create(layout)
def forindex(cls, index):
"Get the part key for an index or nomenclature."
if index.hasemptyoutput():
return None
cls.partkeyed.append(index)
return PartKey().createindex(index.name)
forlayout = classmethod(forlayout)
forindex = classmethod(forindex)
import unicodedata
import urllib
class FormulaParser(Parser):
"Parses a formula"
def parseheader(self, reader):
"See if the formula is inlined"
self.begin = reader.linenumber + 1
type = self.parsetype(reader)
if not type:
reader.nextline()
type = self.parsetype(reader)
if not type:
Trace.error('Unknown formula type in ' + reader.currentline().strip())
return ['unknown']
return [type]
def parsetype(self, reader):
"Get the formula type from the first line."
if reader.currentline().find(FormulaConfig.starts['simple']) >= 0:
return 'inline'
if reader.currentline().find(FormulaConfig.starts['complex']) >= 0:
return 'block'
if reader.currentline().find(FormulaConfig.starts['unnumbered']) >= 0:
return 'block'
if reader.currentline().find(FormulaConfig.starts['beginbefore']) >= 0:
return 'numbered'
return None
def parse(self, reader):
"Parse the formula until the end"
formula = self.parseformula(reader)
while not reader.currentline().startswith(self.ending):
stripped = reader.currentline().strip()
if len(stripped) > 0:
Trace.error('Unparsed formula line ' + stripped)
reader.nextline()
reader.nextline()
return formula
def parseformula(self, reader):
"Parse the formula contents"
simple = FormulaConfig.starts['simple']
if simple in reader.currentline():
rest = reader.currentline().split(simple, 1)[1]
if simple in rest:
# formula is $...$
return self.parsesingleliner(reader, simple, simple)
# formula is multiline $...$
return self.parsemultiliner(reader, simple, simple)
if FormulaConfig.starts['complex'] in reader.currentline():
# formula of the form \[...\]
return self.parsemultiliner(reader, FormulaConfig.starts['complex'],
FormulaConfig.endings['complex'])
beginbefore = FormulaConfig.starts['beginbefore']
beginafter = FormulaConfig.starts['beginafter']
if beginbefore in reader.currentline():
if reader.currentline().strip().endswith(beginafter):
current = reader.currentline().strip()
endsplit = current.split(beginbefore)[1].split(beginafter)
startpiece = beginbefore + endsplit[0] + beginafter
endbefore = FormulaConfig.endings['endbefore']
endafter = FormulaConfig.endings['endafter']
endpiece = endbefore + endsplit[0] + endafter
return startpiece + self.parsemultiliner(reader, startpiece, endpiece) + endpiece
Trace.error('Missing ' + beginafter + ' in ' + reader.currentline())
return ''
begincommand = FormulaConfig.starts['command']
beginbracket = FormulaConfig.starts['bracket']
if begincommand in reader.currentline() and beginbracket in reader.currentline():
endbracket = FormulaConfig.endings['bracket']
return self.parsemultiliner(reader, beginbracket, endbracket)
Trace.error('Formula beginning ' + reader.currentline() + ' is unknown')
return ''
def parsesingleliner(self, reader, start, ending):
"Parse a formula in one line"
line = reader.currentline().strip()
if not start in line:
Trace.error('Line ' + line + ' does not contain formula start ' + start)
return ''
if not line.endswith(ending):
Trace.error('Formula ' + line + ' does not end with ' + ending)
return ''
index = line.index(start)
rest = line[index + len(start):-len(ending)]
reader.nextline()
return rest
def parsemultiliner(self, reader, start, ending):
"Parse a formula in multiple lines"
formula = ''
line = reader.currentline()
if not start in line:
Trace.error('Line ' + line.strip() + ' does not contain formula start ' + start)
return ''
index = line.index(start)
line = line[index + len(start):].strip()
while not line.endswith(ending):
formula += line + '\n'
reader.nextline()
line = reader.currentline()
formula += line[:-len(ending)]
reader.nextline()
return formula
class MacroParser(FormulaParser):
"A parser for a formula macro."
def parseheader(self, reader):
"See if the formula is inlined"
self.begin = reader.linenumber + 1
return ['inline']
def parse(self, reader):
"Parse the formula until the end"
formula = self.parsemultiliner(reader, self.parent.start, self.ending)
reader.nextline()
return formula
class FormulaBit(Container):
"A bit of a formula"
type = None
size = 1
original = ''
def __init__(self):
"The formula bit type can be 'alpha', 'number', 'font'."
self.contents = []
self.output = ContentsOutput()
def setfactory(self, factory):
"Set the internal formula factory."
self.factory = factory
return self
def add(self, bit):
"Add any kind of formula bit already processed"
self.contents.append(bit)
self.original += bit.original
bit.parent = self
def skiporiginal(self, string, pos):
"Skip a string and add it to the original formula"
self.original += string
if not pos.checkskip(string):
Trace.error('String ' + string + ' not at ' + pos.identifier())
def computesize(self):
"Compute the size of the bit as the max of the sizes of all contents."
if len(self.contents) == 0:
return 1
self.size = max([element.size for element in self.contents])
return self.size
def clone(self):
"Return a copy of itself."
return self.factory.parseformula(self.original)
def __unicode__(self):
"Get a string representation"
return self.__class__.__name__ + ' read in ' + self.original
class TaggedBit(FormulaBit):
"A tagged string in a formula"
def constant(self, constant, tag):
"Set the constant and the tag"
self.output = TaggedOutput().settag(tag)
self.add(FormulaConstant(constant))
return self
def complete(self, contents, tag, breaklines = False):
"Set the constant and the tag"
self.contents = contents
self.output = TaggedOutput().settag(tag, breaklines)
return self
def selfcomplete(self, tag):
"Set the self-closing tag, no contents (as in \n') html += footer html.append('
)." self.output = TaggedOutput().settag(tag, empty = True) return self class FormulaConstant(Constant): "A constant string in a formula" def __init__(self, string): "Set the constant string" Constant.__init__(self, string) self.original = string self.size = 1 self.type = None def computesize(self): "Compute the size of the constant: always 1." return self.size def clone(self): "Return a copy of itself." return FormulaConstant(self.original) def __unicode__(self): "Return a printable representation." return 'Formula constant: ' + self.string class RawText(FormulaBit): "A bit of text inside a formula" def detect(self, pos): "Detect a bit of raw text" return pos.current().isalpha() def parsebit(self, pos): "Parse alphabetic text" alpha = pos.globalpha() self.add(FormulaConstant(alpha)) self.type = 'alpha' class FormulaSymbol(FormulaBit): "A symbol inside a formula" modified = FormulaConfig.modified unmodified = FormulaConfig.unmodified['characters'] def detect(self, pos): "Detect a symbol" if pos.current() in FormulaSymbol.unmodified: return True if pos.current() in FormulaSymbol.modified: return True return False def parsebit(self, pos): "Parse the symbol" if pos.current() in FormulaSymbol.unmodified: self.addsymbol(pos.current(), pos) return if pos.current() in FormulaSymbol.modified: self.addsymbol(FormulaSymbol.modified[pos.current()], pos) return Trace.error('Symbol ' + pos.current() + ' not found') def addsymbol(self, symbol, pos): "Add a symbol" self.skiporiginal(pos.current(), pos) self.contents.append(FormulaConstant(symbol)) class FormulaNumber(FormulaBit): "A string of digits in a formula" def detect(self, pos): "Detect a digit" return pos.current().isdigit() def parsebit(self, pos): "Parse a bunch of digits" digits = pos.glob(lambda: pos.current().isdigit()) self.add(FormulaConstant(digits)) self.type = 'number' class Comment(FormulaBit): "A LaTeX comment: % to the end of the line." start = FormulaConfig.starts['comment'] def detect(self, pos): "Detect the %." return pos.current() == self.start def parsebit(self, pos): "Parse to the end of the line." self.original += pos.globincluding('\n') class WhiteSpace(FormulaBit): "Some white space inside a formula." def detect(self, pos): "Detect the white space." return pos.current().isspace() def parsebit(self, pos): "Parse all whitespace." self.original += pos.skipspace() def __unicode__(self): "Return a printable representation." return 'Whitespace: *' + self.original + '*' class Bracket(FormulaBit): "A {} bracket inside a formula" start = FormulaConfig.starts['bracket'] ending = FormulaConfig.endings['bracket'] def __init__(self): "Create a (possibly literal) new bracket" FormulaBit.__init__(self) self.inner = None def detect(self, pos): "Detect the start of a bracket" return pos.checkfor(self.start) def parsebit(self, pos): "Parse the bracket" self.parsecomplete(pos, self.innerformula) return self def parsetext(self, pos): "Parse a text bracket" self.parsecomplete(pos, self.innertext) return self def parseliteral(self, pos): "Parse a literal bracket" self.parsecomplete(pos, self.innerliteral) return self def parsecomplete(self, pos, innerparser): "Parse the start and end marks" if not pos.checkfor(self.start): Trace.error('Bracket should start with ' + self.start + ' at ' + pos.identifier()) return None self.skiporiginal(self.start, pos) pos.pushending(self.ending) innerparser(pos) self.original += pos.popending(self.ending) self.computesize() def innerformula(self, pos): "Parse a whole formula inside the bracket" while not pos.finished(): self.add(self.factory.parseany(pos)) def innertext(self, pos): "Parse some text inside the bracket, following textual rules." specialchars = FormulaConfig.symbolfunctions.keys() specialchars.append(FormulaConfig.starts['command']) specialchars.append(FormulaConfig.starts['bracket']) specialchars.append(Comment.start) while not pos.finished(): if pos.current() in specialchars: self.add(self.factory.parseany(pos)) if pos.checkskip(' '): self.original += ' ' else: self.add(FormulaConstant(pos.skipcurrent())) def innerliteral(self, pos): "Parse a literal inside the bracket, which does not generate HTML." self.literal = '' while not pos.finished() and not pos.current() == self.ending: if pos.current() == self.start: self.parseliteral(pos) else: self.literal += pos.skipcurrent() self.original += self.literal class SquareBracket(Bracket): "A [] bracket inside a formula" start = FormulaConfig.starts['squarebracket'] ending = FormulaConfig.endings['squarebracket'] def clone(self): "Return a new square bracket with the same contents." bracket = SquareBracket() bracket.contents = self.contents return bracket class MathsProcessor(object): "A processor for a maths construction inside the FormulaProcessor." def process(self, contents, index): "Process an element inside a formula." Trace.error('Unimplemented process() in ' + unicode(self)) def __unicode__(self): "Return a printable description." return 'Maths processor ' + self.__class__.__name__ class FormulaProcessor(object): "A processor specifically for formulas." processors = [] def process(self, bit): "Process the contents of every formula bit, recursively." self.processcontents(bit) self.processinsides(bit) self.traversewhole(bit) def processcontents(self, bit): "Process the contents of a formula bit." if not isinstance(bit, FormulaBit): return bit.process() for element in bit.contents: self.processcontents(element) def processinsides(self, bit): "Process the insides (limits, brackets) in a formula bit." if not isinstance(bit, FormulaBit): return for index, element in enumerate(bit.contents): for processor in self.processors: processor.process(bit.contents, index) # continue with recursive processing self.processinsides(element) def traversewhole(self, formula): "Traverse over the contents to alter variables and space units." last = None for bit, contents in self.traverse(formula): if bit.type == 'alpha': self.italicize(bit, contents) elif bit.type == 'font' and last and last.type == 'number': bit.contents.insert(0, FormulaConstant(u' ')) last = bit def traverse(self, bit): "Traverse a formula and yield a flattened structure of (bit, list) pairs." for element in bit.contents: if hasattr(element, 'type') and element.type: yield (element, bit.contents) elif isinstance(element, FormulaBit): for pair in self.traverse(element): yield pair def italicize(self, bit, contents): "Italicize the given bit of text." index = contents.index(bit) contents[index] = TaggedBit().complete([bit], 'i') class Formula(Container): "A LaTeX formula" def __init__(self): self.parser = FormulaParser() self.output = TaggedOutput().settag('span class="formula"') def process(self): "Convert the formula to tags" if self.header[0] == 'inline': DocumentParameters.displaymode = False else: DocumentParameters.displaymode = True self.output.settag('div class="formula"', True) if Options.jsmath: self.jsmath() elif Options.mathjax: self.mathjax() elif Options.googlecharts: self.googlecharts() else: self.classic() def jsmath(self): "Make the contents for jsMath." if self.header[0] != 'inline': self.output = TaggedOutput().settag('div class="math"') else: self.output = TaggedOutput().settag('span class="math"') self.contents = [Constant(self.parsed)] def mathjax(self): "Make the contents for MathJax." self.output.tag = 'span class="MathJax_Preview"' tag = 'script type="math/tex' if self.header[0] != 'inline': tag += ';mode=display' self.contents = [TaggedText().constant(self.parsed, tag + '"', True)] def googlecharts(self): "Make the contents using Google Charts http://code.google.com/apis/chart/." url = FormulaConfig.urls['googlecharts'] + urllib.quote_plus(self.parsed) img = '
. """ commandmap = FormulaConfig.hybridfunctions def parsebit(self, pos): "Parse a function with [] and {} parameters" readtemplate = self.translated[0] writetemplate = self.translated[1] self.readparams(readtemplate, pos) self.contents = self.writeparams(writetemplate) self.computehybridsize() def writeparams(self, writetemplate): "Write all params according to the template" return self.writepos(TextPosition(writetemplate)) def writepos(self, pos): "Write all params as read in the parse position." result = [] while not pos.finished(): if pos.checkskip('$'): param = self.writeparam(pos) if param: result.append(param) elif pos.checkskip('f'): function = self.writefunction(pos) if function: function.type = None result.append(function) elif pos.checkskip('('): result.append(self.writebracket('left', '(')) elif pos.checkskip(')'): result.append(self.writebracket('right', ')')) else: result.append(FormulaConstant(pos.skipcurrent())) return result def writeparam(self, pos): "Write a single param of the form $0, $x..." name = '$' + pos.skipcurrent() if not name in self.params: Trace.error('Unknown parameter ' + name) return None if not self.params[name]: return None if pos.checkskip('.'): self.params[name].value.type = pos.globalpha() return self.params[name].value def writefunction(self, pos): "Write a single function f0,...,fn." tag = self.readtag(pos) if not tag: return None if pos.checkskip('/'): # self-closing XHTML tag, such as
return TaggedBit().selfcomplete(tag) if not pos.checkskip('{'): Trace.error('Function should be defined in {}') return None pos.pushending('}') contents = self.writepos(pos) pos.popending() if len(contents) == 0: return None return TaggedBit().complete(contents, tag) def readtag(self, pos): "Get the tag corresponding to the given index. Does parameter substitution." if not pos.current().isdigit(): Trace.error('Function should be f0,...,f9: f' + pos.current()) return None index = int(pos.skipcurrent()) if 2 + index > len(self.translated): Trace.error('Function f' + unicode(index) + ' is not defined') return None tag = self.translated[2 + index] if not '$' in tag: return tag for variable in self.params: if variable in tag: param = self.params[variable] if not param.literal: Trace.error('Parameters in tag ' + tag + ' should be literal: {' + variable + '!}') continue if param.literalvalue: value = param.literalvalue else: value = '' tag = tag.replace(variable, value) return tag def writebracket(self, direction, character): "Return a new bracket looking at the given direction." return self.factory.create(BracketCommand).create(direction, character) def computehybridsize(self): "Compute the size of the hybrid function." if not self.command in HybridSize.configsizes: self.computesize() return self.size = HybridSize().getsize(self) # set the size in all elements at first level for element in self.contents: element.size = self.size class HybridSize(object): "The size associated with a hybrid function." configsizes = FormulaConfig.hybridsizes def getsize(self, function): "Read the size for a function and parse it." sizestring = self.configsizes[function.command] for name in function.params: if name in sizestring: size = function.params[name].value.computesize() sizestring = sizestring.replace(name, unicode(size)) if '$' in sizestring: Trace.error('Unconverted variable in hybrid size: ' + sizestring) return 1 return eval(sizestring) FormulaCommand.types += [HybridFunction] class MacroDefinition(CommandBit): "A function that defines a new command (a macro)." macros = dict() def parsebit(self, pos): "Parse the function that defines the macro." self.output = EmptyOutput() self.parameternumber = 0 self.defaults = [] self.factory.defining = True self.parseparameters(pos) self.factory.defining = False Trace.debug('New command ' + self.newcommand + ' (' + \ unicode(self.parameternumber) + ' parameters)') self.macros[self.newcommand] = self def parseparameters(self, pos): "Parse all optional parameters (number of parameters, default values)" "and the mandatory definition." self.newcommand = self.parsenewcommand(pos) # parse number of parameters literal = self.parsesquareliteral(pos) if literal: self.parameternumber = int(literal) # parse all default values bracket = self.parsesquare(pos) while bracket: self.defaults.append(bracket) bracket = self.parsesquare(pos) # parse mandatory definition self.definition = self.parseparameter(pos) def parsenewcommand(self, pos): "Parse the name of the new command." self.factory.clearskipped(pos) if self.factory.detecttype(Bracket, pos): return self.parseliteral(pos) if self.factory.detecttype(FormulaCommand, pos): return self.factory.create(FormulaCommand).extractcommand(pos) Trace.error('Unknown formula bit in defining function at ' + pos.identifier()) return 'unknown' def instantiate(self): "Return an instance of the macro." return self.definition.clone() class MacroParameter(FormulaBit): "A parameter from elyxer.a macro." def detect(self, pos): "Find a macro parameter: #n." return pos.checkfor('#') def parsebit(self, pos): "Parse the parameter: #n." if not pos.checkskip('#'): Trace.error('Missing parameter start #.') return self.number = int(pos.skipcurrent()) self.original = '#' + unicode(self.number) self.contents = [TaggedBit().constant('#' + unicode(self.number), 'span class="unknown"')] class MacroFunction(CommandBit): "A function that was defined using a macro." commandmap = MacroDefinition.macros def parsebit(self, pos): "Parse a number of input parameters." self.output = FilteredOutput() self.values = [] macro = self.translated self.parseparameters(pos, macro) self.completemacro(macro) def parseparameters(self, pos, macro): "Parse as many parameters as are needed." self.parseoptional(pos, list(macro.defaults)) self.parsemandatory(pos, macro.parameternumber - len(macro.defaults)) if len(self.values) < macro.parameternumber: Trace.error('Missing parameters in macro ' + unicode(self)) def parseoptional(self, pos, defaults): "Parse optional parameters." optional = [] while self.factory.detecttype(SquareBracket, pos): optional.append(self.parsesquare(pos)) if len(optional) > len(defaults): break for value in optional: default = defaults.pop() if len(value.contents) > 0: self.values.append(value) else: self.values.append(default) self.values += defaults def parsemandatory(self, pos, number): "Parse a number of mandatory parameters." for index in range(number): parameter = self.parsemacroparameter(pos, number - index) if not parameter: return self.values.append(parameter) def parsemacroparameter(self, pos, remaining): "Parse a macro parameter. Could be a bracket or a single letter." "If there are just two values remaining and there is a running number," "parse as two separater numbers." self.factory.clearskipped(pos) if pos.finished(): return None if self.factory.detecttype(FormulaNumber, pos): return self.parsenumbers(pos, remaining) return self.parseparameter(pos) def parsenumbers(self, pos, remaining): "Parse the remaining parameters as a running number." "For example, 12 would be {1}{2}." number = self.factory.parsetype(FormulaNumber, pos) if not len(number.original) == remaining: return number for digit in number.original: value = self.factory.create(FormulaNumber) value.add(FormulaConstant(digit)) value.type = number self.values.append(value) return None def completemacro(self, macro): "Complete the macro with the parameters read." self.contents = [macro.instantiate()] replaced = [False] * len(self.values) for parameter in self.searchall(MacroParameter): index = parameter.number - 1 if index >= len(self.values): Trace.error('Macro parameter index out of bounds: ' + unicode(index)) return replaced[index] = True parameter.contents = [self.values[index].clone()] for index in range(len(self.values)): if not replaced[index]: self.addfilter(index, self.values[index]) def addfilter(self, index, value): "Add a filter for the given parameter number and parameter value." original = '#' + unicode(index + 1) value = ''.join(self.values[0].gethtml()) self.output.addfilter(original, value) class FormulaMacro(Formula): "A math macro defined in an inset." def __init__(self): self.parser = MacroParser() self.output = EmptyOutput() def __unicode__(self): "Return a printable representation." return 'Math macro' FormulaFactory.types += [ MacroParameter ] FormulaCommand.types += [ MacroFunction, ] class SideNote(Container): "A side note that appears at the right." def __init__(self): self.parser = InsetParser() self.output = TaggedOutput() def process(self): "Enclose everything in a marginal span." self.output.settag('span class="Marginal"', True) class FootnoteMarker(Container): "A marker for a footnote." def __init__(self): "Set the correct span class." self.contents = [] span = 'span class="SupFootMarker"' if Options.alignfoot: span = 'span class="AlignFootMarker"' self.output = TaggedOutput().settag(span, False) mode = 'A' if Options.numberfoot: mode = '1' if Options.symbolfoot: mode = '*' NumberGenerator.generator.getcounter('Footnote').setmode(mode) def create(self): "Create the marker for a footnote." self.order = NumberGenerator.generator.generate('Footnote') if Options.endfoot: self.link = Link().complete(self.getmark(), 'footmarker-' + self.order) self.createcontents() return self def createanchor(self, marker): "Create the anchor for a footnote. Adds a link for end footnotes." self.order = marker.order if Options.endfoot: self.link = Link().complete(self.getmark(), 'footnote-' + self.order) self.link.setmutualdestination(marker.link) self.createcontents() return self def createcontents(self): "Create the contents of the marker." if Options.endfoot: self.contents = [self.link] else: self.contents = [Constant(self.getmark())] space = Constant(u' ') self.contents = [space] + self.contents + [space] def getmark(self): "Get the mark to be displayed in the marker based on the order." if Options.symbolfoot: return self.order else: return '[' + self.order + ']' class Footnote(Container): "A footnote to the main text." def __init__(self): self.parser = InsetParser() self.output = TaggedOutput().settag('span class="FootOuter"', False) def process(self): "Add a counter for the footnote." "Can be numeric or a letter depending on runtime options." marker = FootnoteMarker().create() anchor = FootnoteMarker().createanchor(marker) notecontents = [anchor] + list(self.contents) self.contents = [marker] if Options.hoverfoot: self.contents.append(self.createnote(notecontents, 'span class="HoverFoot"')) if Options.marginfoot: self.contents.append(self.createnote(notecontents, 'span class="MarginFoot"')) if Options.endfoot: EndFootnotes.footnotes.append(self.createnote(notecontents, 'div class="EndFoot"')) def createnote(self, contents, tag): "Create a note with the given contents and HTML tag." return TaggedText().complete(contents, tag, False) class EndFootnotes(Container): "The collection of footnotes at the document end." footnotes = [] def __init__(self): "Generate all footnotes and a proper header for them all." self.output = ContentsOutput() header = TaggedText().constant(Translator.translate('footnotes'), 'h1 class="index"') self.contents = [header] + self.footnotes class Note(Container): "A LyX note of several types" def __init__(self): self.parser = InsetParser() self.output = EmptyOutput() def process(self): "Hide note and comment, dim greyed out" self.type = self.header[2] if TagConfig.notes[self.type] == '': return self.output = TaggedOutput().settag(TagConfig.notes[self.type], True) class LyXHeader(Container): "Reads the header, outputs the HTML header" def __init__(self): self.contents = [] self.parser = HeaderParser() self.output = HeaderOutput() self.parameters = dict() self.partkey = PartKey().createheader('header') def process(self): "Find pdf title" DocumentParameters.pdftitle = self.getheaderparameter('pdftitle') documentclass = self.getheaderparameter('documentclass') if documentclass in HeaderConfig.styles['article']: DocumentParameters.startinglevel = 1 if documentclass in HeaderConfig.styles['book']: DocumentParameters.bibliography = 'bibliography' else: DocumentParameters.bibliography = 'references' if self.getheaderparameter('paragraphseparation') == 'indent': DocumentParameters.indentstandard = True DocumentParameters.tocdepth = self.getlevel('tocdepth') DocumentParameters.maxdepth = self.getlevel('secnumdepth') DocumentParameters.language = self.getheaderparameter('language') if self.getheaderparameter('outputchanges') == 'true': DocumentParameters.outputchanges = True return self def getheaderparameter(self, configparam): "Get a parameter configured in HeaderConfig." key = HeaderConfig.parameters[configparam] if not key in self.parameters: return None return self.parameters[key] def getlevel(self, configparam): "Get a level read as a parameter from elyxer.HeaderConfig." paramvalue = self.getheaderparameter(configparam) if not paramvalue: return 0 value = int(paramvalue) if DocumentParameters.startinglevel == 1: return value return value + 1 class LyXPreamble(Container): "The preamble at the beginning of a LyX file. Parsed for macros." def __init__(self): self.parser = PreambleParser() self.output = EmptyOutput() self.factory = FormulaFactory() def process(self): "Parse the LyX preamble, if needed." if len(PreambleParser.preamble) == 0: return pos = TextPosition('\n'.join(PreambleParser.preamble)) while not pos.finished(): if self.detectfunction(pos): self.parsefunction(pos) else: pos.globincluding('\n') PreambleParser.preamble = [] def detectfunction(self, pos): "Detect a macro definition or a preamble function." for function in FormulaConfig.misccommands: if pos.checkfor(function): return True return False def parsefunction(self, pos): "Parse a single command." self.factory.parsetype(FormulaCommand, pos) class LyXFooter(Container): "Reads the footer, outputs the HTML footer" def __init__(self): self.contents = [] self.parser = BoundedDummy() self.output = FooterOutput() self.partkey = PartKey().createheader('footer') def process(self): "Include any footnotes at the end." if EndFootnotes.footnotes: endnotes = EndFootnotes() self.contents = [endnotes] class Layout(Container): "A layout (block of text) inside a lyx file" type = 'none' def __init__(self): "Initialize the layout." self.contents = [] self.parser = BoundedParser() self.output = TaggedOutput().setbreaklines(True) def process(self): "Get the type and numerate if necessary." self.type = self.header[1] if self.type in TagConfig.layouts: self.output.tag = TagConfig.layouts[self.type] + ' class="' + self.type + '"' elif self.type.replace('*', '') in TagConfig.layouts: self.output.tag = TagConfig.layouts[self.type.replace('*', '')] self.output.tag += ' class="' + self.type.replace('*', '-') + '"' else: self.output.tag = 'div class="' + self.type + '"' self.numerate() def numerate(self): "Numerate if necessary." partkey = PartKeyGenerator.forlayout(self) if partkey: self.partkey = partkey self.output.tag = self.output.tag.replace('?', unicode(partkey.level)) def __unicode__(self): "Return a printable representation." if self.partkey: return 'Layout ' + self.type + ' #' + unicode(self.partkey.partkey) return 'Layout of type ' + self.type class StandardLayout(Layout): "A standard layout -- can be a true div or nothing at all" indentation = False def process(self): self.type = 'standard' self.output = ContentsOutput() def complete(self, contents): "Set the contents and return it." self.process() self.contents = contents return self class Title(Layout): "The title of the whole document" def process(self): self.type = 'title' self.output.tag = 'h1 class="title"' title = self.extracttext() DocumentTitle.title = title Trace.message('Title: ' + title) class Author(Layout): "The document author" def process(self): self.type = 'author' self.output.tag = 'h2 class="author"' author = self.extracttext() Trace.debug('Author: ' + author) DocumentAuthor.appendauthor(author) class Abstract(Layout): "A paper abstract" done = False def process(self): self.type = 'abstract' self.output.tag = 'div class="abstract"' if Abstract.done: return message = Translator.translate('abstract') tagged = TaggedText().constant(message, 'p class="abstract-message"', True) self.contents.insert(0, tagged) Abstract.done = True class FirstWorder(Layout): "A layout where the first word is extracted" def extractfirstword(self): "Extract the first word as a list" return self.extractfromcontents(self.contents) def extractfromcontents(self, contents): "Extract the first word in contents." firstcontents = [] while len(contents) > 0: if self.isfirstword(contents[0]): firstcontents.append(contents[0]) del contents[0] return firstcontents if self.spaceincontainer(contents[0]): extracted = self.extractfromcontainer(contents[0]) firstcontents.append(extracted) return firstcontents firstcontents.append(contents[0]) del contents[0] return firstcontents def extractfromcontainer(self, container): "Extract the first word from a container cloning it including its output." if isinstance(container, StringContainer): return self.extractfromstring(container) result = Cloner.clone(container) result.output = container.output result.contents = self.extractfromcontents(container.contents) return result def extractfromstring(self, container): "Extract the first word from elyxer.a string container." if not ' ' in container.string: Trace.error('No space in string ' + container.string) return container split = container.string.split(' ', 1) container.string = split[1] return Constant(split[0]) def spaceincontainer(self, container): "Find out if the container contains a space somewhere." return ' ' in container.extracttext() def isfirstword(self, container): "Find out if the container is valid as a first word." if not isinstance(container, FirstWord): return False return not container.isempty() class FirstWord(Container): "A container which is in itself a first word, unless it's empty." "Should be inherited by other containers, e.g. ERT." def isempty(self): "Find out if the first word is empty." Trace.error('Unimplemented isempty()') return True class Description(FirstWorder): "A description layout" def process(self): "Set the first word to bold" self.type = 'Description' self.output.tag = 'div class="Description"' firstword = self.extractfirstword() if not firstword: return tag = 'span class="Description-entry"' self.contents.insert(0, TaggedText().complete(firstword, tag)) self.contents.insert(1, Constant(u' ')) class List(FirstWorder): "A list layout" def process(self): "Set the first word to bold" self.type = 'List' self.output.tag = 'div class="List"' firstword = self.extractfirstword() if not firstword: return first = TaggedText().complete(firstword, 'span class="List-entry"') second = TaggedText().complete(self.contents, 'span class="List-contents"') self.contents = [first, second] class PlainLayout(Layout): "A plain layout" def process(self): "Output just as contents." self.output = ContentsOutput() self.type = 'Plain' def makevisible(self): "Make the layout visible, output as tagged text." self.output = TaggedOutput().settag('div class="PlainVisible"', True) class LyXCode(Layout): "A bit of LyX-Code." def process(self): "Output as pre." self.output.tag = 'pre class="LyX-Code"' for newline in self.searchall(Newline): index = newline.parent.contents.index(newline) newline.parent.contents[index] = Constant('\n') class PostLayout(object): "Numerate an indexed layout" processedclass = Layout def postprocess(self, last, layout, next): "Group layouts and/or number them." if layout.type in TagConfig.group['layouts']: return self.group(last, layout) if layout.partkey: self.number(layout) return layout def group(self, last, layout): "Group two layouts if they are the same type." if not self.isgroupable(layout) or not self.isgroupable(last) or last.type != layout.type: return layout layout.contents = last.contents + [Constant('
\n')] + layout.contents last.contents = [] last.output = EmptyOutput() return layout def isgroupable(self, container): "Check that the container can be grouped." if not isinstance(container, Layout): return False for element in container.contents: if not element.__class__.__name__ in LayoutConfig.groupable['allowed']: return False return True def number(self, layout): "Generate a number and place it before the text" layout.partkey.addtoclabel(layout) class PostStandard(object): "Convert any standard spans in root to divs" processedclass = StandardLayout def postprocess(self, last, standard, next): "Switch to div, and clear if empty." type = 'Standard' if self.isempty(standard): standard.output = EmptyOutput() return standard if DocumentParameters.indentstandard: if isinstance(last, StandardLayout): type = 'Indented' else: type = 'Unindented' standard.output = TaggedOutput().settag('div class="' + type + '"', True) return standard def isempty(self, standard): "Find out if the standard layout is empty." for element in standard.contents: if not element.output.isempty(): return False return True class PostPlainLayout(PostLayout): "Numerate a plain layout" processedclass = PlainLayout def postprocess(self, last, plain, next): "Group plain layouts." if not self.istext(last) or not self.istext(plain): return plain plain.makevisible() return self.group(last, plain) def istext(self, container): "Find out if the container is only text." if not isinstance(container, PlainLayout): return False extractor = ContainerExtractor(TOCConfig.extractplain) text = extractor.extract(container) return (len(text) > 0) class PostLyXCode(object): "Coalesce contiguous LyX-Code layouts." processedclass = LyXCode def postprocess(self, last, lyxcode, next): "Coalesce if last was also LyXCode" if not isinstance(last, LyXCode): return lyxcode if hasattr(last, 'first'): lyxcode.first = last.first else: lyxcode.first = last toappend = lyxcode.first.contents toappend.append(Constant('\n')) toappend += lyxcode.contents lyxcode.output = EmptyOutput() return lyxcode Postprocessor.stages += [ PostLayout, PostStandard, PostLyXCode, PostPlainLayout ] class BiblioCitation(Container): "A complete bibliography citation (possibly with many cites)." citations = dict() def __init__(self): self.parser = InsetParser() self.output = TaggedOutput().settag('span class="bibcites"') self.contents = [] def process(self): "Process the complete citation and all cites within." self.contents = [Constant('[')] keys = self.getparameterlist('key') for key in keys: self.contents += [BiblioCite().create(key), Constant(', ')] if len(keys) > 0: # remove trailing , self.contents.pop() self.contents.append(Constant(']')) class BiblioCite(Link): "Cite of a bibliography entry" cites = dict() def create(self, key): "Create the cite to the given key." self.key = key number = NumberGenerator.generator.generate('bibliocite') ref = BiblioReference().create(key, number) self.complete(number, 'cite-' + number, type='bibliocite') self.setmutualdestination(ref) if not key in BiblioCite.cites: BiblioCite.cites[key] = [] BiblioCite.cites[key].append(self) return self class Bibliography(Container): "A bibliography layout containing an entry" def __init__(self): self.parser = BoundedParser() self.output = TaggedOutput().settag('p class="biblio"', True) class BiblioHeader(Container): "The header of the bibliography." def __init__(self): "Create the header for the bibliography section." self.type = 'biblio' self.output = ContentsOutput() self.name = Translator.translate(DocumentParameters.bibliography) self.contents = [TaggedText().constant(self.name, 'h1 class="biblio"', True)] def addtotoc(self, parent): "Add the bibliography header to the TOC." self.parent = parent self.partkey = PartKeyGenerator.forindex(self) if not self.partkey: return self.partkey.addtoclabel(self) while parent: parent.partkey = self.partkey parent = parent.parent class PostBiblio(object): "Insert a Bibliography legend before the first item" processedclass = Bibliography def postprocess(self, last, element, next): "If we have the first bibliography insert a tag" if isinstance(last, Bibliography) or Options.nobib: return element layout = StandardLayout() header = BiblioHeader() header.addtotoc(layout) layout.complete([header, element]) return layout Postprocessor.stages += [PostBiblio] class BiblioReference(Link): "A reference to a bibliographical entry." references = dict() def create(self, key, number): "Create the reference with the given key and number." self.key = key self.complete(number, 'biblio-' + number, type='biblioentry') if not key in BiblioReference.references: BiblioReference.references[key] = [] BiblioReference.references[key].append(self) return self class BiblioEntry(Container): "A bibliography entry" entries = dict() def __init__(self): self.parser = InsetParser() self.output = TaggedOutput().settag('span class="entry"') self.contents = [] def process(self): "Process the cites for the entry's key" self.citeref = [Constant(NumberGenerator.generator.generate('biblioentry'))] self.processcites(self.getparameter('key')) def processcites(self, key): "Get all the cites of the entry" self.key = key if not key in BiblioReference.references: self.contents.append(Constant('[-] ')) return self.contents = [Constant('[')] for ref in BiblioReference.references[key]: self.contents.append(ref) self.contents.append(Constant(',')) self.contents.pop(-1) self.contents.append(Constant('] ')) class Processor(object): "Process a container and its contents." prestages = [] skipfiltered = ['LyXHeader', 'LyXFooter', 'Title', 'Author', 'TableOfContents'] def __init__(self, filtering): "Set filtering mode (to skip postprocessing)." "With filtering on, the classes in skipfiltered are not processed at all." self.filtering = filtering self.postprocessor = Postprocessor() def process(self, container): "Do the whole processing on a container." if self.filtering and container.__class__.__name__ in self.skipfiltered: return None container = self.preprocess(container) self.processcontainer(container) if not container: # do not postprocess empty containers from elyxer.here return container return self.postprocess(container) def preprocess(self, root): "Preprocess a root container with all prestages." if not root: return None for stage in self.prestages: root = stage.preprocess(root) if not root: return None return root def processcontainer(self, container): "Process a container and its contents, recursively." if not container: return for element in container.contents: self.processcontainer(element) container.process() def postprocess(self, container): "Postprocess a container, unless filtering is on." if self.filtering: return container return self.postprocessor.postprocess(container) class ListInset(Container): "An inset with a list, normally made of links." def __init__(self): self.parser = InsetParser() self.output = ContentsOutput() def sortdictionary(self, dictionary): "Sort all entries in the dictionary" keys = dictionary.keys() # sort by name keys.sort() return keys sortdictionary = classmethod(sortdictionary) class ListOf(ListInset): "A list of entities (figures, tables, algorithms)" def process(self): "Parse the header and get the type" self.type = self.header[2] text = Translator.translate('list-' + self.type) self.contents = [TaggedText().constant(text, 'div class="tocheader"', True)] class TableOfContents(ListInset): "Table of contents" def process(self): "Parse the header and get the type" self.create(Translator.translate('toc')) def create(self, heading): "Create a table of contents with the given heading text." self.output = TaggedOutput().settag('div class="fulltoc"', True) self.contents = [TaggedText().constant(heading, 'div class="tocheader"', True)] return self def add(self, entry): "Add a new entry to the TOC." if entry: self.contents.append(entry) class IndexReference(Link): "A reference to an entry in the alphabetical index." name = 'none' def process(self): "Put entry in index" name = self.getparameter('name') if name: self.name = name.strip() else: self.name = self.extracttext() IndexEntry.get(self.name).addref(self) def __unicode__(self): "Return a printable representation." return 'Reference to ' + self.name class IndexHeader(Link): "The header line for an index entry. Keeps all arrows." keyescapes = {'!':'', '|':'-', ' ':'-', '--':'-', ',':'', '\\':'', '@':'_', u'°':''} def create(self, names): "Create the header for the given index entry." self.output = TaggedOutput().settag('p class="printindex"', True) self.name = names[-1] keys = [self.escape(part, self.keyescapes) for part in names] self.key = '-'.join(keys) self.anchor = Link().complete('', 'index-' + self.key, None, 'printindex') self.contents = [self.anchor, Constant(self.name + ': ')] self.arrows = [] return self def addref(self, reference): "Create an arrow pointing to a reference." reference.index = unicode(len(self.arrows)) reference.destination = self.anchor reference.complete(u'↓', 'entry-' + self.key + '-' + reference.index) arrow = Link().complete(u'↑', type = 'IndexArrow') arrow.destination = reference if len(self.arrows) > 0: self.contents.append(Constant(u', ')) self.arrows.append(arrow) self.contents.append(arrow) def __unicode__(self): "Return a printable representation." return 'Index header for ' + self.name class IndexGroup(Container): "A group of entries in the alphabetical index, for an entry." root = None def create(self): "Create an index group." self.entries = dict() self.output = EmptyOutput() return self def findentry(self, names): "Find the entry with the given names." if self == IndexGroup.root: self.output = ContentsOutput() else: self.output = TaggedOutput().settag('div class="indexgroup"', True) lastname = names[-1] if not lastname in self.entries: self.entries[lastname] = IndexEntry().create(names) return self.entries[lastname] def sort(self): "Sort all entries in the group." for key in ListInset.sortdictionary(self.entries): entry = self.entries[key] entry.group.sort() self.contents.append(entry) def __unicode__(self): "Return a printable representation." return 'Index group' IndexGroup.root = IndexGroup().create() class IndexEntry(Container): "An entry in the alphabetical index." "When an index entry is of the form 'part1 ! part2 ...', " "a hierarchical structure in the form of an IndexGroup is constructed." "An index entry contains a mandatory header, and an optional group." def create(self, names): "Create an index entry with the given name." self.output = ContentsOutput() self.header = IndexHeader().create(names) self.group = IndexGroup().create() self.contents = [self.header, self.group] return self def addref(self, reference): "Add a reference to the entry." self.header.addref(reference) def get(cls, name): "Get the index entry for the given name." group = IndexGroup.root parts = IndexEntry.splitname(name) readparts = [] for part in parts: readparts.append(part) entry = group.findentry(readparts) group = entry.group return entry def splitname(cls, name): "Split a name in parts divided by !." return [part.strip() for part in name.split('!')] def __unicode__(self): "Return a printable representation." return 'Index entry for ' + self.header.name get = classmethod(get) splitname = classmethod(splitname) class PrintIndex(ListInset): "Command to print an index" def process(self): "Create the alphabetic index" self.name = Translator.translate('index') self.partkey = PartKeyGenerator.forindex(self) if not self.partkey: return self.contents = [TaggedText().constant(self.name, 'h1 class="index"')] self.partkey.addtoclabel(self) IndexGroup.root.sort() self.contents.append(IndexGroup.root) class NomenclatureEntry(Link): "An entry of LyX nomenclature" entries = dict() def process(self): "Put entry in index" symbol = self.getparameter('symbol') description = self.getparameter('description') key = symbol.replace(' ', '-').lower() if key in NomenclatureEntry.entries: Trace.error('Duplicated nomenclature entry ' + key) self.complete(u'↓', 'noment-' + key) entry = Link().complete(u'↑', 'nom-' + key) entry.symbol = symbol entry.description = description self.setmutualdestination(entry) NomenclatureEntry.entries[key] = entry class PrintNomenclature(ListInset): "Print all nomenclature entries" def process(self): "Create the nomenclature." self.name = Translator.translate('nomenclature') self.partkey = PartKeyGenerator.forindex(self) if not self.partkey: return self.contents = [TaggedText().constant(self.name, 'h1 class="nomenclature"')] self.partkey.addtoclabel(self) for key in self.sortdictionary(NomenclatureEntry.entries): entry = NomenclatureEntry.entries[key] contents = [entry, Constant(entry.symbol + u' ' + entry.description)] text = TaggedText().complete(contents, 'div class="Nomenclated"', True) self.contents.append(text) class PreListInset(object): "Preprocess any container that contains a list inset." def preprocess(self, container): "Preprocess a container, extract any list inset and return it." listinsets = container.searchall(ListInset) if len(listinsets) == 0: return container if len(container.contents) > 1: return container return listinsets[0] Processor.prestages += [PreListInset()] class TableParser(BoundedParser): "Parse the whole table" headers = ContainerConfig.table['headers'] def __init__(self): BoundedParser.__init__(self) self.columns = list() def parseheader(self, reader): "Parse table headers" reader.nextline() while self.startswithheader(reader): self.parseparameter(reader) return [] def startswithheader(self, reader): "Check if the current line starts with a header line" for start in TableParser.headers: if reader.currentline().strip().startswith(start): return True return False class TablePartParser(BoundedParser): "Parse a table part (row or cell)" def parseheader(self, reader): "Parse the header" tablekey, parameters = self.parsexml(reader) self.parameters = parameters return list() class ColumnParser(LoneCommand): "Parse column properties" def parseheader(self, reader): "Parse the column definition" key, parameters = self.parsexml(reader) self.parameters = parameters return [] class Table(Container): "A lyx table" def __init__(self): self.parser = TableParser() self.output = TaggedOutput().settag('table', True) self.columns = [] def process(self): "Set the columns on every row" index = 0 while index < len(self.contents): element = self.contents[index] if isinstance(element, Column): self.columns.append(element) del self.contents[index] elif isinstance(element, BlackBox): del self.contents[index] elif isinstance(element, Row): element.setcolumns(self.columns) index += 1 else: Trace.error('Unknown element type ' + element.__class__.__name__ + ' in table: ' + unicode(element.contents[0])) index += 1 class Row(Container): "A row in a table" def __init__(self): self.parser = TablePartParser() self.output = TaggedOutput().settag('tr', True) self.columns = list() def setcolumns(self, columns): "Process alignments for every column" if len(columns) != len(self.contents): Trace.error('Columns: ' + unicode(len(columns)) + ', cells: ' + unicode(len(self.contents))) return for index, cell in enumerate(self.contents): columns[index].set(cell) class Column(Container): "A column definition in a table" def __init__(self): self.parser = ColumnParser() self.output = EmptyOutput() def process(self): "Read size parameters if present." self.size = ContainerSize().readparameters(self) def set(self, cell): "Set alignments in the corresponding cell" alignment = self.getparameter('alignment') if alignment == 'block': alignment = 'justify' cell.setattribute('align', alignment) valignment = self.getparameter('valignment') cell.setattribute('valign', valignment) self.size.addstyle(cell) class Cell(Container): "A cell in a table" def __init__(self): self.parser = TablePartParser() self.output = TaggedOutput().settag('td', True) def setmulticolumn(self, span): "Set the cell as multicolumn" self.setattribute('colspan', span) def setattribute(self, attribute, value): "Set a cell attribute in the tag" self.output.tag += ' ' + attribute + '="' + unicode(value) + '"' class PostTable(object): "Postprocess a table" processedclass = Table def postprocess(self, last, table, next): "Postprocess a table: long table, multicolumn rows" self.longtable(table) for row in table.contents: index = 0 while index < len(row.contents): self.checkforplain(row, index) self.checkmulticolumn(row, index) index += 1 return table def longtable(self, table): "Postprocess a long table, removing unwanted rows" features = table.getparameter('features') if not features: return if not 'islongtable' in features: return if features['islongtable'] != 'true': return if self.hasrow(table, 'endfirsthead'): self.removerows(table, 'endhead') if self.hasrow(table, 'endlastfoot'): self.removerows(table, 'endfoot') def hasrow(self, table, attrname): "Find out if the table has a row of first heads" for row in table.contents: if row.getparameter(attrname): return True return False def removerows(self, table, attrname): "Remove the head rows, since the table has first head rows." for row in table.contents: if row.getparameter(attrname): row.output = EmptyOutput() def checkforplain(self, row, index): "Make plain layouts visible if necessary." cell = row.contents[index] plainlayouts = cell.searchall(PlainLayout) if len(plainlayouts) <= 1: return for plain in plainlayouts: plain.makevisible() def checkmulticolumn(self, row, index): "Process a multicolumn attribute" cell = row.contents[index] mc = cell.getparameter('multicolumn') if not mc: return if mc != '1': Trace.error('Unprocessed multicolumn=' + unicode(multicolumn) + ' cell ' + unicode(cell)) return total = 1 index += 1 while self.checkbounds(row, index): del row.contents[index] total += 1 cell.setmulticolumn(total) def checkbounds(self, row, index): "Check if the index is within bounds for the row" if index >= len(row.contents): return False mc = row.contents[index].getparameter('multicolumn') if mc != '2': return False return True Postprocessor.stages.append(PostTable) import struct import sys import os import shutil import os import os.path import codecs class Path(object): "Represents a generic path" def exists(self): "Check if the file exists" return os.path.exists(self.path) def open(self): "Open the file as readonly binary" return codecs.open(self.path, 'rb') def getmtime(self): "Return last modification time" return os.path.getmtime(self.path) def hasexts(self, exts): "Check if the file has one of the given extensions." for ext in exts: if self.hasext(ext): return True return False def hasext(self, ext): "Check if the file has the given extension" return self.getext() == ext def getext(self): "Get the current extension of the file." base, ext = os.path.splitext(self.path) return ext def __unicode__(self): "Return a unicode string representation" return self.path def __eq__(self, path): "Compare to another path" if not hasattr(path, 'path'): return False return self.path == path.path class InputPath(Path): "Represents an input file" def __init__(self, url): "Create the input path based on url" self.url = url self.path = url if not os.path.isabs(url): self.path = os.path.join(Options.directory, url) class OutputPath(Path): "Represents an output file" def __init__(self, inputpath): "Create the output path based on an input path" self.url = inputpath.url if os.path.isabs(self.url): self.url = os.path.basename(self.url) self.path = os.path.join(Options.destdirectory, self.url) def changeext(self, ext): "Change extension to the given one" base, oldext = os.path.splitext(self.path) self.path = base + ext base, oldext = os.path.splitext(self.url) self.url = base + ext def exists(self): "Check if the file exists" return os.path.exists(self.path) def createdirs(self): "Create any intermediate directories that don't exist" dir = os.path.dirname(self.path) if len(dir) > 0 and not os.path.exists(dir): os.makedirs(dir) def removebackdirs(self): "Remove any occurrences of ../ (or ..\ on Windows)" self.path = os.path.normpath(self.path) backdir = '..' + os.path.sep while self.path.startswith(backdir): self.path = self.path[len(backdir):] while self.url.startswith('../'): self.url = self.url[len('../'):] class Image(Container): "An embedded image" defaultformat = ImageConfig.formats['default'] size = None copy = None def __init__(self): self.parser = InsetParser() self.output = TaggedOutput() self.type = 'embedded' def process(self): "Place the url, convert the image if necessary." self.origin = InputPath(self.getparameter('filename')) self.destination = self.getdestination(self.origin) self.size = ContainerSize().readparameters(self) if self.origin.exists(): ImageConverter.instance.convert(self) else: Trace.error('Image ' + unicode(self.origin) + ' not found') self.setsize() self.settag() def getdestination(self, origin): "Convert origin path to destination path." "Changes extension of destination to output image format." destination = OutputPath(origin) if Options.noconvert: return destination self.convertformat(destination) destination.removebackdirs() return destination def convertformat(self, destination): "Convert the format of the destination image." if Options.copyimages: return imageformat = '.jpg' forcedest = Image.defaultformat if Options.imageformat: imageformat = Options.imageformat forcedest = Options.imageformat if not destination.hasext(imageformat): destination.changeext(forcedest) def setsize(self): "Set the size attributes width and height." width, height = ImageFile(self.destination).getdimensions() self.size.checkimage(width, height) def scalevalue(self, value): "Scale the value according to the image scale and return it as unicode." scaled = value * int(self.size.scale) / 100 return unicode(int(scaled)) + 'px' def settag(self): "Set the output tag for the image." tag = 'img class="' + self.type + '"' if self.origin.exists(): url = self.destination.url else: url = self.origin.url alt = Translator.translate('figure') + ' ' + url tag += ' src="' + url + '" alt="' + alt + '"' emptytag = True if self.destination.hasext('.svg'): self.contents = [Constant(alt)] tag = 'object class="' + self.type + '" data="' + url + '"' emptytag = False self.output.settag(tag, True, empty=emptytag) self.size.addstyle(self) class ImageConverter(object): "A converter from elyxer.one image file to another." vectorformats = ImageConfig.formats['vector'] cropboxformats = ImageConfig.cropboxformats active = True instance = None def convert(self, image): "Convert an image to PNG" if not ImageConverter.active or Options.noconvert: return if image.origin.path == image.destination.path: return if image.destination.exists(): if image.origin.getmtime() <= image.destination.getmtime(): # file has not changed; do not convert return image.destination.createdirs() if Options.copyimages: Trace.debug('Copying ' + image.origin.path + ' to ' + image.destination.path) shutil.copy2(image.origin.path, image.destination.path) return converter, command = self.buildcommand(image) try: Trace.debug(converter + ' command: "' + command + '"') result = os.system(command.encode(sys.getfilesystemencoding())) if result != 0: Trace.error(converter + ' not installed; images will not be processed') ImageConverter.active = False return Trace.message('Converted ' + unicode(image.origin) + ' to ' + unicode(image.destination)) except OSError, exception: Trace.error('Error while converting image ' + unicode(image.origin) + ': ' + unicode(exception)) def buildcommand(self, image): "Build the command to convert the image." if Options.converter in ImageConfig.converters: command = ImageConfig.converters[Options.converter] else: command = Options.converter; params = self.getparams(image) for param in params: command = command.replace('$' + param, unicode(params[param])) # remove unwanted options while '[' in command and ']' in command: command = self.removeparam(command) return Options.converter, command def removeparam(self, command): "Remove an unwanted param." if command.index('[') > command.index(']'): Trace.error('Converter command should be [...$...]: ' + command) exit() before = command[:command.index('[')] after = command[command.index(']') + 1:] between = command[command.index('[') + 1:command.index(']')] if '$' in between: return before + after return before + between + after def getparams(self, image): "Get the parameters for ImageMagick conversion" params = dict() params['input'] = image.origin params['output'] = image.destination if image.origin.hasexts(self.vectorformats): scale = 100 if image.size.scale: scale = image.size.scale # descale image.size.scale = None params['scale'] = scale if image.origin.getext() in self.cropboxformats: params['format'] = self.cropboxformats[image.origin.getext()] return params ImageConverter.instance = ImageConverter() class ImageFile(object): "A file corresponding to an image (JPG or PNG)" dimensions = dict() def __init__(self, path): "Create the file based on its path" self.path = path def getdimensions(self): "Get the dimensions of a JPG or PNG image" if not self.path.exists(): return None, None if unicode(self.path) in ImageFile.dimensions: return ImageFile.dimensions[unicode(self.path)] dimensions = (None, None) if self.path.hasext('.png'): dimensions = self.getpngdimensions() elif self.path.hasext('.jpg'): dimensions = self.getjpgdimensions() elif self.path.hasext('.svg'): dimensions = self.getsvgdimensions() ImageFile.dimensions[unicode(self.path)] = dimensions return dimensions def getpngdimensions(self): "Get the dimensions of a PNG image" pngfile = self.path.open() pngfile.seek(16) width = self.readlong(pngfile) height = self.readlong(pngfile) pngfile.close() return (width, height) def getjpgdimensions(self): "Get the dimensions of a JPEG image" jpgfile = self.path.open() start = self.readword(jpgfile) if start != int('ffd8', 16): Trace.error(unicode(self.path) + ' not a JPEG file') return (None, None) self.skipheaders(jpgfile, ['ffc0', 'ffc2']) self.seek(jpgfile, 3) height = self.readword(jpgfile) width = self.readword(jpgfile) jpgfile.close() return (width, height) def getsvgdimensions(self): "Get the dimensions of a SVG image." return (None, None) def skipheaders(self, file, hexvalues): "Skip JPEG headers until one of the parameter headers is found" headervalues = [int(value, 16) for value in hexvalues] header = self.readword(file) safetycounter = 0 while header not in headervalues and safetycounter < 30: length = self.readword(file) if length == 0: Trace.error('End of file ' + file.name) return self.seek(file, length - 2) header = self.readword(file) safetycounter += 1 def readlong(self, file): "Read a long (32-bit) value from elyxer.file" return self.readformat(file, '>L', 4) def readword(self, file): "Read a 16-bit value from elyxer.file" return self.readformat(file, '>H', 2) def readformat(self, file, format, bytes): "Read any format from elyxer.file" read = file.read(bytes) if read == '' or len(read) < bytes: Trace.error('EOF reached') return 0 tuple = struct.unpack(format, read) return tuple[0] def seek(self, file, bytes): "Seek forward, just by reading the given number of bytes" file.read(bytes) class ListItem(Container): "An element in a list" type = 'none' def __init__(self): "Create a list item." self.parser = BoundedParser() self.output = ContentsOutput() def process(self): "Set the correct type and contents." self.type = self.header[1] tag = TaggedText().complete(self.contents, 'li', True) self.contents = [tag] def __unicode__(self): return self.type + ' item @ ' + unicode(self.begin) class DeeperList(Container): "A nested list" def __init__(self): "Create a nested list element." self.parser = BoundedParser() self.output = ContentsOutput() self.contents = [] def process(self): "Create the deeper list" if len(self.contents) == 0: Trace.error('Empty deeper list') return def __unicode__(self): result = 'deeper list @ ' + unicode(self.begin) + ': [' for element in self.contents: result += unicode(element) + ', ' return result[:-2] + ']' class PendingList(object): "A pending list" def __init__(self): self.contents = [] self.type = None def additem(self, item): "Add a list item" self.contents += item.contents if not self.type: self.type = item.type def adddeeper(self, deeper): "Add a deeper list item" if self.empty(): self.insertfake() self.contents[-1].contents += deeper.contents def generate(self): "Get the resulting list" if not self.type: tag = 'ul' else: tag = TagConfig.listitems[self.type] text = TaggedText().complete(self.contents, tag, True) self.__init__() return text def isduewithitem(self, item): "Decide whether the pending list must be generated before the given item" if not self.type: return False if self.type != item.type: return True return False def isduewithnext(self, next): "Applies only if the list is finished with next item." if not next: return True if not isinstance(next, ListItem) and not isinstance(next, DeeperList): return True return False def empty(self): return len(self.contents) == 0 def insertfake(self): "Insert a fake item" item = TaggedText().constant('', 'li class="nested"', True) self.contents = [item] self.type = 'Itemize' def __unicode__(self): result = 'pending ' + unicode(self.type) + ': [' for element in self.contents: result += unicode(element) + ', ' if len(self.contents) > 0: result = result[:-2] return result + ']' class PostListItem(object): "Postprocess a list item" processedclass = ListItem def postprocess(self, last, item, next): "Add the item to pending and return an empty item" if not hasattr(self.postprocessor, 'list'): self.postprocessor.list = PendingList() self.postprocessor.list.additem(item) if self.postprocessor.list.isduewithnext(next): return self.postprocessor.list.generate() if isinstance(next, ListItem) and self.postprocessor.list.isduewithitem(next): return self.postprocessor.list.generate() return BlackBox() class PostDeeperList(object): "Postprocess a deeper list" processedclass = DeeperList def postprocess(self, last, deeper, next): "Append to the list in the postprocessor" if not hasattr(self.postprocessor, 'list'): self.postprocessor.list = PendingList() self.postprocessor.list.adddeeper(deeper) if self.postprocessor.list.isduewithnext(next): return self.postprocessor.list.generate() return BlackBox() Postprocessor.stages += [PostListItem, PostDeeperList] class Float(Container): "A floating inset" type = 'none' def __init__(self): self.parser = InsetParser() self.output = TaggedOutput().settag('div class="float"', True) def process(self): "Get the float type." self.type = self.header[2] self.processnumber() self.processfloats() self.processtags() def isparent(self): "Find out whether the float is the parent float or is contained in another float." current = self.parent while current: if isinstance(current, Float): return False current = current.parent return True def processnumber(self): "Number a float if it isn't numbered." if not self.isparent(): # do nothing; parent will take care of numbering return self.partkey = PartKey().createfloat(self) def processtags(self): "Process the HTML tags." tagged = self.embed() self.applywideningtag(tagged) def embed(self): "Embed the whole contents in a div." embeddedtag = self.getembeddedtag() tagged = TaggedText().complete(self.contents, embeddedtag, True) self.contents = [tagged] return tagged def processfloats(self): "Process all floats contained inside." floats = self.searchall(Float) counter = NumberCounter('subfloat').setmode('a') for subfloat in floats: subfloat.output.tag = subfloat.output.tag.replace('div', 'span') subfloat.partkey = PartKey().createsubfloat(counter.getnext()) def getembeddedtag(self): "Get the tag for the embedded object." floats = self.searchall(Float) if len(floats) > 0: return 'div class="multi' + self.type + '"' return 'div class="' + self.type + '"' def applywideningtag(self, container): "Apply the tag to set float width, if present." images = self.searchall(Image) if len(images) != 1: return '' image = images[0] if not image.size: return width = image.size.removepercentwidth() if not width: return image.type = 'figure' ContainerSize().setmax(width).addstyle(container) image.settag() def searchinside(self, type): "Search for a given type in the contents" return self.searchincontents(self.contents, type) def searchincontents(self, contents, type): "Search in the given contents for the required type." list = [] for element in contents: list += self.searchinelement(element, type) return list def searchinelement(self, element, type): "Search for a given type outside floats" if isinstance(element, Float): return [] if isinstance(element, type): return [element] return self.searchincontents(element.contents, type) def __unicode__(self): "Return a printable representation" return 'Floating inset of type ' + self.type class Wrap(Float): "A wrapped (floating) float" def processtags(self): "Add the widening tag to the parent tag." self.embed() placement = self.getparameter('placement') if not placement: placement = 'o' self.output.tag = 'div class="wrap-' + placement + '"' self.applywideningtag(self) class Listing(Container): "A code listing" processor = None def __init__(self): self.parser = InsetParser() self.output = TaggedOutput().settag('div class="listing"', True) self.numbered = None def process(self): "Remove all layouts" self.counter = 0 self.type = 'listing' self.processparams() if Listing.processor: Listing.processor.preprocess(self) for container in self.extractcontents(): if container: self.contents.append(container) if 'caption' in self.lstparams: text = self.lstparams['caption'][1:-1] self.contents.insert(0, Caption().create(text)) if Listing.processor: Listing.processor.postprocess(self) def extractcontents(self): "Extract all contents one container at a time." oldcontents = self.contents self.contents = [] inpre = [] for container in oldcontents: if self.iscaption(container): yield self.completepre(inpre) inpre = [] yield container else: inpre += self.extract(container) yield self.completepre(inpre) def processparams(self): "Process listing parameteres." LstParser().parsecontainer(self) if 'numbers' in self.lstparams: self.numbered = self.lstparams['numbers'] def iscaption(self, container): "Find out if the container has a caption (which should not be in
)."
return (len(container.searchall(Caption)) > 0)
def completepre(self, listinpre):
"Complete the tag with whatever has already been added."
if len(listinpre) == 0:
return None
return TaggedText().complete(listinpre, 'pre class="listing"', False)
def extract(self, container):
"Extract the container's contents and return them"
if isinstance(container, StringContainer):
return self.modifystring(container)
if isinstance(container, StandardLayout):
return self.modifylayout(container)
if isinstance(container, PlainLayout):
return self.modifylayout(container)
Trace.error('Unexpected container ' + container.__class__.__name__ +
' in listing')
container.tree()
return []
def modifystring(self, string):
"Modify a listing string"
if string.string == '':
string.string = u''
return self.modifycontainer(string)
def modifylayout(self, layout):
"Modify a standard layout"
if len(layout.contents) == 0:
layout.contents = [Constant(u'')]
return self.modifycontainer(layout)
def modifycontainer(self, container):
"Modify a listing container"
contents = [container, Constant('\n')]
if self.numbered:
self.counter += 1
tag = 'span class="number-' + self.numbered + '"'
contents.insert(0, TaggedText().constant(unicode(self.counter), tag))
return contents
class FloatNumber(Container):
"Holds the number for a float in the caption."
def __init__(self):
self.output = ContentsOutput()
def create(self, float):
"Create the float number."
self.contents = [Constant(float.partkey.partkey)]
return self
class PostFloat(object):
"Postprocess a float: number it and move the label"
processedclass = Float
def postprocess(self, last, float, next):
"Move the label to the top and number the caption"
number = FloatNumber().create(float)
for caption in float.searchinside(Caption):
self.postlabels(float, caption)
caption.contents = [number, Separator(u' ')] + caption.contents
return float
def postlabels(self, float, caption):
"Search for labels and move them to the top"
labels = caption.searchremove(Label)
if len(labels) == 0 and float.partkey.tocentry:
labels = [Label().create(' ', float.partkey.partkey.replace(' ', '-'))]
float.contents = labels + float.contents
class PostWrap(PostFloat):
"For a wrap: exactly like a float"
processedclass = Wrap
Postprocessor.stages += [PostFloat, PostWrap]
class IncludeInset(Container):
"A child document included within another."
# the converter factory will be set in converter.py
converterfactory = None
filename = None
def __init__(self):
self.parser = InsetParser()
self.output = ContentsOutput()
def process(self):
"Include the provided child document"
self.filename = os.path.join(Options.directory, self.getparameter('filename'))
Trace.debug('Child document: ' + self.filename)
LstParser().parsecontainer(self)
command = self.getparameter('LatexCommand')
if command == 'verbatiminput':
self.readverbatim()
return
elif command == 'lstinputlisting':
self.readlisting()
return
self.processinclude()
def processinclude(self):
"Process a regular include: standard child document."
self.contents = []
olddir = Options.directory
newdir = os.path.dirname(self.getparameter('filename'))
if newdir != '':
Trace.debug('Child dir: ' + newdir)
Options.directory = os.path.join(Options.directory, newdir)
try:
self.convertinclude()
finally:
Options.directory = olddir
def convertinclude(self):
"Convert an included document."
try:
converter = IncludeInset.converterfactory.create(self)
except:
Trace.error('Could not read ' + self.filename + ', please check that the file exists and has read permissions.')
return
if self.hasemptyoutput():
return
converter.convert()
self.contents = converter.getcontents()
def readverbatim(self):
"Read a verbatim document."
self.contents = [TaggedText().complete(self.readcontents(), 'pre', True)]
def readlisting(self):
"Read a document as a listing."
listing = Listing()
listing.contents = self.readcontents()
listing.parameters = self.parameters
listing.process()
self.contents = [listing]
def readcontents(self):
"Read the contents of a complete file."
contents = list()
lines = BulkFile(self.filename).readall()
for line in lines:
contents.append(Constant(line))
return contents
def __unicode__(self):
"Return a printable description."
if not self.filename:
return 'Included unnamed file'
return 'Included "' + self.filename + '"'
class ChangeInserted(Container):
"A change which consists of an insertion."
def __init__(self):
self.parser = TextParser(self)
if DocumentParameters.outputchanges:
self.output = TaggedOutput().settag('span class="inserted"')
else:
self.output = ContentsOutput()
class ChangeDeleted(TaggedText):
"A change which consists of a deletion."
def __init__(self):
self.parser = TextParser(self)
if DocumentParameters.outputchanges:
self.output = TaggedOutput().settag('span class="deleted"')
else:
self.output = EmptyOutput()
class ERT(FirstWord):
"Evil Red Text: embedded TeX code."
"Considered as a first word for descriptions."
def __init__(self):
self.parser = InsetParser()
self.output = ContentsOutput()
def process(self):
"Process all TeX code, formulas, commands."
text = ''
separator = ''
for container in self.contents:
text += separator + container.extracttext()
separator = '\n'
pos = TextPosition(text)
pos.leavepending = True
code = TeXCode()
code.parse(pos)
self.contents = [code]
def isempty(self):
"Find out if the ERT is empty or not."
if len(self.contents) == 0:
return True
if len(self.contents) > 1:
Trace.error('Unknown ERT length 2')
return False
texcode = self.contents[0]
return len(texcode.contents) == 0
class TeXCode(Container):
"A parser and processor for TeX code."
texseparators = ['{', '\\', '}', '$', '%']
replaced = BibTeXConfig.replaced
factory = FormulaFactory()
endinglist = EndingList()
def __init__(self):
self.contents = []
self.output = ContentsOutput()
def parse(self, pos):
"Parse some TeX code."
self.parserecursive(pos)
if pos.leavepending:
self.endinglist.pickpending(pos)
def findlaststring(self):
"Find the last string in the contents."
if len(self.contents) == 0:
return None
string = self.contents[-1]
if not isinstance(string, StringContainer):
return None
return string
def add(self, piece):
"Add a new piece to the tag."
if isinstance(piece, basestring):
self.addtext(piece)
else:
self.contents.append(piece)
def addtext(self, piece):
"Add a text string to the tag."
last = self.findlaststring()
if last:
last.string += piece
return
self.contents.append(Constant(piece))
def parserecursive(self, pos):
"Parse brackets or quotes recursively."
while not pos.finished():
self.parsetext(pos)
if pos.finished():
return
elif pos.checkfor('{'):
self.parseopenbracket(pos)
elif pos.checkfor('}'):
self.parseclosebracket(pos)
elif pos.checkfor('\\'):
self.parseescaped(pos)
elif pos.checkfor('$'):
self.parseformula(pos)
elif pos.checkfor('%'):
self.parsecomment(pos)
else:
pos.error('Unexpected character ' + pos.current())
pos.skipcurrent()
def parsetext(self, pos):
"Parse a bit of text, excluding separators and compressing spaces."
text = self.parsecompressingspace(pos)
if text == '':
return
for key in self.replaced:
if key in text:
text = text.replace(key, self.replaced[key])
self.add(text)
def parsecompressingspace(self, pos):
"Parse some text excluding value separators and compressing spaces."
parsed = ''
while not pos.finished():
parsed += pos.glob(lambda: self.excludespaces(pos))
if not pos.finished() and pos.current().isspace():
parsed += ' '
pos.skipspace()
else:
return parsed
return parsed
def excludespaces(self, pos):
"Exclude value separators and spaces."
current = pos.current()
if current in self.texseparators:
return False
if current.isspace():
return False
return True
def parseescaped(self, pos):
"Parse an escaped string \\*."
if pos.checkfor('\\(') or pos.checkfor('\\['):
# start of formula commands
self.parseformula(pos)
return
if not self.factory.detecttype(FormulaCommand, pos):
pos.error('Not an escape sequence')
return
self.add(self.factory.parsetype(FormulaCommand, pos))
def parseopenbracket(self, pos):
"Parse a { bracket."
if not pos.checkskip('{'):
pos.error('Missing opening { bracket')
return
pos.pushending('}')
self.parserecursive(pos)
pos.popending('}')
def parseclosebracket(self, pos):
"Parse a } bracket."
ending = self.endinglist.findending(pos)
if not ending:
Trace.error('Unexpected closing } bracket')
else:
self.endinglist.pop(pos)
if not pos.checkskip('}'):
pos.error('Missing closing } bracket')
return
def parseformula(self, pos):
"Parse a whole formula."
formula = Formula().parse(pos)
self.add(formula)
def parsecomment(self, pos):
"Parse a TeX comment: % to the end of the line."
pos.globexcluding('\n')
def __unicode__(self):
"Return a printable representation."
return 'TeX code: ' + self.extracttext()
class BibTagParser(object):
"A parser for BibTeX tags."
nameseparators = ['{', '=', '"', '#']
def __init__(self):
self.key = None
tags = BibStylesConfig.defaulttags
self.tags = dict((x, BibTag().constant(tags[x])) for x in tags)
def parse(self, pos):
"Parse the entry between {}."
self.type = pos.globexcluding(self.nameseparators).strip()
if not pos.checkskip('{'):
pos.error('Entry should start with {')
return
pos.pushending('}')
self.parsetags(pos)
pos.popending('}')
pos.skipspace()
def parsetags(self, pos):
"Parse all tags in the entry."
pos.skipspace()
while not pos.finished():
if pos.checkskip('{'):
pos.error('Unmatched {')
return
pos.pushending(',', True)
self.parsetag(pos)
if pos.checkfor(','):
pos.popending(',')
def parsetag(self, pos):
"Parse a single tag."
(key, value) = self.getkeyvalue(pos)
if not value:
self.key = key
return
name = key.lower()
self.tags[name] = value
if hasattr(self, 'dissect' + name):
dissector = getattr(self, 'dissect' + name)
dissector(value.extracttext())
if not pos.finished():
remainder = pos.globexcluding(',')
pos.error('Ignored ' + remainder + ' before comma')
def getkeyvalue(self, pos):
"Parse a string of the form key=value."
piece = pos.globexcluding(self.nameseparators).strip()
if pos.finished():
return (piece, None)
if not pos.checkskip('='):
pos.error('Undesired character in tag name ' + piece)
pos.skipcurrent()
return (piece, None)
key = piece.lower()
pos.skipspace()
value = self.parsevalue(pos)
return (key, value)
def parsevalue(self, pos):
"Parse the value for a tag."
tag = BibTag()
pos.skipspace()
if pos.checkfor(','):
pos.error('Unexpected ,')
return tag.error()
tag.parse(pos)
return tag
def dissectauthor(self, authortag):
"Dissect the author tag into pieces."
authorsplit = authortag.split(' and ')
if len(authorsplit) == 0:
return
authorlist = []
for authorname in authorsplit:
author = BibAuthor().parse(authorname)
authorlist.append(author)
initials = ''
authors = ''
if len(authorlist) == 1:
initials = authorlist[0].surname[0:3]
authors = unicode(authorlist[0])
else:
for author in authorlist:
initials += author.surname[0:1]
authors += unicode(author) + ', '
authors = authors[:-2]
self.tags['surname'] = BibTag().constant(authorlist[0].surname)
self.tags['Sur'] = BibTag().constant(initials)
self.tags['authors'] = BibTag().constant(authors)
def dissectyear(self, yeartag):
"Dissect the year tag into pieces, looking for 4 digits in a row."
pos = TextPosition(yeartag)
while not pos.finished():
if pos.current().isdigit():
number = pos.globnumber()
if len(number) == 4:
self.tags['YY'] = BibTag().constant(number[2:])
return
else:
pos.skipcurrent()
def dissectfile(self, filetag):
"Extract the filename from elyxer.the file tag as ':filename:FORMAT'."
if not filetag.startswith(':'):
return
bits = filetag.split(':')
if len(bits) != 3:
return
self.tags['filename'] = BibTag().constant(bits[1])
self.tags['format'] = BibTag().constant(bits[2])
def gettag(self, key):
"Get the tag for a given key."
if not key in self.tags:
return None
return self.tags[key]
def gettagtext(self, key):
"Get the tag for a key as raw text."
return self.gettag(key).extracttext()
class BibTag(Container):
"A tag in a BibTeX file."
valueseparators = ['{', '"', '#', '}']
stringdefs = dict()
def __init__(self):
self.contents = []
self.output = ContentsOutput()
def constant(self, text):
"Initialize for a single constant."
self.contents = [Constant(text)]
return self
def error(self):
"To use when parsing resulted in an error."
return self.constant('')
def parse(self, pos):
"Parse brackets or quotes at the first level."
while not pos.finished():
self.parsetext(pos)
if pos.finished():
return
elif pos.checkfor('{'):
self.parsebracket(pos)
elif pos.checkfor('"'):
self.parsequoted(pos)
elif pos.checkfor('#'):
self.parsehash(pos)
else:
pos.error('Unexpected character ' + pos.current())
pos.skipcurrent()
def parsetext(self, pos):
"Parse a bit of text, try to substitute strings with string defs."
text = pos.globexcluding(self.valueseparators)
key = text.strip()
if key == '':
return
if key in self.stringdefs:
self.add(self.stringdefs[key])
return
self.add(Constant(key))
def add(self, piece):
"Add a new piece to the tag."
self.contents.append(piece)
def parsetex(self, pos):
"Parse some TeX code."
tex = TeXCode()
tex.parse(pos)
self.add(tex)
def parsebracket(self, pos):
"Parse a {} bracket"
if not pos.checkskip('{'):
pos.error('Missing opening { in bracket')
return
pos.pushending('}')
self.parsetex(pos)
pos.popending('}')
def parsequoted(self, pos):
"Parse a piece of quoted text"
if not pos.checkskip('"'):
pos.error('Missing opening " in quote')
return
pos.pushending('"')
self.parsetex(pos)
pos.popending('"')
pos.skipspace()
def parsehash(self, pos):
"Parse a hash mark #."
if not pos.checkskip('#'):
pos.error('Missing # in hash')
return
def __unicode__(self):
"Return a printable representation."
return 'BibTag: ' + self.extracttext()
class BibAuthor(object):
"A BibTeX individual author."
def __init__(self):
self.surname = ''
self.firstnames = []
def parse(self, tag):
"Parse an individual author tag."
if ',' in tag:
self.parsecomma(tag)
else:
self.parsewithoutcomma(tag)
return self
def parsecomma(self, tag):
"Parse an author with a comma: Python, M."
bits = tag.split(',')
if len(bits) > 2:
Trace.error('Too many commas in ' + tag)
self.surname = bits[0].strip()
self.parsefirstnames(bits[1].strip())
def parsewithoutcomma(self, tag):
"Parse an author without a comma: M. Python."
bits = tag.rsplit(None, 1)
if len(bits) == 0:
Trace.error('Empty author')
ppp()
return
self.surname = bits[-1].strip()
if len(bits) == 1:
return
self.parsefirstnames(bits[0].strip())
def parsefirstnames(self, firstnames):
"Parse the first name."
for firstname in firstnames.split():
self.firstnames.append(firstname)
def getinitial(self):
"Get the main initial for the author."
if len(self.surname) == 0:
return ''
return self.surname[0].toupper()
def __unicode__(self):
"Return a printable representation."
result = ''
for firstname in self.firstnames:
result += firstname + ' '
return result + self.surname
class BibTeX(Container):
"Show a BibTeX bibliography and all referenced entries"
def __init__(self):
self.parser = InsetParser()
self.output = ContentsOutput()
def process(self):
"Read all bibtex files and process them."
self.entries = []
self.contents = [self.createheader()]
bibliography = Translator.translate('bibliography')
files = self.getparameterlist('bibfiles')
showall = False
if self.getparameter('btprint') == 'btPrintAll':
showall = True
for file in files:
bibfile = BibFile(file, showall)
bibfile.parse()
self.entries += bibfile.entries
Trace.message('Parsed ' + unicode(bibfile))
self.entries.sort(key = unicode)
self.applystyle()
def createheader(self):
"Create the header for the bibliography."
header = BiblioHeader()
if 'bibtotoc' in self.getparameterlist('options'):
header.addtotoc(self)
return header
def applystyle(self):
"Read the style and apply it to all entries"
style = self.readstyle()
for entry in self.entries:
entry.template = style['default']
entry.citetemplate = style['cite']
type = entry.type.lower()
if type in style:
entry.template = style[type]
entry.process()
self.contents.append(entry)
def readstyle(self):
"Read the style from elyxer.the bibliography options"
for option in self.getparameterlist('options'):
if hasattr(BibStylesConfig, option):
return getattr(BibStylesConfig, option)
return BibStylesConfig.default
class BibFile(object):
"A BibTeX file"
def __init__(self, filename, showall):
"Create the BibTeX file"
self.filename = filename + '.bib'
self.showall = showall
self.added = 0
self.ignored = 0
self.entries = []
def parse(self):
"Parse the BibTeX file and extract all entries."
try:
self.parsefile()
except IOError:
Trace.error('Error reading ' + self.filename + '; make sure the file exists and can be read.')
def parsefile(self):
"Parse the whole file."
bibpath = InputPath(self.filename)
if Options.lowmem:
pos = FilePosition(bibpath.path)
else:
bulkfile = BulkFile(bibpath.path)
text = ''.join(bulkfile.readall())
pos = TextPosition(text)
while not pos.finished():
pos.skipspace()
if pos.checkskip(','):
pos.skipspace()
self.parseentry(pos)
def parseentry(self, pos):
"Parse a single entry"
for entry in BibEntry.instances:
if entry.detect(pos):
newentry = Cloner.clone(entry)
newentry.parse(pos)
if not newentry.isvisible():
return
if self.showall or newentry.isreferenced():
self.entries.append(newentry)
self.added += 1
else:
Trace.debug('Ignored entry ' + unicode(newentry))
self.ignored += 1
return
# Skip the whole line since it's a comment outside an entry
pos.globincluding('\n').strip()
def __unicode__(self):
"String representation"
string = self.filename + ': ' + unicode(self.added) + ' entries added, '
string += unicode(self.ignored) + ' entries ignored'
return string
class BibEntry(Container):
"An entry in a BibTeX file"
instances = []
def detect(self, pos):
"Throw an error."
Trace.error('Tried to detect() in ' + unicode(self))
def parse(self, pos):
"Throw an error."
Trace.error('Tried to parse() in ' + unicode(self))
def isvisible(self):
"Return if the entry should be visible. Throws an error."
Trace.error('Function isvisible() not implemented for ' + unicode(self))
def isreferenced(self):
"Return if the entry is referenced. Throws an error."
Trace.error('Function isreferenced() not implemented for ' + unicode(self))
def __unicode__(self):
"Return a string representation"
return 'BibTeX entry ' + self.__class__.__name__
class CommentEntry(BibEntry):
"A simple comment."
def detect(self, pos):
"Detect the special entry"
return pos.checkfor('%')
def parse(self, pos):
"Parse all consecutive comment lines."
while pos.checkfor('%'):
pos.globincluding('\n')
def isvisible(self):
"A comment entry is never visible."
return False
def __unicode__(self):
"Return a string representation"
return 'Comment'
class SpecialEntry(BibEntry):
"A special entry"
types = ['@preamble', '@comment']
def __init__(self):
self.contents = []
self.output = EmptyOutput()
def detect(self, pos):
"Detect the special entry"
for type in self.types:
if pos.checkforlower(type):
return True
return False
def parse(self, pos):
"Parse and ignore."
self.type = 'special'
pos.globincluding('{')
pos.pushending('}')
while not pos.finished():
if pos.checkfor('{'):
self.parse(pos)
else:
pos.skipcurrent()
pos.popending()
def isvisible(self):
"A special entry is never visible."
return False
def __unicode__(self):
"Return a string representation"
return self.type
class StringEntry(SpecialEntry):
"A string definition. The definition can later be used in other entries."
parser = BibTagParser()
start = '@string'
key = None
def detect(self, pos):
"Detect the string definition."
return pos.checkforlower(self.start)
def parse(self, pos):
"Parse a single tag, which will define a string."
self.type = self.start
if not self.checkstart(pos):
return
pos.skipspace()
if not pos.checkskip('{'):
Trace.error('Missing opening { in ' + unicode(self))
pos.globincluding('\n')
return
pos.pushending('}')
(self.key, value) = self.parser.getkeyvalue(pos)
BibTag.stringdefs[self.key] = value
pos.popending('}')
def checkstart(self, pos):
"Check that the entry starts with @string."
if not pos.checkskip('@'):
Trace.error('Missing @ from elyxer.string definition')
return False
name = '@' + pos.globalpha()
if not name.lower() == self.start.lower():
Trace.error('Invalid start @' + name +', missing ' + self.start + ' from elyxer.' + unicode(self))
pos.globincluding('\n')
return False
return True
def __unicode__(self):
"Return a printable representation."
result = 'string definition'
if self.key:
result += ' for ' + self.key
return result
BibEntry.instances += [CommentEntry(), SpecialEntry(), StringEntry()]
class PubEntry(BibEntry):
"A publication entry"
def __init__(self):
self.output = TaggedOutput().settag('p class="biblio"', True)
def detect(self, pos):
"Detect a publication entry."
return pos.checkfor('@')
def parse(self, pos):
"Parse the publication entry."
self.parser = BibTagParser()
self.parser.parse(pos)
self.type = self.parser.type
def isvisible(self):
"A publication entry is always visible."
return True
def isreferenced(self):
"Check if the entry is referenced."
if not self.parser.key:
return False
return self.parser.key in BiblioReference.references
def process(self):
"Process the entry."
self.index = NumberGenerator.generator.generate('pubentry')
self.parser.tags['index'] = Constant(self.index)
biblio = BiblioEntry()
biblio.citeref = self.createref()
biblio.processcites(self.parser.key)
self.contents = [biblio, Constant(' ')]
self.contents += self.entrycontents()
def entrycontents(self):
"Get the contents of the entry."
return self.translatetemplate(self.template)
def createref(self):
"Create the reference to cite."
return self.translatetemplate(self.citetemplate)
def translatetemplate(self, template):
"Translate a complete template into a list of contents."
pos = TextPosition(template)
part = BibPart(self.parser.tags).parse(pos)
for variable in part.searchall(BibVariable):
if variable.empty():
Trace.error('Error parsing BibTeX template for ' + unicode(self) + ': '
+ unicode(variable) + ' is empty')
return [part]
def __unicode__(self):
"Return a string representation"
string = ''
if 'author' in self.parser.tags:
string += self.parser.gettagtext('author') + ': '
if 'title' in self.parser.tags:
string += '"' + self.parser.gettagtext('title') + '"'
return string
class BibPart(Container):
"A part of a BibTeX template."
def __init__(self, tags):
self.output = ContentsOutput()
self.contents = []
self.tags = tags
self.quotes = 0
def parse(self, pos):
"Parse a part of a template, return a list of contents."
while not pos.finished():
self.add(self.parsepiece(pos))
return self
def parsepiece(self, pos):
"Get the next piece of the template, return if it was empty."
if pos.checkfor('{'):
return self.parsebraces(pos)
elif pos.checkfor('$'):
return self.parsevariable(pos)
result = ''
while not pos.finished() and not pos.current() in '{$':
if pos.current() == '"':
self.quotes += 1
result += pos.skipcurrent()
return Constant(result)
def parsebraces(self, pos):
"Parse a pair of curly braces {}."
if not pos.checkskip('{'):
Trace.error('Missing { in braces.')
return None
pos.pushending('}')
part = BibPart(self.tags).parse(pos)
pos.popending('}')
empty = part.emptyvariables()
if empty:
return None
return part
def parsevariable(self, pos):
"Parse a variable $name."
var = BibVariable(self.tags).parse(pos)
if self.quotes % 2 == 1:
# odd number of quotes; don't add spans in an attribute
var.removetag()
return var
def emptyvariables(self):
"Find out if there are only empty variables in the part."
for variable in self.searchall(BibVariable):
if not variable.empty():
return False
return True
def add(self, piece):
"Add a new piece to the current part."
if not piece:
return
if self.redundantdot(piece):
# remove extra dot
piece.string = piece.string[1:]
self.contents.append(piece)
piece.parent = self
def redundantdot(self, piece):
"Find out if there is a redundant dot in the next piece."
if not isinstance(piece, Constant):
return False
if not piece.string.startswith('.'):
return False
if len(self.contents) == 0:
return False
if not isinstance(self.contents[-1], BibVariable):
return False
if not self.contents[-1].extracttext().endswith('.'):
return False
return True
class BibVariable(Container):
"A variable in a BibTeX template."
def __init__(self, tags):
self.output = TaggedOutput()
self.contents = []
self.tags = tags
def parse(self, pos):
"Parse the variable name."
if not pos.checkskip('$'):
Trace.error('Missing $ in variable name.')
return self
self.key = pos.globalpha()
self.output.tag = 'span class="bib-' + self.key + '"'
self.processtags()
return self
def processtags(self):
"Find the tag with the appropriate key in the list of tags."
if not self.key in self.tags:
return
result = self.tags[self.key]
self.contents = [result]
def empty(self):
"Find out if the variable is empty."
if not self.contents:
return True
if self.extracttext() == '':
return True
return False
def removetag(self):
"Remove the output tag and leave just the contents."
self.output = ContentsOutput()
def __unicode__(self):
"Return a printable representation."
result = 'variable ' + self.key
if not self.empty():
result += ':' + self.extracttext()
return result
BibEntry.instances += [PubEntry()]
class NewfangledChunk(Layout):
"A chunk of literate programming."
names = dict()
firsttime = True
def process(self):
"Process the literate chunk."
self.output.tag = 'div class="chunk"'
self.type = 'chunk'
text = self.extracttext()
parts = text.split(',')
if len(parts) < 1:
Trace.error('Not enough parameters in ' + text)
return
self.name = parts[0]
self.number = self.order()
self.createlinks()
self.contents = [self.left, self.declaration(), self.right]
ChunkProcessor.lastchunk = self
def order(self):
"Create the order number for the chunk."
return NumberGenerator.generator.generate('chunk')
def createlinks(self):
"Create back and forward links."
self.leftlink = Link().complete(self.number, 'chunk:' + self.number, type='chunk')
self.left = TaggedText().complete([self.leftlink], 'span class="chunkleft"', False)
self.right = TaggedText().constant('', 'span class="chunkright"', False)
if not self.name in NewfangledChunk.names:
NewfangledChunk.names[self.name] = []
else:
last = NewfangledChunk.names[self.name][-1]
forwardlink = Link().complete(self.number + u'→', 'chunkback:' + last.number, type='chunk')
backlink = Link().complete(u'←' + last.number + u' ', 'chunkforward:' + self.number, type='chunk')
forwardlink.setmutualdestination(backlink)
last.right.contents.append(forwardlink)
self.right.contents.append(backlink)
NewfangledChunk.names[self.name].append(self)
self.origin = self.createorigin()
if self.name in NewfangledChunkRef.references:
for ref in NewfangledChunkRef.references[self.name]:
self.linkorigin(ref.origin)
def createorigin(self):
"Create a link that points to the chunks' origin."
link = Link()
self.linkorigin(link)
return link
def linkorigin(self, link):
"Create a link to the origin."
start = NewfangledChunk.names[self.name][0]
link.complete(start.number, type='chunk')
link.destination = start.leftlink
link.computedestination()
def declaration(self):
"Get the chunk declaration."
contents = []
text = u'⟨' + self.name + '[' + unicode(len(NewfangledChunk.names[self.name])) + '] '
contents.append(Constant(text))
contents.append(self.origin)
text = ''
if NewfangledChunk.firsttime:
Listing.processor = ChunkProcessor()
NewfangledChunk.firsttime = False
text += u'⟩'
if len(NewfangledChunk.names[self.name]) > 1:
text += '+'
text += u'≡'
contents.append(Constant(text))
return TaggedText().complete(contents, 'span class="chunkdecl"', True)
class ChunkProcessor(object):
"A processor for listings that belong to chunks."
lastchunk = None
counters = dict()
endcommand = '}'
chunkref = 'chunkref'
def preprocess(self, listing):
"Preprocess a listing: set the starting counter."
if not ChunkProcessor.lastchunk:
return
name = ChunkProcessor.lastchunk.name
if not name in ChunkProcessor.counters:
ChunkProcessor.counters[name] = 0
listing.counter = ChunkProcessor.counters[name]
for command, container, index in self.commandsinlisting(listing):
chunkref = self.getchunkref(command)
if chunkref:
self.insertchunkref(chunkref, container, index)
def commandsinlisting(self, listing):
"Find all newfangle commands in a listing."
for container in listing.contents:
for index in range(len(container.contents) - 2):
if self.findinelement(container, index):
third = container.contents[index + 2].string
end = third.index(NewfangleConfig.constants['endmark'])
command = third[:end]
lenstart = len(NewfangleConfig.constants['startmark'])
container.contents[index].string = container.contents[index].string[:-lenstart]
del container.contents[index + 1]
container.contents[index + 1].string = third[end + len(NewfangleConfig.constants['endmark']):]
yield command, container, index
def findinelement(self, container, index):
"Find a newfangle command in an element."
for i in range(2):
if not isinstance(container.contents[index + i], StringContainer):
return False
first = container.contents[index].string
second = container.contents[index + 1].string
third = container.contents[index + 2].string
if not first.endswith(NewfangleConfig.constants['startmark']):
return False
if second != NewfangleConfig.constants['startcommand']:
return False
if not NewfangleConfig.constants['endmark'] in third:
return False
return True
def getchunkref(self, command):
"Get the contents of a chunkref command, if present."
if not command.startswith(NewfangleConfig.constants['chunkref']):
return None
if not NewfangleConfig.constants['endcommand'] in command:
return None
start = len(NewfangleConfig.constants['chunkref'])
end = command.index(NewfangleConfig.constants['endcommand'])
return command[start:end]
def insertchunkref(self, ref, container, index):
"Insert a chunkref after the given index at the given container."
chunkref = NewfangledChunkRef().complete(ref)
container.contents.insert(index + 1, chunkref)
def postprocess(self, listing):
"Postprocess a listing: store the ending counter for next chunk."
if not ChunkProcessor.lastchunk:
return
ChunkProcessor.counters[ChunkProcessor.lastchunk.name] = listing.counter
class NewfangledChunkRef(Inset):
"A reference to a chunk."
references = dict()
def process(self):
"Show the reference."
self.output.tag = 'span class="chunkref"'
self.ref = self.extracttext()
self.addbits()
def complete(self, ref):
"Complete the reference to the given string."
self.output = ContentsOutput()
self.ref = ref
self.contents = [Constant(self.ref)]
self.addbits()
return self
def addbits(self):
"Add the bits to the reference."
if not self.ref in NewfangledChunkRef.references:
NewfangledChunkRef.references[self.ref] = []
NewfangledChunkRef.references[self.ref].append(self)
if self.ref in NewfangledChunk.names:
start = NewfangledChunk.names[self.ref][0]
self.origin = start.createorigin()
else:
self.origin = Link()
self.contents.insert(0, Constant(u'⟨'))
self.contents.append(Constant(' '))
self.contents.append(self.origin)
self.contents.append(Constant(u'⟩'))
def __unicode__(self):
"Return a printable representation."
return 'Reference to chunk ' + self.ref
class SetCounterFunction(CommandBit):
"A function which is used in the preamble to set a counter."
def parsebit(self, pos):
"Parse a function with [] and {} parameters."
counter = self.parseliteral(pos)
value = self.parseliteral(pos)
try:
self.setcounter(counter, int(value))
except:
Trace.error('Counter ' + counter + ' cannot be set to ' + value)
def setcounter(self, counter, value):
"Set a global counter."
Trace.debug('Setting counter ' + unicode(counter) + ' to ' + unicode(value))
NumberGenerator.generator.getcounter(counter).init(value)
class FormulaTag(CommandBit):
"A \\tag command."
def parsebit(self, pos):
"Parse the tag and apply it."
self.output = EmptyOutput()
self.tag = self.parseliteral(pos)
class MiscCommand(CommandBit):
"A generic command which maps to a command class."
commandmap = FormulaConfig.misccommands
def parsebit(self, pos):
"Find the right command to parse and parse it."
commandtype = globals()[self.translated]
return self.parsecommandtype(self.translated, commandtype, pos)
FormulaCommand.types += [MiscCommand]
class ContainerFactory(object):
"Creates containers depending on the first line"
def __init__(self):
"Read table that convert start lines to containers"
types = dict()
for start, typename in ContainerConfig.starts.iteritems():
types[start] = globals()[typename]
self.tree = ParseTree(types)
def createcontainer(self, reader):
"Parse a single container."
#Trace.debug('processing "' + reader.currentline().strip() + '"')
if reader.currentline() == '':
reader.nextline()
return None
container = Cloner.create(self.tree.find(reader))
container.start = reader.currentline().strip()
self.parse(container, reader)
return container
def parse(self, container, reader):
"Parse a container"
parser = container.parser
parser.parent = container
parser.ending = self.getending(container)
parser.factory = self
container.header = parser.parseheader(reader)
container.begin = parser.begin
self.parsecontents(container, reader)
container.parameters = parser.parameters
container.parser = None
def parsecontents(self, container, reader):
"Parse the contents of a container."
contents = container.parser.parse(reader)
if isinstance(contents, basestring):
# read a string, set as parsed
container.parsed = contents
container.contents = []
else:
container.contents = contents
def getending(self, container):
"Get the ending for a container"
split = container.start.split()
if len(split) == 0:
return None
start = split[0]
if start in ContainerConfig.startendings:
return ContainerConfig.startendings[start]
classname = container.__class__.__name__
if classname in ContainerConfig.endings:
return ContainerConfig.endings[classname]
if hasattr(container, 'ending'):
Trace.error('Pending ending in ' + container.__class__.__name__)
return container.ending
return None
class ParseTree(object):
"A parsing tree"
default = '~~default~~'
def __init__(self, types):
"Create the parse tree"
self.root = dict()
for start, type in types.iteritems():
self.addstart(type, start)
def addstart(self, type, start):
"Add a start piece to the tree"
tree = self.root
for piece in start.split():
if not piece in tree:
tree[piece] = dict()
tree = tree[piece]
if ParseTree.default in tree:
Trace.error('Start ' + start + ' duplicated')
tree[ParseTree.default] = type
def find(self, reader):
"Find the current sentence in the tree"
branches = self.matchline(reader.currentline())
while not ParseTree.default in branches[-1]:
branches.pop()
last = branches[-1]
return last[ParseTree.default]
def matchline(self, line):
"Match a given line against the tree, as deep as possible."
branches = [self.root]
for piece in line.split(' '):
current = branches[-1]
piece = piece.rstrip('>')
if piece in current:
branches.append(current[piece])
else:
return branches
return branches
class TOCEntry(Container):
"A container for a TOC entry."
def __init__(self):
Container.__init__(self)
self.branches = []
def create(self, container):
"Create the TOC entry for a container, consisting of a single link."
if container.partkey.header:
return self.header(container)
self.contents = [self.createlink(container)]
self.output = TaggedOutput().settag('div class="toc"', True)
self.partkey = container.partkey
return self
def header(self, container):
"Create a TOC entry for header and footer (0 depth)."
self.partkey = container.partkey
self.output = EmptyOutput()
return self
def createlink(self, container):
"Create the link that will make the whole TOC entry."
labels = container.searchall(Label)
link = Link()
if self.isanchor(labels):
link.url = '#' + container.partkey.partkey
if Options.tocfor:
link.url = Options.tocfor + link.url
else:
label = labels[0]
link.destination = label
if container.partkey.tocentry:
link.complete(container.partkey.tocentry)
if container.partkey.titlecontents:
if Options.notoclabels:
separator = u' '
else:
separator = u': '
if container.partkey.tocentry:
link.contents.append(Constant(separator))
link.contents += container.partkey.titlecontents
return link
def isanchor(self, labels):
"Decide if the link is an anchor based on a set of labels."
if len(labels) == 0:
return True
if not Options.tocfor:
return False
if Options.splitpart:
return False
return True
def __unicode__(self):
"Return a printable representation."
if not self.partkey.tocentry:
return 'Unnamed TOC entry'
return 'TOC entry: ' + self.partkey.tocentry
class Indenter(object):
"Manages and writes indentation for the TOC."
def __init__(self):
self.depth = 0
def getindent(self, depth):
indent = ''
if depth > self.depth:
indent = self.openindent(depth - self.depth)
elif depth < self.depth:
indent = self.closeindent(self.depth - depth)
self.depth = depth
return Constant(indent)
def openindent(self, times):
"Open the indenting div a few times."
indent = ''
for i in range(times):
indent += '\n'
return indent
def closeindent(self, times):
"Close the indenting div a few times."
indent = ''
for i in range(times):
indent += '\n'
return indent
class IndentedEntry(Container):
"An entry with an indentation."
def __init__(self):
self.output = ContentsOutput()
def create(self, indent, entry):
"Create the indented entry."
self.entry = entry
self.contents = [indent, entry]
return self
def __unicode__(self):
"Return a printable documentation."
return 'Indented ' + unicode(self.entry)
class TOCTree(object):
"A tree that contains the full TOC."
def __init__(self):
self.tree = []
self.branches = []
def store(self, entry):
"Place the entry in a tree of entries."
while len(self.tree) < entry.partkey.level:
self.tree.append(None)
if len(self.tree) > entry.partkey.level:
self.tree = self.tree[:entry.partkey.level]
stem = self.findstem()
if len(self.tree) == 0:
self.branches.append(entry)
self.tree.append(entry)
if stem:
entry.stem = stem
stem.branches.append(entry)
def findstem(self):
"Find the stem where our next element will be inserted."
for element in reversed(self.tree):
if element:
return element
return None
class TOCConverter(object):
"A converter from elyxer.containers to TOC entries."
cache = dict()
tree = TOCTree()
def __init__(self):
self.indenter = Indenter()
def convertindented(self, container):
"Convert a container into an indented TOC entry."
entry = self.convert(container)
if not entry:
return None
return self.indent(entry)
def indent(self, entry):
"Indent a TOC entry."
indent = self.indenter.getindent(entry.partkey.level)
return IndentedEntry().create(indent, entry)
def convert(self, container):
"Convert a container to a TOC entry."
if not container.partkey:
return None
if container.partkey.partkey in self.cache:
return TOCConverter.cache[container.partkey.partkey]
if container.partkey.level > DocumentParameters.tocdepth:
return None
entry = TOCEntry().create(container)
TOCConverter.cache[container.partkey.partkey] = entry
TOCConverter.tree.store(entry)
return entry
class Basket(object):
"A basket to place a set of containers. Can write them, store them..."
def setwriter(self, writer):
self.writer = writer
return self
class WriterBasket(Basket):
"A writer of containers. Just writes them out to a writer."
def write(self, container):
"Write a container to the line writer."
self.writer.write(container.gethtml())
def finish(self):
"Mark as finished."
self.writer.close()
class KeeperBasket(Basket):
"Keeps all containers stored."
def __init__(self):
self.contents = []
def write(self, container):
"Keep the container."
self.contents.append(container)
def finish(self):
"Finish the basket by flushing to disk."
self.flush()
def flush(self):
"Flush the contents to the writer."
for container in self.contents:
self.writer.write(container.gethtml())
self.writer.close()
class TOCBasket(Basket):
"A basket to place the TOC of a document."
def __init__(self):
self.converter = TOCConverter()
def setwriter(self, writer):
Basket.setwriter(self, writer)
Options.nocopy = True
self.writer.write(LyXHeader().gethtml())
return self
def write(self, container):
"Write the table of contents for a container."
entry = self.converter.convertindented(container)
if entry:
self.writer.write(entry.gethtml())
def finish(self):
"Mark as finished."
self.writer.write(LyXFooter().gethtml())
self.writer.close()
class IntegralProcessor(object):
"A processor for an integral document."
def __init__(self):
"Create the processor for the integral contents."
self.storage = []
def locate(self, container):
"Locate only containers of the processed type."
return isinstance(container, self.processedtype)
def store(self, container):
"Store a new container."
self.storage.append(container)
def process(self):
"Process the whole storage."
for container in self.storage:
self.processeach(container)
class IntegralTOC(IntegralProcessor):
"A processor for an integral TOC."
processedtype = TableOfContents
tocentries = []
def processeach(self, toc):
"Fill in a Table of Contents."
converter = TOCConverter()
for container in PartKeyGenerator.partkeyed:
toc.add(converter.convertindented(container))
# finish off with the footer to align indents
toc.add(converter.convertindented(LyXFooter()))
def writetotoc(self, entries, toc):
"Write some entries to the TOC."
for entry in entries:
toc.contents.append(entry)
class IntegralBiblioEntry(IntegralProcessor):
"A processor for an integral bibliography entry."
processedtype = BiblioEntry
def processeach(self, entry):
"Process each entry."
number = NumberGenerator.generator.generate('integralbib')
link = Link().complete('cite', 'biblio-' + number, type='biblioentry')
link.contents = entry.citeref
entry.contents = [Constant('['), link, Constant('] ')]
if entry.key in BiblioCite.cites:
for cite in BiblioCite.cites[entry.key]:
cite.contents = entry.citeref
cite.anchor = 'cite-' + number
cite.destination = link
class IntegralFloat(IntegralProcessor):
"Store all floats in the document by type."
processedtype = Float
bytype = dict()
def processeach(self, float):
"Store each float by type."
if not float.type in IntegralFloat.bytype:
IntegralFloat.bytype[float.type] = []
IntegralFloat.bytype[float.type].append(float)
class IntegralListOf(IntegralProcessor):
"A processor for an integral list of floats."
processedtype = ListOf
def processeach(self, listof):
"Fill in a list of floats."
listof.output = TaggedOutput().settag('div class="fulltoc"', True)
if not listof.type in IntegralFloat.bytype:
Trace.message('No floats of type ' + listof.type)
return
for float in IntegralFloat.bytype[listof.type]:
entry = self.processfloat(float)
if entry:
listof.contents.append(entry)
def processfloat(self, float):
"Get an entry for the list of floats."
if not float.isparent():
return None
return TOCEntry().create(float)
class IntegralReference(IntegralProcessor):
"A processor for a reference to a label."
processedtype = Reference
def processeach(self, reference):
"Extract the text of the original label."
reference.formatcontents()
class MemoryBasket(KeeperBasket):
"A basket which stores everything in memory, processes it and writes it."
def __init__(self):
"Create all processors in one go."
KeeperBasket.__init__(self)
self.processors = [
IntegralTOC(), IntegralBiblioEntry(),
IntegralFloat(), IntegralListOf(), IntegralReference(),
]
def finish(self):
"Process everything which cannot be done in one pass and write to disk."
self.process()
self.flush()
def process(self):
"Process everything with the integral processors."
self.searchintegral()
for processor in self.processors:
processor.process()
def searchintegral(self):
"Search for all containers for all integral processors."
for container in self.contents:
# container.tree()
if self.integrallocate(container):
self.integralstore(container)
container.locateprocess(self.integrallocate, self.integralstore)
def integrallocate(self, container):
"Locate all integrals."
for processor in self.processors:
if processor.locate(container):
return True
return False
def integralstore(self, container):
"Store a container in one or more processors."
for processor in self.processors:
if processor.locate(container):
processor.store(container)
class SplitPartLink(IntegralProcessor):
"A link processor for multi-page output."
processedtype = Link
def processeach(self, link):
"Process each link and add the current page."
link.page = self.page
class NavigationLink(Container):
"A link in the navigation header."
def __init__(self, name):
"Create the link for a given name (prev, next...)."
self.name = name
self.link = Link().complete(u' ', name, type=name)
self.output = TaggedOutput().settag('span class="' + name + '"')
self.contents = [self.link]
def complete(self, container, after = False):
"Complete the navigation link with destination container."
"The 'after' parameter decides if the link goes after the part title."
if not container.partkey:
Trace.error('No part key for link name ' + unicode(container))
return
self.link.contents = [Constant(Translator.translate(self.name))]
partname = self.getpartname(container)
separator = Constant(u' ')
if after:
self.contents = partname + [separator, self.link]
else:
self.contents = [self.link, separator] + partname
def getpartname(self, container):
"Get the part name for a container, title optional."
partname = [Constant(container.partkey.tocentry)]
if not container.partkey.titlecontents:
return partname
if Options.notoclabels:
return container.partkey.titlecontents
return partname + [Constant(': ')] + container.partkey.titlecontents
def setdestination(self, destination):
"Set the destination for this link."
self.link.destination = destination
def setmutualdestination(self, destination):
"Set the destination for this link, and vice versa."
self.link.setmutualdestination(destination.link)
class UpAnchor(Link):
"An anchor to the top of the page for the up links."
def create(self, container):
"Create the up anchor based on the first container."
if not container.partkey:
Trace.error('No part key for ' + unicode(container))
return None
self.createliteral(container.partkey.tocentry)
self.partkey.titlecontents = container.partkey.titlecontents
return self
def createmain(self):
"Create the up anchor for the main page."
return self.createliteral(Translator.translate('main-page'))
def createliteral(self, literal):
"Create the up anchor based on a literal string."
self.complete('', '')
self.output = EmptyOutput()
self.partkey = PartKey().createanchor(literal)
return self
class SplitPartNavigation(object):
"Used to create the navigation links for a new split page."
def __init__(self):
self.upanchors = []
self.lastcontainer = None
self.nextlink = None
self.lastnavigation = None
def writefirstheader(self, basket):
"Write the first header to the basket."
anchor = self.createmainanchor()
basket.write(anchor)
basket.write(self.createnavigation(anchor))
def writeheader(self, basket, container):
"Write the header to the basket."
basket.write(LyXHeader())
basket.write(self.currentupanchor(container))
basket.write(self.createnavigation(container))
def writefooter(self, basket):
"Write the footer to the basket."
if self.lastnavigation:
basket.write(self.lastnavigation)
basket.write(LyXFooter())
def createnavigation(self, container):
"Create the navigation bar with all links."
prevlink = NavigationLink('prev')
uplink = NavigationLink('up')
if self.nextlink:
prevlink.complete(self.lastcontainer)
self.nextlink.complete(container, after=True)
prevlink.setmutualdestination(self.nextlink)
uplink.complete(self.getupdestination(container))
uplink.setdestination(self.getupdestination(container))
self.nextlink = NavigationLink('next')
contents = [prevlink, Constant('\n'), uplink, Constant('\n'), self.nextlink]
header = TaggedText().complete(contents, 'div class="splitheader"', True)
self.lastcontainer = container
self.lastnavigation = header
return header
def currentupanchor(self, container):
"Update the internal list of up anchors, and return the current one."
level = self.getlevel(container)
while len(self.upanchors) > level:
del self.upanchors[-1]
while len(self.upanchors) < level:
self.upanchors.append(self.upanchors[-1])
upanchor = UpAnchor().create(container)
self.upanchors.append(upanchor)
return upanchor
def createmainanchor(self):
"Create the up anchor to the main page."
mainanchor = UpAnchor().createmain()
self.upanchors.append(mainanchor)
return mainanchor
def getupdestination(self, container):
"Get the name of the up page."
level = self.getlevel(container)
if len(self.upanchors) < level:
uppage = self.upanchors[-1]
else:
uppage = self.upanchors[level - 1]
return uppage
def getlevel(self, container):
"Get the level of the container."
if not container.partkey:
return 1
else:
return container.partkey.level + 1
class SplitFileBasket(MemoryBasket):
"A memory basket which contains a part split into a file, possibly with a TOC."
def __init__(self):
MemoryBasket.__init__(self)
self.entrycount = 0
self.root = None
self.converter = TOCConverter()
def write(self, container):
"Keep track of numbered layouts."
MemoryBasket.write(self, container)
if not container.partkey:
return
if container.partkey.header:
return
entry = self.converter.convert(container)
if not entry:
return
self.entrycount += 1
self.root = entry
def addtoc(self):
"Add the table of contents if necessary."
if self.entrycount != 1:
return
if self.root.branches == []:
return
text = Translator.translate('toc-for') + self.root.partkey.tocentry
toc = TableOfContents().create(text)
self.addbranches(self.root, toc)
toc.add(self.converter.convertindented(LyXFooter()))
self.write(toc)
def addbranches(self, entry, toc):
"Add an entry and all of its branches to the table of contents."
for branch in entry.branches:
toc.add(self.converter.indent(branch))
self.addbranches(branch, toc)
class SplitPartBasket(Basket):
"A basket used to split the output in different files."
baskets = []
def setwriter(self, writer):
if not hasattr(writer, 'filename') or not writer.filename:
Trace.error('Cannot use standard output for split output; ' +
'please supply an output filename.')
exit()
self.writer = writer
self.filename = writer.filename
self.converter = TOCConverter()
self.basket = MemoryBasket()
self.basket.page = writer.filename
return self
def write(self, container):
"Write a container, possibly splitting the file."
self.basket.write(container)
def splitbaskets(self):
"Process the whole basket and create all baskets for split part pages."
self.basket.process()
basket = self.firstbasket()
navigation = SplitPartNavigation()
for container in self.basket.contents:
if self.mustsplit(container):
filename = self.getfilename(container)
Trace.debug('New page ' + filename)
basket.addtoc()
navigation.writefooter(basket)
basket = self.addbasket(filename)
navigation.writeheader(basket, container)
basket.write(container)
if self.afterheader(container):
navigation.writefirstheader(basket)
self.mainanchor = navigation.upanchors[0]
for basket in self.baskets:
basket.process()
def finish(self):
"Process the whole basket, split into page baskets and flush all of them."
self.splitbaskets()
for basket in self.baskets:
basket.flush()
def afterheader(self, container):
"Find out if this is the header on the file."
return isinstance(container, LyXHeader)
def firstbasket(self):
"Create the first basket."
return self.addbasket(self.filename, self.writer)
def addbasket(self, filename, writer = None):
"Add a new basket."
if not writer:
writer = LineWriter(filename)
basket = SplitFileBasket()
basket.setwriter(writer)
self.baskets.append(basket)
# set the page name everywhere
basket.page = filename
splitpartlink = SplitPartLink()
splitpartlink.page = os.path.basename(basket.page)
basket.processors = [splitpartlink]
return basket
def mustsplit(self, container):
"Find out if the oputput file has to be split at this entry."
if not container.partkey:
return False
if not container.partkey.filename:
return False
return True
def getfilename(self, container):
"Get the new file name for a given container."
partname = container.partkey.filename
basename = self.filename
if Options.tocfor:
basename = Options.tocfor
base, extension = os.path.splitext(basename)
return base + '-' + partname + extension
class SplitTOCBasket(SplitPartBasket):
"A basket which contains the TOC for a split part document."
def finish(self):
"Process the whole basket, split into page baskets and flush all of them."
self.splitbaskets()
tocbasket = TOCBasket().setwriter(self.writer)
self.mainanchor.partkey = PartKey().createmain()
tocbasket.write(self.mainanchor)
for container in self.basket.contents:
tocbasket.write(container)
tocbasket.finish()
class PostFormula(object):
"Postprocess a formula"
processedclass = Formula
def postprocess(self, last, formula, next):
"Postprocess any formulae"
if Options.jsmath or Options.mathjax:
return formula
self.postnumbering(formula)
return formula
def postnumbering(self, formula):
"Check if it's a numbered equation, insert number."
if formula.header[0] != 'numbered':
return
functions = formula.searchremove(LabelFunction)
if len(functions) == 0:
label = self.createlabel(formula)
elif len(functions) == 1:
label = self.createlabel(formula, functions[0])
if len(functions) <= 1:
label.parent = formula
formula.contents.insert(0, label)
return
for function in functions:
label = self.createlabel(formula, function)
row = self.searchrow(function)
label.parent = row
row.contents.insert(0, label)
def createlabel(self, formula, function = None):
"Create a new label for a formula."
"Add a label to a formula."
tag = self.createtag(formula)
partkey = PartKey().createformula(tag)
if not formula.partkey:
formula.partkey = partkey
if not function:
label = Label()
label.create(partkey.tocentry + ' ', 'eq-' + tag, type="eqnumber")
else:
label = function.label
label.complete(partkey.tocentry + ' ')
return label
def createtag(self, formula):
"Create the label tag."
tags = formula.searchall(FormulaTag)
if len(tags) == 0:
return NumberGenerator.chaptered.generate('formula')
if len(tags) > 1:
Trace.error('More than one tag in formula: ' + unicode(formula))
return tags[0].tag
def searchrow(self, function):
"Search for the row that contains the label function."
if isinstance(function.parent, Formula) or isinstance(function.parent, FormulaRow):
return function.parent
return self.searchrow(function.parent)
Postprocessor.stages.append(PostFormula)
class eLyXerConverter(object):
"Converter for a document in a lyx file. Places all output in a given basket."
def __init__(self):
self.filtering = False
def setio(self, ioparser):
"Set the InOutParser"
self.reader = ioparser.getreader()
self.basket = self.getbasket()
self.basket.setwriter(ioparser.getwriter())
return self
def getbasket(self):
"Get the appropriate basket for the current options."
if Options.tocfor:
if Options.splitpart:
return SplitTOCBasket()
return TOCBasket()
if Options.splitpart:
return SplitPartBasket()
if Options.memory:
return MemoryBasket()
return WriterBasket()
def embed(self, reader):
"Embed the results from elyxer.a reader into a memory basket."
"Header and footer are ignored. Useful for embedding one document inside another."
self.filtering = True
self.reader = reader
self.basket = MemoryBasket()
return self
def convert(self):
"Perform the conversion for the document"
try:
self.processcontents()
except (Exception):
version = '[eLyXer version ' + GeneralConfig.version['number']
version += ' (' + GeneralConfig.version['date'] + ') in '
version += Options.location + '] '
Trace.error(version)
Trace.error('Conversion failed at ' + self.reader.currentline())
raise
def processcontents(self):
"Parse the contents and write it by containers"
factory = ContainerFactory()
processor = Processor(self.filtering)
while not self.reader.finished():
container = factory.createcontainer(self.reader)
result = processor.process(container)
self.writecontainer(result)
result = processor.postprocess(None)
self.writecontainer(result)
if not self.filtering:
self.basket.finish()
def writecontainer(self, container):
"Write each container to the correct basket."
if not container:
return
includes = container.searchremove(IncludeInset)
self.basket.write(container)
# recursive processing for IncludeInset
for include in includes:
for element in include.contents:
self.basket.write(element)
def getcontents(self):
"Return the contents of the basket."
return self.basket.contents
def __unicode__(self):
"Printable representation."
string = 'Converter with filtering ' + unicode(self.filtering)
string += ' and basket ' + unicode(self.basket)
return string
class InOutParser(object):
"Parse in and out arguments"
def __init__(self):
self.filein = sys.stdin
self.fileout = sys.stdout
def parse(self, args):
"Parse command line arguments"
self.filein = sys.stdin
self.fileout = sys.stdout
if len(args) < 2:
Trace.quietmode = True
if len(args) > 0:
self.filein = args[0]
del args[0]
self.readdir(self.filein, 'directory')
else:
Options.directory = '.'
if len(args) > 0:
self.fileout = args[0]
del args[0]
self.readdir(self.fileout, 'destdirectory')
else:
Options.destdirectory = '.'
if len(args) > 0:
raise Exception('Unused arguments: ' + unicode(args))
return self
def getreader(self):
"Get the resulting reader."
return LineReader(self.filein)
def getwriter(self):
"Get the resulting writer."
return LineWriter(self.fileout)
def readdir(self, filename, diroption):
"Read the current directory if needed"
if getattr(Options, diroption) != None:
return
setattr(Options, diroption, os.path.dirname(filename))
if getattr(Options, diroption) == '':
setattr(Options, diroption, '.')
class NullWriter(object):
"A writer that goes nowhere."
def write(self, list):
"Do nothing."
pass
class ConverterFactory(object):
"Create a converter fit for converting a filename and embedding the result."
def create(self, container):
"Create a converter for a given container, with filename"
" and possibly other parameters."
fullname = os.path.join(Options.directory, container.filename)
reader = LineReader(container.filename)
if 'firstline' in container.lstparams:
reader.setstart(int(container.lstparams['firstline']))
if 'lastline' in container.lstparams:
reader.setend(int(container.lstparams['lastline']))
return eLyXerConverter().embed(reader)
IncludeInset.converterfactory = ConverterFactory()
def convertdoc(args):
"Read a whole document from the command line and write it."
Options().parseoptions(args)
ioparser = InOutParser().parse(args)
converter = eLyXerConverter().setio(ioparser)
converter.convert()
def main():
"Main function, called if invoked from the command line"
convertdoc(list(sys.argv))
if __name__ == '__main__':
main()