- \n')
+ for c in doc.getChildNodes():
+ getattr(self, self.element_types[c.getNodeName()])(c, level, output)
+ n=doc.getNextSibling()
+ if n is None or n.getNodeName() is not doc.getNodeName():
+ output('
- \n')
+ output('
- ') + for c in doc.getChildNodes(): + getattr(self, self.element_types[c.getNodeName()])(c, level, output) + n=doc.getNextSibling() + output(' \n') + if n is None or n.getNodeName() is not doc.getNodeName(): + output('
- \n')
+ output('
- ') + for c in doc.getChildNodes(): + getattr(self, self.element_types[c.getNodeName()])(c, level, output) + n=doc.getNextSibling() + output(' \n') + if n is None or n.getNodeName() is not doc.getNodeName(): + output('
')
+ output(html_quote(c.getNodeValue()))
+ output('\n')
+ else:
+ getattr(self, self.element_types[c.getNodeName()])(
+ c, level, output)
+
+ def paragraph(self, doc, level, output):
+ i=0
+ output('') + for c in doc.getChildNodes(): + if c.getNodeName() in ['StructuredTextParagraph']: + getattr(self, self.element_types[c.getNodeName()])( + c, level, output) + else: + getattr(self, self.element_types[c.getNodeName()])( + c, level, output) + output('
') + + def link(self, doc, level, output): + output('' % doc.href) + for c in doc.getChildNodes(): + getattr(self, self.element_types[c.getNodeName()])(c, level, output) + output('') + + def emphasis(self, doc, level, output): + output('') + for c in doc.getChildNodes(): + getattr(self, self.element_types[c.getNodeName()])(c, level, output) + output('') + + def literal(self, doc, level, output): + output('')
+ for c in doc.getChildNodes():
+ output(html_quote(c.getNodeValue()))
+ output('')
+
+ def strong(self, doc, level, output):
+ output('')
+ for c in doc.getChildNodes():
+ getattr(self, self.element_types[c.getNodeName()])(c, level, output)
+ output('')
+
+ def underline(self, doc, level, output):
+ output("")
+ for c in doc.getChildNodes():
+ getattr(self, self.element_types[c.getNodeName()])(c, level, output)
+ output("")
+
+ def innerLink(self, doc, level, output):
+ output('[')
+ for c in doc.getChildNodes():
+ getattr(self, self.element_types[c.getNodeName()])(c, level, output)
+ output(']')
+
+ def namedLink(self, doc, level, output):
+ output('[')
+ for c in doc.getChildNodes():
+ getattr(self, self.element_types[c.getNodeName()])(c, level, output)
+ output(']')
+
+ def sgml(self,doc,level,output):
+ for c in doc.getChildNodes():
+ getattr(self, self.element_types[c.getNodeName()])(c, level, output)
+
+ def table(self,doc,level,output):
+ """
+ A StructuredTextTable holds StructuredTextRow(s) which
+ holds StructuredTextColumn(s). A StructuredTextColumn
+ is a type of StructuredTextParagraph and thus holds
+ the actual data.
+ """
+ output("| " % column.getSpan() + output(str) + #for c in doc.getChildNodes(): + # getattr(self, self.element_types[c.getNodeName()])(c, level, output) + for c in column.getChildNodes(): + getattr(self, self.element_types[c.getNodeName()])(c, level, output) + output(" | \n") + output("
')
+ r.append(line)
+ self.pre(s[1],r)
+ return join(r,'\n')
+
+ def _str(self,structure,level):
+ r=''
+ for s in structure:
+ # print s[0],'\n', len(s[1]), '\n\n'
+ if bullet.match(s[0]) >= 0:
+ p=bullet.group(1)
+ r=self.ul(r,p,self._str(s[1],level))
+ elif ol.match(s[0]) >= 0:
+ p=ol.group(3)
+ r=self.ol(r,p,self._str(s[1],level))
+ elif olp.match(s[0]) >= 0:
+ p=olp.group(1)
+ r=self.ol(r,p,self._str(s[1],level))
+ elif dl.match(s[0]) >= 0:
+ t,d=dl.group(1,2)
+ r=self.dl(r,t,d,self._str(s[1],level))
+ elif example.search(s[0]) >= 0 and s[1]:
+ # Introduce an example, using pre tags:
+ r=self.normal(r,s[0],self.pre(s[1]))
+ elif s[0][-2:]=='::' and s[1]:
+ # Introduce an example, using pre tags:
+ r=self.normal(r,s[0][:-1],self.pre(s[1]))
+ elif nl.search(s[0]) < 0 and s[1] and s[0][-1:] != ':':
+ # Treat as a heading
+ t=s[0]
+ r=self.head(r,t,level,
+ self._str(s[1],level and level+1))
+ else:
+ r=self.normal(r,s[0],self._str(s[1],level))
+ return r
diff --git a/wxPython/samples/stxview/StructuredText/ST.py b/wxPython/samples/stxview/StructuredText/ST.py
new file mode 100644
index 0000000000..2e6d0aba1f
--- /dev/null
+++ b/wxPython/samples/stxview/StructuredText/ST.py
@@ -0,0 +1,278 @@
+import re, STDOM
+from string import split, join, replace, expandtabs, strip, find
+
+#####################################################################
+# Updated functions #
+#####################################################################
+
+def indention(str,front = re.compile("^\s+").match):
+ """
+ Convert all tabs to the appropriate number of spaces.
+ Find the number of leading spaces. If none, return 0
+ """
+
+ if front(str):
+ start,end = front(str).span()
+ return end-start-1
+ else:
+ return 0 # no leading spaces
+
+def insert(struct, top, level):
+ """
+ find what will be the parant paragraph of
+ a sentence and return that paragraph's
+ sub-paragraphs. The new paragraph will be
+ appended to those sub-paragraphs
+ """
+ #print "struct", struct, top-1
+ if not top-1 in range(len(struct)):
+ return None
+ run = struct[top-1]
+ i = 0
+ while i+1 < level:
+ run = run.getSubparagraphs()[len(run.getSubparagraphs())-1]
+ i = i + 1
+ #print "parent for level ", level, " was => ", run.getColorizableTexts()
+ return run.getSubparagraphs()
+
+def display(struct):
+ """
+ runs through the structure and prints out
+ the paragraphs. If the insertion works
+ correctly, display's results should mimic
+ the orignal paragraphs.
+ """
+
+ if struct.getColorizableTexts():
+ print join(struct.getColorizableTexts()),"\n"
+ if struct.getSubparagraphs():
+ for x in struct.getSubparagraphs():
+ display(x)
+
+def display2(struct):
+ """
+ runs through the structure and prints out
+ the paragraphs. If the insertion works
+ correctly, display's results should mimic
+ the orignal paragraphs.
+ """
+
+ if struct.getNodeValue():
+ print struct.getNodeValue(),"\n"
+ if struct.getSubparagraphs():
+ for x in struct.getSubparagraphs():
+ display(x)
+
+def findlevel(levels,indent):
+ """
+ remove all level information of levels
+ with a greater level of indentation.
+ Then return which level should insert this
+ paragraph
+ """
+
+ keys = levels.keys()
+ for key in keys:
+ if levels[key] > indent:
+ del(levels[key])
+ keys = levels.keys()
+ if not(keys):
+ return 0
+ else:
+ for key in keys:
+ if levels[key] == indent:
+ return key
+ highest = 0
+ for key in keys:
+ if key > highest:
+ highest = key
+ return highest-1
+
+#####################################################################
+
+# Golly, the capitalization of this function always makes me think it's a class
+def StructuredText(paragraphs, paragraph_delimiter=re.compile('\n\s*\n')):
+ """
+ StructuredText accepts paragraphs, which is a list of
+ lines to be parsed. StructuredText creates a structure
+ which mimics the structure of the paragraphs.
+ Structure => [paragraph,[sub-paragraphs]]
+ """
+
+ currentlevel = 0
+ currentindent = 0
+ levels = {0:0}
+ level = 0 # which header are we under
+ struct = [] # the structure to be returned
+ run = struct
+
+ paragraphs = filter(
+ strip,
+ paragraph_delimiter.split(expandtabs('\n\n'+paragraphs+'\n\n'))
+ )
+
+ if not paragraphs: return []
+
+ ind = [] # structure based on indention levels
+ for paragraph in paragraphs:
+ ind.append([indention(paragraph), paragraph])
+
+ currentindent = indention(paragraphs[0])
+ levels[0] = currentindent
+
+ #############################################################
+ # updated #
+ #############################################################
+
+ for indent,paragraph in ind :
+ if indent == 0:
+ level = level + 1
+ currentlevel = 0
+ currentindent = 0
+ levels = {0:0}
+ struct.append(StructuredTextParagraph(paragraph, indent=indent, level=currentlevel))
+ elif indent > currentindent:
+ currentlevel = currentlevel + 1
+ currentindent = indent
+ levels[currentlevel] = indent
+ run = insert(struct,level,currentlevel)
+ run.append(StructuredTextParagraph(paragraph, indent=indent, level=currentlevel))
+ elif indent < currentindent:
+ result = findlevel(levels,indent)
+ if result > 0:
+ currentlevel = result
+ currentindent = indent
+ run = insert(struct,level,currentlevel)
+ run.append(StructuredTextParagraph(paragraph, indent=indent, level=currentlevel))
+ else:
+ if insert(struct,level,currentlevel):
+ run = insert(struct,level,currentlevel)
+ else:
+ run = struct
+ currentindet = indent
+ run.append(StructuredTextParagraph(paragraph, indent=indent, level=currentlevel))
+
+ return StructuredTextDocument(struct)
+
+Basic = StructuredText
+
+class StructuredTextParagraph(STDOM.Element):
+
+ indent=0
+
+ def __init__(self, src, subs=None, **kw):
+ if subs is None: subs=[]
+ self._src=src
+ self._subs=list(subs)
+
+ self._attributes=kw.keys()
+ for k, v in kw.items(): setattr(self, k, v)
+
+ def getChildren(self, type=type, lt=type([])):
+ src=self._src
+ if type(src) is not lt: src=[src]
+ return src+self._subs
+
+ def getAttribute(self, name):
+ return getattr(self, name, None)
+
+ def getAttributeNode(self, name):
+ if hasattr(self, name):
+ return STDOM.Attr(name, getattr(self, name))
+
+ def getAttributes(self):
+ d={}
+ for a in self._attributes:
+ d[a]=getattr(self, a, '')
+ return STDOM.NamedNodeMap(d)
+
+ def getSubparagraphs(self):
+ return self._subs
+
+ def setSubparagraphs(self, subs):
+ self._subs=subs
+
+ def getColorizableTexts(self):
+ return (self._src,)
+
+ def setColorizableTexts(self, src):
+ self._src=src[0]
+
+ def __repr__(self):
+ r=[]; a=r.append
+ a((' '*(self.indent or 0))+
+ ('%s(' % self.__class__.__name__)
+ +str(self._src)+', ['
+ )
+ for p in self._subs: a(`p`)
+ a((' '*(self.indent or 0))+'])')
+ return join(r,'\n')
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_Children(self, type=type, lt=type([])):
+ return self.getChildren(type,lt)
+
+ def _get_Attribute(self, name):
+ return self.getAttribute(name)
+
+ def _get_AttributeNode(self, name):
+ return self.getAttributeNode(name)
+
+ def _get_Attributes(self):
+ return self.getAttributes()
+
+ def _get_Subparagraphs(self):
+ return self.getSubparagraphs()
+
+ def _set_Subparagraphs(self, subs):
+ return self.setSubparagraphs(subs)
+
+ def _get_ColorizableTexts(self):
+ return self.getColorizableTexts()
+
+ def _set_ColorizableTexts(self, src):
+ return self.setColorizableTexts(src)
+
+class StructuredTextDocument(StructuredTextParagraph):
+ """
+ A StructuredTextDocument holds StructuredTextParagraphs
+ as its subparagraphs.
+ """
+ _attributes=()
+
+ def __init__(self, subs=None, **kw):
+ apply(StructuredTextParagraph.__init__,
+ (self, '', subs),
+ kw)
+
+ def getChildren(self):
+ return self._subs
+
+ def getColorizableTexts(self):
+ return ()
+
+ def setColorizableTexts(self, src):
+ pass
+
+ def __repr__(self):
+ r=[]; a=r.append
+ a('%s([' % self.__class__.__name__)
+ for p in self._subs: a(`p`+',')
+ a('])')
+ return join(r,'\n')
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_Children(self):
+ return self.getChildren()
+
+ def _get_ColorizableTexts(self):
+ return self.getColorizableTexts()
+
+ def _set_ColorizableTexts(self, src):
+ return self.setColorizableTexts(src)
diff --git a/wxPython/samples/stxview/StructuredText/STDOM.py b/wxPython/samples/stxview/StructuredText/STDOM.py
new file mode 100644
index 0000000000..1eb2d42731
--- /dev/null
+++ b/wxPython/samples/stxview/StructuredText/STDOM.py
@@ -0,0 +1,736 @@
+##############################################################################
+#
+# Zope Public License (ZPL) Version 1.0
+# -------------------------------------
+#
+# Copyright (c) Digital Creations. All rights reserved.
+#
+# This license has been certified as Open Source(tm).
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# 1. Redistributions in source code must retain the above copyright
+# notice, this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in
+# the documentation and/or other materials provided with the
+# distribution.
+#
+# 3. Digital Creations requests that attribution be given to Zope
+# in any manner possible. Zope includes a "Powered by Zope"
+# button that is installed by default. While it is not a license
+# violation to remove this button, it is requested that the
+# attribution remain. A significant investment has been put
+# into Zope, and this effort will continue if the Zope community
+# continues to grow. This is one way to assure that growth.
+#
+# 4. All advertising materials and documentation mentioning
+# features derived from or use of this software must display
+# the following acknowledgement:
+#
+# "This product includes software developed by Digital Creations
+# for use in the Z Object Publishing Environment
+# (http://www.zope.org/)."
+#
+# In the event that the product being advertised includes an
+# intact Zope distribution (with copyright and license included)
+# then this clause is waived.
+#
+# 5. Names associated with Zope or Digital Creations must not be used to
+# endorse or promote products derived from this software without
+# prior written permission from Digital Creations.
+#
+# 6. Modified redistributions of any form whatsoever must retain
+# the following acknowledgment:
+#
+# "This product includes software developed by Digital Creations
+# for use in the Z Object Publishing Environment
+# (http://www.zope.org/)."
+#
+# Intact (re-)distributions of any official Zope release do not
+# require an external acknowledgement.
+#
+# 7. Modifications are encouraged but must be packaged separately as
+# patches to official Zope releases. Distributions that do not
+# clearly separate the patches from the original work must be clearly
+# labeled as unofficial distributions. Modifications which do not
+# carry the name Zope may be packaged in any form, as long as they
+# conform to all of the clauses above.
+#
+#
+# Disclaimer
+#
+# THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS ``AS IS'' AND ANY
+# EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DIGITAL CREATIONS OR ITS
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+#
+#
+# This software consists of contributions made by Digital Creations and
+# many individuals on behalf of Digital Creations. Specific
+# attributions are listed in the accompanying credits file.
+#
+##############################################################################
+"""
+DOM implementation in StructuredText : Read-Only methods
+
+All standard Zope objects support DOM to a limited extent.
+"""
+import string
+
+
+# Node type codes
+# ---------------
+
+ELEMENT_NODE = 1
+ATTRIBUTE_NODE = 2
+TEXT_NODE = 3
+CDATA_SECTION_NODE = 4
+ENTITY_REFERENCE_NODE = 5
+ENTITY_NODE = 6
+PROCESSING_INSTRUCTION_NODE = 7
+COMMENT_NODE = 8
+DOCUMENT_NODE = 9
+DOCUMENT_TYPE_NODE = 10
+DOCUMENT_FRAGMENT_NODE = 11
+NOTATION_NODE = 12
+
+# Exception codes
+# ---------------
+
+INDEX_SIZE_ERR = 1
+DOMSTRING_SIZE_ERR = 2
+HIERARCHY_REQUEST_ERR = 3
+WRONG_DOCUMENT_ERR = 4
+INVALID_CHARACTER_ERR = 5
+NO_DATA_ALLOWED_ERR = 6
+NO_MODIFICATION_ALLOWED_ERR = 7
+NOT_FOUND_ERR = 8
+NOT_SUPPORTED_ERR = 9
+INUSE_ATTRIBUTE_ERR = 10
+
+# Exceptions
+# ----------
+
+class DOMException(Exception):
+ pass
+class IndexSizeException(DOMException):
+ code = INDEX_SIZE_ERR
+class DOMStringSizeException(DOMException):
+ code = DOMSTRING_SIZE_ERR
+class HierarchyRequestException(DOMException):
+ code = HIERARCHY_REQUEST_ERR
+class WrongDocumentException(DOMException):
+ code = WRONG_DOCUMENT_ERR
+class InvalidCharacterException(DOMException):
+ code = INVALID_CHARACTER_ERR
+class NoDataAllowedException(DOMException):
+ code = NO_DATA_ALLOWED_ERR
+class NoModificationAllowedException(DOMException):
+ code = NO_MODIFICATION_ALLOWED_ERR
+class NotFoundException(DOMException):
+ code = NOT_FOUND_ERR
+class NotSupportedException(DOMException):
+ code = NOT_SUPPORTED_ERR
+class InUseAttributeException(DOMException):
+ code = INUSE_ATTRIBUTE_ERR
+
+# Node classes
+# ------------
+
+class ParentNode:
+ """
+ A node that can have children, or, more precisely, that implements
+ the child access methods of the DOM.
+ """
+
+ def getChildNodes(self, type=type, st=type('')):
+ """
+ Returns a NodeList that contains all children of this node.
+ If there are no children, this is a empty NodeList
+ """
+
+ r=[]
+ for n in self.getChildren():
+ if type(n) is st: n=TextNode(n)
+ r.append(n.__of__(self))
+
+ return NodeList(r)
+
+ def getFirstChild(self, type=type, st=type('')):
+ """
+ The first child of this node. If there is no such node
+ this returns None
+ """
+ children = self.getChildren()
+
+ if not children:
+ return None
+
+ n=chidren[0]
+
+ if type(n) is st:
+ n=TextNode(n)
+
+ return n.__of__(self)
+
+ def getLastChild(self, type=type, st=type('')):
+ """
+ The last child of this node. If there is no such node
+ this returns None.
+ """
+ children = self.getChildren()
+ if not children: return None
+ n=chidren[-1]
+ if type(n) is st: n=TextNode(n)
+ return n.__of__(self)
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_ChildNodes(self, type=type, st=type('')):
+ return self.getChildNodes(type,st)
+
+ def _get_FirstChild(self, type=type, st=type('')):
+ return self.getFirstChild(type,st)
+
+ def _get_LastChild(self, type=type, st=type('')):
+ return self.getLastChild(type,st)
+
+class NodeWrapper(ParentNode):
+ """
+ This is an acquisition-like wrapper that provides parent access for
+ DOM sans circular references!
+ """
+
+ def __init__(self, aq_self, aq_parent):
+ self.aq_self=aq_self
+ self.aq_parent=aq_parent
+
+ def __getattr__(self, name):
+ return getattr(self.aq_self, name)
+
+ def getParentNode(self):
+ """
+ The parent of this node. All nodes except Document
+ DocumentFragment and Attr may have a parent
+ """
+ return self.aq_parent
+
+ def _getDOMIndex(self, children, getattr=getattr):
+ i=0
+ self=self.aq_self
+ for child in children:
+ if getattr(child, 'aq_self', child) is self:
+ self._DOMIndex=i
+ return i
+ i=i+1
+ return None
+
+ def getPreviousSibling(self,
+ type=type,
+ st=type(''),
+ getattr=getattr,
+ None=None):
+
+ """
+ The node immediately preceding this node. If
+ there is no such node, this returns None.
+ """
+
+ children = self.aq_parent.getChildren()
+ if not children:
+ return None
+
+ index=getattr(self, '_DOMIndex', None)
+ if index is None:
+ index=self._getDOMIndex(children)
+ if index is None: return None
+
+ index=index-1
+ if index < 0: return None
+ try: n=children[index]
+ except IndexError: return None
+ else:
+ if type(n) is st:
+ n=TextNode(n)
+ n._DOMIndex=index
+ return n.__of__(self)
+
+
+ def getNextSibling(self, type=type, st=type('')):
+ """
+ The node immediately preceding this node. If
+ there is no such node, this returns None.
+ """
+ children = self.aq_parent.getChildren()
+ if not children:
+ return None
+
+ index=getattr(self, '_DOMIndex', None)
+ if index is None:
+ index=self._getDOMIndex(children)
+ if index is None:
+ return None
+
+ index=index+1
+ try: n=children[index]
+ except IndexError:
+ return None
+ else:
+ if type(n) is st:
+ n=TextNode(n)
+ n._DOMIndex=index
+ return n.__of__(self)
+
+ def getOwnerDocument(self):
+ """
+ The Document object associated with this node, if any.
+ """
+ return self.aq_parent.getOwnerDocument()
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_ParentNode(self):
+ return self.getParentNode()
+
+ def _get_DOMIndex(self, children, getattr=getattr):
+ return self._getDOMIndex(children,getattr)
+
+ def _get_PreviousSibling(self,
+ type=type,
+ st=type(''),
+ getattr=getattr,
+ None=None):
+
+ return self.getPreviousSibling(type,st,getattr,None)
+
+ def _get_NextSibling(self, type=type, st=type('')):
+ return self.getNextSibling(type,st)
+
+ def _get_OwnerDocument(self):
+ return self.getOwnerDocument()
+
+class Node(ParentNode):
+ """
+ Node Interface
+ """
+
+ # Get a DOM wrapper with a parent link
+ def __of__(self, parent):
+ return NodeWrapper(self, parent)
+
+ # DOM attributes
+ # --------------
+
+ def getNodeName(self):
+ """
+ The name of this node, depending on its type
+ """
+
+ def getNodeValue(self):
+ """
+ The value of this node, depending on its type
+ """
+ return None
+
+ def getParentNode(self):
+ """
+ The parent of this node. All nodes except Document
+ DocumentFragment and Attr may have a parent
+ """
+
+ def getChildren(self):
+ """
+ Get a Python sequence of children
+ """
+ return ()
+
+ def getPreviousSibling(self,
+ type=type,
+ st=type(''),
+ getattr=getattr,
+ None=None):
+ """
+ The node immediately preceding this node. If
+ there is no such node, this returns None.
+ """
+
+ def getNextSibling(self, type=type, st=type('')):
+ """
+ The node immediately preceding this node. If
+ there is no such node, this returns None.
+ """
+
+ def getAttributes(self):
+ """
+ Returns a NamedNodeMap containing the attributes
+ of this node (if it is an element) or None otherwise.
+ """
+ return None
+
+ def getOwnerDocument(self):
+ """
+ The Document object associated with this node, if any.
+ """
+
+ # DOM Methods
+ # -----------
+
+ def hasChildNodes(self):
+ """
+ Returns true if the node has any children, false
+ if it doesn't.
+ """
+ return len(self.getChildren())
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_NodeName(self):
+ return self.getNodeName()
+
+ def _get_NodeValue(self):
+ return self.getNodeValue()
+
+ def _get_ParentNode(self):
+ return self.getParentNode()
+
+ def _get_Children(self):
+ return self.getChildren()
+
+ def _get_PreviousSibling(self,
+ type=type,
+ st=type(''),
+ getattr=getattr,
+ None=None):
+
+ return self.getPreviousSibling(type,st,getattr,None)
+
+ def _get_NextSibling(self, type=type, st=type('')):
+ return self.getNextSibling()
+
+ def _get_Attributes(self):
+ return self.getAttributes()
+
+ def _get_OwnerDocument(self):
+ return self.getOwnerDocument()
+
+ def _has_ChildNodes(self):
+ return self.hasChildNodes()
+
+
+class TextNode(Node):
+
+ def __init__(self, str): self._value=str
+
+ def getNodeType(self):
+ return TEXT_NODE
+
+ def getNodeName(self):
+ return '#text'
+
+ def getNodeValue(self):
+ return self._value
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_NodeType(self):
+ return self.getNodeType()
+
+ def _get_NodeName(self):
+ return self.getNodeName()
+
+ def _get_NodeValue(self):
+ return self.getNodeValue()
+
+class Element(Node):
+ """
+ Element interface
+ """
+
+ # Element Attributes
+ # ------------------
+
+ def getTagName(self):
+ """The name of the element"""
+ return self.__class__.__name__
+
+ def getNodeName(self):
+ """The name of this node, depending on its type"""
+ return self.__class__.__name__
+
+ def getNodeType(self):
+ """A code representing the type of the node."""
+ return ELEMENT_NODE
+
+ def getNodeValue(self, type=type, st=type('')):
+ r=[]
+ for c in self.getChildren():
+ if type(c) is not st:
+ c=c.getNodeValue()
+ r.append(c)
+ return string.join(r,'')
+
+ def getParentNode(self):
+ """
+ The parent of this node. All nodes except Document
+ DocumentFragment and Attr may have a parent
+ """
+
+ # Element Methods
+ # ---------------
+
+ _attributes=()
+
+ def getAttribute(self, name): return getattr(self, name, None)
+ def getAttributeNode(self, name):
+ if hasattr(self, name):
+ return Attr(name, getattr(self, name))
+
+ def getAttributes(self):
+ d={}
+ for a in self._attributes:
+ d[a]=getattr(self, a, '')
+ return NamedNodeMap(d)
+
+ def getAttribute(self, name):
+ """Retrieves an attribute value by name."""
+ return None
+
+ def getAttributeNode(self, name):
+ """ Retrieves an Attr node by name or None if
+ there is no such attribute. """
+ return None
+
+ def getElementsByTagName(self, tagname):
+ """
+ Returns a NodeList of all the Elements with a given tag
+ name in the order in which they would be encountered in a
+ preorder traversal of the Document tree. Parameter: tagname
+ The name of the tag to match (* = all tags). Return Value: A new
+ NodeList object containing all the matched Elements.
+ """
+ nodeList = []
+ for child in self.getChildren():
+ if (child.getNodeType()==ELEMENT_NODE and \
+ child.getTagName()==tagname or tagname== '*'):
+
+ nodeList.append(child)
+
+ if hasattr(child, 'getElementsByTagName'):
+ n1 = child.getElementsByTagName(tagname)
+ nodeList = nodeList + n1._data
+ return NodeList(nodeList)
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_TagName(self):
+ return self.getTagName()
+
+ def _get_NodeName(self):
+ return self.getNodeName()
+
+ def _get_NodeType(self):
+ return self.getNodeType()
+
+ def _get_NodeValue(self, type=type, st=type('')):
+ return self.GetNodeValue(type,st)
+
+ def _get_ParentNode(self):
+ return self.getParentNode()
+
+ def _get_Attribute(self, name):
+ return self.getAttribute(name)
+
+ def _get_AttributeNode(self, name):
+ return self.getAttributeNode(name)
+
+ def _get_Attributes(self):
+ return self.getAttributes()
+
+ def _get_Attribute(self, name):
+ return self.getAttribute(name)
+
+ def _get_AttributeNode(self, name):
+ return self.getAttributeNode(name)
+
+ def _get_ElementsByTagName(self, tagname):
+ return self.getElementsByTagName(tagname)
+
+
+class NodeList:
+ """
+ NodeList interface - Provides the abstraction of an ordered
+ collection of nodes.
+
+ Python extensions: can use sequence-style 'len', 'getitem', and
+ 'for..in' constructs.
+ """
+
+ def __init__(self,list=None):
+ self._data = list or []
+
+ def __getitem__(self, index, type=type, st=type('')):
+ return self._data[index]
+
+ def __getslice__(self, i, j):
+ return self._data[i:j]
+
+ def item(self, index):
+ """
+ Returns the index-th item in the collection
+ """
+ try: return self._data[index]
+ except IndexError: return None
+
+ def getLength(self):
+ """
+ The length of the NodeList
+ """
+ return len(self._data)
+
+ __len__=getLength
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_Length(self):
+ return self.getLength()
+
+class NamedNodeMap:
+ """
+ NamedNodeMap interface - Is used to represent collections
+ of nodes that can be accessed by name. NamedNodeMaps are not
+ maintained in any particular order.
+
+ Python extensions: can use sequence-style 'len', 'getitem', and
+ 'for..in' constructs, and mapping-style 'getitem'.
+ """
+
+ def __init__(self, data=None):
+ if data is None:
+ data = {}
+ self._data = data
+
+ def item(self, index):
+ """
+ Returns the index-th item in the map
+ """
+ try: return self._data.values()[index]
+ except IndexError: return None
+
+ def __getitem__(self, key):
+ if type(key)==type(1):
+ return self._data.values()[key]
+ else:
+ return self._data[key]
+
+ def getLength(self):
+ """
+ The length of the NodeList
+ """
+ return len(self._data)
+
+ __len__ = getLength
+
+ def getNamedItem(self, name):
+ """
+ Retrieves a node specified by name. Parameters:
+ name Name of a node to retrieve. Return Value A Node (of any
+ type) with the specified name, or None if the specified name
+ did not identify any node in the map.
+ """
+ if self._data.has_key(name):
+ return self._data[name]
+ return None
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+ def _get_Length(self):
+ return self.getLength()
+
+ def _get_NamedItem(self, name):
+ return self.getNamedItem(name)
+
+class Attr(Node):
+ """
+ Attr interface - The Attr interface represents an attriubte in an
+ Element object. Attr objects inherit the Node Interface
+ """
+
+ def __init__(self, name, value, specified=1):
+ self.name = name
+ self.value = value
+ self.specified = specified
+
+ def getNodeName(self):
+ """
+ The name of this node, depending on its type
+ """
+ return self.name
+
+ def getName(self):
+ """
+ Returns the name of this attribute.
+ """
+ return self.name
+
+ def getNodeValue(self):
+ """
+ The value of this node, depending on its type
+ """
+ return self.value
+
+ def getNodeType(self):
+ """
+ A code representing the type of the node.
+ """
+ return ATTRIBUTE_NODE
+
+ def getSpecified(self):
+ """
+ If this attribute was explicitly given a value in the
+ original document, this is true; otherwise, it is false.
+ """
+ return self.specified
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_NodeName(self):
+ return self.getNodeName()
+
+ def _get_Name(self):
+ return self.getName()
+
+ def _get_NodeValue(self):
+ return self.getNodeValue()
+
+ def _get_NodeType(self):
+ return self.getNodeType()
+
+ def _get_Specified(self):
+ return self.getSpecified()
diff --git a/wxPython/samples/stxview/StructuredText/STNG.txt b/wxPython/samples/stxview/StructuredText/STNG.txt
new file mode 100644
index 0000000000..40af179bd1
--- /dev/null
+++ b/wxPython/samples/stxview/StructuredText/STNG.txt
@@ -0,0 +1,116 @@
+Using Structured Text
+
+ The goal of StructuredText is to make it possible to express
+ structured text using a relatively simple plain text format. Simple
+ structures, like bullets or headings are indicated through
+ conventions that are natural, for some definition of
+ "natural". Hierarchical structures are indicated through
+ indentation. The use of indentation to express hierarchical
+ structure is inspired by the Python programming language.
+
+ Use of StructuredText consists of one to three logical steps. In the
+ first step, a text string is converted to a network of objects using
+ the 'StructuredText.Basic' facility, as in the following
+ example::
+
+ raw=open("mydocument.txt").read()
+ import StructuredText
+ st=StructuredText.Basic(raw)
+
+ The output of 'StructuredText.Basic' is simply a
+ StructuredTextDocumemt object containing StructuredTextParagraph
+ objects arranged in a hierarchy. Paragraphs are delimited by strings
+ of two or more whitespace characters beginning and ending with
+ newline characters. Hierarchy is indicated by indentation. The
+ indentation of a paragraph is the minimum number of leading spaces
+ in a line containing non-white-space characters after converting tab
+ characters to spaces (assuming a tab stop every eight characters).
+
+ StructuredTextNode objects support the read-only subset of the
+ Document Object Model (DOM) API. It should be possible to process
+ 'StructuredTextNode' hierarchies using XML tools such as XSLT.
+
+ The second step in using StructuredText is to apply additional
+ structuring rules based on text content. A variety of differentText
+ rules can be used. Typically, these are used to implement a
+ structured text language for producing documents, but any sort of
+ structured text language could be implemented in the second
+ step. For example, it is possible to use StructuredText to implement
+ structured text formats for representing structured data. The second
+ step, which could consist of multiple processing steps, is
+ performed by processing, or "coloring", the hierarchy of generic
+ StructuredTextParagraph objects into a network of more specialized
+ objects. Typically, the objects produced should also implement the DOM
+ API to allow processing with XML tools.
+
+ A document processor is provided to convert a StructuredTextDocument
+ object containing only StructuredStructuredTextParagraph objects
+ into a StructuredTextDocument object containing a richer collection
+ of objects such as bullets, headings, emphasis, and so on using
+ hints in the text. Hints are selected based on conventions of the
+ sort typically seen in electronic mail or news-group postings. It
+ should be noted, however, that these conventions are somewhat
+ culturally dependent, fortunately, the document processor is easily
+ customized to implement alternative rules. Here's an example of
+ using the DOC processor to convert the output of the previous example::
+
+ doc=StructuredText.Document(st)
+
+ The final step is to process the colored networks produced from the
+ second step to produce additional outputs. The final step could be
+ performed by Python programs, or by XML tools. A Python outputter is
+ provided for the document processor output that produces Hypertext Markup
+ Language (HTML) text::
+
+ html=StructuredText.HTML(doc)
+
+Customizing the document processor
+
+ The document processor is driven by two tables. The first table,
+ named 'paragraph_types', is a sequence of callable objects or method
+ names for coloring paragraphs. If a table entry is a string, then it
+ is the name of a method of the document processor to be used. For
+ each input paragraph, the objects in the table are called until one
+ returns a value (not 'None'). The value returned replaces the
+ original input paragraph in the output. If none of the objects in
+ the paragraph types table return a value, then a copy of the
+ original paragraph is used. The new object returned by calling a
+ paragraph type should implement the ReadOnlyDOM,
+ StructuredTextColorizable, and StructuredTextSubparagraphContainer
+ interfaces. See the 'Document.py' source file for examples.
+
+ A paragraph type may return a list or tuple of replacement
+ paragraphs, this allowing a paragraph to be split into multiple
+ paragraphs.
+
+ The second table, 'text_types', is a sequence of callable objects or
+ method names for coloring text. The callable objects in this table
+ are used in sequence to transform the input text into new text or
+ objects. The callable objects are passed a string and return
+ nothing ('None') or a three-element tuple consisting of:
+
+ - a replacement object,
+
+ - a starting position, and
+
+ - an ending position
+
+ The text from the starting position is (logically) replaced with the
+ replacement object. The replacement object is typically an object
+ that implements that implements the ReadOnlyDOM, and
+ StructuredTextColorizable interfaces. The replacement object can
+ also be a string or a list of strings or objects. Replacement is
+ done from beginning to end and text after the replacement ending
+ position will be passed to the character type objects for processing.
+
+Example: adding wiki links
+
+ We want to add support for Wiki links. A Wiki link is a string of
+ text containing mixed-case letters, such that at least two of the
+ letters are upper case and such that the first letter is upper case.
+
+
+
+
+
+
diff --git a/wxPython/samples/stxview/StructuredText/StructuredText.py b/wxPython/samples/stxview/StructuredText/StructuredText.py
new file mode 100644
index 0000000000..a1b3fd03ad
--- /dev/null
+++ b/wxPython/samples/stxview/StructuredText/StructuredText.py
@@ -0,0 +1,833 @@
+#! /usr/bin/env python -- # -*- python -*-
+##############################################################################
+#
+# Zope Public License (ZPL) Version 1.0
+# -------------------------------------
+#
+# Copyright (c) Digital Creations. All rights reserved.
+#
+# This license has been certified as Open Source(tm).
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# 1. Redistributions in source code must retain the above copyright
+# notice, this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in
+# the documentation and/or other materials provided with the
+# distribution.
+#
+# 3. Digital Creations requests that attribution be given to Zope
+# in any manner possible. Zope includes a "Powered by Zope"
+# button that is installed by default. While it is not a license
+# violation to remove this button, it is requested that the
+# attribution remain. A significant investment has been put
+# into Zope, and this effort will continue if the Zope community
+# continues to grow. This is one way to assure that growth.
+#
+# 4. All advertising materials and documentation mentioning
+# features derived from or use of this software must display
+# the following acknowledgement:
+#
+# "This product includes software developed by Digital Creations
+# for use in the Z Object Publishing Environment
+# (http://www.zope.org/)."
+#
+# In the event that the product being advertised includes an
+# intact Zope distribution (with copyright and license included)
+# then this clause is waived.
+#
+# 5. Names associated with Zope or Digital Creations must not be used to
+# endorse or promote products derived from this software without
+# prior written permission from Digital Creations.
+#
+# 6. Modified redistributions of any form whatsoever must retain
+# the following acknowledgment:
+#
+# "This product includes software developed by Digital Creations
+# for use in the Z Object Publishing Environment
+# (http://www.zope.org/)."
+#
+# Intact (re-)distributions of any official Zope release do not
+# require an external acknowledgement.
+#
+# 7. Modifications are encouraged but must be packaged separately as
+# patches to official Zope releases. Distributions that do not
+# clearly separate the patches from the original work must be clearly
+# labeled as unofficial distributions. Modifications which do not
+# carry the name Zope may be packaged in any form, as long as they
+# conform to all of the clauses above.
+#
+#
+# Disclaimer
+#
+# THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS ``AS IS'' AND ANY
+# EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DIGITAL CREATIONS OR ITS
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+#
+#
+# This software consists of contributions made by Digital Creations and
+# many individuals on behalf of Digital Creations. Specific
+# attributions are listed in the accompanying credits file.
+#
+##############################################################################
+'''Structured Text Manipulation
+
+Parse a structured text string into a form that can be used with
+structured formats, like html.
+
+Structured text is text that uses indentation and simple
+symbology to indicate the structure of a document.
+
+A structured string consists of a sequence of paragraphs separated by
+one or more blank lines. Each paragraph has a level which is defined
+as the minimum indentation of the paragraph. A paragraph is a
+sub-paragraph of another paragraph if the other paragraph is the last
+preceding paragraph that has a lower level.
+
+Special symbology is used to indicate special constructs:
+
+- A single-line paragraph whose immediately succeeding paragraphs are lower
+ level is treated as a header.
+
+- A paragraph that begins with a '-', '*', or 'o' is treated as an
+ unordered list (bullet) element.
+
+- A paragraph that begins with a sequence of digits followed by a
+ white-space character is treated as an ordered list element.
+
+- A paragraph that begins with a sequence of sequences, where each
+ sequence is a sequence of digits or a sequence of letters followed
+ by a period, is treated as an ordered list element.
+
+- A paragraph with a first line that contains some text, followed by
+ some white-space and '--' is treated as
+ a descriptive list element. The leading text is treated as the
+ element title.
+
+- Sub-paragraphs of a paragraph that ends in the word 'example' or the
+ word 'examples', or '::' is treated as example code and is output as is.
+
+- Text enclosed single quotes (with white-space to the left of the
+ first quote and whitespace or puctuation to the right of the second quote)
+ is treated as example code.
+
+- Text surrounded by '*' characters (with white-space to the left of the
+ first '*' and whitespace or puctuation to the right of the second '*')
+ is emphasized.
+
+- Text surrounded by '**' characters (with white-space to the left of the
+ first '**' and whitespace or puctuation to the right of the second '**')
+ is made strong.
+
+- Text surrounded by '_' underscore characters (with whitespace to the left
+ and whitespace or punctuation to the right) is made underlined.
+
+- Text encloded by double quotes followed by a colon, a URL, and concluded
+ by punctuation plus white space, *or* just white space, is treated as a
+ hyper link. For example:
+
+ "Zope":http://www.zope.org/ is ...
+
+ Is interpreted as 'Zope is ....'
+ Note: This works for relative as well as absolute URLs.
+
+- Text enclosed by double quotes followed by a comma, one or more spaces,
+ an absolute URL and concluded by punctuation plus white space, or just
+ white space, is treated as a hyper link. For example:
+
+ "mail me", mailto:amos@digicool.com.
+
+ Is interpreted as 'mail me.'
+
+- Text enclosed in brackets which consists only of letters, digits,
+ underscores and dashes is treated as hyper links within the document.
+ For example:
+
+ As demonstrated by Smith [12] this technique is quite effective.
+
+ Is interpreted as '... by Smith [12] this ...'. Together
+ with the next rule this allows easy coding of references or end notes.
+
+- Text enclosed in brackets which is preceded by the start of a line, two
+ periods and a space is treated as a named link. For example:
+
+ .. [12] "Effective Techniques" Smith, Joe ...
+
+ Is interpreted as '[12] "Effective Techniques" ...'.
+ Together with the previous rule this allows easy coding of references or
+ end notes.
+
+
+- A paragraph that has blocks of text enclosed in '||' is treated as a
+ table. The text blocks correspond to table cells and table rows are
+ denoted by newlines. By default the cells are center aligned. A cell
+ can span more than one column by preceding a block of text with an
+ equivalent number of cell separators '||'. Newlines and '|' cannot
+ be a part of the cell text. For example:
+
+ |||| **Ingredients** ||
+ || *Name* || *Amount* ||
+ ||Spam||10||
+ ||Eggs||3||
+
+ is interpreted as::
+
+ | Ingredients | +|
| Name | +Amount | +
| Spam | +10 | +
| Eggs | +3 | +
. For example: +# +# |||| **Ingredients** || +# || *Name* || *Amount* || +# ||Spam||10|| +# ||Eggs||3|| +# +# Revision 1.23 1999/08/03 20:49:05 jim +# Fixed to allow list elements to introduce examples. +# +# Restructured _str using continue to avoid excessive nesting. +# +# Revision 1.22 1999/08/02 22:01:28 jim +# Fixed a bunch of bugs introduced by making ts_regex actually thread +# safe. +# +# Also localized a bunch of regular expressions +# using "static" variables (aka always default arguments). +# +# Revision 1.21 1999/08/02 13:26:52 jim +# paragraph_divider needs to be a regular (thread-unsafe) regex +# since it gets passed to ts_regex.split, which is thread-safe +# and wants to use regs. +# +# Revision 1.20 1999/07/21 13:33:59 jim +# untabified. +# +# Revision 1.19 1999/07/15 16:43:15 jim +# Checked in Scott Robertson's thread-safety fixes. +# +# Revision 1.18 1999/03/24 00:03:18 klm +# Provide for relative links, eg whatever, +# as: +# +# "whatever", :file_in_same_dir +# +# or +# +# "whatever"::file_in_same_dir +# +# .__init__(): relax the second gsub, using a '*' instead of a '+', so +# the stuff before the ':' can be missing, and also do postprocessing so +# any resulting ''s have the superfluous ':' +# removed. *Seems* good! +# +# Revision 1.17 1999/03/12 23:21:39 klm +# Gratuituous checkin to test my cvs *update* logging hook. +# +# Revision 1.16 1999/03/12 17:12:12 klm +# Added support for underlined elements, in the obvious way (and +# included an entry in the module docstring for it). +# +# Added an entry in the module docstring describing what i *guess* is +# the criterion for identifying header elements. (I'm going to have to +# delve into and understand the framework a bit better before *knowing* +# this is the case.) +# +# Revision 1.15 1999/03/11 22:40:18 klm +# Handle links that include '#' named links. +# +# Revision 1.14 1999/03/11 01:35:19 klm +# Fixed a small typo, and refined the module docstring link example, in +# order to do a checkin to exercise the CVS repository mirroring. Might +# as well include my last checkin message, with some substantial stuff: +# +# Links are now recognized whether or not the candidate strings are +# terminated with punctuation before the trailing whitespace. The old +# form - trailing punctuation then whitespace - is preserved, but the +# punctuation is now unnecessary. +# +# The regular expressions are a bit more complicated, but i've factored +# out the common parts and but them in variables with suggestive names, +# which may make them easier to understand. +# +# Revision 1.13 1999/03/11 00:49:57 klm +# Links are now recognized whether or not the candidate strings are +# terminated with punctuation before the trailing whitespace. The old +# form - trailing punctuation then whitespace - is preserved, but the +# punctuation is now unnecessary. +# +# The regular expressions are a bit more complicated, but i've factored +# out the common parts and but them in variables with suggestive names, +# which may make them easier to understand. +# +# Revision 1.12 1999/03/10 00:15:46 klm +# Committing with version 1.0 of the license. +# +# Revision 1.11 1999/02/08 18:13:12 klm +# Trival checkin (spelling fix "preceedeing" -> "preceding" and similar) +# to see what pitfalls my environment presents to accomplishing a +# successful checkin. (It turns out that i can't do it from aldous because +# the new version of cvs doesn't support the '-t' and '-f' options in the +# cvswrappers file...) +# +# Revision 1.10 1998/12/29 22:30:43 amos +# Improved doc string to describe hyper link and references capabilities. +# +# Revision 1.9 1998/12/04 20:15:31 jim +# Detabification and new copyright. +# +# Revision 1.8 1998/02/27 18:45:22 jim +# Various updates, including new indentation utilities. +# +# Revision 1.7 1997/12/12 15:39:54 jim +# Added level as argument for html_with_references. +# +# Revision 1.6 1997/12/12 15:27:25 jim +# Added additional pattern matching for HTML references. +# +# Revision 1.5 1997/03/08 16:01:03 jim +# Moved code to recognize: "foo bar", url. +# into object initializer, so it gets applied in all cases. +# +# Revision 1.4 1997/02/17 23:36:35 jim +# Added support for "foo title", http:/foohost/foo +# +# Revision 1.3 1996/12/06 15:57:37 jim +# Fixed bugs in character tags. +# +# Added -t command-line option to generate title if: +# +# - The first paragraph is one line (i.e. a heading) and +# +# - All other paragraphs are indented. +# +# Revision 1.2 1996/10/28 13:56:02 jim +# Fixed bug in ordered lists. +# Added option for either HTML-style headings or descriptive-list style +# headings. +# +# Revision 1.1 1996/10/23 14:00:45 jim +# *** empty log message *** +# +# +# + +import ts_regex, regex +from ts_regex import gsub +from string import split, join, strip, find + +def untabify(aString, + indent_tab=ts_regex.compile('\(\n\|^\)\( *\)\t').search_group, + ): + '''\ + Convert indentation tabs to spaces. + ''' + result='' + rest=aString + while 1: + ts_results = indent_tab(rest, (1,2)) + if ts_results: + start, grps = ts_results + lnl=len(grps[0]) + indent=len(grps[1]) + result=result+rest[:start] + rest="\n%s%s" % (' ' * ((indent/8+1)*8), + rest[start+indent+1+lnl:]) + else: + return result+rest + +def indent(aString, indent=2): + """Indent a string the given number of spaces""" + r=split(untabify(aString),'\n') + if not r: return '' + if not r[-1]: del r[-1] + tab=' '*level + return "%s%s\n" % (tab,join(r,'\n'+tab)) + +def reindent(aString, indent=2, already_untabified=0): + "reindent a block of text, so that the minimum indent is as given" + + if not already_untabified: aString=untabify(aString) + + l=indent_level(aString)[0] + if indent==l: return aString + + r=[] + + append=r.append + + if indent > l: + tab=' ' * (indent-l) + for s in split(aString,'\n'): append(tab+s) + else: + l=l-indent + for s in split(aString,'\n'): append(s[l:]) + + return join(r,'\n') + +def indent_level(aString, + indent_space=ts_regex.compile('\n\( *\)').search_group, + ): + '''\ + Find the minimum indentation for a string, not counting blank lines. + ''' + start=0 + text='\n'+aString + indent=l=len(text) + while 1: + + ts_results = indent_space(text, (1,2), start) + if ts_results: + start, grps = ts_results + i=len(grps[0]) + start=start+i+1 + if start < l and text[start] != '\n': # Skip blank lines + if not i: return (0,aString) + if i < indent: indent = i + else: + return (indent,aString) + +def paragraphs(list,start): + l=len(list) + level=list[start][0] + i=start+1 + while i < l and list[i][0] > level: i=i+1 + return i-1-start + +def structure(list): + if not list: return [] + i=0 + l=len(list) + r=[] + while i < l: + sublen=paragraphs(list,i) + i=i+1 + r.append((list[i-1][1],structure(list[i:i+sublen]))) + i=i+sublen + return r + + +class Table: + CELL='
\\2\\3',s)
+ s=gsub(em, '\\1\\2\\3',s)
+ return s
+
+class HTML(StructuredText):
+
+ '''\
+ An HTML structured text formatter.
+ '''\
+
+ def __str__(self,
+ extra_dl=regex.compile("\n- "),
+ extra_ul=regex.compile("\n
- %s\n%s\n
- %s\n%s\n
- %s
%s
\n%s\n- %s\n
- %s\n
- "),
+ extra_ol=regex.compile("\n
- "),
+ ):
+ '''\
+ Return an HTML string representation of the structured text data.
+
+ '''
+ s=self._str(self.structure,self.level)
+ s=gsub(extra_dl,'\n',s)
+ s=gsub(extra_ul,'\n',s)
+ s=gsub(extra_ol,'\n',s)
+ return s
+
+ def ul(self, before, p, after):
+ if p: p="
%s
" % strip(ctag(p)) + return ('%s%s
" % strip(ctag(p)) + return ('%s%s
" % strip(ctag(t)) + return ('%s
%s
\n%s\n' % (before,ctag(p),after) + + def pre(self,structure,tagged=0): + if not structure: return '' + if tagged: + r='' + else: + r='\n' + for s in structure: + r="%s%s\n\n%s" % (r,html_quote(s[0]),self.pre(s[1],1)) + if not tagged: r=r+'\n' + return r + + def table(self,before,table,after): + return '%s
%s
\n%s\n' % (before,ctag(table),after) + + def _str(self,structure,level, + # Static + bullet=ts_regex.compile('[ \t\n]*[o*-][ \t\n]+\([^\0]*\)' + ).match_group, + example=ts_regex.compile('[\0- ]examples?:[\0- ]*$' + ).search, + dl=ts_regex.compile('\([^\n]+\)[ \t]+--[ \t\n]+\([^\0]*\)' + ).match_group, + nl=ts_regex.compile('\n').search, + ol=ts_regex.compile( + '[ \t]*\(\([0-9]+\|[a-zA-Z]+\)[.)]\)+[ \t\n]+\([^\0]*\|$\)' + ).match_group, + olp=ts_regex.compile('[ \t]*([0-9]+)[ \t\n]+\([^\0]*\|$\)' + ).match_group, + ): + r='' + for s in structure: + + ts_results = bullet(s[0], (1,)) + if ts_results: + p = ts_results[1] + if s[0][-2:]=='::' and s[1]: ps=self.pre(s[1]) + else: ps=self._str(s[1],level) + r=self.ul(r,p,ps) + continue + ts_results = ol(s[0], (3,)) + if ts_results: + p = ts_results[1] + if s[0][-2:]=='::' and s[1]: ps=self.pre(s[1]) + else: ps=self._str(s[1],level) + r=self.ol(r,p,ps) + continue + ts_results = olp(s[0], (1,)) + if ts_results: + p = ts_results[1] + if s[0][-2:]=='::' and s[1]: ps=self.pre(s[1]) + else: ps=self._str(s[1],level) + r=self.ol(r,p,ps) + continue + ts_results = dl(s[0], (1,2)) + if ts_results: + t,d = ts_results[1] + r=self.dl(r,t,d,self._str(s[1],level)) + continue + if example(s[0]) >= 0 and s[1]: + # Introduce an example, using pre tags: + r=self.normal(r,s[0],self.pre(s[1])) + continue + if s[0][-2:]=='::' and s[1]: + # Introduce an example, using pre tags: + r=self.normal(r,s[0][:-1],self.pre(s[1])) + continue + if table.create(s[0]): + ## table support. + r=self.table(r,table.html(),self._str(s[1],level)) + continue + else: + + if nl(s[0]) < 0 and s[1] and s[0][-1:] != ':': + # Treat as a heading + t=s[0] + r=self.head(r,t,level, + self._str(s[1],level and level+1)) + else: + r=self.normal(r,s[0],self._str(s[1],level)) + return r + + +def html_quote(v, + character_entities=( + (regex.compile('&'), '&'), + (regex.compile("<"), '<' ), + (regex.compile(">"), '>' ), + (regex.compile('"'), '"') + )): #" + text=str(v) + for re,name in character_entities: + text=gsub(re,name,text) + return text + +def html_with_references(text, level=1): + text = gsub( + '[\0\n].. \[\([-_0-9_a-zA-Z-]+\)\]', + '\n [\\1]', + text) + + text = gsub( + '\([\0- ,]\)\[\([0-9_a-zA-Z-]+\)\]\([\0- ,.:]\)', + '\\1[\\2]\\3', + text) + + text = gsub( + '\([\0- ,]\)\[\([^]]+\)\.html\]\([\0- ,.:]\)', + '\\1[\\2]\\3', + text) + + return HTML(text,level=level) + + +def main(): + import sys, getopt + + opts,args=getopt.getopt(sys.argv[1:],'tw') + + if args: + [infile]=args + s=open(infile,'r').read() + else: + s=sys.stdin.read() + + if opts: + + if filter(lambda o: o[0]=='-w', opts): + print 'Content-Type: text/html\n' + + if s[:2]=='#!': + s=ts_regex.sub('^#![^\n]+','',s) + + r=ts_regex.compile('\([\0-\n]*\n\)') + ts_results = r.match_group(s, (1,)) + if ts_results: + s=s[len(ts_results[1]):] + s=str(html_with_references(s)) + if s[:4]=='': + t=s[4:find(s,'
')] + s='''| Ingredients | +|
| Name | +Amount | +
| Spam | +10 | +
| Eggs | +3 | +