Move tagname lowering from parser to builder

aradi · aradi · commit e503e6ac53fa · 2021-11-03T13:43:44.000+01:00
diff --git a/src/hsd/dict.py b/src/hsd/dict.py
@@ -9,7 +9,7 @@
 """
 import re
 from typing import List, Tuple, Union
-from hsd.common import np, ATTRIB_SUFFIX, HSD_ATTRIB_SUFFIX, HsdError,\
+from hsd.common import HSD_ATTRIB_NAME, np, ATTRIB_SUFFIX, HSD_ATTRIB_SUFFIX, HsdError,\
     QUOTING_CHARS, SPECIAL_CHARS
 from hsd.eventhandler import HsdEventHandler, HsdEventPrinter
 
@@ -42,14 +42,16 @@ class HsdDictBuilder(HsdEventHandler):
 
     Args:
         flatten_data: Whether multiline data in the HSD input should be
-            flattened into a single list. Othewise a list of lists is created,
-            with one list for every line (default).
-        include_hsd_attribs: Whether the HSD-attributes (processing related
-            attributes, like original tag name, line information, etc.) should
-            be stored.
+            flattened into a single list. Othewise a list of lists is created, with one list for
+            every line (default).
+        lower_tag_names: Whether tag names should be all converted to lower case (to ease case
+            insensitive processing). Default: False. If set and include_hsd_attribs is also set,
+            the original tag names can be retrieved from the "name" hsd attributes.
+        include_hsd_attribs: Whether the HSD-attributes (processing related attributes, like
+            original tag name, line information, etc.) should be stored (default: False).
     """
 
