Use JSON for printable representation of tokens and nodes.

* WikiTrans/wikidump.py: New file.
* WikiTrans/__init__.py: Update
* WikiTrans/wiki2html.py: Minor change
* WikiTrans/wiki2texi.py: Likewise.
* WikiTrans/wikimarkup.py (BaseWikiMarkup.__createWikiNode): New
method; use it instead of invoking constructors directly throughout
the code.
(token_class): New attribute. A dictionary of token classes for each
specific node type.
* WikiTrans/wikitoken.py: Use JSON for printable representation of
nodes.
* bin/wikitrans: Update

7 files changed, 231 insertions, 151 deletions

diff --git a/WikiTrans/__init__.py b/WikiTrans/__init__.py
index ad99ce3..2c3c005 100644
--- a/WikiTrans/__init__.py
+++ b/WikiTrans/__init__.py
@@ -15,4 +15,12 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-__all__ = [ "wikimarkup", "wiki2html", "wiki2text", "wiki2texi", "wikins" ]
+__all__ = [
+    "wikitoken",
+    "wikimarkup",
+    "wikidump",
+    "wiki2html",
+    "wiki2text",
+    "wiki2texi",
+    "wikins"
+]
diff --git a/WikiTrans/wiki2html.py b/WikiTrans/wiki2html.py
index 122c91c..0d92e0a 100644
--- a/WikiTrans/wiki2html.py
+++ b/WikiTrans/wiki2html.py
@@ -33,6 +33,8 @@ class HtmlWikiMarkup (WikiMarkup):
            Should be before.
     """
 
+    nested = 0
+    
     def wiki_ns_name(self, str):
         if str in wiki_ns[self.lang]:
             return wiki_ns[self.lang][str]
diff --git a/WikiTrans/wiki2texi.py b/WikiTrans/wiki2texi.py
index dfde565..f55fc06 100644
--- a/WikiTrans/wiki2texi.py
+++ b/WikiTrans/wiki2texi.py
@@ -21,6 +21,7 @@ import re
 import urllib
 
 class TexiWikiMarkup (WikiMarkup):
+    nested = 0
     sectcomm = {
         'numbered': [
             '@top',
diff --git a/WikiTrans/wikidump.py b/WikiTrans/wikidump.py
new file mode 100644
index 0000000..138d0c6
--- /dev/null
+++ b/WikiTrans/wikidump.py
@@ -0,0 +1,34 @@
+# Wiki "dump" format. -*- coding: utf-8 -*-
+# Copyright (C) 2015 Sergey Poznyakoff
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import print_function
+from WikiTrans.wikitoken import *
+import json
+from WikiTrans.wikimarkup import WikiMarkup
+
+class DumpWikiMarkup(WikiMarkup):
+    indent = None
+    def __init__(self, **kwarg):
+        n = kwarg.pop('indent', None)
+        if n != None:
+            self.indent = int(n)
+        WikiMarkup.__init__(self, **kwarg)
+    def __str__(self):
+        return json.dumps(self.tree,
+                          cls=WikiNodeEncoder,
+                          indent=self.indent,
+                          separators=(',',': '),
+                          sort_keys=True)
diff --git a/WikiTrans/wikimarkup.py b/WikiTrans/wikimarkup.py
index f971347..026f1d7 100644
--- a/WikiTrans/wikimarkup.py
+++ b/WikiTrans/wikimarkup.py
@@ -116,7 +116,6 @@ class BaseWikiMarkup(object):
 
     tags = [ 'code', 'nowiki', 'tt', 'div' ]
     
-    nested = 0
     debug_level = 0
     
     def dprint(self, lev, fmt, *argv):
@@ -125,6 +124,32 @@ class BaseWikiMarkup(object):
                 print("[DEBUG] %s" % l)
 
     inline_delims = [ "''", "'''", "[", "]", "[[", "]]", "{{", "}}", "|" ]
+
+    token_class = {
+        'NIL':   WikiNode,
+        'NL':    WikiNode,
+        'OTAG':  WikiTagNode,
+        'CTAG':  WikiTagNode,
+        'TAG':   WikiTagNode,
+        'DELIM': WikiDelimNode,
+        'TEXT':  WikiTextNode,
+        'PRE':   WikiContentNode,
+        'PARA':  WikiSeqNode,
+        'BAR':   WikiNode, 
+        'SEQ':   WikiSeqNode,
+        'IND':   WikiIndNode,
+        'REF':   WikiRefNode,
+        'TMPL':  WikiSeqNode,
+        'IT':    WikiSeqNode,
+        'BOLD':  WikiSeqNode,
+        'ELT':   WikiEltNode,
+        'ENV':   WikiEnvNode,
+        'LINK':  WikiSeqNode,
+        'HDR':   WikiHdrNode
+    }
+
+    def __createWikiNode(self,**kwarg):
+        return self.token_class[kwarg['type']](**kwarg)
     
     def tokread(self):
         line = None
@@ -138,11 +163,11 @@ class BaseWikiMarkup(object):
                     line = u''
                     
             if not line or line == "":
-                yield(WikiNode(type='NIL'))
+                yield(self.__createWikiNode(type='NIL'))
                 break
 
             if line == '\n':
-                yield(WikiNode(type='NL'))
+                yield(self.__createWikiNode(type='NL'))
                 line = None
                 continue
 
@@ -151,7 +176,8 @@ class BaseWikiMarkup(object):
             
             if m:
                 if (pos < m.start(0)):
-                    yield(WikiTextNode(content=line[pos:m.start(0)]))
+                    yield(self.__createWikiNode(type='TEXT',
+                                                content=line[pos:m.start(0)]))
                 pos = m.start(0)
                 t = None
 
@@ -165,11 +191,13 @@ class BaseWikiMarkup(object):
                                     try:
                                         m = self.ctag.search(line, pos)
                                         if m and m.group('tag') == 'nowiki':
-                                            yield(WikiTextNode(content=line[pos:m.start(0)] ))
+                                            yield(self.__createWikiNode(type='TEXT',
+                                                                        content=line[pos:m.start(0)] ))
                                             pos = m.end(0)
                                             break
 
-                                        yield(WikiTextNode(content=line[pos:]))
+                                        yield(self.__createWikiNode(type='TEXT',
+                                                                    content=line[pos:]))
 
                                         line = self.input()
                                         pos = 0
@@ -178,36 +206,37 @@ class BaseWikiMarkup(object):
                             continue
                         elif m.group('tag') in self.tags:
                             try:
-                                yield(WikiTagNode(type='OTAG',
+                                yield(self.__createWikiNode(type='OTAG',
                                                   tag=m.group('tag'),
                                                   isblock=(line[pos] == '\n'),
                                                   args=TagAttributes(m.group('args'))))
                                 if m.group('closed'):
-                                    yield(WikiTagNode(type='CTAG',
+                                    yield(self.__createWikiNode(type='CTAG',
                                                       tag=m.group('tag')))
                             except TagAttributeSyntax:
-                                yield(WikiTextNode(content=m.group(0)))
+                                yield(self.__createWikiNode(type='TEXT',content=m.group(0)))
                             continue
                         else:
-                            yield(WikiTextNode(content=m.group(0)))
+                            yield(self.__createWikiNode(type='TEXT',content=m.group(0)))
                             continue
                     else:
                         m = self.ctag.match(line, pos)
                         if m:
                             if m.group('tag') in self.tags:
-                                yield(WikiTagNode(type='CTAG',
+                                yield(self.__createWikiNode(type='CTAG',
                                                   tag=m.group('tag')))
                                 pos = m.end(0)
                                 continue
                         else:
-                            yield(WikiTextNode(content=line[pos:pos+1]))
+                            yield(self.__createWikiNode(type='TEXT',
+                                                        content=line[pos:pos+1]))
                             pos += 1
                             continue
                 else:
                     pos = m.end(0)
                     content = m.group(0)
                     if content[0] in self.envtypes:
-                        node = WikiDelimNode(type='DELIM',
+                        node = self.__createWikiNode(type='DELIM',
                                              content=content,
                                              isblock=True,
                                              continuation=pos < len(line) and line[pos] == ":")
@@ -220,7 +249,7 @@ class BaseWikiMarkup(object):
                         while pos < len(line) and line[pos] in [' ', '\t']:
                             pos += 1 
                     else:
-                        yield(WikiDelimNode(type='DELIM',
+                        yield(self.__createWikiNode(type='DELIM',
                                             isblock=(content.strip() not in self.inline_delims),
                                             content=content.strip()))
                     continue
@@ -228,10 +257,10 @@ class BaseWikiMarkup(object):
             if line:
                 if line[-1] == '\n':
                     if line[pos:-1] != '':
-                        yield(WikiTextNode(content=line[pos:-1]))
-                    yield(WikiNode(type='NL'))
+                        yield(self.__createWikiNode(type='TEXT',content=line[pos:-1]))
+                    yield(self.__createWikiNode(type='NL'))
                 else:
-                    yield(WikiTextNode(content=line[pos:]))
+                    yield(self.__createWikiNode(type='TEXT',content=line[pos:]))
                 line = None
                 
 
@@ -313,7 +342,7 @@ class BaseWikiMarkup(object):
     def getkn(self):
         self.newline = self.tokind == 0 or self.toklist[self.tokind-1].type == 'NL'
         if self.tokind == len(self.toklist):
-            return WikiNode(type='NIL')
+            return self.__createWikiNode(type='NIL')
         tok = self.toklist[self.tokind]
         self.tokind = self.tokind + 1
         self.dprint(20, "getkn: %s", tok)
@@ -334,6 +363,7 @@ class BaseWikiMarkup(object):
         return tok
     
     def dump(self, tree, file=sys.stdout):
+        
         for node in tree:
             file.write(str(node))
             file.write('\n')
@@ -361,7 +391,7 @@ class BaseWikiMarkup(object):
         
         def flush():
             if acc['textlist']:
-                acc['seq'].append(WikiContentNode(type='TEXT',
+                acc['seq'].append(self.__createWikiNode(type='TEXT',
                                            content=''.join(acc['textlist'])))
                 acc['textlist'] = []
 
@@ -393,7 +423,7 @@ class BaseWikiMarkup(object):
             tok = self.getkn()
         flush()
         if acc['seq']:
-            tok = WikiSeqNode(type=type, content=acc['seq'])
+            tok = self.__createWikiNode(type=type, content=acc['seq'])
         else:
             tok = None
         self.dprint(80, "LEAVE parse_para=%s", tok)
@@ -403,11 +433,12 @@ class BaseWikiMarkup(object):
         self.dprint(80, "ENTER parse_block_delim")
         assert(tok.type == 'DELIM')
         if tok.content == "----":
-            node = WikiNode(type = 'BAR')
+            node = self.__createWikiNode(type = 'BAR')
         elif tok.content[0:2] == "==":
             node = self.parse_header(tok)
             if not node:
-                tok = self.ungetkn(WikiTextNode(content=tok.content))
+                tok = self.ungetkn(self.__createWikiNode(type='TEXT',
+                                                         content=tok.content))
         elif tok.content[0] in self.envtypes:
             node = None
             if tok.content[0] == ':':
@@ -433,7 +464,8 @@ class BaseWikiMarkup(object):
                 list.append(tok)
             elif tok.type == 'DELIM':
                 if tok.isblock:
-                    tok = WikiContentNode(type = 'TEXT', content = tok.content)
+                    tok = self.__createWikiNode(type = 'TEXT',
+                                                content = tok.content)
                     self.fixuptkn(tok)
                     list.append(tok)
                 elif tok.content[0] == ":":
@@ -445,7 +477,7 @@ class BaseWikiMarkup(object):
                     if x:
                         list.append(x)
                     else:
-                        list.append(self.fixuptkn(WikiContentNode(type = 'TEXT', content = tok.content)))
+                        list.append(self.fixuptkn(self.__createWikiNode(type = 'TEXT', content = tok.content)))
             elif tok.type == 'OTAG':
                 if tok.isblock:
                     self.ungetkn()
@@ -453,14 +485,14 @@ class BaseWikiMarkup(object):
                 list.append(self.parse_tag(tok))
             else:
                 list.append(tok)
-        ret = WikiSeqNode(type='SEQ', content=list)
+        ret = self.__createWikiNode(type='SEQ', content=list)
         self.dprint(80, "LEAVE parse_line=%s", ret)
         return ret
     
     def parse_indent(self, tok):
         lev = len(tok.content)
         self.dprint(80, "ENTER parse_indent(%s)", lev)
-        x = WikiIndNode(type='IND', level=lev, content=self.parse_line())
+        x = self.__createWikiNode(type='IND', level=lev, content=self.parse_line())
         self.dprint(80, "LEAVE parse_indent=%s", x)
         return x
     
@@ -482,7 +514,7 @@ class BaseWikiMarkup(object):
                     break
                 else:
                     if text:
-                        seq.append(WikiContentNode(type='TEXT', content=text))
+                        seq.append(self.__createWikiNode(type='TEXT', content=text))
                         text = ''
                     x = self.parse_inline_delim(tok)
                     if x:
@@ -491,13 +523,13 @@ class BaseWikiMarkup(object):
                         self.dprint(80, "LEAVE parse_fontmod=%s", "None")
                         return None
             elif tok.type == 'NL':
-                seq.append(WikiContentNode(type='TEXT', content='\n'))
+                seq.append(self.__createWikiNode(type='TEXT', content='\n'))
             else:
                 self.dprint(80, "LEAVE parse_fontmod=None")
                 return None
         if text:
-            seq.append(WikiContentNode(type='TEXT', content=text))
-        res = WikiSeqNode(type=what, content=seq)
+            seq.append(self.__createWikiNode(type='TEXT', content=text))
+        res = self.__createWikiNode(type=what, content=seq)
         self.dprint(80, "LEAVE parse_fontmod=%s", res)    
         return res
 
@@ -511,7 +543,7 @@ class BaseWikiMarkup(object):
         seq = []
         (ref,sep,text) = tok.content.partition(' ')
         if text:
-            seq.insert(0, WikiContentNode(type='TEXT', content=text))
+            seq.insert(0, self.__createWikiNode(type='TEXT', content=text))
 
         while True:
             tok = self.getkn()
@@ -536,9 +568,9 @@ class BaseWikiMarkup(object):
             else:
                 seq.append(tok)
 
-        ret = WikiRefNode(type='REF', 
+        ret = self.__createWikiNode(type='REF', 
                           ref=ref,
-                          content=WikiSeqNode(type='SEQ', content=seq))
+                          content=self.__createWikiNode(type='SEQ', content=seq))
         self.dprint(80, "LEAVE parse_ref= %s", ret)
         return ret
 
@@ -554,12 +586,12 @@ class BaseWikiMarkup(object):
             if tok.type == 'DELIM':
                 if tok.content == delim:
                     if list:
-                        subtree.append(WikiSeqNode(type='SEQ',
+                        subtree.append(self.__createWikiNode(type='SEQ',
                                                    content=list))
                     break
                 elif tok.content == "|":
                     if len(list) > 1:
-                        subtree.append(WikiSeqNode(type='SEQ',
+                        subtree.append(self.__createWikiNode(type='SEQ',
                                                    content=list))
                     elif list:
                         subtree.append(list[0])
@@ -576,7 +608,7 @@ class BaseWikiMarkup(object):
             else:
                 self.dprint(80, "LEAVE parse_link=None [unexpected token]")
                 return None
-        ret = WikiSeqNode(type=type, content=subtree)
+        ret = self.__createWikiNode(type=type, content=subtree)
         self.dprint(80, "LEAVE parse_link=%s", ret)
         return ret
     
@@ -602,7 +634,8 @@ class BaseWikiMarkup(object):
         else:
             self.dprint(80, "BEGIN DELIMITER RECOVERY: %s", tok)
             self.pop_mark()
-            x = self.fixuptkn(WikiTextNode(content=tok.content))
+            x = self.fixuptkn(self.__createWikiNode(type='TEXT',
+                                                    content=tok.content))
             od = tok.content
             if od in self.close_delim:
                 cd = self.close_delim[od]
@@ -615,7 +648,8 @@ class BaseWikiMarkup(object):
                             lev += 1
                         elif tok.content == cd:
                             if lev == 0:
-                                tok = WikiTextNode(content=tok.content)
+                                tok = self.__createWikiNode(type='TEXT',
+                                                            content=tok.content)
                                 self.toklist[self.tokind+1+i] = tok
                             lev -= 1
                             break
@@ -636,7 +670,7 @@ class BaseWikiMarkup(object):
                 if tag.args:
                     s += ' ' + str(tag.args)
                 s += '>'
-                node = WikiTextNode(content=s)
+                node = self.__createWikiNode(type='TEXT',content=s)
                 if tag.content:
                     self.tree[self.tokind:self.tokind] = tag.content
                 self.dprint(80, "LEAVE parse_tag = %s (tree modified)", node)
@@ -652,17 +686,18 @@ class BaseWikiMarkup(object):
                 if tag.tag == tok.tag:
                     break
                 s = '</' + tag.tag + '>'
-                tok = self.fixuptkn(WikiTextNode(content=s))
+                tok = self.fixuptkn(self.__createWikiNode(type='TEXT',
+                                                          content=s))
             elif tok.type == 'NL':
-                tok = WikiContentNode(type = 'TEXT', content = '\n')
+                tok = self.__createWikiNode(type = 'TEXT', content = '\n')
             list.append(tok)
 
         self.clear_mark()
-        ret = WikiTagNode(type = 'TAG',
+        ret = self.__createWikiNode(type = 'TAG',
                           tag  = tag.tag,
                           args = tag.args,
                           isblock = tag.isblock,
-                          content = WikiSeqNode(type = 'SEQ', content = list))
+                          content = self.__createWikiNode(type = 'SEQ', content = list))
         self.dprint(80, "LEAVE parse_tag = %s", ret)
         return ret
                 
@@ -683,7 +718,7 @@ class BaseWikiMarkup(object):
                 else:
                     elt = self.parse_line()
                     if not tok.continuation:
-                        list.append(WikiEltNode(type='ELT',
+                        list.append(self.__createWikiNode(type='ELT',
                                       subtype=self.envtypes[tok.content[0]][1],
                                       content=elt))
                         tok = self.getkn()
@@ -693,7 +728,7 @@ class BaseWikiMarkup(object):
                     if list[-1].content.type != 'SEQ':
                         x = list[-1].content.content
                         # FIXME:
-                        list[-1].content = WikiNode(type='SEQ', content=[x])
+                        list[-1].content = self.__createWikiNode(type='SEQ', content=[x])
                     list[-1].content.content.append(elt)
             else:
                 self.ungetkn()
@@ -701,7 +736,7 @@ class BaseWikiMarkup(object):
 
             tok = self.getkn()
 
-        ret = WikiEnvNode(type='ENV',
+        ret = self.__createWikiNode(type='ENV',
                           envtype=type,
                           level=lev,
                           content=list)
@@ -748,8 +783,10 @@ class BaseWikiMarkup(object):
                 
 
         self.clear_mark()
-        ret = WikiHdrNode(level = len(delim),
-                          content = WikiSeqNode(type='SEQ', content=list))
+        ret = self.__createWikiNode(type='HDR',
+                                    level = len(delim),
+                                    content = WikiSeqNode(type='SEQ',
+                                                          content=list))
         self.dprint(80, "LEAVE parse_header=%s", ret)
         return ret
         
@@ -836,8 +873,6 @@ class WikiMarkup (BaseWikiMarkup):
                 self.image_base = keywords[kw]
             elif kw == 'media_base':
                 self.media_base = keywords[kw]
-            elif kw == 'nested':
-                self.nested = keywords[kw]
 
     def __del__(self):
         if self.file:
diff --git a/WikiTrans/wikitoken.py b/WikiTrans/wikitoken.py
index 88c168e..3ca2b79 100644
--- a/WikiTrans/wikitoken.py
+++ b/WikiTrans/wikitoken.py
@@ -16,49 +16,24 @@
 
 from __future__ import print_function
 import re
-
-def mkstr(func):
-    def _indent(s, n=0):
-        return '  ' * n + s
-    def _do_str(self):
-        ret = _indent('NODE %s' % self.type)
-        s = func(self)
-        if s:
-            if not s.startswith('\n'):
-                ret += '\n'
-            ret += '\n'.join(map(lambda x: _indent(x, 1), s.split("\n")))
-        if not ret.endswith('\n'):
-            ret += '\n'
-        return ret + _indent('END NODE %s' % self.type)
-    return _do_str
-
-def mkcontentstr(func):
-    def _indent(s, n=0):
-        return '  ' * n + s
-    def _do_str(self):
-        ret = _indent('NODE %s' % self.type)
-        s = func(self)
-        if s:
-            if not s.startswith('\n'):
-                ret += '\n'
-            ret += '\n'.join(map(lambda x: _indent(x,1), s.split("\n")))
-        if not ret.endswith('\n'):
-            ret += '\n'
-        if self.content:
-            ret += _indent('CONTENT BEGIN\n',1)
-            if isinstance(self.content,list):
-                ret += ',\n'.join(map(lambda x: re.sub('^', _indent('',2), str(x), 0, re.MULTILINE), self.content))
-            else:
-                ret += '\n'.join(map(lambda x: _indent(x, 2), str(self.content).split("\n")))
-            if not ret.endswith('\n'):
-                ret += '\n'
-            ret += _indent('CONTENT END\n',1)
-        return ret + _indent('END NODE %s' % self.type)
-    return _do_str
-            
+import json
+
+class WikiNodeEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj,WikiNode):
+            return obj.jsonEncode()
+        return json.JSONEncoder.default(self, obj)
+
+def jsonencoder(func):
+    def _mkencoder(self):
+        json = func(self)
+        json['wikinode'] = self.__class__.__name__
+        json['type'] = self.type
+        return json
+    return _mkencoder
+    
 class WikiNode(object):
     type = 'UNDEF'
-    nesting = 0
 
     def __init__(self, **kwargs):
         for key in kwargs:
@@ -67,100 +42,131 @@ class WikiNode(object):
             else:
                 raise AttributeError("'%s' has no attribute '%s'" % (self.__class__.__name__, key))
     
-    @mkstr
     def __str__(self):
-        s = ''
+        return json.dumps(self, cls=WikiNodeEncoder, sort_keys=True)
+    
+    @jsonencoder
+    def jsonEncode(self):
+        ret = {}
         for x in dir(self):
-            if x == 'type' or x.startswith('_') or type(x) == 'function':
+            if x.startswith('_') or type(x) == 'function':
                 continue
             if x in self.__dict__:
-                s += '\n%s=%s' % (x, self.__dict__[x])
-        return s
+                ret[x] = self.__dict__[x]
+        return ret
 
 class WikiContentNode(WikiNode):
     content = None
-    @mkcontentstr
-    def __str__(self):
-        pass
+    @jsonencoder
+    def jsonEncode(self):
+        ret = {}
+        if self.content:
+            if self.type == 'TEXT':
+                ret['content'] = self.content
+            elif isinstance(self.content,list):
+                ret['content'] = map(lambda x: x.jsonEncode(), self.content)
+            elif isinstance(self.content,WikiNode):
+                ret['content'] = self.content.jsonEncode()
+            else:
+                ret['content'] = self.content
+        else:
+            ret['content'] = None
+        return ret
 
 class WikiSeqNode(WikiContentNode):
-    pass
+    @jsonencoder
+    def jsonEncode(self):
+        ret = {}
+        if not self.content:
+            ret['content'] = None
+        elif isinstance(self.content,list):
+            ret['content'] = map(lambda x: x.jsonEncode(), self.content)
+        elif isinstance(self.content,WikiNode):
+            ret['content'] = self.content.jsonEncode()
+        else:
+            ret['content'] = self.content
+        return ret
+
     
 # ##############
 
 class WikiTextNode(WikiContentNode):
     type = 'TEXT'
-    @mkstr
-    def __str__(self):
-        return '\nCONTENT: "%s"' % self.content
+    @jsonencoder
+    def jsonEncode(self):
+        return {
+            'content': self.content
+        }
 
 class WikiDelimNode(WikiContentNode):
     type = 'DELIM'
     isblock=False
-    continuation = False
-    @mkstr
-    def __str__(self):
-        s = '\nPLACEMENT: %s' % ('BLOCK' if self.isblock else 'INLINE')
-        if self.content:
-            s += '\nCONTENT: "%s"' % self.content
-        if self.continuation:
-            s += '\nCONTINUATION' 
-        return s
+    continuation = False        
 
 class WikiTagNode(WikiContentNode):
     tag = None
     isblock = False
     args = None
-    @mkcontentstr
-    def __str__(self):
-        s = '\nTAG: %s' % self.tag
-        s += '\nPLACEMENT: %s' % ('BLOCK' if self.isblock else 'INLINE')
-        if self.args:
-            s += '\nARGS: %s' % str(self.args)
-        return s
+    @jsonencoder
+    def jsonEncode(self):
+        return {
+            'tag': self.tag,
+            'isblock': self.isblock,
+            'args': self.args.tab if self.args else None,
+            'content': self.content.jsonEncode()
+        }
 
 class WikiRefNode(WikiContentNode):
     type = 'REF'
     ref = None
-    @mkcontentstr
-    def __str__(self):
-        s = '\nREF: %s' % self.ref
-        return s
+    @jsonencoder
+    def jsonEncode(self):
+        return {
+            'ref': self.ref,
+            'content': self.content.jsonEncode()
+        }
 
 class WikiHdrNode(WikiContentNode):
     type = 'HDR'
     level = None
-    @mkcontentstr
-    def __str__(self):
-        s = '\nLEVEL: %s' % self.level
-        return s
+    @jsonencoder
+    def jsonEncode(self):
+        return {
+            'level': self.level,
+            'content': self.content.jsonEncode()
+        }
     
 class WikiEltNode(WikiContentNode):
     type = 'ELT'
     subtype = None
-    @mkcontentstr
-    def __str__(self):
-        s = '\nSUBTYPE: %s' % self.subtype
-        return s
+    @jsonencoder
+    def jsonEncode(self):
+        return {
+            'subtype': self.subtype,
+            'content': self.content.jsonEncode()
+        }
 
 class WikiEnvNode(WikiContentNode):
     type = 'ENV'
     envtype = None
     level = None
-    @mkcontentstr
-    def __str__(self):
-        s = '\nLEVEL: %s' % self.level
-        s += '\nENVTYPE: %s' % self.envtype
-        return s
+    @jsonencoder
+    def jsonEncode(self):
+        return {
+            'envtype': self.envtype,
+            'level': self.level,
+            'content': map(lambda x: x.jsonEncode(), self.content)
+        }
 
 class WikiIndNode(WikiContentNode):
     type = 'IND'
     level = None
-    @mkcontentstr
-    def __str__(self):
-        return '\nLEVEL: %s' % self.level
+    @jsonencoder
+    def jsonEncode(self):
+        return {
+            'level': self.level,
+            'content': self.content.jsonEncode()
+        }
 
-class WikiLinkNode(WikiContentNode):
-    type = 'LINK'
 
 
diff --git a/bin/wikitrans b/bin/wikitrans
index 7f9789f..0b2d867 100755
--- a/bin/wikitrans
+++ b/bin/wikitrans
@@ -26,15 +26,7 @@ from WikiTrans.wiki2html  import HtmlWikiMarkup, HtmlWiktionaryMarkup
 from WikiTrans.wiki2text  import TextWikiMarkup, TextWiktionaryMarkup
 from WikiTrans.wiki2texi  import TexiWikiMarkup
 from WikiTrans.wikimarkup import WikiMarkup
-
-class DumpWikiMarkup (WikiMarkup):
-    def __str__(self):
-        if self.tree:
-            s = StringIO()
-            self.dump(self.tree, s)
-            return s.getvalue()
-        else:
-            return ""
+from WikiTrans.wikidump   import DumpWikiMarkup
 
 handlers = {
     'dump': {
@@ -112,6 +104,8 @@ def main():
         
     options.kwdict['lang'] = options.lang # FIXME
 
+    if options.otype == 'dump' and not 'indent' in options.kwdict:
+        options.kwdict['indent'] = 2
     if options.otype in handlers:
         if options.itype in handlers[options.otype]:
             markup = handlers[options.otype][options.itype](**options.kwdict)