WeasyPrint/weasy/tests/test_boxes.py

# coding: utf8

#  WeasyPrint converts web documents (HTML, CSS, ...) to PDF.
#  Copyright (C) 2011  Simon Sapin
#
#  This program is free software: you can redistribute it and/or modify
#  it under the terms of the GNU Affero General Public License as
#  published by the Free Software Foundation, either version 3 of the
#  License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU Affero General Public License for more details.
#
#  You should have received a copy of the GNU Affero General Public License
#  along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""
Test the CSS boxes.

"""

import contextlib

from attest import Tests, assert_hook  # pylint: disable=W0611

from . import resource_filename
from ..css import validation, page_style
from . import TestPNGDocument
from ..formatting_structure import boxes, build


SUITE = Tests()


PROPER_CHILDREN = dict((key, tuple(map(tuple, value))) for key, value in {
    # Children can be of *any* type in *one* of the lists.
    boxes.BlockContainerBox: [[boxes.BlockLevelBox], [boxes.LineBox]],
    boxes.LineBox: [[boxes.InlineLevelBox]],
    boxes.InlineBox: [[boxes.InlineLevelBox]],
    boxes.TableBox: [[boxes.TableCaptionBox,
                      boxes.TableColumnGroupBox, boxes.TableColumnBox,
                      boxes.TableRowGroupBox, boxes.TableRowBox]],
    boxes.InlineTableBox: [[boxes.TableCaptionBox,
                            boxes.TableColumnGroupBox, boxes.TableColumnBox,
                            boxes.TableRowGroupBox, boxes.TableRowBox]],
    boxes.TableColumnGroupBox: [[boxes.TableColumnBox]],
    boxes.TableRowGroupBox: [[boxes.TableRowBox]],
    boxes.TableRowBox: [[boxes.TableCellBox]],
}.iteritems())


def serialize(box_list):
    """Transform a box list into a structure easier to compare for testing."""
    return [
        (
            box.element_tag,
            ('Anon'
                 if box.style.anonymous and
                       type(box) not in (boxes.TextBox, boxes.LineBox)
                 else ''
             ) + type(box).__name__[:-3],
            (
            # All concrete boxes are either text, replaced, column or parent.
            box.text if isinstance(box, boxes.TextBox)
            else '<replaced>' if isinstance(box, boxes.ReplacedBox)
            else serialize(getattr(box, 'column_groups', ()) + box.children)))
        for box in box_list
    ]


def unwrap_html_body(box):
    """Test that the box tree starts with a ``<html>`` and a ``<body>`` blocks.

    Remove them to simplify further tests. These are always at the root
    of HTML documents.

    """
    assert box.element_tag == 'html'
    assert isinstance(box, boxes.BlockBox)
    assert len(box.children) == 1

    box = box.children[0]
    assert isinstance(box, boxes.BlockBox)
    assert box.element_tag == 'body'

    return box.children


def to_lists(box_tree):
    """Serialize and unwrap ``<html>`` and ``<body>``."""
    return serialize(unwrap_html_body(box_tree))


@contextlib.contextmanager
def monkeypatch_validation(replacement):
    """Create a context manager patching the validation mechanism.

    This is useful to change the behaviour of the validation for one property
    not yet supported, without affecting the validation for the other
    properties.

    """
    real_non_shorthand = validation.validate_non_shorthand

    def patched_non_shorthand(*args, **kwargs):
        """Wraps the validator into ``replacement``."""
        return replacement(real_non_shorthand, *args, **kwargs)

    validation.validate_non_shorthand = patched_non_shorthand
    try:
        yield
    finally:
        validation.validate_non_shorthand = real_non_shorthand


def validate_inline_block(real_non_shorthand, name, values, required=False):
    """Fake validator for inline blocks."""
    if name == 'display' and values[0].value == 'inline-block':
        return [(name, 'inline-block')]
    return real_non_shorthand(name, values, required)


def parse(html_content):
    """Parse some HTML, apply stylesheets and transform to boxes."""
    # TODO: remove this patching when inline-block is validated.
    with monkeypatch_validation(validate_inline_block):
        document = TestPNGDocument.from_string(html_content)
        # Dummy filename, but in the right directory.
        document.base_url = resource_filename('<test>')
        box, = build.dom_to_box(document, document.dom)
        return box


def parse_all(html_content):
    """Like parse() but also run all corrections on boxes."""
    document = TestPNGDocument.from_string(html_content)
    document.base_url = resource_filename('<test>')
    box = build.build_formatting_structure(document)
    sanity_checks(box)
    return box


def assert_tree(box, expected):
    """Check the box tree equality.

    The obtained result is prettified in the message in case of failure.

    box: a Box object, starting with <html> and <body> blocks.
    expected: a list of serialized <body> children as returned by to_lists().

    """
    assert to_lists(box) == expected


def sanity_checks(box):
    """Check that the rules regarding boxes are met.

    This is not required and only helps debugging.

    - A block container can contain either only block-level boxes or
      only line boxes;
    - Line boxes and inline boxes can only contain inline-level boxes.

    """
    if not isinstance(box, boxes.ParentBox):
        return

    for class_ in type(box).mro():
        if class_ in PROPER_CHILDREN:
            acceptable_types_lists = PROPER_CHILDREN[class_]
            break
    else:
        raise TypeError

    assert any(
        all(isinstance(child, acceptable_types) for child in box.children)
        for acceptable_types in acceptable_types_lists
    ), (box, box.children)

    for child in box.children:
        sanity_checks(child)


@SUITE.test
def test_box_tree():
    """Test the creation of trees from HTML strings."""
    assert_tree(parse('<p>'), [('p', 'Block', [])])
    assert_tree(parse('''
        <style>
            span { display: inline-block }
        </style>
        <p>Hello <em>World <img src="pattern.png"><span>Lipsum</span></em>!</p>
    '''), [
        ('p', 'Block', [
            ('p', 'Text', 'Hello '),
            ('em', 'Inline', [
                ('em', 'Text', 'World '),
                ('img', 'InlineReplaced', '<replaced>'),
                ('span', 'InlineBlock', [
                    ('span', 'Text', 'Lipsum')])]),
            ('p', 'Text', '!')])])


@SUITE.test
def test_html_entities():
    """Test the management of HTML entities."""
    for quote in ['"', '&quot;', '&#x22;', '&#34;']:
        assert_tree(parse('<p>{}abc{}'.format(quote, quote)), [
            ('p', 'Block', [
                ('p', 'Text', '"abc"')])])


@SUITE.test
def test_inline_in_block():
    """Test the management of inline boxes in block boxes."""
    source = '<div>Hello, <em>World</em>!\n<p>Lipsum.</p></div>'
    expected = [
        ('div', 'Block', [
            ('div', 'AnonBlock', [
                ('div', 'Line', [
                    ('div', 'Text', 'Hello, '),
                    ('em', 'Inline', [
                        ('em', 'Text', 'World')]),
                    ('div', 'Text', '!\n')])]),
            ('p', 'Block', [
                ('p', 'Line', [
                    ('p', 'Text', 'Lipsum.')])])])]

    box = parse(source)
    box = build.inline_in_block(box)
    assert_tree(box, expected)


@SUITE.test
def test_block_in_inline():
    """Test the management of block boxes in inline boxes."""
    box = parse('''
<style>
    p { display: inline-block; }
    span { display: block; }
</style>
<p>Lorem <em>ipsum <strong>dolor <span>sit</span>
    <span>amet,</span></strong><span><em>consectetur<div/></em></span></em></p>
    ''')
    box = build.inline_in_block(box)
    assert_tree(box, [
        ('body', 'Line', [
            ('p', 'InlineBlock', [
                ('p', 'Line', [
                    ('p', 'Text', 'Lorem '),
                    ('em', 'Inline', [
                        ('em', 'Text', 'ipsum '),
                        ('strong', 'Inline', [
                            ('strong', 'Text', 'dolor '),
                            ('span', 'Block', [  # This block is "pulled up"
                                ('span', 'Line', [
                                    ('span', 'Text', 'sit')])]),
                            # No whitespace processing here.
                            ('strong', 'Text', '\n    '),
                            ('span', 'Block', [  # This block is "pulled up"
                                ('span', 'Line', [
                                    ('span', 'Text', 'amet,')])])]),
                        ('span', 'Block', [  # This block is "pulled up"
                            ('span', 'Line', [
                                ('em', 'Inline', [
                                    ('em', 'Text', 'consectetur'),
                                    ('div', 'Block', []),
                                    ])])])])])])])])

    box = build.block_in_inline(box)
    assert_tree(box, [
        ('body', 'Line', [
            ('p', 'InlineBlock', [
                ('p', 'AnonBlock', [
                    ('p', 'Line', [
                        ('p', 'Text', 'Lorem '),
                        ('em', 'Inline', [
                            ('em', 'Text', 'ipsum '),
                            ('strong', 'Inline', [
                                ('strong', 'Text', 'dolor ')])])])]),
                ('span', 'Block', [
                    ('span', 'Line', [
                        ('span', 'Text', 'sit')])]),
                ('p', 'AnonBlock', [
                    ('p', 'Line', [
                        ('em', 'Inline', [
                            ('strong', 'Inline', [
                                # Whitespace processing not done yet.
                                ('strong', 'Text', '\n    ')])])])]),
                ('span', 'Block', [
                    ('span', 'Line', [
                        ('span', 'Text', 'amet,')])]),

                ('p', 'AnonBlock', [
                    ('p', 'Line', [
                        ('em', 'Inline', [
                            ('strong', 'Inline', [])])])]),
                ('span', 'Block', [
                    ('span', 'AnonBlock', [
                        ('span', 'Line', [
                            ('em', 'Inline', [
                                ('em', 'Text', 'consectetur')])])]),
                    ('div', 'Block', []),
                    ('span', 'AnonBlock', [
                        ('span', 'Line', [
                            ('em', 'Inline', [])])])]),
                ('p', 'AnonBlock', [
                    ('p', 'Line', [
                        ('em', 'Inline', [])])])])])])


@SUITE.test
def test_styles():
    """Test the application of CSS to HTML."""
    box = parse('''
        <style>
            span { display: block; }
            * { margin: 42px }
            html { color: blue }
        </style>
        <p>Lorem <em>ipsum <strong>dolor <span>sit</span>
            <span>amet,</span></strong><span>consectetur</span></em></p>''')
    box = build.inline_in_block(box)
    box = build.block_in_inline(box)

    descendants = list(box.descendants())
    assert len(descendants) == 31
    assert descendants[0] == box

    for child in descendants:
        # All boxes inherit the color
        assert child.style.color.value == 'blue'
        # Only non-anonymous boxes have margins
        if child.style.anonymous:
            assert child.style.margin_top == 0
        else:
            assert child.style.margin_top == 42


@SUITE.test
def test_whitespace():
    """Test the management of white spaces."""
    # TODO: test more cases
    # http://www.w3.org/TR/CSS21/text.html#white-space-model
    assert_tree(parse_all('''
        <p>Lorem \t\r\n  ipsum\t<strong>  dolor
            <img src=pattern.png> sit</strong>.</p>
        <pre>\t  foo\n</pre>
        <pre style="white-space: pre-wrap">\t  foo\n</pre>
        <pre style="white-space: pre-line">\t  foo\n</pre>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Text', 'Lorem ipsum '),
                ('strong', 'Inline', [
                    ('strong', 'Text', 'dolor '),
                    ('img', 'InlineReplaced', '<replaced>'),
                    ('strong', 'Text', ' sit')]),
                ('p', 'Text', '.')])]),
        ('pre', 'Block', [
            ('pre', 'Line', [
                # pre
                ('pre', 'Text', u'\t\xA0\xA0foo\n')])]),
        ('pre', 'Block', [
            ('pre', 'Line', [
                # pre-wrap
                ('pre', 'Text', u'\t\xA0\xA0\u200Bfoo\n')])]),
        ('pre', 'Block', [
            ('pre', 'Line', [
                # pre-line
                ('pre', 'Text', u'foo\n')])])])


@SUITE.test
def test_page_style():
    """Test the management of page styles."""
    document = TestPNGDocument.from_string('''
        <style>
            @page { margin: 3px }
            @page :first { margin-top: 20px }
            @page :right { margin-right: 10px; margin-top: 10px }
            @page :left { margin-left: 10px; margin-top: 10px }
        </style>
    ''')

    def assert_page_margins(page_number, top, right, bottom, left):
        """Check the page margin values."""
        style = page_style(document, page_number)
        assert style.margin_top == top
        assert style.margin_right == right
        assert style.margin_bottom == bottom
        assert style.margin_left == left

    # Odd numbers are :right pages, even are :left. 1 has :first as well
    assert_page_margins(1, top=20, right=10, bottom=3, left=3)
    assert_page_margins(2, top=10, right=3, bottom=3, left=10)
    assert_page_margins(3, top=10, right=10, bottom=3, left=3)
    assert_page_margins(4, top=10, right=3, bottom=3, left=10)
    assert_page_margins(45, top=10, right=10, bottom=3, left=3)
    assert_page_margins(122, top=10, right=3, bottom=3, left=10)


@SUITE.test
def test_text_transform():
    """Test the text-transform property."""
    assert_tree(parse_all('''
        <style>
            p { text-transform: capitalize }
            p+p { text-transform: uppercase }
            p+p+p { text-transform: lowercase }
            p+p+p+p { text-transform: none }
        </style>
<p>heLLo wOrlD!</p><p>heLLo wOrlD!</p><p>heLLo wOrlD!</p><p>heLLo wOrlD!</p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Text', 'Hello World!')])]),
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Text', 'HELLO WORLD!')])]),
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Text', 'hello world!')])]),
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Text', 'heLLo wOrlD!')])]),
    ])


@SUITE.test
def test_tables():
    # Rules in http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
    # Rule 1.3
    # Also table model: http://www.w3.org/TR/CSS21/tables.html#model
    assert_tree(parse_all('''
        <table>
            <tr>
                <th>foo</th>
                <th>bar</th>
            </tr>
            <tfoot></tfoot>
            <thead><th></th></thead>
            <caption style="caption-side: bottom"></caption>
            <thead></thead>
            <col></col>
            <caption>top caption</caption>
            <tr>
                <td>baz</td>
            </tr>
        </table>
    '''), [
        ('table', 'AnonBlock', [
            ('caption', 'TableCaption', [
                ('caption', 'Line', [
                    ('caption', 'Text', 'top caption')])]),
            ('table', 'Table', [
                ('table', 'AnonTableColumnGroup', [
                    ('col', 'TableColumn', [])]),
                ('thead', 'TableRowGroup', [
                    ('thead', 'AnonTableRow', [
                        ('th', 'TableCell', [])])]),
                ('table', 'AnonTableRowGroup', [
                    ('tr', 'TableRow', [
                        ('th', 'TableCell', [
                            ('th', 'Line', [
                                ('th', 'Text', 'foo')])]),
                        ('th', 'TableCell', [
                            ('th', 'Line', [
                                ('th', 'Text', 'bar')])])])]),
                ('thead', 'TableRowGroup', []),
                ('table', 'AnonTableRowGroup', [
                    ('tr', 'TableRow', [
                        ('td', 'TableCell', [
                            ('td', 'Line', [
                                ('td', 'Text', 'baz')])])])]),
                ('tfoot', 'TableRowGroup', [])]),
            ('caption', 'TableCaption', [])])])

    # Rules 1.4 and 3.1
    assert_tree(parse_all('''
        <span style="display: table-cell">foo</span>
        <span style="display: table-cell">bar</span>
    '''), [
        ('body', 'AnonBlock', [
            ('body', 'AnonTable', [
                ('body', 'AnonTableRowGroup', [
                    ('body', 'AnonTableRow', [
                        ('span', 'TableCell', [
                            ('span', 'Line', [
                                ('span', 'Text', 'foo')])]),
                        ('span', 'TableCell', [
                            ('span', 'Line', [
                                ('span', 'Text', 'bar')])])])])])])])

    # http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
    # Rules 1.1 and 1.2
    assert_tree(parse_all('''
        <span style="display: table-column-group">
            1
            <em style="display: table-column">
                2
                <strong>3</strong>
            </em>
            <strong>4</strong>
        </span>
    '''), [
        ('body', 'AnonBlock', [
            ('body', 'AnonTable', [
                ('span', 'TableColumnGroup', [
                    ('em', 'TableColumn', [])])])])])

    # Rules 2.1 then 2.3
    assert_tree(parse_all('<table>foo <div></div></table>'), [
        ('table', 'AnonBlock', [
            ('table', 'Table', [
                ('table', 'AnonTableRowGroup', [
                    ('table', 'AnonTableRow', [
                        ('table', 'AnonTableCell', [
                            ('table', 'AnonBlock', [
                                ('table', 'Line', [
                                    ('table', 'Text', 'foo ')])]),
                            ('div', 'Block', [])])])])])])])

    # Rule 2.2
    assert_tree(parse_all('<thead><div></div><td></td></thead>'), [
        ('body', 'AnonBlock', [
            ('body', 'AnonTable', [
                ('thead', 'TableRowGroup', [
                    ('thead', 'AnonTableRow', [
                        ('thead', 'AnonTableCell', [
                            ('div', 'Block', [])]),
                        ('td', 'TableCell', [])])])])])])

    # TODO: re-enable this once we support inline-table
#    # Rule 3.2
#    assert_tree(parse_all('<span><tr></tr></span>'), [
#        ('body', 'Line', [
#            ('span', 'Inline', [
#                ('span', 'AnonInlineBlock', [
#                    ('span', 'AnonInlineTable', [
#                        ('span', 'AnonTableRowGroup', [
#                            ('tr', 'TableRow', [])])])])])])])

#    # Rule 3.1
#    # Also, rule 1.3 does not apply: whitespace before and after is preserved
#    assert_tree(parse_all('''
#        <span>
#            <em style="display: table-cell"></em>
#            <em style="display: table-cell"></em>
#        </span>
#    '''), [
#        ('body', 'Line', [
#            ('span', 'Inline', [
#                # Whitespace is preserved in table handling, then collapsed
#                # into a single space.
#                ('span', 'Text', ' '),
#                ('span', 'AnonInlineBlock', [
#                    ('span', 'AnonInlineTable', [
#                        ('span', 'AnonTableRowGroup', [
#                            ('span', 'AnonTableRow', [
#                                ('em', 'TableCell', []),
#                                ('em', 'TableCell', [])])])])]),
#                ('span', 'Text', ' ')])])])

    # Rule 3.2
    assert_tree(parse_all('<tr></tr>\t<tr></tr>'), [
        ('body', 'AnonBlock', [
            ('body', 'AnonTable', [
                ('body', 'AnonTableRowGroup', [
                    ('tr', 'TableRow', []),
                    ('tr', 'TableRow', [])])])])])
    assert_tree(parse_all('<col></col>\n<colgroup></colgroup>'), [
        ('body', 'AnonBlock', [
            ('body', 'AnonTable', [
                ('body', 'AnonTableColumnGroup', [
                    ('col', 'TableColumn', [])]),
                ('colgroup', 'TableColumnGroup', [])])])])


@SUITE.test
def test_table_style():
    html = parse_all('<table style="margin: 1px; padding: 2px"></table>')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    assert isinstance(wrapper, boxes.BlockBox)
    assert isinstance(table, boxes.TableBox)
    assert wrapper.style.margin_top == 1
    assert wrapper.style.padding_top == 0
    assert table.style.margin_top == 0
    assert table.style.padding_top == 2


@SUITE.test
def test_column_style():
    html = parse_all('''
        <table>
            <col span=3 style="width: 10px"></col>
            <col span=2></col>
        </table>
    ''')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    colgroup, = table.column_groups
    widths = [col.style.width for col in colgroup.children]
    assert widths == [10, 10, 10, 'auto', 'auto']
    assert [col.grid_x for col in colgroup.children] == [0, 1, 2, 3, 4]
    # copies, not the same box object
    assert colgroup.children[0] is not colgroup.children[1]


@SUITE.test
def test_nested_grid_x():
    html = parse_all('''
        <table>
            <col span=2></col>
            <colgroup span=2></colgroup>
            <colgroup>
                <col></col>
                <col span=2></col>
            </colgroup>
            <col></col>
        </table>
    ''')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    grid = [(colgroup.grid_x, [col.grid_x for col in colgroup.children])
            for colgroup in table.column_groups]
    assert grid == [(0, [0, 1]), (2, []), (4, [4, 5, 6]), (7, [7])]


@SUITE.test
def test_colspan_rowspan():
    """
    +---+---+---+
    | A | B | C | #
    +---+---+---+
    | D |     E | #
    +---+---+   +---+
    |  F ...|   |   |   <-- overlap
    +---+---+---+   +
    | H | #   # | G |
    +---+---+   +   +
    | I | J | # |   |
    +---+---+   +---+

    # empty cells

    """
    html = parse_all('''
        <table>
            <tr>
                <td>A <td>B <td>C
            </tr>
            <tr>
                <td>D <td colspan=2 rowspan=2>E
            </tr>
            <tr>
                <td colspan=2>F <td rowspan=0>G
            </tr>
            <tr>
                <td>H
            </tr>
            <tr>
                <td>I <td>J
            </tr>
        </table>
    ''')
    body, = html.children
    wrapper, = body.children
    table, = wrapper.children
    group, = table.children
    assert [[c.grid_x for c in row.children] for row in group.children] == [
        [0, 1, 2],
        [0, 1],
        [0,      3],
        [0],
        [0, 1],
    ]
    assert [[c.colspan for c in row.children] for row in group.children] == [
        [1, 1, 1],
        [1, 2],
        [2,      1],
        [1],
        [1, 1],
    ]
    assert [[c.rowspan for c in row.children] for row in group.children] == [
        [1, 1, 1],
        [1, 2],
        [1,      3],
        [1],
        [1, 1],
    ]


@SUITE.test
def test_before_after():
    """Test the :before and :after pseudo-elements."""
    assert_tree(parse_all('''
        <style>
            p:before { content: 'a' 'b' }
            p:after { content: 'd' 'e' }
        </style>
        <p>
            c
        </p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Inline', [
                    ('p', 'Text', 'ab')]),
                ('p', 'Text', ' c '),
                ('p', 'Inline', [
                    ('p', 'Text', 'de')])])])])

    assert_tree(parse_all('''
        <style>
            a[href]:before { content: '[' attr(href) '] ' }
        </style>
        <p><a href="some url">some text</a></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('a', 'Inline', [
                    ('a', 'Inline', [  # :before
                        ('a', 'Text', '[some url] ')]),
                    ('a', 'Text', 'some text')])])])])

    assert_tree(parse_all(u'''
        <style>
            body { quotes: '«' '»' '“' '”' }
            q:before { content: open-quote ' '}
            q:after { content: ' ' close-quote }
        </style>
        <p><q>Lorem ipsum <q>dolor</q> sit amet</q></p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('q', 'Inline', [
                    ('q', 'Inline', [  # :before
                        ('q', 'Text', u'« ')]),
                    ('q', 'Text', 'Lorem ipsum '),
                    ('q', 'Inline', [
                        ('q', 'Inline', [  # :before
                            ('q', 'Text', u'“ ')]),
                        ('q', 'Text', 'dolor'),
                        ('q', 'Inline', [  # :after
                            ('q', 'Text', u' ”')])]),
                    ('q', 'Text', ' sit amet'),
                    ('q', 'Inline', [  # :after
                        ('q', 'Text', u' »')])])])])])

    assert_tree(parse_all('''
        <style>
            p:before { content: 'a' url(pattern.png) 'b'}
        </style>
        <p>c</p>
    '''), [
        ('p', 'Block', [
            ('p', 'Line', [
                ('p', 'Inline', [  # :before
                    ('p', 'Text', 'a'),
                    ('p', 'AnonInlineReplaced', '<replaced>'),
                    ('p', 'Text', 'b')]),
                ('p', 'Text', 'c')])])])
-												Add a 'boxes' module. (Empty for now.)

											
										
										
											2011-05-17 13:29:00 +04:00
+								# coding: utf8
 								#  WeasyPrint converts web documents (HTML, CSS, ...) to PDF.
 								#  Copyright (C) 2011  Simon Sapin
 								#
 								#  This program is free software: you can redistribute it and/or modify
 								#  it under the terms of the GNU Affero General Public License as
 								#  published by the Free Software Foundation, either version 3 of the
 								#  License, or (at your option) any later version.
 								#
 								#  This program is distributed in the hope that it will be useful,
 								#  but WITHOUT ANY WARRANTY; without even the implied warranty of
 								#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 								#  GNU Affero General Public License for more details.
 								#
 								#  You should have received a copy of the GNU Affero General Public License
 								#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								"""
 								Test the CSS boxes.
 								"""
-												Monkey-patch validation for tests that need unsupported values.

											
										
										
											2011-08-16 18:01:50 +04:00
+								import contextlib
-												Add a 'boxes' module. (Empty for now.)

											
										
										
											2011-05-17 13:29:00 +04:00
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								from attest import Tests, assert_hook  # pylint: disable=W0611
-												Add a 'boxes' module. (Empty for now.)

											
										
										
											2011-05-17 13:29:00 +04:00
-												Test boxes sanity only for tests

											
										
										
											2011-09-02 20:38:11 +04:00
+								from . import resource_filename
-												Have the style passed as a parameter to boxes.

This prepares for :before and :after pseudo-elements.

											
										
										
											2011-12-02 14:31:06 +04:00
+								from ..css import validation, page_style
-												Use a shorter HTML stylesheet to speed up tests.

											
										
										
											2011-09-27 20:11:31 +04:00
+								from . import TestPNGDocument
-												Test boxes sanity only for tests

											
										
										
											2011-09-02 20:38:11 +04:00
+								from ..formatting_structure import boxes, build
-												Add a 'boxes' module. (Empty for now.)

											
										
										
											2011-05-17 13:29:00 +04:00
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								SUITE = Tests()
-												Add a 'boxes' module. (Empty for now.)

											
										
										
											2011-05-17 13:29:00 +04:00
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								PROPER_CHILDREN = dict((key, tuple(map(tuple, value))) for key, value in {
 								    # Children can be of *any* type in *one* of the lists.
 								    boxes.BlockContainerBox: [[boxes.BlockLevelBox], [boxes.LineBox]],
 								    boxes.LineBox: [[boxes.InlineLevelBox]],
 								    boxes.InlineBox: [[boxes.InlineLevelBox]],
 								    boxes.TableBox: [[boxes.TableCaptionBox,
 								                      boxes.TableColumnGroupBox, boxes.TableColumnBox,
 								                      boxes.TableRowGroupBox, boxes.TableRowBox]],
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    boxes.InlineTableBox: [[boxes.TableCaptionBox,
 								                            boxes.TableColumnGroupBox, boxes.TableColumnBox,
 								                            boxes.TableRowGroupBox, boxes.TableRowBox]],
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								    boxes.TableColumnGroupBox: [[boxes.TableColumnBox]],
 								    boxes.TableRowGroupBox: [[boxes.TableRowBox]],
 								    boxes.TableRowBox: [[boxes.TableCellBox]],
 								}.iteritems())
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								def serialize(box_list):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Transform a box list into a structure easier to compare for testing."""
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    return [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        (
-												Remove references to elements in boxes.

											
										
										
											2011-12-02 15:36:20 +04:00
+								            box.element_tag,
-												Being anonymous is now an attribute of styles, not boxes.

											
										
										
											2011-12-05 18:25:42 +04:00
+								            ('Anon'
 								                 if box.style.anonymous and
 								                       type(box) not in (boxes.TextBox, boxes.LineBox)
 								                 else ''
 								             ) + type(box).__name__[:-3],
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								            (
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								            # All concrete boxes are either text, replaced, column or parent.
-												End this UTF-8 madness.

											
										
										
											2011-11-08 16:09:19 +04:00
+								            box.text if isinstance(box, boxes.TextBox)
-												Page boxes have no children; dont create them in formatting_structure.build

											
										
										
											2011-07-11 14:47:00 +04:00
+								            else '<replaced>' if isinstance(box, boxes.ReplacedBox)
-												Initial layout for tables. (widths/horizontal only)

											
										
										
											2011-11-22 16:06:50 +04:00
+								            else serialize(getattr(box, 'column_groups', ()) + box.children)))
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								        for box in box_list
 								    ]
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
 								def unwrap_html_body(box):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test that the box tree starts with a ``<html>`` and a ``<body>`` blocks.
 								    Remove them to simplify further tests. These are always at the root
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
+								    of HTML documents.
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
+								    """
-												Remove references to elements in boxes.

											
										
										
											2011-12-02 15:36:20 +04:00
+								    assert box.element_tag == 'html'
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								    assert isinstance(box, boxes.BlockBox)
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    assert len(box.children) == 1
 								    box = box.children[0]
-												Add box classes to propely represent eg. an inline-level block container
generated by an element with 'display: inline-block'

											
										
										
											2011-05-25 16:59:42 +04:00
+								    assert isinstance(box, boxes.BlockBox)
-												Remove references to elements in boxes.

											
										
										
											2011-12-02 15:36:20 +04:00
+								    assert box.element_tag == 'body'
-												Remove trailing whitespace.

											
										
										
											2011-06-29 16:04:42 +04:00
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    return box.children
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
-												If a block has block children, wrap all non-block children
in anonymous blocks and lines.

											
										
										
											2011-05-19 18:03:50 +04:00
+								def to_lists(box_tree):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Serialize and unwrap ``<html>`` and ``<body>``."""
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    return serialize(unwrap_html_body(box_tree))
-												Remove trailing whitespace.

											
										
										
											2011-06-29 16:04:42 +04:00
