Full refactor of YAML dungeon generator.

The big difference is that the differences between the entity types
is concentrated in one place.

Also concentrated all File I/O in main function, moved most processing
outside of main

tests/coverage_dungeon.py

@@ -17,18 +17,18 @@ YAML_PATH = "../adventure.yaml"
 HTML_TEMPLATE_PATH = "coverage_dungeon.html.tpl"
 DEFAULT_HTML_OUTPUT_PATH = "../coverage/adventure.yaml.html"
 
-STDOUT_REPORT_CATEGORY = "  {name:.<19}: {percent}% covered ({covered} of {total}))\n"
+STDOUT_REPORT_CATEGORY = "  {name:.<19}: {percent:5.1f}% covered ({covered} of {total})\n"
 
 HTML_SUMMARY_ROW = """
     <tr>
         <td class="headerItem"><a href="#{name}">{name}:</a></td>
         <td class="headerCovTableEntry">{total}</td>
         <td class="headerCovTableEntry">{covered}</td>
-        <td class="headerCovTableEntry">{percent}%</td>
+        <td class="headerCovTableEntry">{percent:.1f}%</td>
     </tr>
 """
 
-HTML_CATEGORY_TABLE = """
+HTML_CATEGORY_SECTION = """
     <tr id="{id}"></tr>
     {rows}
     <tr>
@@ -36,33 +36,21 @@ HTML_CATEGORY_TABLE = """
     </tr>
 """
 
-HTML_CATEGORY_TABLE_HEADER_3_FIELDS = """
+HTML_CATEGORY_HEADER = """
     <tr>
-        <td class="tableHead" width="60%">{}</td>
+        <td class="tableHead" width="60%" colspan="{colspan}">{label}</td>
-        <td class="tableHead" width="20%">{}</td>
+        {cells}
-        <td class="tableHead" width="20%">{}</td>
     </tr>
 """
 
-HTML_CATEGORY_TABLE_HEADER_2_FIELDS = """
+HTML_CATEGORY_HEADER_CELL = '<td class="tableHead" width="15%">{}</td>\n'
-    <tr>
-        <td class="tableHead" colspan="2">{}</td>
-        <td class="tableHead">{}</td>
-    </tr>
-"""
 
-HTML_CATEGORY_ROW_3_FIELDS = """
+HTML_CATEGORY_COVERAGE_CELL = '<td class="{}">&nbsp;</td>\n'
-    <tr>
-        <td class="coverFile">{}</td>
-        <td class="{}">&nbsp;</td>
-        <td class="{}">&nbsp;</td>
-    </tr>
-"""
 
-HTML_CATEGORY_ROW_2_FIELDS = """
+HTML_CATEGORY_ROW = """
     <tr>
-        <td class="coverFile" colspan="2">{}</td>
+        <td class="coverFile" colspan="{colspan}">{id}</td>
-        <td class="{}">&nbsp;</td>
+        {cells}
     </tr>
 """
 
@@ -80,257 +68,175 @@ def search(needle, haystack):
 
     return re.search(needle, haystack)
 
-def loc_coverage(locations, text):
+def obj_coverage(objects, text, report):
-    # locations have a long and a short description, that each have to
-    # be checked seperately
-    for locname, loc in locations:
-        if loc["description"]["long"] == None or loc["description"]["long"] == '':
-            loc["description"]["long"] = True
-        if loc["description"]["long"] != True:
-            if search(loc["description"]["long"], text):
-                loc["description"]["long"] = True
-        if loc["description"]["short"] == None or loc["description"]["short"] == '':
-            loc["description"]["short"] = True
-        if loc["description"]["short"] != True:
-            if search(loc["description"]["short"], text):
-                loc["description"]["short"] = True
-
-def arb_coverage(arb_msgs, text):
-    # arbitrary messages are a map to tuples
-    for i, msg in enumerate(arb_msgs):
-        (msg_name, msg_text) = msg
-        if msg_text == None or msg_text == '':
-            arb_msgs[i] = (msg_name, True)
-        elif msg_text != True:
-            if search(msg_text, text):
-                arb_msgs[i] = (msg_name, True)
-
-def obj_coverage(objects, text):
     # objects have multiple descriptions based on state
     for i, objouter in enumerate(objects):
         (obj_name, obj) = objouter
         if obj["descriptions"]:
             for j, desc in enumerate(obj["descriptions"]):
