idl-parser 0.2.2__tar.gz → 0.3.0__tar.gz

{idl_parser-0.2.2/idl_parser.egg-info → idl_parser-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idl_parser
-Version: 0.2.2
+Version: 0.3.0
 Summary: Very simple OMG IDL (Interface Definition Language) parser. This parses IDL files and outputs intermediate class objects.
 Author-email: ysuga <ysuga@ysuga.net>
 License-Expression: GPL-3.0-or-later
@@ -102,6 +102,7 @@ More examples are in the ``examples`` folder of the repository:
 - ``example.py``: interfaces, typedefs, unions and structs
 - ``union_example.py``: unions (discriminator kinds, case and ``default`` labels, member types)
 - ``annotation_example.py``: IDL 4 annotations (``@key``, ``@range``, ...) and struct keys
+- ``scoped_name_example.py``: same-named types in several modules (relative ``X``, ``C::X`` and absolute ``::B::X`` names)
 
 https://github.com/sugarsweetrobotics/idl_parser/tree/main/examples
 

{idl_parser-0.2.2 → idl_parser-0.3.0}/README.md

@@ -77,6 +77,7 @@ More examples are in the [examples](examples/) folder:
 | [`example.py`](examples/example.py) | interfaces, typedefs, unions and structs |
 | [`union_example.py`](examples/union_example.py) | unions: discriminator kinds, case and `default` labels, member types |
 | [`annotation_example.py`](examples/annotation_example.py) | IDL 4 annotations (`@key`, `@range`, ...) and struct keys |
+| [`scoped_name_example.py`](examples/scoped_name_example.py) | same-named types in several modules: relative (`X`, `C::X`) and absolute (`::B::X`) names |
 
 Run them with e.g. `python examples/union_example.py` (in a source checkout no install is needed).
 

{idl_parser-0.2.2 → idl_parser-0.3.0}/README.rst

@@ -79,6 +79,7 @@ More examples are in the ``examples`` folder of the repository:
 - ``example.py``: interfaces, typedefs, unions and structs
 - ``union_example.py``: unions (discriminator kinds, case and ``default`` labels, member types)
 - ``annotation_example.py``: IDL 4 annotations (``@key``, ``@range``, ...) and struct keys
+- ``scoped_name_example.py``: same-named types in several modules (relative ``X``, ``C::X`` and absolute ``::B::X`` names)
 
 https://github.com/sugarsweetrobotics/idl_parser/tree/main/examples
 

idl_parser-0.3.0/examples/scoped_name_example.py

@@ -0,0 +1,121 @@
+"""Example: resolve type names across modules (relative and absolute names).
+
+When several modules define a type with the same name, a type name is
+resolved with the IDL scoping rules (issues #69, #72):
+
+- a relative name (``X``, ``C::X``) is looked up from the scope where it is
+  written, innermost first, then in the outer scopes;
+- an absolute name (``::B::X``) is looked up from the global scope only.
+
+Shows how to get
+- the definition a member, argument or return type refers to (``obj`` / ``type``),
+- the name as written (``ref_name``) and the name of the definition (``name``),
+- a typedef resolved in the scope where it is defined,
+- ``find_types()`` with and without a scope.
+
+Run::
+
+    python examples/scoped_name_example.py
+"""
+import _path  # noqa: F401  (use the idl_parser of this checkout)
+
+from idl_parser import parser
+
+IDL = '''
+// A global Point, and a Point in each module
+struct Point { long id; };
+
+module geometry {
+  struct Point { double x; double y; };
+  typedef Point Origin;       // geometry::Point (the scope of the typedef)
+
+  module d3 {
+    struct Point { double x; double y; double z; };
+  };
+};
+
+module robot {
+  struct Point { long joint; };
+
+  module arm {
+    struct Point { double angle; };
+
+    interface Controller {
+      // relative names: looked up from robot::arm, then robot, then global
+      Point            current();                    // robot::arm::Point
+      void             move_joint(in robot::Point p);  // robot::Point
+      void             move_to(in geometry::Point p);  // geometry::Point
+      void             move_to_3d(in geometry::d3::Point p);
+      // absolute names: from the global scope only
+      void             mark(in ::Point p);           // the global Point
+      void             move_arm(in ::robot::arm::Point p);
+      geometry::Origin origin();                     // typedef of geometry::Point
+    };
+  };
+
+  struct Pose {
+    Point                    joint;     // robot::Point
+    arm::Point               arm;       // relative name with a scope: robot::arm::Point
+    sequence<geometry::Point> path;     // element type is resolved too
+    ::Point                  marker;    // the global Point
+  };
+};
+'''
+
+
+def path(node):
+    """Full path of a definition ('' for the global scope is shown as '::')."""
+    p = node.full_path.lstrip(':')
+    return p if '::' in p else '::' + p
+
+
+def show(label, written, definition):
+    print('  %-22s %-24s -> %s' % (label, written, path(definition)))
+
+
+def main():
+    global_module = parser.IDLParser().load(IDL)
+    robot = global_module.module_by_name('robot')
+    arm = robot.module_by_name('arm')
+
+    print('robot::arm::Controller (name as written -> definition)')
+    controller = arm.interface_by_name('Controller')
+    for method in controller.methods:
+        if method.returns.name != 'void':
+            show(method.name + '() returns', method.returns.ref_name, method.returns.obj)
+        for a in method.arguments:
+            show(method.name + '(' + a.name + ')', a.type.ref_name, a.type.obj)
+    print()
+
+    # For a struct member, .type is the definition itself
+    print('robot::Pose members (member -> definition)')
+    pose = robot.struct_by_name('Pose')
+    for m in pose.members:
+        t = m.type
+        if t.is_sequence:
+            print('  %-22s -> sequence of %s' % (m.name, path(t.inner_type.obj)))
+        else:
+            print('  %-22s -> %s' % (m.name, path(t)))
+    print()
+
+    # The typedef is resolved where it is defined (module geometry),
+    # not where it is used (module robot::arm).
+    typedef = controller.method_by_name('origin').returns.obj
+    print('typedef %s -> %s' % (path(typedef), path(typedef.type)))
+    print()
+
+    # type.name is the name of the definition, without its scope
+    t = controller.method_by_name('move_to').arguments[0].type
+    print('name: %s, ref_name: %s, full path: %s' % (t.name, t.ref_name, path(t.obj)))
+    print()
+
+    # find_types(): with a scope the IDL scoping rules are used;
+    # without one, every definition with that name is returned.
+    print('find_types("Point", scope=robot::arm):', [path(n) for n in global_module.find_types('Point', scope=arm)])
+    print('find_types("Point", scope=robot):     ', [path(n) for n in global_module.find_types('Point', scope=robot)])
+    print('find_types("::Point"):                ', [path(n) for n in global_module.find_types('::Point')])
+    print('find_types("Point") (no scope):       ', sorted(path(n) for n in global_module.find_types('Point')))
+
+
+if __name__ == '__main__':
+    main()

{idl_parser-0.2.2 → idl_parser-0.3.0}/idl_parser/const.py

@@ -35,7 +35,7 @@ class IDLConst(node.IDLNode):
 
     @property
     def type(self):
-        return self.root_node.find_types(self.typename)[0]
+        return self.root_node.find_types(self.typename, scope=self)[0]
     @property
     def value(self):
         return self._value

{idl_parser-0.2.2 → idl_parser-0.3.0}/idl_parser/enum.py

@@ -54,6 +54,8 @@ class IDLEnum(node.IDLNode):
         if quiet:
             return 'enum %s' % name
         dic = { 'enum %s' % name : [v.to_simple_dic() for v in self.values] }
+        if member_only:
+            return list(dic.values())[0]
         return dic
 
 

{idl_parser-0.2.2 → idl_parser-0.3.0}/idl_parser/module.py

@@ -461,29 +461,68 @@ class IDLModule(node.IDLNode):
         for m in self.typedefs:
             retval.append(func(m))
 
-    def find_types(self, full_typename, parent=None):
+    def find_types(self, full_typename, parent=None, scope=None):
+        """Return the type definitions named ``full_typename`` (a list).
+
+        ``scope`` is the node where the name is written (issue #72). When it
+        is given, the name is resolved with the IDL scoping rules: it is
+        looked up in the innermost enclosing scope first, then in the outer
+        ones (``X`` in module ``B`` finds ``B::X`` before ``X`` elsewhere).
+        A name starting with ``::`` is looked up from the global scope only.
+        If the scoping rules find nothing, every definition whose name or
+        full path is ``full_typename`` is returned, as before.
+        """
         if type.is_primitive(full_typename):
             return [type.IDLType(full_typename, self)]
-        typenode = []
-
-        def parse_node(s, name=str(full_typename)):
-            if parent:
-                if parent.full_path + '::' + name.strip() == s.full_path or name.strip() == s.full_path:
-                    typenode.append(s)
-            else:
-                if s.name == name.strip() or s.full_path == name.strip():
-                    typenode.append(s)
-
+        # A fully qualified name may start with '::' ("::M::A", issue #69).
+        # full_path has no leading '::' ("M::A"), so drop it before comparing.
+        name = str(full_typename).strip()
+        absolute = name.startswith('::')
+        if absolute:
+            name = name.lstrip(':').strip()
+
+        nodes = []
         def parse_module(m):
             m.for_each_module(parse_module)
-            m.for_each_struct(parse_node)
-            m.for_each_typedef(parse_node)
-            m.for_each_enum(parse_node)
-            m.for_each_bitmask(parse_node)
-            m.for_each_bitset(parse_node)
-            m.for_each_union(parse_node)
-            m.for_each_interface(parse_node)
-
+            for each in (m.for_each_struct, m.for_each_typedef, m.for_each_enum,
+                         m.for_each_bitmask, m.for_each_bitset, m.for_each_union,
+                         m.for_each_interface):
+                each(nodes.append)
         parse_module(self)
 
-        return typenode
+        def with_full_path(full):
+            return [s for s in nodes if s.full_path.lstrip(':') == full]
+
+        if absolute:
+            # '::X' always names X from the global scope
+            return with_full_path(name)
+
+        if scope is not None:
+            for prefix in _enclosing_scopes(scope):
+                found = with_full_path(prefix + sep + name if prefix else name)
+                if len(found) > 0:
+                    return found
+
+        if parent:
+            prefix = parent.full_path.lstrip(':')
+            return [s for s in nodes
+                    if s.full_path.lstrip(':') in ((prefix + sep + name if prefix else name), name)]
+        return [s for s in nodes if s.name == name or s.full_path.lstrip(':') == name]
+
+
+_scope_classnames = ('IDLModule', 'IDLStruct', 'IDLUnion', 'IDLInterface')
+
+def _enclosing_scopes(node):
+    """Full paths (without a leading '::') of the scopes enclosing ``node``,
+    innermost first and ending with the global scope ('')."""
+    scopes = []
+    n = node
+    while n is not None:
+        if n.classname in _scope_classnames:
+            path = n.full_path.lstrip(':')
+            if path not in scopes:
+                scopes.append(path)
+        n = n.parent
+    if '' not in scopes:
+        scopes.append('')
+    return scopes

{idl_parser-0.2.2 → idl_parser-0.3.0}/idl_parser/node.py

@@ -308,9 +308,49 @@ class IDLNode(object):
         walk(self.root_node)
         return len(found) > 0
 
+    def check_element_types(self, typ):
+        """Raise InvalidDataTypeException if an element type of the sequence
+        or array ``typ`` (nested ones included) is not declared (issue #67).
+
+        A type that has been forward-declared ("interface A;", "struct A;",
+        "union A;") may be used before its definition, as with a direct member.
+        """
+        from . import exception
+        while getattr(typ, 'is_sequence', False) or getattr(typ, 'is_array', False):
+            typ = typ.inner_type
+            if typ.classname != 'IDLBasicType':
+                continue
+            name = typ.name.strip()
+            if name.startswith(self.sep):
+                name = name[len(self.sep):]
+            if len(typ.resolve()) > 0:
+                continue
+            if self.is_pending_forward_declaration(name):
+                continue
+            if self._is_enclosing_definition(name):
+                continue # recursive type: "struct Node { sequence<Node> children; };"
+            print('Can not find Data Type (%s)\n' % typ.name)
+            raise exception.InvalidDataTypeException(
+                message='Can not find Data Type (%s)' % typ.name)
+
+    def _is_enclosing_definition(self, name):
+        """True if name is a struct or union that encloses this node and is
+        still being parsed (so it is not registered in its module yet)."""
+        n = self.parent
+        while n is not None and not n.is_root:
+            if n.classname in ('IDLStruct', 'IDLUnion'):
+                if name == n.name or name == n.full_path.lstrip(':'):
+                    return True
+            n = n.parent
+        return False
+
     def refine_typename(self, typ):
         return self._refine_typename(typ.name)
 
+    def _lookup_scope(self):
+        """The node whose scope type names written here are resolved from."""
+        return self
+
     def _refine_typename(self, name):
         from . import type as idl_type
         name = name.strip()
@@ -323,7 +363,7 @@ class IDLNode(object):
         bounded = idl_type.parse_bounded_string(name)
         if bounded is not None:
             return bounded[0]
-        typs = self.root_node.find_types(name)
+        typs = self.root_node.find_types(name, scope=self._lookup_scope())
         if len(typs) == 0:
             # Not resolvable yet (e.g. a forward-declared interface): keep the name
             return name

{idl_parser-0.2.2 → idl_parser-0.3.0}/idl_parser/struct.py

@@ -41,8 +41,6 @@ class IDLMember(node.IDLNode):
         if recursive:
             if self.type.is_primitive:
                 return str(self.type) + ' ' + self.name
-            elif self.type.obj.is_enum:
-                return str('enum') + ' ' + self.name
             dic = {str(self.type) +' ' + self.name :
                    self.type.obj.to_simple_dic(recursive=recursive, member_only=True)}
             return dic
@@ -59,16 +57,10 @@ class IDLMember(node.IDLNode):
     @property
     def type(self):
         if self._type.classname == 'IDLBasicType': # Struct
-            typs = self.root_node.find_types(self._type.name)
+            typs = self._type.resolve() # from this member's scope (issue #72)
             if len(typs) == 0:
-                print('Can not find Data Type (%s)\n' % self._type.name)
+                print('Can not find Data Type (%s)\n' % self._type.ref_name)
                 raise exception.InvalidDataTypeException()
-            elif len(typs) > 1:
-                typs = self.root_node.find_types(self._type.name, parent=self.parent.parent)
-                if len(typs) == 0:
-                    print('Can not find Data Type (%s)\n' % self._type.name)
-                    raise exception.InvalidDataTypeException()
-
             return typs[0]
         return self._type
 
@@ -83,6 +75,7 @@ class IDLMember(node.IDLNode):
     def post_process(self):
         if self._type.classname == 'IDLBasicType' and self.is_pending_forward_declaration(self._type.name):
             return # forward-declared type; resolved via .type once it is defined
+        self.check_element_types(self._type) # sequence / array elements (issue #67)
         self._type._name = self.refine_typename(self.type)
 
 

{idl_parser-0.2.2 → idl_parser-0.3.0}/idl_parser/type.py

@@ -383,16 +383,33 @@ class IDLPrimitive(IDLTypeBase):
         return (self.parent.full_path + self.sep + self.name).strip()
 class IDLBasicType(IDLTypeBase):
     def __init__(self, name, parent):
+        # The node where the name is written: the name is resolved from its
+        # scope (issue #72). The parent of a type node is the root node.
+        self._scope = parent
+        self._ref_name = name.strip()
         super(IDLBasicType, self).__init__('IDLBasicType', name, parent.root_node)
         self._verbose = True
         #if self.name.find('['):
         #    self._name = self.name[self.name.find('[')+1:]
         self._name = self.refine_typename(self)
 
+    @property
+    def ref_name(self):
+        """The type name as written (``'A::X'``, ``'::B::X'``). ``name`` is
+        the name of the definition without its scope (``'X'``)."""
+        return self._ref_name
+
+    def _lookup_scope(self):
+        return self._scope
+
+    def resolve(self):
+        """The definitions this name refers to, found from the scope where
+        it is written (a list; empty if it is not defined)."""
+        return self.root_node.find_types(self._ref_name, scope=self._scope)
+
     @property
     def obj(self):
-        global_module = self.root_node
-        typs = global_module.find_types(self.name)
+        typs = self.resolve()
         if len(typs) == 0:
             return None
         else:

{idl_parser-0.2.2 → idl_parser-0.3.0}/idl_parser/typedef.py

@@ -40,7 +40,13 @@ class IDLTypedef(node.IDLNode):
     @property
     def type(self):
         if self._type.classname == 'IDLBasicType': # Struct
-            return self.root_node.find_types(self._type.name)[0]
+            typs = self._type.resolve() # from this typedef's scope (issue #72)
+            if len(typs) == 0:
+                # issue #69: report an unknown type instead of an IndexError
+                from . import exception
+                raise exception.InvalidDataTypeException(
+                    message='Can not find Data Type (%s)' % self._type.ref_name)
+            return typs[0]
         return self._type
 
     def get_type(self, extract_typedef=False):
@@ -83,4 +89,5 @@ class IDLTypedef(node.IDLNode):
     def _post_process(self):
         if self._type.classname == 'IDLBasicType' and self.is_pending_forward_declaration(self._type.name):
             return # forward-declared type; resolved via .type once it is defined
+        self.check_element_types(self._type) # sequence / array elements (issue #67)
         self._type._name = self.refine_typename(self.type)

{idl_parser-0.2.2 → idl_parser-0.3.0}/idl_parser/union.py

@@ -52,8 +52,6 @@ class IDLUnionMember(node.IDLNode):
         if recursive:
             if self.type.is_primitive:
                 return str(self.type) + ' ' + self.name
-            elif self.type.obj.is_enum:
-                return str('enum') + ' ' + self.name
             dic = {str(self.type) +' ' + self.name :
                    self.type.obj.to_simple_dic(recursive=recursive, member_only=True)}
             return dic
@@ -72,9 +70,9 @@ class IDLUnionMember(node.IDLNode):
     @property
     def type(self):
         if self._type.classname == 'IDLBasicType': # Union
-            typs = self.root_node.find_types(self._type.name)
+            typs = self._type.resolve() # from this member's scope (issue #72)
             if len(typs) == 0:
-                print('Can not find Data Type (%s)\n' % self._type.name)
+                print('Can not find Data Type (%s)\n' % self._type.ref_name)
                 raise exception.InvalidDataTypeException()
             return typs[0]
         return self._type
@@ -98,6 +96,7 @@ class IDLUnionMember(node.IDLNode):
     def post_process(self):
         if self._type.classname == 'IDLBasicType' and self.is_pending_forward_declaration(self._type.name):
             return # forward-declared type; resolved via .type once it is defined
+        self.check_element_types(self._type) # sequence / array elements (issue #67)
         self._type._name = self.refine_typename(self.type)
 
 class IDLUnion(node.IDLNode):

{idl_parser-0.2.2 → idl_parser-0.3.0/idl_parser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idl_parser
-Version: 0.2.2
+Version: 0.3.0
 Summary: Very simple OMG IDL (Interface Definition Language) parser. This parses IDL files and outputs intermediate class objects.
 Author-email: ysuga <ysuga@ysuga.net>
 License-Expression: GPL-3.0-or-later
@@ -102,6 +102,7 @@ More examples are in the ``examples`` folder of the repository:
 - ``example.py``: interfaces, typedefs, unions and structs
 - ``union_example.py``: unions (discriminator kinds, case and ``default`` labels, member types)
 - ``annotation_example.py``: IDL 4 annotations (``@key``, ``@range``, ...) and struct keys
+- ``scoped_name_example.py``: same-named types in several modules (relative ``X``, ``C::X`` and absolute ``::B::X`` names)
 
 https://github.com/sugarsweetrobotics/idl_parser/tree/main/examples
 

{idl_parser-0.2.2 → idl_parser-0.3.0}/idl_parser.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ docs/api/index.rst
 examples/_path.py
 examples/annotation_example.py
 examples/example.py
+examples/scoped_name_example.py
 examples/union_example.py
 idl_parser/__init__.py
 idl_parser/bitmask.py
@@ -57,6 +58,10 @@ tests/issue50_test.py
 tests/issue52_test.py
 tests/issue53_test.py
 tests/issue57_test.py
+tests/issue60_test.py
+tests/issue67_test.py
+tests/issue69_test.py
+tests/issue72_test.py
 tests/issue9_test.py
 tests/key_annotation_test.py
 tests/module_test.py

{idl_parser-0.2.2 → idl_parser-0.3.0}/idl_parser.egg-info/scm_file_list.json

@@ -14,6 +14,7 @@
     "examples/_path.py",
     "examples/annotation_example.py",
     "examples/example.py",
+    "examples/scoped_name_example.py",
     "examples/union_example.py",
     "idl_parser/__init__.py",
     "idl_parser/bitmask.py",
@@ -72,6 +73,10 @@
     "tests/issue52_test.py",
     "tests/issue53_test.py",
     "tests/issue57_test.py",
+    "tests/issue60_test.py",
+    "tests/issue67_test.py",
+    "tests/issue69_test.py",
+    "tests/issue72_test.py",
     "tests/issue9_test.py",
     "tests/key_annotation_test.py",
     "tests/module_test.py",

{idl_parser-0.2.2 → idl_parser-0.3.0}/idl_parser.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.2.2",
+  "tag": "0.3.0",
   "distance": 0,
-  "node": "g58eea3fbf48f5d5a8a6c1178dde50925ecfded03",
+  "node": "g0f3a257197ff60ce02868622378b3843fa21c028",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-07"

{idl_parser-0.2.2 → idl_parser-0.3.0}/tests/examples_test.py

@@ -50,7 +50,8 @@ class ExamplesRunAsScriptTest(unittest.TestCase):
 
     def test_examples_exist(self):
         names = [os.path.basename(p) for p in example_scripts()]
-        for name in ('example.py', 'union_example.py', 'annotation_example.py'):
+        for name in ('example.py', 'union_example.py', 'annotation_example.py',
+                     'scoped_name_example.py'):
             self.assertIn(name, names)
 
     def test_each_example_runs_as_script(self):
@@ -174,5 +175,44 @@ class AnnotationExampleTest(unittest.TestCase):
         self.assertIn('"APPENDABLE"', self.text)
 
 
+class ScopedNameExampleTest(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.text = run_main('scoped_name_example')
+
+    def assertResolved(self, label, written, definition):
+        for line in self.text.splitlines():
+            if line.split() == [*label.split(), written, '->', definition]:
+                return
+        self.fail('no line for %s %s -> %s in output:\n%s' % (label, written, definition, self.text))
+
+    def test_relative_names(self):
+        self.assertResolved('current() returns', 'Point', 'robot::arm::Point')
+        self.assertResolved('move_joint(p)', 'robot::Point', 'robot::Point')
+        self.assertResolved('move_to(p)', 'geometry::Point', 'geometry::Point')
+        self.assertResolved('move_to_3d(p)', 'geometry::d3::Point', 'geometry::d3::Point')
+
+    def test_absolute_names(self):
+        self.assertResolved('mark(p)', '::Point', '::Point')
+        self.assertResolved('move_arm(p)', '::robot::arm::Point', 'robot::arm::Point')
+
+    def test_struct_members(self):
+        self.assertIn('  joint                  -> robot::Point', self.text)
+        self.assertIn('  arm                    -> robot::arm::Point', self.text)
+        self.assertIn('  path                   -> sequence of geometry::Point', self.text)
+        self.assertIn('  marker                 -> ::Point', self.text)
+
+    def test_typedef_and_names(self):
+        self.assertIn('typedef geometry::Origin -> geometry::Point', self.text)
+        self.assertIn('name: Point, ref_name: geometry::Point, full path: geometry::Point', self.text)
+
+    def test_find_types(self):
+        self.assertIn("scope=robot::arm): ['robot::arm::Point']", self.text)
+        self.assertIn("scope=robot):      ['robot::Point']", self.text)
+        self.assertIn("(no scope):        ['::Point', 'geometry::Point', 'geometry::d3::Point', "
+                      "'robot::Point', 'robot::arm::Point']", self.text)
+
+
 if __name__ == '__main__':
     unittest.main()

{idl_parser-0.2.2 → idl_parser-0.3.0}/tests/issue30_test.py

@@ -68,7 +68,7 @@ class MemberTypeSimpleDicTest(unittest.TestCase):
             'WithSeqInline': [{'sequence<long> q': {'sequence<long>': 'long'}}],
             'WithArray': [{'long[3] a': 'long[3]'}],
             'WithStruct': [{'T t': ['long s']}],
-            'WithEnum': ['enum e'],
+            'WithEnum': [{'E e': [{'A': 0}, {'B': 1}]}],
             'WithBitmask': [{'F f': [{'F1': 0}, {'F2': 1}]}],
             'WithBitset': [{'BS bs': [{'b': 'bitfield<3, octet>'}]}],
             'WithSeqTypedef': [{'DSeq d': {'typedef sequence<double> DSeq':

idl_parser-0.3.0/tests/issue60_test.py

@@ -0,0 +1,64 @@
+"""to_simple_dic(recursive=True) expands enum members like other types (issue #60).
+
+A direct enum member used to become ``'enum <member name>'`` (no type name,
+no values), while ``sequence<E>`` / typedef of an enum expanded the values.
+Enum members now expand the same way as struct and bitmask members.
+"""
+import unittest
+
+from idl_parser import parser
+
+IDL = '''
+module M {
+  enum E { A, B };
+  bitmask F { F1, F2 };
+  typedef E EAlias;
+  typedef sequence<E> ESeq;
+  struct S { E e; sequence<E> se; EAlias ea; ESeq es; F f; };
+  union U switch (E) { case A: E ue; case B: long l; };
+};
+'''
+
+VALUES = [{'A': 0}, {'B': 1}]
+
+
+class EnumMemberSimpleDicTest(unittest.TestCase):
+
+    def setUp(self):
+        self.m = parser.IDLParser().load(IDL).module_by_name('M')
+
+    def _members(self):
+        return self.m.struct_by_name('S').to_simple_dic(recursive=True)['struct S']
+
+    def test_direct_member(self):
+        self.assertEqual(self._members()[0], {'E e': VALUES})
+
+    def test_sequence_of_enum(self):
+        self.assertEqual(self._members()[1], {'sequence<E> se': {'sequence<E>': VALUES}})
+
+    def test_typedef_of_enum(self):
+        self.assertEqual(self._members()[2], {'EAlias ea': {'typedef E EAlias': VALUES}})
+
+    def test_typedef_of_sequence_of_enum(self):
+        self.assertEqual(self._members()[3],
+                         {'ESeq es': {'typedef sequence<E> ESeq': {'sequence<E>': VALUES}}})
+
+    def test_same_shape_as_bitmask(self):
+        self.assertEqual(self._members()[4], {'F f': [{'F1': 0}, {'F2': 1}]})
+
+    def test_union_member(self):
+        self.assertEqual(self.m.union_by_name('U').to_simple_dic(recursive=True),
+                         {'union U': [{'E ue': VALUES}, 'long l']})
+
+    def test_enum_itself_unchanged(self):
+        e = self.m.enum_by_name('E')
+        self.assertEqual(e.to_simple_dic(), {'enum E': VALUES})
+        self.assertEqual(e.to_simple_dic(member_only=True), VALUES)
+        self.assertEqual(e.to_simple_dic(quiet=True), 'enum E')
+
+    def test_non_recursive_unchanged(self):
+        self.assertEqual(self.m.struct_by_name('S').to_simple_dic()['struct S'][0], {'e': 'E'})
+
+
+if __name__ == '__main__':
+    unittest.main()