-												If a block has block children, wrap all non-block children
in anonymous blocks and lines.

											
										
										
											2011-05-19 18:03:50 +04:00
-												Monkey-patch validation for tests that need unsupported values.

											
										
										
											2011-08-16 18:01:50 +04:00
+								@contextlib.contextmanager
 								def monkeypatch_validation(replacement):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Create a context manager patching the validation mechanism.
 								    This is useful to change the behaviour of the validation for one property
 								    not yet supported, without affecting the validation for the other
 								    properties.
 								    """
-												Monkey-patch validation for tests that need unsupported values.

											
										
										
											2011-08-16 18:01:50 +04:00
+								    real_non_shorthand = validation.validate_non_shorthand
 								    def patched_non_shorthand(*args, **kwargs):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								        """Wraps the validator into ``replacement``."""
-												Monkey-patch validation for tests that need unsupported values.

											
										
										
											2011-08-16 18:01:50 +04:00
+								        return replacement(real_non_shorthand, *args, **kwargs)
 								    validation.validate_non_shorthand = patched_non_shorthand
 								    try:
 								        yield
 								    finally:
 								        validation.validate_non_shorthand = real_non_shorthand
 								def validate_inline_block(real_non_shorthand, name, values, required=False):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Fake validator for inline blocks."""
