Task 845: .XSL File Format

1. Properties of the .XSL File Format Intrinsic to Its File System

The .XSL file format refers to Extensible Stylesheet Language (XSL) files, which are XML-based stylesheets primarily used for XSL Transformations (XSLT). These files adhere to the W3C XSLT specification, typically version 2.0 or later, and are text-based rather than binary. The format is governed by XML rules, with no fixed binary magic number or file system-specific intrinsics beyond standard XML encoding (e.g., UTF-8). Properties are derived from the document structure and do not involve low-level file system attributes like clusters or inodes; instead, they pertain to the XML schema and XSLT semantics.

The key properties include:

• Document Type: A well-formed XML document conforming to the Namespaces in XML recommendation.
• Root Element: Either <xsl:stylesheet> or <xsl:transform> (synonymous).
• Namespace URI: http://www.w3.org/1999/XSL/Transform (must be declared on the root element).
• Version Attribute: Required on the root element; a decimal number (e.g., 2.0), controlling compatibility modes (backwards for <2.0, standard for 2.0, forwards for >2.0).
• Media Type: application/xslt+xml.
• Top-Level Declarations: Direct children of the root, including xsl:import (with href attribute, must precede others), xsl:include (with href), xsl:attribute-set (with name), xsl:character-map (with name), xsl:decimal-format (with name), xsl:function (with name and optional as), xsl:import-schema (with href), xsl:key (with name, match, use), xsl:namespace-alias (with stylesheet-prefix, result-prefix), xsl:output (with attributes like method, encoding, indent), xsl:param (global, with name, select, as), xsl:preserve-space (with elements), xsl:strip-space (with elements), xsl:template (with match or name), xsl:variable (global, with name, select, as), and user-defined data elements in non-null namespaces.
• Standard Attributes on Elements: id (optional identifier), extension-element-prefixes (list of prefixes for extensions), exclude-result-prefixes (list of excluded prefixes), xpath-default-namespace (default for unprefixed QNames), default-collation (list of collation URIs), default-validation (preserve or strip), input-type-annotations (preserve, strip, or unspecified), use-when (XPath expression for conditional inclusion), and element-specific attributes like href on imports/includes.
• Namespace Rules: All XSLT elements in the specified URI; reserved namespaces (e.g., XPath functions) cannot define stylesheet objects; extensions in separate namespaces.
• Whitespace Handling: Stripped per xsl:strip-space/xsl:preserve-space; xml:space="preserve" overrides.
• Modularity: Supports import/include with precedence and cycle detection.
• Conditional Inclusion: Via use-when attribute, evaluated statically.
• Error Conditions: Static (e.g., missing version, duplicates) and dynamic (e.g., type errors).
• Output Control: Via xsl:output for serialization (e.g., method: xml/html/text).
• Type System: Optional as attributes using XPath SequenceTypes.
• Extensibility: Extension elements/attributes in declared namespaces.

These properties ensure the file can transform XML documents consistently across processors.

2. Direct Download Links for .XSL Files

Two direct download links for example .XSL (XSLT stylesheet) files are provided below. These are raw files from public repositories, suitable for testing:

• https://raw.githubusercontent.com/chb/sample_ccdas/master/CDA.xsl
• https://raw.githubusercontent.com/ncbi/JATSPreviewStylesheets/master/xslt/main/jats-html.xsl

3. HTML/JavaScript for Drag-and-Drop .XSL File Viewer

The following is a self-contained HTML document with embedded JavaScript that can be embedded in a blog post (e.g., on Ghost or similar platforms). It enables users to drag and drop a .XSL file, parses it as XML, extracts the properties listed in section 1, and displays them on the screen. The code uses the browser's DOMParser for XML parsing and assumes modern browser support.

This code handles file input securely in the browser, parses the XML, extracts representative properties, and outputs them as text.

4. Python Class for .XSL File Handling

The following Python class uses the xml.etree.ElementTree module to open, parse (decode), read properties, print them to console, and write the file (with optional modifications). It assumes Python 3.12+.

import xml.etree.ElementTree as ET

