/// <summary> /// This is used to create a <see cref="TargetDictionary"/> used to store reference link targets /// </summary> /// <param name="configuration">The configuration element for the target dictionary</param> /// <returns>A default <see cref="InMemoryTargetDictionary"/> instance containing the reference link /// targets</returns> /// <remarks>This can be overridden in derived classes to provide persistent caches with backing stores /// other than the default <see cref="Dictionary{TKey, TValue}"/></remarks>. public virtual TargetDictionary CreateTargetDictionary(XPathNavigator configuration) { TargetDictionary d = null; try { d = new InMemoryTargetDictionary(this, configuration); } catch (Exception ex) { base.WriteMessage(MessageLevel.Error, BuildComponentUtilities.GetExceptionMessage(ex)); } return(d); }
public override void Apply(XmlDocument document, string key) { // set the evaluation context context["key"] = key; XPathExpression path_xpath = path_expression.Clone(); path_xpath.SetContext(context); // evaluate the path string path = document.CreateNavigator().Evaluate(path_xpath).ToString(); string file = Path.GetFileName(path); string fileLinkPath = Path.Combine(linkPath, file); if (basePath != null) { path = Path.Combine(basePath, path); } // *SECURIY* The path name may be derived from user entered meta data in Doc Studio and as such // it is not trustworthy. To pass, the path must be inside the directory tree base_directory // (which is the current directory if a path is not specified). // This test is causing problems /* * string absoluteBasePath = (basePath == null) ? Directory.GetCurrentDirectory() : Path.GetFullPath(basePath); * string targetPath = Path.GetDirectoryName(path); * if (!targetPath.StartsWith(absoluteBasePath, StringComparison.CurrentCultureIgnoreCase)) { * WriteMessage(MessageLevel.Error, string.Format("Cannot save document outside of base directory: {0}", targetPath)); * return; * } */ string targetDirectory = Path.GetDirectoryName(path); if (!Directory.Exists(targetDirectory)) { Directory.CreateDirectory(targetDirectory); } // save the document // select_expression determines which nodes get saved. If there is no select_expression // we simply save the root node as before. If there is a select_expression, we evaluate the // xpath expression and save the resulting node set. The select expression also enables the // "literal-text" processing instruction, which outputs its content as unescaped text. if (select_expression == null) { XmlNode doctype = document.DocumentType; try { //Console.WriteLine("path = '{0}'", path); //document.Save(path); using (XmlWriter writer = XmlWriter.Create(path, settings)) { document.Save(writer); } } catch (IOException e) { WriteMessage(MessageLevel.Error, String.Format("An access error occured while attempting to save to the file '{0}'. The error message is: {1}", path, BuildComponentUtilities.GetExceptionMessage(e))); } catch (XmlException e) { WriteMessage(MessageLevel.Error, String.Format("Invalid XML was written to the output file '{0}'. The error message is: '{1}'", path, BuildComponentUtilities.GetExceptionMessage(e))); } // Get the relative html path for HXF generation. int index = fileLinkPath.IndexOf('/'); string htmlPath = fileLinkPath.Substring(index + 1, fileLinkPath.Length - (index + 1)); FileCreatedEventArgs fe = new FileCreatedEventArgs(htmlPath, Path.GetDirectoryName(targetDirectory)); OnComponentEvent(fe); } else { // IMPLEMENTATION NOTE: The separate StreamWriter is used to maintain XML indenting. // Without it the XmlWriter won't honor our indent settings after plain text nodes have been // written. settings.ConformanceLevel = ConformanceLevel.Auto; using (StreamWriter output = File.CreateText(path)) { using (XmlWriter writer = XmlWriter.Create(output, settings)) { XPathExpression select_xpath = select_expression.Clone(); select_xpath.SetContext(context); XPathNodeIterator ni = document.CreateNavigator().Select(select_expression); while (ni.MoveNext()) { if (ni.Current.NodeType == XPathNodeType.ProcessingInstruction && ni.Current.Name.Equals("literal-text")) { writer.Flush(); output.Write(ni.Current.Value); } else { ni.Current.WriteSubtree(writer); } } } } } }
public TransformComponent(BuildAssembler assembler, XPathNavigator configuration) : base(assembler, configuration) { // load the transforms XPathNodeIterator transform_nodes = configuration.Select("transform"); foreach (XPathNavigator transform_node in transform_nodes) { // load the transform string file = transform_node.GetAttribute("file", String.Empty); if (String.IsNullOrEmpty(file)) { WriteMessage(MessageLevel.Error, "Each transform element must specify a file attribute."); } file = Environment.ExpandEnvironmentVariables(file); Transform transform = null; try { transform = new Transform(file); } catch (IOException e) { WriteMessage(MessageLevel.Error, String.Format("The transform file '{0}' could not be loaded. The error message is: {1}", file, BuildComponentUtilities.GetExceptionMessage(e))); } catch (XmlException e) { WriteMessage(MessageLevel.Error, String.Format("The transform file '{0}' is not a valid XML file. The error message is: {1}", file, BuildComponentUtilities.GetExceptionMessage(e))); } catch (XsltException e) { WriteMessage(MessageLevel.Error, String.Format("The XSL transform '{0}' contains an error. The error message is: {1}", file, BuildComponentUtilities.GetExceptionMessage(e))); } transforms.Add(transform); // load any arguments XPathNodeIterator argument_nodes = transform_node.Select("argument"); foreach (XPathNavigator argument_node in argument_nodes) { string key = argument_node.GetAttribute("key", String.Empty); if ((key == null) || (key.Length == 0)) { WriteMessage(MessageLevel.Error, "When creating a transform argument, you must specify a key using the key attribute"); } // set "expand-value" attribute to true to expand environment variables embedded in "value". string expand_attr = argument_node.GetAttribute("expand-value", String.Empty); bool expand_value = String.IsNullOrEmpty(expand_attr) ? false : Convert.ToBoolean(expand_attr); string value = argument_node.GetAttribute("value", String.Empty); if ((value != null) && (value.Length > 0)) { transform.Arguments.AddParam(key, String.Empty, expand_value ? Environment.ExpandEnvironmentVariables(value) : value); } else { transform.Arguments.AddParam(key, String.Empty, argument_node.Clone()); } } } }
private void AddTargets(string file, LinkType2 type) { try { XPathDocument document = new XPathDocument(file); XmlTargetCollectionUtilities.AddTargets(targets, document.CreateNavigator(), type); } catch (XmlSchemaException e) { WriteMessage(MessageLevel.Error, String.Format("The reference targets file '{0}' is not valid. The error message is: {1}", file, BuildComponentUtilities.GetExceptionMessage(e))); } catch (XmlException e) { WriteMessage(MessageLevel.Error, String.Format("The reference targets file '{0}' is not well-formed XML. The error message is: {1}", file, BuildComponentUtilities.GetExceptionMessage(e))); } catch (IOException e) { WriteMessage(MessageLevel.Error, String.Format("An access error occured while opening the reference targets file '{0}'. The error message is: {1}", file, BuildComponentUtilities.GetExceptionMessage(e))); } }
private void LoadContent(string file) { WriteMessage(MessageLevel.Info, String.Format("Loading shared content file '{0}'.", file)); try { XmlReader reader = XmlReader.Create(file); try { reader.MoveToContent(); while (!reader.EOF) { if ((reader.NodeType == XmlNodeType.Element) && (reader.Name == "item")) { string key = reader.GetAttribute("id").ToLower(); string value = reader.ReadInnerXml(); if (content.ContainsKey(key)) { WriteMessage(MessageLevel.Info, String.Format("Overriding shared content item '{0}' with value in file '{1}'.", key, file)); } content[key] = value; // content.Add(key, value); } else { reader.Read(); } } } finally { reader.Close(); } } catch (IOException e) { WriteMessage(MessageLevel.Error, String.Format("The shared content file '{0}' could not be opened. The error message is: {1}", file, BuildComponentUtilities.GetExceptionMessage(e))); } catch (XmlException e) { WriteMessage(MessageLevel.Error, String.Format("The shared content file '{0}' is not well-formed. The error message is: {1}", file, BuildComponentUtilities.GetExceptionMessage(e))); } catch (XmlSchemaException e) { WriteMessage(MessageLevel.Error, String.Format("The shared content file '{0}' is not valid. The error message is: {1}", file, BuildComponentUtilities.GetExceptionMessage(e))); } }