-												Use strings or numbers instead of lists of cssutils Value objects.

... where appropriate. This remove much of the need for functions like
get_single_keyword and get_single_pixel_value.

											
										
										
											2011-10-08 16:41:12 +04:00
+								    if name == 'display' and values[0].value == 'inline-block':
 								        return [(name, 'inline-block')]
-												Monkey-patch validation for tests that need unsupported values.

											
										
										
											2011-08-16 18:01:50 +04:00
+								    return real_non_shorthand(name, values, required)
-												Split box classes and box-building functions into a module each.

											
										
										
											2011-06-29 23:59:29 +04:00
+								def parse(html_content):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Parse some HTML, apply stylesheets and transform to boxes."""
-												Monkey-patch validation for tests that need unsupported values.

											
										
										
											2011-08-16 18:01:50 +04:00
+								    # TODO: remove this patching when inline-block is validated.
 								    with monkeypatch_validation(validate_inline_block):
-												Use a shorter HTML stylesheet to speed up tests.

											
										
										
											2011-09-27 20:11:31 +04:00
+								        document = TestPNGDocument.from_string(html_content)
-												Handle alt-text on images.

											
										
										
											2011-08-25 19:29:16 +04:00
+								        # Dummy filename, but in the right directory.
 								        document.base_url = resource_filename('<test>')
-												Generate multiple boxes for <col> with span > 1

											
										
										
											2011-11-17 18:39:30 +04:00
+								        box, = build.dom_to_box(document, document.dom)
 								        return box
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								def parse_all(html_content):
 								    """Like parse() but also run all corrections on boxes."""
 								    document = TestPNGDocument.from_string(html_content)
-												Fix some edge cases in whitespace processing.

											
										
										
											2011-11-16 20:34:02 +04:00
+								    document.base_url = resource_filename('<test>')
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    box = build.build_formatting_structure(document)
 								    sanity_checks(box)
 								    return box
-												Add the first step of whitespace processing.

											
										
										
											2011-05-23 18:14:51 +04:00
+								def assert_tree(box, expected):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Check the box tree equality.
 								    The obtained result is prettified in the message in case of failure.
-												Remove trailing whitespace.

											
										
										
											2011-06-29 16:04:42 +04:00
-												Add the first step of whitespace processing.

											
										
										
											2011-05-23 18:14:51 +04:00
+								    box: a Box object, starting with <html> and <body> blocks.
 								    expected: a list of serialized <body> children as returned by to_lists().
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
-												Add the first step of whitespace processing.

											
										
										
											2011-05-23 18:14:51 +04:00
+								    """
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								    assert to_lists(box) == expected
-												Make boxes.inline_in_block() idempotent.

											
										
										
											2011-05-19 20:22:06 +04:00