class XSLHandler:
    def __init__(self, file_path):
        self.file_path = file_path
        self.tree = ET.parse(file_path)
        self.root = self.tree.getroot()
        self.ns = {'xsl': 'http://www.w3.org/1999/XSL/Transform'}

    def get_properties(self):
        props = {
            'Document Type': 'Well-formed XML',
            'Root Element': self.root.tag.split('}')[-1] if '}' in self.root.tag else self.root.tag,
            'Namespace URI': self.root.nsmap.get('xsl', 'Not declared'),
            'Version Attribute': self.root.attrib.get('version', 'Not specified'),
            'Media Type': 'application/xslt+xml (inferred)',
            'Imported Stylesheets': [el.attrib.get('href', 'None') for el in self.root.findall('xsl:import', self.ns)],
            'Included Stylesheets': [el.attrib.get('href', 'None') for el in self.root.findall('xsl:include', self.ns)],
            'Global Variables': [el.attrib.get('name', 'Unnamed') for el in self.root.findall('xsl:variable', self.ns)],
            'Global Parameters': [el.attrib.get('name', 'Unnamed') for el in self.root.findall('xsl:param', self.ns)],
            'Templates': [el.attrib.get('match') or el.attrib.get('name', 'Unnamed') for el in self.root.findall('xsl:template', self.ns)],
            'Output Method': self.root.find('xsl:output', self.ns).attrib.get('method', 'Not specified') if self.root.find('xsl:output', self.ns) else 'Not specified',
        }
        return props

    def print_properties(self):
        props = self.get_properties()
        for key, value in props.items():
            if isinstance(value, list):
                print(f"{key}: {', '.join(map(str, value))}")
            else:
                print(f"{key}: {value}")

    def write(self, output_path=None, modify_example=False):
        if modify_example:
            # Example modification: Add a comment
            comment = ET.Comment('Modified by XSLHandler')
            self.root.insert(0, comment)
        if not output_path:
            output_path = self.file_path
        self.tree.write(output_path, encoding='utf-8', xml_declaration=True)

# Example usage:
# handler = XSLHandler('example.xsl')
# handler.print_properties()
# handler.write('modified.xsl', modify_example=True)

This class decodes the XML structure, reads and prints properties, and supports writing with optional changes.

5. Java Class for .XSL File Handling

The following Java class uses javax.xml.parsers.DocumentBuilder to parse the XML, extract properties, print to console, and write using Transformer. It requires Java 8+.

import org.w3c.dom.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.*;
import java.util.*;

public class XSLHandler {
    private Document doc;
    private String filePath;

    public XSLHandler(String filePath) throws Exception {
        this.filePath = filePath;
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        DocumentBuilder builder = factory.newDocumentBuilder();
        doc = builder.parse(new File(filePath));
    }

    public Map<String, Object> getProperties() {
        Map<String, Object> props = new LinkedHashMap<>();
        Element root = doc.getDocumentElement();
        props.put("Document Type", "Well-formed XML");
        props.put("Root Element", root.getLocalName());
        props.put("Namespace URI", root.getNamespaceURI() != null ? root.getNamespaceURI() : "Not declared");
        props.put("Version Attribute", root.getAttribute("version").isEmpty() ? "Not specified" : root.getAttribute("version"));
        props.put("Media Type", "application/xslt+xml (inferred)");

        List<String> imports = new ArrayList<>();
        NodeList importNodes = root.getElementsByTagNameNS("http://www.w3.org/1999/XSL/Transform", "import");
        for (int i = 0; i < importNodes.getLength(); i++) {
            imports.add(((Element) importNodes.item(i)).getAttribute("href"));
        }
        props.put("Imported Stylesheets", imports);

        List<String> includes = new ArrayList<>();
        NodeList includeNodes = root.getElementsByTagNameNS("http://www.w3.org/1999/XSL/Transform", "include");
        for (int i = 0; i < includeNodes.getLength(); i++) {
            includes.add(((Element) includeNodes.item(i)).getAttribute("href"));
        }
        props.put("Included Stylesheets", includes);

        List<String> variables = new ArrayList<>();
        NodeList varNodes = root.getElementsByTagNameNS("http://www.w3.org/1999/XSL/Transform", "variable");
        for (int i = 0; i < varNodes.getLength(); i++) {
            variables.add(((Element) varNodes.item(i)).getAttribute("name"));
        }
        props.put("Global Variables", variables);

        List<String> params = new ArrayList<>();
        NodeList paramNodes = root.getElementsByTagNameNS("http://www.w3.org/1999/XSL/Transform", "param");
        for (int i = 0; i < paramNodes.getLength(); i++) {
            params.add(((Element) paramNodes.item(i)).getAttribute("name"));
        }
        props.put("Global Parameters", params);

        List<String> templates = new ArrayList<>();
        NodeList tempNodes = root.getElementsByTagNameNS("http://www.w3.org/1999/XSL/Transform", "template");
        for (int i = 0; i < tempNodes.getLength(); i++) {
            Element el = (Element) tempNodes.item(i);
            templates.add(el.getAttribute("match") != null ? el.getAttribute("match") : el.getAttribute("name"));
        }
        props.put("Templates", templates);

        Node outputNode = root.getElementsByTagNameNS("http://www.w3.org/1999/XSL/Transform", "output").item(0);
        props.put("Output Method", outputNode != null ? ((Element) outputNode).getAttribute("method") : "Not specified");

        return props;
    }