-                if desc == None or desc == '':
+                name = "{}[{}]".format(obj_name, j)
-                    obj["descriptions"][j] = True
+                if name not in report["messages"]:
-                    objects[i] = (obj_name, obj)
+                    report["messages"][name] = {"covered" : False}
-                elif desc != True:
+                    report["total"] += 1
-                    if search(desc, text):
+                if report["messages"][name]["covered"] != True:
-                        obj["descriptions"][j] = True
+                    if desc == None or desc == '' or search(desc, text):
-                        objects[i] = (obj_name, obj)
+                        report["messages"][name]["covered"] = True
+                        report["covered"] += 1
 
-def hint_coverage(hints, text):
+def loc_coverage(locations, text, report):
+    # locations have a long and a short description, that each have to
+    # be checked seperately
+    for name, loc in locations:
+        if name not in report["messages"]:
+            report["messages"][name] = {"long" : False, "short": False}
+            report["total"] += 2
+        if report["messages"][name]["long"] != True:
+            if loc["description"]["long"] == None or loc["description"]["long"] == '' or search(loc["description"]["long"], text):
+                report["messages"][name]["long"] = True
+                report["covered"] += 1
+        if report["messages"][name]["short"] != True:
+            if loc["description"]["short"] == None or loc["description"]["short"] == '' or search(loc["description"]["short"], text):
+                report["messages"][name]["short"] = True
+                report["covered"] += 1
+
+def hint_coverage(obituaries, text, report):
     # hints have a "question" where the hint is offered, followed
     # by the actual hint if the player requests it
-    for i, hint in enumerate(hints):
+    for i, hintouter in enumerate(obituaries):
-        if hint["hint"]["question"] != True:
+        hint = hintouter["hint"]
-            if search(hint["hint"]["question"], text):
+        name = hint["name"]
-                hint["hint"]["question"] = True
+        if name not in report["messages"]:
-        if hint["hint"]["hint"] != True:
+            report["messages"][name] = {"question" : False, "hint": False}
-            if search(hint["hint"]["hint"], text):
+            report["total"] += 2
-                hint["hint"]["hint"] = True
+        if report["messages"][name]["question"] != True and search(hint["question"], text):
+            report["messages"][name]["question"] = True
+            report["covered"] += 1
+        if report["messages"][name]["hint"] != True and search(hint["hint"], text):
+            report["messages"][name]["hint"] = True
+            report["covered"] += 1
 
-def obit_coverage(obituaries, text):
+def obit_coverage(obituaries, text, report):
     # obituaries have a "query" where it asks the player for a resurrection,
     # followed by a snarky comment if the player says yes
-    for i, obit in enumerate(obituaries):
+    for name, obit in enumerate(obituaries):
-        if obit["query"] != True:
+        if name not in report["messages"]:
-            if search(obit["query"], text):
+            report["messages"][name] = {"query" : False, "yes_response": False}
-                obit["query"] = True
+            report["total"] += 2
-        if obit["yes_response"] != True:
+        if report["messages"][name]["query"] != True and search(obit["query"], text):
-            if search(obit["yes_response"], text):
+            report["messages"][name]["query"] = True
-                obit["yes_response"] = True
+            report["covered"] += 1
+        if report["messages"][name]["yes_response"] != True and search(obit["yes_response"], text):
+            report["messages"][name]["yes_response"] = True
+            report["covered"] += 1
 
-def threshold_coverage(classes, text):
+def threshold_coverage(classes, text, report):
     # works for class thresholds and turn threshold, which have a "message"
     # property
