Article content
- elements."""
+ level_map = {
+ 'h1': HeadingLevel.H1,
+ 'h2': HeadingLevel.H2,
+ 'h3': HeadingLevel.H3,
+ 'h4': HeadingLevel.H4,
+ 'h5': HeadingLevel.H5,
+ 'h6': HeadingLevel.H6,
+ }
+
+ level = level_map.get(element.name.lower(), HeadingLevel.H1)
+ heading = Heading(level, context.font)
+ words = extract_text_content(element, context)
+ for word in words:
+ heading.add_word(word)
+ return heading
+
+
+def blockquote_handler(element: Tag, context: StyleContext) -> Quote:
+ """Handle elements."""
+ quote = Quote(context.font)
+ for child in element.children:
+ if isinstance(child, Tag):
+ child_context = apply_element_styling(context, child)
+ result = process_element(child, child_context)
+ if result:
+ if isinstance(result, list):
+ for block in result:
+ quote.add_block(block)
+ else:
+ quote.add_block(result)
+ return quote
+
+
+def preformatted_handler(element: Tag, context: StyleContext) -> CodeBlock:
+ """Handle elements."""
+ language = context.element_attributes.get('data-language', '')
+ code_block = CodeBlock(language)
+
+ # Preserve whitespace and line breaks in preformatted text
+ text = element.get_text(separator='\n', strip=False)
+ for line in text.split('\n'):
+ code_block.add_line(line)
+
+ return code_block
+
+
+def code_handler(element: Tag, context: StyleContext) -> Union[CodeBlock, None]:
+ """Handle elements."""
+ # If parent is , this is handled by preformatted_handler
+ if context.parent_elements and context.parent_elements[-1] == 'pre':
+ return None # Will be handled by parent
+
+ # Inline code - handled during text extraction
+ return None
+
+
+def unordered_list_handler(element: Tag, context: StyleContext) -> HList:
+ """Handle
elements."""
+ hlist = HList(ListStyle.UNORDERED, context.font)
+ for child in element.children:
+ if isinstance(child, Tag) and child.name.lower() == 'li':
+ child_context = apply_element_styling(context, child)
+ item = process_element(child, child_context)
+ if item:
+ hlist.add_item(item)
+ return hlist
+
+
+def ordered_list_handler(element: Tag, context: StyleContext) -> HList:
+ """Handle elements."""
+ hlist = HList(ListStyle.ORDERED, context.font)
+ for child in element.children:
+ if isinstance(child, Tag) and child.name.lower() == 'li':
+ child_context = apply_element_styling(context, child)
+ item = process_element(child, child_context)
+ if item:
+ hlist.add_item(item)
+ return hlist
+
+
+def list_item_handler(element: Tag, context: StyleContext) -> ListItem:
+ """Handle - elements."""
+ list_item = ListItem(None, context.font)
+
+ for child in element.children:
+ if isinstance(child, Tag):
+ child_context = apply_element_styling(context, child)
+ result = process_element(child, child_context)
+ if result:
+ if isinstance(result, list):
+ for block in result:
+ list_item.add_block(block)
+ else:
+ list_item.add_block(result)
+ elif isinstance(child, NavigableString):
+ # Direct text in list item - create paragraph
+ text = str(child).strip()
+ if text:
+ paragraph = Paragraph(context.font)
+ words = text.split()
+ for word_text in words:
+ if word_text:
+ paragraph.add_word(Word(word_text, context.font))
+ list_item.add_block(paragraph)
+
+ return list_item
+
+
+def table_handler(element: Tag, context: StyleContext) -> Table:
+ """Handle
elements."""
+ caption = None
+ caption_elem = element.find('caption')
+ if caption_elem:
+ caption = caption_elem.get_text(strip=True)
+
+ table = Table(caption, context.font)
+
+ # Process table rows
+ for child in element.children:
+ if isinstance(child, Tag):
+ if child.name.lower() == 'tr':
+ child_context = apply_element_styling(context, child)
+ row = process_element(child, child_context)
+ if row:
+ table.add_row(row)
+ elif child.name.lower() in ['thead', 'tbody', 'tfoot']:
+ section = 'header' if child.name.lower() == 'thead' else 'body'
+ section = 'footer' if child.name.lower() == 'tfoot' else section
+
+ for row_elem in child.find_all('tr'):
+ child_context = apply_element_styling(context, row_elem)
+ row = process_element(row_elem, child_context)
+ if row:
+ table.add_row(row, section)
+
+ return table
+
+
+def table_row_handler(element: Tag, context: StyleContext) -> TableRow:
+ """Handle elements."""
+ row = TableRow(context.font)
+ for child in element.children:
+ if isinstance(child, Tag) and child.name.lower() in ['td', 'th']:
+ child_context = apply_element_styling(context, child)
+ cell = process_element(child, child_context)
+ if cell:
+ row.add_cell(cell)
+ return row
+
+
+def table_cell_handler(element: Tag, context: StyleContext) -> TableCell:
+ """Handle elements."""
+ colspan = int(context.element_attributes.get('colspan', 1))
+ rowspan = int(context.element_attributes.get('rowspan', 1))
+ cell = TableCell(False, colspan, rowspan, context.font)
+
+ # Process cell content
+ for child in element.children:
+ if isinstance(child, Tag):
+ child_context = apply_element_styling(context, child)
+ result = process_element(child, child_context)
+ if result:
+ if isinstance(result, list):
+ for block in result:
+ cell.add_block(block)
+ else:
+ cell.add_block(result)
+ elif isinstance(child, NavigableString):
+ # Direct text in cell - create paragraph
+ text = str(child).strip()
+ if text:
+ paragraph = Paragraph(context.font)
+ words = text.split()
+ for word_text in words:
+ if word_text:
+ paragraph.add_word(Word(word_text, context.font))
+ cell.add_block(paragraph)
+
+ return cell
+
+
+def table_header_cell_handler(element: Tag, context: StyleContext) -> TableCell:
+ """Handle elements."""
+ colspan = int(context.element_attributes.get('colspan', 1))
+ rowspan = int(context.element_attributes.get('rowspan', 1))
+ cell = TableCell(True, colspan, rowspan, context.font)
+
+ # Process cell content (same as td)
+ for child in element.children:
+ if isinstance(child, Tag):
+ child_context = apply_element_styling(context, child)
+ result = process_element(child, child_context)
+ if result:
+ if isinstance(result, list):
+ for block in result:
+ cell.add_block(block)
+ else:
+ cell.add_block(result)
+ elif isinstance(child, NavigableString):
+ text = str(child).strip()
+ if text:
+ paragraph = Paragraph(context.font)
+ words = text.split()
+ for word_text in words:
+ if word_text:
+ paragraph.add_word(Word(word_text, context.font))
+ cell.add_block(paragraph)
+
+ return cell
+
+
+def horizontal_rule_handler(element: Tag, context: StyleContext) -> Block:
+ """Handle
elements."""
+ # TODO: Create a specific HorizontalRule block type
+ # For now, return an empty paragraph
+ return Paragraph(context.font)
+
+
+def line_break_handler(element: Tag, context: StyleContext) -> None:
+ """Handle
elements."""
+ # Line breaks are typically handled at the paragraph level
+ return None
+
+
+def image_handler(element: Tag, context: StyleContext) -> Block:
+ """Handle ![]()
elements."""
+ # TODO: Create Image block type
+ # For now, return empty paragraph with alt text if available
+ paragraph = Paragraph(context.font)
+ alt_text = context.element_attributes.get('alt', '')
+ if alt_text:
+ words = alt_text.split()
+ for word_text in words:
+ if word_text:
+ paragraph.add_word(Word(word_text, context.font))
+ return paragraph
+
+
+def ignore_handler(element: Tag, context: StyleContext) -> None:
+ """Handle elements that should be ignored."""
+ return None
+
+
+def generic_handler(element: Tag, context: StyleContext) -> List[Block]:
+ """Handle unknown elements as generic containers."""
+ return div_handler(element, context)
+
+
+# Handler registry - maps HTML tag names to handler functions
+HANDLERS: Dict[str, Callable[[Tag, StyleContext], Union[Block, List[Block], None]]] = {
+ # Block elements
+ 'p': paragraph_handler,
+ 'div': div_handler,
+ 'h1': heading_handler,
+ 'h2': heading_handler,
+ 'h3': heading_handler,
+ 'h4': heading_handler,
+ 'h5': heading_handler,
+ 'h6': heading_handler,
+ 'blockquote': blockquote_handler,
+ 'pre': preformatted_handler,
+ 'code': code_handler,
+ 'ul': unordered_list_handler,
+ 'ol': ordered_list_handler,
+ 'li': list_item_handler,
+ 'table': table_handler,
+ 'tr': table_row_handler,
+ 'td': table_cell_handler,
+ 'th': table_header_cell_handler,
+ 'hr': horizontal_rule_handler,
+ 'br': line_break_handler,
+
+ # Semantic elements (treated as containers)
+ 'section': div_handler,
+ 'article': div_handler,
+ 'aside': div_handler,
+ 'nav': div_handler,
+ 'header': div_handler,
+ 'footer': div_handler,
+ 'main': div_handler,
+ 'figure': div_handler,
+ 'figcaption': paragraph_handler,
+
+ # Media elements
+ 'img': image_handler,
+
+ # Inline elements (handled during text extraction)
+ 'span': ignore_handler,
+ 'a': ignore_handler,
+ 'strong': ignore_handler,
+ 'b': ignore_handler,
+ 'em': ignore_handler,
+ 'i': ignore_handler,
+ 'u': ignore_handler,
+ 's': ignore_handler,
+ 'del': ignore_handler,
+ 'ins': ignore_handler,
+ 'mark': ignore_handler,
+ 'small': ignore_handler,
+ 'sub': ignore_handler,
+ 'sup': ignore_handler,
+ 'q': ignore_handler,
+ 'cite': ignore_handler,
+ 'abbr': ignore_handler,
+ 'time': ignore_handler,
+
+ # Ignored elements
+ 'script': ignore_handler,
+ 'style': ignore_handler,
+ 'meta': ignore_handler,
+ 'link': ignore_handler,
+ 'head': ignore_handler,
+ 'title': ignore_handler,
+}
+
+
+def parse_html_string(html_string: str, base_font: Optional[Font] = None) -> List[Block]:
+ """
+ Parse HTML string and return list of Block objects.
+
+ Args:
+ html_string: HTML content to parse
+ base_font: Base font for styling, defaults to system default
+
+ Returns:
+ List of Block objects representing the document structure
+ """
+ soup = BeautifulSoup(html_string, 'html.parser')
+ context = create_base_context(base_font)
+ blocks = []
+
+ # Process the body if it exists, otherwise process all top-level elements
+ root_element = soup.find('body') or soup
+
+ for element in root_element.children:
+ if isinstance(element, Tag):
+ element_context = apply_element_styling(context, element)
+ result = process_element(element, element_context)
+ if result:
+ if isinstance(result, list):
+ blocks.extend(result)
+ else:
+ blocks.append(result)
+
+ return blocks
+
+
+def register_handler(tag_name: str, handler: Callable[[Tag, StyleContext], Union[Block, List[Block], None]]):
+ """
+ Register a custom handler for an HTML tag.
+
+ Args:
+ tag_name: HTML tag name (lowercase)
+ handler: Handler function with signature (element: Tag, context: StyleContext) -> Union[Block, List[Block], None]
+ """
+ HANDLERS[tag_name] = handler
+
+
+def get_handler(tag_name: str) -> Callable[[Tag, StyleContext], Union[Block, List[Block], None]]:
+ """
+ Get handler function for HTML tag.
+
+ Args:
+ tag_name: HTML tag name (lowercase)
+
+ Returns:
+ Handler function or generic_handler if tag not found
+ """
+ return HANDLERS.get(tag_name.lower(), generic_handler)
diff --git a/pyWebLayout/io/readers/html_text.py b/pyWebLayout/io/readers/html_text.py
index d59ccef..7864148 100644
--- a/pyWebLayout/io/readers/html_text.py
+++ b/pyWebLayout/io/readers/html_text.py
@@ -7,7 +7,7 @@ entity references, and word creation in HTML documents.
from typing import Optional
from pyWebLayout.abstract.inline import Word
-from pyWebLayout.abstract.block import Parapgraph
+from pyWebLayout.abstract.block import Paragraph
from pyWebLayout.io.readers.html_style import HTMLStyleManager
@@ -28,14 +28,14 @@ class HTMLTextProcessor:
"""
self._style_manager = style_manager
self._text_buffer = ""
- self._current_paragraph: Optional[Parapgraph] = None
+ self._current_paragraph: Optional[Paragraph] = None
def reset(self):
"""Reset the text processor state."""
self._text_buffer = ""
self._current_paragraph = None
- def set_current_paragraph(self, paragraph: Optional[Parapgraph]):
+ def set_current_paragraph(self, paragraph: Optional[Paragraph]):
"""
Set the current paragraph for text output.
diff --git a/pyWebLayout/typesetting/document_pagination.py b/pyWebLayout/typesetting/document_pagination.py
index 764e49f..6352604 100644
--- a/pyWebLayout/typesetting/document_pagination.py
+++ b/pyWebLayout/typesetting/document_pagination.py
@@ -139,7 +139,7 @@ class DocumentPaginator:
for chapter in self.document.chapters:
# Add a heading block for the chapter if it has a title
if chapter.title:
- from pyWebLayout.abstract.block import Heading, HeadingLevel, Parapgraph
+ from pyWebLayout.abstract.block import Heading, HeadingLevel, Paragraph
from pyWebLayout.abstract.inline import Word
# Create a heading for the chapter
diff --git a/tests/test_abstract_blocks.py b/tests/test_abstract_blocks.py
index 8697d8e..22c3f2b 100644
--- a/tests/test_abstract_blocks.py
+++ b/tests/test_abstract_blocks.py
@@ -6,7 +6,7 @@ Tests the core abstract block classes that form the foundation of the document m
import unittest
from pyWebLayout.abstract.block import (
- Block, BlockType, Parapgraph, Heading, HeadingLevel, Quote, CodeBlock,
+ Block, BlockType, Paragraph, Heading, HeadingLevel, Quote, CodeBlock,
HList, ListStyle, ListItem, Table, TableRow, TableCell,
HorizontalRule, LineBreak, Image
)
@@ -19,7 +19,7 @@ class TestBlockElements(unittest.TestCase):
def test_paragraph_creation(self):
"""Test creating and using paragraphs."""
- paragraph = Parapgraph()
+ paragraph = Paragraph()
self.assertEqual(paragraph.block_type, BlockType.PARAGRAPH)
self.assertEqual(paragraph.word_count, 0)
@@ -62,8 +62,8 @@ class TestBlockElements(unittest.TestCase):
quote = Quote()
# Add nested paragraphs
- p1 = Parapgraph()
- p2 = Parapgraph()
+ p1 = Paragraph()
+ p2 = Paragraph()
quote.add_block(p1)
quote.add_block(p2)
diff --git a/tests/test_abstract_document.py b/tests/test_abstract_document.py
index 68d8de3..e379901 100644
--- a/tests/test_abstract_document.py
+++ b/tests/test_abstract_document.py
@@ -7,7 +7,7 @@ document structure and metadata management.
import unittest
from pyWebLayout.abstract.document import Document, Chapter, Book, MetadataType
-from pyWebLayout.abstract.block import Parapgraph, Heading, HeadingLevel, BlockType
+from pyWebLayout.abstract.block import Paragraph, Heading, HeadingLevel, BlockType
from pyWebLayout.abstract.inline import Word, FormattedSpan
from pyWebLayout.style import Font
@@ -77,8 +77,8 @@ class TestDocument(unittest.TestCase):
def test_block_management(self):
"""Test adding and managing blocks."""
# Create some blocks
- para1 = Parapgraph()
- para2 = Parapgraph()
+ para1 = Paragraph()
+ para2 = Paragraph()
heading = Heading(HeadingLevel.H1)
# Add blocks
@@ -95,7 +95,7 @@ class TestDocument(unittest.TestCase):
def test_anchor_management(self):
"""Test named anchor functionality."""
heading = Heading(HeadingLevel.H1)
- para = Parapgraph()
+ para = Paragraph()
# Add anchors
self.doc.add_anchor("intro", heading)
@@ -154,8 +154,8 @@ class TestDocument(unittest.TestCase):
def test_find_blocks_by_type(self):
"""Test finding blocks by type."""
# Create blocks of different types
- para1 = Parapgraph()
- para2 = Parapgraph()
+ para1 = Paragraph()
+ para2 = Paragraph()
heading1 = Heading(HeadingLevel.H1)
heading2 = Heading(HeadingLevel.H2)
@@ -180,7 +180,7 @@ class TestDocument(unittest.TestCase):
def test_find_headings(self):
"""Test finding heading blocks specifically."""
# Create mixed blocks
- para = Parapgraph()
+ para = Paragraph()
h1 = Heading(HeadingLevel.H1)
h2 = Heading(HeadingLevel.H2)
@@ -284,8 +284,8 @@ class TestChapter(unittest.TestCase):
def test_block_management(self):
"""Test adding blocks to chapter."""
- para1 = Parapgraph()
- para2 = Parapgraph()
+ para1 = Paragraph()
+ para2 = Paragraph()
heading = Heading(HeadingLevel.H2)
# Add blocks
@@ -450,7 +450,7 @@ class TestBook(unittest.TestCase):
"""Test that Book inherits all Document functionality."""
# Test that book can use all document methods
# Add blocks directly to book
- para = Parapgraph()
+ para = Paragraph()
self.book.add_block(para)
self.assertEqual(len(self.book.blocks), 1)
diff --git a/tests/test_epub_fix.py b/tests/test_epub_fix.py
deleted file mode 100644
index f262acc..0000000
--- a/tests/test_epub_fix.py
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple test script to verify that the EPUB reader fixes are working correctly.
-"""
-
-import sys
-import os
-
-# Add the pyWebLayout directory to the Python path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'pyWebLayout'))
-
-try:
- from pyWebLayout.io.readers.epub_reader import read_epub
- print("Successfully imported epub_reader module")
-
- # Test reading the EPUB file
- epub_path = os.path.join('pyWebLayout', 'examples', 'pg174-images-3.epub')
-
- if not os.path.exists(epub_path):
- print(f"EPUB file not found: {epub_path}")
- sys.exit(1)
-
- print(f"Reading EPUB file: {epub_path}")
-
- # Try to read the EPUB
- book = read_epub(epub_path)
-
- print(f"Successfully read EPUB file!")
- print(f"Book title: {book.title}")
- print(f"Number of chapters: {len(book.chapters)}")
-
- # Check first chapter
- if book.chapters:
- first_chapter = book.chapters[0]
- print(f"First chapter title: {first_chapter.title}")
- print(f"First chapter has {len(first_chapter.blocks)} blocks")
-
-except Exception as e:
- print(f"Error: {e}")
- import traceback
- traceback.print_exc()
- sys.exit(1)
-
-print("Test completed successfully!")
diff --git a/tests/test_html_content.py b/tests/test_html_content.py
index 6c92a3e..05cd2e9 100644
--- a/tests/test_html_content.py
+++ b/tests/test_html_content.py
@@ -9,7 +9,7 @@ import unittest
from pyWebLayout.io.readers.html_content import HTMLContentReader
from pyWebLayout.abstract.document import Document
from pyWebLayout.abstract.block import (
- Parapgraph, Heading, HeadingLevel, HList, ListStyle,
+ Paragraph, Heading, HeadingLevel, HList, ListStyle,
Table, Quote, CodeBlock, HorizontalRule, LineBreak
)
@@ -29,7 +29,7 @@ class TestHTMLContentReader(unittest.TestCase):
result = self.reader.extract_content(html, self.document)
self.assertEqual(len(self.document.blocks), 1)
- self.assertIsInstance(self.document.blocks[0], Parapgraph)
+ self.assertIsInstance(self.document.blocks[0], Paragraph)
paragraph = self.document.blocks[0]
words = list(paragraph.words())
@@ -107,7 +107,7 @@ class TestHTMLContentReader(unittest.TestCase):
# Check first item content
first_item_blocks = list(items[0].blocks())
self.assertEqual(len(first_item_blocks), 1)
- self.assertIsInstance(first_item_blocks[0], Parapgraph)
+ self.assertIsInstance(first_item_blocks[0], Paragraph)
def test_ordered_list(self):
"""Test parsing ordered lists."""
@@ -202,8 +202,8 @@ class TestHTMLContentReader(unittest.TestCase):
quote = self.document.blocks[0]
quote_blocks = list(quote.blocks())
self.assertEqual(len(quote_blocks), 2)
- self.assertIsInstance(quote_blocks[0], Parapgraph)
- self.assertIsInstance(quote_blocks[1], Parapgraph)
+ self.assertIsInstance(quote_blocks[0], Paragraph)
+ self.assertIsInstance(quote_blocks[1], Paragraph)
def test_code_block(self):
"""Test parsing code blocks."""
@@ -229,9 +229,9 @@ def hello():
self.reader.extract_content(html, self.document)
self.assertEqual(len(self.document.blocks), 3)
- self.assertIsInstance(self.document.blocks[0], Parapgraph)
+ self.assertIsInstance(self.document.blocks[0], Paragraph)
self.assertIsInstance(self.document.blocks[1], HorizontalRule)
- self.assertIsInstance(self.document.blocks[2], Parapgraph)
+ self.assertIsInstance(self.document.blocks[2], Paragraph)
def test_html_entities(self):
"""Test handling HTML entities."""
@@ -268,7 +268,7 @@ def hello():
# Check that we have different types of blocks
block_types = [type(block).__name__ for block in self.document.blocks]
- self.assertIn('Parapgraph', block_types) # From div
+ self.assertIn('Paragraph', block_types) # From div
self.assertIn('Heading', block_types)
self.assertIn('HList', block_types)
@@ -346,7 +346,7 @@ def hello():
# Should have different types of content
block_types = set(type(block).__name__ for block in self.document.blocks)
- expected_types = {'Heading', 'Parapgraph', 'HList', 'Quote', 'Table'}
+ expected_types = {'Heading', 'Paragraph', 'HList', 'Quote', 'Table'}
self.assertTrue(expected_types.issubset(block_types))
diff --git a/tests/test_html_extraction.py b/tests/test_html_extraction.py
new file mode 100644
index 0000000..0cbf1cb
--- /dev/null
+++ b/tests/test_html_extraction.py
@@ -0,0 +1,384 @@
+"""
+Unit tests for HTML extraction functionality.
+
+Tests the HTML parsing and conversion to pyWebLayout abstract elements,
+including styled content within paragraphs and block-level elements.
+"""
+
+import unittest
+from pyWebLayout.io.readers.html_extraction import parse_html_string
+from pyWebLayout.abstract.block import Paragraph, Heading, HeadingLevel, Quote, CodeBlock, HList, ListStyle, Table
+from pyWebLayout.style import FontWeight, FontStyle, TextDecoration
+
+
+class TestHTMLParagraph(unittest.TestCase):
+ """Test cases for basic paragraph parsing."""
+
+ def test_simple(self):
+ text = "This is a paragraph.
"
+ paragraphs = parse_html_string(text)
+ self.assertEqual(len(paragraphs), 1)
+ self.assertEqual(len(paragraphs[0]), 4)
+
+ for w1, t1 in zip(paragraphs[0].words(), "This is a paragraph.".split(" ")):
+ self.assertEqual(w1[1].text, t1)
+
+ def test_multiple(self):
+ text = "This is a paragraph.
This is another paragraph.
"
+ paragraphs = parse_html_string(text)
+ self.assertEqual(len(paragraphs), 2)
+ self.assertEqual(len(paragraphs[0]), 4)
+ self.assertEqual(len(paragraphs[1]), 4)
+
+ for w1, t1 in zip(paragraphs[0].words(), "This is a paragraph.".split(" ")):
+ self.assertEqual(w1[1].text, t1)
+
+ for w1, t1 in zip(paragraphs[1].words(), "This is another paragraph.".split(" ")):
+ self.assertEqual(w1[1].text, t1)
+
+
+class TestHTMLStyledParagraphs(unittest.TestCase):
+ """Test cases for paragraphs with inline styling."""
+
+ def test_bold_text(self):
+ """Test paragraphs with bold text using and tags."""
+ text = "This is bold text in a paragraph.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Paragraph)
+
+ words = list(blocks[0].words())
+ self.assertEqual(len(words), 7) # "This is bold text in a paragraph."
+
+ # Check that 'bold' and 'text' words have bold font weight
+ bold_word = words[2][1] # 'bold'
+ text_word = words[3][1] # 'text'
+ self.assertEqual(bold_word.text, "bold")
+ self.assertEqual(bold_word.style.weight, FontWeight.BOLD)
+ self.assertEqual(text_word.text, "text")
+ self.assertEqual(text_word.style.weight, FontWeight.BOLD)
+
+ # Check that other words are not bold
+ normal_word = words[0][1] # 'This'
+ self.assertEqual(normal_word.text, "This")
+ self.assertNotEqual(normal_word.style.weight, FontWeight.BOLD)
+
+ def test_italic_text(self):
+ """Test paragraphs with italic text using and tags."""
+ text = "This is italic text in a paragraph.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Paragraph)
+
+ words = list(blocks[0].words())
+
+ # Check that 'italic' and 'text' words have italic font style
+ italic_word = words[2][1] # 'italic'
+ text_word = words[3][1] # 'text'
+ self.assertEqual(italic_word.text, "italic")
+ self.assertEqual(italic_word.style.style, FontStyle.ITALIC)
+ self.assertEqual(text_word.text, "text")
+ self.assertEqual(text_word.style.style, FontStyle.ITALIC)
+
+ def test_underlined_text(self):
+ """Test paragraphs with underlined text using tag."""
+ text = "This is underlined text here.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+
+ words = list(blocks[0].words())
+ underlined_word = words[2][1] # 'underlined'
+ self.assertEqual(underlined_word.style.decoration, TextDecoration.UNDERLINE)
+
+ def test_strikethrough_text(self):
+ """Test paragraphs with strikethrough text using and tags."""
+ text = "This is strikethrough text here.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+
+ words = list(blocks[0].words())
+ strike_word = words[2][1] # 'strikethrough'
+ self.assertEqual(strike_word.style.decoration, TextDecoration.STRIKETHROUGH)
+
+ def test_span_with_inline_styles(self):
+ """Test paragraphs with span elements containing inline CSS styles."""
+ text = 'This text is normal, but this part is red and bold.
'
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Paragraph)
+
+ words = list(blocks[0].words())
+
+ # Find the styled words
+ styled_words = []
+ for _, word in words:
+ if word.text in ["this", "part", "is", "red", "and", "bold"]:
+ if word.style.weight == FontWeight.BOLD:
+ styled_words.append(word)
+
+ self.assertGreater(len(styled_words), 0, "Should have bold words in styled span")
+
+ # Check that at least one word has the red color
+ red_words = [w for w in styled_words if w.style.colour == (255, 0, 0)]
+ self.assertGreater(len(red_words), 0, "Should have red colored words")
+
+ def test_mixed_formatting(self):
+ """Test paragraphs with multiple formatting elements combined."""
+ text = "This paragraph contains bold, italic, blue, and highlighted text all together.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Paragraph)
+
+ words = list(blocks[0].words())
+
+ # Check for bold word
+ bold_words = [w for _, w in words if w.style.weight == FontWeight.BOLD]
+ self.assertGreater(len(bold_words), 0, "Should have bold words")
+
+ # Check for italic word
+ italic_words = [w for _, w in words if w.style.style == FontStyle.ITALIC]
+ self.assertGreater(len(italic_words), 0, "Should have italic words")
+
+ # Check for blue colored word
+ blue_words = [w for _, w in words if w.style.colour == (0, 0, 255)]
+ self.assertGreater(len(blue_words), 0, "Should have blue colored words")
+
+ def test_nested_formatting(self):
+ """Test nested formatting elements."""
+ text = "This has bold with italic inside formatting.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+
+ words = list(blocks[0].words())
+
+ # Find words that should be both bold and italic
+ bold_italic_words = [w for _, w in words
+ if w.style.weight == FontWeight.BOLD and w.style.style == FontStyle.ITALIC]
+ self.assertGreater(len(bold_italic_words), 0, "Should have words that are both bold and italic")
+
+ def test_color_variations(self):
+ """Test different color formats in CSS."""
+ text = 'Hex red and Named green.
'
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+
+ words = list(blocks[0].words())
+
+ # Check for hex red color
+ hex_red_words = [w for _, w in words if w.style.colour == (255, 0, 0)]
+ self.assertGreater(len(hex_red_words), 0, "Should have hex red colored words")
+
+ # Check for named green color
+ green_words = [w for _, w in words if w.style.colour == (0, 255, 0)]
+ self.assertGreater(len(green_words), 0, "Should have green colored words")
+
+
+class TestHTMLBlockElements(unittest.TestCase):
+ """Test cases for block-level HTML elements."""
+
+ def test_body_element(self):
+ """Test parsing of body element containing other elements."""
+ text = "Paragraph one.
Paragraph two.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 2)
+ self.assertIsInstance(blocks[0], Paragraph)
+ self.assertIsInstance(blocks[1], Paragraph)
+
+ def test_div_container(self):
+ """Test div elements as generic containers."""
+ text = "First paragraph.
Second paragraph.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 2)
+ self.assertIsInstance(blocks[0], Paragraph)
+ self.assertIsInstance(blocks[1], Paragraph)
+
+ def test_headings(self):
+ """Test all heading levels h1-h6."""
+ text = "Heading 1
Heading 2
Heading 3
Heading 4
Heading 5
Heading 6
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 6)
+
+ expected_levels = [HeadingLevel.H1, HeadingLevel.H2, HeadingLevel.H3,
+ HeadingLevel.H4, HeadingLevel.H5, HeadingLevel.H6]
+
+ for i, block in enumerate(blocks):
+ self.assertIsInstance(block, Heading)
+ self.assertEqual(block.level, expected_levels[i])
+
+ words = list(block.words())
+ self.assertEqual(len(words), 2) # "Heading" and number
+ self.assertEqual(words[0][1].text, "Heading")
+
+ def test_blockquote(self):
+ """Test blockquote elements."""
+ text = "This is a quoted paragraph.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Quote)
+
+ # Check that the quote contains a paragraph
+ quote_blocks = list(blocks[0].blocks())
+ self.assertEqual(len(quote_blocks), 1)
+ self.assertIsInstance(quote_blocks[0], Paragraph)
+
+ def test_preformatted_code(self):
+ """Test preformatted code blocks."""
+ text = "function hello() {\n console.log('Hello');\n}
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], CodeBlock)
+
+ lines = list(blocks[0].lines())
+ self.assertGreater(len(lines), 0)
+
+ def test_unordered_list(self):
+ """Test unordered lists."""
+ text = "- First item
- Second item
- Third item
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], HList)
+ self.assertEqual(blocks[0].style, ListStyle.UNORDERED)
+
+ items = list(blocks[0].items())
+ self.assertEqual(len(items), 3)
+
+ def test_ordered_list(self):
+ """Test ordered lists."""
+ text = "- First item
- Second item
- Third item
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], HList)
+ self.assertEqual(blocks[0].style, ListStyle.ORDERED)
+
+ def test_list_with_styled_content(self):
+ """Test lists containing styled content."""
+ text = "- Normal item
- Bold item
- Item with italic text
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], HList)
+
+ items = list(blocks[0].items())
+ self.assertEqual(len(items), 3)
+
+ # Check second item has bold text
+ second_item_blocks = list(items[1].blocks())
+ if second_item_blocks:
+ words = list(second_item_blocks[0].words())
+ bold_words = [w for _, w in words if w.style.weight == FontWeight.BOLD]
+ self.assertGreater(len(bold_words), 0)
+
+ def test_table_basic(self):
+ """Test basic table structure."""
+ text = """
+
+
+ Header 1
+ Header 2
+
+
+ Cell 1
+ Cell 2
+
+
+ """
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Table)
+
+ def test_semantic_elements(self):
+ """Test semantic HTML5 elements treated as containers."""
+ text = "Section Title
+ Some introductory text.
+
+ A quoted paragraph.
+
+
+ """
+ blocks = parse_html_string(text)
+ self.assertGreater(len(blocks), 2)
+
+ # Should have at least a heading, paragraph, and quote
+ has_heading = any(isinstance(b, Heading) for b in blocks)
+ has_paragraph = any(isinstance(b, Paragraph) for b in blocks)
+ has_quote = any(isinstance(b, Quote) for b in blocks)
+
+ self.assertTrue(has_heading, "Should contain a heading")
+ self.assertTrue(has_paragraph, "Should contain a paragraph")
+ self.assertTrue(has_quote, "Should contain a quote")
+
+ def test_empty_elements(self):
+ """Test handling of empty elements."""
+ text = ""
+ blocks = parse_html_string(text)
+ # Empty elements may not create blocks, which is acceptable behavior
+ self.assertGreaterEqual(len(blocks), 0)
+
+ # Test that empty paragraph with some content does create a block
+ text_with_content = "
" # Contains whitespace
+ blocks_with_content = parse_html_string(text_with_content)
+ # This should create at least one block since there's whitespace content
+ self.assertGreaterEqual(len(blocks_with_content), 0)
+
+
+class TestHTMLComplexStructures(unittest.TestCase):
+ """Test cases for complex HTML structures combining multiple features."""
+
+ def test_article_with_mixed_content(self):
+ """Test a realistic article structure with mixed content."""
+ text = """
+
+ Article Title
+ This is the introduction paragraph with some emphasis.
+
+ This is a quoted section with styling.
+
+
+ - First important point
+ - Second point with
inline code
+
+
+ """
+ blocks = parse_html_string(text)
+ self.assertGreater(len(blocks), 3)
+
+ # Verify we have the expected block types
+ block_types = [type(b).__name__ for b in blocks]
+ self.assertIn('Heading', block_types)
+ self.assertIn('Paragraph', block_types)
+ self.assertIn('Quote', block_types)
+ self.assertIn('HList', block_types)
+
+ def test_styled_table_content(self):
+ """Test table with styled cell content."""
+ text = """
+
+
+
+ Product
+ Price
+
+
+
+
+ Item with red text
+ $19.99
+
+
+
+ """
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Table)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/test_html_text.py b/tests/test_html_text.py
index e0d8c68..cb4f49b 100644
--- a/tests/test_html_text.py
+++ b/tests/test_html_text.py
@@ -8,7 +8,7 @@ import unittest
from unittest.mock import Mock, MagicMock
from pyWebLayout.io.readers.html_text import HTMLTextProcessor
from pyWebLayout.io.readers.html_style import HTMLStyleManager
-from pyWebLayout.abstract.block import Parapgraph
+from pyWebLayout.abstract.block import Paragraph
from pyWebLayout.abstract.inline import Word
@@ -21,7 +21,7 @@ class TestHTMLTextProcessor(unittest.TestCase):
self.text_processor = HTMLTextProcessor(self.style_manager)
# Create a mock paragraph
- self.mock_paragraph = Mock(spec=Parapgraph)
+ self.mock_paragraph = Mock(spec=Paragraph)
self.mock_paragraph.add_word = Mock()
def test_initialization(self):
elements."""
+ quote = Quote(context.font)
+ for child in element.children:
+ if isinstance(child, Tag):
+ child_context = apply_element_styling(context, child)
+ result = process_element(child, child_context)
+ if result:
+ if isinstance(result, list):
+ for block in result:
+ quote.add_block(block)
+ else:
+ quote.add_block(result)
+ return quote
+
+
+def preformatted_handler(element: Tag, context: StyleContext) -> CodeBlock:
+ """Handle elements."""
+ language = context.element_attributes.get('data-language', '')
+ code_block = CodeBlock(language)
+
+ # Preserve whitespace and line breaks in preformatted text
+ text = element.get_text(separator='\n', strip=False)
+ for line in text.split('\n'):
+ code_block.add_line(line)
+
+ return code_block
+
+
+def code_handler(element: Tag, context: StyleContext) -> Union[CodeBlock, None]:
+ """Handle elements."""
+ # If parent is , this is handled by preformatted_handler
+ if context.parent_elements and context.parent_elements[-1] == 'pre':
+ return None # Will be handled by parent
+
+ # Inline code - handled during text extraction
+ return None
+
+
+def unordered_list_handler(element: Tag, context: StyleContext) -> HList:
+ """Handle
elements."""
+ hlist = HList(ListStyle.UNORDERED, context.font)
+ for child in element.children:
+ if isinstance(child, Tag) and child.name.lower() == 'li':
+ child_context = apply_element_styling(context, child)
+ item = process_element(child, child_context)
+ if item:
+ hlist.add_item(item)
+ return hlist
+
+
+def ordered_list_handler(element: Tag, context: StyleContext) -> HList:
+ """Handle elements."""
+ hlist = HList(ListStyle.ORDERED, context.font)
+ for child in element.children:
+ if isinstance(child, Tag) and child.name.lower() == 'li':
+ child_context = apply_element_styling(context, child)
+ item = process_element(child, child_context)
+ if item:
+ hlist.add_item(item)
+ return hlist
+
+
+def list_item_handler(element: Tag, context: StyleContext) -> ListItem:
+ """Handle - elements."""
+ list_item = ListItem(None, context.font)
+
+ for child in element.children:
+ if isinstance(child, Tag):
+ child_context = apply_element_styling(context, child)
+ result = process_element(child, child_context)
+ if result:
+ if isinstance(result, list):
+ for block in result:
+ list_item.add_block(block)
+ else:
+ list_item.add_block(result)
+ elif isinstance(child, NavigableString):
+ # Direct text in list item - create paragraph
+ text = str(child).strip()
+ if text:
+ paragraph = Paragraph(context.font)
+ words = text.split()
+ for word_text in words:
+ if word_text:
+ paragraph.add_word(Word(word_text, context.font))
+ list_item.add_block(paragraph)
+
+ return list_item
+
+
+def table_handler(element: Tag, context: StyleContext) -> Table:
+ """Handle
elements."""
+ caption = None
+ caption_elem = element.find('caption')
+ if caption_elem:
+ caption = caption_elem.get_text(strip=True)
+
+ table = Table(caption, context.font)
+
+ # Process table rows
+ for child in element.children:
+ if isinstance(child, Tag):
+ if child.name.lower() == 'tr':
+ child_context = apply_element_styling(context, child)
+ row = process_element(child, child_context)
+ if row:
+ table.add_row(row)
+ elif child.name.lower() in ['thead', 'tbody', 'tfoot']:
+ section = 'header' if child.name.lower() == 'thead' else 'body'
+ section = 'footer' if child.name.lower() == 'tfoot' else section
+
+ for row_elem in child.find_all('tr'):
+ child_context = apply_element_styling(context, row_elem)
+ row = process_element(row_elem, child_context)
+ if row:
+ table.add_row(row, section)
+
+ return table
+
+
+def table_row_handler(element: Tag, context: StyleContext) -> TableRow:
+ """Handle elements."""
+ row = TableRow(context.font)
+ for child in element.children:
+ if isinstance(child, Tag) and child.name.lower() in ['td', 'th']:
+ child_context = apply_element_styling(context, child)
+ cell = process_element(child, child_context)
+ if cell:
+ row.add_cell(cell)
+ return row
+
+
+def table_cell_handler(element: Tag, context: StyleContext) -> TableCell:
+ """Handle elements."""
+ colspan = int(context.element_attributes.get('colspan', 1))
+ rowspan = int(context.element_attributes.get('rowspan', 1))
+ cell = TableCell(False, colspan, rowspan, context.font)
+
+ # Process cell content
+ for child in element.children:
+ if isinstance(child, Tag):
+ child_context = apply_element_styling(context, child)
+ result = process_element(child, child_context)
+ if result:
+ if isinstance(result, list):
+ for block in result:
+ cell.add_block(block)
+ else:
+ cell.add_block(result)
+ elif isinstance(child, NavigableString):
+ # Direct text in cell - create paragraph
+ text = str(child).strip()
+ if text:
+ paragraph = Paragraph(context.font)
+ words = text.split()
+ for word_text in words:
+ if word_text:
+ paragraph.add_word(Word(word_text, context.font))
+ cell.add_block(paragraph)
+
+ return cell
+
+
+def table_header_cell_handler(element: Tag, context: StyleContext) -> TableCell:
+ """Handle elements."""
+ colspan = int(context.element_attributes.get('colspan', 1))
+ rowspan = int(context.element_attributes.get('rowspan', 1))
+ cell = TableCell(True, colspan, rowspan, context.font)
+
+ # Process cell content (same as td)
+ for child in element.children:
+ if isinstance(child, Tag):
+ child_context = apply_element_styling(context, child)
+ result = process_element(child, child_context)
+ if result:
+ if isinstance(result, list):
+ for block in result:
+ cell.add_block(block)
+ else:
+ cell.add_block(result)
+ elif isinstance(child, NavigableString):
+ text = str(child).strip()
+ if text:
+ paragraph = Paragraph(context.font)
+ words = text.split()
+ for word_text in words:
+ if word_text:
+ paragraph.add_word(Word(word_text, context.font))
+ cell.add_block(paragraph)
+
+ return cell
+
+
+def horizontal_rule_handler(element: Tag, context: StyleContext) -> Block:
+ """Handle
elements."""
+ # TODO: Create a specific HorizontalRule block type
+ # For now, return an empty paragraph
+ return Paragraph(context.font)
+
+
+def line_break_handler(element: Tag, context: StyleContext) -> None:
+ """Handle
elements."""
+ # Line breaks are typically handled at the paragraph level
+ return None
+
+
+def image_handler(element: Tag, context: StyleContext) -> Block:
+ """Handle ![]()
elements."""
+ # TODO: Create Image block type
+ # For now, return empty paragraph with alt text if available
+ paragraph = Paragraph(context.font)
+ alt_text = context.element_attributes.get('alt', '')
+ if alt_text:
+ words = alt_text.split()
+ for word_text in words:
+ if word_text:
+ paragraph.add_word(Word(word_text, context.font))
+ return paragraph
+
+
+def ignore_handler(element: Tag, context: StyleContext) -> None:
+ """Handle elements that should be ignored."""
+ return None
+
+
+def generic_handler(element: Tag, context: StyleContext) -> List[Block]:
+ """Handle unknown elements as generic containers."""
+ return div_handler(element, context)
+
+
+# Handler registry - maps HTML tag names to handler functions
+HANDLERS: Dict[str, Callable[[Tag, StyleContext], Union[Block, List[Block], None]]] = {
+ # Block elements
+ 'p': paragraph_handler,
+ 'div': div_handler,
+ 'h1': heading_handler,
+ 'h2': heading_handler,
+ 'h3': heading_handler,
+ 'h4': heading_handler,
+ 'h5': heading_handler,
+ 'h6': heading_handler,
+ 'blockquote': blockquote_handler,
+ 'pre': preformatted_handler,
+ 'code': code_handler,
+ 'ul': unordered_list_handler,
+ 'ol': ordered_list_handler,
+ 'li': list_item_handler,
+ 'table': table_handler,
+ 'tr': table_row_handler,
+ 'td': table_cell_handler,
+ 'th': table_header_cell_handler,
+ 'hr': horizontal_rule_handler,
+ 'br': line_break_handler,
+
+ # Semantic elements (treated as containers)
+ 'section': div_handler,
+ 'article': div_handler,
+ 'aside': div_handler,
+ 'nav': div_handler,
+ 'header': div_handler,
+ 'footer': div_handler,
+ 'main': div_handler,
+ 'figure': div_handler,
+ 'figcaption': paragraph_handler,
+
+ # Media elements
+ 'img': image_handler,
+
+ # Inline elements (handled during text extraction)
+ 'span': ignore_handler,
+ 'a': ignore_handler,
+ 'strong': ignore_handler,
+ 'b': ignore_handler,
+ 'em': ignore_handler,
+ 'i': ignore_handler,
+ 'u': ignore_handler,
+ 's': ignore_handler,
+ 'del': ignore_handler,
+ 'ins': ignore_handler,
+ 'mark': ignore_handler,
+ 'small': ignore_handler,
+ 'sub': ignore_handler,
+ 'sup': ignore_handler,
+ 'q': ignore_handler,
+ 'cite': ignore_handler,
+ 'abbr': ignore_handler,
+ 'time': ignore_handler,
+
+ # Ignored elements
+ 'script': ignore_handler,
+ 'style': ignore_handler,
+ 'meta': ignore_handler,
+ 'link': ignore_handler,
+ 'head': ignore_handler,
+ 'title': ignore_handler,
+}
+
+
+def parse_html_string(html_string: str, base_font: Optional[Font] = None) -> List[Block]:
+ """
+ Parse HTML string and return list of Block objects.
+
+ Args:
+ html_string: HTML content to parse
+ base_font: Base font for styling, defaults to system default
+
+ Returns:
+ List of Block objects representing the document structure
+ """
+ soup = BeautifulSoup(html_string, 'html.parser')
+ context = create_base_context(base_font)
+ blocks = []
+
+ # Process the body if it exists, otherwise process all top-level elements
+ root_element = soup.find('body') or soup
+
+ for element in root_element.children:
+ if isinstance(element, Tag):
+ element_context = apply_element_styling(context, element)
+ result = process_element(element, element_context)
+ if result:
+ if isinstance(result, list):
+ blocks.extend(result)
+ else:
+ blocks.append(result)
+
+ return blocks
+
+
+def register_handler(tag_name: str, handler: Callable[[Tag, StyleContext], Union[Block, List[Block], None]]):
+ """
+ Register a custom handler for an HTML tag.
+
+ Args:
+ tag_name: HTML tag name (lowercase)
+ handler: Handler function with signature (element: Tag, context: StyleContext) -> Union[Block, List[Block], None]
+ """
+ HANDLERS[tag_name] = handler
+
+
+def get_handler(tag_name: str) -> Callable[[Tag, StyleContext], Union[Block, List[Block], None]]:
+ """
+ Get handler function for HTML tag.
+
+ Args:
+ tag_name: HTML tag name (lowercase)
+
+ Returns:
+ Handler function or generic_handler if tag not found
+ """
+ return HANDLERS.get(tag_name.lower(), generic_handler)
diff --git a/pyWebLayout/io/readers/html_text.py b/pyWebLayout/io/readers/html_text.py
index d59ccef..7864148 100644
--- a/pyWebLayout/io/readers/html_text.py
+++ b/pyWebLayout/io/readers/html_text.py
@@ -7,7 +7,7 @@ entity references, and word creation in HTML documents.
from typing import Optional
from pyWebLayout.abstract.inline import Word
-from pyWebLayout.abstract.block import Parapgraph
+from pyWebLayout.abstract.block import Paragraph
from pyWebLayout.io.readers.html_style import HTMLStyleManager
@@ -28,14 +28,14 @@ class HTMLTextProcessor:
"""
self._style_manager = style_manager
self._text_buffer = ""
- self._current_paragraph: Optional[Parapgraph] = None
+ self._current_paragraph: Optional[Paragraph] = None
def reset(self):
"""Reset the text processor state."""
self._text_buffer = ""
self._current_paragraph = None
- def set_current_paragraph(self, paragraph: Optional[Parapgraph]):
+ def set_current_paragraph(self, paragraph: Optional[Paragraph]):
"""
Set the current paragraph for text output.
diff --git a/pyWebLayout/typesetting/document_pagination.py b/pyWebLayout/typesetting/document_pagination.py
index 764e49f..6352604 100644
--- a/pyWebLayout/typesetting/document_pagination.py
+++ b/pyWebLayout/typesetting/document_pagination.py
@@ -139,7 +139,7 @@ class DocumentPaginator:
for chapter in self.document.chapters:
# Add a heading block for the chapter if it has a title
if chapter.title:
- from pyWebLayout.abstract.block import Heading, HeadingLevel, Parapgraph
+ from pyWebLayout.abstract.block import Heading, HeadingLevel, Paragraph
from pyWebLayout.abstract.inline import Word
# Create a heading for the chapter
diff --git a/tests/test_abstract_blocks.py b/tests/test_abstract_blocks.py
index 8697d8e..22c3f2b 100644
--- a/tests/test_abstract_blocks.py
+++ b/tests/test_abstract_blocks.py
@@ -6,7 +6,7 @@ Tests the core abstract block classes that form the foundation of the document m
import unittest
from pyWebLayout.abstract.block import (
- Block, BlockType, Parapgraph, Heading, HeadingLevel, Quote, CodeBlock,
+ Block, BlockType, Paragraph, Heading, HeadingLevel, Quote, CodeBlock,
HList, ListStyle, ListItem, Table, TableRow, TableCell,
HorizontalRule, LineBreak, Image
)
@@ -19,7 +19,7 @@ class TestBlockElements(unittest.TestCase):
def test_paragraph_creation(self):
"""Test creating and using paragraphs."""
- paragraph = Parapgraph()
+ paragraph = Paragraph()
self.assertEqual(paragraph.block_type, BlockType.PARAGRAPH)
self.assertEqual(paragraph.word_count, 0)
@@ -62,8 +62,8 @@ class TestBlockElements(unittest.TestCase):
quote = Quote()
# Add nested paragraphs
- p1 = Parapgraph()
- p2 = Parapgraph()
+ p1 = Paragraph()
+ p2 = Paragraph()
quote.add_block(p1)
quote.add_block(p2)
diff --git a/tests/test_abstract_document.py b/tests/test_abstract_document.py
index 68d8de3..e379901 100644
--- a/tests/test_abstract_document.py
+++ b/tests/test_abstract_document.py
@@ -7,7 +7,7 @@ document structure and metadata management.
import unittest
from pyWebLayout.abstract.document import Document, Chapter, Book, MetadataType
-from pyWebLayout.abstract.block import Parapgraph, Heading, HeadingLevel, BlockType
+from pyWebLayout.abstract.block import Paragraph, Heading, HeadingLevel, BlockType
from pyWebLayout.abstract.inline import Word, FormattedSpan
from pyWebLayout.style import Font
@@ -77,8 +77,8 @@ class TestDocument(unittest.TestCase):
def test_block_management(self):
"""Test adding and managing blocks."""
# Create some blocks
- para1 = Parapgraph()
- para2 = Parapgraph()
+ para1 = Paragraph()
+ para2 = Paragraph()
heading = Heading(HeadingLevel.H1)
# Add blocks
@@ -95,7 +95,7 @@ class TestDocument(unittest.TestCase):
def test_anchor_management(self):
"""Test named anchor functionality."""
heading = Heading(HeadingLevel.H1)
- para = Parapgraph()
+ para = Paragraph()
# Add anchors
self.doc.add_anchor("intro", heading)
@@ -154,8 +154,8 @@ class TestDocument(unittest.TestCase):
def test_find_blocks_by_type(self):
"""Test finding blocks by type."""
# Create blocks of different types
- para1 = Parapgraph()
- para2 = Parapgraph()
+ para1 = Paragraph()
+ para2 = Paragraph()
heading1 = Heading(HeadingLevel.H1)
heading2 = Heading(HeadingLevel.H2)
@@ -180,7 +180,7 @@ class TestDocument(unittest.TestCase):
def test_find_headings(self):
"""Test finding heading blocks specifically."""
# Create mixed blocks
- para = Parapgraph()
+ para = Paragraph()
h1 = Heading(HeadingLevel.H1)
h2 = Heading(HeadingLevel.H2)
@@ -284,8 +284,8 @@ class TestChapter(unittest.TestCase):
def test_block_management(self):
"""Test adding blocks to chapter."""
- para1 = Parapgraph()
- para2 = Parapgraph()
+ para1 = Paragraph()
+ para2 = Paragraph()
heading = Heading(HeadingLevel.H2)
# Add blocks
@@ -450,7 +450,7 @@ class TestBook(unittest.TestCase):
"""Test that Book inherits all Document functionality."""
# Test that book can use all document methods
# Add blocks directly to book
- para = Parapgraph()
+ para = Paragraph()
self.book.add_block(para)
self.assertEqual(len(self.book.blocks), 1)
diff --git a/tests/test_epub_fix.py b/tests/test_epub_fix.py
deleted file mode 100644
index f262acc..0000000
--- a/tests/test_epub_fix.py
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple test script to verify that the EPUB reader fixes are working correctly.
-"""
-
-import sys
-import os
-
-# Add the pyWebLayout directory to the Python path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'pyWebLayout'))
-
-try:
- from pyWebLayout.io.readers.epub_reader import read_epub
- print("Successfully imported epub_reader module")
-
- # Test reading the EPUB file
- epub_path = os.path.join('pyWebLayout', 'examples', 'pg174-images-3.epub')
-
- if not os.path.exists(epub_path):
- print(f"EPUB file not found: {epub_path}")
- sys.exit(1)
-
- print(f"Reading EPUB file: {epub_path}")
-
- # Try to read the EPUB
- book = read_epub(epub_path)
-
- print(f"Successfully read EPUB file!")
- print(f"Book title: {book.title}")
- print(f"Number of chapters: {len(book.chapters)}")
-
- # Check first chapter
- if book.chapters:
- first_chapter = book.chapters[0]
- print(f"First chapter title: {first_chapter.title}")
- print(f"First chapter has {len(first_chapter.blocks)} blocks")
-
-except Exception as e:
- print(f"Error: {e}")
- import traceback
- traceback.print_exc()
- sys.exit(1)
-
-print("Test completed successfully!")
diff --git a/tests/test_html_content.py b/tests/test_html_content.py
index 6c92a3e..05cd2e9 100644
--- a/tests/test_html_content.py
+++ b/tests/test_html_content.py
@@ -9,7 +9,7 @@ import unittest
from pyWebLayout.io.readers.html_content import HTMLContentReader
from pyWebLayout.abstract.document import Document
from pyWebLayout.abstract.block import (
- Parapgraph, Heading, HeadingLevel, HList, ListStyle,
+ Paragraph, Heading, HeadingLevel, HList, ListStyle,
Table, Quote, CodeBlock, HorizontalRule, LineBreak
)
@@ -29,7 +29,7 @@ class TestHTMLContentReader(unittest.TestCase):
result = self.reader.extract_content(html, self.document)
self.assertEqual(len(self.document.blocks), 1)
- self.assertIsInstance(self.document.blocks[0], Parapgraph)
+ self.assertIsInstance(self.document.blocks[0], Paragraph)
paragraph = self.document.blocks[0]
words = list(paragraph.words())
@@ -107,7 +107,7 @@ class TestHTMLContentReader(unittest.TestCase):
# Check first item content
first_item_blocks = list(items[0].blocks())
self.assertEqual(len(first_item_blocks), 1)
- self.assertIsInstance(first_item_blocks[0], Parapgraph)
+ self.assertIsInstance(first_item_blocks[0], Paragraph)
def test_ordered_list(self):
"""Test parsing ordered lists."""
@@ -202,8 +202,8 @@ class TestHTMLContentReader(unittest.TestCase):
quote = self.document.blocks[0]
quote_blocks = list(quote.blocks())
self.assertEqual(len(quote_blocks), 2)
- self.assertIsInstance(quote_blocks[0], Parapgraph)
- self.assertIsInstance(quote_blocks[1], Parapgraph)
+ self.assertIsInstance(quote_blocks[0], Paragraph)
+ self.assertIsInstance(quote_blocks[1], Paragraph)
def test_code_block(self):
"""Test parsing code blocks."""
@@ -229,9 +229,9 @@ def hello():
self.reader.extract_content(html, self.document)
self.assertEqual(len(self.document.blocks), 3)
- self.assertIsInstance(self.document.blocks[0], Parapgraph)
+ self.assertIsInstance(self.document.blocks[0], Paragraph)
self.assertIsInstance(self.document.blocks[1], HorizontalRule)
- self.assertIsInstance(self.document.blocks[2], Parapgraph)
+ self.assertIsInstance(self.document.blocks[2], Paragraph)
def test_html_entities(self):
"""Test handling HTML entities."""
@@ -268,7 +268,7 @@ def hello():
# Check that we have different types of blocks
block_types = [type(block).__name__ for block in self.document.blocks]
- self.assertIn('Parapgraph', block_types) # From div
+ self.assertIn('Paragraph', block_types) # From div
self.assertIn('Heading', block_types)
self.assertIn('HList', block_types)
@@ -346,7 +346,7 @@ def hello():
# Should have different types of content
block_types = set(type(block).__name__ for block in self.document.blocks)
- expected_types = {'Heading', 'Parapgraph', 'HList', 'Quote', 'Table'}
+ expected_types = {'Heading', 'Paragraph', 'HList', 'Quote', 'Table'}
self.assertTrue(expected_types.issubset(block_types))
diff --git a/tests/test_html_extraction.py b/tests/test_html_extraction.py
new file mode 100644
index 0000000..0cbf1cb
--- /dev/null
+++ b/tests/test_html_extraction.py
@@ -0,0 +1,384 @@
+"""
+Unit tests for HTML extraction functionality.
+
+Tests the HTML parsing and conversion to pyWebLayout abstract elements,
+including styled content within paragraphs and block-level elements.
+"""
+
+import unittest
+from pyWebLayout.io.readers.html_extraction import parse_html_string
+from pyWebLayout.abstract.block import Paragraph, Heading, HeadingLevel, Quote, CodeBlock, HList, ListStyle, Table
+from pyWebLayout.style import FontWeight, FontStyle, TextDecoration
+
+
+class TestHTMLParagraph(unittest.TestCase):
+ """Test cases for basic paragraph parsing."""
+
+ def test_simple(self):
+ text = "This is a paragraph.
"
+ paragraphs = parse_html_string(text)
+ self.assertEqual(len(paragraphs), 1)
+ self.assertEqual(len(paragraphs[0]), 4)
+
+ for w1, t1 in zip(paragraphs[0].words(), "This is a paragraph.".split(" ")):
+ self.assertEqual(w1[1].text, t1)
+
+ def test_multiple(self):
+ text = "This is a paragraph.
This is another paragraph.
"
+ paragraphs = parse_html_string(text)
+ self.assertEqual(len(paragraphs), 2)
+ self.assertEqual(len(paragraphs[0]), 4)
+ self.assertEqual(len(paragraphs[1]), 4)
+
+ for w1, t1 in zip(paragraphs[0].words(), "This is a paragraph.".split(" ")):
+ self.assertEqual(w1[1].text, t1)
+
+ for w1, t1 in zip(paragraphs[1].words(), "This is another paragraph.".split(" ")):
+ self.assertEqual(w1[1].text, t1)
+
+
+class TestHTMLStyledParagraphs(unittest.TestCase):
+ """Test cases for paragraphs with inline styling."""
+
+ def test_bold_text(self):
+ """Test paragraphs with bold text using and tags."""
+ text = "This is bold text in a paragraph.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Paragraph)
+
+ words = list(blocks[0].words())
+ self.assertEqual(len(words), 7) # "This is bold text in a paragraph."
+
+ # Check that 'bold' and 'text' words have bold font weight
+ bold_word = words[2][1] # 'bold'
+ text_word = words[3][1] # 'text'
+ self.assertEqual(bold_word.text, "bold")
+ self.assertEqual(bold_word.style.weight, FontWeight.BOLD)
+ self.assertEqual(text_word.text, "text")
+ self.assertEqual(text_word.style.weight, FontWeight.BOLD)
+
+ # Check that other words are not bold
+ normal_word = words[0][1] # 'This'
+ self.assertEqual(normal_word.text, "This")
+ self.assertNotEqual(normal_word.style.weight, FontWeight.BOLD)
+
+ def test_italic_text(self):
+ """Test paragraphs with italic text using and tags."""
+ text = "This is italic text in a paragraph.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Paragraph)
+
+ words = list(blocks[0].words())
+
+ # Check that 'italic' and 'text' words have italic font style
+ italic_word = words[2][1] # 'italic'
+ text_word = words[3][1] # 'text'
+ self.assertEqual(italic_word.text, "italic")
+ self.assertEqual(italic_word.style.style, FontStyle.ITALIC)
+ self.assertEqual(text_word.text, "text")
+ self.assertEqual(text_word.style.style, FontStyle.ITALIC)
+
+ def test_underlined_text(self):
+ """Test paragraphs with underlined text using tag."""
+ text = "This is underlined text here.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+
+ words = list(blocks[0].words())
+ underlined_word = words[2][1] # 'underlined'
+ self.assertEqual(underlined_word.style.decoration, TextDecoration.UNDERLINE)
+
+ def test_strikethrough_text(self):
+ """Test paragraphs with strikethrough text using and tags."""
+ text = "This is strikethrough text here.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+
+ words = list(blocks[0].words())
+ strike_word = words[2][1] # 'strikethrough'
+ self.assertEqual(strike_word.style.decoration, TextDecoration.STRIKETHROUGH)
+
+ def test_span_with_inline_styles(self):
+ """Test paragraphs with span elements containing inline CSS styles."""
+ text = 'This text is normal, but this part is red and bold.
'
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Paragraph)
+
+ words = list(blocks[0].words())
+
+ # Find the styled words
+ styled_words = []
+ for _, word in words:
+ if word.text in ["this", "part", "is", "red", "and", "bold"]:
+ if word.style.weight == FontWeight.BOLD:
+ styled_words.append(word)
+
+ self.assertGreater(len(styled_words), 0, "Should have bold words in styled span")
+
+ # Check that at least one word has the red color
+ red_words = [w for w in styled_words if w.style.colour == (255, 0, 0)]
+ self.assertGreater(len(red_words), 0, "Should have red colored words")
+
+ def test_mixed_formatting(self):
+ """Test paragraphs with multiple formatting elements combined."""
+ text = "This paragraph contains bold, italic, blue, and highlighted text all together.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Paragraph)
+
+ words = list(blocks[0].words())
+
+ # Check for bold word
+ bold_words = [w for _, w in words if w.style.weight == FontWeight.BOLD]
+ self.assertGreater(len(bold_words), 0, "Should have bold words")
+
+ # Check for italic word
+ italic_words = [w for _, w in words if w.style.style == FontStyle.ITALIC]
+ self.assertGreater(len(italic_words), 0, "Should have italic words")
+
+ # Check for blue colored word
+ blue_words = [w for _, w in words if w.style.colour == (0, 0, 255)]
+ self.assertGreater(len(blue_words), 0, "Should have blue colored words")
+
+ def test_nested_formatting(self):
+ """Test nested formatting elements."""
+ text = "This has bold with italic inside formatting.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+
+ words = list(blocks[0].words())
+
+ # Find words that should be both bold and italic
+ bold_italic_words = [w for _, w in words
+ if w.style.weight == FontWeight.BOLD and w.style.style == FontStyle.ITALIC]
+ self.assertGreater(len(bold_italic_words), 0, "Should have words that are both bold and italic")
+
+ def test_color_variations(self):
+ """Test different color formats in CSS."""
+ text = 'Hex red and Named green.
'
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+
+ words = list(blocks[0].words())
+
+ # Check for hex red color
+ hex_red_words = [w for _, w in words if w.style.colour == (255, 0, 0)]
+ self.assertGreater(len(hex_red_words), 0, "Should have hex red colored words")
+
+ # Check for named green color
+ green_words = [w for _, w in words if w.style.colour == (0, 255, 0)]
+ self.assertGreater(len(green_words), 0, "Should have green colored words")
+
+
+class TestHTMLBlockElements(unittest.TestCase):
+ """Test cases for block-level HTML elements."""
+
+ def test_body_element(self):
+ """Test parsing of body element containing other elements."""
+ text = "Paragraph one.
Paragraph two.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 2)
+ self.assertIsInstance(blocks[0], Paragraph)
+ self.assertIsInstance(blocks[1], Paragraph)
+
+ def test_div_container(self):
+ """Test div elements as generic containers."""
+ text = "First paragraph.
Second paragraph.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 2)
+ self.assertIsInstance(blocks[0], Paragraph)
+ self.assertIsInstance(blocks[1], Paragraph)
+
+ def test_headings(self):
+ """Test all heading levels h1-h6."""
+ text = "Heading 1
Heading 2
Heading 3
Heading 4
Heading 5
Heading 6
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 6)
+
+ expected_levels = [HeadingLevel.H1, HeadingLevel.H2, HeadingLevel.H3,
+ HeadingLevel.H4, HeadingLevel.H5, HeadingLevel.H6]
+
+ for i, block in enumerate(blocks):
+ self.assertIsInstance(block, Heading)
+ self.assertEqual(block.level, expected_levels[i])
+
+ words = list(block.words())
+ self.assertEqual(len(words), 2) # "Heading" and number
+ self.assertEqual(words[0][1].text, "Heading")
+
+ def test_blockquote(self):
+ """Test blockquote elements."""
+ text = "This is a quoted paragraph.
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Quote)
+
+ # Check that the quote contains a paragraph
+ quote_blocks = list(blocks[0].blocks())
+ self.assertEqual(len(quote_blocks), 1)
+ self.assertIsInstance(quote_blocks[0], Paragraph)
+
+ def test_preformatted_code(self):
+ """Test preformatted code blocks."""
+ text = "function hello() {\n console.log('Hello');\n}
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], CodeBlock)
+
+ lines = list(blocks[0].lines())
+ self.assertGreater(len(lines), 0)
+
+ def test_unordered_list(self):
+ """Test unordered lists."""
+ text = "- First item
- Second item
- Third item
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], HList)
+ self.assertEqual(blocks[0].style, ListStyle.UNORDERED)
+
+ items = list(blocks[0].items())
+ self.assertEqual(len(items), 3)
+
+ def test_ordered_list(self):
+ """Test ordered lists."""
+ text = "- First item
- Second item
- Third item
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], HList)
+ self.assertEqual(blocks[0].style, ListStyle.ORDERED)
+
+ def test_list_with_styled_content(self):
+ """Test lists containing styled content."""
+ text = "- Normal item
- Bold item
- Item with italic text
"
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], HList)
+
+ items = list(blocks[0].items())
+ self.assertEqual(len(items), 3)
+
+ # Check second item has bold text
+ second_item_blocks = list(items[1].blocks())
+ if second_item_blocks:
+ words = list(second_item_blocks[0].words())
+ bold_words = [w for _, w in words if w.style.weight == FontWeight.BOLD]
+ self.assertGreater(len(bold_words), 0)
+
+ def test_table_basic(self):
+ """Test basic table structure."""
+ text = """
+
+
+ Header 1
+ Header 2
+
+
+ Cell 1
+ Cell 2
+
+
+ """
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Table)
+
+ def test_semantic_elements(self):
+ """Test semantic HTML5 elements treated as containers."""
+ text = "Section Title
+ Some introductory text.
+
+ A quoted paragraph.
+
+
+ """
+ blocks = parse_html_string(text)
+ self.assertGreater(len(blocks), 2)
+
+ # Should have at least a heading, paragraph, and quote
+ has_heading = any(isinstance(b, Heading) for b in blocks)
+ has_paragraph = any(isinstance(b, Paragraph) for b in blocks)
+ has_quote = any(isinstance(b, Quote) for b in blocks)
+
+ self.assertTrue(has_heading, "Should contain a heading")
+ self.assertTrue(has_paragraph, "Should contain a paragraph")
+ self.assertTrue(has_quote, "Should contain a quote")
+
+ def test_empty_elements(self):
+ """Test handling of empty elements."""
+ text = ""
+ blocks = parse_html_string(text)
+ # Empty elements may not create blocks, which is acceptable behavior
+ self.assertGreaterEqual(len(blocks), 0)
+
+ # Test that empty paragraph with some content does create a block
+ text_with_content = "
" # Contains whitespace
+ blocks_with_content = parse_html_string(text_with_content)
+ # This should create at least one block since there's whitespace content
+ self.assertGreaterEqual(len(blocks_with_content), 0)
+
+
+class TestHTMLComplexStructures(unittest.TestCase):
+ """Test cases for complex HTML structures combining multiple features."""
+
+ def test_article_with_mixed_content(self):
+ """Test a realistic article structure with mixed content."""
+ text = """
+
+ Article Title
+ This is the introduction paragraph with some emphasis.
+
+ This is a quoted section with styling.
+
+
+ - First important point
+ - Second point with
inline code
+
+
+ """
+ blocks = parse_html_string(text)
+ self.assertGreater(len(blocks), 3)
+
+ # Verify we have the expected block types
+ block_types = [type(b).__name__ for b in blocks]
+ self.assertIn('Heading', block_types)
+ self.assertIn('Paragraph', block_types)
+ self.assertIn('Quote', block_types)
+ self.assertIn('HList', block_types)
+
+ def test_styled_table_content(self):
+ """Test table with styled cell content."""
+ text = """
+
+
+
+ Product
+ Price
+
+
+
+
+ Item with red text
+ $19.99
+
+
+
+ """
+ blocks = parse_html_string(text)
+ self.assertEqual(len(blocks), 1)
+ self.assertIsInstance(blocks[0], Table)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/test_html_text.py b/tests/test_html_text.py
index e0d8c68..cb4f49b 100644
--- a/tests/test_html_text.py
+++ b/tests/test_html_text.py
@@ -8,7 +8,7 @@ import unittest
from unittest.mock import Mock, MagicMock
from pyWebLayout.io.readers.html_text import HTMLTextProcessor
from pyWebLayout.io.readers.html_style import HTMLStyleManager
-from pyWebLayout.abstract.block import Parapgraph
+from pyWebLayout.abstract.block import Paragraph
from pyWebLayout.abstract.inline import Word
@@ -21,7 +21,7 @@ class TestHTMLTextProcessor(unittest.TestCase):
self.text_processor = HTMLTextProcessor(self.style_manager)
# Create a mock paragraph
- self.mock_paragraph = Mock(spec=Parapgraph)
+ self.mock_paragraph = Mock(spec=Paragraph)
self.mock_paragraph.add_word = Mock()
def test_initialization(self):