Merge pull request #159 from giuseppe/support-net-devices

ocispec: Add string-to-object map support and refactor helper classes

Author: flouthoc

src/ocispec/generate.py

@@ -53,7 +53,7 @@
 Interface: rootpaths
 History: 2019-06-17
 '''
-class MyRoot(object):
+class MyRoot:
     '''
     Description: Store schema information
     Interface: None
@@ -275,7 +275,7 @@ def get_type_pattern_incur(cur, schema_info, src, curfile):
     return typ
 
 
-class GenerateNodeInfo(object):
+class GenerateNodeInfo:
     '''
     Description: Store schema information
     Interface: None
@@ -321,7 +321,7 @@ def gen_all_arr_typnode(node_info, src, typ, refname):
     children = merge(resolve_list(schema_info, name, src, cur["items"]['allOf'], curfile))
     subtyp = children[0].typ
     subtypobj = children
-    return helpers.Unite(name,
+    return helpers.SchemaNode(name,
                         typ,
                         children,
                         subtyp=subtyp,
@@ -348,7 +348,7 @@ def gen_any_arr_typnode(node_info, src, typ, refname):
     children = anychildren[0].children
     subtypobj = children
     refname = anychildren[0].subtypname
-    return helpers.Unite(name,
+    return helpers.SchemaNode(name,
                         typ,
                         children,
                         subtyp=subtyp,
@@ -375,7 +375,7 @@ def gen_ref_arr_typnode(node_info, src, typ, refname):
         refname = make_ref_name(subrefname, curfile)
     else:
         refname = item_type.subtypname
-    return helpers.Unite(name,
+    return helpers.SchemaNode(name,
                         typ,
                         None,
                         subtyp=item_type.typ,
@@ -398,15 +398,15 @@ def gen_type_arr_typnode(node_info, src, typ, refname):
     item_type, src = resolve_type(schema_info, name, src, cur["items"], curfile)
 
     if typ == 'array' and typ == item_type.typ and not helpers.valid_basic_map_name(item_type.subtyp):
-        return helpers.Unite(name,
+        return helpers.SchemaNode(name,
                         typ,
                         None,
                         subtyp=item_type.subtyp,
                         subtypobj=item_type.subtypobj,
                         subtypname=item_type.subtypname,
                         required=item_type.required, doublearray=True), src
     else:
-        return helpers.Unite(name,
+        return helpers.SchemaNode(name,
                         typ,
                         None,
                         subtyp=item_type.typ,
@@ -450,7 +450,11 @@ def gen_obj_typnode(node_info, src, typ, refname):
     subtypobj = None
     required = None
 
-    if 'allOf' in cur:
+    if 'additionalProperties' in cur and isinstance(cur['additionalProperties'], dict):
+        child, src_child = resolve_type(schema_info, name, src, cur['additionalProperties'], curfile)
+        child.fixname = "values"
+        return helpers.SchemaNode(name, 'mapStringObject', [child], None, None, None), src
+    elif 'allOf' in cur:
         children = merge(resolve_list(schema_info, name, src, cur['allOf'], curfile))
     elif 'anyOf' in cur:
         children = resolve_list(schema_info, name, src, cur['anyOf'], curfile)
@@ -466,7 +470,7 @@ def gen_obj_typnode(node_info, src, typ, refname):
             if 'properties' in cur else None
     if 'required' in cur:
         required = cur['required']
-    return helpers.Unite(name,\
+    return helpers.SchemaNode(name,\
             typ,\
             children,\
             subtyp=subtyp,\
@@ -532,7 +536,7 @@ def resolve_type(schema_info, name, src, cur, curfile):
             raise RuntimeError("Invalid schema type: %s" % typ)
         children = None
 
-    return helpers.Unite(name,
+    return helpers.SchemaNode(name,
                         typ,
                         children,
                         subtyp=subtyp,
@@ -550,9 +554,9 @@ def resolve_list(schema_info, name, schema, objs, curfile):
     obj = []
     index = 0
     for i in objs:
-        generated_name = helpers.CombinateName( \
+        generated_name = helpers.HierarchicalName( \
             i['$ref'].split("/")[-1]) if '$ref' in i \
-            else helpers.CombinateName(name.name + str(index))
+            else helpers.HierarchicalName(name.name + str(index))
         node, _ = resolve_type(schema_info, generated_name, schema, i, curfile)
         if node:
             obj.append(node)
@@ -599,9 +603,9 @@ def handle_type_not_in_schema(schema_info, schema, prefix):
     """
     required = None
     if 'definitions' in schema:
-        return helpers.Unite( \
-            helpers.CombinateName("definitions"), 'definitions', \
-            parse_properties(schema_info, helpers.CombinateName(""), schema, schema, \
+        return helpers.SchemaNode( \
+            helpers.HierarchicalName("definitions"), 'definitions', \
+            parse_properties(schema_info, helpers.HierarchicalName(""), schema, schema, \
                             schema_info.name.name), None, None, None, None)
     else:
         if len(schema) > 1:
@@ -611,14 +615,14 @@ def handle_type_not_in_schema(schema_info, schema, prefix):
         for value in schema:
             if 'required' in schema[value]:
                 required = schema[value]['required']
-            childrens = parse_properties(schema_info, helpers.CombinateName(""), \
+            childrens = parse_properties(schema_info, helpers.HierarchicalName(""), \
                                         schema[value], schema[value], \
                                         schema_info.name.name)
-            value_node = helpers.Unite(helpers.CombinateName(prefix), \
+            value_node = helpers.SchemaNode(helpers.HierarchicalName(prefix), \
                                        'object', childrens, None, None, \
                                        None, required)
             value_nodes.append(value_node)
-        return helpers.Unite(helpers.CombinateName("definitions"), \
+        return helpers.SchemaNode(helpers.HierarchicalName("definitions"), \
                              'definitions', value_nodes, None, None, \
                             None, None)
 
@@ -636,20 +640,20 @@ def parse_schema(schema_info, schema, prefix):
     if 'object' in schema['type']:
         if 'required' in schema:
             required = schema['required']
-        return helpers.Unite(
-            helpers.CombinateName(prefix), 'object',
+        return helpers.SchemaNode(
+            helpers.HierarchicalName(prefix), 'object',
             parse_properties(schema_info, \
-                            helpers.CombinateName(""), \
+                            helpers.HierarchicalName(""), \
                             schema, schema, schema_info.name.name), \
             None, None, None, required)
     elif 'array' in schema['type']:
-        item_type, _ = resolve_type(schema_info, helpers.CombinateName(""), \
+        item_type, _ = resolve_type(schema_info, helpers.HierarchicalName(""), \
                                     schema['items'], schema['items'], schema_info.name.name)
         if item_type.typ == 'array' and not helpers.valid_basic_map_name(item_type.subtyp):
             item_type.doublearray = True
             return item_type
         else:
-            return helpers.Unite(helpers.CombinateName(prefix), 'array', None, item_type.typ, \
+            return helpers.SchemaNode(helpers.HierarchicalName(prefix), 'array', None, item_type.typ, \
                             item_type.children, None, item_type.required)
 
     else:
@@ -673,8 +677,8 @@ def expand(tree, structs, visited):
             expand(i, structs, visited=visited)
 
     if tree.typ == 'array' and helpers.valid_basic_map_name(tree.subtyp):
-        name = helpers.CombinateName(tree.name + "_element")
-        node = helpers.Unite(name, tree.subtyp, None)
+        name = helpers.HierarchicalName(tree.name + "_element")
+        node = helpers.SchemaNode(name, tree.subtyp, None)
         expand(node, structs, visited)
 
     id_ = "%s:%s" % (tree.name, tree.typ)

src/ocispec/headers.py

@@ -45,7 +45,7 @@ def append_header_arr(obj, header, prefix):
             if i.subtypobj is not None:
                 c_typ = helpers.get_name_substr(i.name, prefix)
 
-            if not helpers.judge_complex(i.subtyp):
+            if not helpers.is_compound_type(i.subtyp):
                 header.append(f"    {c_typ}{' ' if '*' not in c_typ else ''}*{i.fixname};\n")
             else:
                 header.append(f"    {c_typ} **{i.fixname};\n")
@@ -75,7 +75,7 @@ def append_header_map_str_obj(obj, header, prefix):
     if helpers.valid_basic_map_name(child.typ):
         c_typ = helpers.get_prefixed_pointer("", child.typ, "")
     elif child.subtypname:
-        c_typ = child.subtypname
+        c_typ = child.subtypname +  " *"
     else:
         c_typ = helpers.get_prefixed_pointer(child.name, child.typ, prefix)
     header.append(f"    {c_typ}{' ' if '*' not in c_typ else ''}*{child.fixname};\n")
@@ -105,7 +105,7 @@ def append_header_child_arr(child, header, prefix):
 
     if helpers.valid_basic_map_name(child.subtyp):
         header.append(f"    {helpers.make_basic_map_name(child.subtyp)} **{child.fixname};\n")
-    elif not helpers.judge_complex(child.subtyp):
+    elif not helpers.is_compound_type(child.subtyp):
         header.append(f"    {c_typ}{' ' if '*' not in c_typ else ''}*{dflag}{child.fixname};\n")
     else:
         header.append(f"    {c_typ}{' ' if '*' not in c_typ else ''}**{dflag}{child.fixname};\n")
@@ -138,7 +138,7 @@ def append_type_c_header(obj, header, prefix):
     Interface: None
     History: 2019-06-17
     '''
