Interwiki Module Fixed

MoinMoin/util/interwiki.py

 # Copyright: 2010 MoinMoin:ThomasWaldmann
 # Copyright: 2010 MoinMoin:MicheleOrru
 # License: GNU GPL v2 (or any later version), see LICENSE.txt for details.
 
 """
     MoinMoin - interwiki support code
 """
 
 from __future__ import absolute_import, division
 
 from werkzeug import url_quote
 
 from flask import current_app as app
 from flask import url_for
 
 import os.path
-
-from MoinMoin.constants.keys import CURRENT, FIELDS
+from collections import namedtuple
+
+from MoinMoin.constants.keys import CURRENT, FIELDS, NAME_EXACT, NAMESPACE
 from MoinMoin.constants.contenttypes import CHARSET
 
 from MoinMoin import log
 logging = log.getLogger(__name__)
 
 
 def is_local_wiki(wiki_name):
     """
     check if <wiki_name> is THIS wiki
     """
     return wiki_name in [u'', u'Self', app.cfg.interwikiname, ]
 
 
 def is_known_wiki(wiki_name):
     """
     check if <wiki_name> is a known wiki name
 
     Note: interwiki_map should have entries for the special wikinames
     denoting THIS wiki, so we do not need to check these names separately.
     """
     return wiki_name in app.cfg.interwiki_map
 
 
 def get_fqname(item_name, field, namespace):

[waldi, 2013/06/29 14:30:10]

You may want to convert this to a member of CompositeName later.

     """
     Compute composite name from item_name, field, namespace
     composite name == [NAMESPACE/][@FIELD/]NAME
     """
+    if field == NAME_EXACT:
+        field = u''
     if field:

[waldi, 2013/06/29 14:30:10]

"if field and field != NAME_EXACT:"
may be faster and easier to read.

         item_name = u'@{0}/{1}'.format(field, item_name)
     if namespace:
         item_name = u'{0}/{1}'.format(namespace, item_name)
     return item_name
 
 
 def url_for_item(item_name, wiki_name=u'', field=u'', namespace=u'', rev=CURRENT, endpoint=u'frontend.show_item', _external=False):
     """
     Compute URL for some local or remote/interwiki item.
 
     For local items:
     give <rev> to get the url of some specific revision.
     give the <endpoint> to get the url of some specific view,
     give _external=True to compute fully specified URLs.
 
     For remote/interwiki items:
     If you just give <item_name> and <wiki_name>, a generic interwiki URL
     will be built.
     If you also give <rev> and/or <endpoint>, it is assumed that remote wiki
     URLs are built in the same way as local URLs.
     Computed URLs are always fully specified.
     """
+    if field == NAME_EXACT:
+        field = u''
     if is_local_wiki(wiki_name):
         item_name = get_fqname(item_name, field, namespace)
         if rev is None or rev == CURRENT:
             url = url_for(endpoint, item_name=item_name, _external=_external)
         else:
             url = url_for(endpoint, item_name=item_name, rev=rev, _external=_external)
     else:
         try:
             wiki_base_url = app.cfg.interwiki_map[wiki_name]
         except KeyError, err:
@@ skipping 31 matching lines @@
     Example:
         namespaces_set(['ns1', 'ns1/ns2'])
         url: ns1/urlalasd return: ns1, urlalasd
         url: ns3/urlalasd return: '', ns3/urlalasd
         url: ns2/urlalasd return: '', ns2/urlalasd
         url: ns1/ns2/urlalasd return: ns1/ns2, urlalasd
     param namespaces_set: set of namespaces (strings) to search
     param url: string
     returns: (namespace, url)
     """
-    namespace_set = {namespace.rstrip('/') for namespace in namespaces}

[ashu1461, 2013/06/23 12:21:32]

we need rstrip here, because the namespace name can be 
'ns1/', we had a test covering this.
earlier we did the same in _split_interwiki.

-
     namespace = u''
     tokens_list = url.split('/')
     for token in tokens_list:
         if namespace:
             token = u'{0}/{1}'.format(namespace, token)
-        if token in namespace_set:
+        if token in namespaces:
             namespace = token
         else:
             break
     if namespace:
         length = len(namespace) + 1
         url = url[length:]
     return namespace, url
 
 
+class CompositeName(namedtuple('CompositeName', 'namespace, field, value')):
+    """
+    namedtuple to hold the compositename
+    """
+    @property
+    def split(self):

[waldi, 2013/06/29 14:30:10]

Is this used? This looks like backward compatibility code and defines a
different view over the same data. If it is used, document it, otherwise remove
it.

+        return {NAMESPACE: self.namespace, u'field': self.field, u'item_name': self.value}
+
+    @property
+    def fullname(self):
+        return get_fqname(self.value, self.field, self.namespace)
+
+    def __unicode__(self):
+        return self.fullname
+
+
 def split_fqname(url):

[waldi, 2013/06/29 14:30:10]

You may want to convert this to a (static) member method of CompositeName later

     """
