Changeset 442

Show
Ignore:
Timestamp:
Wed Aug 1 13:33:16 2007
Author:
djfroofy
Message:

- moved i18n-related stuff out of web.py into i18n.py

Files:

Legend:

Unmodified
Added
Removed
Modified

  • subprojects/Wuming/trunk/wuming/test/test_web.py

    r438 r442  
    15 15         return http.Response(responsecode.OK, stream=stream.MemoryStream(self.data))  
    16 16  
    17    
    18 17 class TestRoot(web.BaseResource):  
    19 18     tree = {  
    …… 
    61 60 import os  
    62 61 from wuming.i18n import _  
      62 from wuming import i18n  
    63 63 from wuming.templates import wgenshi  
    64 64  
    …… 
    68 68  
    69 69     templateLoader = wgenshi.GenshiTemplateLoader([os.path.dirname(__file__)])  
    70       translationStrategy = web.resource_i18n(localedir)  
      70     translationStrategy = i18n.resource_i18n(localedir)  
    70 70  
    71 71     def render_context(self, request):  
    …… 
    77 77                 }  
    78 78  
    79   babelyResource = web.I18NResourceWrapper(Babely())  
      79 babelyResource = i18n.I18NResourceWrapper(Babely())  
    79 79  
    80 80 class I18NTest(web2test.BaseCase):  

  • subprojects/Wuming/trunk/wuming/web.py

    r441 r442  
    126 126  
    127 127  
    128    
    129   import weakref  
    130    
    131   class LocalizedRequestTranslation(object):  
    132    
    133       implements(ITranslationStrategy)  
    134    
    135       _cache = weakref.WeakKeyDictionary()  
    136    
    137       preferences = lambda self, r: None  
    138    
    139       def __init__(self, translator, preferencesFunction=None):  
    140           self.translator = ITranslator(translator)  
    141           self.preferences = preferencesFunction or self.preferences  
    142    
    143       def getTranslator(self, request):  
    144           """Get the translate function for a request  
    145           """  
    146           if request in self._cache:  
    147               return self._cache[request]  
    148           prefs = self.preferences(request)  
    149           if prefs is None:  
    150               prefs = ITranslationPreferences(request)  
    151           # ???  
    152           langs = []  
    153           r = [ langs.extend(t) for t in prefs ]  
    154           return self.translator(langs)  
    155            
    156    
    157    
    158   def languagesDomainFactory(s, request):  
    159       header = request.headers.getHeader('accept-language')  
    160       if header is None:  
    161           return [], None  
    162       langs = {}  
    163       for lang in header.split(','):  
    164           quality = 1.0  
    165           if ';' in lang:  
    166               lang, quality = lang.split(';', 1)  
    167               if quality[:2] == 'q=':  
    168                   try:  
    169                       quality = float(quality[2:])  
    170                   except ValueError:  
    171                       pass  
    172           #langs.append((quality, lang))  
    173           t = langs.get(quality, ())  
    174           t = langs[quality] = t + (lang,)  
    175           if '-' in lang:  
    176               #langs.append((quality, lang.split('-')[0]))  
    177               langs[quality] = t + (lang.split('-')[0],)  
    178       items = langs.items()  
    179       items.sort(lambda a,b: cmp(b[0], a[0]))  
    180       return [lang for quality, lang in items], None  
    181    
    182   class RequestToTranslationPreferencesAdapter(object):  
    183       """I adapt an http request to an ITranslationPreferences  
    184        
    185       >>> from twisted.web2.http import Request  
    186       >>> from twisted.web2 import http_headers  
    187       >>> r = Request(None, 'GET', 'http://host/', 'HTTP/1.1', 0, http_headers.Headers())  
    188       >>> prefs = ITranslationPreferences(r)  
    189    
    190       """  
    191       implements(ITranslationPreferences)  
    192    
    193       languagesDomainFactory = languagesDomainFactory  
    194    
    195       def __init__(self, request):  
    196           self.languages, self.domain = self.languagesDomainFactory(request)  
    197        
    198       def __iter__(self):  
    199           return iter(self.languages)  
    200    
    201    
    202   components.registerAdapter(RequestToTranslationPreferencesAdapter,  
    203           IRequest, ITranslationPreferences)  
    204    
    205    
    206   class I18NResourceWrapper(resource.WrapperResource):  
    207    
    208       def __init__(self, resource):  
    209           self.resource = resource  
    210           self.translationStrategy = ITranslationStrategy(resource)  
    211    
    212       def hook(self, request):  
    213           #if self.translationStrategy != resource.translationStrategy:  
    214           #    self.translationStrategy = ITranslationStrategy(resource)  
    215           #strategy = ITranslationStrategy(self.resource)  
    216           # XXX  
    217           request.translator = self.translationStrategy.getTranslator(request)  
    218    
    219    
    220   def resource_i18n(localedir, translatorClass=None):  
    221       """A convenience function for getting the a sensible default translation strategy:  
    222       LocalizedRequestTranslation.  
    223       """  
    224       factory = translatorClass  
    225       if factory is None:  
    226           from wuming.i18n import GettextTranslator  
    227           factory = GettextTranslator  
    228       return LocalizedRequestTranslation(factory(localedir))  
    229    
    230   @implementer(ITranslationStrategy)  
    231   def adaptResourceToTranslationStrategy(resource):  
    232       """Adapt a resource to a provider of ITranslationStrategy  
    233    
    234       >>> class FooResource(resource.Resource):  
    235       ...     translationStrategy = resource_i18n(None)  
    236       ...  
    237       >>> strategy = ITranslationStrategy(FooResource())  
    238       >>> from zope.interface.verify import verifyObject  
    239       >>> verifyObject(ITranslationStrategy, strategy)  
    240       True  
    241       """  
    242       if hasattr(resource, 'translationStrategy') and \  
    243               ITranslationStrategy.providedBy(resource.translationStrategy):  
    244           return resource.translationStrategy  
    245       # Brute force search over properties for a translation strategy  
    246       #for attr in (a in dir(resource) if a[0] != '_'):  
    247       #    v = getattr(resource, attr)  
    248       #    id ITranslationStrategy.providedBy(v)  
    249       #    return v  
    250       raise NotImplementedError('Failed adapting resource to ITranslationStrategy')  
    251    
    252   components.registerAdapter(adaptResourceToTranslationStrategy,  
    253           IResource, ITranslationStrategy)  
    254    
    255 128 application = None  
    256 129  

  • subprojects/Wuming/trunk/wuming/i18n.py

    r441 r442  
    5 5  
    6 6 from wuming.interfaces import ITranslator, ITranslationStrategy, ITranslationPreferences  
    7    
    8   from zope.interface import Interface, implements, classImplements  
      7 from zope.interface import Interface, implements, implementer, classImplements  
    9 8  
    10 9 import gettext  
    …… 
    103 102 components.registerAdapter(ListAdapter, IList, ITranslationPreferences)  
    104 103  
      104 ###############################################################################  
      105 # web2 glue  
      106  
      107 from twisted.web2 import resource  
      108 from twisted.web2.iweb import IRequest, IResource  
      109 import weakref  
      110  
      111 class LocalizedRequestTranslation(object):  
      112  
      113     implements(ITranslationStrategy)  
      114  
      115     _cache = weakref.WeakKeyDictionary()  
      116  
      117     preferences = lambda self, r: None  
      118  
      119     def __init__(self, translator, preferencesFunction=None):  
      120         self.translator = ITranslator(translator)  
      121         self.preferences = preferencesFunction or self.preferences  
      122  
      123     def getTranslator(self, request):  
      124         """Get the translate function for a request  
      125         """  
      126         if request in self._cache:  
      127             return self._cache[request]  
      128         prefs = self.preferences(request)  
      129         if prefs is None:  
      130             prefs = ITranslationPreferences(request)  
      131         # ???  
      132         langs = []  
      133         r = [ langs.extend(t) for t in prefs ]  
      134         return self.translator(langs)  
      135          
      136  
      137  
      138 def languagesDomainFactory(s, request):  
      139     header = request.headers.getHeader('accept-language')  
      140     if header is None:  
      141         return [], None  
      142     langs = {}  
      143     for lang in header.split(','):  
      144         quality = 1.0  
      145         if ';' in lang:  
      146             lang, quality = lang.split(';', 1)  
      147             if quality[:2] == 'q=':  
      148                 try:  
      149                     quality = float(quality[2:])  
      150                 except ValueError:  
      151                     pass  
      152         #langs.append((quality, lang))  
      153         t = langs.get(quality, ())  
      154         t = langs[quality] = t + (lang,)  
      155         if '-' in lang:  
      156             #langs.append((quality, lang.split('-')[0]))  
      157             langs[quality] = t + (lang.split('-')[0],)  
      158     items = langs.items()  
      159     items.sort(lambda a,b: cmp(b[0], a[0]))  
      160     return [lang for quality, lang in items], None  
      161  
      162 class RequestToTranslationPreferencesAdapter(object):  
      163     """I adapt an http request to an ITranslationPreferences  
      164      
      165     >>> from twisted.web2.http import Request  
      166     >>> from twisted.web2 import http_headers  
      167     >>> r = Request(None, 'GET', 'http://host/', 'HTTP/1.1', 0, http_headers.Headers())  
      168     >>> prefs = ITranslationPreferences(r)  
      169  
      170     """  
      171     implements(ITranslationPreferences)  
      172  
      173     languagesDomainFactory = languagesDomainFactory  
      174  
      175     def __init__(self, request):  
      176         self.languages, self.domain = self.languagesDomainFactory(request)  
      177      
      178     def __iter__(self):  
      179         return iter(self.languages)  
      180  
      181  
      182 components.registerAdapter(RequestToTranslationPreferencesAdapter,  
      183         IRequest, ITranslationPreferences)  
      184  
      185  
      186 class I18NResourceWrapper(resource.WrapperResource):  
      187  
      188     def __init__(self, resource):  
      189         self.resource = resource  
      190         self.translationStrategy = ITranslationStrategy(resource)  
      191  
      192     def hook(self, request):  
      193         #if self.translationStrategy != resource.translationStrategy:  
      194         #    self.translationStrategy = ITranslationStrategy(resource)  
      195         #strategy = ITranslationStrategy(self.resource)  
      196         # XXX  
      197         request.translator = self.translationStrategy.getTranslator(request)  
      198  
      199  
      200 def resource_i18n(localedir, translatorClass=None):  
      201     """A convenience function for getting the a sensible default translation strategy:  
      202     LocalizedRequestTranslation.  
      203     """  
      204     factory = translatorClass  
      205     if factory is None:  
      206         factory = GettextTranslator  
      207     return LocalizedRequestTranslation(factory(localedir))  
      208  
      209 @implementer(ITranslationStrategy)  
      210 def adaptResourceToTranslationStrategy(resource):  
      211     """Adapt a resource to a provider of ITranslationStrategy  
      212  
      213     >>> class FooResource(resource.Resource):  
      214     ...     translationStrategy = resource_i18n(None)  
      215     ...  
      216     >>> strategy = ITranslationStrategy(FooResource())  
      217     >>> from zope.interface.verify import verifyObject  
      218     >>> verifyObject(ITranslationStrategy, strategy)  
      219     True  
      220     """  
      221     if hasattr(resource, 'translationStrategy') and \  
      222             ITranslationStrategy.providedBy(resource.translationStrategy):  
      223         return resource.translationStrategy  
      224     # Brute force search over properties for a translation strategy  
      225     #for attr in (a in dir(resource) if a[0] != '_'):  
      226     #    v = getattr(resource, attr)  
      227     #    id ITranslationStrategy.providedBy(v)  
      228     #    return v  
      229     raise NotImplementedError('Failed adapting resource to ITranslationStrategy')  
      230  
      231 components.registerAdapter(adaptResourceToTranslationStrategy,  
      232         IResource, ITranslationStrategy)  
    105 233