    public void printProperties() {
        Map<String, Object> props = getProperties();
        for (Map.Entry<String, Object> entry : props.entrySet()) {
            if (entry.getValue() instanceof List) {
                System.out.println(entry.getKey() + ": " + String.join(", ", (List<String>) entry.getValue()));
            } else {
                System.out.println(entry.getKey() + ": " + entry.getValue());
            }
        }
    }

    public void write(String outputPath, boolean modifyExample) throws Exception {
        if (modifyExample) {
            // Example modification: Add a comment
            Comment comment = doc.createComment("Modified by XSLHandler");
            doc.getDocumentElement().insertBefore(comment, doc.getDocumentElement().getFirstChild());
        }
        if (outputPath == null) {
            outputPath = filePath;
        }
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer transformer = tf.newTransformer();
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
        transformer.transform(new DOMSource(doc), new StreamResult(new File(outputPath)));
    }

    // Example usage:
    // public static void main(String[] args) throws Exception {
    //     XSLHandler handler = new XSLHandler("example.xsl");
    //     handler.printProperties();
    //     handler.write("modified.xsl", true);
    // }
}

This class handles parsing, property extraction, console printing, and file writing with optional modifications.

6. JavaScript Class for .XSL File Handling

The following JavaScript class (Node.js compatible) uses the xmldom package for parsing (assume installed via npm). It opens, parses, extracts properties, prints to console, and writes using fs.

const fs = require('fs');
const { DOMParser, XMLSerializer } = require('xmldom');

class XSLHandler {
    constructor(filePath) {
        this.filePath = filePath;
        const data = fs.readFileSync(filePath, 'utf-8');
        const parser = new DOMParser();
        this.doc = parser.parseFromString(data, 'application/xml');
        this.ns = 'http://www.w3.org/1999/XSL/Transform';
    }

    getProperties() {
        const root = this.doc.documentElement;
        const props = {
            'Document Type': 'Well-formed XML',
            'Root Element': root.tagName,
            'Namespace URI': root.namespaceURI || 'Not declared',
            'Version Attribute': root.getAttribute('version') || 'Not specified',
            'Media Type': 'application/xslt+xml (inferred)',
            'Imported Stylesheets': Array.from(root.getElementsByTagNameNS(this.ns, 'import')).map(el => el.getAttribute('href') || 'None'),
            'Included Stylesheets': Array.from(root.getElementsByTagNameNS(this.ns, 'include')).map(el => el.getAttribute('href') || 'None'),
            'Global Variables': Array.from(root.getElementsByTagNameNS(this.ns, 'variable')).map(el => el.getAttribute('name') || 'Unnamed'),
            'Global Parameters': Array.from(root.getElementsByTagNameNS(this.ns, 'param')).map(el => el.getAttribute('name') || 'Unnamed'),
            'Templates': Array.from(root.getElementsByTagNameNS(this.ns, 'template')).map(el => el.getAttribute('match') || el.getAttribute('name') || 'Unnamed'),
            'Output Method': root.getElementsByTagNameNS(this.ns, 'output')[0]?.getAttribute('method') || 'Not specified',
        };
        return props;
    }

    printProperties() {
        const props = this.getProperties();
        for (const [key, value] of Object.entries(props)) {
            if (Array.isArray(value)) {
                console.log(`${key}: ${value.join(', ')}`);
            } else {
                console.log(`${key}: ${value}`);
            }
        }
    }

