Implement <ref> and <references>

* WikiTrans/wikimarkup.py (BaseWikiMarkup.tags): Add 'ref' and 'references'.
* WikiTrans/wikitoken.py (WikiTagNode): If the parser has the 'references'
attribute, store each <ref> there.
* WikiTrans/wikidump.py: Handle new tags.
* WikiTrans/wiki2html.py (HtmlTagNode): Handle new tags.
(HtmlWikiMarkup.references): New attribute
* WikiTrans/wiki2texi.py (TexiTagNode): Handle new tags.
* WikiTrans/wiki2text.py (TextTagNode): Handle new tags.
(TextWikiMarkup.showrefs): Renamed from references
(TextWikiMarkup.references): New attribute.

6 files changed, 59 insertions, 7 deletions

diff --git a/WikiTrans/wiki2html.py b/WikiTrans/wiki2html.py
index 81b918f..7c71602 100644
--- a/WikiTrans/wiki2html.py
+++ b/WikiTrans/wiki2html.py
@@ -134,24 +134,43 @@ class HtmlEnvNode(WikiEnvNode):
         return "<%s>%s</%s>" % (self.parser.envt[type]["hdr"],
                                 string,
                                 self.parser.envt[type]["hdr"])
         return string
         
 class HtmlTagNode(WikiTagNode):
     def format(self):
         if self.tag == 'code':
             self.parser.nested += 1
             s = self.content.format()
             self.parser.nested -= 1
             return '<pre><code>' + s + '</code></pre>' #FIXME
+        elif self.tag == 'ref':
+            n = self.idx+1
+            return '<sup id="cite_ref-%d" class="reference"><a name="cite_ref-%d" href=#cite_note-%d">%d</a></sup>' % (n,n,n,n)
+        elif self.tag == 'references':
+            s = '<div class="references">\n'
+            s += '<ol class="references">\n'
+            n = 0
+            for ref in self.parser.references:
+                n += 1 
+                s += ('<li id="cite_note-%d">' + \
+                       '<span class="mw-cite-backlink">' + \
+                       '<b><a href="#cite_ref-%d">^</a></b>' + \
+                       '</span>' + \
+                       '<span class="reference-text">' + \
+                       ref.content.format() + \
+                       '</span>' + \
+                       '</li>\n') % (n,n)
+            s += '</ol>\n</div>\n'
+            return s
         else:
             s = '<' + self.tag
             if self.args:
                 s += ' ' + str(self.args)
             s += '>'
             s += self.content.format()
             return s + '</' + self.tag + '>'
         
 class HtmlParaNode(HtmlSeqNode):
     def format(self):
         return "<p>" + super(HtmlParaNode, self).format() + "</p>\n"
 
@@ -168,25 +187,25 @@ class HtmlIndNode(WikiIndNode):
         return ("<dl><dd>" * self.level) + self.content.format() + "</dd></dl>" * self.level
     
 
 class HtmlWikiMarkup (WikiMarkup):
     """
     A (hopefully) general-purpose Wiki->HTML translator class.
     FIXME: 1. See WikiMarkup for a list
            2. [[official position]]s : final 's' gets after closing </a> tag.
            Should be before.
     """
 
     nested = 0
-    
+    references = []
     def __init__(self, *args, **kwargs):
         super(HtmlWikiMarkup, self).__init__(*args, **kwargs)
         self.token_class['LINK'] = HtmlLinkNode
         self.token_class['TMPL'] = HtmlLinkNode
         self.token_class['REF'] = HtmlRefNode
         self.token_class['IT'] = HtmlFontNode
         self.token_class['BOLD'] = HtmlFontNode
         self.token_class['HDR'] = HtmlHdrNode
         self.token_class['BAR'] = HtmlBarNode
         self.token_class['ENV'] = HtmlEnvNode
         self.token_class['TAG'] = HtmlTagNode
         self.token_class['PARA'] = HtmlParaNode