-    for i, msg in enumerate(classes):
+    for name, item in enumerate(classes):
-        if msg["message"] == None:
+        if name not in report["messages"]:
-            msg["message"] = True
+            report["messages"][name] = {"covered" : "False"}
-        elif msg["message"] != True:
+            report["total"] += 1
-            if search(msg["message"], text):
+        if report["messages"][name]["covered"] != True:
-                msg["message"] = True
+            if item["message"] == None or item["message"] == "NO_MESSAGE" or search(item["message"], text):
+                report["messages"][name]["covered"] = True
+                report["covered"] += 1
 
-def specials_actions_coverage(items, text):
+def arb_coverage(arb_msgs, text, report):
+    for name, message in arb_msgs:
+        if name not in report["messages"]:
+            report["messages"][name] = {"covered" : False}
+            report["total"] += 1
+        if report["messages"][name]["covered"] != True:
+            if message == None or search(message, text):
+                report["messages"][name]["covered"] = True
+                report["covered"] += 1
+
+def specials_actions_coverage(items, text, report):
     # works for actions or specials
     for name, item in items:
-        if item["message"] == None or item["message"] == "NO_MESSAGE":
+        if name not in report["messages"]:
-            item["message"] = True
+            report["messages"][name] = {"covered" : False}
-        if item["message"] != True:
+            report["total"] += 1
-            if search(item["message"], text):
+        if report["messages"][name]["covered"] != True:
-                item["message"] = True
+            if item["message"] == None or item["message"] == "NO_MESSAGE" or search(item["message"], text):
+                report["messages"][name]["covered"] = True
+                report["covered"] += 1
 
-if __name__ == "__main__":
+def coverage_report(db, check_file_contents):
-    with open(YAML_PATH, "r") as f:
+    # Create report for each catagory, including total items,  number of items
-        db = yaml.load(f)
+    # covered, and a list of the covered messages
-
-    # Create report for each catagory, including HTML table, total items,
-    # and number of items covered
     report = {}
     for name in db.keys():
         # initialize each catagory
         report[name] = {
             "name" : name, # convenience for string formatting
-            "html" : "",
             "total" : 0,
-            "covered" : 0
+            "covered" : 0,
+            "messages" : {}
         }
 
-    motions = db["motions"]
+    # search for each message in ever test check file
-    locations = db["locations"]
+    for chk in check_file_contents:
-    arb_msgs = db["arbitrary_messages"]
+        arb_coverage(db["arbitrary_messages"], chk, report["arbitrary_messages"])
-    objects = db["objects"]
+        hint_coverage(db["hints"], chk, report["hints"])
-    hints = db["hints"]
+        loc_coverage(db["locations"], chk, report["locations"])
-    classes = db["classes"]
+        obit_coverage(db["obituaries"], chk, report["obituaries"])
-    turn_thresholds = db["turn_thresholds"]
+        obj_coverage(db["objects"], chk, report["objects"])
-    obituaries = db["obituaries"]
+        specials_actions_coverage(db["actions"], chk, report["actions"])
-    actions = db["actions"]
+        specials_actions_coverage(db["specials"], chk, report["specials"])
-    specials = db["specials"]
+        threshold_coverage(db["classes"], chk, report["classes"])
+        threshold_coverage(db["turn_thresholds"], chk, report["turn_thresholds"])
 
-    text = ""
+    return report
+
+if __name__ == "__main__":
+    # load DB
+    try:
+        with open(YAML_PATH, "r") as f:
+            db = yaml.load(f)
+    except IOError as e:
+        print('ERROR: could not load {} ({}})'.format(YAML_PATH, e.strerror))
+        exit(-1)
+
+    # get contents of all the check files
+    check_file_contents = []
     for filename in os.listdir(TEST_DIR):
         if filename.endswith(".chk"):
-            with open(filename, "r") as chk:
+            with open(filename, "r") as f:
-                text = chk.read()
+                check_file_contents.append(f.read())
-                loc_coverage(locations, text)
-                arb_coverage(arb_msgs, text)
-                obj_coverage(objects, text)
-                hint_coverage(hints, text)
-                threshold_coverage(classes, text)
-                threshold_coverage(turn_thresholds, text)
-                obit_coverage(obituaries, text)
-                specials_actions_coverage(actions, text)
-                specials_actions_coverage(specials, text)
 
