#!/usr/bin/env python  """ XSL-based form templating.  Copyright (C) 2005 Paul Boddie <paul@boddie.org.uk>  This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.  You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA """  import Constants import libxsltmod, libxml2mod import libxml2dom import urllib  def path_to_node(node, attribute_ref, name, multivalue=0):      """     Generate an XSLForms path to the given 'node', producing an attribute     reference if 'attribute_ref' is true; for example:      /package$1/discriminators$5/discriminator$1/category      Otherwise an element reference is produced; for example:      /package$1/discriminators$5/discriminator$1      Use the given 'name' to complete the path if an attribute reference is     required (and if a genuine attribute is found at the context node -     otherwise 'name' will be None and the context node will be treated like an     attribute).      If 'multivalue' is true and 'attribute_ref' is set, produce an attribute     reference using the given 'name':      /package$1/categories$1/category$$name      If 'multivalue' is true and 'attribute_ref' is not set, produce an attribute     reference using the given 'name' of form (element, attribute):      /package$1/categories$1/element$$attribute     """      l = []     # Skip attribute reference.     if node.nodeType == node.ATTRIBUTE_NODE:         node = node.parentNode     # Manually insert the attribute name if defined.     if attribute_ref:         # A real attribute is referenced.         if name is not None:             l.insert(0, name)             if multivalue:                 l.insert(0, Constants.multi_separator)                 l.insert(0, node.nodeName)                 node = node.parentNode             l.insert(0, Constants.path_separator)         # Otherwise, treat the element name as an attribute name.         # NOTE: Not sure how useful this is.         else:             l.insert(0, node.nodeName)             l.insert(0, Constants.path_separator)             node = node.parentNode     # Otherwise insert any multivalue references (eg. list-attribute).     elif multivalue:         element_name, attribute_name = name         l.insert(0, attribute_name)         l.insert(0, Constants.multi_separator)         l.insert(0, element_name)         l.insert(0, Constants.path_separator)      # Element references.     while node is not None and node.nodeType != node.DOCUMENT_NODE:         l.insert(0, str(int(node.xpath("count(preceding-sibling::*) + 1"))))         l.insert(0, Constants.pair_separator)         l.insert(0, node.nodeName)         l.insert(0, Constants.path_separator)         node = node.parentNode     return "".join(l)  def path_to_context(context, attribute_ref, multivalue_name=None):      """     As a libxslt extension function, return a string containing the XSLForms     path to the 'context' node, using the special "this-name" variable to     complete the path if an attribute reference is required (as indicated by     'attribute_ref' being set to true). If 'multivalue_name' is set, produce a     reference to a multivalued field using the given string as the attribute     name.     """      context = libxml2mod.xmlXPathParserGetContext(context)     transform_context = libxsltmod.xsltXPathGetTransformContext(context)     name_var = libxsltmod.xsltVariableLookup(transform_context, "this-name", None)     if multivalue_name is not None:         name = multivalue_name         multivalue = 1     elif name_var is not None:         name = libxml2mod.xmlNodeGetContent(name_var[0])         name = unicode(name, "utf-8")         multivalue = 0     else:         name = None         multivalue = 0     node = libxml2dom.Node(libxml2mod.xmlXPathGetContextNode(context))     return path_to_node(node, attribute_ref, name, multivalue)  # Exposed extension functions.  def this_element(context):      """     Exposed as {template:this-element()}.     Provides a reference to the current element in the form data structure.     """      #print "this_element"     r = path_to_context(context, 0)     return r.encode("utf-8")  def this_attribute(context):      """     Exposed as {template:this-attribute()}.     Provides a reference to the current attribute in the form data structure.     """      #print "this_attribute"     r = path_to_context(context, 1)     return r.encode("utf-8")  def new_attribute(context, name):      """     Exposed as {template:new-attribute(name)}.     Provides a reference to a new attribute of the given 'name' on the current     element in the form data structure.     """      #print "new_attribute"     name = unicode(name, "utf-8")     r = path_to_context(context, 0) + "/" + name     return r.encode("utf-8")  def other_elements(context, nodes):      """     Exposed as {template:other-elements(nodes)}.     Provides a reference to other elements in the form data structure according     to the specified 'nodes' parameter (an XPath expression in the template).     """      #print "other_elements"     names = []     for node in nodes:         name = path_to_node(libxml2dom.Node(node), 0, None, 0)         if name not in names:             names.append(name)     r = ",".join(names)     return r.encode("utf-8")  def list_attribute(context, element_name, attribute_name):      """     Exposed as {template:list-attribute(element_name, attribute_name)}.     Provides a reference to one or many elements of the given 'element_name'     found under the current element in the form data structure having     attributes with the given 'attribute_name'.     """      #print "list_attribute"     element_name = unicode(element_name, "utf-8")     attribute_name = unicode(attribute_name, "utf-8")     r = path_to_context(context, 0, (element_name, attribute_name))     return r.encode("utf-8")  def other_list_attributes(context, element_name, attribute_name, nodes):      """     Exposed as {template:other-list-attributes(element_name, attribute_name, nodes)}.     Provides a reference to other elements in the form data structure, found     under the specified 'nodes' (described using an XPath expression in the     template) having the given 'element_name' and bearing attributes of the     given 'attribute_name'.     """      #print "other_list_attributes"     element_name = unicode(element_name, "utf-8")     attribute_name = unicode(attribute_name, "utf-8")     names = []     for node in nodes:         name = path_to_node(libxml2dom.Node(node), 0, (element_name, attribute_name), 1)         if name not in names:             names.append(name)     r = ",".join(names)     return r.encode("utf-8")  def other_attributes(context, attribute_name, nodes):      """     Exposed as {template:other-attributes(name, nodes)}.     Provides a reference to attributes in the form data structure of the given     'attribute_name' residing on the specified 'nodes' (described using an XPath     expression in the template).     """      #print "other_attributes"     attribute_name = unicode(attribute_name, "utf-8")     # NOTE: Cannot directly reference attributes in the nodes list because     # NOTE: libxml2dom does not yet support parent element discovery on     # NOTE: attributes.     names = []     for node in nodes:         name = path_to_node(libxml2dom.Node(node), 1, attribute_name, 0)         if name not in names:             names.append(name)     r = ",".join(names)     return r.encode("utf-8")  def child_element(context, element_name, position, node_paths):      """     Exposed as {template:child-element(element_name, position, node_paths)}.     Provides relative paths to the specifed 'element_name', having the given     'position' (1-based) under each element specified in 'node_paths' (provided     by calls to other extension functions in the template). For example:      template:child-element('comment', 1, template:this-element()) -> '.../comment$1'     """      element_name = unicode(element_name, "utf-8")     l = []     for node_path in node_paths.split(","):         l.append(node_path + Constants.path_separator + element_name             + Constants.pair_separator + str(int(position)))     return ",".join(l).encode("utf-8")  def child_attribute(context, attribute_name, node_paths):      """     Exposed as {template:child-attribute(attribute_name, node_paths)}.     Provides a relative path to the specifed 'attribute_name' for each element     specified in 'node_paths' (provided by calls to other extension functions in     the template). For example:      template:child-attribute('value', template:this-element()) -> '.../value'     """      attribute_name = unicode(attribute_name, "utf-8")     l = []     for node_path in node_paths.split(","):         l.append(node_path + Constants.path_separator + attribute_name)     return ",".join(l).encode("utf-8")  # Old implementations.  def multi_field_name(context, multivalue_name):     #print "multi_field_name"     multivalue_name = unicode(multivalue_name, "utf-8")     r = path_to_context(context, 1, multivalue_name)     return r.encode("utf-8")  def other_multi_field_names(context, multivalue_name, nodes):     #print "other_multi_field_names"     multivalue_name = unicode(multivalue_name, "utf-8")     names = []     for node in nodes:         name = path_to_node(libxml2dom.Node(node), 1, multivalue_name, 1)         if name not in names:             names.append(name)     r = ",".join(names)     return r.encode("utf-8")  # Utility functions.  def url_encode(context, nodes, charset="utf-8"):      """     Exposed as {template:url-encode(nodes)}.     Provides a "URL encoded" string created from the merged textual contents of     the given 'nodes', with the encoded character values representing characters     in the optional 'charset' (UTF-8 if not specified).      template:url-encode(./text(), 'iso-8859-1')     """      l = []     for node in nodes:         s = libxml2dom.Node(node).nodeValue         l.append(urllib.quote(s.encode("utf-8")).replace("/", "%2F"))     output = "".join(l)     return output  def element_path(context, field_names):      """     Convert the given 'field_names' back to XPath references.     For example:     /configuration$1/details$1/base-system$$value -> /*[position() = 1]/*[position() = 1]/base-system     If more than one field name is given - ie. 'field_names' contains a     comma-separated list of names - then only the first name is used.     """      field_name = field_names.split(",")[0]      # Get the main part of the name (where a multivalue reference was given).      field_name = get_field_name(field_name)      # Build the XPath expression.      parts = field_name.split(Constants.path_separator)     new_parts = []     for part in parts:         path_parts = part.split(Constants.pair_separator)         if len(path_parts) == 2:             new_parts.append("*[position() = " + path_parts[1] + "]")         else:             new_parts.append(path_parts[0])     return "/".join(new_parts)  # New functions.  libxsltmod.xsltRegisterExtModuleFunction("list-attribute", "http://www.boddie.org.uk/ns/xmltools/template", list_attribute) libxsltmod.xsltRegisterExtModuleFunction("other-list-attributes", "http://www.boddie.org.uk/ns/xmltools/template", other_list_attributes) libxsltmod.xsltRegisterExtModuleFunction("other-attributes", "http://www.boddie.org.uk/ns/xmltools/template", other_attributes) libxsltmod.xsltRegisterExtModuleFunction("child-element", "http://www.boddie.org.uk/ns/xmltools/template", child_element) libxsltmod.xsltRegisterExtModuleFunction("child-attribute", "http://www.boddie.org.uk/ns/xmltools/template", child_attribute)  # New names.  libxsltmod.xsltRegisterExtModuleFunction("this-element", "http://www.boddie.org.uk/ns/xmltools/template", this_element) libxsltmod.xsltRegisterExtModuleFunction("this-attribute", "http://www.boddie.org.uk/ns/xmltools/template", this_attribute) libxsltmod.xsltRegisterExtModuleFunction("new-attribute", "http://www.boddie.org.uk/ns/xmltools/template", new_attribute) libxsltmod.xsltRegisterExtModuleFunction("other-elements", "http://www.boddie.org.uk/ns/xmltools/template", other_elements)  # Old names.  libxsltmod.xsltRegisterExtModuleFunction("this-position", "http://www.boddie.org.uk/ns/xmltools/template", this_element) libxsltmod.xsltRegisterExtModuleFunction("field-name", "http://www.boddie.org.uk/ns/xmltools/template", this_attribute) libxsltmod.xsltRegisterExtModuleFunction("new-field", "http://www.boddie.org.uk/ns/xmltools/template", new_attribute) libxsltmod.xsltRegisterExtModuleFunction("other-field-names", "http://www.boddie.org.uk/ns/xmltools/template", other_elements)  # Old functions.  libxsltmod.xsltRegisterExtModuleFunction("multi-field-name", "http://www.boddie.org.uk/ns/xmltools/template", multi_field_name) libxsltmod.xsltRegisterExtModuleFunction("other-multi-field-names", "http://www.boddie.org.uk/ns/xmltools/template", other_multi_field_names)  # Utility functions.  libxsltmod.xsltRegisterExtModuleFunction("url-encode", "http://www.boddie.org.uk/ns/xmltools/template", url_encode) libxsltmod.xsltRegisterExtModuleFunction("element-path", "http://www.boddie.org.uk/ns/xmltools/template", element_path)  def get_field_name(field_or_multi_name):     return field_or_multi_name.split(Constants.multi_separator)[0]  # vim: tabstop=4 expandtab shiftwidth=4