Python unordered_list Examples

Example #1

File: test_unordered_list.py Project: AdityaDaflapurkar/digimenu

    def test_legacy(self):
        """
        Old format for unordered lists should still work
        """
        self.assertEqual(unordered_list(['item 1', []]), '\t<li>item 1</li>')

        self.assertEqual(
            unordered_list(['item 1', [['item 1.1', []]]]),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>',
        )

        self.assertEqual(
            unordered_list(['item 1', [['item 1.1', []], ['item 1.2', []]]]),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1'
            '</li>\n\t\t<li>item 1.2</li>\n\t</ul>\n\t</li>',
        )

        self.assertEqual(
            unordered_list([
                'States',
                [['Kansas', [['Lawrence', []], ['Topeka', []]]],
                 ['Illinois', []]]
            ]),
            '\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>Lawrence</li>'
            '\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>',
        )

Example #2

File: test_unordered_list.py Project: thibaudcolas/django

    def test_ulitem(self):
        class ULItem:
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return "ulitem-%s" % str(self.title)

        a = ULItem("a")
        b = ULItem("b")
        c = ULItem("<a>c</a>")
        self.assertEqual(
            unordered_list([a, b, c]),
            "\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t"
            "<li>ulitem-&lt;a&gt;c&lt;/a&gt;</li>",
        )

        def item_generator():
            yield from (a, b, c)

        self.assertEqual(
            unordered_list(item_generator()),
            "\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t"
            "<li>ulitem-&lt;a&gt;c&lt;/a&gt;</li>",
        )

Example #3

    def test_ulitem(self):
        class ULItem:
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return 'ulitem-%s' % str(self.title)

        a = ULItem('a')
        b = ULItem('b')
        c = ULItem('<a>c</a>')
        self.assertEqual(
            unordered_list([a, b, c]),
            '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-&lt;a&gt;c&lt;/a&gt;</li>',
        )

        def item_generator():
            yield a
            yield b
            yield c

        self.assertEqual(
            unordered_list(item_generator()),
            '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-&lt;a&gt;c&lt;/a&gt;</li>',
        )

Example #4

File: test_unordered_list.py Project: ravn244/django

    def test_ulitem_autoescape_off(self):
        @python_2_unicode_compatible
        class ULItem(object):
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return 'ulitem-%s' % str(self.title)

        a = ULItem('a')
        b = ULItem('b')
        c = ULItem('<a>c</a>')
        self.assertEqual(
            unordered_list([a, b, c], autoescape=False),
            '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-<a>c</a></li>',
        )

        def item_generator():
            yield a
            yield b
            yield c

        self.assertEqual(
            unordered_list(item_generator(), autoescape=False),
            '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-<a>c</a></li>',
        )

Example #5

    def test_legacy(self):
        """
        Old format for unordered lists should still work
        """
        with warnings.catch_warnings():
            warnings.simplefilter('ignore', RemovedInDjango20Warning)

            self.assertEqual(unordered_list(['item 1', []]),
                             '\t<li>item 1</li>')

            self.assertEqual(
                unordered_list(['item 1', [['item 1.1', []]]]),
                '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>',
            )

            self.assertEqual(
                unordered_list(
                    ['item 1', [['item 1.1', []], ['item 1.2', []]]]),
                '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1'
                '</li>\n\t\t<li>item 1.2</li>\n\t</ul>\n\t</li>',
            )

            self.assertEqual(
                unordered_list([
                    'States',
                    [['Kansas', [['Lawrence', []], ['Topeka', []]]],
                     ['Illinois', []]]
                ]),
                '\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>Lawrence</li>'
                '\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>',
            )

Example #6

