コード例 #1
0
ファイル: test_flatten.py プロジェクト: chevah/twisted
 def test_serializeCDATA(self):
     """
     Test that CDATA is correctly flattened and escaped.
     """
     self.assertFlattensImmediately(CDATA("foo bar"), b"<![CDATA[foo bar]]>"),
     self.assertFlattensImmediately(
         CDATA("foo ]]> bar"), b"<![CDATA[foo ]]]]><![CDATA[> bar]]>"
     )
コード例 #2
0
 def test_serializeCDATA(self):
     """
     Test that CDATA is correctly flattened and escaped.
     """
     return gatherResults([
         self.assertFlattensTo(CDATA('foo bar'), '<![CDATA[foo bar]]>'),
         self.assertFlattensTo(CDATA('foo ]]> bar'),
                               '<![CDATA[foo ]]]]><![CDATA[> bar]]>'),
     ])
コード例 #3
0
 def test_cdataReprPy3(self):
     """
     L{CDATA.__repr__} returns a value which makes it easy to see what's in
     the comment.
     """
     self.assertEqual(repr(CDATA("test data")),
                      "CDATA('test data')")
コード例 #4
0
ファイル: html.py プロジェクト: thiasB/kotori
    def fill_slots(self, request, tag):

        slotdata = self.__dict__.copy()

        # Pass data to template verbatim without applying htmlentity conversion
        slotdata['data_uri'] = CDATA(slotdata['data_uri'])

        tag.fillSlots(**slotdata)
        return tag
コード例 #5
0
ファイル: test_flatten.py プロジェクト: chevah/twisted
 def test_serializeUnicode(self):
     """
     Test that unicode is encoded correctly in the appropriate places, and
     raises an error when it occurs in inappropriate place.
     """
     snowman = "\N{SNOWMAN}"
     self.assertFlattensImmediately(snowman, b"\xe2\x98\x83")
     self.assertFlattensImmediately(tags.p(snowman), b"<p>\xe2\x98\x83</p>")
     self.assertFlattensImmediately(Comment(snowman), b"<!--\xe2\x98\x83-->")
     self.assertFlattensImmediately(CDATA(snowman), b"<![CDATA[\xe2\x98\x83]]>")
     self.assertFlatteningRaises(Tag(snowman), UnicodeEncodeError)
     self.assertFlatteningRaises(
         Tag("p", attributes={snowman: ""}), UnicodeEncodeError
     )
コード例 #6
0
 def test_serializeUnicode(self):
     """
     Test that unicode is encoded correctly in the appropriate places, and
     raises an error when it occurs in inappropriate place.
     """
     snowman = u'\N{SNOWMAN}'
     return gatherResults([
         self.assertFlattensTo(snowman, '\xe2\x98\x83'),
         self.assertFlattensTo(tags.p(snowman), '<p>\xe2\x98\x83</p>'),
         self.assertFlattensTo(Comment(snowman), '<!--\xe2\x98\x83-->'),
         self.assertFlattensTo(CDATA(snowman), '<![CDATA[\xe2\x98\x83]]>'),
         self.assertFlatteningRaises(Tag(snowman), UnicodeEncodeError),
         self.assertFlatteningRaises(Tag('p', attributes={snowman: ''}),
                                     UnicodeEncodeError),
     ])