-												Move sanity checks on formatting structure into tests.

											
										
										
											2011-09-27 13:44:35 +04:00
+								def sanity_checks(box):
 								    """Check that the rules regarding boxes are met.
 								    This is not required and only helps debugging.
 								    - A block container can contain either only block-level boxes or
 								      only line boxes;
 								    - Line boxes and inline boxes can only contain inline-level boxes.
 								    """
 								    if not isinstance(box, boxes.ParentBox):
 								        return
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								    for class_ in type(box).mro():
 								        if class_ in PROPER_CHILDREN:
 								            acceptable_types_lists = PROPER_CHILDREN[class_]
 								            break
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    else:
 								        raise TypeError
-												Move sanity checks on formatting structure into tests.

											
										
										
											2011-09-27 13:44:35 +04:00
 								    assert any(
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								        all(isinstance(child, acceptable_types) for child in box.children)
 								        for acceptable_types in acceptable_types_lists
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    ), (box, box.children)
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
 								    for child in box.children:
 								        sanity_checks(child)
-												Move sanity checks on formatting structure into tests.

											
										
										
											2011-09-27 13:44:35 +04:00
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								@SUITE.test
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
+								def test_box_tree():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the creation of trees from HTML strings."""
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								    assert_tree(parse('<p>'), [('p', 'Block', [])])
-												Use the new box classes as appropriate (ie. for inline-block.)

											
										
										
											2011-05-25 17:27:30 +04:00
+								    assert_tree(parse('''
 								        <style>
 								            span { display: inline-block }
 								        </style>
-												Handle alt-text on images.

											
										
										
											2011-08-25 19:29:16 +04:00
+								        <p>Hello <em>World <img src="pattern.png"><span>Lipsum</span></em>!</p>
-												Use the new box classes as appropriate (ie. for inline-block.)

											
										
										
											2011-05-25 17:27:30 +04:00
+								    '''), [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('p', 'Block', [
 								            ('p', 'Text', 'Hello '),
 								            ('em', 'Inline', [
 								                ('em', 'Text', 'World '),
-												Shorter names.

											
										
										
											2011-12-05 17:24:43 +04:00
+								                ('img', 'InlineReplaced', '<replaced>'),
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								                ('span', 'InlineBlock', [
 								                    ('span', 'Text', 'Lipsum')])]),
 								            ('p', 'Text', '!')])])
-												Let’s start with a dumb box model.

											
										
										
											2011-05-19 17:31:34 +04:00
-												If a block has block children, wrap all non-block children
in anonymous blocks and lines.

											
										
										
											2011-05-19 18:03:50 +04:00
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								@SUITE.test
-												Apparently lxml.html already converts html entities.

											
										
										
											2011-08-16 14:00:59 +04:00
+								def test_html_entities():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the management of HTML entities."""
-												Apparently lxml.html already converts html entities.

											
										
										
											2011-08-16 14:00:59 +04:00