-    def __init__(self, flatten_data: bool = False,
+    def __init__(self, flatten_data: bool = False, lower_tag_names: bool = False,
                  include_hsd_attribs: bool = False):
         super().__init__()
         self._hsddict: dict = {}
@@ -58,6 +60,7 @@ def __init__(self, flatten_data: bool = False,
         self._data: Union[None, _DataType] = None
         self._attribs: List[Tuple[str, dict]] = []
         self._flatten_data: bool = flatten_data
+        self._lower_tag_names: bool = lower_tag_names
         self._include_hsd_attribs: bool = include_hsd_attribs
 
 
@@ -79,46 +82,49 @@ def open_tag(self, tagname, attrib, hsdattrib):
     def close_tag(self, tagname):
         attrib, hsdattrib = self._attribs.pop(-1)
         parentblock = self._parentblocks.pop(-1)
+        key = tagname.lower() if self._lower_tag_names else tagname
         prevcont = parentblock.get(tagname)
+
         if self._data is not None:
             if prevcont is None:
-                parentblock[tagname] = self._data
+                parentblock[key] = self._data
             elif isinstance(prevcont, list) and len(prevcont) > 0 and isinstance(prevcont[0], dict):
                 prevcont.append({None: self._data})
             elif isinstance(prevcont, dict):
-                parentblock[tagname] = [prevcont, {None: self._data}]
+                parentblock[key] = [prevcont, {None: self._data}]
             else:
-                parentblock[tagname] = [{None: prevcont}, {None: self._data}]
+                parentblock[key] = [{None: prevcont}, {None: self._data}]
         else:
             if prevcont is None:
-                parentblock[tagname] = self._curblock
+                parentblock[key] = self._curblock
             elif isinstance(prevcont, list) and len(prevcont) > 0 and isinstance(prevcont[0], dict):
                 prevcont.append(self._curblock)
             elif isinstance(prevcont, dict):
-                parentblock[tagname] = [prevcont, self._curblock]
+                parentblock[key] = [prevcont, self._curblock]
             else:
-                parentblock[tagname] = [{None: prevcont}, self._curblock]
+                parentblock[key] = [{None: prevcont}, self._curblock]
 
-        if prevcont is None:
-            if attrib:
-                parentblock[tagname + ATTRIB_SUFFIX] = attrib
-            if self._include_hsd_attribs:
-                parentblock[tagname + HSD_ATTRIB_SUFFIX] = hsdattrib
-        else:
-            prevattrib = parentblock.get(tagname + ATTRIB_SUFFIX)
+        if attrib and prevcont is None:
+            parentblock[key + ATTRIB_SUFFIX] = attrib
+        elif prevcont is not None:
+            prevattrib = parentblock.get(key + ATTRIB_SUFFIX)
             if isinstance(prevattrib, list):
                 prevattrib.append(attrib)
             else:
-                parentblock[tagname + ATTRIB_SUFFIX] = [prevattrib, attrib]
-                print(f"parentblock[{tagname} + {ATTRIB_SUFFIX}] = [{prevattrib}, {attrib}]")
+                parentblock[key + ATTRIB_SUFFIX] = [prevattrib, attrib]
 
-            if self._include_hsd_attribs:
-                prevhsdattrib = parentblock.get(tagname + HSD_ATTRIB_SUFFIX)
+        if self._include_hsd_attribs:
+            if self._lower_tag_names:
+                hsdattrib = {} if hsdattrib is None else hsdattrib
+                hsdattrib[HSD_ATTRIB_NAME] = tagname
+            if prevcont is None:
+                parentblock[key + HSD_ATTRIB_SUFFIX] = hsdattrib
+            else:
+                prevhsdattrib = parentblock.get(key + HSD_ATTRIB_SUFFIX)
                 if isinstance(prevhsdattrib, list):
                     prevhsdattrib.append(hsdattrib)
                 else:
-                    parentblock[tagname + HSD_ATTRIB_SUFFIX] = [prevhsdattrib,
-                                                                hsdattrib]
+                    parentblock[key + HSD_ATTRIB_SUFFIX] = [prevhsdattrib, hsdattrib]
         self._curblock = parentblock
         self._data = None
 
diff --git a/src/hsd/io.py b/src/hsd/io.py
@@ -43,10 +43,9 @@ def load(hsdfile: Union[TextIO, str], lower_tag_names: bool = False,
     Examples:
         See :func:`hsd.load_string` for examples of usage.
     """
-    dictbuilder = HsdDictBuilder(flatten_data=flatten_data,
+    dictbuilder = HsdDictBuilder(lower_tag_names=lower_tag_names, flatten_data=flatten_data,
                                  include_hsd_attribs=include_hsd_attribs)
-    parser = HsdParser(eventhandler=dictbuilder,
-                       lower_tag_names=lower_tag_names)
+    parser = HsdParser(eventhandler=dictbuilder)
     if isinstance(hsdfile, str):
         with open(hsdfile, "r") as hsddescr:
             parser.parse(hsddescr)
diff --git a/src/hsd/parser.py b/src/hsd/parser.py
@@ -29,9 +29,6 @@ class HsdParser:
     Arguments:
         eventhandler: Object which should handle the HSD-events triggered
             during parsing. When not specified, HsdEventPrinter() is used.
-        lower_tag_names: Whether tag names should be lowered during parsing.
-            If the option is set, the original tag name will be stored among
-            the hsd attributes.
 
     Examples:
         >>> from io import StringIO
@@ -53,8 +50,7 @@ class HsdParser:
         {'Temperature': 100, 'Temperature.attrib': 'Kelvin'}}}}}
     """
 
-    def __init__(self, eventhandler: Optional[HsdEventHandler] = None,
-        lower_tag_names: bool = False):
+    def __init__(self, eventhandler: Optional[HsdEventHandler] = None):
         """Initializes the parser.
 
         Args:
@@ -79,7 +75,6 @@ def __init__(self, eventhandler: Optional[HsdEventHandler] = None,
         self._has_child = True             # Whether current node has a child already
         self._has_text = False             # whether current node contains text already
         self._oldbefore = ""               # buffer for tagname
-        self._lower_tag_names = lower_tag_names  # whether tag names should be lower cased
 
 
     def parse(self, fobj: Union[TextIO, str]):
@@ -258,9 +253,6 @@ def _starttag(self, tagname, closeprev):
         if len(tagname_stripped.split()) > 1:
             self._error(SYNTAX_ERROR, (self._currline, self._currline))
         self._hsdattrib[common.HSD_ATTRIB_LINE] = self._currline
-        if self._lower_tag_names:
-            self._hsdattrib[common.HSD_ATTRIB_NAME] = tagname_stripped
-            tagname_stripped = tagname_stripped.lower()
         self._eventhandler.open_tag(tagname_stripped, self._attrib,
                                     self._hsdattrib)
         self._opened_tags.append(
diff --git a/test/test_dict.py b/test/test_dict.py
@@ -137,7 +137,7 @@
     _TESTS_NO_HSDATTRIB_CASES,
     ids=_TESTS_NO_HSDATTRIB_NAMES
 )
-def test_builder_nohsdattr(hsdstr, hsddict):
+def test_dict_builder_nohsdattr(hsdstr, hsddict):
     """Test transformation from hsd to dictionary without HSD attributes."""
     dictbuilder = hsd.HsdDictBuilder(include_hsd_attribs=False)
     parser = hsd.HsdParser(eventhandler=dictbuilder)
@@ -151,7 +151,7 @@ def test_builder_nohsdattr(hsdstr, hsddict):
     _TESTS_HSDATTRIB_CASES,
     ids=_TESTS_HSDATTRIB_NAMES
 )
-def test_builder_hsdattr(hsdstr, hsddict):
+def test_dict_builder_hsdattr(hsdstr, hsddict):
     """Test transformation from hsd to dictionary with HSD attributes."""
     dictbuilder = hsd.HsdDictBuilder(include_hsd_attribs=True)
     parser = hsd.HsdParser(eventhandler=dictbuilder)
@@ -165,10 +165,10 @@ def test_builder_hsdattr(hsdstr, hsddict):
     _TESTS_HSDATTRIB_LOWER_CASES,
     ids=_TESTS_HSDATTRIB_LOWER_NAMES
 )
-def test_builder_hsdattr_lower(hsdstr, hsddict):
+def test_dict_builder_hsdattr_lower(hsdstr, hsddict):
     """Test transformation from hsd to dictionary with HSD attributes and case lowering."""
-    dictbuilder = hsd.HsdDictBuilder(include_hsd_attribs=True)
-    parser = hsd.HsdParser(eventhandler=dictbuilder, lower_tag_names=True)
+    dictbuilder = hsd.HsdDictBuilder(include_hsd_attribs=True, lower_tag_names=True)
+    parser = hsd.HsdParser(eventhandler=dictbuilder)
     fobj = io.StringIO(hsdstr)
     parser.parse(fobj)
     assert dictbuilder.hsddict == hsddict
@@ -179,7 +179,7 @@ def test_builder_hsdattr_lower(hsdstr, hsddict):
     _TESTS_HSDATTRIB_CASES,
     ids=_TESTS_HSDATTRIB_NAMES
 )
-def test_walker_hsdattr(hsdstr, hsddict):
+def test_dict_walker_hsdattr(hsdstr, hsddict):
     """Test transformation from dictionary to string using HSD attributes."""
     output = io.StringIO()
     formatter = hsd.HsdFormatter(output, use_hsd_attribs=True)
@@ -193,7 +193,7 @@ def test_walker_hsdattr(hsdstr, hsddict):
     _TESTS_HSDATTRIB_LOWER_CASES,
     ids=_TESTS_HSDATTRIB_LOWER_NAMES
 )
-def test_walker_hsdattr_lower(hsdstr, hsddict):
+def test_dict_walker_hsdattr_lower(hsdstr, hsddict):
     """Test transformation from dictionary to string using HSD attributes."""
     output = io.StringIO()
     formatter = hsd.HsdFormatter(output, use_hsd_attribs=True)
diff --git a/test/test_parser.py b/test/test_parser.py
@@ -50,6 +50,19 @@
             ]
         )
     ),
+    (
+        "Variable", (
+            """$Variable = 12\nValue = $Variable\n""",
+            [
+                (_OPEN_TAG_EVENT, "$Variable", None, {_HSD_LINE: 0, _HSD_EQUAL: True}),
+                (_ADD_TEXT_EVENT, "12"),
+                (_CLOSE_TAG_EVENT, "$Variable"),
+                (_OPEN_TAG_EVENT, "Value", None, {_HSD_LINE: 1, _HSD_EQUAL: True}),
+                (_ADD_TEXT_EVENT, "$Variable"),
+                (_CLOSE_TAG_EVENT, "Value")
+            ]
+        )
+    ),
 ]
 
 _VALID_TEST_NAMES, _VALID_TEST_CASES = zip(*_VALID_TESTS)
@@ -87,8 +100,8 @@ class _TestEventHandler(hsd.HsdEventHandler):
     def __init__(self):
         self.events = []
 
-    def open_tag(self, tagname, attrib, hsdoptions):
-        self.events.append((_OPEN_TAG_EVENT, tagname, attrib, hsdoptions))
+    def open_tag(self, tagname, attrib, hsdattrib):
+        self.events.append((_OPEN_TAG_EVENT, tagname, attrib, hsdattrib))
 
     def close_tag(self, tagname):
         self.events.append((_CLOSE_TAG_EVENT, tagname))
@@ -102,7 +115,8 @@ def add_text(self, text):
     _VALID_TEST_CASES,
     ids=_VALID_TEST_NAMES
 )
-def test_valid_parser_events(hsd_input, expected_events):
+def test_parser_events(hsd_input, expected_events):
+    """Test valid parser events"""
     testhandler = _TestEventHandler()
     parser = hsd.HsdParser(eventhandler=testhandler)
     hsdfile = io.StringIO(hsd_input)
@@ -115,7 +129,8 @@ def test_valid_parser_events(hsd_input, expected_events):
     _FAILING_TEST_CASES,
     ids=_FAILING_TEST_NAMES
 )
-def test_invalid_parser_events(hsd_input):
+def test_parser_exceptions(hsd_input):
+    """Test exception raised by the parser"""
     testhandler = _TestEventHandler()
     parser = hsd.HsdParser(eventhandler=testhandler)
     hsdfile = io.StringIO(hsd_input)
