[OpenTAL-checkins] opental/PlacelessTranslationService Negotiator.py

[Fernando Lalo Martins]

CVSROOT:        /cvsroot/opental
Module name:    opental
Branch:         
Changes by:     Fernando Lalo Martins <address@hidden>  03/10/06 17:29:31

Modified files:
        PlacelessTranslationService: Negotiator.py 

Log message:
        Refactored the Negotiator to be able to negotiate any header in the 
Accept format

CVSWeb URLs:
http://savannah.gnu.org/cgi-bin/viewcvs/opental/opental/PlacelessTranslationService/Negotiator.py.diff?tr1=1.8&tr2=1.9&r1=text&r2=text

Patches:
Index: opental/PlacelessTranslationService/Negotiator.py
diff -u opental/PlacelessTranslationService/Negotiator.py:1.8 
opental/PlacelessTranslationService/Negotiator.py:1.9
--- opental/PlacelessTranslationService/Negotiator.py:1.8       Thu Aug 28 
15:12:10 2003
+++ opental/PlacelessTranslationService/Negotiator.py   Mon Oct  6 17:29:31 2003
@@ -17,70 +17,88 @@
 #    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA
 """
 
-$Id: Negotiator.py,v 1.8 2003/08/28 19:12:10 lalo Exp $
+$Id: Negotiator.py,v 1.9 2003/10/06 21:29:31 lalo Exp $
 """
 
-_langPrefsRegistry = []
+try:
+    True
+except NameError:
+    True=1
+    False=0
+
+def lang_normalize(lang):
+    return lang.replace('_', '-')
+
+def type_accepted(available, preferred):
+    # ex: preferred is text/* and available is text/html
+    av = available.split('/')
+    pr = preferred.split('/')
+    if len(av) < 2 or len(pr) < 2:
+        return False
+    return pr[1] == '*' and pr[0] == av[0]
+
+def lang_accepted(available, preferred):
+    # ex: available is pt, preferred is pt-br
+    return available.startswith(preferred)
 
-def registerLangPrefsMethod(prefs):
-    if type(prefs) is not type({}):
-        prefs = {'klass':prefs,'priority':0}
-    _langPrefsRegistry.append(prefs)
-    _langPrefsRegistry.sort(lambda x, y: cmp(x['priority'], y['priority']))
+def _false(*a, **kw):
+    pass
 
-def getLangPrefsMethod(env):
-    return _langPrefsRegistry[-1]['klass'](env)
-
-class DummyUserPreferredLanguages:
-
-    def __init__(self, env):
-        self._env = env
-
-    def getPreferredLanguages(self):
-        return self._env.getPreferredLanguages()
-
-registerLangPrefsMethod(DummyUserPreferredLanguages)
+class Negotiator:
+    filters = {
+        'content-type': (str.lower,),
+        'language': (str.lower, lang_normalize),
+    }
+
+    tests = {
+        'content-type': type_accepted,
+        'language': lang_accepted,
+    }
+
+    def getAccepted(self, request, kind='content-type'):
+        get = request.get
+        custom_name = ('user_%s' % kind).lower()
+        if kind == 'content-type':
+            header_name = ('HTTP_ACCEPT').upper()
+        else:
+            header_name = ('HTTP_ACCEPT_%s' % kind).upper()
 
-class BrowserLanguages:
-    
-    def __init__(self, context):
-        get = context.get
-            
         try:
-            user_langs = get('user_language', '')
-            http_langs = get('HTTP_ACCEPT_LANGUAGE', '')
+            user_accepts = get(custom_name, '')
+            http_accepts = get(header_name, '')
         except:
             from traceback import print_exc
             print_exc()
-            self.langs = ()
             return
-        if user_langs and http_langs and user_langs == 
context.cookies.get('user_language'):
-            user_langs = user_langs.split(',')
-            http_langs = http_langs.split(',')
-            for l in user_langs:
-                if l not in http_langs:
-                    req_langs = user_langs + http_langs
+        if user_accepts and http_accepts and user_accepts == 
request.cookies.get('custom_name'):
+            user_accepts = user_accepts.split(',')
+            http_accepts = http_accepts.split(',')
+            for l in user_accepts:
+                if l not in http_accepts:
+                    req_accepts = user_accepts + http_accepts
                     break
                 else:
-                    # user_langs is a subset of http_langs
-                    context.RESPONSE.expireCookie('user_language', path='/')
-                    req_langs = http_langs
+                    # user_accepts is a subset of http_accepts
+                    request.RESPONSE.expireCookie('custom_name', path='/')
+                    req_accepts = http_accepts
         else:
-            req_langs = (user_langs +','+ http_langs).split(',')
+            req_accepts = (user_accepts +','+ http_accepts).split(',')
 
-        langs = []
+        accepts = []
         i=0
-        length=len(req_langs)
+        length=len(req_accepts)
+        filters = self.filters.get(kind, ())
         
         # parse quality strings and build a tuple 
         # like ((float(quality), lang), (float(quality), lang))
         # which is sorted afterwards
         # if no quality string is given then the list order
         # is used as quality indicator
-       for lang in req_langs:
-           lang = lang.strip().lower().replace('_', '-')
-           if lang:
-                l = lang.split(';', 2)
+       for accept in req_accepts:
+            for normalizer in filters:
+                accept = normalizer(accept)
+           if accept:
+                l = accept.split(';', 2)
                 quality = []
 
                 if len(l) == 2:
@@ -95,59 +113,49 @@
                 if quality == []:
                     quality = float(length-i)
                                                                                
 
-                language = l[0]
-                langs.append((quality, language))
+                accepts.append((quality, l[0]))
                 i += 1
                 
         # sort and reverse it
-        langs.sort()
-        langs.reverse()
+        accepts.sort()
+        accepts.reverse()
         
-        # filter quality string        
-        langs = map(lambda x: x[1], langs)    
-            
-        self.langs = langs
-       
-    def getPreferredLanguages(self):
-       """
-       """
-       return self.langs
-               
-registerLangPrefsMethod({'klass':BrowserLanguages,'priority':10 })
-
-class Negotiator:
+        return [accept[1] for accept in accepts]
 
-
-    def getLanguage(self, langs, env):
-        langs = tuple(langs)
+    def negotiate(self, choices, request, kind='content-type'):
+        choices = tuple(choices)
+        cache_name = '_pts_negotiator_cache_%s' % kind
         try:
-            cache = env.other['_pts_negotiator_cache']
+            cache = request.other[cache_name]
         except KeyError:
             # Store cache in request object
             cache = {}
-            env.set('_pts_negotiator_cache', cache)
+            request.set(cache_name, cache)
         try:
-            return cache[langs]
+            return cache[choices]
         except KeyError:
-            cache[langs] = self._getLanguage(langs, env)
-            return cache[langs]
+            cache[choices] = self._negotiate(choices, request, kind)
+            return cache[choices]
 
-    def _getLanguage(self, langs, env):
-        envprefs = getLangPrefsMethod(env)
-        userlangs = envprefs.getPreferredLanguages()
-        # Prioritize on the user preferred languages.  Return the first user
-        # preferred language that the object has available.
-        for lang in userlangs:
-            if lang in langs:
-                return lang
-            for l_avail in langs:
-                if l_avail.startswith(lang):
+    def _negotiate(self, choices, request, kind):
+        userchoices = self.getAccepted(request, kind)
+        # Prioritize on the user preferred choices.  Return the first user
+        # preferred choice that the object has available.
+        test = self.tests.get(kind, _false)
+        for choice in userchoices:
+            if choice in choices:
+                return choice
+            for l_avail in choices:
+                if test(l_avail, choice):
                     return l_avail
         return None
 
-    def getLanguages(self, env):
-        envprefs = getLangPrefsMethod(env)
-        return envprefs.getPreferredLanguages()
+    # backwards compatibility... should be deprecated
+    def getLanguage(self, langs, request):
+        return self.negotiate(langs, request, 'language')
+
+    def getLanguages(self, request):
+        return self.getAccepted(request, 'language')
 
 
 negotiator = Negotiator()