From 9eefc6aa66f7aaf502277f8708ff0390306977be Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Eray=20=C3=96zkural?= Date: Tue, 25 Oct 2005 14:20:32 +0000 Subject: [PATCH] * add a check method to autoxml classes --- pisi/util.py | 4 +-- pisi/xmlfile.py | 68 +++++++++++++++++++++++++++++++++++++++++-------- 2 files changed, 59 insertions(+), 13 deletions(-) diff --git a/pisi/util.py b/pisi/util.py index f34bad3a..9017b0a4 100644 --- a/pisi/util.py +++ b/pisi/util.py @@ -71,10 +71,10 @@ class Checks: # string/list/functional# ######################### -def every(seq, pred): +def every(pred, seq): return reduce(operator.and_, map(pred, seq)) -def any(seq, pred): +def any(pred, seq): return reduce(operator.or_, map(pred, seq)) def unzip(seq): diff --git a/pisi/xmlfile.py b/pisi/xmlfile.py index 892d94b4..421ec72d 100644 --- a/pisi/xmlfile.py +++ b/pisi/xmlfile.py @@ -46,6 +46,7 @@ _ = __trans.ugettext import pisi from pisi.xmlext import * import pisi.context as ctx +import pisi.util as util class Error(pisi.Error): pass @@ -98,6 +99,13 @@ class LocalText(object): newnode.appendChild(newtext) node.appendChild(newnode) + def check(self): + errs = [] + langs = [ locale.getlocale()[0][0:2], 'tr', 'en' ] + if not util.any(lambda x : self.locs.has_key(x), langs): + errs.append(_("Tag should have at least an English or Turkish version")) + return errs + def format(self, f, errs): L = locale.getlocale()[0][0:2] # try to read language, pathetic isn't it? if self.locs.has_key(L): @@ -205,6 +213,7 @@ class autoxml(type): inits = [] decoders = [] encoders = [] + checkers = [] formatters = [] order = dict.keys() order.sort() @@ -215,10 +224,11 @@ class autoxml(type): x = autoxml.gen_attr_member(cls, name) elif var.startswith('t_'): x = autoxml.gen_tag_member(cls, name) - (init, decoder, encoder, formatter) = x + (init, decoder, encoder, checker, formatter) = x inits.append(init) decoders.append(decoder) encoders.append(encoder) + checkers.append(checker) formatters.append(formatter) # generate top-level helper functions @@ -241,6 +251,14 @@ class autoxml(type): encode_member(self, xml, node, errs) cls.encode = encode + cls.checkers = checkers + def check(self): + errs = [] + for checker in self.__class__.checkers: + errs.extend(checker(self)) + return errs + cls.check = check + cls.formatters = formatters def format(self, f, errs): for formatter in self.__class__.formatters: @@ -308,7 +326,7 @@ class autoxml(type): name = cls.mixed_case(token) token_type = spec[0] req = spec[1] - (init_a, decode_a, encode_a, format_a) = anonfuns + (init_a, decode_a, encode_a, check_a, format_a) = anonfuns def init(self): """initialize component""" @@ -326,15 +344,25 @@ class autoxml(type): value = None encode_a(xml, node, value, errs) + def check(self): + errs = [] + if hasattr(self, name): + value = getattr(self,name) + errs.extend(check_a(value)) + else: + if req == mandatory: + errs.append(_('Mandatory variable %s not available') % name) + return errs + def format(self, f, errs): if hasattr(self, name): value = getattr(self,name) f.add_literal_data('%s: %s\n' % (token, format_a(value, f, errs))) else: if req == mandatory: - raise Error(_('Mandatory variable %s not available') % name) + errs.append(_('Mandatory variable %s not available') % name) - return (init, decode, encode, format) + return (init, decode, encode, check, format) def mixed_case(cls, identifier): """helper function to turn token name into mixed case""" @@ -402,11 +430,17 @@ class autoxml(type): if req == mandatory: errs.append(_('Mandatory argument not available')) + def check(value): + errs = [] + if not isinstance(value, token_type): + errs.append(_('Type mismatch')) + return errs + def format(value, f, errs): """format value for pretty printing""" f.add_literal_data(unicode(value)) - return initialize, decode, encode, format + return initialize, decode, encode, check, format def gen_class_tag(cls, tag, spec): """generate a class datatype""" @@ -448,14 +482,17 @@ class autoxml(type): else: if req == mandatory: errs.append(_('Mandatory argument not available')) - + + def check(obj): + return obj.check() + def format(obj, f, errs): try: obj.format(f, errs) except Error: if req == mandatory: errs.append(_('Mandatory argument not available')) - return (init, decode, encode, format) + return (init, decode, encode, check, format) def gen_list_tag(cls, tag, spec): """generate a list datatype. stores comps in tag/comp_tag""" @@ -466,7 +503,7 @@ class autoxml(type): raise Error(_('List type must contain only one element')) x = cls.gen_tag(comp_tag, [tag_type[0], mandatory]) - (init_item, decode_item, encode_item, format_item) = x + (init_item, decode_item, encode_item, check_item, format_item) = x def init(): return [] @@ -493,6 +530,12 @@ class autoxml(type): if req is mandatory: errs.append(_('Mandatory list empty')) + def check(l): + errs = [] + for ix in range(len(l)): + errs.extend(check_item(l[ix])) + return errs + def format(l, f, errs): # indent here for ix in range(len(l)): @@ -501,7 +544,7 @@ class autoxml(type): if ix != len(l)-1: f.add_flowing_data(', ') - return (init, decode, encode, format) + return (init, decode, encode, check, format) def gen_insetclass_tag(cls, tag, spec): """generate a class datatype that is highly integrated @@ -544,7 +587,10 @@ class autoxml(type): else: if req == mandatory: errs.append(_('Mandatory argument not available')) - + + def check(obj): + return obj.check() + def format(obj, f, errs): try: obj.format(f, errs) @@ -552,7 +598,7 @@ class autoxml(type): if req == mandatory: errs.append(_('Mandatory argument not available')) - return (init, decode, encode, format) + return (init, decode, encode, check, format) basic_cons_map = { types.StringType : str,