Edgewall Software

Ticket #129: i18n_choose_translate.2.patch

File i18n_choose_translate.2.patch, 6.6 KB (added by palgarvio, 6 years ago)

This one now works correctly

  • genshi/filters/i18n.py

    diff --git a/genshi/filters/i18n.py b/genshi/filters/i18n.py
    a b  
    131131            gettext = self.translator.ugettext 
    132132        except AttributeError: 
    133133            gettext = self.translator.gettext 
     134        try: 
     135            # Unicode aware version first 
     136            ngettext = self.translator.ungettext 
     137        except AttributeError: 
     138            ngettext = self.translator.ngettext 
    134139 
    135140        if not self.extract_text: 
    136141            search_text = False 
    137142        skip = 0 
    138         i18n_msg = I18N_NAMESPACE['msg'] 
     143        i18n_msg = I18N_NAMESPACE['msg']         
     144        i18n_choose = I18N_NAMESPACE['choose'] 
    139145        ns_prefixes = [] 
    140146        xml_lang = XML_NAMESPACE['lang'] 
    141  
     147         
    142148        for kind, data, pos in stream: 
    143149 
    144150            # skip chunks that should not be localized 
     
    184190                    params = attrs.get(i18n_msg) 
    185191                    msgbuf = MessageBuffer(params) 
    186192                    attrs -= i18n_msg 
     193                elif i18n_choose in attrs: 
     194                    params = attrs.get(i18n_choose) 
     195                    msgbuf = MessageBuffer(params) 
     196                    attrs -= i18n_choose                     
    187197 
    188198                yield kind, (tag, attrs), pos 
    189199 
     
    202212            elif not skip and msgbuf and kind is END: 
    203213                msgbuf.append(kind, data, pos) 
    204214                if not msgbuf.depth: 
    205                     for event in msgbuf.translate(gettext(msgbuf.format())): 
    206                         yield event 
     215                    if msgbuf.singular or msgbuf.plural: 
     216                        singular, plural, expr = msgbuf.format() 
     217                        events = ngettext(singular, plural, expr.evaluate(ctxt)) 
     218                        for event in msgbuf.translate(events): 
     219                            yield event 
     220                    else: 
     221                        for event in msgbuf.translate(gettext(msgbuf.format())): 
     222                            yield event 
    207223                    msgbuf = None 
    208224                    yield kind, data, pos 
    209225 
     
    298314                        if name in self.include_attrs: 
    299315                            text = value.strip() 
    300316                            if text: 
    301                                 yield pos[1], None, text 
     317                                yield pos[1], None, text, [] 
    302318                    else: 
    303319                        for lineno, funcname, text, comments in self.extract( 
    304320                                _ensure(value), gettext_functions, 
     
    328344                msgbuf.append(kind, data, pos) 
    329345                if not msgbuf.depth: 
    330346                    if msgbuf.singular or msgbuf.plural: 
    331                          yield msgbuf.lineno, 'ngettext', msgbuf.format(), \ 
     347                        singular, plural, num = msgbuf.format() 
     348                        yield msgbuf.lineno, 'ngettext', (singular, plural), \ 
    332349                                                                msgbuf.comments 
    333350                    else: 
    334351                        yield msgbuf.lineno, None, msgbuf.format(), \ 
     
    374391                            self.params.append(param.strip()) 
    375392                elif entry[0] == 'EXPR': 
    376393                    self.choose_numeral = entry[1] 
     394        elif isinstance(params, basestring): 
     395            self.params = [p.strip() for p in params.split(',')] 
    377396        else: 
    378397            self.params = params 
    379398        self.singular_params = self.params[:] 
     
    384403        self.plural = [] 
    385404        self.events = {} 
    386405        self.values = {} 
    387         self.singular_values = {} 
    388         self.plural_values = {} 
    389406        self.depth = 1 
    390407        self.order = 1 
    391408        self.choose_order = 1 
     
    414431        elif kind is EXPR: 
    415432            if self.choose_singular: 
    416433                param = self.singular_params.pop(0) 
    417                 self.singular.append('%%(%s)s' % param) 
    418                 self.singular_values[param] = (kind, data, pos)          
     434                self.singular.append('%%(%s)s' % param)       
    419435            elif self.choose_plural: 
    420436                param = self.plural_params.pop(0) 
    421437                self.plural.append('%%(%s)s' % param) 
    422                 self.plural_values[param] = (kind, data, pos) 
    423438            else: 
    424439                param = self.params.pop(0) 
    425440                self.string.append('%%(%s)s' % param) 
    426                 self.values[param] = (kind, data, pos) 
     441            self.values[param] = (kind, data, pos) 
    427442            self.events.setdefault(self.stack[-1], []).append(None) 
    428443        else: 
    429444            if kind is START: 
    430445                if self.choose_singular: 
    431                     self.ordered_singular = True 
    432446                    self.singular.append(u'[%d:' % self.choose_order) 
     447                    self.events.setdefault(self.choose_order, 
     448                                           []).append((kind, data, pos)) 
    433449                elif self.choose_plural: 
    434                     self.ordered_plural = True 
    435450                    self.plural.append(u'[%d:' % self.choose_order) 
     451                    self.events.setdefault(self.choose_order, 
     452                                           []).append((kind, data, pos)) 
     453                    self.stack.append(self.choose_order) 
    436454                    self.choose_order += 1 
    437455                elif self.i18n_choose_singular in data[1]: 
    438456                    self.choose_singular = True 
     
    442460                    self.choose_singular = False 
    443461                else: 
    444462                    self.string.append(u'[%d:' % self.order) 
     463                    self.events.setdefault(self.order, 
     464                                           []).append((kind, data, pos)) 
     465                    self.stack.append(self.order) 
    445466                    self.order += 1 
    446                 self.events.setdefault(self.order, []).append((kind, data, pos)) 
    447                 self.stack.append(self.order) 
    448467                self.depth += 1 
    449468            elif kind is END: 
    450469                self.depth -= 1 
     
    453472                        self.choose_singular = False 
    454473                        if self.choose_order > 1: 
    455474                            self.singular.append(u']') 
    456                             self.ordered_singular = False 
    457475                    elif self.choose_plural: 
    458476                        self.choose_plural = False 
    459477                        if self.choose_order > 1: 
     
    469487        """ 
    470488        if self.singular or self.plural: 
    471489            return (u''.join(self.singular).strip(), 
    472                     u''.join(self.plural).strip()) 
     490                    u''.join(self.plural).strip(), self.choose_numeral) 
    473491        return u''.join(self.string).strip() 
    474492 
    475493    def translate(self, string, regex=re.compile(r'%\((\w+)\)s')):