+								    for quote in ['"', '&quot;', '&#x22;', '&#34;']:
 								        assert_tree(parse('<p>{}abc{}'.format(quote, quote)), [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								            ('p', 'Block', [
 								                ('p', 'Text', '"abc"')])])
-												Apparently lxml.html already converts html entities.

											
										
										
											2011-08-16 14:00:59 +04:00
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								@SUITE.test
-												Make boxes.inline_in_block() idempotent.

											
										
										
											2011-05-19 20:22:06 +04:00
+								def test_inline_in_block():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the management of inline boxes in block boxes."""
-												Make process_whitespace a separate step and also collapse spaces across tags.

											
										
										
											2011-05-23 18:56:12 +04:00
+								    source = '<div>Hello, <em>World</em>!\n<p>Lipsum.</p></div>'
-												Make boxes.inline_in_block() idempotent.

											
										
										
											2011-05-19 20:22:06 +04:00
+								    expected = [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('div', 'Block', [
 								            ('div', 'AnonBlock', [
 								                ('div', 'Line', [
 								                    ('div', 'Text', 'Hello, '),
 								                    ('em', 'Inline', [
 								                        ('em', 'Text', 'World')]),
 								                    ('div', 'Text', '!\n')])]),
 								            ('p', 'Block', [
 								                ('p', 'Line', [
 								                    ('p', 'Text', 'Lipsum.')])])])]
-												Remove trailing whitespace.

											
										
										
											2011-06-29 16:04:42 +04:00
-												Make boxes.inline_in_block() idempotent.

											
										
										
											2011-05-19 20:22:06 +04:00
+								    box = parse(source)
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								    box = build.inline_in_block(box)
-												Add the first step of whitespace processing.

											
										
										
											2011-05-23 18:14:51 +04:00
+								    assert_tree(box, expected)
-												Make boxes.inline_in_block() idempotent.

											
										
										
											2011-05-19 20:22:06 +04:00
-												If a block has block children, wrap all non-block children
in anonymous blocks and lines.

											
										
										
											2011-05-19 18:03:50 +04:00
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								@SUITE.test
-												WIP: if an inline has a block child, pull the block up (see docstring)

											
										
										
											2011-05-19 20:58:39 +04:00
+								def test_block_in_inline():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the management of block boxes in inline boxes."""
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    box = parse('''
-												Bug fix: properly build anonymous blocks when a block element is in an inline

											
										
										
											2011-08-17 19:33:19 +04:00
+								<style>
 								    p { display: inline-block; }
 								    span { display: block; }
 								</style>
 								<p>Lorem <em>ipsum <strong>dolor <span>sit</span>
 								    <span>amet,</span></strong><span><em>consectetur<div/></em></span></em></p>
 								    ''')
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								    box = build.inline_in_block(box)
-												Add the first step of whitespace processing.

											
										
										
											2011-05-23 18:14:51 +04:00
+								    assert_tree(box, [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('body', 'Line', [
 								            ('p', 'InlineBlock', [
 								                ('p', 'Line', [
 								                    ('p', 'Text', 'Lorem '),
 								                    ('em', 'Inline', [
 								                        ('em', 'Text', 'ipsum '),
 								                        ('strong', 'Inline', [
 								                            ('strong', 'Text', 'dolor '),
 								                            ('span', 'Block', [  # This block is "pulled up"
 								                                ('span', 'Line', [
 								                                    ('span', 'Text', 'sit')])]),
-												Make process_whitespace a separate step and also collapse spaces across tags.

											
										
										
											2011-05-23 18:56:12 +04:00
+								                            # No whitespace processing here.
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								                            ('strong', 'Text', '\n    '),
 								                            ('span', 'Block', [  # This block is "pulled up"
 								                                ('span', 'Line', [
 								                                    ('span', 'Text', 'amet,')])])]),
 								                        ('span', 'Block', [  # This block is "pulled up"
 								                            ('span', 'Line', [
 								                                ('em', 'Inline', [
 								                                    ('em', 'Text', 'consectetur'),
 								                                    ('div', 'Block', []),
-												Bug fix: properly build anonymous blocks when a block element is in an inline

											
										
										
											2011-08-17 19:33:19 +04:00
+								                                    ])])])])])])])])
-												Change a test to cover more cases with inline-block.

											
										
										
											2011-05-25 17:55:08 +04:00
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								    box = build.block_in_inline(box)
-												Change a test to cover more cases with inline-block.

											
										
										
											2011-05-25 17:55:08 +04:00
