[Zope-Checkins] CVS: Packages/ZConfig - datatypes.py:1.1.2.6 info.py:1.1.2.7 loader.py:1.1.2.9 matcher.py:1.1.2.12 schema.py:1.1.2.8

Fred L. Drake, Jr. fred@zope.com
Thu, 12 Dec 2002 13:11:20 -0500


Update of /cvs-repository/Packages/ZConfig
In directory cvs.zope.org:/tmp/cvs-serv15000

Modified Files:
      Tag: zconfig-schema-devel-branch
	datatypes.py info.py loader.py matcher.py schema.py 
Log Message:
Support the sectiontype element in schemas.
This requires separation of the SectionInfo and SectionType information;
the schema itself is only represented as type info.
(The tests pass, but new tests are definately needed.)


=== Packages/ZConfig/datatypes.py 1.1.2.5 => 1.1.2.6 ===
--- Packages/ZConfig/datatypes.py:1.1.2.5	Wed Dec 11 16:06:44 2002
+++ Packages/ZConfig/datatypes.py	Thu Dec 12 13:11:20 2002
@@ -22,6 +22,11 @@
     False = 0
 
 
+class NullConversion:
+    def convert(self, value):
+        return value
+
+
 class TrivialConversion:
     """Datatype that exposes a conversion implemented as a function."""
 


=== Packages/ZConfig/info.py 1.1.2.6 => 1.1.2.7 ===
--- Packages/ZConfig/info.py:1.1.2.6	Thu Dec 12 00:03:08 2002
+++ Packages/ZConfig/info.py	Thu Dec 12 13:11:20 2002
@@ -114,21 +114,59 @@
 
 
 class SectionInfo(KeyInfo):
-    def __init__(self, typename, datatype, minOccurs, maxOccurs, handler,
-                 attribute, keytype, names, nametype):
-        assert keytype is not None
-        self.typename = typename
+    def __init__(self, name, sectiontype, minOccurs, maxOccurs, handler,
+                 attribute):
+        # name        - name of the section; one of '*', '+', or name1
+        # sectiontype - SectionType instance
+        # minOccurs   - minimum number of occurances of the section
+        # maxOccurs   - maximum number of occurances; if > 1, name
+        #               must be '*' or '+'
+        # handler     - handler function called when value(s) must take
+        #               effect
+        # attribute   - name of the attribute on the SectionValue object
+        if maxOccurs > 1:
+            if name not in ('*', '+'):
+                raise ZConfig.ConfigurationError(
+                    "sections which can occur more than once must"
+                    " use a name of '*' or '+'")
+            if not attribute:
+                raise ZConfig.ConfigurationError(
+                    "sections which can occur more than once must"
+                    " specify a target attribute name")
+        KeyInfo.__init__(self, name, sectiontype.datatype,
+                         minOccurs, maxOccurs, handler, attribute)
+        self.sectiontype = sectiontype
+
+    def issection(self):
+        return True
+
+    def allowUnnamed(self):
+        return self.name == "*"
+
+    def isAllowedName(self, name):
+        if name == "*" or name == "+":
+            return False
+        elif self.name == "+":
+            return bool(name)
+        elif not name:
+            return self.name == "*"
+        else:
+            return name == self.name
+
+
+class SectionType:
+    def __init__(self, name, keytype, valuetype, datatype):
+        # name      -
+        # datatype  - type for the section itself
+        # keytype   - type for the keys themselves
+        # valuetype - default type for key values
+        self.name = name
+        self.datatype = datatype
         self.keytype = keytype
-        self.names = names     # '*', '+', or [name1, ...]
-        self.nametype = nametype
+        self.valuetype = valuetype
         self._children = []    # [info, ...]
         self._attrmap = {}     # {attribute: index, ...}
         self._keymap = {}      # {key: index, ...}
-        self._secttypemap = {} # {section type: info, ...}
-        if datatype is None:
-            datatype = _null_conversion
-        KeyInfo.__init__(self, None, datatype, minOccurs, maxOccurs,
-                         handler, attribute)
 
     def __len__(self):
         return len(self._children)
@@ -156,15 +194,7 @@
 
     def addsection(self, name, sectinfo):
         assert name not in ("*", "+")
-        # Check that this isn't a different definition of the section type,
-        # since once _add_child() returns we must succeed, or undo a whole
-        # bunch of stuff.  This is the easier alternative.  ;-)
-        oldinfo = self._secttypemap.get(sectinfo.typename)
-        if oldinfo not in (None, sectinfo):
-            raise ZConfig.ConfigurationError(
-                "duplicate definition of section type " + `name`)
         self._add_child(name, sectinfo)
-        self._secttypemap[sectinfo.typename] = sectinfo
 
     def getinfo(self, key):
         if not key:
@@ -188,10 +218,10 @@
                     if not info.issection():
                         raise ZConfig.ConfigurationError(
                             "section name %s already in use for key" % key)
-                    if not info.typename == type:
+                    if not info.sectiontype.name == type:
                         raise ZConfig.ConfigurationError(
                             "name %s must be used for a %s section"
-                            % (`name`, `info.typename`))
+                            % (`name`, `info.sectiontype.name`))
                     return index
             elif info.typename == type:
                 if not (name or info.allowUnnamed()):
@@ -204,27 +234,24 @@
         i = self.getsectionindex(type, name)
         return self._children[i][1]
 
-    def issection(self):
-        return True
 
-    def allowUnnamed(self):
-        return self.names == "*"
-
-    def isAllowedName(self, name):
-        if name == "*" or name == "+":
-            return False
-        elif self.names == "+":
-            return bool(name)
-        elif not name:
-            return self.names == "*"
-        else:
-            return name in self.names
-
-
-class SchemaInfo(SectionInfo):
-    def __init__(self, datatype, handler, keytype):
-        SectionInfo.__init__(self, None, datatype, 1, 1, handler, None,
-                             keytype, (), None)
+class SchemaType(SectionType):
+    def __init__(self, keytype, valuetype, datatype, handler):
+        SectionType.__init__(self, None, keytype, valuetype, datatype)
+        self.handler = handler
+        self._types = {}
+
+    def addtype(self, typeinfo):
+        if self._types.has_key(typeinfo.name):
+            raise ZConfig.ConfigurationError("type name cannot be redefined: "
+                                             + `typeinfo.name`)
+        self._types[typeinfo.name] = typeinfo
+
+    def gettype(self, name):
+        try:
+            return self._types[name]
+        except KeyError:
+            raise ZConfig.ConfigurationError("unknown type name: " + `name`)
 
     def allowUnnamed(self):
         return True
@@ -232,9 +259,5 @@
     def isAllowedName(self, name):
         return False
 
-
-class NullConversion:
-    def convert(self, value):
-        return value
-
-_null_conversion = NullConversion()
+    def issection(self):
+        return True


=== Packages/ZConfig/loader.py 1.1.2.8 => 1.1.2.9 ===
--- Packages/ZConfig/loader.py:1.1.2.8	Wed Dec 11 15:18:15 2002
+++ Packages/ZConfig/loader.py	Thu Dec 12 13:11:20 2002
@@ -98,7 +98,13 @@
     def startSection(self, parent, type, name, delegatename):
         if delegatename:
             raise NotImpementedError("section delegation is not yet supported")
-        ci = parent.info.getsectioninfo(type, name)
+        info = parent.info
+        info = getattr(info, "sectiontype", info)
+        ci = info.getsectioninfo(type, name)
+        if not ci.isAllowedName(name):
+            raise ZConfig.ConfigurationError(
+                "%s is not an allowed name for %s sections"
+                % (`name`, `ci.sectiontype.name`))
         return matcher.SectionMatcher(ci, name)
 
     def endSection(self, parent, type, name, delegatename, matcher):


=== Packages/ZConfig/matcher.py 1.1.2.11 => 1.1.2.12 ===
--- Packages/ZConfig/matcher.py:1.1.2.11	Thu Dec 12 00:03:08 2002
+++ Packages/ZConfig/matcher.py	Thu Dec 12 13:11:20 2002
@@ -19,24 +19,21 @@
 
 
 class SectionMatcher:
-    def __init__(self, info, name=None):
+    def __init__(self, info, name):
         if name is not None:
-            self.name = info.nametype.convert(name)
-            if not info.isAllowedName(self.name):
-                raise ZConfig.ConfigurationError(
-                    "%s is not an allowed name for %s sections"
-                    % (`name`, `info.name`))
+            self.name = name
         elif info.allowUnnamed():
             self.name = None
         else:
             raise ZConfig.ConfigurationError(
                 `info.name` + " sections may not be unnamed")
         self.info = info
-        self._values = [None] * len(info)
+        self.type = info.sectiontype
+        self._values = [None] * len(self.type)
 
     def addSection(self, type, name, sectvalue):
-        i = self.info.getsectionindex(type, name)
-        ci = self.info.getsectioninfo(type, name)
+        i = self.type.getsectionindex(type, name)
+        ci = self.type.getsectioninfo(type, name)
         v = self._values[i]
         if v is None and ci.ismulti():
             v = [sectvalue]
@@ -47,9 +44,9 @@
             self._values[i] = sectvalue
 
     def addValue(self, key, value):
-        length = len(self.info)
+        length = len(self.type)
         for i in range(length):