def make_html(components, instances):
    table = tags.table(class_='main')
    heading_row = tags.tr()
    for heading in 'component', 'tip revno', 'unreleased revisions', 'latest release':
        heading_row(tags.th(heading))
    for instance_name in sorted(instances):
        heading_row(tags.th(instance_name, class_="instance-name"))
    table(tags.thead(heading_row))
    tbody = tags.tbody()
    for name, component in sorted(components.items()):
        row = tags.tr(class_="component")
        revs_between_ids = {}
        extra_rows = []

        def td(*args, **kwargs):
            row(tags.td(*args, **kwargs))

        td(name)
        td(str(component.tip_revno), class_='version')
        unreleased_count = len(component.unreleased_revisions)
        if unreleased_count:
            id_ = get_id()
            td(tags.a(str(unreleased_count), href='#', class_='highlight'),
               class_='version clickable',
               id=id_)
            sub_name = 'revs between %s (r%s) and tip (r%s)' % (
                component.last_release, component.released_revno,
                component.tip_revno)
            extra_rows.append(
                tags.tr(tags.td(format_revlist(component.unreleased_revisions,
                                               name=sub_name),
                                colspan=str(4 + len(instances))),
                        class_='hidden',
                        id="show-" + id_))
        elif not component.last_release:
            td(u'\N{EM DASH}', class_='version')
        else:
            td(str(unreleased_count), class_='version')
        if component.last_release:
            td(component.last_release, class_='version')
        else:
            td(u'???', class_='version')
        for instance_name, instance in sorted(instances.items()):
            ver, location = instance.get(name, (None, None))
            if ver is None:
                td(u'\N{EM DASH}', class_='version')
            elif ver == component.last_release:
                td(ver, class_='version')
            elif ver in component.release2revno:
                revno_low = component.release2revno[ver]
                sub_name = 'revs between %s (r%s) and %s (r%s)' % (
                    ver, revno_low, component.last_release,
                    component.released_revno)
                revlist = []
                for rev, revno in component.mainline_revs:
                    if revno_low < revno < component.released_revno:
                        revlist.append((rev, revno))
                if revlist:
                    id_ = get_id()
                    revs_between_ids[revno_low] = id_
                    extra_rows.append(
                        tags.tr(tags.td(format_revlist(revlist, name=sub_name),
                                        colspan=str(4 + len(instances))),
                                class_='hidden branch-diff',
                                id="show-" + id_))
                    td(tags.a(ver, href='#', class_='highlight'),
                       class_='version clickable',
                       id=id_)
                else:
                    td(tags.span(ver, class_='highlight'), class_='version')
            elif location:
                try:
                    branch = bzrlib.branch.Branch.open(location)
                except bzrlib.errors.NoSuchBranch:
                    td(tags.span(ver, class_='highlight'), class_='version')
                else:
                    branch.lock_read()
                    try:
                        # This utterly half-assed version of bzr missing
                        # doesn't take merges into account!
                        revno, revid = branch.last_revision_info()
                        ver = ver.split('dev')[0] + 'dev' + str(revno)
                        mainline_revids = dict(
                            (rev.revision_id, revno)
                            for rev, revno in component.mainline_revs)
                        in_branch_revs = []
                        while revid not in mainline_revids:
                            rev = branch.repository.get_revision(revid)
                            if rev.message != 'post release bump':
                                in_branch_revs.append((rev, revno))
                            revno -= 1
                            if not rev.parent_ids:
                                break
                            revid = rev.parent_ids[0]
                        tables = []
                        if in_branch_revs:
                            tables.append(
                                format_revlist(
                                    in_branch_revs,
                                    'in branch (with nick %s) but not tip' %
                                    branch.nick))
                        in_trunk_revs = []
                        lca_revno = revno
                        for rev, revno in component.mainline_revs:
                            if revno > lca_revno:
                                in_trunk_revs.append((rev, revno))
                        if in_trunk_revs:
                            tables.append(
                                format_revlist(in_trunk_revs,
                                               'in tip but not branch'))
                        if tables:
                            id_ = get_id()
                            td(tags.a(ver, href='#', class_='highlight'),
                               class_='version clickable',
                               id=id_)
                            extra_rows.append(
                                tags.tr(tags.td(tables,
                                                colspan=str(4 +
                                                            len(instances))),
                                        class_='hidden branch-diff',
                                        id="show-" + id_))
                        else:
                            if branch.last_revision() == component.tip_revno:
                                td(ver, class_='highlight version')
                            else:
                                td(ver, class_='version')
                    finally:
                        branch.unlock()
            else:
                td(tags.span(ver, class_='highlight'), class_='version')
        tbody(row, *extra_rows)
    table(tbody)
    html = tags.html(
        tags.head(
            tags.title("Deployment report"),
            tags.script(
                src=
                'https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js',
                type='text/javascript'),
            tags.script(
                src=
                'https://ajax.googleapis.com/ajax/libs/jqueryui/1.8.18/jquery-ui.min.js',
                type='text/javascript'),
            tags.script(CDATA(js), type='text/javascript'),
            tags.style(CDATA(css), type="text/css"),
        ),
        tags.body(
            tags.h1("Deployment report"),
            table,
        ),
    )
    html(xmlns="http://www.w3.org/1999/xhtml")
    return DOCTYPE + flatten(html)