+								    assert_tree(box, [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('body', 'Line', [
 								            ('p', 'InlineBlock', [
 								                ('p', 'AnonBlock', [
 								                    ('p', 'Line', [
 								                        ('p', 'Text', 'Lorem '),
 								                        ('em', 'Inline', [
 								                            ('em', 'Text', 'ipsum '),
 								                            ('strong', 'Inline', [
 								                                ('strong', 'Text', 'dolor ')])])])]),
 								                ('span', 'Block', [
 								                    ('span', 'Line', [
 								                        ('span', 'Text', 'sit')])]),
 								                ('p', 'AnonBlock', [
 								                    ('p', 'Line', [
 								                        ('em', 'Inline', [
 								                            ('strong', 'Inline', [
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								                                # Whitespace processing not done yet.
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								                                ('strong', 'Text', '\n    ')])])])]),
 								                ('span', 'Block', [
 								                    ('span', 'Line', [
 								                        ('span', 'Text', 'amet,')])]),
 								                ('p', 'AnonBlock', [
 								                    ('p', 'Line', [
 								                        ('em', 'Inline', [
 								                            ('strong', 'Inline', [])])])]),
 								                ('span', 'Block', [
 								                    ('span', 'AnonBlock', [
 								                        ('span', 'Line', [
 								                            ('em', 'Inline', [
 								                                ('em', 'Text', 'consectetur')])])]),
 								                    ('div', 'Block', []),
 								                    ('span', 'AnonBlock', [
 								                        ('span', 'Line', [
 								                            ('em', 'Inline', [])])])]),
 								                ('p', 'AnonBlock', [
 								                    ('p', 'Line', [
 								                        ('em', 'Inline', [])])])])])])
-												If a block has block children, wrap all non-block children
in anonymous blocks and lines.

											
										
										
											2011-05-19 18:03:50 +04:00
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								@SUITE.test
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								def test_styles():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the application of CSS to HTML."""
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								    box = parse('''
 								        <style>
 								            span { display: block; }
 								            * { margin: 42px }
 								            html { color: blue }
 								        </style>
 								        <p>Lorem <em>ipsum <strong>dolor <span>sit</span>
 								            <span>amet,</span></strong><span>consectetur</span></em></p>''')
-												Make box.children a deque, make box.copy() more efficient,
rework algorithm for block_in_inline.

											
										
										
											2011-07-20 13:35:43 +04:00
+								    box = build.inline_in_block(box)
 								    box = build.block_in_inline(box)
-												Remove trailing whitespace.

											
										
										
											2011-06-29 16:04:42 +04:00
-												Use strings or numbers instead of lists of cssutils Value objects.

... where appropriate. This remove much of the need for functions like
get_single_keyword and get_single_pixel_value.

											
										
										
											2011-10-08 16:41:12 +04:00
+								    descendants = list(box.descendants())
 								    assert len(descendants) == 31
 								    assert descendants[0] == box
 								    for child in descendants:
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								        # All boxes inherit the color
-												Use strings or numbers instead of lists of cssutils Value objects.

... where appropriate. This remove much of the need for functions like
get_single_keyword and get_single_pixel_value.

											
										
										
											2011-10-08 16:41:12 +04:00
+								        assert child.style.color.value == 'blue'
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								        # Only non-anonymous boxes have margins
-												Being anonymous is now an attribute of styles, not boxes.

											
										
										
											2011-12-05 18:25:42 +04:00
+								        if child.style.anonymous:
-												Use strings or numbers instead of lists of cssutils Value objects.

... where appropriate. This remove much of the need for functions like
get_single_keyword and get_single_pixel_value.

											
										
										
											2011-10-08 16:41:12 +04:00
+								            assert child.style.margin_top == 0
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
+								        else:
-												Use strings or numbers instead of lists of cssutils Value objects.

... where appropriate. This remove much of the need for functions like
get_single_keyword and get_single_pixel_value.

											
										
										
											2011-10-08 16:41:12 +04:00
+								            assert child.style.margin_top == 42
-												Boxes have style too.

											
										
										
											2011-05-23 15:59:47 +04:00
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								@SUITE.test
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								def test_whitespace():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the management of white spaces."""
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								    # TODO: test more cases
 								    # http://www.w3.org/TR/CSS21/text.html#white-space-model
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    assert_tree(parse_all('''
-												Fix some edge cases in whitespace processing.

											
										
										
											2011-11-16 20:34:02 +04:00
+								        <p>Lorem \t\r\n  ipsum\t<strong>  dolor
 								            <img src=pattern.png> sit</strong>.</p>
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								        <pre>\t  foo\n</pre>
 								        <pre style="white-space: pre-wrap">\t  foo\n</pre>
 								        <pre style="white-space: pre-line">\t  foo\n</pre>
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    '''), [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('p', 'Text', 'Lorem ipsum '),
 								                ('strong', 'Inline', [
-												Fix some edge cases in whitespace processing.

											
										
										
											2011-11-16 20:34:02 +04:00
+								                    ('strong', 'Text', 'dolor '),
-												Shorter names.

											
										
										
											2011-12-05 17:24:43 +04:00
+								                    ('img', 'InlineReplaced', '<replaced>'),
-												Fix some edge cases in whitespace processing.

											
										
										
											2011-11-16 20:34:02 +04:00
+								                    ('strong', 'Text', ' sit')]),
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								                ('p', 'Text', '.')])]),
 								        ('pre', 'Block', [
 								            ('pre', 'Line', [
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								                # pre
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								                ('pre', 'Text', u'\t\xA0\xA0foo\n')])]),
 								        ('pre', 'Block', [
 								            ('pre', 'Line', [
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								                # pre-wrap
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								                ('pre', 'Text', u'\t\xA0\xA0\u200Bfoo\n')])]),
 								        ('pre', 'Block', [
 								            ('pre', 'Line', [
-												Add tests for whitespace processing.

											
										
										
											2011-05-23 19:37:37 +04:00
+								                # pre-line
-												Whitespace processing: only atomic inlines "interrupt" text.

The rule is "any space following another space — even a space before
the inline"

Eg:
  A<p><span>B<img src=foo.png>C</span>D</p>

D follows C and B follows A, but C does not follow B because of the image.

											
										
										
											2011-12-01 17:46:23 +04:00
+								                ('pre', 'Text', u'foo\n')])])])
-												Test @page styles.

											
										
										
											2011-07-05 13:32:16 +04:00
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								@SUITE.test
-												Test @page styles.

											
										
										
											2011-07-05 13:32:16 +04:00
+								def test_page_style():
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    """Test the management of page styles."""
-												Use a shorter HTML stylesheet to speed up tests.

											
										
										
											2011-09-27 20:11:31 +04:00
+								    document = TestPNGDocument.from_string('''
-												Test @page styles.

											
										
										
											2011-07-05 13:32:16 +04:00
+								        <style>
 								            @page { margin: 3px }
 								            @page :first { margin-top: 20px }
 								            @page :right { margin-right: 10px; margin-top: 10px }
 								            @page :left { margin-left: 10px; margin-top: 10px }
 								        </style>
 								    ''')
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
-												Test @page styles.

											
										
										
											2011-07-05 13:32:16 +04:00
+								    def assert_page_margins(page_number, top, right, bottom, left):
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								        """Check the page margin values."""
-												Have the style passed as a parameter to boxes.

This prepares for :before and :after pseudo-elements.

											
										
										
											2011-12-02 14:31:06 +04:00
+								        style = page_style(document, page_number)
 								        assert style.margin_top == top
 								        assert style.margin_right == right
 								        assert style.margin_bottom == bottom
 								        assert style.margin_left == left
-												Test @page styles.

											
										
										
											2011-07-05 13:32:16 +04:00
-												Clean weasy/tests/test_boxes

											
										
										
											2011-08-24 13:36:10 +04:00
+								    # Odd numbers are :right pages, even are :left. 1 has :first as well
-												Test @page styles.

											
										
										
											2011-07-05 13:32:16 +04:00
+								    assert_page_margins(1, top=20, right=10, bottom=3, left=3)
 								    assert_page_margins(2, top=10, right=3, bottom=3, left=10)
 								    assert_page_margins(3, top=10, right=10, bottom=3, left=3)
 								    assert_page_margins(4, top=10, right=3, bottom=3, left=10)
 								    assert_page_margins(45, top=10, right=10, bottom=3, left=3)
 								    assert_page_margins(122, top=10, right=3, bottom=3, left=10)
-												Implement the `text-transform` property.

											
										
										
											2011-10-21 13:36:01 +04:00
 								@SUITE.test
 								def test_text_transform():
-												Clean, document and add tests

											
										
										
											2011-11-05 02:55:26 +04:00
