public static void Transform(Uri StyleSheet, String Input,Encoding Encoding,out String Output)
{
Processor processor = new Processor();
XdmNode input = processor.NewDocumentBuilder().Build(new XmlTextReader(new StringReader(Input)));
processor.SetProperty("http://saxon.sf.net/feature/preferJaxpParser", "true");
XsltCompiler compiler = processor.NewXsltCompiler();
XsltExecutable executable = compiler.Compile(StyleSheet);
XsltTransformer transformer = executable.Load();
transformer.InitialContextNode = input;
Serializer serializer = new Serializer();
MemoryStream stream = new MemoryStream();
System.IO.StreamWriter writer = new StreamWriter(stream);
serializer.SetOutputWriter(writer);
transformer.Run(serializer);
Output = Encoding.GetString(stream.ToArray());
writer.Close();
stream.Close();
}
static void Main(string[] args)
{
String s1 = @"<xsl:stylesheet version='2.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'><xsl:output method='xml' indent='yes'/><xsl:template match='/'>";
String s2 = "This is running an XSLT engine by <xsl:value-of select=\"system-property('xsl:vendor')\" /> <a href=\"{system-property('xsl:vendor-url')}\"><xsl:value-of select=\"system-property('xsl:vendor-url')\" /></a> implementing XSLT v<xsl:value-of select=\"system-property('xsl:version')\" /> ";
String s3 = @"\n<xsl:apply-templates/></xsl:template><xsl:template match='@*|node()'> ";
String s4 = @"<xsl:copy><xsl:apply-templates select='@*|node()'/></xsl:copy></xsl:template></xsl:stylesheet>";
String str = s1 + s2 + s3 + s4;
//Run Saxon
//new SaxonTransform().doTransform(args, "Transform");
//Run Saxon s9 api
// Create a Processor instance.
Processor processor = new Processor();
// Load the source document.
XdmNode input = processor.NewDocumentBuilder().Build(XmlReader.Create(new StringReader(str)));
XsltCompiler compiler = processor.NewXsltCompiler();
//although it is not required in this example, we need to set otherwise exception will be thrown
compiler.BaseUri = new Uri("http://dummyurl.com");
// Create a transformer for the stylesheet.
XsltTransformer transformer = compiler.Compile(XmlReader.Create(new StringReader(str))).Load();
// BaseOutputUri is only necessary for xsl:result-document.
//transformer.BaseOutputUri = new Uri("http://dummyurl.com");
// Set the root node of the source document to be the initial context node.
transformer.InitialContextNode = input;
transformer.SetParameter(new QName("", "", "maxmin"), new XdmAtomicValue("parm1"));
transformer.SetParameter(new QName("", "", "pricestock"), new XdmAtomicValue("parm2"));
// Create a serializer.
Serializer serializer = new Serializer();
// Set the root node of the source document to be the initial context node
//transformer.InitialTemplate = new QName("","","go");
serializer.SetOutputWriter(Console.Out);
serializer.SetOutputProperty(Serializer.INDENT, "yes");
// serializer.SetOutputFile(Server.MapPath("test.html")); //for file
// Transform the source XML to System.out.
transformer.Run(serializer);
//Call the SaxonMediator
SaxonMediator mediator = new SaxonMediator();
//mediator.Transform(null, Template template, Package package)
//wait for user to exit
Console.ReadLine();
}
public static void Transform(String StylesheetFilename, String SourceFilename, String OutputFilename)
{
if (StylesheetFilename.StartsWith(".\\"))
{
StylesheetFilename = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\" + StylesheetFilename;
}
Processor processor = new Processor();
XdmNode input = processor.NewDocumentBuilder().Build(new Uri(SourceFilename));
processor.SetProperty("http://saxon.sf.net/feature/preferJaxpParser", "true");
XsltCompiler compiler = processor.NewXsltCompiler();
XsltExecutable executable = compiler.Compile(new Uri(StylesheetFilename));
XsltTransformer transformer = executable.Load();
transformer.InitialContextNode = input;
Serializer serializer = new Serializer();
System.IO.StreamWriter stream = new StreamWriter(OutputFilename);
serializer.SetOutputWriter(stream);
transformer.Run(serializer);
stream.Close();
}
public string Transform(string baseDir, string sourceXml, string releaseType, string version)
{
var sourceXsl = SchematronBuilder.CheckForNewerSchematron(baseDir, releaseType, version);
// Create a Processor instance.
var processor = new Processor();
var result = new StringBuilder();
var xmlDocumentBuilder = processor.NewDocumentBuilder();
xmlDocumentBuilder.BaseUri = new Uri(baseDir);
var xsltCompiler = processor.NewXsltCompiler();
xsltCompiler.ErrorList = new ArrayList();
var xmlToValidate = xmlDocumentBuilder.Build(new StringReader(sourceXml));
var compiledXsl = xsltCompiler.Compile(new XmlTextReader(sourceXsl));
var xmlValidator = compiledXsl.Load();
// Set the root node of the source document to be the initial context node.
xmlValidator.InitialContextNode = xmlToValidate;
// BaseOutputUri is only necessary for xsl:result-document.
xmlValidator.BaseOutputUri = new Uri(Path.Combine(baseDir, "output.xml"));
var validationSerializer = new Serializer();
using (var resultsWriter = new StringWriter(result))
{
validationSerializer.SetOutputWriter(resultsWriter);
xmlValidator.Run(validationSerializer);
}
return result.ToString();
}
public void Process (HttpContext context, TextWriter writer) {
HttpRequest Request = context.Request;
HttpResponse Response = context.Response;
String sourceUri = context.Server.MapPath(Request.RawUrl);
Uri sUri = new Uri(sourceUri);
if (!this._IS_INITIALIZED) Init(context);
using (Stream sXml = (Stream)this._Resolver.GetEntity(sUri, null, typeof(Stream))) {
using (_TemplateStream) {
DocumentBuilder builder = _Processor.NewDocumentBuilder();
builder.BaseUri = sUri;
XdmNode input = builder.Build(sXml);
Serializer mySerializer = new Serializer();
mySerializer.SetOutputWriter(writer);
XsltTransformer myTransformer = this._Template.Load();
myTransformer.InputXmlResolver = this._Resolver;
myTransformer.InitialContextNode = input;
myTransformer.Run(mySerializer);
}
}
}
public void GenXML()
{
String sourceUri = Server.MapPath("5648.xml");
String xqUri = Server.MapPath("graph.xq");
using (FileStream sXml = File.OpenRead(sourceUri))
{
using (FileStream sXq = File.OpenRead(xqUri))
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = sourceUri;
XQueryExecutable exp = compiler.Compile(sXq);
XQueryEvaluator eval = exp.Load();
DocumentBuilder loader = processor.NewDocumentBuilder();
loader.BaseUri = new Uri(sourceUri);
XdmNode indoc = loader.Build(new FileStream(sourceUri, FileMode.Open, FileAccess.Read));
eval.ContextItem = indoc;
Serializer qout = new Serializer();
qout.SetOutputProperty(Serializer.METHOD, "xml");
qout.SetOutputProperty(Serializer.INDENT, "yes");
qout.SetOutputProperty(Serializer.SAXON_INDENT_SPACES, "1");
qout.SetOutputWriter(Response.Output);
eval.Run(qout);
}
}
}
/// <summary>
/// Create a Serializer initialized to write to a given Writer.
/// Closing the writer after use is the responsibility of the caller.
/// </summary>
/// <param name="textWriter">writer The TextWriter to which the Serializer will write</param>
/// <returns> a new Serializer </returns>
public Serializer NewSerializer(TextWriter textWriter)
{
Serializer s = new Serializer();
s.SetProcessor(this);
s.SetOutputWriter(textWriter);
return(s);
}
private string xml2HtmlTree()
{
XmlDocument xml = new XmlDocument();
xml.LoadXml(this.Xsd);
StreamReader xsl = new StreamReader(AppDomain.CurrentDomain.BaseDirectory + "/Areas/MSM/Resources/Stylesheets/xsd2htmlTree.xslt");
Processor processor = new Processor();
XdmNode input = processor.NewDocumentBuilder().Build(xml);
XsltTransformer transformer = processor.NewXsltCompiler().Compile(xsl).Load();
transformer.InitialContextNode = input;
StringWriter writer = new StringWriter();
Serializer serializer = new Serializer();
serializer.SetOutputWriter(writer);
transformer.Run(serializer);
return writer.ToString();
}
/// <summary>
/// Run an XSLT transformation producing multiple output documents
/// </summary>
public override void run(Uri samplesDir)
{
// Create a Processor instance.
Processor processor = new Processor();
processor.SetProperty("http://saxon.sf.net/feature/timing", "true");
// Load the source document
XdmNode input = processor.NewDocumentBuilder().Build(new Uri(samplesDir, "data/othello.xml"));
// Create a transformer for the stylesheet.
XsltTransformer transformer = processor.NewXsltCompiler().Compile(new Uri(samplesDir, "styles/play.xsl")).Load();
// Set the root node of the source document to be the initial context node
transformer.InitialContextNode = input;
// Set the required stylesheet parameter
transformer.SetParameter(new QName("", "", "dir"), new XdmAtomicValue(samplesDir.ToString() + "play"));
// Create a serializer
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
// Transform the source XML to System.out.
transformer.Run(serializer);
}
/// <summary>
/// Show a transformation using calls to extension functions
/// </summary>
public override void run(Uri samplesDir)
{
// Create a Processor instance.
Processor processor = new Processor();
// Identify the Processor version
Console.WriteLine(processor.ProductVersion);
// Set diagnostics
//processor.SetProperty("http://saxon.sf.net/feature/trace-external-functions", "true");
// Create the stylesheet
String s = @"<xsl:transform version='2.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'" +
@" xmlns:math='http://example.math.co.uk/demo'> " +
@" <xsl:template name='go'> " +
@" <out sqrt2='{math:sqrt(2.0e0)}' " +
@" sqrtEmpty='{math:sqrt(())}'/> " +
@" </xsl:template></xsl:transform>";
// Register the integrated extension function math:sqrt
processor.RegisterExtensionFunction(new Sqrt());
// Create a transformer for the stylesheet.
XsltTransformer transformer = processor.NewXsltCompiler().Compile(new StringReader(s)).Load();
// Set the root node of the source document to be the initial context node
transformer.InitialTemplate = new QName("go");
// Create a serializer
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
serializer.SetOutputProperty(Serializer.INDENT, "yes");
// Transform the source XML to System.out.
transformer.Run(serializer);
}
/// <summary>
/// Demonstrate XSLT extensibility using user-written extension functions
/// </summary>
/// <remarks>Note: If SamplesExtensions is compiled to a different assembly than ExamplesPE, use
/// the namespace URI clitype:SampleExtensions.SampleExtensions?asm=ASSEMBLY_NAME_HERE
/// </remarks>
public override void run(Uri samplesDir)
{
// Create a Processor instance.
Processor processor = new Processor();
// Identify the Processor version
Console.WriteLine(processor.ProductVersion);
// Set diagnostics
//processor.SetProperty("http://saxon.sf.net/feature/trace-external-functions", "true");
// Create the stylesheet
String s = @"<xsl:transform version='2.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'" +
@" xmlns:ext='clitype:SampleExtensions.SampleExtensions?asm=ExamplesPE' " +
@" xmlns:tz='clitype:System.TimeZone' " +
@" xmlns:math='http://example.math.co.uk/demo' " +
@" xmlns:env='http://example.env.co.uk/demo' " +
@" exclude-result-prefixes='ext math env tz'> " +
@" <xsl:param name='timezone' required='yes'/> " +
@" <xsl:template match='/'> " +
@" <out addition='{ext:add(2,2)}' " +
@" average='{ext:average((1,2,3,4,5,6))}' " +
@" firstchild='{ext:nameOfFirstChild(.)}' " +
@" timezone='{tz:StandardName($timezone)}' " +
@" sqrt2='{math:sqrt(2.0e0)}' " +
@" defaultNamespace='{env:defaultNamespace()}' " +
@" sqrtEmpty='{math:sqrt(())}'> " +
@" <xsl:copy-of select='ext:FirstChild((//ITEM)[1])'/> " +
@" <defaultNS value='{env:defaultNamespace()}' xsl:xpath-default-namespace='http://default.namespace.com/' /> " +
@" <combine1><xsl:sequence select='ext:combine(ext:FirstChild((//ITEM)[1]), count(*))'/></combine1> " +
@" <combine2><xsl:sequence select='ext:combine((//TITLE)[1], (//AUTHOR)[1])'/></combine2> " +
@" </out> " +
@" </xsl:template></xsl:transform>";
// Register the integrated extension functions math:sqrt and env:defaultNamespace
processor.RegisterExtensionFunction(new Sqrt());
processor.RegisterExtensionFunction(new DefaultNamespace());
// Create a transformer for the stylesheet.
XsltTransformer transformer = processor.NewXsltCompiler().Compile(new StringReader(s)).Load();
// Load the source document (must be a wrapper around an XmlDocument for this test)
XmlDocument doc = new XmlDocument();
doc.Load(new XmlTextReader(samplesDir.AbsolutePath + "data/books.xml"));
XdmNode input = processor.NewDocumentBuilder().Wrap(doc);
// Set the root node of the source document to be the initial context node
transformer.InitialContextNode = input;
// Supply a parameter
transformer.SetParameter(new QName("", "timezone"),
XdmAtomicValue.WrapExternalObject(TimeZone.CurrentTimeZone));
// Create a serializer
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
serializer.SetOutputProperty(Serializer.INDENT, "yes");
// Transform the source XML to System.out.
transformer.Run(serializer);
}
public override void run(Uri samplesDir)
{
Processor processor = new Processor(true);
// Create the stylesheet
String s = "<xsl:transform version='2.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform' xmlns:saxon='http://saxon.sf.net/'>\n" +
" <xsl:template name='main'> " +
" <xsl:value-of select=\"count(saxon:stream(doc('" + new Uri(samplesDir, "data/othello.xml").ToString() + "')//LINE[count(tokenize(.,'/s')) > 0] ))\" />" +
" </xsl:template></xsl:transform>";
// Create a transformer for the stylesheet.
XsltTransformer transformer = processor.NewXsltCompiler().Compile(new StringReader(s)).Load();
transformer.InitialTemplate = new QName("main");
// Create a serializer
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
// serializer.SetOutputProperty(Serializer.INDENT, "yes");
// Transform the source XML to System.out.
transformer.Run(serializer);
}
private bool testAssertion2(XdmNode assertion, Outcome outcome, XPathCompiler assertXpc, XPathCompiler catalogXpc, bool debug)
{
string tag = assertion.NodeName.LocalName;
if (tag.Equals("assert-eq"))
{
if (outcome.isException())
{
return false;
}
else
{
XPathSelector s = assertXpc.Compile("$result eq " + assertion.StringValue).Load();
s.SetVariable(new QName("result"), outcome.getResult());
XdmAtomicValue item = (XdmAtomicValue)s.EvaluateSingle();
if (s == null)
{
return false;
}
return (bool)item.Value;
}
}
if (tag.Equals("assert-deep-eq"))
{
if (outcome.isException())
{
return false;
}
else
{
XPathSelector s = assertXpc.Compile("deep-equal($result , (" + assertion.StringValue + "))").Load();
s.SetVariable(new QName("result"), outcome.getResult());
return (bool)((XdmAtomicValue)s.Evaluate()).Value;
}
}
else if (tag.Equals("assert-permutation"))
{
// TODO: extend this to handle nodes (if required)
if (outcome.isException())
{
return false;
}
else
{
try
{
int expectedItems = 0;
Hashtable expected = new Hashtable();
XPathSelector s = assertXpc.Compile("(" + assertion.StringValue + ")").Load();
s.SetVariable(new QName("result"), outcome.getResult()); // not used, but we declared it
net.sf.saxon.lib.StringCollator collator = net.sf.saxon.expr.sort.CodepointCollator.getInstance();
net.sf.saxon.expr.XPathContext context = new net.sf.saxon.expr.XPathContextMajor(net.sf.saxon.value.StringValue.EMPTY_STRING, assertXpc.Processor.Implementation);
/* foreach (XdmItem item in s) {
expectedItems++;
XdmValue value = (XdmValue) item;
Object comparable = value.isNaN() ?
AtomicSortComparer.COLLATION_KEY_NaN :
value.getXPathComparable(false, collator, context);
expected.add(comparable);
} */
int actualItems = 0;
/*foreach (XdmItem item in outcome.getResult()) {
actualItems++;
AtomicValue value = (AtomicValue) item.getUnderlyingValue();
Object comparable = value.isNaN() ?
AtomicSortComparer.COLLATION_KEY_NaN :
value.getXPathComparable(false, collator, context);
if (!expected.Contains(comparable)) {
return false;
}
}*/
return actualItems == expectedItems;
}
catch (DynamicError e)
{
return false;
}
}
}
else if (tag.Equals("assert-serialization"))
{
if (outcome.isException())
{
return false;
}
else
{
string normalizeAtt = assertion.GetAttributeValue(new QName("normalize-space"));
bool normalize = normalizeAtt != null && ("true".Equals(normalizeAtt.Trim()) || "1".Equals(normalizeAtt.Trim()));
string ignoreAtt = assertion.GetAttributeValue(new QName("ignore-prefixes"));
bool ignorePrefixes = ignoreAtt != null && ("true".Equals(ignoreAtt.Trim()) || "1".Equals(ignoreAtt.Trim()));
catalogXpc.BaseUri = "";
string comparand = catalogXpc.Evaluate("if (@file) then unparsed-text(resolve-uri(@file, base-uri(.))) else string(.)", assertion).ToString();
if (normalize)
{
comparand = net.sf.saxon.value.Whitespace.collapseWhitespace(comparand).ToString();
}
StringWriter tw = new StringWriter();
Serializer serializer = new Serializer();
serializer.SetOutputWriter(tw);
serializer.SetOutputProperty(Serializer.METHOD, "xml");
serializer.SetOutputProperty(Serializer.INDENT, "no");
serializer.SetOutputProperty(Serializer.OMIT_XML_DECLARATION, "yes");
assertXpc.Processor.WriteXdmValue(outcome.getResult(), serializer);
if (comparand.Equals(tw.ToString())) {
return true;
}
DocumentBuilder builder = assertXpc.Processor.NewDocumentBuilder();
StringReader reader = new StringReader("<z>" + comparand + "</z>");
builder.BaseUri = assertion.BaseUri;
XdmNode expected = builder.Build(reader);
int flag = 0;
flag |= net.sf.saxon.functions.DeepEqual.INCLUDE_COMMENTS;
flag |= net.sf.saxon.functions.DeepEqual.INCLUDE_PROCESSING_INSTRUCTIONS;
if (!ignorePrefixes)
{
flag |= net.sf.saxon.functions.DeepEqual.INCLUDE_NAMESPACES;
flag |= net.sf.saxon.functions.DeepEqual.INCLUDE_PREFIXES;
}
flag |= net.sf.saxon.functions.DeepEqual.COMPARE_STRING_VALUES;
flag |= net.sf.saxon.functions.DeepEqual.WARNING_IF_FALSE;
try
{
net.sf.saxon.om.SequenceIterator iter0;
XdmValue v = outcome.getResult();
if (v.Count == 1 && v is XdmNode && ((XdmNode)v).NodeKind == XmlNodeType.Document)
{
iter0 = ((XdmNode)v).Implementation.iterateAxis(net.sf.saxon.om.Axis.CHILD);
} else {
iter0 = net.sf.saxon.value.Value.asIterator(outcome.getResult().Unwrap());
}
net.sf.saxon.om.SequenceIterator iter1 = (expected.Implementation.iterateAxis(net.sf.saxon.om.Axis.CHILD).next()).iterateAxis(net.sf.saxon.om.Axis.CHILD);
return net.sf.saxon.functions.DeepEqual.deepEquals(
iter0, iter1,
new net.sf.saxon.expr.sort.GenericAtomicComparer(net.sf.saxon.expr.sort.CodepointCollator.getInstance(), null),
assertXpc.Processor.Implementation, flag);
}
catch (DynamicError e)
{
// e.printStackTrace();
return false;
}
}
}
else if (tag.Equals("assert-serialization-error"))
{
if (outcome.isException()) {
return false;
} else {
string expectedError = assertion.GetAttributeValue(new QName("code"));
StringWriter sw = new StringWriter();
Serializer serializer = new Serializer();
serializer.SetOutputWriter(sw);
serializer.SetOutputProperty(Serializer.METHOD, "xml");
serializer.SetOutputProperty(Serializer.INDENT, "no");
serializer.SetOutputProperty(Serializer.OMIT_XML_DECLARATION, "yes");
try {
assertXpc.Processor.WriteXdmValue(outcome.getResult(), serializer);
return false;
} catch (DynamicError err) {
bool b = expectedError.Equals(err.ErrorCode.LocalName);
if (!b)
{
feedback.Message("Expected " + expectedError + ", got " + err.ErrorCode.LocalName, false);
}
return true;
}
}
}
else if (tag.Equals("assert-empty"))
{
if (outcome.isException())
{
return false;
}
else
{
XdmValue result = outcome.getResult();
return result.Count == 0;
}
}
else if (tag.Equals("assert-count"))
{
if (outcome.isException())
{
return false;
}
else
{
XdmValue result = outcome.getResult();
return result.Count == int.Parse(assertion.StringValue);
}
}
else if (tag.Equals("assert"))
{
if (outcome.isException())
{
return false;
}
else
{
XPathSelector s = assertXpc.Compile(assertion.StringValue).Load();
s.SetVariable(new QName("result"), outcome.getResult());
return (bool)((XdmAtomicValue)s.EvaluateSingle()).Value;
}
}
else if (tag.Equals("assert-string-value"))
{
if (outcome.isException())
{
return false;
}
else
{
XdmValue resultValue = outcome.getResult();
string resultstring;
string assertionstring = assertion.StringValue;
if (resultValue is XdmNode)
{
resultstring = ((XdmNode)resultValue).StringValue;
}else if(resultValue is XdmAtomicValue){
resultstring = ((XdmAtomicValue)resultValue).ToString();
}
else
{
bool first = true;
StringBuilder fsb = new StringBuilder(256);
foreach (XdmItem item in resultValue)
{
if (first)
{
first = false;
}
else
{
fsb.Append(' ');
}
fsb.Append(item.Unwrap().getStringValue());
}
resultstring = fsb.ToString();
}
string normalizeAtt = assertion.GetAttributeValue(new QName("normalize-space"));
if (normalizeAtt != null && (normalizeAtt.Trim().Equals("true") || normalizeAtt.Trim().Equals("1")))
{
assertionstring = net.sf.saxon.value.Whitespace.collapseWhitespace(assertionstring).ToString();
resultstring = net.sf.saxon.value.Whitespace.collapseWhitespace(resultstring).ToString();
}
if (resultstring.Equals(assertionstring))
{
return true;
}
else
{
if (debug)
{
if (resultstring.Length != assertionstring.Length)
{
Console.WriteLine("Result length " + resultstring.Length + "; expected length " + assertionstring.Length);
}
int len = Math.Min(resultstring.Length, assertionstring.Length);
for (int i = 0; i < len; i++)
{
if (resultstring[i] != assertionstring[i])
{
feedback.Message("Results differ at index " + i +
"(\"" + resultstring.Substring(i, (i + 10 > len ? len : i + 10)) + "\") vs (\"" +
assertionstring.Substring(i, (i + 10 > len ? len : i + 10)) + "\")", false);
break;
}
}
}
return false;
}
}
}
else if (tag.Equals("assert-type"))
{
if (outcome.isException())
{
return false;
}
else
{
XPathSelector s = assertXpc.Compile("$result instance of " + assertion.StringValue).Load();
s.SetVariable(new QName("result"), outcome.getResult());
return (bool)((XdmAtomicValue)s.EvaluateSingle()).Value;
}
}
else if (tag.Equals("assert-true"))
{
if (outcome.isException())
{
return false;
}
else
{
XdmValue result = outcome.getResult();
return result.Count == 1 && ((XdmItem)result).IsAtomic() &&
((XdmAtomicValue)result).GetPrimitiveTypeName().Equals(QName.XS_BOOLEAN) &&
(((XdmAtomicValue)result).GetBooleanValue());
}
}
else if (tag.Equals("assert-false"))
{
if (outcome.isException())
{
return false;
}
else
{
XdmValue result = outcome.getResult();
return result.Count == 1 &&
((XdmItem)result.Simplify).IsAtomic() &&
((XdmAtomicValue)result.Simplify).GetPrimitiveTypeName().Equals(QName.XS_BOOLEAN) &&
!(bool)((XdmAtomicValue)result.Simplify).Value;
}
}
else if (tag.Equals("error"))
{
string expectedError = assertion.GetAttributeValue(new QName("code"));
//noinspection ThrowableResultOfMethodCallIgnored
Exception err = outcome.getException();
QName errorCode = null;
if (err is DynamicError)
{
errorCode = ((DynamicError)outcome.getException()).ErrorCode;
}
else {
errorCode = ((StaticError)outcome.getException()).ErrorCode;
}
return outcome.isException() &&
(expectedError.Equals("*") ||
(errorCode != null &&
errorCode.LocalName.Equals(expectedError)) ||
(outcome.hasReportedError(expectedError)));
}
else if (tag.Equals("all-of"))
{
XdmValue children = catalogXpc.Evaluate("*", assertion);
foreach (XdmItem child in children)
{
if (!testAssertion((XdmNode)child, outcome, assertXpc, catalogXpc, debug))
{
return false;
}
}
return true;
}
else if (tag.Equals("any-of"))
{
XdmValue children = catalogXpc.Evaluate("*", assertion);
foreach (XdmItem child in children)
{
if (testAssertion((XdmNode)child, outcome, assertXpc, catalogXpc, debug))
{
return true;
}
}
return false;
}
throw new Exception("Unknown assertion element " + tag);
}
/// <summary>
/// Run an XSLT transformation making use of an XmlResolver to resolve URIs both at compile time and at run-time
/// </summary>
public override void run(Uri samplesDir)
{
// Create a Processor instance.
Processor processor = new Processor();
// Load the source document
DocumentBuilder builder = processor.NewDocumentBuilder();
UserXmlResolver buildTimeResolver = new UserXmlResolver();
buildTimeResolver.Message = "** Calling build-time XmlResolver: ";
builder.XmlResolver = buildTimeResolver;
builder.BaseUri = samplesDir;
String doc = "<!DOCTYPE doc [<!ENTITY e SYSTEM 'flamingo.txt'>]><doc>&e;</doc>";
MemoryStream ms = new MemoryStream();
StreamWriter tw = new StreamWriter(ms);
tw.Write(doc);
tw.Flush();
Stream instr = new MemoryStream(ms.GetBuffer(), 0, (int)ms.Length);
XdmNode input = builder.Build(instr);
// Create a transformer for the stylesheet.
String stylesheet =
"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='2.0'>" +
"<xsl:import href='empty.xslt'/>" +
"<xsl:template match='/'>" +
"<out note=\"{doc('heron.txt')}\" ><xsl:copy-of select='.'/></out>" +
"</xsl:template>" +
"</xsl:stylesheet>";
XsltCompiler compiler = processor.NewXsltCompiler();
UserXmlResolver compileTimeResolver = new UserXmlResolver();
compileTimeResolver.Message = "** Calling compile-time XmlResolver: ";
compiler.XmlResolver = compileTimeResolver;
compiler.BaseUri = samplesDir;
XsltTransformer transformer = compiler.Compile(new XmlTextReader(new StringReader(stylesheet))).Load();
// Set the root node of the source document to be the initial context node
transformer.InitialContextNode = input;
// Set the user-written XmlResolver
UserXmlResolver runTimeResolver = new UserXmlResolver();
runTimeResolver.Message = "** Calling transformation-time XmlResolver: ";
transformer.InputXmlResolver = runTimeResolver;
// Create a serializer
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
// Transform the source XML to System.out.
transformer.Run(serializer);
}
/// <summary>
/// Run a transformation: supply input as a file
/// </summary>
public override void run(Uri samplesDir)
{
if (samplesDir.Scheme != Uri.UriSchemeFile)
{
Console.WriteLine("Supplied URI must be a file directory");
}
String dir = samplesDir.AbsolutePath;
String sourceFile = dir + "data/books.xml";
String styleFile = dir + "styles/books.xsl";
// Create a Processor instance.
Processor processor = new Processor();
// Load the source document
DocumentBuilder builder = processor.NewDocumentBuilder();
builder.BaseUri = new Uri(samplesDir, "data/books.xml");
XdmNode input = builder.Build(File.OpenRead(sourceFile));
// Create a transformer for the stylesheet.
XsltCompiler compiler = processor.NewXsltCompiler();
compiler.BaseUri = new Uri(samplesDir, "styles/books.xsl");
XsltTransformer transformer = compiler.Compile(File.OpenRead(styleFile)).Load();
// Set the root node of the source document to be the initial context node
transformer.InitialContextNode = input;
// Create a serializer, with output to the standard output stream
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
// Transform the source XML and serialize the result document
transformer.Run(serializer);
}
/// <summary>
/// Run an XSLT transformation capturing run-time messages within the application
/// </summary>
public override void run(Uri samplesDir)
{
// Create a Processor instance.
Processor processor = new Processor();
// Ask for the JAXP parser to be used (or not to be used, if false)
processor.SetProperty("http://saxon.sf.net/feature/preferJaxpParser", "false");
// Load the source document
DocumentBuilder builder = processor.NewDocumentBuilder();
builder.IsLineNumbering = true;
XdmNode input = builder.Build(new Uri(samplesDir, "data/othello.xml"));
// Create the XSLT Compiler
XsltCompiler compiler = processor.NewXsltCompiler();
// Define a stylesheet that shows line numbers of source elements
String stylesheet =
"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='2.0' xmlns:saxon='http://saxon.sf.net/'>\n" +
"<xsl:template match='/'>\n" +
"<out>\n" +
" <xsl:for-each select='//ACT'>\n" +
" <out><xsl:value-of select='saxon:line-number(.)'/></out>\n" +
" </xsl:for-each>\n" +
"</out>\n" +
"</xsl:template>\n" +
"</xsl:stylesheet>";
compiler.BaseUri = new Uri("http://localhost/stylesheet");
XsltExecutable exec = compiler.Compile(new StringReader(stylesheet));
// Create a transformer for the stylesheet.
XsltTransformer transformer = exec.Load();
// Set the root node of the source document to be the initial context node
transformer.InitialContextNode = input;
// Create a serializer
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
// Transform the source XML to System.out.
transformer.Run(serializer);
}
private String compareDocs(XdmNode doc1, XdmNode doc2) {
try {
XsltTransformer t = xmlComparer.Load();
t.InitialTemplate = new QName("", "compare");
t.SetParameter(new QName("", "actual"), doc1);
t.SetParameter(new QName("", "gold"), doc2);
t.SetParameter(new QName("", "debug"), new XdmAtomicValue(debug));
StringWriter sw = new StringWriter();
Serializer sr = new Serializer();
sr.SetOutputWriter(sw);
t.Run(sr);
String result = sw.ToString();
if (result.StartsWith("true"))
{
return "OK";
}
else
{
return "XML comparison - not equal";
}
}
catch (Exception e)
{
Console.WriteLine("***" + e.Message);
return "XML comparison failure: " + e.Message;
}
}
/// <summary>
/// Run a transformation: simplest possible script
/// </summary>
public override void run(Uri samplesDir)
{
// Create a Processor instance.
Processor processor = new Processor();
// Load the source document
XdmNode input = processor.NewDocumentBuilder().Build(new Uri(samplesDir, "data/books.xml"));
// Create a transformer for the stylesheet.
XsltTransformer transformer = processor.NewXsltCompiler().Compile(new Uri(samplesDir, "styles/books.xsl")).Load();
// Set the root node of the source document to be the initial context node
transformer.InitialContextNode = input;
// Create a serializer, with output to the standard output stream
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
// Transform the source XML and serialize the result document
transformer.Run(serializer);
}
static bool[] FunctionsAvailable(QName[] names, Processor processor, XPathItemFactory itemFactory)
{
const string xsltNs = "http://www.w3.org/1999/XSL/Transform";
IXPathNavigable stylesheetDoc = itemFactory.BuildNode();
XmlWriter builder = stylesheetDoc.CreateNavigator().AppendChild();
builder.WriteStartElement("stylesheet", xsltNs);
builder.WriteAttributeString("version", "2.0");
for (int i = 0; i < names.Length; i++) {
QName item = names[i];
builder.WriteAttributeString("xmlns", "p" + i.ToStringInvariant(), null, item.Uri);
}
builder.WriteStartElement("output", xsltNs);
builder.WriteAttributeString("method", "text");
builder.WriteEndElement();
builder.WriteStartElement("template", xsltNs);
builder.WriteAttributeString("name", "main");
for (int i = 0; i < names.Length; i++) {
QName item = names[i];
if (i > 0) {
builder.WriteElementString("text", xsltNs, "|");
}
builder.WriteStartElement("value-of", xsltNs);
builder.WriteAttributeString("select", "function-available('{0}:{1}')".FormatInvariant("p" + i.ToStringInvariant(), item.LocalName));
builder.WriteEndElement();
}
builder.WriteEndElement(); // template
builder.WriteEndElement(); // stylesheet
builder.Close();
XsltCompiler compiler = processor.NewXsltCompiler();
compiler.BaseUri = new Uri("foo:bar");
compiler.XmlResolver = null;
XsltTransformer transform = compiler.Compile(stylesheetDoc.CreateNavigator().ReadSubtree()).Load();
transform.InitialTemplate = new QName("main");
using (var output = new StringWriter(CultureInfo.InvariantCulture)) {
var serializer = new Serializer();
serializer.SetOutputWriter(output);
transform.Run(serializer);
return output.ToString().Trim().Split('|').Select(s => XmlConvert.ToBoolean(s)).ToArray();
}
}
/// <summary>
/// Run a transformation: simplest possible script
/// </summary>
public override void run(Uri samplesDir)
{
Processor processor = new Processor();
// Load the source document
DocumentBuilder builder = processor.NewDocumentBuilder();
builder.BaseUri = samplesDir;
String doc = "<doc> <a> <b>text</b> </a> <a/> </doc>";
MemoryStream ms = new MemoryStream();
StreamWriter tw = new StreamWriter(ms);
tw.Write(doc);
tw.Flush();
Stream instr = new MemoryStream(ms.GetBuffer(), 0, (int)ms.Length);
XdmNode input = builder.Build(instr);
// Create a transformer for the stylesheet.
String stylesheet =
"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='2.0'>" +
"<xsl:strip-space elements='*'/>" +
"<xsl:template match='/'>" +
" <xsl:copy-of select='.'/>" +
"</xsl:template>" +
"</xsl:stylesheet>";
XsltCompiler compiler = processor.NewXsltCompiler();
compiler.BaseUri = samplesDir;
XsltTransformer transformer = compiler.Compile(new XmlTextReader(new StringReader(stylesheet))).Load();
// Set the root node of the source document to be the initial context node
transformer.InitialContextNode = input;
// Create a serializer
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
// Transform the source XML to System.out.
transformer.Run(serializer);
}
static void Main(string[] args) {
var proc = new Processor();
proc.RegisterExtensionFunction(new MakeRelativeUriExtensionFunction());
var compiler = proc.NewXsltCompiler();
string currentDir = Environment.CurrentDirectory;
string inputDir = args[0];
string outputDir = args[1];
if (currentDir.Last() != Path.DirectorySeparatorChar) {
currentDir += Path.DirectorySeparatorChar;
}
if (inputDir.Last() != Path.DirectorySeparatorChar) {
inputDir += Path.DirectorySeparatorChar;
}
if (outputDir.Last() != Path.DirectorySeparatorChar) {
outputDir += Path.DirectorySeparatorChar;
}
var baseUri = new Uri(AppDomain.CurrentDomain.BaseDirectory, UriKind.Absolute);
var callerBaseUri = new Uri(currentDir, UriKind.Absolute);
var sourceUri = new Uri(callerBaseUri, inputDir);
var outputUri = new Uri(callerBaseUri, outputDir);
var exec = compiler.Compile(new Uri(baseUri, "sandcastle-md-all.xsl"));
var transformer = exec.Load();
transformer.InitialTemplate = new QName("main");
transformer.SetParameter(new QName("source-dir"), new XdmAtomicValue(sourceUri));
if (args.Length > 1) {
transformer.SetParameter(new QName("output-dir"), new XdmAtomicValue(outputUri));
}
var serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
transformer.Run(serializer);
var iconsSourceUri = new Uri(sourceUri, "icons");
var iconsDestUri = new Uri(outputUri, "_icons");
DirectoryInfo iconsSourceDir = new DirectoryInfo(iconsSourceUri.LocalPath);
DirectoryInfo iconsDestDir;
if (!Directory.Exists(iconsDestUri.LocalPath)) {
iconsDestDir = Directory.CreateDirectory(iconsDestUri.LocalPath);
} else{
iconsDestDir = new DirectoryInfo(iconsDestUri.LocalPath);
}
var icons = new HashSet<string>(File.ReadAllLines(new Uri(baseUri, "icons.txt").LocalPath), StringComparer.OrdinalIgnoreCase);
foreach (FileInfo iconFile in iconsSourceDir.GetFiles()) {
if (icons.Contains(iconFile.Name)) {
iconFile.CopyTo(Path.Combine(iconsDestDir.FullName, iconFile.Name), overwrite: true);
}
}
}
private String canonizeXhtml(Processor p, String input) {
try {
XsltExecutable canonizer = getXhtmlCanonizer(p);
XsltTransformer t = canonizer.Load();
StringWriter sw = new StringWriter();
Serializer r = new Serializer();
r.SetOutputWriter(sw);
t.InitialContextNode = p.NewDocumentBuilder().Build(
new FileStream(input, FileMode.Open));
t.Run(r);
return sw.ToString();
} catch (Exception err) {
Console.WriteLine("*** Failed to compile or run XHTML canonicalizer stylesheet: " + err.ToString());
}
return "";
}
public static string ImportSchematron(string baseDir, string schemaPath, string xsltPath)
{
// Builds a new XSLT file from a schematron file.
// This only needs to be done when the schematron file changes.
var sxnProc = new Processor();
var outPath = xsltPath;
var baseXsltPath = Path.Combine(baseDir, @"Content\Saxon\");
var schConverter = new string[]
{
baseXsltPath + "iso_dsdl_include.xsl",
baseXsltPath + "iso_abstract_expand.xsl",
baseXsltPath + "iso_svrl_for_xslt2.xsl"
};
var schemaUri = new Uri(schemaPath);
var xslComp = sxnProc.NewXsltCompiler();
//////transform-1/////
var xslUri = new Uri(schConverter[0]);
var xslExec = xslComp.Compile(xslUri);
var xslTrans = xslExec.Load();
var domOut1 = new DomDestination(new XmlDocument());
using(var fs = File.Open(schemaPath, FileMode.Open, FileAccess.Read))
{
xslTrans.SetInputStream(fs, schemaUri); // set baseUri
xslTrans.Run(domOut1);
}
//////transform-2/////
xslUri = new Uri(schConverter[1]);
xslExec = xslComp.Compile(xslUri);
xslTrans = xslExec.Load();
var domOut2 = new DomDestination(new XmlDocument());
var docBuilder = sxnProc.NewDocumentBuilder();
docBuilder.BaseUri = schemaUri;
var inputDoc2 = docBuilder.Wrap(domOut1.XmlDocument);
xslTrans.InitialContextNode = inputDoc2;
xslTrans.Run(domOut2);
//////transform-3/////
xslUri = new Uri(schConverter[2]);
xslExec = xslComp.Compile(xslUri);
xslTrans = xslExec.Load();
var inputDoc3 = docBuilder.Wrap(domOut2.XmlDocument);
xslTrans.InitialContextNode = inputDoc3;
var serializer = new Serializer();
using (TextWriter tw = new StreamWriter(outPath, false))
{
serializer.SetOutputWriter(tw);
serializer.SetOutputProperty(Serializer.INDENT, "no");
xslTrans.Run(serializer);
}
return outPath;
}
static void Main(string[] args)
{
string infile = @"c:\daisybooks\verysimplebook\verysimplebook.xml";
string infile_dir = @"c:\daisybooks\verysimplebook\";
string xsltfile = @"c:\devel\amis\trunk\amis\bin\xslt\dtbook\dtbook2xhtml.xsl";
string outfile = @"c:\devel\amis\sandbox\dtbooktransformer_out.xml";
// Create a Processor instance.
Processor processor = new Processor();
// Load the source document
XdmNode input = processor.NewDocumentBuilder().Build(new Uri(infile));
// Create a transformer for the stylesheet.
XsltTransformer transformer =
processor.NewXsltCompiler().Compile(new Uri(xsltfile)).Load();
QName basedir = new QName("", "baseDir");
List<XdmAtomicValue> elementNames = new List<XdmAtomicValue>();
elementNames.Add(new XdmAtomicValue(infile_dir));
XdmValue basedir_value = new XdmValue(elementNames);
transformer.SetParameter(basedir, basedir_value);
// Set the user-written XmlResolver
UserXmlResolver runTimeResolver = new UserXmlResolver();
runTimeResolver.Message = "** Calling transformation-time XmlResolver: ";
transformer.InputXmlResolver = runTimeResolver;
// Set the root node of the source document to be the initial context node
transformer.InitialContextNode = input;
/*
* String outfile = "OutputFromXsltSimple2.xml";
Serializer serializer = new Serializer();
serializer.SetOutputStream(new FileStream(outfile, FileMode.Create, FileAccess.Write));
*/
// Create a serializer, with output to the standard output stream
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
// Transform the source XML and serialize the result document
transformer.Run(serializer);
Console.ReadLine();
}
/// <summary>
/// Run an XSLT transformation capturing run-time messages within the application
/// </summary>
public override void run(Uri samplesDir)
{
// Create a Processor instance.
Processor processor = new Processor();
// Create the XSLT Compiler
XsltCompiler compiler = processor.NewXsltCompiler();
// Define a stylesheet that generates messages
String stylesheet =
"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='2.0'>\n" +
"<xsl:template name='main'>\n" +
" <xsl:message><a>starting</a></xsl:message>\n" +
" <out><xsl:value-of select='current-date()'/></out>\n" +
" <xsl:message><a>finishing</a></xsl:message>\n" +
"</xsl:template>\n" +
"</xsl:stylesheet>";
compiler.BaseUri = new Uri("http://localhost/stylesheet");
XsltExecutable exec = compiler.Compile(new StringReader(stylesheet));
// Create a transformer for the stylesheet.
XsltTransformer transformer = exec.Load();
// Set the name of the initial template
transformer.InitialTemplate = new QName("", "main");
// Create a Listener to which messages will be written
transformer.MessageListener = new UserMessageListener();
// Create a serializer
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Out);
// Transform the source XML to System.out.
transformer.Run(serializer);
}
public string serialize(Processor p)
{
if (isException())
{
return "EXCEPTION " + exception.Message;
}
else
{
StringWriter sw = new StringWriter();
Serializer s = new Serializer();
s.SetOutputWriter(sw);
s.SetOutputProperty(Serializer.METHOD, "xml");
s.SetOutputProperty(Serializer.INDENT, "yes");
s.SetOutputProperty(Serializer.OMIT_XML_DECLARATION, "yes");
try
{
(new Processor()).WriteXdmValue(value, s);
}
catch (DynamicError err)
{
return ("SERIALIZATION FAILED: " + err.Message);
}
return sw.ToString();
}
}
/// <summary>
/// Demonstrate XQuery Update
/// </summary>
public override void run(Uri samplesDir)
{
Processor processor = new Processor(true);
DocumentBuilder loader = processor.NewDocumentBuilder();
loader.BaseUri = new Uri(samplesDir, "data/books.xml");
loader.TreeModel = TreeModel.LinkedTree;
XdmNode indoc = loader.Build(new Uri(samplesDir, "data/books.xml"));
Console.Out.WriteLine("=========== BEFORE UPDATE ===========");
Serializer serializer0 = new Serializer();
serializer0.SetOutputProperty(Serializer.METHOD, "xml");
serializer0.SetOutputProperty(Serializer.INDENT, "yes");
serializer0.SetOutputWriter(Console.Out);
processor.WriteXdmValue(indoc, serializer0);
String query =
"for $i in //PRICE return \n" +
"replace value of node $i with $i - 0.05";
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.UpdatingEnabled = true;
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
eval.ContextItem = indoc;
XdmNode[] updatedNodes = eval.RunUpdate();
foreach (XdmNode root in updatedNodes)
{
Uri documentUri = root.DocumentUri;
if (documentUri != null && documentUri.Scheme == "file")
{
Stream stream = UriConnection.getWritableUriStream(documentUri);
Serializer serializer = new Serializer();
serializer.SetOutputProperty(Serializer.METHOD, "xml");
serializer.SetOutputProperty(Serializer.INDENT, "yes");
serializer.SetOutputStream(stream);
processor.WriteXdmValue(root, serializer);
}
}
Console.Out.WriteLine("=========== AFTER UPDATE ===========");
processor.WriteXdmValue(indoc, serializer0);
}
