Changeset 4295:46c7e07b95af in livinglogic.python.xist

Show
Ignore:
Timestamp:
01/21/11 16:24:54 (9 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Internal refactoring of ll.xist.xnd.

All options are now passed to Module.init.

Adding stuff to the module (and attributes to an element) is done with +=.

Files:
10 modified

Legend:

Unmodified
Added
Removed
  • NEWS.rst

    r4294 r4295  
    3232    :class:`misc.FlagAction`). 
    3333 
    34 *   The script ``xml2xsc.py`` has a new option :option:`--force-ns`, for setting 
    35     a namespace name for elements without a namespace. 
     34*   The script ``xml2xsc.py`` has a new option :option:`--defaultxmlns` for 
     35    setting a namespace name for elements without a namespace. 
     36 
     37*   :mod:`ll.xist.xnd` and the related scripts have seen some refactoring. 
    3638 
    3739 
  • src/ll/xist/ns/tld.py

    r4289 r4295  
    184184            e.doc = node.asxnd(model=model) 
    185185        for attr in self[attribute]: 
    186             attrname = unicode(attr[name][0].content) 
    187             e.attrs[attrname] = attr.asxnd(model=model) 
     186            e += attr.asxnd(model=model) 
    188187        return e 
    189188 
     
    236235            if xmlns is not None and isinstance(e, xnd.Element): 
    237236                e.xmlns = xmlns 
    238             e.add(ns) 
     237            ns += e 
    239238        return ns 
    240239 
  • src/ll/xist/scripts/dtd2xsc.py

    r4289 r4295  
    2525 
    2626 
    27 import sys, os.path, argparse, contextlib 
     27import sys, os.path, argparse, cStringIO 
    2828 
    2929try: 
     
    5555 
    5656 
    57 def adddtd2xnd(ns, dtd, xmlns=None, model="simple", duplicates="reject"): 
     57def adddtd2xnd(ns, dtd): 
    5858    """ 
    5959    Append DTD information from :var:`dtd` to the :class:`xnd.Module` object 
     
    6363    dtd = dtdparser.load_dtd_string(dtd) 
    6464 
    65     if xmlns is None: 
    66         # try to guess the namespace name from the dtd 
    67         xmlns = getxmlns(dtd) 
    68         if len(xmlns) == 1: 
    69             xmlns = iter(xmlns).next() 
    70         else: 
    71             xmlns = None 
     65    # try to guess the namespace name from the dtd 
     66    xmlns = getxmlns(dtd) 
     67    if len(xmlns) == 1: 
     68        xmlns = iter(xmlns).next() 
     69    else: 
     70        xmlns = None 
    7271 
    7372    # Add element info 
     
    101100                else: 
    102101                    required = None 
    103                 a = xnd.Attr(name=attrname, type=type, default=default, required=required, values=values) 
    104                 e.attrs[a.name] = a 
    105         e.add(ns, duplicates=duplicates) 
     102                e += xnd.Attr(name=attrname, type=type, default=default, required=required, values=values) 
     103        ns += e 
    106104 
    107105    # Iterate through the elements a second time and add model information 
     
    140138                    modeltype = "sims.NoElementsOrText" 
    141139        e = ns.elements[(elemname, xmlns)] 
    142         if model == "simple": 
     140        if ns.model == "simple": 
    143141            modeltype = modeltype == "sims.Empty" 
    144142            modelargs = None 
     
    156154                pass 
    157155            else: 
    158                 e = xnd.CharRef(entname, codepoint=ord(unicode(ent[0])[0])) 
    159                 e.add(ns, duplicates=duplicates) 
     156                ns += xnd.CharRef(entname, codepoint=ord(unicode(ent[0])[0])) 
    160157 
    161158 
    162 def urls2xnd(urls, xmlns, shareattrs, duplicates): 
    163     ns = xnd.Module() 
     159def urls2xnd(urls, shareattrs=None, **kwargs): 
     160    ns = xnd.Module(**kwargs) 
    164161    with url.Context(): 
    165162        for u in urls: 
    166             with contextlib.closing(u.openread()) as f: 
    167                 adddtd2xnd(ns, f.read(), xmlns, duplicates) 
     163            if isinstance(u, url.URL): 
     164                u = u.openread() 
     165            elif isinstance(u, str): 
     166                u = cStringIO.StringIO(u) 
     167            adddtd2xnd(ns, u.read()) 
    168168 
    169169    if shareattrs=="dupes": 
     
    174174 
    175175 
    176 def dtd2xnd(dtd, xmlns=None, duplicates="reject"): 
    177     ns = xnd.Module() 
    178     adddtd2xnd(ns, dtd, xmlns, duplicates) 
    179     return ns 
    180  
    181  
    182176def main(args=None): 
    183177    p = argparse.ArgumentParser(description="Convert DTDs to XIST namespace (on stdout)") 
    184178    p.add_argument("urls", metavar="urls", type=url.URL, help="ULRs of DTDs to be parsed", nargs="+") 
    185     p.add_argument("-x", "--xmlns", dest="xmlns", metavar="NAME", help="the namespace name for this module") 
     179    p.add_argument("-x", "--xmlns", dest="defaultxmlns", metavar="NAME", help="the namespace name for this module") 
    186180    p.add_argument("-s", "--shareattrs", dest="shareattrs", help="Should identical attributes be shared among elements? (default: %(default)s)", choices=("none", "dupes", "all"), default="dupes") 
    187181    p.add_argument("-m", "--model", dest="model", default="once", help="Add sims information to the namespace (default: %(default)s)", choices=("no", "simple", "fullall", "fullonce")) 
     
    190184 
    191185    args = p.parse_args(args) 
    192     print urls2xnd(args.urls, args.xmlns, args.shareattrs, args.model, args.duplicates).aspy(model=args.model, defaults=args.defaults) 
     186    print urls2xnd(args.urls, **args.__dict__) 
    193187 
    194188 
  • src/ll/xist/scripts/tld2xsc.py

    r4292 r4295  
    3232 
    3333 
    34 def makexnd(stream, shareattrs="dupes", model="simple"): 
     34def makexnd(stream, encoding=None, shareattrs="dupes", model="simple"): 
    3535    # :var:`stream` can be a stream, an :class:`URL` or a string 
    3636    node = parse.tree(stream, parse.Expat(), parse.NS(tld), parse.Node()) 
     
    5353 
    5454    args = p.parse_args(args) 
    55     print makexnd(sys.stdin, args.shareattrs).aspy(model=args.model, defaults=args.defaults) 
     55    print makexnd(sys.stdin, args.shareattrs, model=args.model, defaults=args.defaults) 
    5656 
    5757 
  • src/ll/xist/scripts/xml2xsc.py

    r4293 r4295  
    4949            else: 
    5050                xndnode = xnd.Element(name, xmlns=xmlns) 
    51                 xndnode.add(ns) 
     51                ns += xndnode 
    5252                elements[(name, xmlns)] = set() 
    5353            for attrname in node.keys(): 
    5454                if not attrname.startswith("{") and attrname not in xndnode.attrs: 
    55                     xndnode(xnd.Attr(attrname, type=xsc.TextAttr)) 
     55                    xndnode += xnd.Attr(attrname, type=xsc.TextAttr) 
    5656        elif "ProcessingInstruction" in type(node).__name__: 
    5757            name = node.target 
    5858            if name not in ns.procinsts: 
    59                 xndnode = xnd.ProcInst(name) 
    60                 xndnode.add(ns) 
     59                ns += xnd.ProcInst(name) 
    6160        elif "Comment" in type(node).__name__: 
    6261            xndnode = "#comment" 
     
    7372 
    7473 
    75 def makexnd(streams, parser="etree", shareattrs="dupes", model="simple"): 
     74def makexnd(urls, parser="etree", shareattrs="dupes", model="simple", defaultxmlns=None): 
    7675    elements = {} # maps (name, xmlns) to content set 
    77     ns = xnd.Module() 
     76    ns = xnd.Module(defaultxmlns=defaultxmlns) 
    7877    with url.Context(): 
    79         for stream in streams: 
    80             if isinstance(stream, url.URL): 
    81                 stream = stream.openread() 
    82             elif isinstance(stream, str): 
    83                 stream = cStringIO.StringIO(stream) 
     78        for u in urls: 
     79            if isinstance(u, url.URL): 
     80                u = u.openread() 
     81            elif isinstance(u, str): 
     82                u = cStringIO.StringIO(u) 
    8483            if parser == "etree": 
    8584                from xml.etree import cElementTree 
    86                 node = cElementTree.parse(stream).getroot() 
     85                node = cElementTree.parse(u).getroot() 
    8786            elif parser == "lxml": 
    8887                from lxml import etree 
    89                 node = etree.parse(stream).getroot() 
     88                node = etree.parse(u).getroot() 
    9089            else: 
    9190                raise ValueError("unknown parser {!r}".format(parser)) 
    92             stream.close() 
    9391            addetree2xnd(ns, node, elements) 
    9492 
     
    133131    p.add_argument("-s", "--shareattrs", dest="shareattrs", help="Should identical attributes be shared among elements? (default: %(default)s)", choices=("none", "dupes", "all"), default="dupes") 
    134132    p.add_argument("-m", "--model", dest="model", help="Create sims info? (default: %(default)s)", choices=("none", "simple", "fullall", "fullonce"), default="simple") 
    135     p.add_argument("-n", "--force-ns", dest="forcens", metavar="NAME", help="Force elements without a namespace into this namespace") 
     133    p.add_argument("-x", "--defaultxmlns", dest="defaultxmlns", metavar="NAME", help="Force elements without a namespace into this namespace") 
    136134 
    137135    args = p.parse_args(args) 
    138     print makexnd(args.urls, parser=args.parser, shareattrs=args.shareattrs, model=args.model).aspy(model=args.model, forcens=args.forcens) 
     136    print makexnd(**args.__dict__) 
    139137 
    140138 
  • src/ll/xist/xnd.py

    r4294 r4295  
    2424 
    2525 
    26 def simplify(value): 
     26def _simplify(value): 
    2727    """ 
    2828    Return a string whose value can be used as an intializer for an attribute 
     
    111111def findname(basename, names): 
    112112    """ 
    113     Return a name that is based on :var:`basename`, a valid Python identifier 
    114     and not in :var:`names. Illegal characters in :var:`basename` are replaced 
    115     with ``_`` and an ``_`` appendedwhen the name collides with a Python 
    116     keyword. 
     113    Return a new valid Python identifier based on :var:`basename`, i.e. a name 
     114    that is based on :var:`basename`, a valid Python identifier and not in 
     115    :var:`names. Illegal characters in :var:`basename` are replaced with ``_`` 
     116    and an ``_`` appendedwhen the name collides with a Python keyword. 
    117117    """ 
    118118    basename = "".join(c if "a" <= c <= "z" or "A" <= c <= "Z" or "0" <= c <= "9" or c == "_" else "_" for c in basename) 
     
    127127 
    128128 
    129 class Base(object): 
    130     def __init__(self, name): 
    131         self.name = name 
    132         self.pyname = None 
    133  
    134     def __ne__(self, other): 
    135         return not self == other 
    136  
    137     def assignpyname(self, names, name=None): 
    138         """ 
    139         Assign a Python identifier to :var:`self` (using either :var:`name` or 
    140         :var:`self.name`). This uses :func:`findname` to create a valid Python 
    141         identifier that is not in :var:`names`. 
    142         """ 
    143         if name is None: 
    144             name = self.name 
    145         name = findname(name, names) 
    146         self.pyname = name 
    147         names.add(name) 
    148  
    149     def aspy(self, **options): 
    150         options = Options(**options) 
    151         lines = [] 
    152         self._aspy(lines, 0, set(), options) 
    153         return u"".join(u"{}{}\n".format(level*options.indent, text) for (level, text) in lines) 
    154  
    155     def _addlines(self, newlines, lines): 
    156         l = len(newlines) 
    157         if l==0: 
    158             lines[-1][1] += u" pass" 
    159         elif l==1: 
    160             lines[-1][1] += u" {}".format(newlines[-1][1]) 
    161         else: 
    162             lines.extend(newlines) 
    163  
    164     def _adddoc(self, lines, level): 
    165         if self.doc is not None: 
    166             lines.append([level, u'"""']) 
    167             for line in self.doc.splitlines(): 
    168                 lines.append([level, line]) 
    169             lines.append([level, u'"""']) 
    170  
    171  
    172 class Module(Base): 
    173     def __init__(self, doc=None): 
    174         Base.__init__(self, "____") 
     129def _addlines(lines, newlines): 
     130    l = len(newlines) 
     131    if l==0: 
     132        lines[-1][1] += u" pass" 
     133    elif l==1: 
     134        lines[-1][1] += u" {}".format(newlines[-1][1]) 
     135    else: 
     136        lines.extend(newlines) 
     137 
     138 
     139def _adddoc(lines, doc, level): 
     140    if doc is not None: 
     141        lines.append([level, u'"""']) 
     142        for line in doc.splitlines(): 
     143            lines.append([level, line]) 
     144        lines.append([level, u'"""']) 
     145 
     146 
     147class Module(object): 
     148    def __init__(self, doc=None, defaultxmlns=None, indent="\t", encoding=None, defaults=False, model="fullonce", duplicates="reject"): 
    175149        self.doc = doc 
     150        self.defaultxmlns = defaultxmlns 
     151        self.indent = indent 
     152        self.encoding = encoding if encoding is not None else sys.getdefaultencoding() 
     153        self.defaults = defaults 
     154        self.model = model 
     155        self.duplicates = duplicates 
    176156        self.elements = collections.OrderedDict() # Maps (element name, namespace name) to ``xnd.Element`` 
    177157        self.procinsts = collections.OrderedDict() # Maps pi target to ``xnd.ProcInst`` 
     
    182162        return "<{0.__class__.__module__}.{0.__class__.__name__} name={0.name!r} url={0.url!r} at {1:#x}>".format(self, id(self)) 
    183163 
    184     def __call__(self, *content): 
    185         for thing in content: 
    186             thing.add(self) 
     164    def __iadd__(self, node): 
     165        node._add(self) 
    187166        return self 
     167 
     168    def __unicode__(self): 
     169        lines = [] 
     170        self._aspy(lines, 0, set(), self) 
     171        return u"".join(u"{}{}\n".format(level*self.indent, text) for (level, text) in lines) 
     172 
     173    def __str__(self): 
     174        return unicode(self).encode(self.encoding) 
    188175 
    189176    def _findgroups(self): 
     
    205192        return attrgroups 
    206193 
    207     def _aspy(self, lines, level, names, options): 
     194    def _aspy(self, lines, level, names, module): 
     195        # Find all namespaces 
     196        self.xmlnames = dict.fromkeys(e.xmlns for e in self.elements.itervalues()) 
     197        # Assign variable names to namespaces 
     198        for xmlns in self.xmlnames: 
     199            varname = findname("xmlns", names) 
     200            self.xmlnames[xmlns] = varname 
     201            names.add(varname) 
     202        print self.xmlnames 
     203         
    208204        # used as a variable name for the namespace name (must always work, i.e. be the original name) 
    209         self.assignpyname(names, "xmlns") 
     205        # self.assignpyname(names, "xmlns") 
    210206 
    211207        # assign names to all elements 
     
    233229            attrgroup.assignpyname(names) 
    234230 
    235         lines.append([level, "# -*- coding: {} -*-".format(options.encoding)]) 
     231        lines.append([level, "# -*- coding: {} -*-".format(module.encoding)]) 
    236232        lines.append([0, ""]) 
    237233        lines.append([0, ""]) 
    238234 
    239         self._adddoc(lines, level) 
     235        _adddoc(lines, self.doc, level) 
    240236 
    241237        lines.append([level, "from ll.xist import xsc, sims"]) 
     
    245241            lines.append([0, ""]) 
    246242            lines.append([0, ""]) 
    247             attrgroup._aspy(lines, level, names, options) 
     243            attrgroup._aspy(lines, level, names, module) 
    248244 
    249245        # output elements, procinsts, entities and charref 
     
    252248                lines.append([0, ""]) 
    253249                lines.append([0, ""]) 
    254                 node._aspy(lines, level, names, options) 
     250                node._aspy(lines, level, names, module) 
    255251 
    256252        # output schema information for the elements 
    257         if options.model != "none": 
     253        if module.model != "none": 
    258254            elswithschema = [node for node in self.elements.itervalues() if not isinstance(node.modeltype, (bool, type(None)))] 
    259255            if elswithschema: 
     
    269265                            modelargs.append(arg) 
    270266                    newlines.append(("{}.model".format(node.pyname), "{}({})".format(node.modeltype, ", ".join(modelargs)))) 
    271                 if options.model in ("simple", "fullall"): 
     267                if self.model in ("simple", "fullall"): 
    272268                    for line in newlines: 
    273269                        lines.append([0, "{} = {}".format(*line)]) 
    274                 elif options.model == "fullonce": 
     270                elif self.model == "fullonce": 
    275271                    newlines.sort(key=lambda l: l[1]) 
    276272                    for (i, line) in enumerate(newlines): 
     
    280276                        lines.append([0, "{} = {}".format(var, code)]) 
    281277                else: 
    282                     raise ValueError("unknown sims mode {!r}".format(options.model)) 
     278                    raise ValueError("unknown sims mode {!r}".format(self.model)) 
    283279 
    284280    def shareattrs(self, all): 
     
    303299 
    304300 
    305 class Element(Base): 
     301class Named(object): 
     302    def __init__(self, name): 
     303        self.name = name 
     304        self.pyname = None 
     305 
     306    def __ne__(self, other): 
     307        return not self == other 
     308 
     309    def assignpyname(self, names, name=None): 
     310        """ 
     311        Assign a Python identifier to :var:`self` (using either :var:`name` or 
     312        :var:`self.name`). This uses :func:`findname` to create a valid Python 
     313        identifier that is not in :var:`names`. 
     314        """ 
     315        if name is None: 
     316            name = self.name 
     317        name = findname(name, names) 
     318        self.pyname = name 
     319        names.add(name) 
     320 
     321 
     322class Element(Named): 
    306323    def __init__(self, name, xmlns=None, modeltype=None, modelargs=None, doc=None): 
    307         Base.__init__(self, name) 
     324        Named.__init__(self, name) 
    308325        self.xmlns = xmlns 
    309326        self.attrs = collections.OrderedDict() 
     
    319336        return type(other) is Element and self.name == other.name and self.xmlns == other.xmlns and self.attrs == other.attrs 
    320337 
    321     def __call__(self, *attrs): 
    322         for attr in attrs: 
    323             self.attrs[attr.name] = attr 
     338    def __iadd__(self, attr): 
     339        self.attrs[attr.name] = attr 
    324340        return self 
    325341 
    326     def add(self, module, duplicates="reject"): 
     342    def _add(self, module): 
    327343        key = (self.name, self.xmlns) 
    328344        if key in module.elements: 
    329345            oldelement = module.elements[key] 
    330             if duplicates == "reject": 
    331                 raise RedefinedElementError(oldelement, self, duplicates=duplicates) 
    332             elif duplicates == "allow": 
     346            if module.duplicates == "reject": 
     347                raise RedefinedElementError(oldelement, self, duplicates=module.duplicates) 
     348            elif module.duplicates == "allow": 
    333349                if module.elements[self.name] != self: 
    334                     raise RedefinedElementError(oldelement, self, duplicates=duplicates) 
     350                    raise RedefinedElementError(oldelement, self, duplicates=module.duplicates) 
    335351            else: # if duplicates == "merge" 
    336352                for attr in self.attrs.itervalues(): 
    337353                    if attr.name in self.attrs: 
    338354                        if attr != self.attrs[attr.name]: 
    339                             raise RedefinedElementError(oldelement, self, duplicates=duplicates) 
     355                            raise RedefinedElementError(oldelement, self, duplicates=module.duplicates) 
    340356                    else: 
    341357                        self.attrs[attr.name] = attr 
    342358        else: 
    343359            module.elements[key] = self 
    344  
    345     def _aspy(self, lines, level, names, options): 
     360        if self.xmlns is None: 
     361            self.xmlns = module.defaultxmlns 
     362 
     363    def _aspy(self, lines, level, names, module): 
    346364        lines.append([level, "class {}(xsc.Element):".format(self.pyname)]) 
    347365        newlines = [] 
    348         self._adddoc(newlines, level+1) 
    349         xmlns = self.xmlns 
    350         if xmlns is None: 
    351             xmlns = options.forcens 
    352         if xmlns is not None: 
    353             newlines.append([level+1, "xmlns = {}".format(simplify(xmlns))]) 
     366        _adddoc(newlines, self.doc, level+1) 
     367        if self.xmlns is not None: 
     368            newlines.append([level+1, "xmlns = {}".format(_simplify(self.xmlns))]) 
    354369        if self.pyname != self.name: 
    355             newlines.append([level+1, "xmlname = {}".format(simplify(self.name))]) 
    356         # only output model, if it is a bool, otherwise it might reference other element, 
     370            newlines.append([level+1, "xmlname = {}".format(_simplify(self.name))]) 
     371        # only output model if it is a bool, otherwise it might reference other element, 
    357372        # in which case this is done after all element classes have been defined 
    358373        if isinstance(self.modeltype, bool): 
     
    379394                localnames = [] 
    380395                for attr in nogroup: 
    381                     attr._aspy(newlines, level+2, localnames, options) 
     396                    attr._aspy(newlines, level+2, localnames, module) 
    382397            else: 
    383398                newlines.append([level+2, "pass"]) 
    384         self._addlines(newlines, lines) 
    385  
    386  
    387 class AttrGroup(Base): 
     399        _addlines(lines, newlines) 
     400 
     401 
     402class AttrGroup(Named): 
    388403    id = 0 
    389404    def __init__(self, name): 
     
    391406            name = "attrgroup_{}".format(self.__class__.id) 
    392407            self.__class__.id += 1 
    393         Base.__init__(self, name) 
     408        Named.__init__(self, name) 
    394409        self.attrs = [] 
    395410 
     
    398413        return self 
    399414 
    400     def _aspy(self, lines, level, names, options): 
     415    def _aspy(self, lines, level, names, module): 
    401416        lines.append([level, "class {}(xsc.Element.Attrs):".format(self.pyname)]) 
    402417        localnames = [] 
    403418        for attr in self.attrs: 
    404             attr._aspy(lines, level+1, localnames, options) 
    405  
    406  
    407 class Attr(Base): 
     419            attr._aspy(lines, level+1, localnames, module) 
     420 
     421 
     422class Attr(Named): 
    408423    def __init__(self, name, type, required=False, default=None, values=None, doc=None): 
    409         Base.__init__(self, name) 
     424        Named.__init__(self, name) 
    410425        self.doc = doc 
    411426        self.type = type 
     
    424439        return hash(self.name) ^ hash(self.type) ^ hash(self.required) ^ hash(self.default) ^ hash(self.values) 
    425440 
    426     def _aspy(self, lines, level, names, options): 
     441    def _aspy(self, lines, level, names, module): 
    427442        name = self.name 
    428443        if isinstance(self.type, type): 
     
    434449        lines.append([level, "class {}({}):".format(self.pyname, basename)]) 
    435450        newlines = [] 
    436         self._adddoc(newlines, level+1) 
     451        _adddoc(newlines, self.doc, level+1) 
    437452        if self.pyname != self.name: 
    438             newlines.append([level+1, "xmlname = {}".format(simplify(self.name))]) 
     453            newlines.append([level+1, "xmlname = {}".format(_simplify(self.name))]) 
    439454        if self.values: 
    440             values = "({})".format(", ".join(str(simplify(value)) for value in self.values)) 
     455            values = "({})".format(", ".join(str(_simplify(value)) for value in self.values)) 
    441456            newlines.append([level+1, "values = {}".format(values)]) 
    442         if self.default and options.defaults: 
    443             newlines.append([level+1, "default = {}".format(simplify(self.default))]) 
     457        if self.default and module.defaults: 
     458            newlines.append([level+1, "default = {}".format(_simplify(self.default))]) 
    444459        if self.required: 
    445460            newlines.append([level+1, "required = True"]) 
    446         self._addlines(newlines, lines) 
     461        _addlines(lines, newlines) 
    447462 
    448463    def share(self, group): 
     
    454469 
    455470 
    456 class ProcInst(Base): 
     471class ProcInst(Named): 
    457472    def __init__(self, name, doc=None): 
    458         Base.__init__(self, name) 
     473        Named.__init__(self, name) 
    459474        self.doc = doc 
    460475 
     
    462477        return "<{0.__class__.__module__}.{0.__class__.__name__} name={0.name!r} at {1:#x}>".format(self, id(self)) 
    463478 
    464     def add(self, module, duplicates="reject"): 
     479    def _add(self, module): 
    465480        if self.name in module.procinsts: 
    466             if duplicates == "reject": 
    467                 raise RedefinedProcInstError(module.procinsts[self.name], self, duplicates) 
     481            if module.duplicates == "reject": 
     482                raise RedefinedProcInstError(module.procinsts[self.name], self, module.duplicates) 
    468483        else: 
    469484            module.procinsts[self.name] = self 
    470485 
    471     def _aspy(self, lines, level, names, options): 
     486    def _aspy(self, lines, level, names, module): 
    472487        lines.append([level, "class {}(xsc.ProcInst):".format(self.pyname)]) 
    473488        newlines = [] 
    474         self._adddoc(newlines, level+1) 
     489        _adddoc(newlines, self.doc, level+1) 
    475490        if self.pyname != self.name: 
    476             newlines.append([level+1, "xmlname = {}".format(simplify(self.name))]) 
    477         self._addlines(newlines, lines) 
    478  
    479  
    480 class Entity(Base): 
     491            newlines.append([level+1, "xmlname = {}".format(_simplify(self.name))]) 
     492        _addlines(lines, newlines) 
     493 
     494 
     495class Entity(Named): 
    481496    def __init__(self, name, doc=None): 
    482         Base.__init__(self, name) 
     497        Named.__init__(self, name) 
    483498        self.doc = doc 
    484499 
     
    489504        return type(other) is CharRef and self.name == other.name 
    490505 
    491     def add(self, module, duplicates="reject"): 
     506    def _add(self, module): 
    492507        if self.name in module.entities: 
    493             if duplicates == "reject": 
    494                 raise RedefinedEntityError(module.entities[self.name], self, duplicates) 
     508            if module.duplicates == "reject": 
     509                raise RedefinedEntityError(module.entities[self.name], self, module.duplicates) 
    495510        else: 
    496511            module.entities[self.name] = self 
    497512 
    498     def _aspy(self, lines, level, names, options): 
     513    def _aspy(self, lines, level, names, module): 
    499514        lines.append([level, "class {}(xsc.Entity):".format(self.pyname)]) 
    500515        newlines = [] 
    501         self._adddoc(newlines, level+1) 
     516        _adddoc(newlines, self.doc, level+1) 
    502517        if self.pyname != self.name: 
    503             newlines.append([level+1, "xmlname = {}".format(simplify(self.name))]) 
    504         self._addlines(newlines, lines) 
     518            newlines.append([level+1, "xmlname = {}".format(_simplify(self.name))]) 
     519        _addlines(lines, newlines) 
    505520 
    506521 
     
    516531        return type(other) is CharRef and self.name == other.name and self.codepoint == other.codepoint 
    517532 
    518     def add(self, module, duplicates="reject"): 
     533    def _add(self, module): 
    519534        if self.name in module.charrefs: 
    520             if duplicates == "reject": 
    521                 raise RedefinedCharRefError(oldcharref, self, duplicates) 
     535            if module.duplicates == "reject": 
     536                raise RedefinedCharRefError(oldcharref, self, module.duplicates) 
    522537            else: # duplicates in ("allow", "merge"): 
    523538                oldcharref = module.charrefs[self.name] 
    524539                if oldcharref != self: 
    525                     raise RedefinedCharRefError(oldcharref, self, duplicates) 
     540                    raise RedefinedCharRefError(oldcharref, self, module.duplicates) 
    526541        else: 
    527542            module.charrefs[self.name] = self 
    528543 
    529     def _aspy(self, lines, level, names, options): 
     544    def _aspy(self, lines, level, names, module): 
    530545        lines.append([level, "class {}(xsc.CharRef):".format(self.pyname)]) 
    531546        newlines = [] 
    532         self._adddoc(newlines, level+1) 
     547        _adddoc(newlines, self.doc, level+1) 
    533548        if self.pyname != self.name: 
    534             newlines.append([level+1, "xmlname = {}".format(simplify(self.name))]) 
     549            newlines.append([level+1, "xmlname = {}".format(_simplify(self.name))]) 
    535550        if self.codepoint > 0xffff: 
    536551            fmt = "#010x" 
     
    540555            fmt = "#02x" 
    541556        newlines.append([level+1, "codepoint = {0:{1}}".format(self.codepoint, fmt)]) 
    542         self._addlines(newlines, lines) 
    543  
    544  
    545 class Options(object): 
    546     def __init__(self, indent="\t", encoding=None, defaults=False, model="fullonce", forcens=None): 
    547         self.indent = indent 
    548         if encoding is None: 
    549             encoding = sys.getdefaultencoding() 
    550         self.encoding = encoding 
    551         self.defaults = defaults 
    552         self.model = model 
    553         self.forcens = forcens 
     557        _addlines(lines, newlines) 
  • test/test_xist_dtd2xsc.py

    r4289 r4295  
    1616 
    1717 
    18 def dtd2mod(s, xmlns=None, shareattrs=None): 
    19     xnd = dtd2xsc.dtd2xnd(s, xmlns) 
     18def dtd2mod(s, shareattrs=None, **kwargs): 
     19    xnd = dtd2xsc.urls2xnd([s], encoding="iso-8859-1", model="fullonce", **kwargs) 
    2020 
    2121    if shareattrs is not None: 
     
    2424    mod = types.ModuleType("test") 
    2525    mod.__file__ = "test.py" 
    26     encoding = "iso-8859-1" 
    27     code = xnd.aspy(encoding=encoding, model="fullonce").encode(encoding) 
     26 
     27    code = str(xnd) 
    2828    print "Module source generated from DTDs:" 
    2929    print code 
     
    9393    <!ENTITY bar "&#xff;"> 
    9494    """ 
    95     ns = dtd2mod(dtdstring, "foo") 
     95    ns = dtd2mod(dtdstring) 
    9696 
    9797    assert ns.bar.codepoint == 0xff 
     
    105105    > 
    106106    """ 
    107     ns = dtd2mod(dtdstring, "foo") 
     107    ns = dtd2mod(dtdstring) 
    108108    assert issubclass(ns.foo.Attrs.class_, xsc.TextAttr) 
    109109    assert ns.foo.Attrs.class_.__name__ == "class_" 
     
    115115    <!ELEMENT foo EMPTY> 
    116116    """ 
    117     ns = dtd2mod(dtdstring, '"') 
     117    ns = dtd2mod(dtdstring, defaultxmlns='"') 
    118118    assert ns.foo.xmlns == '"' 
    119119 
     
    123123    <!ELEMENT foo EMPTY> 
    124124    """ 
    125     ns = dtd2mod(dtdstring, u'\u3042') 
     125    ns = dtd2mod(dtdstring, defaultxmlns=u'\u3042') 
    126126    assert ns.foo.xmlns == u'\u3042' 
    127127 
     
    131131    <!ELEMENT foo EMPTY> 
    132132    """ 
    133     ns = dtd2mod(dtdstring, u'"\u3042"') 
     133    ns = dtd2mod(dtdstring, defaultxmlns=u'"\u3042"') 
    134134    assert ns.foo.xmlns == u'"\u3042"' 
    135135 
     
    139139    <!ELEMENT class EMPTY> 
    140140    """ 
    141     ns = dtd2mod(dtdstring, "foo") 
     141    ns = dtd2mod(dtdstring) 
    142142    assert issubclass(ns.class_, xsc.Element) 
    143143 
     
    154154    > 
    155155    """ 
    156     ns = dtd2mod(dtdstring, "foo", shareattrs=None) 
     156    ns = dtd2mod(dtdstring, shareattrs=None) 
    157157    assert not hasattr(ns, "baz") 
    158158 
     
    171171    > 
    172172    """ 
    173     ns = dtd2mod(dtdstring, "foo", shareattrs=False) 
     173    ns = dtd2mod(dtdstring, shareattrs=False) 
    174174    assert issubclass(ns.foo.Attrs.baz, ns.baz.baz) 
    175175    assert issubclass(ns.bar.Attrs.baz, ns.baz.baz) 
     
    192192    > 
    193193    """ 
    194     ns = dtd2mod(dtdstring, "foo", shareattrs=True) 
     194    ns = dtd2mod(dtdstring, shareattrs=True) 
    195195    assert issubclass(ns.foo.Attrs.baz, ns.baz.baz) 
    196196    assert issubclass(ns.bar.Attrs.baz, ns.baz.baz) 
  • test/test_xist_tld2xsc.py

    r4289 r4295  
    1818 
    1919def tld2ns(s, shareattrs=None): 
    20     xnd = tld2xsc.makexnd(s, shareattrs=shareattrs) 
     20    xnd = tld2xsc.makexnd(s, encoding="iso-8859-1", shareattrs=shareattrs) 
    2121 
    2222    mod = types.ModuleType("test") 
    2323    mod.__file__ = "test.py" 
    24     encoding = "iso-8859-1" 
    25     code = xnd.aspy(encoding=encoding).encode(encoding) 
     24 
     25    code = str(xnd) 
    2626    print "Module source generated from TLD:" 
    2727    print code 
  • test/test_xist_xml2xsc.py

    r4289 r4295  
    2727        xnd = xml2xsc.makexnd(strings, parser=parser, model=model) 
    2828 
    29         code = xnd.aspy(model=model).encode() 
     29        code = str(xnd) 
    3030        print "Module source generated from XMLs:" 
    3131        print code 
  • test/test_xist_xnd.py

    r3930 r4295  
    2020def xnd2ns(data): 
    2121    with xsc.Pool(): # don't pollute the defaultpool 
     22        code = str(data) 
     23        code = compile(code, "test.py", "exec") 
    2224        mod = types.ModuleType("test") 
    2325        mod.__file__ = "test.py" 
    24         encoding = "iso-8859-1" 
    25         code = data.aspy(encoding=encoding).encode(encoding) 
    26         print code 
    27         code = compile(code, "test.py", "exec") 
    2826        exec code in mod.__dict__ 
    2927        return mod 
     
    3129 
    3230def test_xmlns(): 
    33     e = xnd.Module(xmlns)() 
    34     ns = xnd2ns(e) 
     31    ns = xnd.Module(xmlns) 
     32    ns = xnd2ns(ns) 
    3533    assert ns.xsc is xsc 
    3634 
    3735 
    3836def test_element(): 
    39     e = xnd.Module(xmlns)( 
    40         xnd.Element("foo", xmlns="http://xmlns.foo.com"), 
    41         xnd.Element("foo", xmlns="http://xmlns.foo2.com"), 
    42     ) 
    43     ns = xnd2ns(e) 
     37    ns = xnd.Module() 
     38    ns += xnd.Element("foo", xmlns="http://xmlns.foo.com") 
     39    ns += xnd.Element("foo", xmlns="http://xmlns.foo2.com") 
     40    ns = xnd2ns(ns) 
    4441    assert ns.foo.xmlname == "foo" 
    4542    assert ns.foo.xmlns == "http://xmlns.foo.com" 
     
    4946 
    5047def test_procinst(): 
    51     e = xnd.Module(xmlns)( 
    52         xnd.ProcInst("foo", doc="gurk") 
    53     ) 
    54     ns = xnd2ns(e) 
     48    ns = xnd.Module() 
     49    ns += xnd.ProcInst("foo", doc="gurk") 
     50    ns = xnd2ns(ns) 
    5551 
    5652    assert issubclass(ns.foo, xsc.ProcInst) 
    5753    assert ns.foo.__doc__.strip() == "gurk" 
    5854 
    59     e = xnd.Module(xmlns)( 
    60         xnd.ProcInst("f-o-o") 
    61     ) 
    62     ns = xnd2ns(e) 
     55    ns = xnd.Module(xmlns) 
     56    ns += xnd.ProcInst("f-o-o") 
     57    ns = xnd2ns(ns) 
    6358    assert issubclass(ns.f_o_o, xsc.ProcInst) 
    6459    assert ns.f_o_o.xmlname == "f-o-o" 
     
    6661 
    6762def test_entity(): 
    68     e = xnd.Module(xmlns)( 
    69         xnd.Entity("foo", doc="gurk") 
    70     ) 
    71     ns = xnd2ns(e) 
     63    ns = xnd.Module() 
     64    ns += xnd.Entity("foo", doc="gurk") 
     65    ns = xnd2ns(ns) 
    7266    assert issubclass(ns.foo, xsc.Entity) 
    7367    assert ns.foo.__doc__.strip() == "gurk" 
    7468 
    75     e = xnd.Module(xmlns)( 
    76         xnd.Entity("f-o-o") 
    77     ) 
    78     ns = xnd2ns(e) 
     69    ns = xnd.Module() 
     70    ns += xnd.Entity("f-o-o") 
     71    ns = xnd2ns(ns) 
    7972    assert issubclass(ns.f_o_o, xsc.Entity) 
    8073    assert ns.f_o_o.xmlname == "f-o-o" 
     
    8275 
    8376def test_charref(): 
    84     e = xnd.Module(xmlns)( 
    85         xnd.CharRef("foo", doc="gurk", codepoint=0x3042) 
    86     ) 
    87     ns = xnd2ns(e) 
     77    ns = xnd.Module() 
     78    ns += xnd.CharRef("foo", doc="gurk", codepoint=0x3042) 
     79    ns = xnd2ns(ns) 
    8880    assert issubclass(ns.foo, xsc.CharRef) 
    8981    assert ns.foo.__doc__.strip() == "gurk" 
    9082    assert ns.foo.codepoint == 0x3042 
    9183 
    92     e = xnd.Module(xmlns)( 
    93         xnd.CharRef("f-o-o", codepoint=0x3042) 
    94     ) 
    95     ns = xnd2ns(e) 
     84    ns = xnd.Module() 
     85    ns += xnd.CharRef("f-o-o", codepoint=0x3042) 
     86    ns = xnd2ns(ns) 
    9687    assert issubclass(ns.f_o_o, xsc.CharRef) 
    9788    assert ns.f_o_o.xmlname == "f-o-o" 
     
    9990 
    10091def test_model(): 
    101     e = xnd.Module(xmlns)( 
    102         xnd.Element("foo", modeltype=True) 
    103     ) 
    104     ns = xnd2ns(e) 
     92    ns = xnd.Module(xmlns) 
     93    ns += xnd.Element("foo", modeltype=True) 
     94    ns = xnd2ns(ns) 
    10595    assert isinstance(ns.foo.model, sims.Any) 
    10696 
    107     e = xnd.Module(xmlns)( 
    108         xnd.Element("foo", modeltype=False) 
    109     ) 
    110     ns = xnd2ns(e) 
     97    ns = xnd.Module() 
     98    ns += xnd.Element("foo", modeltype=False) 
     99    ns = xnd2ns(ns) 
    111100    assert isinstance(ns.foo.model, sims.Empty)