-    report["locations"]["total"] = len(locations) * 2
+    # run coverage analysis report on dungeon database
-    report["locations"]["html"] = HTML_CATEGORY_TABLE_HEADER_3_FIELDS.format("Location ID", "long", "short")
+    report = coverage_report(db, check_file_contents)
-    locations.sort()
-    for locouter in locations:
-        locname = locouter[0]
-        loc = locouter[1]
-        if loc["description"]["long"] != True:
-            long_success = "uncovered"
-        else:
-            long_success = "covered"
-            report["locations"]["covered"] += 1
 
-        if loc["description"]["short"] != True:
+    # render report output
-            short_success = "uncovered"
-        else:
-            short_success = "covered"
-            report["locations"]["covered"] += 1
-
-        report["locations"]["html"] += HTML_CATEGORY_ROW_3_FIELDS.format(locname, long_success, short_success)
-
-    arb_msgs.sort()
-    report["arbitrary_messages"]["total"] = len(arb_msgs)
-    report["arbitrary_messages"]["html"] = HTML_CATEGORY_TABLE_HEADER_2_FIELDS.format("Arbitrary Message ID", "covered")
-    for name, msg in arb_msgs:
-        if msg != True:
-            success = "uncovered"
-        else:
-            success = "covered"
-            report["arbitrary_messages"]["covered"] += 1
-        report["arbitrary_messages"]["html"] += HTML_CATEGORY_ROW_2_FIELDS.format(name, success)
-
-    objects.sort()
-    report["objects"]["html"] = HTML_CATEGORY_TABLE_HEADER_2_FIELDS.format("Object ID", "covered")
-    for (obj_name, obj) in objects:
-        if obj["descriptions"]:
-            for j, desc in enumerate(obj["descriptions"]):
-                report["objects"]["total"] += 1
-                if desc != True:
-                    success = "uncovered"
-                else:
-                    success = "covered"
-                    report["objects"]["covered"] += 1
-                report["objects"]["html"] += HTML_CATEGORY_ROW_2_FIELDS.format("%s[%d]" % (obj_name, j), success)
-
-    hints.sort()
-    report["hints"]["total"] = len(hints) * 2
-    report["hints"]["html"] = HTML_CATEGORY_TABLE_HEADER_3_FIELDS.format("Hint ID", "question", "hint")
-    for i, hint in enumerate(hints):
-        hintname = hint["hint"]["name"]
-        if hint["hint"]["question"] != True:
-            question_success = "uncovered"
-        else:
-            question_success = "covered"
-            report["hints"]["covered"] += 1
-        if hint["hint"]["hint"] != True:
-            hint_success = "uncovered"
-        else:
-            hint_success = "covered"
-            report["hints"]["covered"] += 1
-        report["hints"]["html"] += HTML_CATEGORY_ROW_3_FIELDS.format(name, question_success, hint_success)
-
-    report["classes"]["total"] = len(classes)
-    report["classes"]["html"] = HTML_CATEGORY_TABLE_HEADER_2_FIELDS.format("Adventurer Class #", "covered")
-    for name, msg in enumerate(classes):
-        if msg["message"] != True:
-            success = "uncovered"
-        else:
-            success = "covered"
-            report["classes"]["covered"] += 1
-        report["classes"]["html"] += HTML_CATEGORY_ROW_2_FIELDS.format(msg["threshold"], success)
-
-    report["turn_thresholds"]["total"] = len(turn_thresholds)
-    report["turn_thresholds"]["html"] = HTML_CATEGORY_TABLE_HEADER_2_FIELDS.format("Turn Threshold", "covered")
-    for name, msg in enumerate(turn_thresholds):
-        if msg["message"] != True:
-            success = "uncovered"
-        else:
-            success = "covered"
-            report["turn_thresholds"]["covered"] += 1
-        report["turn_thresholds"]["html"] += HTML_CATEGORY_ROW_2_FIELDS.format(msg["threshold"], success)
-
-    report["obituaries"]["total"] = len(obituaries) * 2
-    report["obituaries"]["html"] = HTML_CATEGORY_TABLE_HEADER_3_FIELDS.format("Obituary #", "query", "yes_response")
-    for i, obit in enumerate(obituaries):
-        if obit["query"] != True:
-            query_success = "uncovered"
-        else:
-            query_success = "covered"
-            report["obituaries"]["covered"] += 1
-        if obit["yes_response"] != True:
-            obit_success = "uncovered"
-        else:
-            obit_success = "covered"
-            report["obituaries"]["covered"] += 1
-        report["obituaries"]["html"] += HTML_CATEGORY_ROW_3_FIELDS.format(i, query_success, obit_success)
-
-    actions.sort()
-    report["actions"]["total"] = len(actions)
-    report["actions"]["html"] = HTML_CATEGORY_TABLE_HEADER_2_FIELDS.format("Action ID", "covered")
-    for name, action in actions:
-        if action["message"] != True:
-            success = "uncovered"
-        else:
-            success = "covered"
-            report["actions"]["covered"] += 1
-        report["actions"]["html"] += HTML_CATEGORY_ROW_2_FIELDS.format(name, success)
-
-    report["specials"]["total"] = len(specials)
-    report["specials"]["html"] = HTML_CATEGORY_TABLE_HEADER_2_FIELDS.format("Special ID", "covered")
-    for name, special in specials:
-        if special["message"] != True:
-            success = "uncovered"
-        else:
-            success = "covered"
-            report["specials"]["covered"] += 1
-        report["specials"]["html"] += HTML_CATEGORY_ROW_2_FIELDS.format(name, success)
-
-    # calculate percentages for each catagory and HTML for category tables
     categories_html = ""
     summary_html = ""
     summary_stdout = "adventure.yaml coverage rate:\n"
     for name, category in sorted(report.items()):