File: test_unordered_list.py Project: lab3000/GalvanizeU

    def test_ulitem_autoescape_off(self):
        @python_2_unicode_compatible
        class ULItem(object):
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return 'ulitem-%s' % str(self.title)

        a = ULItem('a')
        b = ULItem('b')
        c = ULItem('<a>c</a>')
        self.assertEqual(
            unordered_list([a, b, c], autoescape=False),
            '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-<a>c</a></li>',
        )

        def item_generator():
            yield a
            yield b
            yield c

        self.assertEqual(
            unordered_list(item_generator(), autoescape=False),
            '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-<a>c</a></li>',
        )

Example #7

    def test_unordered_list(self):
        self.assertEqual(unordered_list(['item 1', 'item 2']),
                         '\t<li>item 1</li>\n\t<li>item 2</li>')
        self.assertEqual(
            unordered_list(['item 1', ['item 1.1']]),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>')

        self.assertEqual(
            unordered_list(['item 1', ['item 1.1', 'item1.2'], 'item 2']),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t\t<li>item1.2'
            '</li>\n\t</ul>\n\t</li>\n\t<li>item 2</li>')

        self.assertEqual(
            unordered_list(
                ['item 1', ['item 1.1', ['item 1.1.1', ['item 1.1.1.1']]]]),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1\n\t\t<ul>\n\t\t\t<li>'
            'item 1.1.1\n\t\t\t<ul>\n\t\t\t\t<li>item 1.1.1.1</li>\n\t\t\t'
            '</ul>\n\t\t\t</li>\n\t\t</ul>\n\t\t</li>\n\t</ul>\n\t</li>')

        self.assertEqual(
            unordered_list(
                ['States', ['Kansas', ['Lawrence', 'Topeka'], 'Illinois']]),
            '\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>'
            'Lawrence</li>\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>'
            '\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>')

        @python_2_unicode_compatible
        class ULItem(object):
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return 'ulitem-%s' % str(self.title)

        a = ULItem('a')
        b = ULItem('b')
        self.assertEqual(unordered_list([a, b]),
                         '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>')

        # Old format for unordered lists should still work
        self.assertEqual(unordered_list(['item 1', []]), '\t<li>item 1</li>')

        self.assertEqual(
            unordered_list(['item 1', [['item 1.1', []]]]),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>')

        self.assertEqual(
            unordered_list(['item 1', [['item 1.1', []], ['item 1.2', []]]]),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1'
            '</li>\n\t\t<li>item 1.2</li>\n\t</ul>\n\t</li>')

        self.assertEqual(
            unordered_list([
                'States',
                [['Kansas', [['Lawrence', []], ['Topeka', []]]],
                 ['Illinois', []]]
            ]), '\t<li>States\n\t'
            '<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>Lawrence</li>'
            '\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>\n\t\t<li>'
            'Illinois</li>\n\t</ul>\n\t</li>')

Example #8

File: test_unordered_list.py Project: CrazyChief/django

    def test_ulitem(self):
        class ULItem:
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return 'ulitem-%s' % str(self.title)

        a = ULItem('a')
        b = ULItem('b')
        c = ULItem('<a>c</a>')
        self.assertEqual(
            unordered_list([a, b, c]),
            '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-&lt;a&gt;c&lt;/a&gt;</li>',
        )

        def item_generator():
            yield a
            yield b
            yield c

        self.assertEqual(
            unordered_list(item_generator()),
            '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-&lt;a&gt;c&lt;/a&gt;</li>',
        )

Example #9

File: tests.py Project: Alexis374/django

    def test_unordered_list(self):
        self.assertEqual(unordered_list(['item 1', 'item 2']),
            '\t<li>item 1</li>\n\t<li>item 2</li>')
        self.assertEqual(unordered_list(['item 1', ['item 1.1']]),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>')

        self.assertEqual(
            unordered_list(['item 1', ['item 1.1', 'item1.2'], 'item 2']),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t\t<li>item1.2'
            '</li>\n\t</ul>\n\t</li>\n\t<li>item 2</li>')

        self.assertEqual(
            unordered_list(['item 1', ['item 1.1', ['item 1.1.1', ['item 1.1.1.1']]]]),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1\n\t\t<ul>\n\t\t\t<li>'
            'item 1.1.1\n\t\t\t<ul>\n\t\t\t\t<li>item 1.1.1.1</li>\n\t\t\t'
            '</ul>\n\t\t\t</li>\n\t\t</ul>\n\t\t</li>\n\t</ul>\n\t</li>')

        self.assertEqual(unordered_list(
            ['States', ['Kansas', ['Lawrence', 'Topeka'], 'Illinois']]),
            '\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>'
            'Lawrence</li>\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>'
            '\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>')

        @python_2_unicode_compatible
        class ULItem(object):
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return 'ulitem-%s' % str(self.title)

        a = ULItem('a')
        b = ULItem('b')
        self.assertEqual(unordered_list([a, b]), '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>')

        # Old format for unordered lists should still work
        with warnings.catch_warnings(record=True):
            warnings.simplefilter("always")

            self.assertEqual(unordered_list(['item 1', []]), '\t<li>item 1</li>')

            self.assertEqual(unordered_list(['item 1', [['item 1.1', []]]]),
                '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>')

            self.assertEqual(unordered_list(['item 1', [['item 1.1', []],
                ['item 1.2', []]]]), '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1'
                '</li>\n\t\t<li>item 1.2</li>\n\t</ul>\n\t</li>')

            self.assertEqual(unordered_list(['States', [['Kansas', [['Lawrence',
                []], ['Topeka', []]]], ['Illinois', []]]]), '\t<li>States\n\t'
                '<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>Lawrence</li>'
                '\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>\n\t\t<li>'
                'Illinois</li>\n\t</ul>\n\t</li>')

Example #10

File: test_unordered_list.py Project: ravn244/django

 def test_nested_multiple(self):
     self.assertEqual(
         unordered_list(['item 1', ['item 1.1', ['item 1.1.1', ['item 1.1.1.1']]]]),
         '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1\n\t\t<ul>\n\t\t\t<li>'
         'item 1.1.1\n\t\t\t<ul>\n\t\t\t\t<li>item 1.1.1.1</li>\n\t\t\t'
         '</ul>\n\t\t\t</li>\n\t\t</ul>\n\t\t</li>\n\t</ul>\n\t</li>',
     )

Example #11

File: test_unordered_list.py Project: thibaudcolas/django

 def test_nested_multiple(self):
     self.assertEqual(
         unordered_list(["item 1", ["item 1.1", ["item 1.1.1", ["item 1.1.1.1"]]]]),
         "\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1\n\t\t<ul>\n\t\t\t<li>"
         "item 1.1.1\n\t\t\t<ul>\n\t\t\t\t<li>item 1.1.1.1</li>\n\t\t\t"
         "</ul>\n\t\t\t</li>\n\t\t</ul>\n\t\t</li>\n\t</ul>\n\t</li>",
     )

Example #12

File: test_unordered_list.py Project: daiqingyang/django

 def test_nested_multiple(self):
     self.assertEqual(
         unordered_list(["item 1", ["item 1.1", ["item 1.1.1", ["item 1.1.1.1"]]]]),
         "\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1\n\t\t<ul>\n\t\t\t<li>"
         "item 1.1.1\n\t\t\t<ul>\n\t\t\t\t<li>item 1.1.1.1</li>\n\t\t\t"
         "</ul>\n\t\t\t</li>\n\t\t</ul>\n\t\t</li>\n\t</ul>\n\t</li>",
     )

Example #13

File: test_unordered_list.py Project: ravn244/django

 def test_nested_multiple2(self):
     self.assertEqual(
         unordered_list(['States', ['Kansas', ['Lawrence', 'Topeka'], 'Illinois']]),
         '\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>'
         'Lawrence</li>\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>'
         '\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>',
     )

Example #14

File: test_unordered_list.py Project: yephper/django

 def test_nested_multiple2(self):
     self.assertEqual(
         unordered_list(['States', ['Kansas', ['Lawrence', 'Topeka'], 'Illinois']]),
         '\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>'
         'Lawrence</li>\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>'
         '\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>',
     )

Example #15

File: test_unordered_list.py Project: daiqingyang/django

 def test_nested_multiple2(self):
     self.assertEqual(
         unordered_list(["States", ["Kansas", ["Lawrence", "Topeka"], "Illinois"]]),
         "\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>"
         "Lawrence</li>\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>"
         "\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>",
     )

Example #16

File: test_unordered_list.py Project: yephper/django

 def test_nested_multiple(self):
     self.assertEqual(
         unordered_list(['item 1', ['item 1.1', ['item 1.1.1', ['item 1.1.1.1']]]]),
         '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1\n\t\t<ul>\n\t\t\t<li>'
         'item 1.1.1\n\t\t\t<ul>\n\t\t\t\t<li>item 1.1.1.1</li>\n\t\t\t'
         '</ul>\n\t\t\t</li>\n\t\t</ul>\n\t\t</li>\n\t</ul>\n\t</li>',
     )

Example #17

File: test_unordered_list.py Project: thibaudcolas/django

 def test_nested_multiple2(self):
     self.assertEqual(
         unordered_list(["States", ["Kansas", ["Lawrence", "Topeka"], "Illinois"]]),
         "\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>"
         "Lawrence</li>\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>"
         "\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>",
     )

Example #18

 def populate_toc(self, export_url):
     package = self.idevice.parent_node.package
     toc_list = [self._generate_item(package.root, export_url)]
     if package.root.children.exists():
         toc_list.append(self._generate_toc_tree(package.root, export_url))
     return '<ul class="toc">%s</ul>' % unordered_list(toc_list,
                                                       autoescape=False)

Example #19

File: test_unordered_list.py Project: daiqingyang/django

    def test_ulitem(self):
        @python_2_unicode_compatible
        class ULItem(object):
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return "ulitem-%s" % str(self.title)

        a = ULItem("a")
        b = ULItem("b")
        self.assertEqual(unordered_list([a, b]), "\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>")

        def item_generator():
            yield a
            yield b

        self.assertEqual(unordered_list(item_generator()), "\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>")

Example #20

File: admin.py Project: nask0/openpgp-python

def _nested_objs(obj):
    c = NestedObjects("default")
    c.collect([obj])

    def format_callback(obj):
        return mark_safe('<a href="/keys/{}/{}/">{}</a>'.format(obj._meta.model_name, obj.pk, escape(obj)))

    result = unordered_list(c.nested(format_callback))
    return mark_safe("<ul>{}</ul>".format(result))

Example #21

File: mainpage_extras.py Project: almir-sahinovic/creyoco

def render_outline(package, current_node):
    NODE_TEMPLATE = "exe/node_link.html"

    node_list = [
        render_to_string(NODE_TEMPLATE, {"node": package.root}),
        _create_children_list(package.root, NODE_TEMPLATE)
    ]
    node_list_content = unordered_list(node_list, autoescape=False)

    return locals()

Example #22

    def test_ulitem(self):
        @python_2_unicode_compatible
        class ULItem(object):
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return 'ulitem-%s' % str(self.title)

        a = ULItem('a')
        b = ULItem('b')
        self.assertEqual(unordered_list([a, b]),
                         '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>')

        def item_generator():
            yield a
            yield b

        self.assertEqual(unordered_list(item_generator()),
                         '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>')

Example #23

File: test_unordered_list.py Project: daiqingyang/django

    def test_legacy(self):
        """
        Old format for unordered lists should still work
        """
        self.assertEqual(unordered_list(["item 1", []]), "\t<li>item 1</li>")

        self.assertEqual(
            unordered_list(["item 1", [["item 1.1", []]]]),
            "\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>",
        )

        self.assertEqual(
            unordered_list(["item 1", [["item 1.1", []], ["item 1.2", []]]]),
            "\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1" "</li>\n\t\t<li>item 1.2</li>\n\t</ul>\n\t</li>",
        )

        self.assertEqual(
            unordered_list(["States", [["Kansas", [["Lawrence", []], ["Topeka", []]]], ["Illinois", []]]]),
            "\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>Lawrence</li>"
            "\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>",
        )

Example #24

File: mainpage_extras.py Project: go38/exedjango

def idevice_ul(groups, group_order):
    idevice_list = []
    for group in group_order:
        idevice_list.append("<a>%s</a>" % group)
        prototype_list = []
        for prototype in groups[group]:
            prototype_list.append('<a class="ideviceItem" href="#"' + \
                ' ideviceid="%s">%s</a>' % (prototype.__name__,
                                             prototype.name))
        idevice_list.append(prototype_list)

    return unordered_list(idevice_list)

Example #25

File: mainpage_extras.py Project: almir-sahinovic/creyoco

def idevice_ul(groups, group_order):
    idevice_list = []
    for group in group_order:
        idevice_list.append(force_text("<a>%s</a>" % group))
        prototype_list = []
        for prototype in groups[group]:
            prototype_list.append(force_text('<a class="ideviceItem" href="#"' + \
                                  ' ideviceid="%s">%s</a>' % (
                                      prototype.__name__,
                                      force_text(prototype.name))))
        idevice_list.append(prototype_list)
    return unordered_list(idevice_list, autoescape=False)

Example #26

File: test_unordered_list.py Project: ravn244/django

    def test_legacy(self):
        """
        Old format for unordered lists should still work
        """
        self.assertEqual(unordered_list(['item 1', []]), '\t<li>item 1</li>')

        self.assertEqual(
            unordered_list(['item 1', [['item 1.1', []]]]),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>',
        )

        self.assertEqual(
            unordered_list(['item 1', [['item 1.1', []],
            ['item 1.2', []]]]), '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1'
            '</li>\n\t\t<li>item 1.2</li>\n\t</ul>\n\t</li>',
        )

        self.assertEqual(
            unordered_list(['States', [['Kansas', [['Lawrence', []], ['Topeka', []]]], ['Illinois', []]]]),
            '\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>Lawrence</li>'
            '\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>',
        )

Example #27

File: test_unordered_list.py Project: ArcTanSusan/django

    def test_nested_generators(self):
        def inner_generator():
            yield from ('B', 'C')

        def item_generator():
            yield 'A'
            yield inner_generator()
            yield 'D'

        self.assertEqual(
            unordered_list(item_generator()),
            '\t<li>A\n\t<ul>\n\t\t<li>B</li>\n\t\t<li>C</li>\n\t</ul>\n\t</li>\n\t<li>D</li>',
        )

Example #28

File: test_unordered_list.py Project: guyi2020/blog

    def test_nested_generators(self):
        def inner_generator():
            yield from ('B', 'C')

        def item_generator():
            yield 'A'
            yield inner_generator()
            yield 'D'

        self.assertEqual(
            unordered_list(item_generator()),
            '\t<li>A\n\t<ul>\n\t\t<li>B</li>\n\t\t<li>C</li>\n\t</ul>\n\t</li>\n\t<li>D</li>',
        )

Example #29

File: test_unordered_list.py Project: thibaudcolas/django

    def test_ulitem_autoescape_off(self):
        class ULItem:
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return "ulitem-%s" % str(self.title)

        a = ULItem("a")
        b = ULItem("b")
        c = ULItem("<a>c</a>")
        self.assertEqual(
            unordered_list([a, b, c], autoescape=False),
            "\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-<a>c</a></li>",
        )

        def item_generator():
            yield from (a, b, c)

        self.assertEqual(
            unordered_list(item_generator(), autoescape=False),
            "\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-<a>c</a></li>",
        )

Example #30

File: test_unordered_list.py Project: thibaudcolas/django

    def test_nested_generators(self):
        def inner_generator():
            yield from ("B", "C")

        def item_generator():
            yield "A"
            yield inner_generator()
            yield "D"

        self.assertEqual(
            unordered_list(item_generator()),
            "\t<li>A\n\t<ul>\n\t\t<li>B</li>\n\t\t<li>C</li>\n\t</ul>\n\t</li>\n\t"
            "<li>D</li>",
        )

Example #31

File: test_unordered_list.py Project: Damgaard/django

    def test_ulitem_autoescape_off(self):
        class ULItem:
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return 'ulitem-%s' % str(self.title)

        a = ULItem('a')
        b = ULItem('b')
        c = ULItem('<a>c</a>')
        self.assertEqual(
            unordered_list([a, b, c], autoescape=False),
            '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-<a>c</a></li>',
        )

        def item_generator():
            yield from (a, b, c)

        self.assertEqual(
            unordered_list(item_generator(), autoescape=False),
            '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>\n\t<li>ulitem-<a>c</a></li>',
        )

Example #32

def format_unordered_list(object_list, template_name):
    """
    Use django's `unordered_list` filter but use a template to render the
    items. The items are expected to be dicts and will be passed as context
    into the template.
    """
    def reformat_list(nested_list):
        new_list = []
        for item in nested_list:
            if isinstance(item, (list, tuple)):
                item = reformat_list(item)
            else:
                item = render_to_string(template_name, item)
            new_list.append(item)
        return new_list
    object_list = reformat_list(object_list)
    return unordered_list(object_list)

Example #33

def extra_facts(extra_facts, autoescape=True):
    if autoescape:
        esc = conditional_escape
    else:

        def esc(x):
            return x

    if not extra_facts or not isinstance(extra_facts, dict):
        return mark_safe("")
    data = ""
    for key in sorted(extra_facts.keys()):
        data += "<dt>{}</dt>\n".format(esc(key))
        val = extra_facts[key]
        if isinstance(val, list):
            val_data = "<ul>\n{}</ul>\n".format(
                unordered_list(val, autoescape=autoescape))
        else:
            val_data = esc(val)
        data += "<dd>\n{}\n</dd>\n".format(val_data)
    return mark_safe(data)

Example #34

File: admin.py Project: edos21/ironmanedgar

 def _block(self, object):
     items = unordered_list([
         '%s' % (name, ) for key, name in Article.BLOCK_CHOICES
         if key in object.block
     ])
     return '<ul>%s</ul>\n' % items

Example #35

File: test_unordered_list.py Project: thibaudcolas/django

 def test_nested3(self):
     self.assertEqual(
         unordered_list(["item 1", "item 2", ["item 2.1"]]),
         "\t<li>item 1</li>\n\t<li>item 2\n\t<ul>\n\t\t<li>item 2.1"
         "</li>\n\t</ul>\n\t</li>",
     )

Example #36

File: tests.py Project: GT-Master/DNDC

    def test_unordered_list(self):
        self.assertEqual(unordered_list(['item 1', 'item 2']),
                         '\t<li>item 1</li>\n\t<li>item 2</li>')
        self.assertEqual(
            unordered_list(['item 1', ['item 1.1']]),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>')

        self.assertEqual(
            unordered_list(['item 1', ['item 1.1', 'item1.2'], 'item 2']),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t\t<li>item1.2'
            '</li>\n\t</ul>\n\t</li>\n\t<li>item 2</li>')

        self.assertEqual(
            unordered_list(
                ['item 1', ['item 1.1', ['item 1.1.1', ['item 1.1.1.1']]]]),
            '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1\n\t\t<ul>\n\t\t\t<li>'
            'item 1.1.1\n\t\t\t<ul>\n\t\t\t\t<li>item 1.1.1.1</li>\n\t\t\t'
            '</ul>\n\t\t\t</li>\n\t\t</ul>\n\t\t</li>\n\t</ul>\n\t</li>')

        self.assertEqual(
            unordered_list(
                ['States', ['Kansas', ['Lawrence', 'Topeka'], 'Illinois']]),
            '\t<li>States\n\t<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>'
            'Lawrence</li>\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>'
            '\n\t\t<li>Illinois</li>\n\t</ul>\n\t</li>')

        @python_2_unicode_compatible
        class ULItem(object):
            def __init__(self, title):
                self.title = title

            def __str__(self):
                return 'ulitem-%s' % str(self.title)

        a = ULItem('a')
        b = ULItem('b')
        self.assertEqual(unordered_list([a, b]),
                         '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>')

        def item_generator():
            yield a
            yield b

        self.assertEqual(unordered_list(item_generator()),
                         '\t<li>ulitem-a</li>\n\t<li>ulitem-b</li>')

        # Old format for unordered lists should still work
        with warnings.catch_warnings(record=True):
            warnings.simplefilter("always")

            self.assertEqual(unordered_list(['item 1', []]),
                             '\t<li>item 1</li>')

            self.assertEqual(
                unordered_list(['item 1', [['item 1.1', []]]]),
                '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>'
            )

            self.assertEqual(
                unordered_list(
                    ['item 1', [['item 1.1', []], ['item 1.2', []]]]),
                '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1'
                '</li>\n\t\t<li>item 1.2</li>\n\t</ul>\n\t</li>')

            self.assertEqual(
                unordered_list([
                    'States',
                    [['Kansas', [['Lawrence', []], ['Topeka', []]]],
                     ['Illinois', []]]
                ]), '\t<li>States\n\t'
                '<ul>\n\t\t<li>Kansas\n\t\t<ul>\n\t\t\t<li>Lawrence</li>'
                '\n\t\t\t<li>Topeka</li>\n\t\t</ul>\n\t\t</li>\n\t\t<li>'
                'Illinois</li>\n\t</ul>\n\t</li>')

Example #37

File: test_unordered_list.py Project: lab3000/GalvanizeU

 def test_nested3(self):
     self.assertEqual(
         unordered_list(['item 1', 'item 2', ['item 2.1']]),
         '\t<li>item 1</li>\n\t<li>item 2\n\t<ul>\n\t\t<li>item 2.1'
         '</li>\n\t</ul>\n\t</li>',
     )

Example #38

File: test_unordered_list.py Project: lab3000/GalvanizeU

 def test_list(self):
     self.assertEqual(unordered_list(['item 1', 'item 2']),
                      '\t<li>item 1</li>\n\t<li>item 2</li>')

Example #39

File: test_unordered_list.py Project: thibaudcolas/django

 def test_nested2(self):
     self.assertEqual(
         unordered_list(["item 1", ["item 1.1", "item1.2"], "item 2"]),
         "\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t\t<li>item1.2"
         "</li>\n\t</ul>\n\t</li>\n\t<li>item 2</li>",
     )

Example #40

File: test_unordered_list.py Project: daiqingyang/django

 def test_nested2(self):
     self.assertEqual(
         unordered_list(["item 1", ["item 1.1", "item1.2"], "item 2"]),
         "\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t\t<li>item1.2" "</li>\n\t</ul>\n\t</li>\n\t<li>item 2</li>",
     )

Example #41

File: test_unordered_list.py Project: Damgaard/django

 def test_nested3(self):
     self.assertEqual(
         unordered_list(['item 1', 'item 2', ['item 2.1']]),
         '\t<li>item 1</li>\n\t<li>item 2\n\t<ul>\n\t\t<li>item 2.1'
         '</li>\n\t</ul>\n\t</li>',
     )

Example #42

File: tables.py Project: NZtechpapa/expert-system

def safe_unordered_list(value):
    return filters.unordered_list(value, autoescape=True)

Example #43

File: tocidevice.py Project: go38/exedjango

 def populate_toc(self):
     package = self.parent_node.package
     toc_list = [self._generate_item(package.root)]
     if package.root.children.exists():
         toc_list.append(self._generate_toc_tree(package.root))
     return '<ul class="toc">%s</ul>' % unordered_list(toc_list)

Example #44

File: test_unordered_list.py Project: lab3000/GalvanizeU

 def test_autoescape_off(self):
     self.assertEqual(
         unordered_list(['<a>item 1</a>', 'item 2'], autoescape=False),
         '\t<li><a>item 1</a></li>\n\t<li>item 2</li>',
     )

Example #45

File: templates.py Project: xealot/django-helpers

def unordered_list(context, value):
    return filters.unordered_list(value)

Example #46

File: test_unordered_list.py Project: ravn244/django

 def test_nested2(self):
     self.assertEqual(
         unordered_list(['item 1', ['item 1.1', 'item1.2'], 'item 2']),
         '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t\t<li>item1.2'
         '</li>\n\t</ul>\n\t</li>\n\t<li>item 2</li>',
     )

Example #47

File: test_unordered_list.py Project: lab3000/GalvanizeU

 def test_nested2(self):
     self.assertEqual(
         unordered_list(['item 1', ['item 1.1', 'item1.2'], 'item 2']),
         '\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t\t<li>item1.2'
         '</li>\n\t</ul>\n\t</li>\n\t<li>item 2</li>',
     )

Example #48

File: test_unordered_list.py Project: ravn244/django

 def test_autoescape_off(self):
     self.assertEqual(
         unordered_list(['<a>item 1</a>', 'item 2'], autoescape=False),
         '\t<li><a>item 1</a></li>\n\t<li>item 2</li>',
     )

Example #49

File: test_unordered_list.py Project: lab3000/GalvanizeU

 def test_autoescape(self):
     self.assertEqual(
         unordered_list(['<a>item 1</a>', 'item 2']),
         '\t<li>&lt;a&gt;item 1&lt;/a&gt;</li>\n\t<li>item 2</li>',
     )

Example #50

File: test_unordered_list.py Project: ravn244/django

 def test_list(self):
     self.assertEqual(unordered_list(['item 1', 'item 2']), '\t<li>item 1</li>\n\t<li>item 2</li>')

Example #51

File: test_unordered_list.py Project: thibaudcolas/django

 def test_list_gettext(self):
     self.assertEqual(
         unordered_list(["item 1", gettext_lazy("item 2")]),
         "\t<li>item 1</li>\n\t<li>item 2</li>",
     )

Example #52

File: test_unordered_list.py Project: ArcTanSusan/django

 def test_list_gettext(self):
     self.assertEqual(
         unordered_list(['item 1', gettext_lazy('item 2')]),
         '\t<li>item 1</li>\n\t<li>item 2</li>'
     )

Example #53

File: test_unordered_list.py Project: daiqingyang/django

 def test_list(self):
     self.assertEqual(unordered_list(["item 1", "item 2"]), "\t<li>item 1</li>\n\t<li>item 2</li>")

Example #54

File: test_unordered_list.py Project: ravn244/django

 def test_autoescape(self):
     self.assertEqual(
         unordered_list(['<a>item 1</a>', 'item 2']),
         '\t<li>&lt;a&gt;item 1&lt;/a&gt;</li>\n\t<li>item 2</li>',
     )

Example #55

File: tables.py Project: amotoki/horizon

def safe_unordered_list(value):
    return filters.unordered_list(value, autoescape=True)

Example #56

File: test_unordered_list.py Project: daiqingyang/django

 def test_nested(self):
     self.assertEqual(
         unordered_list(["item 1", ["item 1.1"]]), "\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>"
     )

Example #57

File: project_filters.py Project: timur-orudzhov/e-travel

def format_phone_numbers(value):
    return unordered_list(value.split(','))

Example #58

File: serializers.py Project: mkwm/casia

 def to_html(cls, obj, field):
     return '<ul>%s</ul>' % unordered_list(get_field_value(field, obj).all(),
                                           escape)