/// <summary>
/// Runs the necessary stylesheet transformations.
/// </summary>
/// <param name="context">The IRailsEngineContext containing the necessary transformation parameters.</param>
/// <param name="controller">The controller.</param>
/// <param name="templateName">Name of the template to run.</param>
private void RunStylesheets(IRailsEngineContext context, IController controller, String templateName)
{
//Collect arguments
XsltTransformationArguments arguments = CreateArguments(context, controller);
//Start new pipeline
XsltPipeline pipeline = new XsltPipeline(arguments);
//First stage
pipeline.AddStage(new XsltPipelineStage(TemplateStore.LoadTemplate(templateName, arguments)));
//Layout stage
if (controller.LayoutName != null)
{
pipeline.AddStage(new XsltPipelineStage(TemplateStore.LoadTemplate(@"layouts\" + controller.LayoutName, arguments)));
}
string xhtmlDocType = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
if (XHtmlRendering)
{
using (StreamWriter writer = new StreamWriter(context.Response.OutputStream))
{
writer.WriteLine(xhtmlDocType);
}
}
//Execute pipeline
pipeline.Execute(InputDocument, new XmlTextWriter(context.Response.Output));
}
private IXsltTransform CompileTransform(string templateName, XsltTransformationArguments arguments)
{
using (Stream templateStream = GetTemplateStream(templateName))
{
return(CompileTransform(new XsltTemplateStoreBasedXsltTemplateResolver(this, templateName), templateStream, arguments));
}
}
/// <summary>
/// Registers the extensions objects in the specified
/// transformation arguments to a new HelperTransformationBuilder.
/// </summary>
/// <param name="arguments">The arguments.</param>
/// <returns></returns>
internal static HelperTransformationBuilder BuildTransformationHelper(XsltTransformationArguments arguments)
{
HelperTransformationBuilder hp = new HelperTransformationBuilder();
foreach (object exO in arguments.ExtensionObjects)
{
hp.AddType(exO.GetType());
}
return hp;
}
/// <summary>
/// Loads the transformation from the specified stream
/// </summary>
/// <param name="store">The store to be used when resolving includes in the xslt stylesheet</param>
/// <param name="stream">The stream to load the transformation from.</param>
/// <param name="arguments">The arguments to arguments to use in the transformation.</param>
/// <returns></returns>
public IXsltTransform LoadTransform(IXsltTemplateResolver resolver, System.IO.Stream stream, XsltTransformationArguments arguments)
{
XslCompiledTransform transformer = new XslCompiledTransform();
using (XmlReader reader = new XmlTextReader(stream))
{
XsltSettings settings = new XsltSettings(false,false);
transformer.Load(reader, settings,
new HelperTransformationResolver(resolver,
XsltTransform.BuildTransformationHelper(arguments)));
}
return new XsltTransform(transformer, this);
}
/// <summary>
/// Creates an XsltTransformationArguments instance using the information
/// from the controller and IRailsEngineContext
/// </summary>
/// <param name="context">The context.</param>
/// <param name="controller">The controller.</param>
/// <returns></returns>
private XsltTransformationArguments CreateArguments(IRailsEngineContext context, IController controller)
{
XsltTransformationArguments arguments = new XsltTransformationArguments();
//Flash
AddFlash(context, arguments);
//P-bag
AddPropertyBag(context, controller, arguments);
//Helpers
AddExtensionObjects(context, controller, arguments);
return(arguments);
}
public void Execute(XmlReader reader, XmlWriter writer, XsltTransformationArguments arguments)
{
if (_executed)
throw new InvalidOperationException("XsltPipelineStage has already been executed!");
if (BeforeExecute != null)
BeforeExecute.Invoke(this, new XsltPipelineStageEventArgs(reader, writer, arguments));
_Transformer.Transform(reader, writer, arguments);
_executed = true;
if (AfterExecute != null)
AfterExecute.Invoke(this, new XsltPipelineStageEventArgs(reader, writer, arguments));
}
/// <summary>
/// Processes the view - using the templateName to obtain the correct template,
/// and using the context to output the result.
/// </summary>
public override void Process(IRailsEngineContext context, IController controller, String templateName)
{
try
{
AdjustContentType(context);
//Todo: make configurable so this can be turned off
//Dump all arguments in XML to the ResponseStream
if (context.Request.Params["debugxml"] != null)
{
XsltTransformationArguments arguments = CreateArguments(context, controller);
XmlDocument doc = new XmlDocument();
foreach (XsltTransformationParameter thing in arguments.Parameters)
{
XmlElement elem = doc.CreateElement(thing.Name, thing.NameSpace);
if (thing.Value is IXPathNavigable)
{
elem.InnerXml = (thing.Value as IXPathNavigable).CreateNavigator().OuterXml;
}
else
{
elem.Value = thing.Value.ToString();
}
}
context.Response.ContentType = "text/xml";
doc.WriteTo(new XmlTextWriter(context.Response.Output));
}
else
{
//Run the transformations.
RunStylesheets(context, controller, templateName);
}
}
catch (Exception ex)
{
if (context.Request.IsLocal)
{
SendErrorDetails(ex, context.Response.Output);
}
else
{
//TODO: possibly incorrect message
throw new RailsException("Could not obtain view: " + templateName, ex);
}
}
}
/// <summary>
/// Converts the XsltTransformationArguments to a XsltArgumentList instance
/// </summary>
/// <param name="arguments">The arguments.</param>
/// <returns></returns>
private XsltArgumentList BuildXslArgumentList(XsltTransformationArguments arguments)
{
XsltArgumentList list = new XsltArgumentList();
foreach (XsltTransformationParameter param in arguments.Parameters)
{
list.AddParam(param.Name, param.NameSpace, param.Value);
}
foreach (object exO in arguments.ExtensionObjects)
{
list.AddExtensionObject("urn:" + exO.GetType().Name,
_Engine.DynamicAdapterStore.Adapt(exO));
}
return list;
}
public IXsltTransform LoadTemplate(string templateName, XsltTransformationArguments arguments)
{
string key = templateName.ToLower();
lock (_lock)
{
if (_templateCache.ContainsKey(key))
{
return(_templateCache[key]);
}
IXsltTransform transform = CompileTransform(key, arguments);
_templateCache[key] = transform;
return(transform);
}
}
public void Execute(XmlReader reader, XmlWriter writer, XsltTransformationArguments arguments)
{
if (_executed)
{
throw new InvalidOperationException("XsltPipelineStage has already been executed!");
}
if (BeforeExecute != null)
{
BeforeExecute.Invoke(this, new XsltPipelineStageEventArgs(reader, writer, arguments));
}
_Transformer.Transform(reader, writer, arguments);
_executed = true;
if (AfterExecute != null)
{
AfterExecute.Invoke(this, new XsltPipelineStageEventArgs(reader, writer, arguments));
}
}
private static void AddFlash(IRailsEngineContext context, XsltTransformationArguments arguments)
{
if (context.Flash.Keys.Count == 0)
{
return;
}
ObjectXPathContext ocontext = new ObjectXPathContext();
//For each object in the flash build an ObjectXPathNavigator to
//create an XPath-able represenation of that object
foreach (String key in context.Flash.Keys)
{
object value = context.Flash[key];
if (value != null)
{
arguments.AddParam(key, string.Empty, ocontext.CreateNavigator(value));
}
}
}
/// <summary>
/// Initializes a new instance of the XsltPipeline class.
/// </summary>
/// <param name="arguments"></param>
public XsltPipeline(XsltTransformationArguments arguments)
{
_Arguments = arguments;
}
/// <summary>
/// Creates an XsltTransformationArguments instance using the information
/// from the controller and IRailsEngineContext
/// </summary>
/// <param name="context">The context.</param>
/// <param name="controller">The controller.</param>
/// <returns></returns>
private XsltTransformationArguments CreateArguments(IRailsEngineContext context, IController controller)
{
XsltTransformationArguments arguments = new XsltTransformationArguments();
//Flash
AddFlash(context, arguments);
//P-bag
AddPropertyBag(context, controller, arguments);
//Helpers
AddExtensionObjects(context, controller, arguments);
return arguments;
}
/// <summary>
/// Adds XPathNavigable representations of the items in the propertybag
/// of the controller.
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="arguments">The arguments.</param>
private static void AddPropertyBag(IRailsEngineContext railscontext, IController controller, XsltTransformationArguments arguments)
{
ObjectXPathContext context = new ObjectXPathContext();
//For each object in the property bag build an ObjectXPathNavigator to
//create an XPath-able represenation of that object
foreach (String key in controller.PropertyBag.Keys)
{
object value = controller.PropertyBag[key];
if (value != null)
{
arguments.AddParam(key, string.Empty, context.CreateNavigator(value));
}
}
arguments.AddParam("context", string.Empty, context.CreateNavigator(railscontext));
//arguments.AddExtensionObject("urn:request", context.Request);
//arguments.AddExtensionObject("urn:response", context.Response);
//arguments.AddExtensionObject("urn:server", context.Server);
//arguments.AddExtensionObject("urn:session", context.Session);
}
/// <summary>
/// Adds the necessary helper objects to the specified
/// XsltTransformationArguments instance.
/// </summary>
/// <param name="context">The context</param>
/// <param name="controller">The controller to get the Helpers from</param>
/// <param name="arguments">The XsltTransformationArguments instance to add the Helpers to.</param>
private static void AddExtensionObjects(IRailsEngineContext context, IController controller, XsltTransformationArguments arguments)
{
List <string> extensions = new List <string>();
foreach (object helper in controller.Helpers.Values)
{
//TODO: get_Name is an expensive reflection operation
string name = helper.GetType().Name;
//Make sure every helper is only added once
if (extensions.Contains(name))
{
continue;
}
arguments.AddExtensionObject(helper);
extensions.Add(name);
}
arguments.AddExtensionObject(new XsltReflectionHelper());
}
/// <summary>
/// Adds the necessary helper objects to the specified
/// XsltTransformationArguments instance.
/// </summary>
/// <param name="context">The context</param>
/// <param name="controller">The controller to get the Helpers from</param>
/// <param name="arguments">The XsltTransformationArguments instance to add the Helpers to.</param>
private static void AddExtensionObjects(IRailsEngineContext context, IController controller, XsltTransformationArguments arguments)
{
List<string> extensions = new List<string>();
foreach (object helper in controller.Helpers.Values)
{
//TODO: get_Name is an expensive reflection operation
string name = helper.GetType().Name;
//Make sure every helper is only added once
if (extensions.Contains(name)) continue;
arguments.AddExtensionObject(helper);
extensions.Add(name);
}
arguments.AddExtensionObject(new XsltReflectionHelper());
}
/// <summary>
/// Adds XPathNavigable representations of the items in the propertybag
/// of the controller.
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="arguments">The arguments.</param>
private static void AddPropertyBag(IRailsEngineContext railscontext, IController controller, XsltTransformationArguments arguments)
{
ObjectXPathContext context = new ObjectXPathContext();
//For each object in the property bag build an ObjectXPathNavigator to
//create an XPath-able represenation of that object
foreach (String key in controller.PropertyBag.Keys)
{
object value = controller.PropertyBag[key];
if (value != null)
{
arguments.AddParam(key, string.Empty, context.CreateNavigator(value));
}
}
arguments.AddParam("context", string.Empty, context.CreateNavigator(railscontext));
//arguments.AddExtensionObject("urn:request", context.Request);
//arguments.AddExtensionObject("urn:response", context.Response);
//arguments.AddExtensionObject("urn:server", context.Server);
//arguments.AddExtensionObject("urn:session", context.Session);
}
private IXsltTransform CompileTransform(IXsltTemplateResolver resolver, Stream transformStream, XsltTransformationArguments arguments)
{
return(_xsltEngine.LoadTransform(resolver, transformStream, arguments));
}
private static void AddFlash(IRailsEngineContext context, XsltTransformationArguments arguments)
{
if (context.Flash.Keys.Count == 0) return;
ObjectXPathContext ocontext = new ObjectXPathContext();
//For each object in the flash build an ObjectXPathNavigator to
//create an XPath-able represenation of that object
foreach (String key in context.Flash.Keys)
{
object value = context.Flash[key];
if (value != null)
{
arguments.AddParam(key, string.Empty, ocontext.CreateNavigator(value));
}
}
}
/// <summary>
/// Initializes a new instance of the XsltPipelineStageEventArgs class.
/// </summary>
/// <param name="reader"></param>
/// <param name="writer"></param>
/// <param name="arguments"></param>
public XsltPipelineStageEventArgs(XmlReader reader, XmlWriter writer, XsltTransformationArguments arguments)
{
_Reader = reader;
_Writer = writer;
_Arguments = arguments;
}
private IXsltTransform CompileTransform(IXsltTemplateResolver resolver, Stream transformStream, XsltTransformationArguments arguments)
{
return _xsltEngine.LoadTransform(resolver, transformStream, arguments);
}
private IXsltTransform CompileTransform(string templateName, XsltTransformationArguments arguments)
{
using (Stream templateStream = GetTemplateStream(templateName))
{
return CompileTransform(new XsltTemplateStoreBasedXsltTemplateResolver(this, templateName), templateStream, arguments);
}
}
public IXsltTransform LoadTemplate(string templateName, XsltTransformationArguments arguments)
{
string key = templateName.ToLower();
lock (_lock)
{
if (_templateCache.ContainsKey(key))
return _templateCache[key];
IXsltTransform transform = CompileTransform(key, arguments);
_templateCache[key] = transform;
return transform;
}
}
/// <summary>
/// Initializes a new instance of the XsltPipelineStageEventArgs class.
/// </summary>
/// <param name="reader"></param>
/// <param name="writer"></param>
/// <param name="arguments"></param>
public XsltPipelineStageEventArgs(XmlReader reader, XmlWriter writer, XsltTransformationArguments arguments)
{
_Reader = reader;
_Writer = writer;
_Arguments = arguments;
}
/// <summary>
/// Transforms the specified input to the specified output using the specified arguments.
/// </summary>
/// <param name="input">The input document.</param>
/// <param name="output">The output document to write to.</param>
/// <param name="arguments">The arguments of the transformation.</param>
public void Transform(System.Xml.XmlReader input, System.Xml.XmlWriter output, XsltTransformationArguments arguments)
{
XsltArgumentList xslArguments = BuildXslArgumentList(arguments);
_transformer.Transform(input, xslArguments, output);
}
/// <summary>
/// Initializes a new instance of the XsltPipeline class.
/// </summary>
/// <param name="arguments"></param>
public XsltPipeline(XsltTransformationArguments arguments)
{
_Arguments = arguments;
}