def convert(self, converter): size = self["href"].convert(converter).contentlength( root=converter.root) if size is not None: return xsc.Text(size) else: return xsc.Text("?")
def test_with_addattr(): with xsc.build(): with html.ul() as e: with xsc.addattr("id"): +xsc.Text("gurk") assert e == html.ul(id="gurk") with xsc.build(): with html.ul() as e: with xsc.addattr(html.ul.Attrs.id): +xsc.Text("gurk") assert e == html.ul(id="gurk")
def convert(self, converter): with xsc.build(): with xsc.Frag() as e: if self[term] or self[classifier]: with doc.dt(): +xsc.Frag(self[term]) if self[classifier]: +xsc.Text(" (") +xsc.Frag(self[classifier]).withsep(", ") +xsc.Text(")") +xsc.Frag(self[definition]) return e.convert(converter)
def test_with(): with xsc.build(): with html.ul() as e: +html.li(1) +html.li(2) assert e == html.ul(html.li(1), html.li(2)) with xsc.build(): with html.p() as e: +html.span(1) with html.b(): +html.span(2) +html.span(3) assert e == html.p(html.span(1), html.b(html.span(2)), html.span(3)) with xsc.build(): with html.p() as e: +xsc.Text(1) assert e == html.p(1) with xsc.build(): with html.p() as e: +xml.Attrs(lang="de") assert e == html.p(xml.Attrs(lang="de")) assert e.bytes() == b'<p xml:lang="de"></p>' with xsc.build(): with xsc.Frag() as e: +xsc.Text(1) assert e == xsc.Frag(1) # Test add() with xsc.build(): with html.p() as e: xsc.add(1) assert e == html.p(1) with xsc.build(): with html.p() as e: xsc.add(class_="foo") assert e == html.p(class_="foo") with xsc.build(): with html.p() as e: xsc.add({"class": "foo"}) assert e == html.p(class_="foo") with xsc.build(): with html.p() as e: xsc.add(xml.Attrs(lang="en")) assert e == html.p(xml.Attrs(lang="en"))
def test_text(): with xsc.build(): with xsc.Frag() as e: +detox.def_("gurk()") +xsc.Text("foo") +detox.end("def") assert makeoutput(e, "gurk") == "foo"
def test_publishescaped(): s = """\x04<&'"\xff>""" node = xsc.Text(s) assert node.bytes(encoding="ascii") == b"""<&'"ÿ>""" node = html.span(class_=s) assert node.bytes( encoding="ascii", xhtml=2) == b"""<span class="<&'"ÿ>"/>"""
def test_scopecheck(): with xsc.build(): with xsc.Frag() as e: +detox.def_("gurk()") +xsc.Text("hurz") +detox.end() assert makeoutput(e, "gurk") == "hurz" with xsc.build(): with xsc.Frag() as e: +detox.def_("gurk()") +xsc.Text("hurz") +detox.end("for") with pytest.raises(SyntaxError): makeoutput(e, "gurk")
def test_getitem(): for cls in (xsc.Frag, html.div): e = cls(list(range(6))) # int assert e[2] == xsc.Text(2) assert e[-1] == xsc.Text(5) # slice assert e[:] == cls(list(range(6))) assert e[:2] == cls(0, 1) assert e[-2:] == cls(4, 5) assert e[::2] == cls(0, 2, 4) assert e[1::2] == cls(1, 3, 5) assert e[::-1] == cls(list(range(5, -1, -1))) # selector e = cls((html.dt(i), html.dd(2 * i)) for i in range(3)) assert xsc.Frag(e[html.dt]) == xsc.Frag(html.dt(0), html.dt(1), html.dt(2)) assert xsc.Frag(e[html.dt[1]]) == xsc.Frag(html.dt(1)) assert e[e[0]][0] is e[ 0] # selector for a single node (returns an iterator nevertheless) def isgt1(p): return int(str(p[-1])) > 1 assert xsc.Frag(e[html.dt & isgt1]) == xsc.Frag(html.dt(2)) assert xsc.Frag(e[e / html.dt]) == xsc.Frag(html.dt(0), html.dt(1), html.dt(2)) assert xsc.Frag(e[e.__class__ / html.dt]) == xsc.Frag( html.dt(0), html.dt(1), html.dt(2)) for attr in ("class_", xml.Attrs.lang): e = cls("foo", html.div("bar", {attr: "gurk"}), "baz") i = e[xsc.Text] assert str(next(i)) == "foo" assert str(next(i)) == "baz" with pytest.raises(StopIteration): next(i) # list for attr in ("class", xml.Attrs.lang): node = cls(html.div("foo", html.div("bar", {attr: "gurk"}), "baz")) assert node[[]] is node assert str(node[[0, 1]]) == "bar" assert str(node[[0, 1, attr]]) == "gurk"
def convert(self, converter): format = str(self["format"].convert(converter)) if "utc" in self.attrs: f = datetime.datetime.utcnow else: f = datetime.datetime.now return xsc.Text(f().strftime(format))
def convert(self, converter): if "len" in self.attrs: chars = int(self["len"].convert(converter)) count = (chars + len(self.text) - 1) // len(self.text) text = count * self.text text = text[:chars] else: text = self.text.strip() return xsc.Text(text)
def text(self, data): node = xsc.Text(data) if self.loc: node.startloc = xsc.Location(self._url, *self._position) node.parsed(self, "text") if self._inattr: self._stack[-1].append(node) elif not self._indoctype: return ("textnode", node)
def toxist(node): if isinstance(node, nodes.Text): return xsc.Text(str(node.astext())) else: e = elements[node.__class__.__name__](toxist(child) for child in node.children) e.startloc = xsc.Location(node.source, node.line) for (attrkey, attrvalue) in node.attlist(): if attrkey in e.Attrs: if isinstance(attrvalue, list): attrvalue = " ".join(attrvalue) e.attrs[attrkey] = attrvalue return e
def translate(txt, context): """ Someday soon, this function will return a translation for unicode_string suitable for context. - If txt is a unicode string it will translate it and return a xsc.Text instance to be used with xist - If a xist DOM tree is supplied, it will recursively traverse it and translate B{all} CharachterData instance's content that are not marked with a __translated__ Flag. """ if type(txt) == UnicodeType: # insert actual translation here!! ret = xsc.Text(txt) ret.__translated__ = True return ret elif type(txt) == StringType: return translate(unicode(txt), context) elif isinstance(txt, xsc.Text): if getattr(txt, "__translated__", False): return txt else: return translate(txt.content, context) elif isinstance(txt, xsc.Frag): for index, a in enumerate(txt): txt[index] = translate(txt[index], context) elif isinstance(txt, xsc.Element): txt.content = translate(txt.content, context) else: tpl = ( repr(type(txt)), repr(txt), ) raise TypeError("translate can only operate on unicode strings, "+ \ "xsc.Element, or xsc.Frag, not %s %s" % tpl)
def test_texteq(): assert xsc.Text() == xsc.Text() assert xsc.Text(1) == xsc.Text(1) assert xsc.Text("1") == xsc.Text(1) assert xsc.Text("1") == xsc.Text(1) assert xsc.Text("") != xsc.Text(1)
def convert(self, node): if isinstance(node, nodes.document): return xsc.Frag(self.convert(child) for child in node.children) elif isinstance(node, nodes.Text): return xsc.Text(node.astext()) elif isinstance(node, nodes.problematic): # We don't do anything about this return xsc.Frag(self.convert(child) for child in node.children) elif isinstance(node, nodes.section): return self.doc.section( self.convert(child) for child in node.children) elif isinstance(node, nodes.title): return self.doc.h(self.convert(child) for child in node.children) elif isinstance(node, nodes.paragraph): return self.doc.p(self.convert(child) for child in node.children) elif isinstance(node, nodes.bullet_list): return self.doc.ul(self.convert(child) for child in node.children) elif isinstance(node, nodes.list_item): return self.doc.li(self.convert(child) for child in node.children) elif isinstance(node, nodes.definition_list): return self.doc.dl(self.convert(child) for child in node.children) elif isinstance(node, nodes.definition_list_item): return xsc.Frag(self.convert(child) for child in node.children) elif isinstance(node, nodes.term): return self.doc.dt(self.convert(child) for child in node.children) elif isinstance(node, nodes.definition): return self.doc.dd(self.convert(child) for child in node.children) elif isinstance(node, nodes.literal_block): return self.doc.prog( self.convert(child) for child in node.children) elif isinstance(node, nodes.literal): return self.doc.lit(self.convert(child) for child in node.children) elif isinstance(node, nodes.emphasis): return self.doc.em(self.convert(child) for child in node.children) elif isinstance(node, nodes.substitution_reference): try: return getattr(self.abbr, node.attributes["refname"].lower())() except AttributeError: return xsc.Frag(self.convert(child) for child in node.children) elif isinstance(node, nodes.reference): e = self.doc.a(self.convert(child) for child in node.children) if "anonymous" in node.attributes: self.unnamedrefs.append(e) else: self.namedrefs[node.attributes["refname"]].append(e) return e elif isinstance(node, nodes.target): uri = node.attributes["refuri"] if "anonymous" in node.attributes: # Set the link on the first unnamed reference self.unnamedrefs[0].attrs.href = uri del self.unnamedrefs[0] # done => remove it else: for name in node.attributes["names"]: try: es = self.namedrefs[name] except KeyError: pass else: for e in es: e.attrs.href = uri del self.namedrefs[name] return xsc.Null elif isinstance(node, nodes.system_message): warnings.warn(ReSTConversionWarning(str(node))) return xsc.Null # ignore system messages else: raise TypeError("can't handle {!r}".format(node.__class__))
def convert(self, converter): format = str(self["format"].convert(converter)) return xsc.Text(self["href"].convert(converter).lastmodified( root=converter.root).strftime(format))
def test_mixeq(): assert xsc.Comment(1) != xsc.Text(1) assert xsc.DocType(1) != xsc.Text(1)
def getdoc(thing, format): if thing.__doc__ is None: return xsc.Null # Remove indentation lines = textwrap.dedent(thing.__doc__).split("\n") # remove empty lines while lines and not lines[0]: del lines[0] while lines and not lines[-1]: del lines[-1] text = "\n".join(lines) modulename = _getmodulename(thing) if inspect.ismethod(thing): base = f"METHOD-DOCSTRING({modulename}.{thing.__class__.__name__}.{thing.__qualname__})" elif isinstance(thing, property): base = f"PROPERTY-DOCSTRING({modulename}.{thing})" elif inspect.isfunction(thing): base = f"FUNCTION-DOCSTRING({modulename}.{thing.__qualname__})" elif inspect.isclass(thing): base = f"CLASS-DOCSTRING({modulename}.{thing.__qualname__})" elif inspect.ismodule(thing): base = f"MODULE-DOCSTRING({modulename})" else: base = "DOCSTRING" lformat = format.lower() if lformat == "plaintext": return xsc.Text(text) elif lformat == "restructuredtext": from ll.xist.ns import rest, doc return rest.fromstring(text, base=base).conv(target=doc) elif lformat == "xist": from ll.xist.ns import doc node = parse.tree(parse.String(text), parse.SGMLOP(), parse.NS(doc), parse.Node(pool=xsc.docpool(), base=base)) if not node[ p]: # optimization: one paragraph docstrings don't need a <p> element. node = p(node) if inspect.ismethod(thing): # Use the original method instead of the decorator realthing = thing while hasattr(realthing, "__wrapped__"): realthing = realthing.__wrapped__ for ref in node.walknodes(pyref): if "module" not in ref.attrs: ref["module"] = _getmodulename(realthing) if "class_" not in ref.attrs: ref["class_"] = thing.__self__.__class__.__name__ if "method" not in ref.attrs: ref["method"] = thing.__name__ elif inspect.isfunction(thing): # Use the original method instead of the decorator while hasattr(thing, "__wrapped__"): thing = thing.__wrapped__ for ref in node.walknodes(pyref): if "module" not in ref.attrs: ref["module"] = _getmodulename(thing) elif inspect.isclass(thing): for ref in node.walknodes(pyref): if "module" not in ref.attrs: ref["module"] = _getmodulename(thing) if "class_" not in ref.attrs: ref["class_"] = thing.__name__ elif inspect.ismodule(thing): for ref in node.walknodes(pyref): if "module" not in ref.attrs: ref["module"] = thing.__name__ return node else: raise ValueError(f"unsupported __docformat__ {format!r}")
def test_charref(): node = chars.ouml() hash(node) assert len(node) == 1 assert node[0] == xsc.Text("ö") assert 3 * node == xsc.Text("ööö") assert node * 3 == xsc.Text("ööö") assert node[1:-2] == xsc.Text() assert node.capitalize() == xsc.Text("Ö") assert node.center(5) == xsc.Text(" ö ") assert node.count("t") == 0 assert node.endswith("ö") is True assert node.index("ö") == 0 assert node.isalpha() is True assert node.isalnum() is True assert node.isdecimal() is False assert node.isdigit() is False assert node.islower() is True assert node.isnumeric() is False assert node.isspace() is False assert node.istitle() is False assert node.isupper() is False assert node.ljust(3) == xsc.Text("ö ") assert node.ljust(3, ".") == xsc.Text("ö..") assert node.lower() == xsc.Text("ö") assert node.replace("ö", "x") == xsc.Text("x") assert node.rjust(3) == xsc.Text(" ö") assert node.rjust(3, ".") == xsc.Text("..ö") assert node.rfind("ö") == 0 assert node.rindex("ö") == 0 assert node.startswith("ö") is True assert node.swapcase() == xsc.Text("Ö") assert node.title() == xsc.Text("Ö") assert node.upper() == xsc.Text("Ö")
def test_textcomment(): pool = xsc.Pool() assert pool.text("foo") == xsc.Text("foo") assert pool.comment("foo") == xsc.Comment("foo")
def test_text(): s = "test" node = xsc.Text(s) hash(node) assert len(node), 4 assert node[1] == xsc.Text("e") assert 3 * node == xsc.Text(3 * s) assert node * 3 == xsc.Text(s * 3) assert node[1:3] == xsc.Text("es") assert node.capitalize() == xsc.Text("Test") assert node.center(8) == xsc.Text(" test ") assert node.count("t") == 2 assert node.endswith("st") is True assert node.index("s") == 2 assert node.isalpha() is True assert node.isalnum() is True assert node.isdecimal() is False assert node.isdigit() is False assert node.islower() is True assert node.isnumeric() is False assert node.isspace() is False assert node.istitle() is False assert node.isupper() is False assert node.join(xsc.Frag(list("abc"))) == xsc.Frag( "a", "test", "b", "test", "c") assert node.ljust(6) == xsc.Text("test ") assert node.ljust(6, ".") == xsc.Text("test..") assert node.lower() == xsc.Text("test") assert xsc.Text(" test").lstrip() == xsc.Text("test") assert node.replace("s", "x") == xsc.Text("text") assert node.rjust(6) == xsc.Text(" test") assert node.rjust(6, ".") == xsc.Text("..test") assert xsc.Text("test ").rstrip() == xsc.Text("test") assert node.rfind("s") == 2 assert node.rindex("s") == 2 assert node.split("e") == xsc.Frag("t", "st") assert xsc.Text("a\nb\n").splitlines() == xsc.Frag("a", "b") assert node.startswith("te") is True assert xsc.Text(" test ").strip() == xsc.Text("test") assert node.swapcase() == xsc.Text("TEST") assert node.title() == xsc.Text("Test") assert node.upper() == xsc.Text("TEST")
def convert_fo(self, converter): return xsc.Text(str(self.content))
def test_css(): with xsc.build(): with html.div(id=1) as e: with html.ul(id=2): +html.li("foo") +html.li() assert list(e.walknodes(css.selector("div"))) == [e] assert list(e.walknodes(css.selector("li"))) == [e[0][0], e[0][1]] assert list(e.walknodes(css.selector("div#1"))) == [e] assert list(e.walknodes(css.selector("#2"))) == [e[0]] assert list(e.walknodes(css.selector(":empty"))) == [e[0][1]] assert list(e.walknodes(css.selector("li:empty"))) == [e[0][1]] assert list(e.walknodes(css.selector("div :empty"))) == [e[0][1]] assert list(e.walknodes(css.selector("div>*:empty"))) == [] assert list(e.walknodes(css.selector("div>:empty"))) == [] assert list(e.walknodes(css.selector("*|li"))) == [e[0][0], e[0][1]] assert list(e.walknodes(css.selector("h|li", prefixes={"h": html }))) == [e[0][0], e[0][1]] assert list(e.walknodes(css.selector("h|li", prefixes={"h": specials}))) == [] with xsc.build(): with xsc.Frag() as e: +html.div("foo") +xsc.Text("filler") +html.p("foo") +xsc.Text("filler") +html.ul(html.li("foo")) assert list(e.walknodes(css.selector("div + p"))) == [e[2]] assert list(e.walknodes(css.selector("div + ul"))) == [] assert list(e.walknodes(css.selector("ul + p"))) == [] assert list(e.walknodes(css.selector("div ~ p"))) == [e[2]] assert list(e.walknodes(css.selector("div ~ ul"))) == [e[4]] assert list(e.walknodes(css.selector("p ~ div"))) == [] assert list(e.walknodes(css.selector("div:first-child + p"))) == [e[2]] assert list(e.walknodes(css.selector("*:first-child + p"))) == [e[2]] with xsc.build(): with xsc.Frag() as e: +html.span(html.b("hurz"), "gurk", html.em("hinz"), html.em("kunz")) +html.em("hurz") +html.em("hinz") +xsc.Text("nix") +html.i("kunz") assert list(e.walknodes( css.selector("*:only-of-type"))) == [e[0], e[0][0], e[4]] assert list(e.walknodes(css.selector("*:nth-child(1)"))) == [e[0], e[0][0]] assert list(e.walknodes(css.selector("*:nth-child(2)"))) == [e[0][2], e[1]] assert list(e.walknodes( css.selector("*:nth-last-child(1)"))) == [e[0][3], e[4]] assert list(e.walknodes( css.selector("*:nth-last-child(2)"))) == [e[0][2], e[2]] assert list(e.walknodes(css.selector("*:nth-of-type(1)"))) == [ e[0], e[0][0], e[0][2], e[1], e[4] ] assert list(e.walknodes( css.selector("*:nth-of-type(2)"))) == [e[0][3], e[2]] assert list(e.walknodes(css.selector("*:nth-last-of-type(1)"))) == [ e[0], e[0][0], e[0][3], e[2], e[4] ] assert list(e.walknodes( css.selector("*:nth-last-of-type(2)"))) == [e[0][2], e[1]] e = xsc.Frag(html.span(html.b("hurz"), "gurk")) assert list(e.walknodes(css.selector("*:only-child"))) == [e[0], e[0][0]] with xsc.build(): with xsc.Frag() as e: +html.em(class_="gurk", lang="en") +html.em(class_="gurk hurz", lang="en-us") +html.em(class_="hurz", lang="de") assert list(e.walknodes(css.selector("em[class='gurk']"))) == [e[0]] assert list(e.walknodes(css.selector("em[class~='gurk']"))) == [e[0], e[1]] assert list(e.walknodes(css.selector("em[lang|='en']"))) == [e[0], e[1]]