diff --git a/WikiTrans/wiki2texi.py b/WikiTrans/wiki2texi.py
index 9a12d37..39c70c6 100644
--- a/WikiTrans/wiki2texi.py
+++ b/WikiTrans/wiki2texi.py
@@ -94,24 +94,30 @@ class TexiTagNode(WikiTagNode):
             s = parser._end_print(save)
             if self.isblock:
                 parser._print('@example', nl=True, escape=False)
                 parser._print(s, escape=False)
                 parser._print('@end example\n', nl=True, escape=False)
             else:
                 parser._print('@code{%s}' % s, escape=False)
         elif self.tag == 'div':
             if self.args and 'id' in self.args:
                 parser._print("@anchor{%s}\n" % self.args['id'],
                               nl=True, escape=False)
             self.content.format()
+        elif self.tag == 'ref':
+            parser._print('@footnote{', escape=False);
+            self.content.format();
+            parser._print('}', escape=False)
+        elif self.tag == 'references':
+            pass
         else:
             parser._print('<' + self.tag)
             if self.args:
                 parser._print(' ' + self.args)
             parser._print('>');
             self.content.format()
             parser._print('</' + self.tag + '>')
         
 class TexiParaNode(WikiSeqNode):
     def format(self):    
         parser = self.parser
         if not parser.acc.in_new_para():
@@ -337,12 +343,13 @@ class TexiWikiMarkup (WikiMarkup):
     def __str__(self):
         self._begin_print()
         for elt in self.tree:
             elt.format()
         self.acc.trimpara()
         return self._end_print()
 
         
     
     
         
     
+    
diff --git a/WikiTrans/wiki2text.py b/WikiTrans/wiki2text.py
index 35f1aff..dc2e003 100644
--- a/WikiTrans/wiki2text.py
+++ b/WikiTrans/wiki2text.py
@@ -95,42 +95,42 @@ class TextLinkNode(WikiSeqNode):
             text = None
 
         if s:
             if s[0] == 'disambigR' or s[0] == 'wikiquote':
                 return ""
             if len(s) > 1 and s[1] == 'thumb':
                 return ""
         (qual,sep,tgt) = arg.partition(':')
         if tgt != '':
             ns = self.parser.wiki_ns_name(qual)
             if ns:
                 if ns == 'NS_IMAGE':
-                    if not self.parser.references:
+                    if not self.parser.showrefs:
                         return ""
                     text = "[%s: %s]" % (qual, text if text else arg)
                     tgt = self.image_base + '/' + \
                                  url_quote(tgt) + \
                                  '/250px-' + url_quote(tgt)
                 elif ns == 'NS_MEDIA':
                     text = "[%s]" % (qual)
                 else:
                     tgt = self.parser.mktgt(tgt)
             elif self.type == 'LINK' and qual in self.parser.langtab:
                 text = self.parser.langtab[qual] + ": " + tgt
                 tgt = self.parser.mktgt(tgt, qual)
             else:
                 tgt = self.parser.mktgt(tgt)
         else:
             tgt = self.parser.mktgt(arg)
-        if self.parser.references:
+        if self.parser.showrefs:
             return "%s (see %s) " % (text, tgt)
         elif not text or text == '':
             return arg
         else:
             return text
         
 class TextTmplNode(TextLinkNode):
     def format(self):
         return '[' + super(TextTmplNode, self).format() + ']'
         
 class TextBarNode(WikiNode):
     def format(self):
@@ -181,53 +181,62 @@ class TextEnvNode(WikiEnvNode):
         return string
 
 class TextIndNode(WikiIndNode):
     def format(self):
         return (" " * self.level) + self.content.format() + '\n'
 
 class TextTagNode(WikiTagNode):
     def format(self):
         if self.tag == 'code':
             self.parser.nested += 1
             s = self.content.format()
             self.parser.nested -= 1
+        elif self.tag == 'ref':
+            s = '[%d]' % (self.idx+1)
+        elif self.tag == 'references':
+            s = '\nReferences:\n'
+            for ref in self.parser.references:
+                s += ('[%d]. ' % (ref.idx+1))  + ref.content.format() + '\n'
         else:
             s = '<' + self.tag
             if self.args:
                 s += ' ' + str(self.args)
             s += '>' + self.content.format() + '</' + self.tag + '>'
         return s            
     
 
 class TextWikiMarkup (WikiMarkup):
     """
     A (general-purpose Wiki->Text translator class.
     """
 
     # Output width
     width = 78
     # Do not show references.
-    references = False
+    showrefs = False
     # Provide a minimum markup
     markup = True
 
     # Number of current element in the environment
     num = 0
 
