public static string Transform(string xsltPath, string xmlPath)
{
string tempPath = Path.GetTempFileName();
using (AutoResetEvent transformedEvent = new AutoResetEvent(false))
{
Action transformTask = () =>
{
MvpXslTransform transform = new MvpXslTransform();
transform.Load(xsltPath, new XsltSettings(true, false),
new XmlUrlResolver());
using (StreamWriter writer = new StreamWriter(tempPath))
using (XmlReader reader = XmlReader.Create(xmlPath))
{
transform.Transform(new XmlInput(reader), null,
new XmlOutput(writer));
}
transformedEvent.Set();
};
double fileSizeMb = new FileInfo(xmlPath).Length / MB;
lock (SyncObj)
{
if ((_CurrentBatchSizeMb += fileSizeMb) > MaxBatchSizeMB)
{
_CurrentBatchSizeMb = fileSizeMb;
Tasks.Queue(isParallel: false, task: Join);
}
Tasks.Queue(isParallel: true, task: transformTask);
}
transformedEvent.WaitOne();
}
return(tempPath);
}
public void TestXPointerIndentationBug()
{
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
XsltSettings xsltSettings = new XsltSettings();
xsltSettings.EnableDocumentFunction = true;
XmlReaderSettings settings = new XmlReaderSettings();
settings.ProhibitDtd = false;
XmlReader reader = XmlReader.Create("../../XInclude/tests/Transform.xsl", settings);
XIncludingReader xInputReader = new XIncludingReader("../../XInclude/tests/FileA.xml");
try
{
MvpXslTransform processor = new MvpXslTransform(false);
processor.Load(reader, xsltSettings, resolver);
//xInputReader.XmlResolver = new XMLBase();
XmlDocument xInputDoc = new XmlDocument();
xInputDoc.Load(xInputReader);
XmlInput xInput = new XmlInput(xInputDoc);
StringWriter stringW = new StringWriter();
XmlOutput xOutput = new XmlOutput(stringW);
processor.Transform(xInput, null, xOutput);
processor.TemporaryFiles.Delete();
Assert.AreEqual("<?xml version=\"1.0\" encoding=\"utf-16\"?>NodeA Content", stringW.ToString());
}
finally
{
reader.Close();
xInputReader.Close();
}
}
/// <summary>
/// Creates XslCompiledTransform instance for given reader and resolver.
/// </summary>
private MvpXslTransform CreateTransform(XmlResolver stylesheetResolver, XmlReader stylesheetReader)
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.SupportCharacterMaps = options.ProcessCharacterMaps;
xslt.EnforceXHTMLOutput = options.EnforceXhtmlOutput;
try
{
xslt.Load(stylesheetReader, XsltSettings.TrustedXslt, stylesheetResolver);
}
catch (XsltException xslte)
{
string errors = GetCompileErrors(xslt.CompiledTransform);
if (!string.IsNullOrEmpty(errors))
{
errors += Environment.NewLine;
}
errors += Reporter.GetFullMessage(xslte);
throw new NXsltException(errors);
}
catch (XmlException xe)
{
string uri = options.LoadStylesheetFromStdin ? NXsltStrings.FromStdin : xe.SourceUri;
throw new NXsltException(NXsltStrings.ErrorParsingDoc, uri, Reporter.GetFullMessage(xe));
}
catch (Exception e)
{
string uri = options.LoadStylesheetFromStdin ? NXsltStrings.FromStdin : stylesheetReader.BaseURI;
throw new NXsltException(NXsltStrings.ErrorCompileStyle, uri, Reporter.GetFullMessage(e));
}
return(xslt);
}
protected void RunAndCompare(string source, string stylesheet,
string result)
{
var doc = new XPathDocument(TestDir + source);
var res = new StringWriter();
// deprecated
//ExsltTransform exslt = new ExsltTransform();
//exslt.Load(TestDir + stylesheet);
//exslt.Transform(doc, null, res);
var transform = new MvpXslTransform();
transform.Load(TestDir + stylesheet);
transform.Transform(new XmlInput(doc), null, new XmlOutput(res));
var sr = new StreamReader(ResultsDir + result);
string expectedResult = sr.ReadToEnd();
XDocument expected = XDocument.Load(new StringReader(expectedResult));
string actualResult = res.ToString();
XDocument actual = XDocument.Load(new StringReader(actualResult));
sr.Close();
bool areEqual = XNode.DeepEquals(expected, actual);
if (!areEqual)
{
Console.WriteLine(@"Actual Result was {0}", actualResult);
Console.WriteLine(@"Expected Result was {0}", expectedResult);
}
Assert.IsTrue(areEqual);
}
public void ResolverTestIXPathNavigableInput()
{
MvpXslTransform xslt = GetMvpXslTransform2();
XmlInput input = new XmlInput(new XPathDocument("../../../Common/MvpXslTransformTests/test.xml"), new MyXmlResolver());
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(resolverTestStandardResult, ms.ToArray());
}
public void TestIXPathNavigableInput()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput(new XPathDocument("../../../Common/northwind.xml", XmlSpace.Preserve));
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(standardResult, ms.ToArray());
}
public void TestXmlReaderInput()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput(XmlReader.Create("../../../Common/northwind.xml"));
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(standardResult, ms.ToArray());
}
public void TestTextReaderInput()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput(new StreamReader("../../../Common/northwind.xml", Encoding.GetEncoding("windows-1252")));
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(standardResult, ms.ToArray());
}
private MvpXslTransform GetMvpXslTransform()
{
if (xslt == null)
{
xslt = new MvpXslTransform();
xslt.Load("../../../Common/MvpXslTransformTests/test1.xslt");
}
return(xslt);
}
private MvpXslTransform GetMvpXslTransform2()
{
if (xslt2 == null)
{
xslt2 = new MvpXslTransform();
xslt2.Load("../../../Common/MvpXslTransformTests/resolver-test.xslt", XsltSettings.TrustedXslt, null);
}
return(xslt2);
}
public void ResolverTestXmlReaderInput()
{
MvpXslTransform xslt = GetMvpXslTransform2();
XmlInput input = new XmlInput(XmlReader.Create("../../MvpXslTransformTests/test.xml"), new MyXmlResolver());
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(resolverTestStandardResult, ms.ToArray());
}
public void CharMapTest4()
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.Load(XmlReader.Create("../../Common/MvpXslTransformTests/char-map.xslt"));
XmlInput input = new XmlInput(new StringReader("<foo attr=\"{data}\">text {%= fff() %} and more text.</foo>"));
StringWriter sw = new StringWriter();
xslt.Transform(input, Arguments, new XmlOutput(sw));
Assert.IsTrue(sw.ToString() == "<out attr=\"a b\"><text>Some text, now ASP.NET <%# Eval(\"foo\") %> and more text.</text><foo attr=\"<data>\">text <%= fff() %> and more text.</foo></out>");
}
public void TestTextReaderInput2()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput(new StreamReader("../../northwind.xml", Encoding.GetEncoding("windows-1252")));
MemoryStream ms = new MemoryStream();
XmlReader r = xslt.Transform(input, Arguments);
XmlWriter w = XmlWriter.Create(ms);
w.WriteNode(r, false);
w.Close();
CompareResults(standardResult, ms.ToArray());
}
public void TestIXPathNavigableInput2()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput(new XPathDocument("../../../Common/northwind.xml", XmlSpace.Preserve));
MemoryStream ms = new MemoryStream();
XmlReader r = xslt.Transform(input, Arguments);
XmlWriter w = XmlWriter.Create(ms);
w.WriteNode(r, false);
w.Close();
CompareResults(standardResult, ms.ToArray());
}
public void TestXmlReaderInput2()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput(XmlReader.Create("../../../Common/northwind.xml"));
MemoryStream ms = new MemoryStream();
XmlReader r = xslt.Transform(input, Arguments);
XmlWriter w = XmlWriter.Create(ms);
w.WriteNode(r, false);
w.Close();
CompareResults(standardResult, ms.ToArray());
}
public void TestStreamInput()
{
MvpXslTransform xslt = GetMvpXslTransform();
using (FileStream fs = File.OpenRead("../../../Common/northwind.xml"))
{
XmlInput input = new XmlInput(fs);
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(standardResult, ms.ToArray());
}
}
public void ResolverTestStreamInput()
{
MvpXslTransform xslt = GetMvpXslTransform2();
using (FileStream fs = File.OpenRead("../../../Common/MvpXslTransformTests/test.xml"))
{
XmlInput input = new XmlInput(fs, new MyXmlResolver());
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(resolverTestStandardResult, ms.ToArray());
}
}
public static void ApplyXslt(Stream inputStream, string xsltFileName, Stream outputStream)
{
// open the xslt file
using (var xslFileReader = XmlReader.Create(xsltFileName))
{
// do the transformation
var xslt = new MvpXslTransform();
xslt.Load(xslFileReader);
xslt.Transform(new XmlInput(inputStream), null, new XmlOutput(outputStream));
outputStream.Position = 0; // move position of stream to beginning to be ready for reading later
}
}
public void ExsltTest()
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.Load("../../../Common/MvpXslTransformTests/exslt-test.xslt");
XmlInput input = new XmlInput("../../../Common/MvpXslTransformTests/test.xml");
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
string expected = "<out>3</out>";
CompareResults(Encoding.ASCII.GetBytes(expected), ms.ToArray());
}
public void TestStringOutput()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput("../../../Common/northwind.xml");
xslt.Transform(input, Arguments, new XmlOutput("../../../Common/MvpXslTransformTests/out.xml"));
using (FileStream fs = File.OpenRead("../../../Common/MvpXslTransformTests/out.xml"))
{
byte[] bytes = new byte[fs.Length];
fs.Read(bytes, 0, bytes.Length);
CompareResults(standardResult, bytes);
}
}
public void CharMapTest2()
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.Load("../../Common/MvpXslTransformTests/char-map.xslt");
XmlInput input = new XmlInput(new StringReader("<foo attr=\"{data}\">text {%= fff() %} and more text.</foo>"));
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
ms.Position = 0;
StreamReader sr = new StreamReader(ms);
Assert.AreEqual(sr.ReadToEnd(), "<out attr=\"a b\"><text>Some text, now ASP.NET <%# Eval(\"foo\") %> and more text.</text><foo attr=\"<data>\">text <%= fff() %> and more text.</foo></out>");
}
public void TestTextWriterOutput()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput("../../../Common/northwind.xml");
TextWriter w = new StreamWriter("../../../Common/MvpXslTransformTests/out.xml", false, Encoding.UTF8);
xslt.Transform(input, Arguments, new XmlOutput(w));
w.Close();
using (FileStream fs = File.OpenRead("../../../Common/MvpXslTransformTests/out.xml"))
{
byte[] bytes = new byte[fs.Length];
fs.Read(bytes, 0, bytes.Length);
CompareResults(standardResult, bytes);
}
}
static void xsltTransform(string inputPath, string outputPath, string xsltPath)
{
XmlUrlResolver resolver = new XmlUrlResolver();
XsltSettings xsltSettings = new XsltSettings(true, true);
MxmlTextWriter mxmlWriter = mxmlWriter = new MxmlTextWriter(outputPath, null, true);
XmlInput input = new XmlInput(inputPath);
MvpXslTransform mxmlTransform = new MvpXslTransform();
mxmlTransform.Load(xsltPath, xsltSettings, resolver);
mxmlTransform.Transform(input, null, new XmlOutput(mxmlWriter));
mxmlWriter.Flush();
mxmlWriter.Close();
mxmlWriter = null;
}
public void XhtmlTest()
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.Load("../../../Common/MvpXslTransformTests/xhtml.xslt");
xslt.EnforceXHTMLOutput = true;
XmlInput input = new XmlInput(new StringReader("<foo/>"));
StringWriter sw = new StringWriter();
XmlWriter w = XmlWriter.Create(sw, xslt.OutputSettings);
xslt.Transform(input, Arguments, new XmlOutput(w));
w.Close();
Console.WriteLine(sw.ToString());
Assert.AreEqual(sw.ToString(), "<?xml version=\"1.0\" encoding=\"utf-16\"?><!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"><html xmlns=\"http://www.w3.org/1999/xhtml\"><head><title>Page title</title></head><body><p>Para</p><p></p><br /><p><img src=\"ddd\" /></p></body></html>");
}
public void CharMapTest()
{
const string expected = "<out attr=\"a b\"><text>Some text, now ASP.NET <%# Eval(\"foo\") %> and more text.</text><foo attr=\"<data>\">text <%= fff() %> and more text.</foo></out>";
MvpXslTransform xslt = new MvpXslTransform {
SupportCharacterMaps = true
};
xslt.Load("../../../Common/MvpXslTransformTests/char-map.xslt");
XmlInput input = new XmlInput(new StringReader("<foo attr=\"{data}\">text {%= fff() %} and more text.</foo>"));
StringWriter sw = new StringWriter();
xslt.Transform(input, Arguments, new XmlOutput(sw));
Assert.AreEqual(expected, sw.ToString());
}
public void NoExsltTest()
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.Load("../../../Common/MvpXslTransformTests/exslt-test.xslt");
XmlInput input = new XmlInput("../../../Common/MvpXslTransformTests/test.xml");
MemoryStream ms = new MemoryStream();
xslt.SupportedFunctions = Mvp.Xml.Exslt.ExsltFunctionNamespace.None;
try
{
xslt.Transform(input, Arguments, new XmlOutput(ms));
}
catch (XsltException) { return; }
Assert.Fail("Shoudn't be here.");
}
/// <summary>
/// Prepares, loads and compiles XSLT stylesheet referenced in the PI.
/// </summary>
private MvpXslTransform PrepareStylesheetFromPI(XPathNavigator srcNav, XmlResolver stylesheetResolver)
{
Stopwatch xsltCompileTimer = null;
if (options.ShowTiming)
{
xsltCompileTimer = new Stopwatch();
xsltCompileTimer.Start();
}
XPathNavigator pi = srcNav.SelectSingleNode("/processing-instruction('xml-stylesheet')");
if (pi == null)
{
//Absent xml-stylesheet PI
throw new NXsltException(NXsltStrings.ErrorInvalidPI);
}
//Found PI node, look for the href pseudo attribute
string href = Utils.ExtractStylsheetHrefFromPI(pi);
MvpXslTransform xslt = null;
if (href.StartsWith("#"))
{
//Embedded stylesheet
string id = href.Remove(0, 1);
XPathNavigator embStylesheet = srcNav.SelectSingleNode("id('" + id + "')|/descendant::*[@id='" + id + "']");
if (embStylesheet == null)
{
//Unresolvable stylesheet URI
throw new NXsltException(NXsltStrings.ErrorPIStylesheetNotFound, href);
}
xslt = CreateTransform(stylesheetResolver, embStylesheet.ReadSubtree());
}
else
{
//External stylesheet
options.Stylesheet = href;
xslt = PrepareStylesheet(stylesheetResolver);
}
//Save stylesheet loading/compilation time
if (options.ShowTiming)
{
xsltCompileTimer.Stop();
timings.XsltCompileTime = xsltCompileTimer.ElapsedMilliseconds;
}
return(xslt);
}
/// <summary>
/// Performs XSL Transformation.
/// </summary>
private void Transform(XmlReader srcReader, MvpXslTransform xslt, XmlResolver resolver)
{
Stopwatch transformTimer = null;
if (options.ShowTiming)
{
transformTimer = new Stopwatch();
transformTimer.Start();
}
if (options.OutFile != null)
{
//Transform to a file
FileStream fs;
try
{
fs = File.Open(options.OutFile, FileMode.Create);
}
catch
{
throw new NXsltException(NXsltStrings.ErrorCreatingFile, options.OutFile);
}
try
{
XmlOutput results = new XmlOutput(fs);
results.XmlResolver = new OutputResolver(Path.GetDirectoryName(options.OutFile));
TransformImpl(srcReader, xslt, resolver, results);
}
finally
{
fs.Close();
}
}
else
{
//Transform to Console
XmlOutput results = new XmlOutput(Console.Out);
results.XmlResolver = new OutputResolver(Directory.GetCurrentDirectory());
TransformImpl(srcReader, xslt, resolver, results);
}
//Save transfomation time
if (options.ShowTiming)
{
transformTimer.Stop();
timings.XsltExecutionTime = transformTimer.ElapsedMilliseconds;
}
}
public override void xslTransformer(XPathNavigator xNav, XsltArgumentList xArgs)
{
XsltSettings settings = new XsltSettings(true, true);
XmlUrlResolver r = new XmlUrlResolver();
MvpXslTransform xslObj = new MvpXslTransform();
xslObj.Load(classXSLObjectSource, settings, r);
XmlInput xm = new XmlInput(xNav);
XmlOutput xo;
if (!(clsFileIO == null))
{
xo = new XmlOutput(clsFileIO);
xslObj.Transform(xm, xArgs, xo);
clsTEXTResult = "FILE SAVED";
}
else if (!(clsHTTPResponse == null))
{
xo = new XmlOutput(clsHTTPResponse.OutputStream);
xslObj.Transform(xm, xArgs, xo);
clsTEXTResult = "OUTPUT STREAMED TO HTTP RESPONSE";
}
else if (!(clsXMLObjectReturn == null))
{
StringWriter sWrit = new StringWriter();
xo = new XmlOutput(sWrit);
xslObj.Transform(xm, xArgs, xo);
clsXMLObjectReturn.LoadXml(sWrit.ToString());
}
else
{
StringWriter sWrit = new StringWriter();
xo = new XmlOutput(sWrit);
xslObj.Transform(xm, xArgs, xo);
// default - results to text
clsTEXTResult = sWrit.ToString();
}
}
/// <summary>
/// Creates XslCompiledTransform instance for given reader and resolver.
/// </summary>
private MvpXslTransform CreateTransform(XmlResolver stylesheetResolver, XmlReader stylesheetReader)
{
MvpXslTransform xslt = new MvpXslTransform();
try
{
xslt.Load(stylesheetReader, XsltSettings.TrustedXslt, stylesheetResolver);
}
catch (XmlException xe)
{
string uri = options.LoadStylesheetFromStdin ? NXsltStrings.FromStdin : xe.SourceUri;
throw new NXsltException(NXsltStrings.ErrorParsingDoc, uri, Reporter.GetFullMessage(xe));
}
catch (Exception e)
{
string uri = options.LoadStylesheetFromStdin ? NXsltStrings.FromStdin : stylesheetReader.BaseURI;
throw new NXsltException(NXsltStrings.ErrorCompileStyle, uri, Reporter.GetFullMessage(e));
}
return(xslt);
}
