meld3-1.0.2/0000755000076500000240000000000012506600672013450 5ustar mnaberezstaff00000000000000meld3-1.0.2/CHANGES.txt0000644000076500000240000004003712506600560015261 0ustar mnaberezstaff000000000000001.0.2 (2015-03-31) ------------------ - Released to fix an issue where the universal wheel was tagged on PyPI as Py Version "2.7" instead of "py2.py3". 1.0.1 (2015-03-31) ------------------ - Fixed a bug introduced in 1.0.0 where unicode strings could not be used as attribute values. Thanks to Terrence Brannon for reporting the issue and supplying the initial patch. - A ``setup.cfg`` file has been added with a ``[bdist_wheel]`` section to mark this package as a universal wheel. 1.0.0 (2014-04-10) ------------------ - Dropped support for Python 2.3 / 2.4. Users of those Python versions should pin to earlier releases, (e.g., "meld3<1.0.0dev"). - Added compatibility with Python 3.2, 3.3, and 3.4. Thanks to Scott Maxwell and Tres Seaver for contributing the patches. - Installation now requires setuptools. - The optional C extension has been removed. It was only used internally by meld3, was not enabled by default, and did not support all meld3 features. The pure Python version has very acceptable performance. - The license has been changed from ZPL 2.1 to the BSD-derived Repoze license, which is the same license used by Supervisor. - Profiling scripts that had been used early in meld3 development have been removed. - The example scripts example.py and melddiff.py have been removed. See README.rst for the same example that was in example.py and the unit tests for examples of the ``diffmeld`` function. - Support for using meld3 directly from the command line with ``python meld3.py `` has been removed. 0.6.10 (2012-11-27) ------------------- - Fixed a bug where an exception could be raised when escaping certain attribute or cdata values. This was caused by meld3 trying to use _encode_entity from xml.etree without importing it first. Thanks to Jorge Puente Sarrin for contributing the patch. 0.6.9 (2012-09-12) ------------------ - Fixed a test failure that only occurred on some builds of Python 2.7 where parsing an unknown entity could raise an expat.error instead of SyntaxError. 0.6.8 (2012-01-12) ------------------ - Added the C extension source (cmeld3.c) to the release package by including it in MANIFEST.in. Thanks to Soren Hansen for noticing it was missing from prior releases. - Running setup.py will now halt on error if a compatible version of Python is not detected. 0.6.7 (2010-08-04) ------------------ - Make compatible with Python 2.7 (patch kindly contributed by Jonathan Riboux). 0.6.6 (2009-09-30) ------------------ - Change download location. This really should be a setuptools package so we can upload it to PyPI. No functionality changes. 0.6.5 (2008-07-21) ------------------ - Apply patch for Python 2.5 compatibility from both Toshio and Anders. - Create distro tarball via: rm MANIFEST USE_MELD3_EXTENSION_MODULES=1 python setup.py sdist .. in order to get the cmeld3.c file in the distribution. 0.6.4 (2008-01-17) ------------------ - Make the default build use the Python-based meld "helper" instead of the C-based one. Since the primary consumer of meld3 (as far as I know) is "supervisor", and since the typical supervisor consumer is likely not to have a C compiler and Python development libraries on his system, it makes more sense for the default build not to compile the C extensions. However, if the environment variable "USE_MELD3_EXTENSION_MODULES" is set when "setup.py install" is invoked, the C extensions will be built. meld3 is much slower without the C extensions, so using "USE_MELD3_EXTENSION_MODULES" is usually a good idea for performance-sensitive systems. As a result of this change, the "NO_MELD3_EXTENSION_MODULES" environment variable introduced in 0.6.1 now has no effect. 0.6.3 (2007-08-25) ------------------ - Fixed two more memory leaks (one in bfclonehandler, the other in findmeldhandler) in the c helper module. 0.6.2 (2007-08-23) ------------------ - Fixed a number of memory leaks in the C implementation of the helper module. Any use of "findmeld", "clone", "getiterator", or "content" previously leaked references. 0.6.1 (2007-08-21) ------------------ - Allow people to install meld3 without building extension modules. If the environment variable "NO_MELD3_EXTENSION_MODULES" is set, the meld3 setup.py file will not build any extension modules. meld3 will still work, only more slowly than if the extension modules existed. 0.6 (2006-09-18) ---------------- - Fixed crashbug when repeating trees with "structure" nodes in them. Symptom: bus error. Thanks to Terrence Brannon for the report. 0.5 (2006-02-19) ---------------- - Add 'fillmeldhtmlform' method to nodes. - Fix obscure parsing bug that arose when attempting to change the URI used as a "meld id" (do not lowercase). - Added three methods to element nodes: write_htmlstring write_xmlstring write_xhtmlstring These methods have the same respective argument lists as their "write_foo" cousins, except they don't accept a "file" argument. Instead of writing to a file, they return a string containing the renderering of the element. - You can now use the meld3.py module to interactively try out different renderings. To do this, invoke meld3.py with a filename and a dotted-python-path name to a mutator function that accepts a single argument (the root element), e.g.: python meld3.py sample.html meld3.sample_mutator The rendering will be sent to stdout - Remove unused parse method. - Add __setslice__, __delslice__, remove methods that correctly update parent pointers. - Don't call into superclass to do append, insert, __setitem__, etc. - Internal speedups: - Avoid function call overhead in various places by inlining code. - _write_html/_write_xml now accept a callable "write" argument instead of a file argument (avoid file.write call overhead). - HTML serializer only calls _escape_cdata/_escape_attrib if necessary instead of calling it without regard to its need. - Use string.encode(encoding) instead of calling an _encode function. - Perform special-case rendering for English-centric encodings during write_html. - Ignore things that might be "QNames" during rendering. - "getiterator", "content", "clone", and "findmeld" now implemented in a C module. Experimental. Disable via changing "import cmeld3 as helper" in meld3.py to something like "import wontbehere". - Fix text and attribute serialization to only quote ampersands that aren't already part of entities. - Do the minimal possible thing to escape text and attribute values during rendering. For text, this is escaping ampersands that aren't parts of entities and the less-than (<) character. For attribute values, this is amps and less-than as well as the quote (") character. This was done partly because I think the spec allows it but it's also what Kid does, shrug. - Change 'diffmeld()' to return a dictionary of dictionaries. The dictionary returned by diffmeld has the keys 'reduced' and 'unreduced'. the values of both 'reduced' and 'unreduced' is another dictionary. The leafmost dictionary has the keys 'added', 'removed', and 'moved. In the 'unreduced' dictionary, *all* meld tags that have been added, removed, or moved are present (this was the behavior of diffmeld previously). In the 'reduced' dictionary, the added, removed, and moved values are reduced to the smallest number of tags which share a common lineage. - Add a meldprofile.py script. 0.4 (2006-01-01) ---------------- - The clone() method of elements copied neither the text nor the tail of the element (this is what caused markup created by "repeats" to fall all on one line). - Add diffing capability to meld nodes. The file 'melddiff.py' shows an example of using the diff API. - Add a 'meldid()' method to elements. This returns None if the element has no meld id, otherwise it returns the id. - Add a 'fillmeld(**kw)' method to elements. This does the same thing as '__mod__' but returns meld ids (the keys of **kw) that cannot be found anywhere in the tree. - Make source distro into a distutils-installable package. 0.3 (2005-12-26) ---------------- - Fix broken example.py file. - Add ZPT-alike methods on elements: 'content', 'replace', and 'attributes'. 'content' replaces the node's content; 'replace' replaces the node itself with a text value, and 'attributes' sets the attributes of the node. Using the ElementTree API to do the same things usually causes the code to run faster, but these functions are more convenient and more easily grokked by ZPT people. - Override __delitem__ on meld elements in order to relieve deleted items of their parent pointers. - Strip all xhtml namespace identifiers out of XHTML output. Browsers just can't deal with this. - Undocumented element API method 'remove' renamed to 'deparent' (it was shadowing an ElementTree API method). - Documentation improvements and change examples to use ZPT-alike methods. - Add support for HTML input files. Input files don't need to be strictly well-formed XML anymore. - Remove the 'parse' top-level function in favor of explicit separate xml parsing and html parsing functions. - Add 'parse_xml' and 'parse_html' top-level parsing functions. - Add 'parse_xmlstring' and 'parse_htmlstring' module-scope functions which calls their respective 'parse_xxx' function with a StringIO containing the passed text. 0.2 (2005-12-24) ---------------- - Use a method on elements to do writing rather than requiring a user call a "write" function. The equivalent is now a method of the element named "write_xml". element.write_xml(file) performs a write of XML into the file. element.write_xml(...) includes an XML declaration in its serialization (but no doctype, at least by default). - Various non-XML serialization methods have been added. The default arguments of these serialization methods are what I'm guessing are the most common cases desired for various kinds of output:: element.write_html(...). This serializes the node and its children to HTML. This feature was inspired by and based on code Ian Bicking. By default, the serialization will include a 'loose' HTML DTD doctype (this can be overridden with the doctype= argument). "Empty" shortcut elements such as "
" will be converted to a balanced pair of tags e.g. "
". But some HTML tags (defined as per the HTML 4 spec as area, base, basefont, br, col, frame, hr, img, input, isindex, link, meta, param) will not be followed with a balanced ending tag; only the beginning tag will be output. Additionally, "boolean" tag attributes will not be followed with any value. The "boolean" tags are selected, checked, compact, declare, defer, disabled, ismap, multiple, nohref, noresize, noshade, and nowrap. So the XML input "" will be turned into "". Additionally, 'script' and 'style' tags will not have their contents escaped (e.g. so "&" will not be turned into & when it's iside the textual content of a script or style tag.) element.write_xhtml(...). This serializes the node and its children to XHTML. By default, the serialization will include a 'loose' XHTML doctype (this can be overridden with the doctype= argument). No XML declaration is included in the serialization by default. If you want to serialize an XML declaration, pass 'declaration=True'. - All serialization methods have a number of optional arguments:: fragment: If this is true, serialize an element as a "fragment". When an element is serialized as a fragment, it will not include either a declaration nor a doctype (the declaration= and doctype= arguments will be ignored). doctype: Output a custom doctype during the writing of XML and HTML (see write, write_xml, write_xhtml, and write_html). Use the constants in meld3.doctype (xhtml, xhtml_strict, html, and html_strict) to avoid passing a literal 3-tuple of (name, pubid, system) as the doctype parameter. If fragment=True is specified for serialization, this argument has no effect. encoding: Specify a character encoding to be used during writing (see write, write_xml write_html, and write_xhtml). The encoding must be a valid Python codec name (e.g. 'utf-8'). If this is provided for write_xml and write_xhtml, and the XML declaration is serialized, the declaration will include the encoding. If an encoding is passed to write_html, no explicit encoding is included in the declaration but the serialization will be done with utf-8. - XML serializations (write_xml and write_xhtml) have the aforementioned arguments but expose two additional optional arguments:: declaration: If this is true, an xml declaration header is output during the writing of XML (see write, write_xml, and write_xhtml). If the encoding is specified, and the serialization is meant to include an XML declaration (via declaration=), the declaration will include the encoding. If 'fragment=True' is specified for serialization, this argument has no effect. It doesn't matter if your input document had a declaration header; this option must be used to control declaration output. pipeline: If this is true, allow meld identifiers to be preserved during the writing of XML and XHTML (see write, write_xml and write_xhtml). meld identifiers cannot be preserved on HTML serializations because HTML doesn't understand namespaces. - HTML entities can now be parsed properly (magically) when a DOCTYPE is not supplied in the source of the XML passed to 'parse'. If your source document does not contain a DOCTYPE declaration, the DOCTYPE is set to 'loose' XHTML 'by magic'. If your source document does contain a DOCTYPE declaration, the existing DOCTYPE is used (and HTML entities thus may or may not work as a result, depending on the DOCTYPE). To prevent this behavior, pass a false value to the xhtml= parameter of the 'parse' function. This in no way effects output, which is independent of parsing. This does not imply that any *non*-HTML entity can be parsed in the input stream under any circumstance without having it defined it in your source document. - Comments are now preserved in output. They are also present in the ElementTree node tree (as Comment elements), so beware. Processing instructions (e.g. ) are completely thrown away at parse time and do not exist anywhere in the element tree. - Avoid use of deepcopy in the clone() method of elements (much speedier to explicitly recurse). - The "meld helper" namespace (e.g. element.meld) is no longer present or supported. Instead of using element.meld['foo'] to find an element with the meld:id "foo", use element.findmeld('foo'). This returns None if the node cannot be found. Instead of using element.meld.get('foo', 'somedefault'), use element.findmeld('foo', 'somedefault'). Instead of using element.meld.repeat(...), use element.repeat(...). - Elements now support a __mod__ which can accept a dictionarylike operand and which causes the text of elements with meld ids which match the keys in the dictionary to be set to the key's value in the dictionary. For example, if an element contains subelements with the meld ids "foo" and "bar", you can replace those nodes' text values with the following:: element % {'foo':'foo text', 'bar':'bar text'} - __mod__ will not accept a non-dictionary-like object (such as a list or tuple). __mod__ will never raise an error unless you pass it a non-dictionary-like object; if it can't find a node corresponding to a key in the dictionary, it moves on to the next key. Only the text values of the nodes which are found during this process are replaced. - Using duplicate meld identifiers on separate elements in the document now causes a ValueError to be raised at parse time. 0.1 (2005-12-18) ---------------- - Initial release. meld3-1.0.2/CONTRIBUTORS.txt0000644000076500000240000000017012321574700016141 0ustar mnaberezstaff00000000000000Contributors ------------ - Chris McDonough, 2005-12-18 - Tres Seaver, 2006-02-09 - Jorge Puente Sarrín, 2012-11-27 meld3-1.0.2/COPYRIGHT.txt0000644000076500000240000000102312233342165015552 0ustar mnaberezstaff00000000000000Meld3 is Copyright (c) 2005-2013 Agendaless Consulting and Contributors. (http://www.agendaless.com), All Rights Reserved This software is subject to the provisions of the license at http://www.repoze.org/LICENSE.txt . A copy of this license should accompany this distribution. THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. meld3-1.0.2/LICENSE.txt0000644000076500000240000000344512233342165015276 0ustar mnaberezstaff00000000000000Meld3 is licensed under the following license: A copyright notice accompanies this license document that identifies the copyright holders. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions in source code must retain the accompanying copyright notice, this list of conditions, and the following disclaimer. 2. Redistributions in binary form must reproduce the accompanying copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Names of the copyright holders must not be used to endorse or promote products derived from this software without prior written permission from the copyright holders. 4. If any files are modified, you must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. Disclaimer THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. meld3-1.0.2/MANIFEST.in0000644000076500000240000000001612233342165015200 0ustar mnaberezstaff00000000000000include *.txt meld3-1.0.2/meld3/0000755000076500000240000000000012506600672014454 5ustar mnaberezstaff00000000000000meld3-1.0.2/meld3/__init__.py0000644000076500000240000012633512502617545016602 0ustar mnaberezstaff00000000000000import email import re import sys from xml.etree.ElementTree import Comment from xml.etree.ElementTree import ElementPath from xml.etree.ElementTree import ProcessingInstruction from xml.etree.ElementTree import TreeBuilder from xml.etree.ElementTree import XMLParser from xml.etree.ElementTree import parse as et_parse from ._compat import PY3 from ._compat import htmlentitydefs from ._compat import HTMLParser from ._compat import StringIO from ._compat import StringTypes from ._compat import bytes from ._compat import unichr from ._compat import _u from ._compat import _b from ._compat import _raise_serialization_error from ._compat import _encode_entity from ._compat import fixtag AUTOCLOSE = "p", "li", "tr", "th", "td", "head", "body" IGNOREEND = "img", "hr", "meta", "link", "br" _BLANK = _b('') _SPACE = _b(' ') _EQUAL = _b('=') _QUOTE = _b('"') _OPEN_TAG_START = _b("<") _CLOSE_TAG_START = _b("") _SELF_CLOSE = _b(" />") _OMITTED_TEXT = _b(' [...]\n') _COMMENT_START = _b('') _PI_START = _b('') _AMPER_ESCAPED = _b('&') _LT = _b('<') _LT_ESCAPED = _b('<') _QUOTE_ESCAPED = _b(""") _XML_PROLOG_BEGIN = _b('\n') _DOCTYPE_BEGIN = _b('\n') if PY3: def encode(text, encoding): if not isinstance(text, bytes): text = text.encode(encoding) return text else: def encode(text, encoding): return text.encode(encoding) # replace element factory def Replace(text, structure=False): element = _MeldElementInterface(Replace, {}) element.text = text element.structure = structure return element class PyHelper: def findmeld(self, node, name, default=None): iterator = self.getiterator(node) for element in iterator: val = element.attrib.get(_MELD_ID) if val == name: return element return default def clone(self, node, parent=None): element = _MeldElementInterface(node.tag, node.attrib.copy()) element.text = node.text element.tail = node.tail element.structure = node.structure if parent is not None: # avoid calling self.append to reduce function call overhead parent._children.append(element) element.parent = parent for child in node._children: self.clone(child, element) return element def _bfclone(self, nodes, parent): L = [] for node in nodes: element = _MeldElementInterface(node.tag, node.attrib.copy()) element.parent = parent element.text = node.text element.tail = node.tail element.structure = node.structure if node._children: self._bfclone(node._children, element) L.append(element) parent._children = L def bfclone(self, node, parent=None): element = _MeldElementInterface(node.tag, node.attrib.copy()) element.text = node.text element.tail = node.tail element.structure = node.structure element.parent = parent if parent is not None: parent._children.append(element) if node._children: self._bfclone(node._children, element) return element def getiterator(self, node, tag=None): nodes = [] if tag == "*": tag = None if tag is None or node.tag == tag: nodes.append(node) for element in node._children: nodes.extend(self.getiterator(element, tag)) return nodes def content(self, node, text, structure=False): node.text = None replacenode = Replace(text, structure) replacenode.parent = node replacenode.text = text replacenode.structure = structure node._children = [replacenode] helper = PyHelper() _MELD_NS_URL = 'http://www.plope.com/software/meld3' _MELD_PREFIX = '{%s}' % _MELD_NS_URL _MELD_LOCAL = 'id' _MELD_ID = '%s%s' % (_MELD_PREFIX, _MELD_LOCAL) _MELD_SHORT_ID = 'meld:%s' % _MELD_LOCAL _XHTML_NS_URL = 'http://www.w3.org/1999/xhtml' _XHTML_PREFIX = '{%s}' % _XHTML_NS_URL _XHTML_PREFIX_LEN = len(_XHTML_PREFIX) _marker = [] class doctype: # lookup table for ease of use in external code html_strict = ('HTML', '-//W3C//DTD HTML 4.01//EN', 'http://www.w3.org/TR/html4/strict.dtd') html = ('HTML', '-//W3C//DTD HTML 4.01 Transitional//EN', 'http://www.w3.org/TR/html4/loose.dtd') xhtml_strict = ('html', '-//W3C//DTD XHTML 1.0 Strict//EN', 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd') xhtml = ('html', '-//W3C//DTD XHTML 1.0 Transitional//EN', 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd') class _MeldElementInterface: parent = None attrib = None text = None tail = None structure = None # overrides to reduce MRU lookups def __init__(self, tag, attrib): self.tag = tag self.attrib = attrib self._children = [] def __repr__(self): return "" % (self.tag, id(self)) def __len__(self): return len(self._children) def __getitem__(self, index): return self._children[index] def __getslice__(self, start, stop): return self._children[start:stop] def getchildren(self): return self._children def find(self, path): return ElementPath.find(self, path) def findtext(self, path, default=None): return ElementPath.findtext(self, path, default) def findall(self, path): return ElementPath.findall(self, path) def clear(self): self.attrib.clear() self._children = [] self.text = self.tail = None def get(self, key, default=None): return self.attrib.get(key, default) def set(self, key, value): self.attrib[key] = value def keys(self): return list(self.attrib.keys()) def items(self): return list(self.attrib.items()) def getiterator(self, *ignored_args, **ignored_kw): # we ignore any tag= passed in to us, originally because it was too # painfail to support in the old C extension, now for b/w compat return helper.getiterator(self) # overrides to support parent pointers and factories def __setitem__(self, index, element): if isinstance(index, slice): for e in element: e.parent = self else: element.parent = self self._children[index] = element # TODO: Can __setslice__ be removed now? def __setslice__(self, start, stop, elements): for element in elements: element.parent = self self._children[start:stop] = list(elements) def append(self, element): self._children.append(element) element.parent = self def insert(self, index, element): self._children.insert(index, element) element.parent = self def __delitem__(self, index): if isinstance(index, slice): for ob in self._children[index]: ob.parent = None else: self._children[index].parent = None ob = self._children[index] del self._children[index] # TODO: Can __delslice__ be removed now? def __delslice__(self, start, stop): obs = self._children[start:stop] for ob in obs: ob.parent = None del self._children[start:stop] def remove(self, element): self._children.remove(element) element.parent = None def makeelement(self, tag, attrib): return self.__class__(tag, attrib) # meld-specific def __mod__(self, other): """ Fill in the text values of meld nodes in tree; only support dictionarylike operand (sequence operand doesn't seem to make sense here)""" return self.fillmelds(**other) def fillmelds(self, **kw): """ Fill in the text values of meld nodes in tree using the keyword arguments passed in; use the keyword keys as meld ids and the keyword values as text that should fill in the node text on which that meld id is found. Return a list of keys from **kw that were not able to be found anywhere in the tree. Never raises an exception. """ unfilled = [] for k in kw: node = self.findmeld(k) if node is None: unfilled.append(k) else: node.text = kw[k] return unfilled def fillmeldhtmlform(self, **kw): """ Perform magic to 'fill in' HTML form element values from a dictionary. Unlike 'fillmelds', the type of element being 'filled' is taken into consideration. Perform a 'findmeld' on each key in the dictionary and use the value that corresponds to the key to perform mutation of the tree, changing data in what is presumed to be one or more HTML form elements according to the following rules:: If the found element is an 'input group' (its meld id ends with the string ':inputgroup'), set the 'checked' attribute on the appropriate subelement which has a 'value' attribute which matches the dictionary value. Also remove the 'checked' attribute from every other 'input' subelement of the input group. If no input subelement's value matches the dictionary value, this key is treated as 'unfilled'. If the found element is an 'input type=text', 'input type=hidden', 'input type=submit', 'input type=password', 'input type=reset' or 'input type=file' element, replace its 'value' attribute with the value. If the found element is an 'input type=checkbox' or 'input type='radio' element, set its 'checked' attribute to true if the dict value is true, or remove its 'checked' attribute if the dict value is false. If the found element is a 'select' element and the value exists in the 'value=' attribute of one of its 'option' subelements, change that option's 'selected' attribute to true and mark all other option elements as unselected. If the select element does not contain an option with a value that matches the dictionary value, do nothing and return this key as unfilled. If the found element is a 'textarea' or any other kind of element, replace its text with the value. If the element corresponding to the key is not found, do nothing and treat the key as 'unfilled'. Return a list of 'unfilled' keys, representing meld ids present in the dictionary but not present in the element tree or meld ids which could not be filled due to the lack of any matching subelements for 'select' nodes or 'inputgroup' nodes. """ unfilled = [] for k in kw: node = self.findmeld(k) if node is None: unfilled.append(k) continue val = kw[k] if k.endswith(':inputgroup'): # an input group is a list of input type="checkbox" or # input type="radio" elements that can be treated as a group # because they attempt to specify the same value found = [] unfound = [] for child in node.findall('input'): input_type = child.attrib.get('type', '').lower() if input_type not in ('checkbox', 'radio'): continue input_val = child.attrib.get('value', '') if val == input_val: found.append(child) else: unfound.append(child) if not found: unfilled.append(k) else: for option in found: option.attrib['checked'] = 'checked' for option in unfound: try: del option.attrib['checked'] except KeyError: pass else: tag = node.tag.lower() if tag == 'input': input_type = node.attrib.get('type', 'text').lower() # fill in value attrib for most input types if input_type in ('hidden', 'submit', 'text', 'password', 'reset', 'file'): node.attrib['value'] = val # unless it's a checkbox or radio attribute, then we # fill in its checked attribute elif input_type in ('checkbox', 'radio'): if val: node.attrib['checked'] = 'checked' else: try: del node.attrib['checked'] except KeyError: pass else: unfilled.append(k) elif tag == 'select': # if the node is a select node, we want to select # the value matching val, otherwise it's unfilled found = [] unfound = [] for option in node.findall('option'): if option.attrib.get('value', '') == val: found.append(option) else: unfound.append(option) if not found: unfilled.append(k) else: for option in found: option.attrib['selected'] = 'selected' for option in unfound: try: del option.attrib['selected'] except KeyError: pass else: node.text = kw[k] return unfilled def findmeld(self, name, default=None): """ Find a node in the tree that has a 'meld id' corresponding to 'name'. Iterate over all subnodes recursively looking for a node which matches. If we can't find the node, return None.""" # this could be faster if we indexed all the meld nodes in the # tree; we just walk the whole hierarchy now. result = helper.findmeld(self, name) if result is None: return default return result def findmelds(self): """ Find all nodes that have a meld id attribute and return the found nodes in a list""" return self.findwithattrib(_MELD_ID) def findwithattrib(self, attrib, value=None): """ Find all nodes that have an attribute named 'attrib'. If 'value' is not None, omit nodes on which the attribute value does not compare equally to 'value'. Return the found nodes in a list.""" iterator = helper.getiterator(self) elements = [] for element in iterator: attribval = element.attrib.get(attrib) if attribval is not None: if value is None: elements.append(element) else: if value == attribval: elements.append(element) return elements # ZPT-alike methods def repeat(self, iterable, childname=None): """repeats an element with values from an iterable. If 'childname' is not None, repeat the element on which the repeat is called, otherwise find the child element with a 'meld:id' matching 'childname' and repeat that. The element is repeated within its parent element (nodes that are created as a result of a repeat share the same parent). This method returns an iterable; the value of each iteration is a two-sequence in the form (newelement, data). 'newelement' is a clone of the template element (including clones of its children) which has already been seated in its parent element in the template. 'data' is a value from the passed in iterable. Changing 'newelement' (typically based on values from 'data') mutates the element 'in place'.""" if childname: element = self.findmeld(childname) else: element = self parent = element.parent # creating a list is faster than yielding a generator (py 2.4) L = [] first = True for thing in iterable: if first is True: clone = element else: clone = helper.bfclone(element, parent) L.append((clone, thing)) first = False return L def replace(self, text, structure=False): """ Replace this element with a Replace node in our parent with the text 'text' and return the index of our position in our parent. If we have no parent, do nothing, and return None. Pass the 'structure' flag to the replace node so it can do the right thing at render time. """ parent = self.parent i = self.deparent() if i is not None: # reduce function call overhead by not calliing self.insert node = Replace(text, structure) parent._children.insert(i, node) node.parent = parent return i def content(self, text, structure=False): """ Delete this node's children and append a Replace node that contains text. Always return None. Pass the 'structure' flag to the replace node so it can do the right thing at render time.""" helper.content(self, text, structure) def attributes(self, **kw): """ Set attributes on this node. """ for k, v in kw.items(): # prevent this from getting to the parser if possible if not isinstance(k, StringTypes): raise ValueError('do not set non-stringtype as key: %s' % k) if not isinstance(v, StringTypes): raise ValueError('do not set non-stringtype as val: %s' % v) self.attrib[k] = kw[k] # output methods def write_xmlstring(self, encoding=None, doctype=None, fragment=False, declaration=True, pipeline=False): data = [] write = data.append if not fragment: if declaration: _write_declaration(write, encoding) if doctype: _write_doctype(write, doctype) _write_xml(write, self, encoding, {}, pipeline) return _BLANK.join(data) def write_xml(self, file, encoding=None, doctype=None, fragment=False, declaration=True, pipeline=False): """ Write XML to 'file' (which can be a filename or filelike object) encoding - encoding string (if None, 'utf-8' encoding is assumed) Must be a recognizable Python encoding type. doctype - 3-tuple indicating name, pubid, system of doctype. The default is to prevent a doctype from being emitted. fragment - True if a 'fragment' should be emitted for this node (no declaration, no doctype). This causes both the 'declaration' and 'doctype' parameters to become ignored if provided. declaration - emit an xml declaration header (including an encoding if it's not None). The default is to emit the doctype. pipeline - preserve 'meld' namespace identifiers in output for use in pipelining """ if not hasattr(file, "write"): file = open(file, "wb") data = self.write_xmlstring(encoding, doctype, fragment, declaration, pipeline) file.write(data) def write_htmlstring(self, encoding=None, doctype=doctype.html, fragment=False): data = [] write = data.append if encoding is None: encoding = 'utf8' if not fragment: if doctype: _write_doctype(write, doctype) _write_html(write, self, encoding, {}) joined = _BLANK.join(data) return joined def write_html(self, file, encoding=None, doctype=doctype.html, fragment=False): """ Write HTML to 'file' (which can be a filename or filelike object) encoding - encoding string (if None, 'utf-8' encoding is assumed). Unlike XML output, this is not used in a declaration, but it is used to do actual character encoding during output. Must be a recognizable Python encoding type. doctype - 3-tuple indicating name, pubid, system of doctype. The default is the value of doctype.html (HTML 4.0 'loose') fragment - True if a "fragment" should be omitted (no doctype). This overrides any provided "doctype" parameter if provided. Namespace'd elements and attributes have their namespaces removed during output when writing HTML, so pipelining cannot be performed. HTML is not valid XML, so an XML declaration header is never emitted. """ if not hasattr(file, "write"): file = open(file, "wb") page = self.write_htmlstring(encoding, doctype, fragment) file.write(page) def write_xhtmlstring(self, encoding=None, doctype=doctype.xhtml, fragment=False, declaration=False, pipeline=False): data = [] write = data.append if not fragment: if declaration: _write_declaration(write, encoding) if doctype: _write_doctype(write, doctype) _write_xml(write, self, encoding, {}, pipeline, xhtml=True) return _BLANK.join(data) def write_xhtml(self, file, encoding=None, doctype=doctype.xhtml, fragment=False, declaration=False, pipeline=False): """ Write XHTML to 'file' (which can be a filename or filelike object) encoding - encoding string (if None, 'utf-8' encoding is assumed) Must be a recognizable Python encoding type. doctype - 3-tuple indicating name, pubid, system of doctype. The default is the value of doctype.xhtml (XHTML 'loose'). fragment - True if a 'fragment' should be emitted for this node (no declaration, no doctype). This causes both the 'declaration' and 'doctype' parameters to be ignored. declaration - emit an xml declaration header (including an encoding string if 'encoding' is not None) pipeline - preserve 'meld' namespace identifiers in output for use in pipelining """ if not hasattr(file, "write"): file = open(file, "wb") page = self.write_xhtmlstring(encoding, doctype, fragment, declaration, pipeline) file.write(page) def clone(self, parent=None): """ Create a clone of an element. If parent is not None, append the element to the parent. Recurse as necessary to create a deep clone of the element. """ return helper.bfclone(self, parent) def deparent(self): """ Remove ourselves from our parent node (de-parent) and return the index of the parent which was deleted. """ i = self.parentindex() if i is not None: del self.parent[i] return i def parentindex(self): """ Return the parent node index in which we live """ parent = self.parent if parent is not None: return parent._children.index(self) def shortrepr(self, encoding=None): data = [] _write_html(data.append, self, encoding, {}, maxdepth=2) return _BLANK.join(data) def diffmeld(self, other): """ Compute the meld element differences from this node (the source) to 'other' (the target). Return a dictionary of sequences in the form {'unreduced: {'added':[], 'removed':[], 'moved':[]}, 'reduced': {'added':[], 'removed':[], 'moved':[]},} """ srcelements = self.findmelds() tgtelements = other.findmelds() srcids = [ x.meldid() for x in srcelements ] tgtids = [ x.meldid() for x in tgtelements ] removed = [] for srcelement in srcelements: if srcelement.meldid() not in tgtids: removed.append(srcelement) added = [] for tgtelement in tgtelements: if tgtelement.meldid() not in srcids: added.append(tgtelement) moved = [] for srcelement in srcelements: srcid = srcelement.meldid() if srcid in tgtids: i = tgtids.index(srcid) tgtelement = tgtelements[i] if not sharedlineage(srcelement, tgtelement): moved.append(tgtelement) unreduced = {'added':added, 'removed':removed, 'moved':moved} moved_reduced = diffreduce(moved) added_reduced = diffreduce(added) removed_reduced = diffreduce(removed) reduced = {'moved':moved_reduced, 'added':added_reduced, 'removed':removed_reduced} return {'unreduced':unreduced, 'reduced':reduced} def meldid(self): return self.attrib.get(_MELD_ID) def lineage(self): L = [] parent = self while parent is not None: L.append(parent) parent = parent.parent return L class MeldTreeBuilder(TreeBuilder): def __init__(self): TreeBuilder.__init__(self, element_factory=_MeldElementInterface) self.meldids = {} def start(self, tag, attrs): elem = TreeBuilder.start(self, tag, attrs) for key, value in attrs.items(): if key == _MELD_ID: if value in self.meldids: raise ValueError('Repeated meld id "%s" in source' % value) self.meldids[value] = 1 break return elem def comment(self, data): self.start(Comment, {}) self.data(data) self.end(Comment) def doctype(self, name, pubid, system): pass if sys.version_info < (2, 7): class MeldParser(XMLParser): """ Based on Fredrik's PIParser[1] Blithely ignores the case of a comment existing outside the root element, and ignores processing instructions entirely. [1] http://effbot.org/zone/element-pi.htm. """ def __init__(self, html=0, target=None): XMLParser.__init__(self, html, target) self._parser.CommentHandler = self.handle_comment def handle_comment(self, data): self._target.start(Comment, {}) self._target.data(data) self._target.end(Comment) else: #just use the stock one MeldParser = XMLParser class HTMLMeldParser(HTMLParser): """ A mostly-cut-and-paste of ElementTree's HTMLTreeBuilder that does special meld3 things (like preserve comments and munge meld ids). Subclassing is not possible due to private attributes. :-(""" def __init__(self, builder=None, encoding=None): self.__stack = [] if builder is None: builder = MeldTreeBuilder() self.builder = builder self.encoding = encoding or "iso-8859-1" try: # ``convert_charrefs`` was added in Python 3.4. Set it to avoid # "DeprecationWarning: The value of convert_charrefs will become # True in 3.5. You are encouraged to set the value explicitly." HTMLParser.__init__(self, convert_charrefs=False) except TypeError: HTMLParser.__init__(self) self.meldids = {} def close(self): HTMLParser.close(self) self.meldids = {} return self.builder.close() def handle_starttag(self, tag, attrs): if tag == "meta": # look for encoding directives http_equiv = content = None for k, v in attrs: if k == "http-equiv": http_equiv = v.lower() elif k == "content": content = v if http_equiv == "content-type" and content: # use email to parse the http header msg = email.message_from_string( "%s: %s\n\n" % (http_equiv, content) ) encoding = msg.get_param("charset") if encoding: self.encoding = encoding if tag in AUTOCLOSE: if self.__stack and self.__stack[-1] == tag: self.handle_endtag(tag) self.__stack.append(tag) attrib = {} if attrs: for k, v in attrs: if k == _MELD_SHORT_ID: k = _MELD_ID if self.meldids.get(v): raise ValueError('Repeated meld id "%s" in source' % v) self.meldids[v] = 1 else: k = k.lower() attrib[k] = v self.builder.start(tag, attrib) if tag in IGNOREEND: self.__stack.pop() self.builder.end(tag) def handle_endtag(self, tag): if tag in IGNOREEND: return lasttag = self.__stack.pop() if tag != lasttag and lasttag in AUTOCLOSE: self.handle_endtag(lasttag) self.builder.end(tag) def handle_charref(self, char): if char[:1] == "x": char = int(char[1:], 16) else: char = int(char) self.builder.data(unichr(char)) def handle_entityref(self, name): entity = htmlentitydefs.entitydefs.get(name) if entity: if len(entity) == 1: entity = ord(entity) else: entity = int(entity[2:-1]) self.builder.data(unichr(entity)) else: self.unknown_entityref(name) def handle_data(self, data): if isinstance(data, bytes): data = _u(data, self.encoding) self.builder.data(data) def unknown_entityref(self, name): pass # ignore by default; override if necessary def handle_comment(self, data): self.builder.start(Comment, {}) self.builder.data(data) self.builder.end(Comment) def do_parse(source, parser): root = et_parse(source, parser=parser).getroot() iterator = root.getiterator() for p in iterator: for c in p: c.parent = p return root def parse_xml(source): """ Parse source (a filelike object) into an element tree. If html is true, use a parser that can resolve somewhat ambiguous HTML into XHTML. Otherwise use a 'normal' parser only.""" builder = MeldTreeBuilder() parser = MeldParser(target=builder) return do_parse(source, parser) def parse_html(source, encoding=None): builder = MeldTreeBuilder() parser = HTMLMeldParser(builder, encoding) return do_parse(source, parser) def parse_xmlstring(text): source = StringIO(text) return parse_xml(source) def parse_htmlstring(text, encoding=None): source = StringIO(text) return parse_html(source, encoding) attrib_needs_escaping = re.compile(r'[&"<]').search cdata_needs_escaping = re.compile(r'[&<]').search def _both_case(mapping): # Add equivalent upper-case keys to mapping. lc_keys = list(mapping.keys()) for k in lc_keys: mapping[k.upper()] = mapping[k] _HTMLTAGS_UNBALANCED = {'area':1, 'base':1, 'basefont':1, 'br':1, 'col':1, 'frame':1, 'hr':1, 'img':1, 'input':1, 'isindex':1, 'link':1, 'meta':1, 'param':1} _both_case(_HTMLTAGS_UNBALANCED) _HTMLTAGS_NOESCAPE = {'script':1, 'style':1} _both_case(_HTMLTAGS_NOESCAPE) _HTMLATTRS_BOOLEAN = {'selected':1, 'checked':1, 'compact':1, 'declare':1, 'defer':1, 'disabled':1, 'ismap':1, 'multiple':1, 'nohref':1, 'noresize':1, 'noshade':1, 'nowrap':1} _both_case(_HTMLATTRS_BOOLEAN) def _write_html(write, node, encoding, namespaces, depth=-1, maxdepth=None): """ Walk 'node', calling 'write' with bytes(?). """ if encoding is None: encoding = 'utf-8' tag = node.tag tail = node.tail text = node.text tail = node.tail to_write = _BLANK if tag is Replace: if not node.structure: if cdata_needs_escaping(text): text = _escape_cdata(text) write(encode(text, encoding)) elif tag is Comment: if cdata_needs_escaping(text): text = _escape_cdata(text) write(encode('', encoding)) elif tag is ProcessingInstruction: if cdata_needs_escaping(text): text = _escape_cdata(text) write(encode('', encoding)) else: xmlns_items = [] # new namespaces in this scope try: if tag[:1] == "{": if tag[:_XHTML_PREFIX_LEN] == _XHTML_PREFIX: tag = tag[_XHTML_PREFIX_LEN:] else: tag, xmlns = fixtag(tag, namespaces) if xmlns: xmlns_items.append(xmlns) except TypeError: _raise_serialization_error(tag) to_write += _OPEN_TAG_START + encode(tag, encoding) attrib = node.attrib if attrib is not None: if len(attrib) > 1: attrib_keys = list(attrib.keys()) attrib_keys.sort() else: attrib_keys = attrib for k in attrib_keys: try: if k[:1] == "{": continue except TypeError: _raise_serialization_error(k) if k in _HTMLATTRS_BOOLEAN: to_write += _SPACE + encode(k, encoding) else: v = attrib[k] to_write += _encode_attrib(k, v, encoding) for k, v in xmlns_items: to_write += _encode_attrib(k, v, encoding) to_write += _OPEN_TAG_END if text is not None and text: if tag in _HTMLTAGS_NOESCAPE: to_write += encode(text, encoding) elif cdata_needs_escaping(text): to_write += _escape_cdata(text) else: to_write += encode(text,encoding) write(to_write) for child in node._children: if maxdepth is not None: depth = depth + 1 if depth < maxdepth: _write_html(write, child, encoding, namespaces, depth, maxdepth) elif depth == maxdepth and text: write(_OMITTED_TEXT) else: _write_html(write, child, encoding, namespaces, depth, maxdepth) if text or node._children or tag not in _HTMLTAGS_UNBALANCED: write(_CLOSE_TAG_START + encode(tag, encoding) + _CLOSE_TAG_END) if tail: if cdata_needs_escaping(tail): write(_escape_cdata(tail)) else: write(encode(tail,encoding)) def _write_xml(write, node, encoding, namespaces, pipeline, xhtml=False): """ Write XML to a file """ if encoding is None: encoding = 'utf-8' tag = node.tag if tag is Comment: write(_COMMENT_START + _escape_cdata(node.text, encoding) + _COMMENT_END) elif tag is ProcessingInstruction: write(_PI_START + _escape_cdata(node.text, encoding) + _PI_END) elif tag is Replace: if node.structure: # this may produce invalid xml write(encode(node.text, encoding)) else: write(_escape_cdata(node.text, encoding)) else: if xhtml: if tag[:_XHTML_PREFIX_LEN] == _XHTML_PREFIX: tag = tag[_XHTML_PREFIX_LEN:] if node.attrib: items = list(node.attrib.items()) else: items = [] # must always be sortable. xmlns_items = [] # new namespaces in this scope try: if tag[:1] == "{": tag, xmlns = fixtag(tag, namespaces) if xmlns: xmlns_items.append(xmlns) except TypeError: _raise_serialization_error(tag) write(_OPEN_TAG_START + encode(tag, encoding)) if items or xmlns_items: items.sort() # lexical order for k, v in items: try: if k[:1] == "{": if not pipeline: if k == _MELD_ID: continue k, xmlns = fixtag(k, namespaces) if xmlns: xmlns_items.append(xmlns) if not pipeline: # special-case for HTML input if k == 'xmlns:meld': continue except TypeError: _raise_serialization_error(k) write(_encode_attrib(k, v, encoding)) for k, v in xmlns_items: write(_encode_attrib(k, v, encoding)) if node.text or node._children: write(_OPEN_TAG_END) if node.text: write(_escape_cdata(node.text, encoding)) for n in node._children: _write_xml(write, n, encoding, namespaces, pipeline, xhtml) write(_CLOSE_TAG_START + encode(tag, encoding) + _CLOSE_TAG_END) else: write(_SELF_CLOSE) for k, v in xmlns_items: del namespaces[v] if node.tail: write(_escape_cdata(node.tail, encoding)) def _encode_attrib(k, v, encoding): return _BLANK.join((_SPACE, encode(k, encoding), _EQUAL, _QUOTE, _escape_attrib(v, encoding), _QUOTE, )) # overrides to elementtree to increase speed and get entity quoting correct. _NONENTITY_RE = re.compile(_b('&(?!([#\w]*;))')) # negative lookahead assertion def _escape_cdata(text, encoding=None): # Return escaped character data as bytes. try: if encoding: try: encoded = encode(text, encoding) except UnicodeError: return _encode_entity(text) else: encoded = _b(text) encoded = _NONENTITY_RE.sub(_AMPER_ESCAPED, encoded) encoded = encoded.replace(_LT, _LT_ESCAPED) return encoded except (TypeError, AttributeError): _raise_serialization_error(text) def _escape_attrib(text, encoding): # Return escaped attribute value as bytes. try: if encoding: try: encoded = encode(text, encoding) except UnicodeError: return _encode_entity(text) else: encoded = _b(text) # don't requote properly-quoted entities encoded = _NONENTITY_RE.sub(_AMPER_ESCAPED, encoded) encoded = encoded.replace(_LT, _LT_ESCAPED) encoded = encoded.replace(_QUOTE, _QUOTE_ESCAPED) return encoded except (TypeError, AttributeError): _raise_serialization_error(text) # utility functions def _write_declaration(write, encoding): # Write as bytes. if not encoding: write(_XML_PROLOG_BEGIN + _XML_PROLOG_END) else: write(_XML_PROLOG_BEGIN + _SPACE + _ENCODING + _EQUAL + _QUOTE + _b(encoding) + _QUOTE + _XML_PROLOG_END) def _write_doctype(write, doctype): # Write as bytes. try: name, pubid, system = doctype except (ValueError, TypeError): raise ValueError("doctype must be supplied as a 3-tuple in the form " "(name, pubid, system) e.g. '%s'" % doctype.xhtml) write(_DOCTYPE_BEGIN + _SPACE + _b(name) + _SPACE + _PUBLIC + _SPACE + _QUOTE + _b(pubid) + _QUOTE + _SPACE + _QUOTE + _b(system) + _QUOTE + _DOCTYPE_END) _XML_DECL_RE = re.compile(r'<\?xml .*?\?>') _BEGIN_TAG_RE = re.compile(r'<[^/?!]?\w+') def insert_doctype(data, doctype=doctype.xhtml): # jam an html doctype declaration into 'data' if it # doesn't already contain a doctype declaration match = _XML_DECL_RE.search(data) dt_string = '' % doctype if match is not None: start, end = match.span(0) before = data[:start] tag = data[start:end] after = data[end:] return before + tag + dt_string + after else: return dt_string + data def insert_meld_ns_decl(data): match = _BEGIN_TAG_RE.search(data) if match is not None: start, end = match.span(0) before = data[:start] tag = data[start:end] + ' xmlns:meld="%s"' % _MELD_NS_URL after = data[end:] data = before + tag + after return data def prefeed(data, doctype=doctype.xhtml): if data.find('": ">", '"': """, } _namespace_map = { # "well-known" namespace prefixes "http://www.w3.org/XML/1998/namespace": "xml", "http://www.w3.org/1999/xhtml": "html", "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf", "http://schemas.xmlsoap.org/wsdl/": "wsdl", } def _encode(s, encoding): try: return s.encode(encoding) except AttributeError: return s def _raise_serialization_error(text): raise TypeError( "cannot serialize %r (type %s)" % (text, type(text).__name__) ) _pattern = None def _encode_entity(text): # map reserved and non-ascii characters to numerical entities global _pattern if _pattern is None: _ptxt = r'[&<>\"' + _NON_ASCII_MIN + '-' + _NON_ASCII_MAX + ']+' #_pattern = re.compile(eval(r'u"[&<>\"\u0080-\uffff]+"')) _pattern = re.compile(_ptxt) def _escape_entities(m): out = [] append = out.append for char in m.group(): text = _escape_map.get(char) if text is None: text = "&#%d;" % ord(char) append(text) return ''.join(out) try: return _encode(_pattern.sub(_escape_entities, text), "ascii") except TypeError: _raise_serialization_error(text) def fixtag(tag, namespaces): # given a decorated tag (of the form {uri}tag), return prefixed # tag and namespace declaration, if any if isinstance(tag, QName): tag = tag.text namespace_uri, tag = tag[1:].split("}", 1) prefix = namespaces.get(namespace_uri) if prefix is None: prefix = _namespace_map.get(namespace_uri) if prefix is None: prefix = "ns%d" % len(namespaces) namespaces[namespace_uri] = prefix if prefix == "xml": xmlns = None else: xmlns = ("xmlns:%s" % prefix, namespace_uri) else: xmlns = None return "%s:%s" % (prefix, tag), xmlns #----------------------------------------------------------------------------- # End fork from Python 2.6.8 stdlib #----------------------------------------------------------------------------- meld3-1.0.2/meld3/meld3.py0000644000076500000240000000020612234553535016033 0ustar mnaberezstaff00000000000000from . import parse_xml # BBB from . import parse_html # BBB from . import parse_xmlstring # BBB from . import parse_htmlstring # BBB meld3-1.0.2/meld3/test_meld3.py0000644000076500000240000017227612502620461017102 0ustar mnaberezstaff00000000000000import unittest import re import sys _SIMPLE_XML = r""" Name Description """ _SIMPLE_XHTML = r""" Hello! """ _EMPTYTAGS_HTML = """
""" _BOOLEANATTRS_XHTML= """ """ _ENTITIES_XHTML= r"""

 

""" _COMPLEX_XHTML = r""" This will be escaped in html output: &
Name Description
""" _NVU_HTML = """ test doc Oh yeah...

Yup More Stuff Oh Yeah
1 2 3 4

And an image...

dumb """ _FILLMELDFORM_HTML = """\ Emergency Contacts
Emergency Contacts
Title
First Name
Middle Name
Last Name
Suffix
Address 1
Address 2
City
State
ZIP
Home Phone
Cell/Mobile Phone
Email Address
Over 18? (Checkbox Boolean)
Mail OK? (Checkbox Ternary)
Favorite Color (Radio) Red Green Blue

Return to list

""" class MeldAPITests(unittest.TestCase): def _makeElement(self, string): from . import parse_xmlstring return parse_xmlstring(string) def _makeElementFromHTML(self, string): from . import parse_htmlstring return parse_htmlstring(string) def test_findmeld(self): root = self._makeElement(_SIMPLE_XML) item = root.findmeld('item') self.assertEqual(item.tag, 'item') name = root.findmeld('name') self.assertEqual(name.text, 'Name') def test_findmeld_default(self): root = self._makeElement(_SIMPLE_XML) item = root.findmeld('item') self.assertEqual(item.tag, 'item') unknown = root.findmeld('unknown', 'foo') self.assertEqual(unknown, 'foo') self.assertEqual(root.findmeld('unknown'), None) def test_repeat_nochild(self): root = self._makeElement(_SIMPLE_XML) item = root.findmeld('item') self.assertEqual(item.tag, 'item') data = [{'name':'Jeff Buckley', 'description':'ethereal'}, {'name':'Slipknot', 'description':'heavy'}] for element, d in item.repeat(data): element.findmeld('name').text = d['name'] element.findmeld('description').text = d['description'] self.assertEqual(item[0].text, 'Jeff Buckley') self.assertEqual(item[1].text, 'ethereal') def test_repeat_child(self): root = self._makeElement(_SIMPLE_XML) list = root.findmeld('list') self.assertEqual(list.tag, 'list') data = [{'name':'Jeff Buckley', 'description':'ethereal'}, {'name':'Slipknot', 'description':'heavy'}] for element, d in list.repeat(data, 'item'): element.findmeld('name').text = d['name'] element.findmeld('description').text = d['description'] self.assertEqual(list[0][0].text, 'Jeff Buckley') self.assertEqual(list[0][1].text, 'ethereal') self.assertEqual(list[1][0].text, 'Slipknot') self.assertEqual(list[1][1].text, 'heavy') def test_mod(self): root = self._makeElement(_SIMPLE_XML) root % {'description':'foo', 'name':'bar'} name = root.findmeld('name') self.assertEqual(name.text, 'bar') desc = root.findmeld('description') self.assertEqual(desc.text, 'foo') def test_fillmelds(self): root = self._makeElement(_SIMPLE_XML) unfilled = root.fillmelds(**{'description':'foo', 'jammyjam':'a'}) desc = root.findmeld('description') self.assertEqual(desc.text, 'foo') self.assertEqual(unfilled, ['jammyjam']) def test_fillmeldhtmlform(self): data = [ {'honorific':'Mr.', 'firstname':'Chris', 'middlename':'Phillips', 'lastname':'McDonough', 'address1':'802 Caroline St.', 'address2':'Apt. 2B', 'city':'Fredericksburg', 'state': 'VA', 'zip':'22401', 'homephone':'555-1212', 'cellphone':'555-1313', 'email':'chrism@plope.com', 'suffix':'Sr.', 'over18':True, 'mailok:inputgroup':'true', 'favorite_color:inputgroup':'Green'}, {'honorific':'Mr.', 'firstname':'Fred', 'middlename':'', 'lastname':'Rogers', 'address1':'1 Imaginary Lane', 'address2':'Apt. 3A', 'city':'Never Never Land', 'state': 'LA', 'zip':'00001', 'homephone':'555-1111', 'cellphone':'555-4444', 'email':'fred@neighborhood.com', 'suffix':'Jr.', 'over18':False, 'mailok:inputgroup':'false','favorite_color:inputgroup':'Yellow',}, {'firstname':'Fred', 'middlename':'', 'lastname':'Rogers', 'address1':'1 Imaginary Lane', 'address2':'Apt. 3A', 'city':'Never Never Land', 'state': 'LA', 'zip':'00001', 'homephone':'555-1111', 'cellphone':'555-4444', 'email':'fred@neighborhood.com', 'suffix':'IV', 'over18':False, 'mailok:inputgroup':'false', 'favorite_color:inputgroup':'Blue', 'notthere':1,}, ] root = self._makeElementFromHTML(_FILLMELDFORM_HTML) clone = root.clone() unfilled = clone.fillmeldhtmlform(**data[0]) self.assertEqual(unfilled, []) self.assertEqual(clone.findmeld('honorific').attrib['value'], 'Mr.') self.assertEqual(clone.findmeld('firstname').attrib['value'], 'Chris') middlename = clone.findmeld('middlename') self.assertEqual(middlename.attrib['value'], 'Phillips') suffix = clone.findmeld('suffix') self.assertEqual(suffix[1].attrib['selected'], 'selected') self.assertEqual(clone.findmeld('over18').attrib['checked'], 'checked') mailok = clone.findmeld('mailok:inputgroup') self.assertEqual(mailok[1].attrib['checked'], 'checked') favoritecolor = clone.findmeld('favorite_color:inputgroup') self.assertEqual(favoritecolor[1].attrib['checked'], 'checked') clone = root.clone() unfilled = clone.fillmeldhtmlform(**data[1]) self.assertEqual(unfilled, ['favorite_color:inputgroup']) self.assertEqual(clone.findmeld('over18').attrib.get('checked'), None) mailok = clone.findmeld('mailok:inputgroup') self.assertEqual(mailok[2].attrib['checked'], 'checked') self.assertEqual(mailok[1].attrib.get('checked'), None) clone = root.clone() unfilled = clone.fillmeldhtmlform(**data[2]) self.assertEqual(sorted(unfilled), ['notthere', 'suffix']) self.assertEqual(clone.findmeld('honorific').text, None) favoritecolor = clone.findmeld('favorite_color:inputgroup') self.assertEqual(favoritecolor[2].attrib['checked'], 'checked') self.assertEqual(favoritecolor[1].attrib.get('checked'), None) def test_replace_removes_all_elements(self): from . import Replace root = self._makeElement(_SIMPLE_XML) L = root.findmeld('list') L.replace('this is a textual replacement') R = root[0] self.assertEqual(R.tag, Replace) self.assertEqual(len(root.getchildren()), 1) def test_replace_replaces_the_right_element(self): from . import Replace root = self._makeElement(_SIMPLE_XML) D = root.findmeld('description') D.replace('this is a textual replacement') self.assertEqual(len(root.getchildren()), 1) L = root[0] self.assertEqual(L.tag, 'list') self.assertEqual(len(L.getchildren()), 1) I = L[0] self.assertEqual(I.tag, 'item') self.assertEqual(len(I.getchildren()), 2) N = I[0] self.assertEqual(N.tag, 'name') self.assertEqual(len(N.getchildren()), 0) D = I[1] self.assertEqual(D.tag, Replace) self.assertEqual(D.text, 'this is a textual replacement') self.assertEqual(len(D.getchildren()), 0) self.assertEqual(D.structure, False) def test_content(self): from . import Replace root = self._makeElement(_SIMPLE_XML) D = root.findmeld('description') D.content('this is a textual replacement') self.assertEqual(len(root.getchildren()), 1) L = root[0] self.assertEqual(L.tag, 'list') self.assertEqual(len(L.getchildren()), 1) I = L[0] self.assertEqual(I.tag, 'item') self.assertEqual(len(I.getchildren()), 2) N = I[0] self.assertEqual(N.tag, 'name') self.assertEqual(len(N.getchildren()), 0) D = I[1] self.assertEqual(D.tag, 'description') self.assertEqual(D.text, None) self.assertEqual(len(D.getchildren()), 1) T = D[0] self.assertEqual(T.tag, Replace) self.assertEqual(T.text, 'this is a textual replacement') self.assertEqual(T.structure, False) def test_attributes(self): from . import _MELD_ID root = self._makeElement(_COMPLEX_XHTML) D = root.findmeld('form1') D.attributes(foo='bar', baz='1', g='2', action='#') self.assertEqual(D.attrib, { 'foo':'bar', 'baz':'1', 'g':'2', 'method':'POST', 'action':'#', _MELD_ID: 'form1'}) def test_attributes_unicode(self): from . import _MELD_ID from ._compat import _u root = self._makeElement(_COMPLEX_XHTML) D = root.findmeld('form1') D.attributes(foo=_u('bar'), action=_u('#')) self.assertEqual(D.attrib, { 'foo':_u('bar'), 'method':'POST', 'action': _u('#'), _MELD_ID: 'form1'}) def test_attributes_nonstringtype_raises(self): root = self._makeElement('') self.assertRaises(ValueError, root.attributes, foo=1) class MeldElementInterfaceTests(unittest.TestCase): def _getTargetClass(self): from . import _MeldElementInterface return _MeldElementInterface def _makeOne(self, *arg, **kw): klass = self._getTargetClass() return klass(*arg, **kw) def test_repeat(self): root = self._makeOne('root', {}) from . import _MELD_ID item = self._makeOne('item', {_MELD_ID:'item'}) record = self._makeOne('record', {_MELD_ID:'record'}) name = self._makeOne('name', {_MELD_ID:'name'}) description = self._makeOne('description', {_MELD_ID:'description'}) record.append(name) record.append(description) item.append(record) root.append(item) data = [{'name':'Jeff Buckley', 'description':'ethereal'}, {'name':'Slipknot', 'description':'heavy'}] for element, d in item.repeat(data): element.findmeld('name').text = d['name'] element.findmeld('description').text = d['description'] self.assertEqual(len(root), 2) item1 = root[0] self.assertEqual(len(item1), 1) record1 = item1[0] self.assertEqual(len(record1), 2) name1 = record1[0] desc1 = record1[1] self.assertEqual(name1.text, 'Jeff Buckley') self.assertEqual(desc1.text, 'ethereal') item2 = root[1] self.assertEqual(len(item2), 1) record2 = item2[0] self.assertEqual(len(record2), 2) name2 = record2[0] desc2 = record2[1] self.assertEqual(name2.text, 'Slipknot') self.assertEqual(desc2.text, 'heavy') def test_content_simple_nostructure(self): el = self._makeOne('div', {'id':'thediv'}) el.content('hello') self.assertEqual(len(el._children), 1) replacenode = el._children[0] self.assertEqual(replacenode.parent, el) self.assertEqual(replacenode.text, 'hello') self.assertEqual(replacenode.structure, False) from . import Replace self.assertEqual(replacenode.tag, Replace) def test_content_simple_structure(self): el = self._makeOne('div', {'id':'thediv'}) el.content('hello', structure=True) self.assertEqual(len(el._children), 1) replacenode = el._children[0] self.assertEqual(replacenode.parent, el) self.assertEqual(replacenode.text, 'hello') self.assertEqual(replacenode.structure, True) from . import Replace self.assertEqual(replacenode.tag, Replace) def test_findmeld_simple(self): from . import _MELD_ID el = self._makeOne('div', {_MELD_ID:'thediv'}) self.assertEqual(el.findmeld('thediv'), el) def test_findmeld_simple_oneleveldown(self): from . import _MELD_ID el = self._makeOne('div', {_MELD_ID:'thediv'}) span = self._makeOne('span', {_MELD_ID:'thespan'}) el.append(span) self.assertEqual(el.findmeld('thespan'), span) def test_findmeld_simple_twolevelsdown(self): from . import _MELD_ID el = self._makeOne('div', {_MELD_ID:'thediv'}) span = self._makeOne('span', {_MELD_ID:'thespan'}) a = self._makeOne('a', {_MELD_ID:'thea'}) span.append(a) el.append(span) self.assertEqual(el.findmeld('thea'), a) def test_ctor(self): iface = self._makeOne('div', {'id':'thediv'}) self.assertEqual(iface.parent, None) self.assertEqual(iface.tag, 'div') self.assertEqual(iface.attrib, {'id':'thediv'}) def test_getiterator_simple(self): div = self._makeOne('div', {'id':'thediv'}) iterator = div.getiterator() self.assertEqual(len(iterator), 1) self.assertEqual(iterator[0], div) def test_getiterator(self): div = self._makeOne('div', {'id':'thediv'}) span = self._makeOne('span', {}) span2 = self._makeOne('span', {'id':'2'}) span3 = self._makeOne('span3', {'id':'3'}) span3.text = 'abc' span3.tail = ' ' div.append(span) span.append(span2) span2.append(span3) it = div.getiterator() self.assertEqual(len(it), 4) self.assertEqual(it[0], div) self.assertEqual(it[1], span) self.assertEqual(it[2], span2) self.assertEqual(it[3], span3) def test_getiterator_tag_ignored(self): div = self._makeOne('div', {'id':'thediv'}) span = self._makeOne('span', {}) span2 = self._makeOne('span', {'id':'2'}) span3 = self._makeOne('span3', {'id':'3'}) span3.text = 'abc' span3.tail = ' ' div.append(span) span.append(span2) span2.append(span3) it = div.getiterator(tag='div') self.assertEqual(len(it), 4) self.assertEqual(it[0], div) self.assertEqual(it[1], span) self.assertEqual(it[2], span2) self.assertEqual(it[3], span3) def test_append(self): div = self._makeOne('div', {'id':'thediv'}) span = self._makeOne('span', {}) div.append(span) self.assertEqual(div[0].tag, 'span') self.assertEqual(span.parent, div) def test__setitem__(self): div = self._makeOne('div', {'id':'thediv'}) span = self._makeOne('span', {}) span2 = self._makeOne('span', {'id':'2'}) div.append(span) div[0] = span2 self.assertEqual(div[0].tag, 'span') self.assertEqual(div[0].attrib, {'id':'2'}) self.assertEqual(div[0].parent, div) def test_insert(self): div = self._makeOne('div', {'id':'thediv'}) span = self._makeOne('span', {}) span2 = self._makeOne('span', {'id':'2'}) div.append(span) div.insert(0, span2) self.assertEqual(div[0].tag, 'span') self.assertEqual(div[0].attrib, {'id':'2'}) self.assertEqual(div[0].parent, div) self.assertEqual(div[1].tag, 'span') self.assertEqual(div[1].attrib, {}) self.assertEqual(div[1].parent, div) def test_clone_simple(self): div = self._makeOne('div', {'id':'thediv'}) div.text = 'abc' div.tail = ' ' span = self._makeOne('span', {}) div.append(span) div2 = div.clone() def test_clone(self): div = self._makeOne('div', {'id':'thediv'}) span = self._makeOne('span', {}) span2 = self._makeOne('span', {'id':'2'}) span3 = self._makeOne('span3', {'id':'3'}) span3.text = 'abc' span3.tail = ' ' div.append(span) span.append(span2) span2.append(span3) div2 = div.clone() self.assertEqual(div.tag, div2.tag) self.assertEqual(div.attrib, div2.attrib) self.assertEqual(div[0].tag, div2[0].tag) self.assertEqual(div[0].attrib, div2[0].attrib) self.assertEqual(div[0][0].tag, div2[0][0].tag) self.assertEqual(div[0][0].attrib, div2[0][0].attrib) self.assertEqual(div[0][0][0].tag, div2[0][0][0].tag) self.assertEqual(div[0][0][0].attrib, div2[0][0][0].attrib) self.assertEqual(div[0][0][0].text, div2[0][0][0].text) self.assertEqual(div[0][0][0].tail, div2[0][0][0].tail) self.assertNotEqual(id(div), id(div2)) self.assertNotEqual(id(div[0]), id(div2[0])) self.assertNotEqual(id(div[0][0]), id(div2[0][0])) self.assertNotEqual(id(div[0][0][0]), id(div2[0][0][0])) def test_deparent_noparent(self): div = self._makeOne('div', {}) self.assertEqual(div.parent, None) div.deparent() self.assertEqual(div.parent, None) def test_deparent_withparent(self): parent = self._makeOne('parent', {}) self.assertEqual(parent.parent, None) child = self._makeOne('child', {}) parent.append(child) self.assertEqual(parent.parent, None) self.assertEqual(child.parent, parent) self.assertEqual(parent[0], child) child.deparent() self.assertEqual(child.parent, None) self.assertRaises(IndexError, parent.__getitem__, 0) def test_setslice(self): parent = self._makeOne('parent', {}) child1 = self._makeOne('child1', {}) child2 = self._makeOne('child2', {}) child3 = self._makeOne('child3', {}) children = (child1, child2, child3) parent[0:2] = children self.assertEqual(child1.parent, parent) self.assertEqual(child2.parent, parent) self.assertEqual(child3.parent, parent) self.assertEqual(parent._children, list(children)) def test_delslice(self): parent = self._makeOne('parent', {}) child1 = self._makeOne('child1', {}) child2 = self._makeOne('child2', {}) child3 = self._makeOne('child3', {}) children = (child1, child2, child3) parent[0:2] = children del parent[0:2] self.assertEqual(child1.parent, None) self.assertEqual(child2.parent, None) self.assertEqual(child3.parent, parent) self.assertEqual(len(parent._children), 1) def test_remove(self): parent = self._makeOne('parent', {}) child1 = self._makeOne('child1', {}) parent.append(child1) parent.remove(child1) self.assertEqual(child1.parent, None) self.assertEqual(len(parent._children), 0) def test_lineage(self): from . import _MELD_ID div1 = self._makeOne('div', {_MELD_ID:'div1'}) span1 = self._makeOne('span', {_MELD_ID:'span1'}) span2 = self._makeOne('span', {_MELD_ID:'span2'}) span3 = self._makeOne('span', {_MELD_ID:'span3'}) span4 = self._makeOne('span', {_MELD_ID:'span4'}) span5 = self._makeOne('span', {_MELD_ID:'span5'}) span6 = self._makeOne('span', {_MELD_ID:'span6'}) unknown = self._makeOne('span', {}) div2 = self._makeOne('div2', {_MELD_ID:'div2'}) div1.append(span1) span1.append(span2) span2.append(span3) span3.append(unknown) unknown.append(span4) span4.append(span5) span5.append(span6) div1.append(div2) def ids(L): return [ x.meldid() for x in L ] self.assertEqual(ids(div1.lineage()), ['div1']) self.assertEqual(ids(span1.lineage()), ['span1', 'div1']) self.assertEqual(ids(span2.lineage()), ['span2', 'span1', 'div1']) self.assertEqual(ids(span3.lineage()), ['span3', 'span2', 'span1', 'div1']) self.assertEqual(ids(unknown.lineage()), [None, 'span3', 'span2', 'span1', 'div1']) self.assertEqual(ids(span4.lineage()), ['span4', None, 'span3', 'span2', 'span1','div1']) self.assertEqual(ids(span5.lineage()), ['span5', 'span4', None, 'span3', 'span2', 'span1','div1']) self.assertEqual(ids(span6.lineage()), ['span6', 'span5', 'span4', None,'span3', 'span2', 'span1','div1']) self.assertEqual(ids(div2.lineage()), ['div2', 'div1']) def test_shortrepr(self): from ._compat import _b div = self._makeOne('div', {'id':'div1'}) span = self._makeOne('span', {}) span2 = self._makeOne('span', {'id':'2'}) span3 = self._makeOne('span3', {'id':'3'}) span4 = self._makeOne('span4', {'id':'4'}) span5 = self._makeOne('span5', {'id':'5'}) span6 = self._makeOne('span6', {'id':'6'}) div2 = self._makeOne('div2', {'id':'div2'}) div.append(span) span.append(span2) div.append(div2) r = div.shortrepr() self.assertEqual(r, _b('
' '
')) def test_shortrepr2(self): from . import parse_xmlstring from ._compat import _b root = parse_xmlstring(_COMPLEX_XHTML) r = root.shortrepr() self.assertEqual(r, _b('\n' ' \n' ' \n' ' [...]\n\n' ' \n' ' [...]\n' '')) def test_diffmeld1(self): from . import parse_xmlstring from . import _MELD_ID root = parse_xmlstring(_COMPLEX_XHTML) clone = root.clone() div = self._makeOne('div', {_MELD_ID:'newdiv'}) clone.append(div) tr = clone.findmeld('tr') tr.deparent() title = clone.findmeld('title') title.deparent() clone.append(title) # unreduced diff = root.diffmeld(clone) changes = diff['unreduced'] addedtags = [ x.attrib[_MELD_ID] for x in changes['added'] ] removedtags = [x.attrib[_MELD_ID] for x in changes['removed'] ] movedtags = [ x.attrib[_MELD_ID] for x in changes['moved'] ] addedtags.sort() removedtags.sort() movedtags.sort() self.assertEqual(addedtags,['newdiv']) self.assertEqual(removedtags,['td1', 'td2', 'tr']) self.assertEqual(movedtags, ['title']) # reduced changes = diff['reduced'] addedtags = [ x.attrib[_MELD_ID] for x in changes['added'] ] removedtags = [x.attrib[_MELD_ID] for x in changes['removed'] ] movedtags = [ x.attrib[_MELD_ID] for x in changes['moved'] ] addedtags.sort() removedtags.sort() movedtags.sort() self.assertEqual(addedtags,['newdiv']) self.assertEqual(removedtags,['tr']) self.assertEqual(movedtags, ['title']) def test_diffmeld2(self): source = """ """ target = """ """ from . import parse_htmlstring source_root = parse_htmlstring(source) target_root = parse_htmlstring(target) changes = source_root.diffmeld(target_root) # unreduced actual = [x.meldid() for x in changes['unreduced']['moved']] expected = ['b'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['unreduced']['added']] expected = [] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['unreduced']['removed']] expected = [] self.assertEqual(expected, actual) # reduced actual = [x.meldid() for x in changes['reduced']['moved']] expected = ['b'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['reduced']['added']] expected = [] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['reduced']['removed']] expected = [] self.assertEqual(expected, actual) def test_diffmeld3(self): source = """ """ target = """ """ from . import parse_htmlstring source_root = parse_htmlstring(source) target_root = parse_htmlstring(target) changes = source_root.diffmeld(target_root) # unreduced actual = [x.meldid() for x in changes['unreduced']['moved']] expected = ['b', 'c'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['unreduced']['added']] expected = ['d', 'e'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['unreduced']['removed']] expected = ['z', 'y'] self.assertEqual(expected, actual) # reduced actual = [x.meldid() for x in changes['reduced']['moved']] expected = ['b'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['reduced']['added']] expected = ['d'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['reduced']['removed']] expected = ['z'] self.assertEqual(expected, actual) def test_diffmeld4(self): source = """ """ target = """

""" from . import parse_htmlstring source_root = parse_htmlstring(source) target_root = parse_htmlstring(target) changes = source_root.diffmeld(target_root) # unreduced actual = [x.meldid() for x in changes['unreduced']['moved']] expected = ['a', 'b'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['unreduced']['added']] expected = ['m', 'n'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['unreduced']['removed']] expected = ['c', 'd', 'z', 'y'] self.assertEqual(expected, actual) # reduced actual = [x.meldid() for x in changes['reduced']['moved']] expected = ['a'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['reduced']['added']] expected = ['m'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['reduced']['removed']] expected = ['c', 'z'] self.assertEqual(expected, actual) def test_diffmeld5(self): source = """ """ target = """

""" from . import parse_htmlstring source_root = parse_htmlstring(source) target_root = parse_htmlstring(target) changes = source_root.diffmeld(target_root) # unreduced actual = [x.meldid() for x in changes['unreduced']['moved']] expected = ['a', 'b', 'c', 'd'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['unreduced']['added']] expected = [] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['unreduced']['removed']] expected = [] self.assertEqual(expected, actual) # reduced actual = [x.meldid() for x in changes['reduced']['moved']] expected = ['a', 'c'] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['reduced']['added']] expected = [] self.assertEqual(expected, actual) actual = [x.meldid() for x in changes['reduced']['removed']] expected = [] self.assertEqual(expected, actual) class ParserTests(unittest.TestCase): def _parse(self, *args): from . import parse_xmlstring root = parse_xmlstring(*args) return root def _parse_html(self, *args): from . import parse_htmlstring root = parse_htmlstring(*args) return root def test_parse_simple_xml(self): from . import _MELD_ID root = self._parse(_SIMPLE_XML) self.assertEqual(root.tag, 'root') self.assertEqual(root.parent, None) l1st = root[0] self.assertEqual(l1st.tag, 'list') self.assertEqual(l1st.parent, root) self.assertEqual(l1st.attrib[_MELD_ID], 'list') item = l1st[0] self.assertEqual(item.tag, 'item') self.assertEqual(item.parent, l1st) self.assertEqual(item.attrib[_MELD_ID], 'item') name = item[0] description = item[1] self.assertEqual(name.tag, 'name') self.assertEqual(name.parent, item) self.assertEqual(name.attrib[_MELD_ID], 'name') self.assertEqual(description.tag, 'description') self.assertEqual(description.parent, item) self.assertEqual(description.attrib[_MELD_ID], 'description') def test_parse_simple_xhtml(self): xhtml_ns = '{http://www.w3.org/1999/xhtml}%s' from . import _MELD_ID root = self._parse(_SIMPLE_XHTML) self.assertEqual(root.tag, xhtml_ns % 'html') self.assertEqual(root.attrib, {}) self.assertEqual(root.parent, None) body = root[0] self.assertEqual(body.tag, xhtml_ns % 'body') self.assertEqual(body.attrib[_MELD_ID], 'body') self.assertEqual(body.parent, root) def test_parse_complex_xhtml(self): xhtml_ns = '{http://www.w3.org/1999/xhtml}%s' from . import _MELD_ID root = self._parse(_COMPLEX_XHTML) self.assertEqual(root.tag, xhtml_ns % 'html') self.assertEqual(root.attrib, {}) self.assertEqual(root.parent, None) head = root[0] self.assertEqual(head.tag, xhtml_ns % 'head') self.assertEqual(head.attrib, {}) self.assertEqual(head.parent, root) meta = head[0] self.assertEqual(meta.tag, xhtml_ns % 'meta') self.assertEqual(meta.attrib['content'], 'text/html; charset=ISO-8859-1') self.assertEqual(meta.parent, head) title = head[1] self.assertEqual(title.tag, xhtml_ns % 'title') self.assertEqual(title.attrib[_MELD_ID], 'title') self.assertEqual(title.parent, head) comment = root[1] body = root[2] self.assertEqual(body.tag, xhtml_ns % 'body') self.assertEqual(body.attrib, {}) self.assertEqual(body.parent, root) div1 = body[0] self.assertEqual(div1.tag, xhtml_ns % 'div') self.assertEqual(div1.attrib, {'{http://foo/bar}baz': 'slab'}) self.assertEqual(div1.parent, body) div2 = body[1] self.assertEqual(div2.tag, xhtml_ns % 'div') self.assertEqual(div2.attrib[_MELD_ID], 'content_well') self.assertEqual(div2.parent, body) form = div2[0] self.assertEqual(form.tag, xhtml_ns % 'form') self.assertEqual(form.attrib[_MELD_ID], 'form1') self.assertEqual(form.attrib['action'], '.') self.assertEqual(form.attrib['method'], 'POST') self.assertEqual(form.parent, div2) img = form[0] self.assertEqual(img.tag, xhtml_ns % 'img') self.assertEqual(img.parent, form) table = form[1] self.assertEqual(table.tag, xhtml_ns % 'table') self.assertEqual(table.attrib[_MELD_ID], 'table1') self.assertEqual(table.attrib['border'], '0') self.assertEqual(table.parent, form) tbody = table[0] self.assertEqual(tbody.tag, xhtml_ns % 'tbody') self.assertEqual(tbody.attrib[_MELD_ID], 'tbody') self.assertEqual(tbody.parent, table) tr = tbody[0] self.assertEqual(tr.tag, xhtml_ns % 'tr') self.assertEqual(tr.attrib[_MELD_ID], 'tr') self.assertEqual(tr.attrib['class'], 'foo') self.assertEqual(tr.parent, tbody) td1 = tr[0] self.assertEqual(td1.tag, xhtml_ns % 'td') self.assertEqual(td1.attrib[_MELD_ID], 'td1') self.assertEqual(td1.parent, tr) td2 = tr[1] self.assertEqual(td2.tag, xhtml_ns % 'td') self.assertEqual(td2.attrib[_MELD_ID], 'td2') self.assertEqual(td2.parent, tr) def test_nvu_html(self): from . import _MELD_ID from . import Comment root = self._parse_html(_NVU_HTML) self.assertEqual(root.tag, 'html') self.assertEqual(root.attrib, {}) self.assertEqual(root.parent, None) head = root[0] self.assertEqual(head.tag, 'head') self.assertEqual(head.attrib, {}) self.assertEqual(head.parent, root) meta = head[0] self.assertEqual(meta.tag, 'meta') self.assertEqual(meta.attrib['content'], 'text/html; charset=ISO-8859-1') title = head[1] self.assertEqual(title.tag, 'title') self.assertEqual(title.attrib[_MELD_ID], 'title') self.assertEqual(title.parent, head) body = root[1] self.assertEqual(body.tag, 'body') self.assertEqual(body.attrib, {}) self.assertEqual(body.parent, root) comment = body[0] self.assertEqual(comment.tag, Comment) br1 = body[1] br2 = body[2] table = body[3] self.assertEqual(table.tag, 'table') self.assertEqual(table.attrib, {'style': 'text-align: left; width: 100px;', 'border':'1', 'cellpadding':'2', 'cellspacing':'2'}) self.assertEqual(table.parent, body) br3 = body[4] href = body[5] self.assertEqual(href.tag, 'a') br4 = body[6] br5 = body[7] img = body[8] self.assertEqual(img.tag, 'img') def test_dupe_meldids_fails_parse_xml(self): meld_ns = "http://www.plope.com/software/meld3" repeated = ('' '' % meld_ns) self.assertRaises(ValueError, self._parse, repeated) def test_dupe_meldids_fails_parse_html(self): meld_ns = "http://www.plope.com/software/meld3" repeated = ('' '' % meld_ns) self.assertRaises(ValueError, self._parse_html, repeated) class UtilTests(unittest.TestCase): def test_insert_xhtml_doctype(self): from . import insert_doctype orig = '' actual = insert_doctype(orig) expected = '' self.assertEqual(actual, expected) def test_insert_doctype_after_xmldecl(self): from . import insert_doctype orig = '' actual = insert_doctype(orig) expected = '' self.assertEqual(actual, expected) def test_insert_meld_ns_decl(self): from . import insert_meld_ns_decl orig = '' actual = insert_meld_ns_decl(orig) expected = '' self.assertEqual(actual, expected) def test_prefeed_preserves_existing_meld_ns(self): from . import prefeed orig = '' actual = prefeed(orig) expected = '' self.assertEqual(actual, expected) def test_prefeed_preserves_existing_doctype(self): from . import prefeed orig = '' actual = prefeed(orig) self.assertEqual(actual, orig) class WriterTests(unittest.TestCase): def _parse(self, xml): from . import parse_xmlstring root = parse_xmlstring(xml) return root def _parse_html(self, xml): from . import parse_htmlstring root = parse_htmlstring(xml) return root def _write(self, fn, **kw): try: from io import BytesIO except: # python 2.5 from StringIO import StringIO as BytesIO out = BytesIO() fn(out, **kw) out.seek(0) actual = out.read() return actual def _write_xml(self, node, **kw): return self._write(node.write_xml, **kw) def _write_html(self, node, **kw): return self._write(node.write_html, **kw) def _write_xhtml(self, node, **kw): return self._write(node.write_xhtml, **kw) def assertNormalizedXMLEqual(self, a, b): from ._compat import _u a = normalize_xml(_u(a)) b = normalize_xml(_u(b)) self.assertEqual(a, b) def assertNormalizedHTMLEqual(self, a, b): from ._compat import _u a = normalize_xml(_u(a)) b = normalize_xml(_u(b)) self.assertEqual(a, b) def test_write_simple_xml(self): root = self._parse(_SIMPLE_XML) actual = self._write_xml(root) expected = """ Name Description """ self.assertNormalizedXMLEqual(actual, expected) for el, data in root.findmeld('item').repeat(((1,2),)): el.findmeld('name').text = str(data[0]) el.findmeld('description').text = str(data[1]) actual = self._write_xml(root) expected = """ 1 2 """ self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xhtml(self): root = self._parse(_SIMPLE_XHTML) actual = self._write_xhtml(root) expected = """Hello!""" self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xhtml_as_html(self): root = self._parse(_SIMPLE_XHTML) actual = self._write_html(root) expected = """ Hello! """ self.assertNormalizedHTMLEqual(actual, expected) def test_write_complex_xhtml_as_html(self): root = self._parse(_COMPLEX_XHTML) actual = self._write_html(root) expected = """ This will be escaped in html output: &
Name Description
""" self.assertNormalizedHTMLEqual(actual, expected) def test_write_complex_xhtml_as_xhtml(self): # I'm not entirely sure if the cdata "script" quoting in this # test is entirely correct for XHTML. Ryan Tomayko suggests # that escaped entities are handled properly in script tags by # XML-aware browsers at # http://sourceforge.net/mailarchive/message.php?msg_id=10835582 # but I haven't tested it at all. ZPT does not seem to do # this; it outputs unescaped data. root = self._parse(_COMPLEX_XHTML) actual = self._write_xhtml(root) expected = """ This will be escaped in html output: &
Name Description
""" self.assertNormalizedXMLEqual(actual, expected) def test_write_emptytags_html(self): from ._compat import _u root = self._parse(_EMPTYTAGS_HTML) actual = self._write_html(root) expected = """
""" self.assertEqual(_u(actual), expected) def test_write_booleanattrs_xhtml_as_html(self): root = self._parse(_BOOLEANATTRS_XHTML) actual = self._write_html(root) expected = """ """ self.assertNormalizedHTMLEqual(actual, expected) def test_write_simple_xhtml_pipeline(self): root = self._parse(_SIMPLE_XHTML) actual = self._write_xhtml(root, pipeline=True) expected = """Hello!""" self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xml_pipeline(self): root = self._parse(_SIMPLE_XML) actual = self._write_xml(root, pipeline=True) expected = """ Name Description """ self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xml_override_encoding(self): root = self._parse(_SIMPLE_XML) actual = self._write_xml(root, encoding="latin-1") expected = """ Name Description """ self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xml_as_fragment(self): root = self._parse(_SIMPLE_XML) actual = self._write_xml(root, fragment=True) expected = """ Name Description """ self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xml_with_doctype(self): root = self._parse(_SIMPLE_XML) from . import doctype actual = self._write_xml(root, doctype=doctype.xhtml) expected = """ Name Description """ self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xml_doctype_nodeclaration(self): root = self._parse(_SIMPLE_XML) from . import doctype actual = self._write_xml(root, declaration=False, doctype=doctype.xhtml) expected = """ Name Description """ self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xml_fragment_kills_doctype_and_declaration(self): root = self._parse(_SIMPLE_XML) from . import doctype actual = self._write_xml(root, declaration=True, doctype=doctype.xhtml, fragment=True) expected = """ Name Description """ self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xhtml_override_encoding(self): root = self._parse(_SIMPLE_XHTML) actual = self._write_xhtml(root, encoding="latin-1", declaration=True) expected = """Hello!""" self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xhtml_as_fragment(self): root = self._parse(_SIMPLE_XHTML) actual = self._write_xhtml(root, fragment=True) expected = """Hello!""" self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xhtml_with_doctype(self): root = self._parse(_SIMPLE_XHTML) from . import doctype actual = self._write_xhtml(root, doctype=doctype.xhtml) expected = """Hello!""" self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xhtml_doctype_nodeclaration(self): root = self._parse(_SIMPLE_XHTML) from . import doctype actual = self._write_xhtml(root, declaration=False, doctype=doctype.xhtml) expected = """Hello!""" self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xhtml_fragment_kills_doctype_and_declaration(self): root = self._parse(_SIMPLE_XHTML) from . import doctype actual = self._write_xhtml(root, declaration=True, doctype=doctype.xhtml, fragment=True) expected = """Hello!""" self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xhtml_as_html_fragment(self): root = self._parse(_SIMPLE_XHTML) actual = self._write_html(root, fragment=True) expected = """Hello!""" self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xhtml_with_doctype_as_html(self): root = self._parse(_SIMPLE_XHTML) actual = self._write_html(root) expected = """ Hello!""" self.assertNormalizedXMLEqual(actual, expected) def test_write_simple_xhtml_as_html_new_doctype(self): root = self._parse(_SIMPLE_XHTML) from . import doctype actual = self._write_html(root, doctype=doctype.html_strict) expected = """ Hello!""" self.assertNormalizedXMLEqual(actual, expected) def test_write_entities_xhtml_no_doctype(self): root = self._parse_html(_ENTITIES_XHTML) # this will be considered an XHTML document by default; we needn't # declare a doctype actual = self._write_xhtml(root) expected =r"""

 

""" def test_write_entities_xhtml_with_doctype(self): dt = '' root = self._parse_html(dt + _ENTITIES_XHTML) actual = self._write_xhtml(root) expected =r"""

 

""" def test_unknown_entity(self): # exception thrown may vary by python or expat version from xml.parsers import expat self.assertRaises((expat.error, SyntaxError), self._parse, '&fleeb;') def test_content_nostructure(self): root = self._parse(_SIMPLE_XML) D = root.findmeld('description') D.content('description &&', structure=False) actual = self._write_xml(root) expected = """ Name description &<foo>&<bar> """ self.assertNormalizedXMLEqual(actual, expected) def test_content_structure(self): root = self._parse(_SIMPLE_XML) D = root.findmeld('description') D.content('description & ', structure=True) actual = self._write_xml(root) expected = """ Name description & """ self.assertNormalizedXMLEqual(actual, expected) def test_replace_nostructure(self): root = self._parse(_SIMPLE_XML) D = root.findmeld('description') D.replace('description &&', structure=False) actual = self._write_xml(root) expected = """ Name description &<foo>&<bar> """ self.assertNormalizedXMLEqual(actual, expected) def test_replace_structure(self): root = self._parse(_SIMPLE_XML) D = root.findmeld('description') D.replace('description & ', structure=True) actual = self._write_xml(root) expected = """ Name description & """ self.assertNormalizedXMLEqual(actual, expected) def test_escape_cdata(self): from ._compat import _b from . import _escape_cdata a = ('< > <& &' && &foo "" ' 'http://www.plope.com?foo=bar&bang=baz {') self.assertEqual( _b('< > <& &' && &foo "" ' 'http://www.plope.com?foo=bar&bang=baz {'), _escape_cdata(a)) def test_escape_cdata_unicodeerror(self): from . import _escape_cdata from ._compat import _b from ._compat import _u a = _u(_b('\x80')) self.assertEqual(_b('€'), _escape_cdata(a, 'ascii')) def test_escape_attrib(self): from . import _escape_attrib from ._compat import _b a = ('< > <& &' && &foo "" ' 'http://www.plope.com?foo=bar&bang=baz {') self.assertEqual( _b('< > <& &' ' '&& &foo "" ' 'http://www.plope.com?foo=bar&bang=baz {'), _escape_attrib(a, None)) def test_escape_attrib_unicodeerror(self): from . import _escape_attrib from ._compat import _b from ._compat import _u a = _u(_b('\x80')) self.assertEqual(_b('€'), _escape_attrib(a, 'ascii')) def normalize_html(s): s = re.sub(r"[ \t]+", " ", s) s = re.sub(r"/>", ">", s) return s def normalize_xml(s): s = re.sub(r"\s+", " ", s) s = re.sub(r"(?s)\s+<", "<", s) s = re.sub(r"(?s)>\s+", ">", s) return s def test_suite(): return unittest.findTestCases(sys.modules[__name__]) def main(): unittest.main(defaultTest='test_suite') if __name__ == '__main__': main() meld3-1.0.2/meld3.egg-info/0000755000076500000240000000000012506600672016146 5ustar mnaberezstaff00000000000000meld3-1.0.2/meld3.egg-info/dependency_links.txt0000644000076500000240000000000112506600672022214 0ustar mnaberezstaff00000000000000 meld3-1.0.2/meld3.egg-info/PKG-INFO0000644000076500000240000000164012506600672017244 0ustar mnaberezstaff00000000000000Metadata-Version: 1.1 Name: meld3 Version: 1.0.2 Summary: meld3 is an HTML/XML templating engine. Home-page: https://github.com/supervisor/meld3 Author: Chris McDonough Author-email: chrism@plope.com License: BSD-derived (http://www.repoze.org/LICENSE.txt) Description: UNKNOWN Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: Operating System :: POSIX Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.5 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.2 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Topic :: Text Processing :: Markup :: HTML meld3-1.0.2/meld3.egg-info/SOURCES.txt0000644000076500000240000000044312506600672020033 0ustar mnaberezstaff00000000000000CHANGES.txt CONTRIBUTORS.txt COPYRIGHT.txt LICENSE.txt MANIFEST.in README.txt TODO.txt setup.cfg setup.py meld3/__init__.py meld3/_compat.py meld3/meld3.py meld3/test_meld3.py meld3.egg-info/PKG-INFO meld3.egg-info/SOURCES.txt meld3.egg-info/dependency_links.txt meld3.egg-info/top_level.txtmeld3-1.0.2/meld3.egg-info/top_level.txt0000644000076500000240000000000612506600672020674 0ustar mnaberezstaff00000000000000meld3 meld3-1.0.2/PKG-INFO0000644000076500000240000000164012506600672014546 0ustar mnaberezstaff00000000000000Metadata-Version: 1.1 Name: meld3 Version: 1.0.2 Summary: meld3 is an HTML/XML templating engine. Home-page: https://github.com/supervisor/meld3 Author: Chris McDonough Author-email: chrism@plope.com License: BSD-derived (http://www.repoze.org/LICENSE.txt) Description: UNKNOWN Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: Operating System :: POSIX Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.5 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.2 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Topic :: Text Processing :: Markup :: HTML meld3-1.0.2/README.txt0000644000076500000240000005224012321576624015155 0ustar mnaberezstaff00000000000000meld3 Overview meld3 is an HTML/XML templating system for Python which keeps template markup and dynamic rendering logic separate from one another. See http://www.entrian.com/PyMeld for a treatise on the benefits of this pattern. meld3 can deal with HTML or XML/XHTML input and can output well-formed HTML or XML/XHTML. meld3 is a variation of Paul Winkler's Meld2, which is itself a variation of Richie Hindle's PyMeld. meld3 uses Frederik Lundh's ElementTree library. Requirements On Python 3, meld3 requires Python 3.2 or later. On Python 2, meld3 requires Python 2.5 or later. Installation Run 'python setup.py install'. Differences from PyMeld - Templates created for use under PyMeld will not work under meld3 due to differences in meld tag identification (meld3's id attributes are in a nondefault XML namespace, PyMeld's are not). Rationale: it should be possible to look at a template and have a good shot at figuring out which pieces of it might get replaced with dynamic content. XML ids are required for other things like CSS styles, so you can't assume if you see an XML id in a template that it was put in there to be a meld identifier. In the worst case scenario, if XML ids were used instead of namespaced id's, and an unused id was present in the source document, the designer would leave it in there even if he wasn't using it because he would think it was a meld id and the programmer would leave it in there even if he wasn't using it because he would think it was being used by the designer's stylesheets. Menawhile, nobody's actually using it and it's just cluttering up the template. Also, having a separate namespace helps the programmer not stomp on the designer by changing identifiers (or needing to grep stylesheets), and lets them avoid fighting over what to call elements. - The "id" attribute used to mark up is in the a separate namespace (aka. xmlns="http://www.plope.com/software/meld3"). So instead of marking up a tag like this: '
', meld3 requires that you qualify the "id" attribute with a "meld" namespace element, like this: '
'. As per the XML namespace specification, the "meld" name is completely optional, and must only represent the "http://www.plope.com/software/meld3" namespace identifier, so '
' is just as valid as as '
' - Output documents by default do not include any meld3 namespace id attributes. If you wish to preserve meld3 ids (for instance, in order to do pipelining of meld3 templates), you can preserve meld ids by passing a "pipeline" option to a "write" function (e.g. write_xml, wwrite_xhtml). - Output can be performed in "XML mode", "XHTML mode" and "HTML mode". HTML output follows recommendations for HTML 4.01, while XML and XHTML output outputs valid XML If you create an empty textarea element and output it in XML and XHTML mode the output will be rendered <'textarea/>'. In HTML mode, it will be rendered as ''. In HTML mode, various other tags like 'img' aren't "balanced" with an ending tag, and so forth. You can decide how you wish to render your templates by passing an 'html' flag to the meld 'writer'. - meld3 elements are instances of ElementTree elements and support the "ElementTree _ElementInterface API":http://effbot.org/zone/pythondoc-elementtree-ElementTree.htm#elementtree.ElementTree._ElementInterface-class) instead of the PyMeld node API. The ElementTree _ElementInterface API has been extended by meld3 to perform various functions specific to meld3. - meld3 elements do not support the __mod__ method with a sequence argument; they do support the __mod__ method with a dictionary argument, however. - meld3 elements support various ZPT-alike methods like "repeat", "content", "attributes", and "replace" that are meant to work like their ZPT counterparts. Examples A valid example meld3 template is as follows:: This is the title
Name Description
Name Description
Note that the script contains no logic, only "meld:id" identifiers. All "meld:id" identifiers in a single document must be unique for a meld template to be parseable. A script which parses the above template and does some transformations is below. Consider the variable "xml" below bound to a string representing the XHTML above:: from meld3 import parse_xmlstring from meld3 import parse_htmlstring from StringIO import StringIO import sys root = parse_xmlstring(xml) root.findmeld('title').content('My document') root.findmeld('form1').attributes(action='./handler') data = ( {'name':'Boys', 'description':'Ugly'}, {'name':'Girls', 'description':'Pretty'}, ) iterator = root.findmeld('tr').repeat(data) for element, item in iterator: element.findmeld('td1').content(item['name']) element.findmeld('td2').content(item['description']) You used the "parse_xmlstring" function to transform the XML into a tree of nodes above. This was possible because the input was well-formed XML. If it had not been, you would have needed to use the "parse_htmlstring" function instead. To output the result of the transformations to stdout as XML, we use the 'write' method of any element. Below, we use the root element (consider it bound to the value of "root" in the above script):: import sys root.write_xml(sys.stdout) ... My document Name Description Boys Ugly Girls Pretty We can also serialize our element tree as well-formed XHTML, which is largely like rendering to XML except it by default doesn't emit the XML declaration and it removes all "html" namespace declarations from the output. It also emits a XHTML 'loose' doctype declaration near the top of the document:: import sys root.write_xhtml(sys.stdout) ... My document
Name Description
Boys Ugly
Girls Pretty
We can also output text in HTML mode, This serializes the node and its children to HTML (this feature was inspired by and based on code Ian Bicking). By default, the serialization will include a 'loose' HTML DTD doctype (this can be overridden with the doctype= argument). "Empty" shortcut elements such as '
' will be converted to a balanced pair of tags e.g. '
'. But some HTML tags (defined as per the HTML 4 spec as area, base, basefont, br, col, frame, hr, img, input, isindex, link, meta, param) will not be followed with a balanced ending tag; only the beginning tag will be output. Additionally, "boolean" tag attributes will not be followed with any value. The "boolean" tags are selected, checked, compact, declare, defer, disabled, ismap, multiple, nohref, noresize, noshade, and nowrap. So the XML input '' will be turned into ''. Additionally, 'script' and 'style' tags will not have their contents escaped (e.g. so "&" will not be turned into '&' when it's iside the textual content of a script or style tag.):: import sys root.write_html(sys.stdout) ... My document
Name Description
Boys Ugly
Girls Pretty
Element API meld3 elements support all of the "ElementTree _ElementInterface API":http://effbot.org/zone/pythondoc-elementtree-ElementTree.htm#elementtree.ElementTree._ElementInterface-class . Other meld-specific methods of elements are as follows:: "clone(parent=None)": clones a node and all of its children via a recursive copy. If parent is passed in, append the clone to the parent node. "findmeld(name, default=None)": searches the this element and its children for elements that have a 'meld:id' attribute that matches "name"; if no element can be found, return the default. "meldid()": Returns the "meld id" of the element or None if the element has no meld id. "repeat(iterable, childname=None)": repeats an element with values from an iterable. If 'childname' is not None, repeat the element on which repeat was called, otherwise find the child element with a 'meld:id' matching 'childname' and repeat that. The element is repeated within its parent element. This method returns an iterable; the value of each iteration is a two-sequence in the form (newelement, data). 'newelement' is a clone of the template element (including clones of its children) which has already been seated in its parent element in the template. 'data' is a value from the passed in iterable. Changing 'newelement' (typically based on values from 'data') mutates the element "in place". "replace(text, structure=False)": (ala ZPT's 'replace' comnand) Replace this element in our parent with a 'Replace' node representing the text 'text'. Return the index of the index position in our parent that was replaced. If 'structure' is true, at rendering time, the outputted text will not be escaped in the serialization. If we have no parent, do nothing, and return None. This method leaves a special kind of node in the element tree (a 'Replace' node) to represent the replacement. NOTE: This command has the potential to cause a non-well-formed XML/HTML serialization at render time if "structure" is True. "content(text, structure=False)": (ala ZPT's 'content' command) Delete every child element in this element and append a Replace node that contains 'text'. Always return None. If 'structure' is true, at rendering time, the outputted text will not be escaped in the serialization. If we have no parent, do nothing, and return None. NOTE: This command has the potential to cause a non-well-formed XML/HTML serialization at render time if "structure" is True. "attributes(**kw)": (ala ZPT's 'attributes' command) For each key value pair in the kw list, add an attribute to this node where the attribute's name is 'key' and the attributes value is 'value'. Keys and values must be string or unicode types, else a ValueError is raised. Returns None. "__mod__(other)": Fill in the text values of meld nodes in this element and children recursively; only support dictionarylike "other" operand (sequence operand doesn't seem to make sense here). "fillmelds(**kw)":Fill in the text values of meld nodes in this element and children recursively. Return the names of keys in the **kw dictionary that could not be found anywhere in the tree. Never raise an exception. "write_xml(file, encoding=None, doctype=None, fragment=False, declaration=True, pipeline=False)": Write XML to 'file' (which can be a filename or filelike object) encoding -- encoding string (if None, 'utf-8' encoding is assumed) Must be a recognizable Python encoding type. doctype -- 3-tuple indicating name, pubid, system of doctype. The default is to prevent a doctype from being emitted. fragment -- True if a 'fragment' should be emitted for this node (no declaration, no doctype). This causes both the 'declaration' and 'doctype' parameters to become ignored if provided. declaration -- emit an xml declaration header (including an encoding if it's not None). The default is to emit the doctype. pipeline -- preserve 'meld' namespace identifiers in output for use in pipelining "write_xhtml(self, file, encoding=None, doctype=doctype.xhtml, fragment=False, declaration=False, pipeline=False)": Write XHTML to 'file' (which can be a filename or filelike object) encoding -- encoding string (if None, 'utf-8' encoding is assumed) Must be a recognizable Python encoding type. doctype -- 3-tuple indicating name, pubid, system of doctype. The default is the value of doctype.xhtml (XHTML 'loose'). fragment -- True if a 'fragment' should be emitted for this node (no declaration, no doctype). This causes both the 'declaration' and 'doctype' parameters to be ignored. declaration -- emit an xml declaration header (including an encoding string if 'encoding' is not None) pipeline -- preserve 'meld' namespace identifiers in output for use in pipelining Note that despite the fact that you can tell meld which doctype to serve, meld does no semantic or syntactical validation of attributes or elements when serving content in XHTML mode; you as a programmer are still responsible for ensuring that your rendering does not include font tags, for instance. Rationale for defaults: By default, 'write_xhtml' doesn't emit an XML declaration because versions of IE before 7 apparently go into "quirks" layout mode when they see an XML declaration, instead of sniffing the DOCTYPE like they do when the xml declaration is not present to determine the layout mode. (see http://hsivonen.iki.fi/doctype/ and http://blogs.msdn.com/ie/archive/2005/09/15/467901.aspx). 'write_xhtml' emits a 'loose' XHTML doctype by default instead of a 'strict' XHTML doctype because 'tidy' emits a 'loose' doctye by default when you convert an HTML document into XHTML via '-asxhtml', and I couldn't think of a good reason to contradict that precedent. A note about emitting the proper Content-Type header when serving pages rendered with write_xhtml: you can sometimes use the content-type 'application/xhtml+xml' (see "http://www.w3.org/TR/xhtml-media-types/#application-xhtml-xml"). The official specification calls for this. But not all browsers support this content type (notably, no version of IE supports it, nor apparently does Safari). So these pages *may* be served using the 'text/html' content type and most browsers will attempt to do doctype sniffing to figure out if the document is actually XHTML. It appears that you can use the Accepts header in the request to figure out if the user agent accepts 'application/xhtml+xml' if you're a stickler for correctness. In practice, this seems like the right thing to do. See "http://keystonewebsites.com/articles/mime_type.php" for more information on serving up the correct content type header. "write_html(self, file, encoding=None, doctype=doctype.html,fragment=False)": Write HTML to 'file' (which can be a filename or filelike object) encoding -- encoding string (if None, 'utf-8' encoding is assumed). Unlike XML output, this is not used in a declaration, but it is used to do actual character encoding during output. Must be a recognizable Python encoding type. doctype -- 3-tuple indicating name, pubid, system of doctype. The default is the value of doctype.html (HTML 4.0 'loose') fragment -- True if a "fragment" should be omitted (no doctype). This overrides any provided "doctype" parameter if provided. Namespace'd elements and attributes have their namespaces removed during output when writing HTML, so pipelining cannot be performed. HTML is not valid XML, so an XML declaration header is never emitted. In general: For all output methods, comments are preserved in output. They are also present in the ElementTree node tree (as Comment elements), so beware. Processing instructions (e.g. '') are completely thrown away at parse time and do not exist anywhere in the element tree or in the output (use the declaration= parameter to emit a declaration processing instruction). Parsing API XML source text is turned into element trees using the "parse_xmlstring" function (demonstrated in examples above). A function that accepts a filename or a filelike object instead of a string, but which performs the same function is named "parse_xml", e.g.:: from meld3 import parse_xml from meld3 import parse_xmlstring HTML source text is turned into element trees using the "parse_htmlstring" function. A function that accepts a filename or a filelike object instead of a string, but which performs the same function is named "parse_html", e.g.:: from meld3 import parse_html from meld3 import parse_htmlstring Using duplicate meld identifiers on separate elements in the source document causes a ValueError to be raised at parse time. When using parse_xml and parse_xmlstring, documents which contain entity references (e.g. ' ') must have the entities defined in the source document or must have a DOCTYPE declaration that allows those entities to be resolved by the expat parser. When using parse_xml and parse_xmlstring, input documents must include the meld3 namespace declaration (conventionally on the root element). For example, '...' parse_html and parse_htmlstring take an optional "encoding" argument which specifies the document source encoding. To Do This implementation depends on classes internal to ElementTree and hasn't been tested with cElementTree or lxml, and almost certainly won't work with either due to this. See TODO.txt for more to-do items. meld3-1.0.2/setup.cfg0000644000076500000240000000013012506600672015263 0ustar mnaberezstaff00000000000000[bdist_wheel] universal = 1 [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 meld3-1.0.2/setup.py0000644000076500000240000000256412506600635015170 0ustar mnaberezstaff00000000000000from setuptools import setup import sys py_version = sys.version_info[:2] if py_version < (2, 5): raise RuntimeError('On Python 2, meld3 requires Python 2.5 or later') elif (3, 0) < py_version < (3, 2): raise RuntimeError('On Python 3, meld3 requires Python 3.2 or later') install_requires = [] CLASSIFIERS = [ 'Development Status :: 5 - Production/Stable', 'Environment :: Web Environment', 'Intended Audience :: Developers', 'Operating System :: POSIX', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.5', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.2', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Topic :: Text Processing :: Markup :: HTML' ] setup( name = 'meld3', version = '1.0.2', description = 'meld3 is an HTML/XML templating engine.', classifiers = CLASSIFIERS, author = 'Chris McDonough', author_email = 'chrism@plope.com', maintainer = "Chris McDonough", maintainer_email = "chrism@plope.com", license = 'BSD-derived (http://www.repoze.org/LICENSE.txt)', install_requires = install_requires, packages = ['meld3'], test_suite = 'meld3', url = 'https://github.com/supervisor/meld3' ) meld3-1.0.2/TODO.txt0000644000076500000240000000207612233342165014760 0ustar mnaberezstaff00000000000000- Document fillmeldhtmlform method. - Preserve xmlns="http://www.w3.org/1999/xhtml" On tags when it's provided in the parsed XML input during xhtml output (or figure out why it makes the XML writer go berserk and output every tag with that qualified namespace, or just output it by default in XHTML mode only if that makes sense). - Revisit . Maybe output an http-equiv content type tag by default matching the serlialization mode. - Investigate why using the "plope.com" namespace identifier is bad. - HTML serializer only calls _escape_cdata/_escape_attrib if necessary instead of calling it without regard to its need. This needs to be done for the XML serializer too.