-            k, ci = self.info[i]
+            k, ci = self.type[i]
             if k == key:
                 break
         else:
@@ -57,7 +54,7 @@
                 `key` + " is not a known key name")
         if ci.issection():
             if ci.name:
-                extra = " in %s sections" % `self.info.name`
+                extra = " in %s sections" % `self.type.name`
             else:
                 extra = ""
             raise ZConfig.ConfigurationError(
@@ -83,11 +80,11 @@
     def finish(self):
         """Check the constraints of the section and convert to an application
         object."""
-        length = len(self.info)
+        length = len(self.type)
         values = self._values
         attrnames = [None] * length
         for i in range(length):
-            key, ci = self.info[i]
+            key, ci = self.type[i]
             attrnames[i] = ci.attribute or key
             v = values[i]
             if v is None and ci.minOccurs:
@@ -119,7 +116,7 @@
     def constuct(self, attrnames):
         values = self._values
         for i in range(len(values)):
-            name, ci = self.info[i]
+            name, ci = self.type[i]
             dt = ci.datatype
             if ci.ismulti():
                 values[i] = [dt.convert(s) for s in values[i]]
@@ -129,20 +126,22 @@
         # XXX  Really should delay this until after all the
         # XXX  sibling SectionValue instances have been created and
         # XXX  we're ready to construct the parent.
-        if self.info.handler:
+        if self.info.handler is not None:
             v = self.info.handler(v)
         return v
 
 
 class SchemaMatcher(SectionMatcher):
     def __init__(self, info):
-        SectionMatcher.__init__(self, info, None)
+        self.info = info
+        self.type = info
+        self._values = [None] * len(info)
 
     def finish(self):
         # Since there's no outer container to call datatype.convert()
         # for the schema, we convert on the way out.
         v = SectionMatcher.finish(self)
-        return self.info.datatype.convert(v)
+        return self.type.datatype.convert(v)
 
 
 class SectionValue:


=== Packages/ZConfig/schema.py 1.1.2.7 => 1.1.2.8 ===
--- Packages/ZConfig/schema.py:1.1.2.7	Thu Dec 12 00:03:08 2002
+++ Packages/ZConfig/schema.py	Thu Dec 12 13:11:20 2002
@@ -34,6 +34,7 @@
 default_value_type = datatypes.get("str")
 default_key_type = datatypes.get("basic-key")
 default_name_type = default_key_type
+default_section_type = datatypes.NullConversion()
 
 _identifier = datatypes.get("identifier").convert
 
@@ -41,7 +42,7 @@
 class SchemaParser(xml.sax.ContentHandler):
 
     _cdata_tags = "description", "metadefault", "example", "default"
-    _handled_tags = "schema", "key", "section", "sectiongroup"
+    _handled_tags = "schema", "key", "section", "sectiongroup", "sectiontype"
 
     def __init__(self):
         self._cdata = None
@@ -49,7 +50,6 @@
         self._prefixes = []
         self._schema = None
         self._stack = []
-        self._sections = []
 
     def parseStream(self, stream):
         xml.sax.parse(stream, self)
@@ -111,67 +111,69 @@
             return name
 
     def push_prefix(self, attrs):
-        name = attrs.get("prefix")
-        self._prefixes.append(self.get_classname(name or ""))
+        name = attrs.get("prefix", "")
+        prefix = self.get_classname(name)
+        if prefix[:1] == ".":
+            raise ZConfig.ConfigurationError("prefix may not begin with '.'")
+        self._prefixes.append(prefix)
+
+    def get_datatype(self, attrs, key, default):
+        if attrs.has_key(key):
+            dtname = self.get_classname(attrs[key])
+            return datatypes.get(dtname)
+        else:
+            return default
+
+    def get_sect_typeinfo(self, attrs):
+        keytype = self.get_datatype(attrs, "keytype", default_key_type)
+        valuetype = self.get_datatype(attrs, "valuetype", default_value_type)
+        datatype = self.get_datatype(attrs, "type", default_section_type)
+        return keytype, valuetype, datatype
 
     def start_schema(self, attrs):
-        self._prefixes.append(attrs.get("prefix", ""))
-        handler = attrs.get("handler")
-        if handler:
-            handler = self.get_classname(handler)
-        if attrs.has_key("keytype"):
-            keytype = datatypes.get(attrs["keytype"])
-        else:
-            keytype = default_key_type
-        datatype = attrs.get("type")
-        if datatype:
-            datatype = datatypes.get(self.get_classname(datatype))
-        self._schema = info.SchemaInfo(datatype, handler, keytype)
-        self._sections = [self._schema]
+        self.push_prefix(attrs)
+        handler = self.get_classname(attrs.get("handler", "")) or None
+        keytype, valuetype, datatype = self.get_sect_typeinfo(attrs)
+        self._schema = info.SchemaType(keytype, valuetype, datatype, handler)
         self._stack = [self._schema]
 
     def end_schema(self):
         del self._prefixes[-1]
         assert not self._prefixes
-        del self._sections[-1]
-        assert not self._sections
+
+    def start_sectiontype(self, attrs):
+        name = attrs.get("name")
+        if not name:
+            raise ZConfig.ConfigurationError(
+                "sectiontype name must not be omitted or empty")
+        name = _identifier(name)
+        keytype, valuetype, datatype = self.get_sect_typeinfo(attrs)
+        sectinfo = info.SectionType(name, keytype, valuetype, datatype)
+        self._schema.addtype(sectinfo)
+        self._stack.append(sectinfo)
+
+    def end_sectiontype(self):
+        self._stack.pop()
 
     def start_section(self, attrs):
         self.push_prefix(attrs)
-        type = attrs.get("sectiontype")
+        type = attrs.get("type")
         if not type:
-            self.doSchemaError("section must specify sectiontype")
-        if attrs.has_key("keytype"):
-            keytype = datatypes.get(attrs["keytype"])
-        else:
-            keytype = default_key_type
-        if attrs.has_key("nametype"):
-            nametype = datatypes.get(attrs["nametype"])
-        else:
-            nametype = default_name_type
-        datatype = attrs.get("type")
-        if datatype:
-            datatype = datatypes.get(self.get_classname(datatype))
+            self.doSchemaError("section must specify type")
+        sectiontype = self._schema.gettype(type)
         maxOccurs, minOccurs, handler = self.get_common_info(attrs)
-        any, names, attribute = self.get_names_info(attrs, nametype)
+        any, name, attribute = self.get_name_info(attrs)
         if self._stack:
             parent = self._stack[-1]
         else:
             parent = self._schema
-        section = info.SectionInfo(type, datatype, minOccurs, maxOccurs,
-                                   handler,
-                                   attribute, keytype, names, nametype)
-        if any:
-            parent.addsection(None, section)
-        else:
-            for n in names:
-                parent.addsection(n, section)
+        section = info.SectionInfo(name, sectiontype, minOccurs, maxOccurs,
+                                   handler, attribute)
+        parent.addsection(name, section)
         self._stack.append(section)
-        self._sections.append(section)
 
     def end_section(self):
         del self._prefixes[-1]
-        del self._sections[-1]
         self._stack.pop().finish()
 
     def start_sectiongroup(self, attrs):
@@ -199,7 +201,7 @@
             attribute = _identifier(name.replace("-", "_"))
         key = info.KeyInfo(name, datatype, minOccurs, maxOccurs, handler,
                            attribute)
-        self._sections[-1].addkey(key)
+        self._stack[-1].addkey(key)
         self._stack.append(key)
 
     def end_key(self):
@@ -226,44 +228,21 @@
             handler = self.get_classname(handler)
         return maxOccurs, minOccurs, handler
 
-    def get_names_info(self, attrs, nametype):
-        if not attrs.get("names"):
-            self.doSchemaError("allowed section names must be specified")
-        anyname = None
-        names = []
-        s = attrs["names"]
-        if s in ("*", "+"):
-            aname = attrs.get("attribute")
+    def get_name_info(self, attrs):
+        name = attrs.get("name")
+        if not name:
+            self.doSchemaError("section name must be specified and non-empty")
+        aname = attrs.get("attribute")
+        if aname:
+            aname = _identifier(aname)
+        if name in ("*", "+"):
             if not aname:
                 self.doSchemaError(
-                    "container attribute must be specified when using"
-                    " '*' or '+' for section names")
-            return s, (), _identifier(aname)
-
-        for s in s.split("|"):
-            s = s.strip()
-            if not s:
-                self.doSchemaError("empty section name not allowed")
-            if s in ("*", "+"):
-                self.doSchemaError(
-                    "'+' and '*' cannot be combined with other names")
-            else:
-                s = nametype.convert(s)
-                if s in ("*", "+"):
-                    self.doSchemaError("nametypes may not convert to"
-                                       " '*' or '+'")
-                names.append(s)
-
-        if attrs.has_key("attribute"):
-            if len(names) > 1:
-                self.doSchemaError(
-                    "cannot give target attribute name with"
-                    " multiple named sections")
-            aname = _identifier(attrs["attribute"])
+                    "container attribute must be specified and non-empty"
+                    " when using '*' or '+' for a section name")
+            return name, None, aname
         else:
-            aname = None
-
-        return None, tuple(names), aname
+            return None, _identifier(name), aname
 
     def doSchemaError(self, message):
         raise ZConfig.ConfigurationError(message)