-        if(category["total"] > 0):
+        # ignore categories with zero entries
-            report[name]["percent"] = round((category["covered"] / float(category["total"])) * 100, 1)
+        if category["total"] > 0:
-            summary_stdout += STDOUT_REPORT_CATEGORY.format(**report[name])
+            # Calculate percent coverage
-            categories_html += HTML_CATEGORY_TABLE.format(id=name, rows=category["html"])
+            category["percent"] = (category["covered"] / float(category["total"])) * 100
-            summary_html += HTML_SUMMARY_ROW.format(**report[name])
+
-        else:
+            # render section header
-            report[name]["percent"] = 100;
+            cat_keys = category["messages"].items()[0][1].keys()
+            headers_html = ""
+            colspan = 10 - len(cat_keys)
+            for key in cat_keys:
+                headers_html += HTML_CATEGORY_HEADER_CELL.format(key)
+            category_html = HTML_CATEGORY_HEADER.format(colspan=colspan, label=category["name"], cells=headers_html)
+
+            # render message coverage row
+            for message_id, covered in sorted(category["messages"].items()):
+                category_html_row = ""
+                for key, value in covered.items():
+                    category_html_row += HTML_CATEGORY_COVERAGE_CELL.format("uncovered" if value != True else "covered")
+                category_html += HTML_CATEGORY_ROW.format(id=message_id,colspan=colspan, cells=category_html_row)
+            categories_html += HTML_CATEGORY_SECTION.format(id=name, rows=category_html)
+
+            # render category summaries
+            summary_stdout += STDOUT_REPORT_CATEGORY.format(**category)
+            summary_html += HTML_SUMMARY_ROW.format(**category)
 
     # output some quick report stats
     print(summary_stdout)
@@ -346,7 +252,7 @@ if __name__ == "__main__":
             # read in HTML template
             html_template = f.read()
     except IOError as e:
-        print 'ERROR: reading HTML report template failed (%s)' % e.strerror
+        print('ERROR: reading HTML report template failed ({})'.format(e.strerror))
         exit(-1)
 
     # parse template with report and write it out
@@ -354,4 +260,4 @@ if __name__ == "__main__":
         with open(html_output_path, "w") as f:
             f.write(html_template.format(categories=categories_html, summary=summary_html))
     except IOError as e:
-        print 'ERROR: writing HTML report failed (%s)' % e.strerror
+        print('ERROR: writing HTML report failed ({})'.format(e.strerror))