-    if not helpers.judge_complex(obj.typ):
+    if not helpers.is_compound_type(obj.typ):
         return
 
     if obj.typ == 'array':

src/ocispec/helpers.py

@@ -178,13 +178,13 @@ def get_prefixed_pointer(name, typ, prefix):
     Interface: None
     History: 2019-06-17
     '''
-    if typ != 'object' and typ != 'mapStringObject' and \
+    if typ != 'array' and typ != 'object' and typ != 'mapStringObject' and \
             not valid_basic_map_name(typ):
         return ""
     return '%s *' % make_basic_map_name(typ) if valid_basic_map_name(typ) \
         else "%s *" % get_prefixed_name(name, prefix)
 
-def judge_complex(typ):
+def is_compound_type(typ):
     '''
     Description: Check compound object
     Interface: None
@@ -235,9 +235,9 @@ def obtain_pointer(name, typ, prefix):
     return "char *" if typ == "string" else \
         ("%s *" % typ if typ == "ArrayOfStrings" else "")
 
-class CombinateName(object):
+class HierarchicalName:
     '''
-    Description: Store CombinateName information
+    Description: Store HierarchicalName information
     Interface: None
     History: 2019-06-17
     '''
@@ -256,12 +256,12 @@ def append(self, leaf):
         History: 2019-06-17
         '''
         prefix_name = self.name + '_' if self.name != "" else ""
-        return CombinateName(prefix_name + leaf, leaf)
+        return HierarchicalName(prefix_name + leaf, leaf)
 
 
-class Unite(object):
+class SchemaNode:
     '''
-    Description: Store Unite information
+    Description: Store SchemaNode information
     Interface: None
     History: 2019-06-17
     '''
@@ -287,7 +287,7 @@ def __repr__(self):
         return "name:(%s) type:(%s)" % (self.name, self.typ)
 
 
-class FilePath(object):
+class FilePath:
     '''
     Description: Store filepath information
     Interface: None
@@ -303,7 +303,7 @@ def __repr__(self):
             % (self.name, self.dirname, self.basename)
 
 
-class SchemaInfo(object):
+class SchemaInfo:
     '''
     Description: Store schema information
     Interface: None