internal string ConstructParentPath(string parentPath, XmlElementContext context, string argumentString) { Debug.Assert(this.parentPath == null && this.context == null && this.argumentString == null, "Do not call ConstructPath recursively"); string resultPath = String.Empty; if (this.parentPath == null && this.context == null && this.argumentString == null) { try { this.parentPath = parentPath; this.context = context; this.argumentString = argumentString; resultPath = ParentPath; } finally { this.parentPath = null; this.context = null; this.argumentString = null; this.arguments = null; ReleaseLogger(); } } return(resultPath); }
private void HandleMissingTarget(XmlElementContext matchFailureContext, bool existedInOriginal) { string messageFormat = existedInOriginal ? SR.XMLTRANSFORMATION_TransformSourceMatchWasRemoved : SR.XMLTRANSFORMATION_TransformNoMatchingTargetNodes; string message = string.Format(CultureInfo.CurrentCulture, messageFormat, matchFailureContext.XPath); switch (MissingTargetMessage) { case MissingTargetMessage.None: Log.LogMessage(MessageType.Verbose, message); break; case MissingTargetMessage.Information: Log.LogMessage(MessageType.Normal, message); break; case MissingTargetMessage.Warning: Log.LogWarning(matchFailureContext.Node, message); break; case MissingTargetMessage.Error: throw new XmlNodeException(message, matchFailureContext.Node); } }
public XmlElementContext(XmlElementContext parent, XmlElement element, XmlDocument xmlTargetDoc, IServiceProvider serviceProvider) : base(element) { this.parentContext = parent; this.xmlTargetDoc = xmlTargetDoc; this.serviceProvider = serviceProvider; }
private void PreprocessTransformDocument() { hasTransformNamespace = false; foreach (XmlAttribute attribute in xmlTransformation.SelectNodes("//namespace::*")) { if (attribute.Value.Equals(TransformNamespace, StringComparison.Ordinal)) { hasTransformNamespace = true; break; } } if (hasTransformNamespace) { // This will look for all nodes from our namespace in the document, // and do any initialization work XmlNamespaceManager namespaceManager = new XmlNamespaceManager(new NameTable()); namespaceManager.AddNamespace("xdt", TransformNamespace); XmlNodeList namespaceNodes = xmlTransformation.SelectNodes("//xdt:*", namespaceManager); foreach (XmlNode node in namespaceNodes) { XmlElement element = node as XmlElement; if (element == null) { Debug.Fail("The XPath for elements returned something that wasn't an element?"); continue; } XmlElementContext context = null; try { switch (element.LocalName) { case "Import": context = CreateElementContext(null, element); PreprocessImportElement(context); break; default: logger.LogWarning(element, SR.XMLTRANSFORMATION_UnknownXdtTag, element.Name); break; } } catch (Exception ex) { if (context != null) { ex = WrapException(ex, context); } logger.LogErrorFromException(ex); throw new XmlTransformationException(SR.XMLTRANSFORMATION_FatalTransformSyntaxError, ex); } finally { context = null; } } } }
private void PreprocessImportElement(XmlElementContext context) { string assemblyName = null; string nameSpace = null; string path = null; foreach (XmlAttribute attribute in context.Element.Attributes) { if (attribute.NamespaceURI.Length == 0) { switch (attribute.Name) { case "assembly": assemblyName = attribute.Value; continue; case "namespace": nameSpace = attribute.Value; continue; case "path": path = attribute.Value; continue; } } throw new XmlNodeException(string.Format(CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportUnknownAttribute, attribute.Name), attribute); } if (assemblyName != null && path != null) { throw new XmlNodeException(string.Format(CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportAttributeConflict), context.Element); } else if (assemblyName == null && path == null) { throw new XmlNodeException(string.Format(CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportMissingAssembly), context.Element); } else if (nameSpace == null) { throw new XmlNodeException(string.Format(CultureInfo.CurrentCulture, SR.XMLTRANSFORMATION_ImportMissingNamespace), context.Element); } else { if (assemblyName != null) { namedTypeFactory.AddAssemblyRegistration(assemblyName, nameSpace); } else { namedTypeFactory.AddPathRegistration(path, nameSpace); } } }
private void TransformLoop(XmlNodeContext parentContext) { foreach (XmlNode node in parentContext.Node.ChildNodes) { XmlElement element = node as XmlElement; if (element == null) { continue; } XmlElementContext context = CreateElementContext(parentContext as XmlElementContext, element); try { HandleElement(context); } catch (Exception ex) { HandleException(ex, context); } } }
internal bool HasTargetNode(out XmlElementContext failedContext, out bool existedInOriginal) { failedContext = null; existedInOriginal = false; if (TargetNodes.Count == 0) { failedContext = this; while (failedContext.parentContext != null && failedContext.parentContext.TargetNodes.Count == 0) { failedContext = failedContext.parentContext; } existedInOriginal = ExistedInOriginal(failedContext.XPath); return(false); } return(true); }
internal bool HasTargetParent(out XmlElementContext failedContext, out bool existedInOriginal) { failedContext = null; existedInOriginal = false; if (TargetParents.Count == 0) { failedContext = this; while (failedContext.parentContext != null && !String.IsNullOrEmpty(failedContext.parentContext.ParentXPath) && failedContext.parentContext.TargetParents.Count == 0) { failedContext = failedContext.parentContext; } existedInOriginal = ExistedInOriginal(failedContext.XPath); return(false); } return(true); }
private void HandleElement(XmlElementContext context) { string argumentString; Transform transform = context.ConstructTransform(out argumentString); if (transform != null) { bool fOriginalSupressWarning = logger.SupressWarnings; XmlAttribute SupressWarningsAttribute = context.Element.Attributes.GetNamedItem(XmlTransformation.SupressWarnings, XmlTransformation.TransformNamespace) as XmlAttribute; if (SupressWarningsAttribute != null) { bool fSupressWarning = Convert.ToBoolean(SupressWarningsAttribute.Value, CultureInfo.InvariantCulture); logger.SupressWarnings = fSupressWarning; } try { OnApplyingTransform(); transform.Execute(context, argumentString); OnAppliedTransform(); } catch (Exception ex) { HandleException(ex, context); } finally { // reset back the SupressWarnings back per node logger.SupressWarnings = fOriginalSupressWarning; } } // process children TransformLoop(context); }
internal void Execute(XmlElementContext context, string argumentString) { Debug.Assert(this.context == null && this.argumentString == null, "Don't call Execute recursively"); Debug.Assert(this.logger == null, "Logger wasn't released from previous execution"); if (this.context == null && this.argumentString == null) { bool error = false; bool startedSection = false; try { this.context = context; this.argumentString = argumentString; this.arguments = null; if (ShouldExecuteTransform()) { startedSection = true; Log.StartSection(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformBeginExecutingMessage, TransformNameLong); Log.LogMessage(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformStatusXPath, context.XPath); if (ApplyTransformToAllTargetNodes) { ApplyOnAllTargetNodes(); } else { ApplyOnce(); } } } catch (Exception ex) { error = true; if (context.TransformAttribute != null) { Log.LogErrorFromException(XmlNodeException.Wrap(ex, context.TransformAttribute)); } else { Log.LogErrorFromException(ex); } } finally { if (startedSection) { if (error) { Log.EndSection(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformErrorExecutingMessage, TransformNameShort); } else { Log.EndSection(MessageType.Verbose, SR.XMLTRANSFORMATION_TransformEndExecutingMessage, TransformNameShort); } } else { Log.LogMessage(MessageType.Normal, SR.XMLTRANSFORMATION_TransformNotExecutingMessage, TransformNameLong); } this.context = null; this.argumentString = null; this.arguments = null; ReleaseLogger(); } } }
private XmlElementContext CreateElementContext(XmlElementContext parentContext, XmlElement element) { return(new XmlElementContext(parentContext, element, xmlTarget, this)); }