Better variable name, self -> doc.

[python-bulletml.git] / bulletml / parser.py

diff --git a/bulletml/parser.py b/bulletml/parser.py
index 51e15ad..e9b0488 100644 (file)
--- a/bulletml/parser.py
+++ b/bulletml/parser.py
@@ -394,7 +394,7 @@ class BulletDef(object):
             elif tag == "actionRef":
                 actions.append(ActionRef.FromXML(doc, subelem))
         dfn = cls(actions, direction, speed)
-        doc.bullets[element.get("label")] = dfn
+        doc._bullets[element.get("label")] = dfn
         return dfn
 
     def __call__(self, params, rank):
@@ -478,7 +478,7 @@ class ActionDef(object):
             else:
                 actions.append(ctr.FromXML(doc, subelem))
         dfn = cls(actions)
-        doc.actions[element.get("label")] = dfn
+        doc._actions[element.get("label")] = dfn
         return dfn
 
     def __call__(self, params, rank):
@@ -584,7 +584,7 @@ class FireDef(object):
         try:
             params = self.bullet.params
         except AttributeError:
-            state = dict(bullet=self.bullet)
+            state.append(('bullet', self.bullet))
         else:
             if params.params:
                 state.append(('bullet', self.bullet))
@@ -621,7 +621,7 @@ class FireDef(object):
         except UnboundLocalError as exc:
             raise ParseError(str(exc))
         else:
-            doc.fires[element.get("label")] = fire
+            doc._fires[element.get("label")] = fire
             return fire
 
     def __call__(self, params, rank):
@@ -674,8 +674,8 @@ class FireRef(object):
 class BulletML(object):
     """BulletML document.
 
-    A BulletML document is a collection of bullets, actions, and
-    firings, as well as a base game type.
+    A BulletML document is a collection of top-level actions and the
+    base game type.
 
     You can add tags to the BulletML.CONSTRUCTORS dictionary to extend
     its parsing. It maps tag names to classes with a FromXML
@@ -690,11 +690,9 @@ class BulletML(object):
         fire=FireDef,
         )
 
-    def __init__(self, type="none", bullets=None, fires=None, actions=None):
+    def __init__(self, type="none", actions=None):
         self.type = type
-        self.bullets = {} if bullets is None else bullets
-        self.actions = {} if actions is None else actions
-        self.fires = {} if fires is None else fires
+        self.actions = [] if actions is None else actions
 
     def __getstate__(self):
         return [('type', self.type), ('actions', self.actions)]
@@ -712,36 +710,41 @@ class BulletML(object):
         tree = ElementTree()
         root = tree.parse(source)
 
-        self = cls(type=root.get("type", "none"))
+        doc = cls(type=root.get("type", "none"))
 
-        self._bullet_refs = []
-        self._action_refs = []
-        self._fire_refs = []
+        doc._bullets = {}
+        doc._actions = {}
+        doc._fires = {}
+        doc._bullet_refs = []
+        doc._action_refs = []
+        doc._fire_refs = []
 
         for element in root.getchildren():
             tag = realtag(element)
-            if tag in self.CONSTRUCTORS:
-                self.CONSTRUCTORS[tag].FromXML(self, element)
+            if tag in doc.CONSTRUCTORS:
+                doc.CONSTRUCTORS[tag].FromXML(doc, element)
 
         try:
-            for ref in self._bullet_refs:
-                ref.bullet = self.bullets[ref.bullet]
-            for ref in self._fire_refs:
-                ref.fire = self.fires[ref.fire]
-            for ref in self._action_refs:
-                ref.action = self.actions[ref.action]
+            for ref in doc._bullet_refs:
+                ref.bullet = doc._bullets[ref.bullet]
+            for ref in doc._fire_refs:
+                ref.fire = doc._fires[ref.fire]
+            for ref in doc._action_refs:
+                ref.action = doc._actions[ref.action]
         except KeyError as exc:
             raise ParseError("unknown reference %s" % exc)
 
-        del(self._bullet_refs)
-        del(self._action_refs)
-        del(self._fire_refs)
+        doc.actions = [act for name, act in doc._actions.items()
+                        if name and name.startswith("top")]
 
-        self.bullets.pop(None, None)
-        self.actions.pop(None, None)
-        self.fires.pop(None, None)
-
-        return self
+        del(doc._bullet_refs)
+        del(doc._action_refs)
+        del(doc._fire_refs)
+        del(doc._bullets)
+        del(doc._actions)
+        del(doc._fires)
+        
+        return doc
 
     @classmethod
     def FromYAML(cls, source):
@@ -776,16 +779,9 @@ class BulletML(object):
         else:
             raise ParseError("unknown initial character %r" % start)
 
-    @property
-    def top(self):
-        """Get a list of all top-level actions."""
-        return [dfn for name, dfn in self.actions.items()
-                if name and name.startswith("top")]
-
     def __repr__(self):
-        return "%s(type=%r, bullets=%r, actions=%r, fires=%r)" % (
-            type(self).__name__, self.type, self.bullets, self.actions,
-            self.fires)
+        return "%s(type=%r, actions=%r)" % (
+            type(self).__name__, self.type, self.actions)
 
 ActionDef.CONSTRUCTORS = dict(
     repeat=Repeat,