From c6693d4bfd06c4dcad31a3c62e518a00ec79fa90 Mon Sep 17 00:00:00 2001
From: Paul Craig <paul@pcraig3.ca>
Date: Mon, 16 Dec 2024 10:14:38 -0500
Subject: [PATCH 1/3] Convert single-item lists into paragraphs inside of tds

We received some feedback that it is better for accessibility to
represent single-item lists as paragraphs instead of giving them
all list sementics when they are inside of a table cell.

Makes sense to me.

Added a function that will do this on import inside of "clean_table_cells".

Pros:
- it's more performant this way since we are already iterating through
  tds and ths

Cons:
- it's not super clear what this function does from the outside
  (but it doesn't change the spirit of the function)
---
 bloom_nofos/nofos/nofo.py | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/bloom_nofos/nofos/nofo.py b/bloom_nofos/nofos/nofo.py
index 34abb75d..cf5f6aa1 100644
--- a/bloom_nofos/nofos/nofo.py
+++ b/bloom_nofos/nofos/nofo.py
@@ -1257,6 +1257,42 @@ def unwrap_empty_elements(soup):
         el.unwrap()
 
 
+def _convert_single_item_lists_to_paragraphs(soup, cell):
+    """
+    This function mutates the soup!
+
+    Converts single-item lists in a table cell to paragraphs for improved accessibility.
+
+    This function checks if a given table cell (`<td>` or `<th>`) contains exactly one child,
+    which must be a list (`<ul>` or `<ol>`) with only one list item (`<li>`). If such a list
+    is found, it is replaced with a `<p>` tag containing the same text content as the list item.
+
+    Modifies:
+        The `cell` object is modified in place. If a matching single-item list is found,
+        it is replaced with a paragraph (`<p>`).
+
+    Example:
+        Input:
+        <td><ul><li>List item</li></ul></td>
+
+        Output:
+        <td><p>List item</p></td>
+    """
+    cell_children = list(cell.children)
+    if (
+        len(cell_children) == 1
+        and cell_children[0].name in ["ul", "ol"]
+        and len(cell_children[0].find_all("li")) == 1
+    ):
+        # Extract the text content of the single list item
+        text = cell_children[0].get_text(strip=True)
+        # Remove the list and replace with a paragraph
+        cell_children[0].decompose()
+        new_paragraph = soup.new_tag("p")
+        new_paragraph.string = text
+        cell.append(new_paragraph)
+
+
 def clean_table_cells(soup):
     """
     This function mutates the soup!
@@ -1287,6 +1323,8 @@ def clean_table_cells(soup):
         for span in cell.find_all("span"):
             span.unwrap()
 
+        _convert_single_item_lists_to_paragraphs(soup, cell)
+
 
 def replace_src_for_inline_images(soup):
     """

From ebed690673bb48e234e978270813e01147cafd45 Mon Sep 17 00:00:00 2001
From: Paul Craig <paul@pcraig3.ca>
Date: Mon, 16 Dec 2024 10:20:44 -0500
Subject: [PATCH 2/3] Add tests and update CHANGELOG for single-item list
 conversion

---
 CHANGELOG.md                   |  2 ++
 bloom_nofos/nofos/test_nofo.py | 62 +++++++++++++++++++++++++++++++++-
 2 files changed, 63 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 080d4bed..fb7eb428 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,8 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 
 ### Changed
 
+- Convert single-item lists to paragraphs inside of table cells
+
 ### Fixed
 
 ## [1.40.0] - 2023-12-16
diff --git a/bloom_nofos/nofos/test_nofo.py b/bloom_nofos/nofos/test_nofo.py
index d9364038..a88cecf2 100644
--- a/bloom_nofos/nofos/test_nofo.py
+++ b/bloom_nofos/nofos/test_nofo.py
@@ -111,7 +111,7 @@ def test_no_replacements_needed(self):
         self.assertEqual(replace_chars(test_string), test_string)
 
 
-class TestsCleanTableCells(TestCase):
+class TestsCleanTableCellsSpans(TestCase):
     def test_remove_span_keep_content(self):
         html = "<table><tr><td><span>Content</span> and more <span>content</span></td></tr></table>"
         soup = BeautifulSoup(html, "html.parser")
@@ -155,6 +155,66 @@ def test_multiple_spans_in_cell(self):
         self.assertEqual(soup.td.text, "FirstSecond")
 
 
+class TestsCleanTableCellsLists(TestCase):
+    def test_replace_single_item_ul_in_table_cell(self):
+        html = "<table><tr><td><ul><li>UL list item 1</li></ul></td></tr></table>"
+        soup = BeautifulSoup(html, "html.parser")
+        clean_table_cells(soup)
+        self.assertEqual(
+            str(soup), "<table><tr><td><p>UL list item 1</p></td></tr></table>"
+        )
+
+    def test_replace_single_item_ol_in_table_cell(self):
+        html = "<table><tr><td><ol><li>OL list item 1</li></ol></td></tr></table>"
+        soup = BeautifulSoup(html, "html.parser")
+        clean_table_cells(soup)
+        self.assertEqual(
+            str(soup), "<table><tr><td><p>OL list item 1</p></td></tr></table>"
+        )
+
+    def test_NO_replace_multiple_item_ul_in_table_cell(self):
+        html = "<table><tr><td><ul><li>UL list item 1</li><li>UL list item 2</li></ul></td></tr></table>"
+        soup = BeautifulSoup(html, "html.parser")
+        clean_table_cells(soup)
+        self.assertEqual(str(soup), html)
+
+    def test_NO_replace_multiple_item_ol_in_table_cell(self):
+        html = "<table><tr><td><ol><li>OL list item 1</li><li>OL list item 2</li></ol></td></tr></table>"
+        soup = BeautifulSoup(html, "html.parser")
+        clean_table_cells(soup)
+        self.assertEqual(str(soup), html)
+
+    def test_NO_replace_single_item_ul_in_table_cell_if_element_before(self):
+        html = "<table><tr><td><p>Paragraph 1 before ul</p><ul><li>UL list item 1</li></ul></td></tr></table>"
+        soup = BeautifulSoup(html, "html.parser")
+        clean_table_cells(soup)
+        self.assertEqual(str(soup), html)
+
+    def test_NO_replace_single_item_ul_in_table_cell_if_element_after(self):
+        html = "<table><tr><td><ul><li>UL list item 1</li></ul><p>Paragraph 1 after ul</p></td></tr></table>"
+        soup = BeautifulSoup(html, "html.parser")
+        clean_table_cells(soup)
+        self.assertEqual(str(soup), html)
+
+    def test_NO_replace_2_single_item_uls_in_table_cell(self):
+        html = "<table><tr><td><ul><li>UL list 1 item 1</li></ul><ul><li>UL list 2 item 1</li></ul></td></tr></table>"
+        soup = BeautifulSoup(html, "html.parser")
+        clean_table_cells(soup)
+        self.assertEqual(str(soup), html)
+
+    def test_NO_replace_2_single_item_ols_in_table_cell(self):
+        html = "<table><tr><td><ol><li>OL list 1 item 1</li></ol><ol><li>OL list 2 item 1</li></ol></td></tr></table>"
+        soup = BeautifulSoup(html, "html.parser")
+        clean_table_cells(soup)
+        self.assertEqual(str(soup), html)
+
+    def test_NO_replace_single_item_ul_and_single_item_ol_in_table_cell(self):
+        html = "<table><tr><td><ul><li>UL list 1 item 1</li></ul><ol><li>OL list 1 item 1</li></ol></td></tr></table>"
+        soup = BeautifulSoup(html, "html.parser")
+        clean_table_cells(soup)
+        self.assertEqual(str(soup), html)
+
+
 class TableConvertFirstRowToHeaderRowTests(TestCase):
     def setUp(self):
         self.caption_text = "Physician Assistant Training Chart"

From a50be7701bbd87d00b1caae24af286f3ef02a132 Mon Sep 17 00:00:00 2001
From: Paul Craig <paul@pcraig3.ca>
Date: Tue, 17 Dec 2024 10:05:44 -0500
Subject: [PATCH 3/3] Preserve HTML elements that are in the table cell as well

Previous to this, we were just keeping the text, but we would lose
HTML elements (eg, lists and bold).

Now it works as you would expect.
---
 bloom_nofos/nofos/nofo.py      | 15 ++++++++-------
 bloom_nofos/nofos/test_nofo.py |  9 +++++++++
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/bloom_nofos/nofos/nofo.py b/bloom_nofos/nofos/nofo.py
index cf5f6aa1..ed094d87 100644
--- a/bloom_nofos/nofos/nofo.py
+++ b/bloom_nofos/nofos/nofo.py
@@ -1265,7 +1265,7 @@ def _convert_single_item_lists_to_paragraphs(soup, cell):
 
     This function checks if a given table cell (`<td>` or `<th>`) contains exactly one child,
     which must be a list (`<ul>` or `<ol>`) with only one list item (`<li>`). If such a list
-    is found, it is replaced with a `<p>` tag containing the same text content as the list item.
+    is found, it is replaced with a `<p>` tag containing the same HTML content as the list item.
 
     Modifies:
         The `cell` object is modified in place. If a matching single-item list is found,
@@ -1273,10 +1273,10 @@ def _convert_single_item_lists_to_paragraphs(soup, cell):
 
     Example:
         Input:
-        <td><ul><li>List item</li></ul></td>
+        <td><ul><li><strong>Bold</strong> list item</li></ul></td>
 
         Output:
-        <td><p>List item</p></td>
+        <td><p><strong>Bold</strong> list item</p></td>
     """
     cell_children = list(cell.children)
     if (
@@ -1285,12 +1285,13 @@ def _convert_single_item_lists_to_paragraphs(soup, cell):
         and len(cell_children[0].find_all("li")) == 1
     ):
         # Extract the text content of the single list item
-        text = cell_children[0].get_text(strip=True)
-        # Remove the list and replace with a paragraph
-        cell_children[0].decompose()
+        li = cell_children[0].find("li", recursive=False)
+
+        # Replace with a paragraph, then remove the list
         new_paragraph = soup.new_tag("p")
-        new_paragraph.string = text
+        new_paragraph.extend(li.contents)
         cell.append(new_paragraph)
+        cell_children[0].decompose()
 
 
 def clean_table_cells(soup):
diff --git a/bloom_nofos/nofos/test_nofo.py b/bloom_nofos/nofos/test_nofo.py
index a88cecf2..d7c0bd22 100644
--- a/bloom_nofos/nofos/test_nofo.py
+++ b/bloom_nofos/nofos/test_nofo.py
@@ -164,6 +164,15 @@ def test_replace_single_item_ul_in_table_cell(self):
             str(soup), "<table><tr><td><p>UL list item 1</p></td></tr></table>"
         )
 
+    def test_replace_single_item_ul_in_table_cell_with_other_tags(self):
+        html = '<table><tr><td><ul><li>UL list item 1 with <a href="https://google.com">a link</a> and <strong>bold formatting</strong></li></ul></td></tr></table>'
+        soup = BeautifulSoup(html, "html.parser")
+        clean_table_cells(soup)
+        self.assertEqual(
+            str(soup),
+            '<table><tr><td><p>UL list item 1 with <a href="https://google.com">a link</a> and <strong>bold formatting</strong></p></td></tr></table>',
+        )
+
     def test_replace_single_item_ol_in_table_cell(self):
         html = "<table><tr><td><ol><li>OL list item 1</li></ol></td></tr></table>"
         soup = BeautifulSoup(html, "html.parser")