-    Split a composite name into namespace, field and pagename
-    composite name -> [NAMESPACE/][@FIELD/]NAME
-    param: url: the composite name to split
-    returns: (namespace, field, itemname)
+    Split a fully qualified url into namespace, field and pagename
+    url -> [NAMESPACE/][@FIELD/]NAME
+    param: url: the url to split
+    returns: a namedtuple CompositeName(namespace, field, itemname)
     Example:
         url: u'ns1/ns2/@itemid/Page' return u'ns1/ns2', u'itemid', u'Page'
         url: u'@revid/OtherPage' return u'', u'revid', u'OtherPage'
         url: u'ns1/Page' return u'ns1', u'', u'Page'
         url: u'ns1/ns2/@notfield' return u'ns1/ns2', u'', u'@notfield'
     """
-    namespace, url = _split_namespace(dict(app.cfg.namespace_mapping).keys(), url)

[ashu1461, 2013/06/23 12:21:32]

the app.cfg.namespace_mapping appears to be list of tuples

-    field = u''
+    namespaces = {namespace.rstrip('/') for namespace, _ in app.cfg.namespace_mapping}
+    namespace, url = _split_namespace(namespaces, url)
+    field = NAME_EXACT
     if url.startswith('@'):
         tokens = url[1:].split('/', 1)
         if tokens[0] in FIELDS:
             field = tokens[0]
             url = tokens[1]
-    return namespace, field, url
+    return CompositeName(namespace, field, url)
 
 
 def split_interwiki(wikiurl):
     """ Split a interwiki name, into wikiname and pagename, e.g:
 
     'MoinMoin/FrontPage' -> "MoinMoin", "", "", "FrontPage"
     'FrontPage' -> "Self", "", "", "FrontPage"
     'MoinMoin/Page with blanks' -> "MoinMoin", "", "", "Page with blanks"
     'MoinMoin/' -> "MoinMoin", "", "", ""
     'MoinMoin/@Someid/SomeValue' -> "MoinMoin", "", "Someid", "SomeValue" if Someid field exists or "MoinMoin", "", "", "Someid/SomePage" if not
     'MoinMoin/interwikins/AnyPage' -> "MoinMoin", "interwikins", "", "AnyPage"
     'ns/AnyPage' -> "Self", "ns", "", "AnyPage" if ns namespace exists or "Self", "", "", "ns:AnyPage" if not.
     'ns1/ns2/AnyPage' -> "Self", "ns1/ns2", "", "AnyPage" if ns1/ns2 namespace exists OR
                          "Self", "ns1", "", "ns2/AnyPage" if ns1 namespace exists OR
                          "Self", "", "", "ns1/ns2/AnyPage" else.
     'MoinMoin/ns/@Somefield/AnyPage' -> "MoinMoin", "ns", "", "@Somefield/AnyPage" if ns namespace exists and field Somefield does not OR
                                      "MoinMoin", "ns", "Somefield", "AnyPage" if ns namespace and field Somefield exist OR
                                      "MoinMoin", "", "", "ns/@Somefield/AnyPage" else.
     :param wikiurl: the url to split
     :rtype: tuple
     :returns: (wikiname, namespace, field, pagename)
     """
-    #TODO Now using slash('/') as delimiter in interwiki markup instead of ':', change the moin 1.9 importer accordingly.
     if not isinstance(wikiurl, unicode):
         wikiurl = wikiurl.decode('utf-8')
     # Base case: no colon in wikiurl
     if not '/' in wikiurl:
-        return u'Self', u'', u'', wikiurl
+        return u'Self', u'', NAME_EXACT, wikiurl
     wikiname = field = namespace = u''
     if not wikiurl.startswith('/'):
         interwiki_mapping = set()
         for interwiki_name in app.cfg.interwiki_map:
             interwiki_mapping.add(interwiki_name.split('/')[0])
         wikiname, item_name = _split_namespace(interwiki_mapping, wikiurl)
         if wikiname:
             wikiurl = wikiurl[len(wikiname)+1:]
         namespace, field, item_name = split_fqname(wikiurl)
         if not wikiname:
@@ skipping 103 matching lines @@
     @staticmethod
     def from_file(filename):
         """
         Load and parse a valid interwiki map file.
         """
         filename = os.path.expanduser(filename)
         with open(filename) as f:
             parser = InterWikiMap(f.read())
 
         return parser