+								    """Test the text-transform property."""
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    assert_tree(parse_all('''
-												Implement the `text-transform` property.

											
										
										
											2011-10-21 13:36:01 +04:00
+								        <style>
 								            p { text-transform: capitalize }
 								            p+p { text-transform: uppercase }
 								            p+p+p { text-transform: lowercase }
 								            p+p+p+p { text-transform: none }
 								        </style>
 								<p>heLLo wOrlD!</p><p>heLLo wOrlD!</p><p>heLLo wOrlD!</p><p>heLLo wOrlD!</p>
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    '''), [
-												Build box type from class name in test lists.

											
										
										
											2011-11-14 17:12:13 +04:00
+								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('p', 'Text', 'Hello World!')])]),
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('p', 'Text', 'HELLO WORLD!')])]),
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('p', 'Text', 'hello world!')])]),
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('p', 'Text', 'heLLo wOrlD!')])]),
-												Implement the `text-transform` property.

											
										
										
											2011-10-21 13:36:01 +04:00
+								    ])
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
 								@SUITE.test
 								def test_tables():
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    # Rules in http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
 								    # Rule 1.3
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								    # Also table model: http://www.w3.org/TR/CSS21/tables.html#model
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    assert_tree(parse_all('''
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								        <table>
 								            <tr>
 								                <th>foo</th>
 								                <th>bar</th>
 								            </tr>
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								            <tfoot></tfoot>
 								            <thead><th></th></thead>
 								            <caption style="caption-side: bottom"></caption>
 								            <thead></thead>
 								            <col></col>
 								            <caption>top caption</caption>
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								            <tr>
 								                <td>baz</td>
 								            </tr>
 								        </table>
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    '''), [
-												Initial layout for tables. (widths/horizontal only)

											
										
										
											2011-11-22 16:06:50 +04:00
+								        ('table', 'AnonBlock', [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								            ('caption', 'TableCaption', [
 								                ('caption', 'Line', [
 								                    ('caption', 'Text', 'top caption')])]),
 								            ('table', 'Table', [
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								                ('table', 'AnonTableColumnGroup', [
-												Make table-column boxes ParentBox instances. This removes some edge cases.

											
										
										
											2011-12-05 17:21:02 +04:00
+								                    ('col', 'TableColumn', [])]),
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								                ('thead', 'TableRowGroup', [
 								                    ('thead', 'AnonTableRow', [
 								                        ('th', 'TableCell', [])])]),
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								                ('table', 'AnonTableRowGroup', [
 								                    ('tr', 'TableRow', [
 								                        ('th', 'TableCell', [
 								                            ('th', 'Line', [
 								                                ('th', 'Text', 'foo')])]),
 								                        ('th', 'TableCell', [
 								                            ('th', 'Line', [
 								                                ('th', 'Text', 'bar')])])])]),
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								                ('thead', 'TableRowGroup', []),
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								                ('table', 'AnonTableRowGroup', [
 								                    ('tr', 'TableRow', [
 								                        ('td', 'TableCell', [
 								                            ('td', 'Line', [
 								                                ('td', 'Text', 'baz')])])])]),
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								                ('tfoot', 'TableRowGroup', [])]),
 								            ('caption', 'TableCaption', [])])])
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    # Rules 1.4 and 3.1
 								    assert_tree(parse_all('''
-												Initial support for table boxes. (No layout yet.)

											
										
										
											2011-11-14 17:29:40 +04:00
+								        <span style="display: table-cell">foo</span>
 								        <span style="display: table-cell">bar</span>
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
+								    '''), [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								        ('body', 'AnonBlock', [
 								            ('body', 'AnonTable', [
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								                ('body', 'AnonTableRowGroup', [
 								                    ('body', 'AnonTableRow', [
 								                        ('span', 'TableCell', [
 								                            ('span', 'Line', [
 								                                ('span', 'Text', 'foo')])]),
 								                        ('span', 'TableCell', [
 								                            ('span', 'Line', [
 								                                ('span', 'Text', 'bar')])])])])])])])
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
 								    # http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
 								    # Rules 1.1 and 1.2
 								    assert_tree(parse_all('''
 								        <span style="display: table-column-group">
 
 								            <em style="display: table-column">
 
 								                <strong>3</strong>
 								            </em>
 								            <strong>4</strong>
 								        </span>
 								    '''), [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								        ('body', 'AnonBlock', [
 								            ('body', 'AnonTable', [
 								                ('span', 'TableColumnGroup', [
-												Make table-column boxes ParentBox instances. This removes some edge cases.

											
										
										
											2011-12-05 17:21:02 +04:00
+								                    ('em', 'TableColumn', [])])])])])
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
 								    # Rules 2.1 then 2.3
 								    assert_tree(parse_all('<table>foo <div></div></table>'), [
-												Initial layout for tables. (widths/horizontal only)

											
										
										
											2011-11-22 16:06:50 +04:00
+								        ('table', 'AnonBlock', [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								            ('table', 'Table', [
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								                ('table', 'AnonTableRowGroup', [
 								                    ('table', 'AnonTableRow', [
 								                        ('table', 'AnonTableCell', [
 								                            ('table', 'AnonBlock', [
 								                                ('table', 'Line', [
 								                                    ('table', 'Text', 'foo ')])]),
 								                            ('div', 'Block', [])])])])])])])
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
 								    # Rule 2.2
 								    assert_tree(parse_all('<thead><div></div><td></td></thead>'), [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								        ('body', 'AnonBlock', [
 								            ('body', 'AnonTable', [
 								                ('thead', 'TableRowGroup', [
 								                    ('thead', 'AnonTableRow', [
 								                        ('thead', 'AnonTableCell', [
 								                            ('div', 'Block', [])]),
 								                        ('td', 'TableCell', [])])])])])])
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
-												Disable support for inline-table since inline-block is not supported either.

											
										
										
											2011-11-21 20:38:08 +04:00
+								    # TODO: re-enable this once we support inline-table
 								#    # Rule 3.2
 								#    assert_tree(parse_all('<span><tr></tr></span>'), [
 								#        ('body', 'Line', [
 								#            ('span', 'Inline', [
 								#                ('span', 'AnonInlineBlock', [
 								#                    ('span', 'AnonInlineTable', [
 								#                        ('span', 'AnonTableRowGroup', [
 								#                            ('tr', 'TableRow', [])])])])])])])
 								#    # Rule 3.1
 								#    # Also, rule 1.3 does not apply: whitespace before and after is preserved
 								#    assert_tree(parse_all('''
 								#        <span>
 								#            <em style="display: table-cell"></em>
 								#            <em style="display: table-cell"></em>
 								#        </span>
 								#    '''), [
 								#        ('body', 'Line', [
 								#            ('span', 'Inline', [
 								#                # Whitespace is preserved in table handling, then collapsed
 								#                # into a single space.
 								#                ('span', 'Text', ' '),
 								#                ('span', 'AnonInlineBlock', [
 								#                    ('span', 'AnonInlineTable', [
 								#                        ('span', 'AnonTableRowGroup', [
 								#                            ('span', 'AnonTableRow', [
 								#                                ('em', 'TableCell', []),
 								#                                ('em', 'TableCell', [])])])])]),
 								#                ('span', 'Text', ' ')])])])
-												More tests and fixes for table boxes.

											
										
										
											2011-11-14 20:42:15 +04:00
 								    # Rule 3.2
-												More tests and minor refactoring.

											
										
										
											2011-11-15 18:05:12 +04:00
+								    assert_tree(parse_all('<tr></tr>\t<tr></tr>'), [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								        ('body', 'AnonBlock', [
 								            ('body', 'AnonTable', [
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								                ('body', 'AnonTableRowGroup', [
 								                    ('tr', 'TableRow', []),
 								                    ('tr', 'TableRow', [])])])])])
-												More tests and minor refactoring.

											
										
										
											2011-11-15 18:05:12 +04:00
+								    assert_tree(parse_all('<col></col>\n<colgroup></colgroup>'), [
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								        ('body', 'AnonBlock', [
 								            ('body', 'AnonTable', [
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								                ('body', 'AnonTableColumnGroup', [
-												Make table-column boxes ParentBox instances. This removes some edge cases.

											
										
										
											2011-12-05 17:21:02 +04:00
+								                    ('col', 'TableColumn', [])]),
-												Add table wrappers and re-order table children.

											
										
										
											2011-11-15 21:22:00 +04:00
+								                ('colgroup', 'TableColumnGroup', [])])])])
-												Distribute table style among table wrapper box and table box.

											
										
										
											2011-11-15 21:58:43 +04:00
 								@SUITE.test
 								def test_table_style():
 								    html = parse_all('<table style="margin: 1px; padding: 2px"></table>')
 								    body, = html.children
 								    wrapper, = body.children
 								    table, = wrapper.children
 								    assert isinstance(wrapper, boxes.BlockBox)
 								    assert isinstance(table, boxes.TableBox)
 								    assert wrapper.style.margin_top == 1
 								    assert wrapper.style.padding_top == 0
 								    assert table.style.margin_top == 0
 								    assert table.style.padding_top == 2