+    # Array of footnote references
+    references = []
+    
     def __init__(self, *args, **keywords):
         super(TextWikiMarkup,self).__init__(*args, **keywords)
         if 'width' in keywords:
             self.width = keywords['width']
         if 'refs' in keywords:
-            self.references = keywords['refs']
+            self.showrefs = keywords['refs']
         if 'markup' in keywords:
             self.markup = keywords['markup']
         self.token_class['SEQ'] = TextSeqNode
         self.token_class['TEXT'] = TextTextNode
         self.token_class['PRE'] = TextPreNode
         self.token_class['PARA'] = TextParaNode
         self.token_class['SEQ'] = TextSeqNode
         self.token_class['IT'] = TextItNode
         self.token_class['BOLD'] = TextBoldNode
         self.token_class['LINK'] = TextLinkNode
         self.token_class['TMPL'] = TextTmplNode
         self.token_class['BAR'] = TextBarNode
diff --git a/WikiTrans/wikidump.py b/WikiTrans/wikidump.py
index 5b257f9..7457dfa 100644
--- a/WikiTrans/wikidump.py
+++ b/WikiTrans/wikidump.py
@@ -10,25 +10,33 @@
 # 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 DumpReferences(object):
+    idx = 0
+    def __len__(self):
+        return self.idx + 1
+    def append(self, obj):
+        self.idx += 1
+
 class DumpWikiMarkup(WikiMarkup):
     indent = None
+    references = DumpReferences()
     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 af97063..0987da2 100644
--- a/WikiTrans/wikimarkup.py
+++ b/WikiTrans/wikimarkup.py
@@ -105,25 +105,25 @@ class BaseWikiMarkup(object):
     # Environment types:
     envtypes = { "*": [ "unnumbered", 0 ],
                  "#": [ "numbered", 0 ],
                  ";": [ "defn", 0 ],
                  ":": [ "defn", 1 ]
     }
 
     toklist = None
     tokind = 0
     newline = 0
     tree = None
 
-    tags = [ 'code', 'nowiki', 'tt', 'div' ]
+    tags = [ 'code', 'nowiki', 'tt', 'div', 'ref', 'references' ]
     
     debug_level = 0
     
     def dprint(self, lev, fmt, *argv):
         if self.debug_level >= lev:
             for l in (fmt % argv).split('\n'):
                 print("[DEBUG] %s" % l)
 
     inline_delims = [ "''", "'''", "[", "]", "[[", "]]", "{{", "}}", "|" ]
 
     token_class = {
         'NIL':   WikiNode,
diff --git a/WikiTrans/wikitoken.py b/WikiTrans/wikitoken.py
index 5606ecc..2238a66 100644
--- a/WikiTrans/wikitoken.py
+++ b/WikiTrans/wikitoken.py
@@ -52,24 +52,26 @@ class WikiNode(object):
         for x in dir(self):
             if x == 'parser' or x.startswith('_') or type(x) == 'function':
                 continue
             if x in self.__dict__:
                 ret[x] = self.__dict__[x]
         return ret
 
     def format(self):
         pass
 
 class WikiContentNode(WikiNode):
     content = None
+    def format(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
@@ -105,31 +107,38 @@ class WikiTextNode(WikiContentNode):
             'content': self.content
         }
 
 class WikiDelimNode(WikiContentNode):
     type = 'DELIM'
     isblock=False
     continuation = False        
 
 class WikiTagNode(WikiContentNode):
     tag = None
     isblock = False
     args = None
+    idx = None
+    def __init__(self, *args, **keywords):
+        super(WikiTagNode, self).__init__(*args, **keywords)
+        if self.type == 'TAG' and self.tag == 'ref' and hasattr(self.parser,'references'):
+            self.idx = len(self.parser.references)
+            self.parser.references.append(self)
     @jsonencoder
     def jsonEncode(self):
         return {
             'tag': self.tag,
             'isblock': self.isblock,
             'args': self.args.tab if self.args else None,
-            'content': self.content.jsonEncode()
+            'content': self.content.jsonEncode() if self.content else None,
+            'idx': self.idx
         }
 
 class WikiRefNode(WikiContentNode):
     type = 'REF'
     ref = None
     @jsonencoder
     def jsonEncode(self):
         return {
             'ref': self.ref,
             'content': self.content.jsonEncode()
         }