Refactor: Improve handling of multiple common content sections and add tests

This commit improves the `exclude_common_contents` function to handle multiple common content sections within a single README file. It also adds a new test, `test__exclude_common_contents__double`, to verify this functionality.

The following changes were made:

- Updated `exclude_common_contents`:
    - The function now uses `re.findall` to find all occurrences of common content markers and removes them from the input string.
    - Improved logging to provide more context when common content markers are not found.
- Added `test__exclude_common_contents__double`:
    - This new test verifies that the `exclude_common_contents` function correctly handles multiple common content sections.
    - It uses new fixtures, `common_lines_2` and `specific_lines_2`, to provide additional test data.
    - The test asserts that the specific lines are preserved and the common lines are removed from the output.
- Added `create_common_block` helper function:
    - This function encapsulates the logic for creating a common content block, making the fixtures more readable.

These changes improve the robustness and functionality of the `exclude_common_contents` function and provide better test coverage.

add // before specific-2 lines between common content blocks
    to make it easier to understand the test message

Author: beachdweller

ai_tutor.py

@@ -283,18 +283,17 @@ def exclude_common_contents(
         A string with the common content removed.
     """
     # Include the markers in the pattern itself
-    pattern = rf"(.*?){common_content_start_marker}\s*(.*?)\s*{common_content_end_marker}(.*?)"
-    match = re.search(pattern, readme_content, re.DOTALL | re.IGNORECASE)
-
-    if match:
-        # Extract the parts before and after the common content
-        before_common = match.group(1).strip()
-        after_common = match.group(3).strip()
-        # Combine them to get the final instructions
-        instruction = (before_common + after_common).strip()
-    else:
+    pattern = rf"({common_content_start_marker}\s*.*?\s*{common_content_end_marker})"
+    found_list = re.findall(pattern, readme_content, re.DOTALL | re.IGNORECASE)
+
+    instruction = str(readme_content)
+
+    if not found_list:
         logging.warning(f"Common content markers '{common_content_start_marker}' and '{common_content_end_marker}' not found in README.md. Returning entire file.")
-        instruction = readme_content.strip()  # Single exit point
+    else:
+        for found in found_list:
+            # Remove the common content
+            instruction = instruction.replace(found, "")
 
     return instruction
 

tests/test_ai_tutor.py

@@ -312,6 +312,14 @@ def common_content_single(
     start_marker:str,
     common_lines:Tuple[str],
     end_marker:str
+) -> str:
+    return create_common_block(start_marker, common_lines, end_marker)
+
+
+def create_common_block(
+        start_marker:str,
+        common_lines:Tuple[str],
+        end_marker:str
 ) -> str:
     return (
         '\n'.join((start_marker,) + common_lines + (end_marker,))
@@ -360,5 +368,68 @@ def test__exclude_common_contents__single(
     assert end_marker.strip() not in result
 
 
+@pytest.fixture
+def specific_lines_2() -> Tuple[str]:
+    """Provides a tuple of specific lines to be inserted between common content blocks."""
+    return (
+        "// This is specific content between the common blocks.",
+        "// It should be preserved in the output."
+    )
+
+
+@pytest.fixture
+def common_lines_2() -> Tuple[str]:
+    return (
+        "def div(a, b):",
+        "    return a / b"
+    )
+
+
+@pytest.fixture
+def readme_content_double(
+    readme_content_single:str,
+    specific_lines_2:Tuple[str],
+    start_marker:str,
+    common_lines_2:Tuple[str],
+    end_marker:str
+) -> str:
+    return (
+        readme_content_single
+        + '\n'.join(specific_lines_2) + '\n'
+        + create_common_block(start_marker, common_lines_2, end_marker)
+    )
+
+
+def test__exclude_common_contents__double(
+    readme_content_double:str,
+    start_marker:str,
+    end_marker:str,
+    specific_lines:Tuple[str],
+    specific_lines_2:Tuple[str],
+    common_lines:Tuple[str],
+    common_lines_2:Tuple[str],
+):
+    result = ai_tutor.exclude_common_contents(
+        readme_content=readme_content_double,
+        common_content_start_marker=start_marker,
+        common_content_end_marker=end_marker,
+    )
+
+    for line in (tuple(specific_lines) + tuple(specific_lines_2)):
+        assert line.strip() in result, ("\n"
+            f"Could not find line: {line}\n"
+            f"in result: {result}."
+        )
+
+    for line in (tuple(common_lines) + tuple(common_lines_2)):
+        assert line.strip() not in result, ("\n"
+            f"Found line: {line}\n"
+            f"in result: {result}."
+        )
+
+    assert start_marker.strip() not in result
+    assert end_marker.strip() not in result
+
+
 if '__main__' == __name__:
     pytest.main([__file__])