-												Generate multiple boxes for <col> with span > 1

											
										
										
											2011-11-17 18:39:30 +04:00
 								@SUITE.test
-												Initial layout for tables. (widths/horizontal only)

											
										
										
											2011-11-22 16:06:50 +04:00
+								def test_column_style():
-												Generate multiple boxes for <col> with span > 1

											
										
										
											2011-11-17 18:39:30 +04:00
+								    html = parse_all('''
 								        <table>
 								            <col span=3 style="width: 10px"></col>
 								            <col span=2></col>
 								        </table>
 								    ''')
 								    body, = html.children
 								    wrapper, = body.children
 								    table, = wrapper.children
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								    colgroup, = table.column_groups
 								    widths = [col.style.width for col in colgroup.children]
-												Generate multiple boxes for <col> with span > 1

											
										
										
											2011-11-17 18:39:30 +04:00
+								    assert widths == [10, 10, 10, 'auto', 'auto']
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								    assert [col.grid_x for col in colgroup.children] == [0, 1, 2, 3, 4]
-												Generate multiple boxes for <col> with span > 1

											
										
										
											2011-11-17 18:39:30 +04:00
+								    # copies, not the same box object
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								    assert colgroup.children[0] is not colgroup.children[1]
-												Handle span on columns and assign grid_x positions.

											
										
										
											2011-11-17 19:13:00 +04:00
 								@SUITE.test
 								def test_nested_grid_x():
 								    html = parse_all('''
 								        <table>
 								            <col span=2></col>
 								            <colgroup span=2></colgroup>
 								            <colgroup>
 								                <col></col>
 								                <col span=2></col>
 								            </colgroup>
 								            <col></col>
 								        </table>
 								    ''')
 								    body, = html.children
 								    wrapper, = body.children
 								    table, = wrapper.children
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								    grid = [(colgroup.grid_x, [col.grid_x for col in colgroup.children])
-												Initial layout for tables. (widths/horizontal only)

											
										
										
											2011-11-22 16:06:50 +04:00
+								            for colgroup in table.column_groups]
-												Create anonymous row groups and column groups as needed.

											
										
										
											2011-11-17 20:05:55 +04:00
+								    assert grid == [(0, [0, 1]), (2, []), (4, [4, 5, 6]), (7, [7])]
-												Assign grid positions to cells, accounting for colspan and rowspan.

											
										
										
											2011-11-21 16:51:22 +04:00
 								@SUITE.test
 								def test_colspan_rowspan():
 								    """
 								    +---+---+---+
 								    | A | B | C | #
 								    +---+---+---+
 								    | D |     E | #
 								    +---+---+   +---+
 								    |  F ...|   |   |   <-- overlap
 								    +---+---+---+   +
 								    | H | #   # | G |
 								    +---+---+   +   +
 								    | I | J | # |   |
 								    +---+---+   +---+
 								    # empty cells
 								    """
 								    html = parse_all('''
 								        <table>
 								            <tr>
 								                <td>A <td>B <td>C
 								            </tr>
 								            <tr>
 								                <td>D <td colspan=2 rowspan=2>E
 								            </tr>
 								            <tr>
 								                <td colspan=2>F <td rowspan=0>G
 								            </tr>
 								            <tr>
 								                <td>H
 								            </tr>
 								            <tr>
 								                <td>I <td>J
 								            </tr>
 								        </table>
 								    ''')
 								    body, = html.children
 								    wrapper, = body.children
 								    table, = wrapper.children
 								    group, = table.children
 								    assert [[c.grid_x for c in row.children] for row in group.children] == [
 								        [0, 1, 2],
 								        [0, 1],
 								        [0,      3],
 								        [0],
 								        [0, 1],
 								    ]
 								    assert [[c.colspan for c in row.children] for row in group.children] == [
 								        [1, 1, 1],
 								        [1, 2],
 								        [2,      1],
 								        [1],
 								        [1, 1],
 								    ]
 								    assert [[c.rowspan for c in row.children] for row in group.children] == [
 								        [1, 1, 1],
 								        [1, 2],
 								        [1,      3],
 								        [1],
 								        [1, 1],
 								    ]
-												Add support for :before and :accept pseudo-elements.

Only with string or attr() content for now.

											
										
										
											2011-12-02 19:51:41 +04:00
 								@SUITE.test
 								def test_before_after():
 								    """Test the :before and :after pseudo-elements."""
 								    assert_tree(parse_all('''
 								        <style>
 								            p:before { content: 'a' 'b' }
 								            p:after { content: 'd' 'e' }
 								        </style>
 								        <p>
 								            c
 								        </p>
 								    '''), [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('p', 'Inline', [
-												Add support for generated quotes.

											
										
										
											2011-12-02 21:02:58 +04:00
+								                    ('p', 'Text', 'ab')]),
-												Add support for :before and :accept pseudo-elements.

Only with string or attr() content for now.

											
										
										
											2011-12-02 19:51:41 +04:00
+								                ('p', 'Text', ' c '),
 								                ('p', 'Inline', [
-												Add support for generated quotes.

											
										
										
											2011-12-02 21:02:58 +04:00
+								                    ('p', 'Text', 'de')])])])])
-												Add support for :before and :accept pseudo-elements.

Only with string or attr() content for now.

											
										
										
											2011-12-02 19:51:41 +04:00
 								    assert_tree(parse_all('''
 								        <style>
 								            a[href]:before { content: '[' attr(href) '] ' }
 								        </style>
 								        <p><a href="some url">some text</a></p>
 								    '''), [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('a', 'Inline', [
-												Add support for generated quotes.

											
										
										
											2011-12-02 21:02:58 +04:00
+								                    ('a', 'Inline', [  # :before
 								                        ('a', 'Text', '[some url] ')]),
-												Add support for :before and :accept pseudo-elements.

Only with string or attr() content for now.

											
										
										
											2011-12-02 19:51:41 +04:00
+								                    ('a', 'Text', 'some text')])])])])
-												Add support for generated quotes.

											
										
										
											2011-12-02 21:02:58 +04:00
 								    assert_tree(parse_all(u'''
 								        <style>
 								            body { quotes: '«' '»' '“' '”' }
 								            q:before { content: open-quote ' '}
 								            q:after { content: ' ' close-quote }
 								        </style>
 								        <p><q>Lorem ipsum <q>dolor</q> sit amet</q></p>
 								    '''), [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('q', 'Inline', [
 								                    ('q', 'Inline', [  # :before
 								                        ('q', 'Text', u'« ')]),
 								                    ('q', 'Text', 'Lorem ipsum '),
 								                    ('q', 'Inline', [
 								                        ('q', 'Inline', [  # :before
 								                            ('q', 'Text', u'“ ')]),
 								                        ('q', 'Text', 'dolor'),
 								                        ('q', 'Inline', [  # :after
 								                            ('q', 'Text', u' ”')])]),
 								                    ('q', 'Text', ' sit amet'),
 								                    ('q', 'Inline', [  # :after
 								                        ('q', 'Text', u' »')])])])])])
-												Add support for URLs (images) in `content`.

											
										
										
											2011-12-02 21:19:34 +04:00
 								    assert_tree(parse_all('''
 								        <style>
 								            p:before { content: 'a' url(pattern.png) 'b'}
 								        </style>
 								        <p>c</p>
 								    '''), [
 								        ('p', 'Block', [
 								            ('p', 'Line', [
 								                ('p', 'Inline', [  # :before
 								                    ('p', 'Text', 'a'),
-												Being anonymous is now an attribute of styles, not boxes.

											
										
										
											2011-12-05 18:25:42 +04:00
+								                    ('p', 'AnonInlineReplaced', '<replaced>'),
-												Add support for URLs (images) in `content`.

											
										
										
											2011-12-02 21:19:34 +04:00
+								                    ('p', 'Text', 'b')]),
 								                ('p', 'Text', 'c')])])])