    write(outputPath = null, modifyExample = false) {
        if (modifyExample) {
            // Example modification: Add a comment
            const comment = this.doc.createComment('Modified by XSLHandler');
            this.doc.documentElement.insertBefore(comment, this.doc.documentElement.firstChild);
        }
        if (!outputPath) {
            outputPath = this.filePath;
        }
        const serializer = new XMLSerializer();
        const xmlStr = serializer.serializeToString(this.doc);
        fs.writeFileSync(outputPath, xmlStr, 'utf-8');
    }
}

// Example usage:
// const handler = new XSLHandler('example.xsl');
// handler.printProperties();
// handler.write('modified.xsl', true);

This class supports server-side operations, including parsing, printing, and writing.

7. C++ Class for .XSL File Handling

The following C++ class uses the TinyXML-2 library (assume included via header) for XML parsing. It opens, parses, extracts properties, prints to console, and writes the file. Compile with -std=c++11 or later.

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include "tinyxml2.h"  // Assume tinyxml2.h is included

using namespace tinyxml2;
using namespace std;

class XSLHandler {
private:
    string filePath;
    XMLDocument doc;
    const char* ns = "http://www.w3.org/1999/XSL/Transform";

public:
    XSLHandler(const string& filePath) : filePath(filePath) {
        doc.LoadFile(filePath.c_str());
    }

    map<string, variant<string, vector<string>>> getProperties() {
        map<string, variant<string, vector<string>>> props;
        XMLElement* root = doc.RootElement();
        props["Document Type"] = "Well-formed XML"s;
        props["Root Element"] = root->Name();
        props["Namespace URI"] = root->GetDocument()->GetErrorID() == 0 ? ns : "Not declared"s;
        props["Version Attribute"] = root->Attribute("version") ? root->Attribute("version") : "Not specified"s;
        props["Media Type"] = "application/xslt+xml (inferred)"s;

        vector<string> imports;
        for (XMLElement* el = root->FirstChildElement("import"); el; el = el->NextSiblingElement("import")) {
            imports.push_back(el->Attribute("href") ? el->Attribute("href") : "None");
        }
        props["Imported Stylesheets"] = imports;

        vector<string> includes;
        for (XMLElement* el = root->FirstChildElement("include"); el; el = el->NextSiblingElement("include")) {
            includes.push_back(el->Attribute("href") ? el->Attribute("href") : "None");
        }
        props["Included Stylesheets"] = includes;

        vector<string> variables;
        for (XMLElement* el = root->FirstChildElement("variable"); el; el = el->NextSiblingElement("variable")) {
            variables.push_back(el->Attribute("name") ? el->Attribute("name") : "Unnamed");
        }
        props["Global Variables"] = variables;

        vector<string> params;
        for (XMLElement* el = root->FirstChildElement("param"); el; el = el->NextSiblingElement("param")) {
            params.push_back(el->Attribute("name") ? el->Attribute("name") : "Unnamed");
        }
        props["Global Parameters"] = params;

        vector<string> templates;
        for (XMLElement* el = root->FirstChildElement("template"); el; el = el->NextSiblingElement("template")) {
            const char* match = el->Attribute("match");
            const char* name = el->Attribute("name");
            templates.push_back(match ? match : (name ? name : "Unnamed"));
        }
        props["Templates"] = templates;

        XMLElement* output = root->FirstChildElement("output");
        props["Output Method"] = output && output->Attribute("method") ? output->Attribute("method") : "Not specified"s;

        return props;
    }

    void printProperties() {
        auto props = getProperties();
        for (const auto& [key, val] : props) {
            if (holds_alternative<vector<string>>(val)) {
                const auto& list = get<vector<string>>(val);
                cout << key << ": ";
                for (size_t i = 0; i < list.size(); ++i) {
                    cout << list[i] << (i < list.size() - 1 ? ", " : "");
                }
                cout << endl;
            } else {
                cout << key << ": " << get<string>(val) << endl;
            }
        }
    }

    void write(const string& outputPath = "", bool modifyExample = false) {
        string path = outputPath.empty() ? filePath : outputPath;
        if (modifyExample) {
            // Example modification: Add a comment
            XMLComment* comment = doc.NewComment("Modified by XSLHandler");
            doc.RootElement()->InsertFirstChild(comment);
        }
        doc.SaveFile(path.c_str());
    }
};

// Example usage:
// int main() {
//     XSLHandler handler("example.xsl");
//     handler.printProperties();
//     handler.write("modified.xsl", true);
//     return 0;
// }

This class provides equivalent functionality in C++, using TinyXML-2 for XML operations.