libs/openid/yadis/xri.py

   1 # -*- test-case-name: openid.test.test_xri -*-
   2 """Utility functions for handling XRIs.
   3
   4 @see: XRI Syntax v2.0 at the U{OASIS XRI Technical Committee<http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=xri>}
   5 """
   6
   7 import re
   8
   9 XRI_AUTHORITIES = ['!', '=', '@', '+', '$', '(']
  10
  11 try:
  12     unichr(0x10000)
  13 except ValueError:
  14     # narrow python build
  15     UCSCHAR = [
  16         (0xA0, 0xD7FF),
  17         (0xF900, 0xFDCF),
  18         (0xFDF0, 0xFFEF),
  19         ]
  20
  21     IPRIVATE = [
  22         (0xE000, 0xF8FF),
  23         ]
  24 else:
  25     UCSCHAR = [
  26         (0xA0, 0xD7FF),
  27         (0xF900, 0xFDCF),
  28         (0xFDF0, 0xFFEF),
  29         (0x10000, 0x1FFFD),
  30         (0x20000, 0x2FFFD),
  31         (0x30000, 0x3FFFD),
  32         (0x40000, 0x4FFFD),
  33         (0x50000, 0x5FFFD),
  34         (0x60000, 0x6FFFD),
  35         (0x70000, 0x7FFFD),
  36         (0x80000, 0x8FFFD),
  37         (0x90000, 0x9FFFD),
  38         (0xA0000, 0xAFFFD),
  39         (0xB0000, 0xBFFFD),
  40         (0xC0000, 0xCFFFD),
  41         (0xD0000, 0xDFFFD),
  42         (0xE1000, 0xEFFFD),
  43         ]
  44
  45     IPRIVATE = [
  46         (0xE000, 0xF8FF),
  47         (0xF0000, 0xFFFFD),
  48         (0x100000, 0x10FFFD),
  49         ]
  50
  51
  52 _escapeme_re = re.compile('[%s]' % (''.join(
  53     map(lambda (m, n): u'%s-%s' % (unichr(m), unichr(n)),
  54         UCSCHAR + IPRIVATE)),))
  55
  56
  57 def identifierScheme(identifier):
  58     """Determine if this identifier is an XRI or URI.
  59
  60     @returns: C{"XRI"} or C{"URI"}
  61     """
  62     if identifier.startswith('xri://') or (
  63         identifier and identifier[0] in XRI_AUTHORITIES):
  64         return "XRI"
  65     else:
  66         return "URI"
  67
  68
  69 def toIRINormal(xri):
  70     """Transform an XRI to IRI-normal form."""
  71     if not xri.startswith('xri://'):
  72         xri = 'xri://' + xri
  73     return escapeForIRI(xri)
  74
  75
  76 _xref_re = re.compile('\((.*?)\)')
  77
  78
  79 def _escape_xref(xref_match):
  80     """Escape things that need to be escaped if they're in a cross-reference.
  81     """
  82     xref = xref_match.group()
  83     xref = xref.replace('/', '%2F')
  84     xref = xref.replace('?', '%3F')
  85     xref = xref.replace('#', '%23')
  86     return xref
  87
  88
  89 def escapeForIRI(xri):
  90     """Escape things that need to be escaped when transforming to an IRI."""
  91     xri = xri.replace('%', '%25')
  92     xri = _xref_re.sub(_escape_xref, xri)
  93     return xri
  94
  95
  96 def toURINormal(xri):
  97     """Transform an XRI to URI normal form."""
  98     return iriToURI(toIRINormal(xri))
  99
 100
 101 def _percentEscapeUnicode(char_match):
 102     c = char_match.group()
 103     return ''.join(['%%%X' % (ord(octet),) for octet in c.encode('utf-8')])
 104
 105
 106 def iriToURI(iri):
 107     """Transform an IRI to a URI by escaping unicode."""
 108     # According to RFC 3987, section 3.1, "Mapping of IRIs to URIs"
 109     return _escapeme_re.sub(_percentEscapeUnicode, iri)
 110
 111
 112 def providerIsAuthoritative(providerID, canonicalID):
 113     """Is this provider ID authoritative for this XRI?
 114
 115     @returntype: bool
 116     """
 117     # XXX: can't use rsplit until we require python >= 2.4.
 118     lastbang = canonicalID.rindex('!')
 119     parent = canonicalID[:lastbang]
 120     return parent == providerID
 121
 122
 123 def rootAuthority(xri):
 124     """Return the root authority for an XRI.
 125
 126     Example::
 127
 128         rootAuthority("xri://@example") == "xri://@"
 129
 130     @type xri: unicode
 131     @returntype: unicode
 132     """
 133     if xri.startswith('xri://'):
 134         xri = xri[6:]
 135     authority = xri.split('/', 1)[0]
 136     if authority[0] == '(':
 137         # Cross-reference.
 138         # XXX: This is incorrect if someone nests cross-references so there
 139         #   is another close-paren in there.  Hopefully nobody does that
 140         #   before we have a real xriparse function.  Hopefully nobody does
 141         #   that *ever*.
 142         root = authority[:authority.index(')') + 1]
 143     elif authority[0] in XRI_AUTHORITIES:
 144         # Other XRI reference.
 145         root = authority[0]
 146     else:
 147         # IRI reference.  XXX: Can IRI authorities have segments?
 148         segments = authority.split('!')
 149         segments = reduce(list.__add__,
 150             map(lambda s: s.split('*'), segments))
 151         root = segments[0]
 152
 153     return XRI(root)
 154
 155
 156 def XRI(xri):
 157     """An XRI object allowing comparison of XRI.
 158
 159     Ideally, this would do full normalization and provide comparsion
 160     operators as per XRI Syntax.  Right now, it just does a bit of
 161     canonicalization by ensuring the xri scheme is present.
 162
 163     @param xri: an xri string
 164     @type xri: unicode
 165     """
 166     if not xri.startswith('xri://'):
 167         xri = 'xri://' + xri
 168     return xri