protected override void OnReadContents(XmlReader reader) { if (_dependencies == null) { _dependencies = new DependencyContent(); } if (reader.IsEmptyElement) { return; } string startElement = reader.Name; Debug.Assert(String.Equals(startElement, "content", StringComparison.OrdinalIgnoreCase)); if (!String.Equals(startElement, "content", StringComparison.OrdinalIgnoreCase)) { return; } if (reader.ReadToDescendant(DependencyContent.TagName)) { _dependencies.ReadXml(reader); } }
/// <overloads> /// Initializes a new instance of the <see cref="ReferenceLinkSource"/> class. /// </overloads> /// <summary> /// Initializes a new instance of the <see cref="ReferenceLinkSource"/> class /// with the default parameters. /// </summary> public ReferenceLinkSource() { _sourceId = Guid.NewGuid().ToString(); _linkType = BuildLinkType.Local; _listItems = new BuildList <ReferenceItem>(); _dependencies = new DependencyContent(); _frameworkType = BuildFrameworkType.None; }
/// <summary> /// Initializes a new instance of the <see cref="ReferenceLinkSource"/> class /// with parameters copied from the specified instance of the /// <see cref="ReferenceLinkSource"/> class, a copy constructor. /// </summary> /// <param name="source"> /// An instance of the <see cref="ReferenceLinkSource"/> class from which the /// initialization parameters or values will be copied. /// </param> /// <exception cref="ArgumentNullException"> /// If the parameter <paramref name="source"/> is <see langword="null"/>. /// </exception> public ReferenceLinkSource(ReferenceLinkSource source) : base(source) { _linkType = source._linkType; _sourceId = source._sourceId; _listItems = source._listItems; _dependencies = source._dependencies; _frameworkType = source._frameworkType; }
public ReferenceContent() { _contentVersion = new Version(1, 0, 0, 0); _contentId = Guid.NewGuid().ToString(); _frameworkType = BuildFrameworkType.Framework20; _dependencies = new DependencyContent(); _tocContent = new HierarchicalTocContent(); _commentContent = new CommentContent(); _typeFilters = new ReferenceRootFilter(false); _attributeFilters = new ReferenceRootFilter(true); }
public void AddDependency(string assembly) { if (String.IsNullOrEmpty(assembly)) { return; } if (_dependencies == null) { _dependencies = new DependencyContent(); } _dependencies.Add(new DependencyItem( Path.GetFileName(assembly), assembly)); }
/// <summary> /// This creates the dependency information after the reflection. /// </summary> /// <param name="dependencies"></param> /// <param name="dependencyDir"></param> private void CreateDependency(DependencyContent dependencies, string dependencyDir) { if (dependencies == null || dependencies.Count == 0) { return; } int itemCount = dependencies.Count; for (int i = 0; i < itemCount; i++) { DependencyItem dependency = dependencies[i]; if (dependency == null || dependency.IsEmpty) { continue; } string dependencyFile = dependency.Location; // There is no need to include a reference assembly, if it is // a dependent assembly... //if (!String.IsNullOrEmpty(dependencyFile) // && !_dictReference.ContainsKey(dependencyFile)) // However, for some cases, especially where there is redirection // of assembly, the explicit dependency is still required... if (!String.IsNullOrEmpty(dependencyFile)) { string fileName = Path.GetFileName(dependencyFile); fileName = Path.Combine(dependencyDir, fileName); if (!File.Exists(fileName)) { File.Copy(dependencyFile, fileName, true); File.SetAttributes(fileName, FileAttributes.Normal); // Set if the comment file exists and link it... dependencyFile = Path.ChangeExtension(dependencyFile, ".xml"); if (File.Exists(dependencyFile)) { _linkCommentFiles.Add(dependencyFile); } if (dependency.IsRedirected) { _bindingRedirects.Add(dependency); } } } } }
public ReferenceContent(ReferenceContent source) : base(source) { _isLoaded = source._isLoaded; _contentId = source._contentId; _contentVersion = source._contentVersion; _contentFile = source._contentFile; _contentDir = source._contentDir; _frameworkType = source._frameworkType; _tocContent = source._tocContent; _dependencies = source._dependencies; _commentContent = source._commentContent; _typeFilters = source._typeFilters; _attributeFilters = source._attributeFilters; }
public override ReferenceContent Create(BuildGroupContext groupContext) { BuildExceptions.NotNull(groupContext, "groupContext"); BuildContext context = groupContext.Context; BuildLogger logger = null; if (context != null) { logger = context.Logger; } if (!this.IsInitialized) { throw new BuildException(String.Format( "The content source '{0}' is not yet initialized.", this.Title)); } if (!this.IsValid) { if (logger != null) { logger.WriteLine(String.Format( "The content group source '{0}' is invalid.", this.Title), BuildLoggerLevel.Warn); } return(null); } string searchPattern = _searchPattern; if (String.IsNullOrEmpty(searchPattern)) { searchPattern = "*.dll"; } string[] fullPaths = Directory.GetFiles(_sourcePath.Path, searchPattern, _isRecursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly); if (fullPaths == null || fullPaths.Length == 0) { return(null); } HashSet <string> dependencyDirs = new HashSet <string>( StringComparer.OrdinalIgnoreCase); Dictionary <string, string> assemblies = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); foreach (string fullPath in fullPaths) { string fileName = Path.GetFileName(fullPath); if (assemblies.ContainsKey(fileName) || (_excludeSet.Count != 0 && _excludeSet.Contains(fileName))) { continue; } // We will not use the assemblies without comments as // dependencies, since we cannot verify these are .NET DLLs. string commentFile = Path.ChangeExtension(fullPath, ".xml"); if (!File.Exists(commentFile)) { continue; } string dependencyDir = Path.GetDirectoryName(fullPath); if (!dependencyDir.EndsWith("\\")) { dependencyDir += "\\"; } dependencyDirs.Add(dependencyDir); assemblies[fileName] = fullPath; } if (assemblies.Count == 0) { return(null); } ReferenceContent content = new ReferenceContent(); // Set the framework version... if (_frameworkType == BuildFrameworkType.Null || _frameworkType == BuildFrameworkType.None) { BuildFramework framework = BuildFrameworks.LatestFramework; if (framework == null) { // If not successful, use the default... framework = BuildFrameworks.DefaultFramework; } content.FrameworkType = framework.FrameworkType; } else { content.FrameworkType = _frameworkType; } foreach (KeyValuePair <string, string> pair in assemblies) { string assemblyFile = pair.Value; string commentFile = Path.ChangeExtension(assemblyFile, ".xml"); content.AddItem(commentFile, assemblyFile); } // Provide the dependency information for the content... DependencyContent depContents = content.Dependencies; foreach (string dependencyDir in dependencyDirs) { depContents.Paths.Add(new BuildDirectoryPath(dependencyDir)); } // Provide other user-supplied information to the content... content.Comments = this.Comments; content.HierarchicalToc = this.HierarchicalToc; content.TypeFilters = this.TypeFilters; content.AttributeFilters = this.AttributeFilters; return(content); }
private void ResolveDependency(ReferenceGroupContext sourceContext, ReferenceContent referenceContent) { BuildContext context = this.Context; BuildLogger logger = context.Logger; BuildFramework framework = sourceContext.Framework; if (framework == null) { throw new BuildException("No valid framework is specified."); } DependencyContent dependencies = referenceContent.Dependencies; _resolveContent = new DependencyContent(); _listReference = new List <ReferenceItem>(); _dictionary = new Dictionary <string, bool>( StringComparer.OrdinalIgnoreCase); _dictDependency = new Dictionary <string, bool>( StringComparer.OrdinalIgnoreCase); _dictReference = new Dictionary <string, bool>( StringComparer.OrdinalIgnoreCase); if (dependencies != null && dependencies.Count != 0) { for (int i = 0; i < dependencies.Count; i++) { DependencyItem depItem = dependencies[i]; if (!depItem.IsEmpty) { _dictDependency[depItem.Location] = true; } } } // Index the reference items to prevent cross referencing... if (referenceContent != null && referenceContent.Count != 0) { for (int i = 0; i < referenceContent.Count; i++) { ReferenceItem refItem = referenceContent[i]; if (!refItem.IsEmpty && !refItem.IsCommentOnly) { string refAssembly = refItem.Assembly; if (!_dictReference.ContainsKey(refAssembly)) { _dictReference[refAssembly] = true; _listReference.Add(refItem); } } } } GeneralAssemblyResolver resolver = new GeneralAssemblyResolver(); // Add the reference item directories, the most likely place to // find the dependencies for (int i = 0; i < _listReference.Count; i++) { resolver.AddSearchDirectory( Path.GetDirectoryName(_listReference[i].Assembly)); } // Add specified dependency directories, if any... IList <BuildDirectoryPath> dependencyPaths = dependencies.Paths; if (dependencyPaths != null && dependencyPaths.Count != 0) { for (int i = 0; i < dependencyPaths.Count; i++) { BuildDirectoryPath dependencyPath = dependencyPaths[i]; if (dependencyPath.Exists) { resolver.AddSearchDirectory(dependencyPath); } } } Version version = framework.Version; // Add, for the Silverlight, known installation directories... BuildFrameworkKind frameworkKind = framework.FrameworkType.Kind; if (frameworkKind == BuildFrameworkKind.Silverlight) { resolver.UseGac = false; string programFiles = PathUtils.ProgramFiles32; string searchDir = Path.Combine(programFiles, @"Microsoft Silverlight\" + version.ToString()); if (Directory.Exists(searchDir)) { resolver.AddSearchDirectory(searchDir); } searchDir = Path.Combine(programFiles, @"Reference Assemblies\Microsoft\Framework\Silverlight\v" + version.ToString(2)); if (Directory.Exists(searchDir)) { resolver.AddSearchDirectory(searchDir); } else { if (version.Major == 5 && version.Minor > 0) { // For Silverlight 5.1, the assemblies are in different places... searchDir = Path.Combine(programFiles, @"Reference Assemblies\Microsoft\Framework\Silverlight\v5.0"); if (Directory.Exists(searchDir)) { resolver.AddSearchDirectory(searchDir); } } } searchDir = Path.Combine(programFiles, @"Microsoft SDKs\Silverlight\v" + version.ToString(2)); if (!Directory.Exists(searchDir)) { if (version.Major == 5 && version.Minor > 0) { // For Silverlight 5.1, the assemblies are in different places... searchDir = Path.Combine(programFiles, @"Microsoft SDKs\Silverlight\v5.0"); } } if (Directory.Exists(searchDir)) { resolver.AddSearchDirectory(searchDir); string tempDir = String.Copy(searchDir); searchDir = Path.Combine(tempDir, @"Libraries\Client"); if (Directory.Exists(searchDir)) { resolver.AddSearchDirectory(searchDir); } searchDir = Path.Combine(tempDir, @"Libraries\Server"); if (Directory.Exists(searchDir)) { resolver.AddSearchDirectory(searchDir); } } if (version.Major == 3) { // 3. The Expression 3.0 Blend SDK... string otherDir = Path.Combine(programFiles, @"Microsoft SDKs\Expression\Blend 3\Interactivity\Libraries\Silverlight"); if (Directory.Exists(otherDir)) { resolver.AddSearchDirectory(otherDir); } otherDir = Path.Combine(programFiles, @"Microsoft SDKs\Expression\Blend 3\Prototyping\Libraries\Silverlight"); if (Directory.Exists(otherDir)) { resolver.AddSearchDirectory(otherDir); } } else if (version.Major == 4) { // Consider the extension libraries... // 1. The RIA Services... string otherDir = Path.Combine(programFiles, @"Microsoft SDKs\RIA Services\v1.0\Libraries\Silverlight"); if (Directory.Exists(otherDir)) { resolver.AddSearchDirectory(otherDir); } // 2. For the Silverlight Toolkit... otherDir = Path.Combine(programFiles, @"Microsoft SDKs\Silverlight\v4.0\Toolkit"); if (Directory.Exists(otherDir)) { // Get the latest installed version... string[] dirs = Directory.GetDirectories(otherDir); if (dirs != null && dirs.Length != 0) { string dir = String.Empty; DateTime latestDt = DateTime.MinValue; for (int j = 0; j < dirs.Length; j++) { string latestDir = Path.GetFileName(dirs[j]); DateTime dt; if (DateTime.TryParse(latestDir, out dt)) { if (dt > latestDt) { latestDt = dt; dir = latestDir; } } } otherDir = Path.Combine(otherDir, dir + @"\Bin"); if (Directory.Exists(otherDir)) { resolver.AddSearchDirectory(otherDir); } } } // 3. The Expression 4.0 Blend SDK... otherDir = Path.Combine(programFiles, @"Microsoft SDKs\Expression\Blend\Silverlight\v4.0\Libraries"); if (Directory.Exists(otherDir)) { resolver.AddSearchDirectory(otherDir); } } else if (version.Major == 5) { // Consider the extension libraries... // 1. The RIA Services... string otherDir = Path.Combine(programFiles, @"Microsoft SDKs\RIA Services\v1.0\Libraries\Silverlight"); if (Directory.Exists(otherDir)) { resolver.AddSearchDirectory(otherDir); } // 2. For the Silverlight Toolkit... otherDir = Path.Combine(programFiles, @"Microsoft SDKs\Silverlight\v5.0\Toolkit"); if (Directory.Exists(otherDir)) { // Get the latest installed version... string[] dirs = Directory.GetDirectories(otherDir); if (dirs != null && dirs.Length != 0) { string dir = String.Empty; DateTime latestDt = DateTime.MinValue; for (int j = 0; j < dirs.Length; j++) { string latestDir = Path.GetFileName(dirs[j]); DateTime dt; if (DateTime.TryParse(latestDir, out dt)) { if (dt > latestDt) { latestDt = dt; dir = latestDir; } } } otherDir = Path.Combine(otherDir, dir + @"\Bin"); if (Directory.Exists(otherDir)) { resolver.AddSearchDirectory(otherDir); } } } // 3. The Expression 5.0 Blend SDK... otherDir = Path.Combine(programFiles, @"Microsoft SDKs\Expression\Blend\Silverlight\v5.0\Libraries"); if (Directory.Exists(otherDir)) { resolver.AddSearchDirectory(otherDir); } } } else if (frameworkKind == BuildFrameworkKind.Portable) { resolver.UseGac = false; resolver.AddSearchDirectory(framework.AssemblyDir); } else if (frameworkKind == BuildFrameworkKind.ScriptSharp) { resolver.UseGac = false; resolver.AddSearchDirectory(framework.AssemblyDir); } else if (frameworkKind == BuildFrameworkKind.Compact) { resolver.UseGac = false; resolver.AddSearchDirectory(framework.AssemblyDir); } else if (frameworkKind == BuildFrameworkKind.DotNet) { string programFiles = Environment.GetFolderPath( Environment.SpecialFolder.ProgramFiles); if (version.Major == 3) { // 3. The Expression 3.0 Blend SDK... string otherDir = Path.Combine(programFiles, @"Microsoft SDKs\Expression\Blend 3\Interactivity\Libraries\.NETFramework"); if (Directory.Exists(otherDir)) { resolver.AddSearchDirectory(otherDir); } } else if (version.Major == 4) { string otherDir = Path.Combine(programFiles, @"Microsoft SDKs\Expression\Blend\.NETFramework\v4.0\Libraries"); if (Directory.Exists(otherDir)) { resolver.AddSearchDirectory(otherDir); } } } else { throw new NotSupportedException(String.Format( "The framework kind '{0}' is not supported.", frameworkKind.ToString())); } // Finally, we look inside the binding sources if we are dealing // with link sources... if (sourceContext.IsLinkGroup || sourceContext.IsEmbeddedGroup) { IList <string> bindingSources = sourceContext.BindingSources; if (bindingSources != null && bindingSources.Count != 0) { foreach (string bindingSource in bindingSources) { if (!String.IsNullOrEmpty(bindingSource) && Directory.Exists(bindingSource)) { resolver.AddSearchDirectory(bindingSource); } } } } for (int i = 0; i < _listReference.Count; i++) { ReferenceItem refItem = _listReference[i]; AssemblyDefinition asmDef = AssemblyDefinition.ReadAssembly( refItem.Assembly); ModuleDefinition modDef = asmDef.MainModule; // Try resolving all the dependencies... if (modDef.HasAssemblyReferences) { IList <AssemblyNameReference> asmRefs = modDef.AssemblyReferences; if (asmRefs != null && asmRefs.Count != 0) { for (int j = 0; j < asmRefs.Count; j++) { this.Resolve(logger, asmRefs[j], resolver, frameworkKind); } } } // Try resolving all the XmlnsDefinitionAttribute attributes... if (asmDef.HasCustomAttributes && refItem.XamlSyntax) { this.ResolveXmlnsDefinitions(sourceContext, asmDef, modDef.Name); } } string[] searchDirs = resolver.GetSearchDirectories(); if (searchDirs != null && searchDirs.Length != 0) { if (_searchDirectories == null) { _searchDirectories = new HashSet <string>(StringComparer.OrdinalIgnoreCase); } for (int i = 0; i < searchDirs.Length; i++) { string searchDir = Path.GetFullPath(String.Copy(searchDirs[i])); if (!searchDir.EndsWith("\\")) { searchDir += "\\"; } _searchDirectories.Add(searchDir); } } }
/// <summary> /// Applies the processing operations defined by this visitor to the /// specified reference group. /// </summary> /// <param name="group"> /// The <see cref="ReferenceGroup">reference group</see> to which the processing /// operations defined by this visitor will be applied. /// </param> /// <exception cref="ArgumentNullException"> /// If the <paramref name="group"/> is <see langword="null"/>. /// </exception> protected override void OnVisit(ReferenceGroup group) { BuildExceptions.NotNull(group, "group"); if (!this.IsInitialized) { throw new BuildException( "ReferenceProjectVisitor: The reference dependency resolver is not initialized."); } BuildContext context = this.Context; BuildLogger logger = context.Logger; if (logger != null) { logger.WriteLine("Begin - Resolving reference dependencies.", BuildLoggerLevel.Info); } ReferenceGroupContext groupContext = context.GroupContexts[group.Id] as ReferenceGroupContext; if (groupContext == null) { throw new BuildException( "The group context is not provided, and it is required by the build system."); } ReferenceGroupContext sourceContext = groupContext; if (!String.IsNullOrEmpty(_sourceId)) { sourceContext = groupContext.Contexts[_sourceId] as ReferenceGroupContext; } if (sourceContext == null) { throw new BuildException( "The group context is not provided, and it is required by the build system."); } _linkCommentFiles = new List <string>(); _bindingRedirects = new List <DependencyItem>(); _searchDirectories = new HashSet <string>(StringComparer.OrdinalIgnoreCase); sourceContext.LinkCommentFiles = _linkCommentFiles; sourceContext.BindingRedirects = _bindingRedirects; // We add the comment files from the link sources so that the // document can contain comments from these sources if needed... IList <ReferenceLinkSource> linkSources = context.GetValue("$ReferenceLinkSources") as IList <ReferenceLinkSource>; if (linkSources != null && linkSources.Count != 0) { for (int i = 0; i < linkSources.Count; i++) { ReferenceLinkSource linkSource = linkSources[i]; IEnumerable <ReferenceItem> linkItems = linkSource.Items; foreach (ReferenceItem linkItem in linkItems) { // Set if the comment file exists and link it... BuildFilePath linkCommentPath = linkItem.Comments; if (linkCommentPath != null && linkCommentPath.Exists) { _linkCommentFiles.Add(linkCommentPath.Path); } else { string linkCommentFile = Path.ChangeExtension( linkItem.Assembly, ".xml"); if (File.Exists(linkCommentFile)) { _linkCommentFiles.Add(linkCommentFile); } } } } } string dependencyDir = sourceContext.DependencyDir; string searchDir = String.Copy(dependencyDir); if (!searchDir.EndsWith("\\")) { searchDir += "\\"; } _searchDirectories.Add(searchDir); ReferenceContent content = _content; if (content == null) { content = group.Content; } DependencyContent dependencies = content.Dependencies; _dependencyContent = dependencies; this.ResolveDependency(sourceContext, content); if (_dependencyContent != null && _dependencyContent.Count != 0) { this.CreateDependency(_dependencyContent, dependencyDir); } if (_resolveContent != null && _resolveContent.Count != 0) { this.CreateDependency(_resolveContent, dependencyDir); } //IList<string> bindingSources = sourceContext.BindingSources; //if (bindingSources == null) //{ // bindingSources = new BuildList<string>(); // sourceContext.BindingSources = bindingSources; //} //foreach (string dir in _searchDirectories) //{ // bindingSources.Add(dir); //} if (logger != null) { logger.WriteLine("Completed - Resolving reference dependencies.", BuildLoggerLevel.Info); } }
private void CreateReflectionSteps(BuildMultiStep listSteps, ReferenceGroup group, string sandcastleDir, string helpStyle) { Debug.Assert(_engineSettings != null); if (_engineSettings == null) { return; } BuildContext context = this.Context; BuildSettings settings = this.Settings; ReferenceGroupContext groupContext = context.GroupContexts[group.Id] as ReferenceGroupContext; if (groupContext == null) { throw new BuildException( "The group context is not provided, and it is required by the build system."); } string workingDir = context.WorkingDirectory; ReferenceContent content = group.Content; string assemblyDir = Path.Combine(workingDir, groupContext.AssemblyFolder); string dependencyDir = Path.Combine(workingDir, groupContext.DependencyFolder); DependencyContent dependencies = content.Dependencies; string reflectionFile = groupContext["$ReflectionFile"]; string manifestFile = groupContext["$ManifestFile"]; string refBuilderFile = groupContext["$ReflectionBuilderFile"]; string tocFile = groupContext["$TocFile"]; BuildStyleType outputStyle = settings.Style.StyleType; string tempText = null; string arguments = null; string application = null; bool ripOldApis = true; string assemblyFiles = null; string dependencyFiles = null; string outputFile = null; string configurationFile = null; ReferenceVisibilityConfiguration visibility = _engineSettings.Visibility; Debug.Assert(visibility != null); // 1. Create the reflection and the manifest StringBuilder textBuilder = new StringBuilder(); if (group.IsSingleVersion) { // Call MRefBuilder to generate the reflection... // MRefBuilder Assembly.dll // /out:reflection.org /config:MRefBuilder.config // /internal- application = Path.Combine(context.SandcastleToolsDirectory, "MRefBuilder.exe"); assemblyFiles = String.Format(@"{0}\*.*", assemblyDir); dependencyFiles = String.Format(@"{0}\*.*", dependencyDir); outputFile = Path.ChangeExtension(reflectionFile, ".ver"); configurationFile = Path.Combine(workingDir, refBuilderFile); textBuilder.Append(assemblyFiles); textBuilder.Append(" /dep:" + dependencyFiles); textBuilder.AppendFormat(" /out:{0} /config:{1}", outputFile, refBuilderFile); if (visibility != null && visibility.IncludeInternalsMembers) { textBuilder.Append(" /internal+"); } else { textBuilder.Append(" /internal-"); } arguments = textBuilder.ToString(); outputFile = Path.Combine(workingDir, outputFile); } else { // Call the VersionBuilder to create the combined reflection file... application = Path.Combine(context.SandcastleToolsDirectory, "VersionBuilder.exe"); textBuilder.AppendFormat(" /config:{0} /out:{1}", groupContext["$ApiVersionsBuilderFile"], Path.ChangeExtension(reflectionFile, ".org")); configurationFile = Path.Combine(workingDir, groupContext["$ApiVersionsBuilderFile"]); ReferenceVersionInfo versionInfo = group.VersionInfo; ripOldApis = versionInfo.RipOldApis; if (ripOldApis) { textBuilder.Append(" /rip+"); } else { textBuilder.Append(" /rip-"); } arguments = textBuilder.ToString(); } StepReflectionBuilder refBuilder = new StepReflectionBuilder(workingDir, application, arguments); refBuilder.Group = group; refBuilder.LogTitle = String.Empty; refBuilder.Message = "Creating XML-formatted reflection information."; refBuilder.CopyrightNotice = 2; // For the direct use of the Sandcastle library, we need the // following parameters... refBuilder.RipOldApis = ripOldApis; refBuilder.DocumentInternals = (visibility != null && visibility.IncludeInternalsMembers); refBuilder.ConfigurationFile = configurationFile; refBuilder.ReflectionFile = outputFile; refBuilder.AssemblyFiles.Add(assemblyFiles); refBuilder.DependencyFiles.Add(dependencyFiles); listSteps.Add(refBuilder); textBuilder.Length = 0; // 2. Create the reflection and comment refining step... StepReferenceRefine referenceRefine = new StepReferenceRefine(workingDir); referenceRefine.LogTitle = String.Empty; referenceRefine.Message = "Refining the reflection files - filtering and cleaning"; referenceRefine.Group = group; listSteps.Add(referenceRefine); textBuilder.Length = 0; // 3. Apply Transforms // XslTransform.exe // /xsl:"%DXROOT%\ProductionTransforms\ApplyVSDocModel.xsl" // reflection.org // /xsl:"%DXROOT%\ProductionTransforms\AddFriendlyFilenames.xsl" // /out:reflection.xml /arg:IncludeAllMembersTopic=true // /arg:IncludeInheritedOverloadTopics=true /arg:project=Project application = Path.Combine(context.SandcastleToolsDirectory, "XslTransform.exe"); string prodPath = Path.Combine(sandcastleDir, "ProductionTransforms"); string textTemp = String.Empty; if (group.EnableXmlnsForXaml) { textTemp = Path.Combine(prodPath, "AddXamlSyntaxData.xsl"); if (!String.IsNullOrEmpty(textTemp)) { textBuilder.AppendFormat(" /xsl:\"{0}\"", textTemp); textTemp = String.Empty; } } if (outputStyle == BuildStyleType.ClassicWhite || outputStyle == BuildStyleType.ClassicBlue) { textTemp = Path.Combine(prodPath, "ApplyVSDocModel.xsl"); } else if (outputStyle == BuildStyleType.Lightweight) { } else if (outputStyle == BuildStyleType.ScriptFree) { } if (!String.IsNullOrEmpty(textTemp)) { textBuilder.AppendFormat(" /xsl:\"{0}\"", textTemp); textTemp = String.Empty; } ReferenceNamingMethod namingMethod = _engineSettings.Naming; if (namingMethod == ReferenceNamingMethod.Guid) { textTemp = Path.Combine(prodPath, "AddGuidFilenames.xsl"); } else if (namingMethod == ReferenceNamingMethod.MemberName) { textTemp = Path.Combine(prodPath, "AddFriendlyFilenames.xsl"); } else { textTemp = Path.Combine(prodPath, "AddGuidFilenames.xsl"); } if (!String.IsNullOrEmpty(textTemp)) { textBuilder.AppendFormat(" /xsl:\"{0}\"", textTemp); textTemp = String.Empty; } textBuilder.Append(" " + Path.ChangeExtension(reflectionFile, ".org")); textBuilder.AppendFormat(" /out:{0}", reflectionFile); textBuilder.AppendFormat(" /arg:IncludeAllMembersTopic={0}", _engineSettings.IncludeAllMembersTopic ? "true" : "false"); textBuilder.AppendFormat(" /arg:IncludeInheritedOverloadTopics={0}", _engineSettings.IncludeInheritedOverloadTopics ? "true" : "false"); bool rootContainer = _engineSettings.RootNamespaceContainer; string rootTitle = group.RootNamespaceTitle; if (rootContainer && !String.IsNullOrEmpty(rootTitle)) { textBuilder.Append(" /arg:project=Project"); // Indicate that this reference group is rooted... groupContext["$IsRooted"] = Boolean.TrueString; } arguments = textBuilder.ToString(); StepReferenceModel applyDocProcess = new StepReferenceModel( workingDir, application, arguments); applyDocProcess.Group = group; applyDocProcess.LogTitle = String.Empty; applyDocProcess.Message = "Xsl Transformation - Applying model and adding filenames"; applyDocProcess.CopyrightNotice = 2; listSteps.Add(applyDocProcess); textBuilder.Length = 0; // 4. and finally the manifest... // XslTransform.exe // /xsl:"%DXROOT%\ProductionTransforms\ReflectionToManifest.xsl" // reflection.xml /out:manifest.xml application = Path.Combine(context.SandcastleToolsDirectory, "XslTransform.exe"); textTemp = Path.Combine(prodPath, "ReflectionToManifest.xsl"); textBuilder.AppendFormat(" /xsl:\"{0}\"", textTemp); textBuilder.AppendFormat(" {0} /out:{1}", reflectionFile, manifestFile); arguments = textBuilder.ToString(); StepReferenceManifest manifestProcess = new StepReferenceManifest( workingDir, application, arguments); manifestProcess.Group = group; manifestProcess.LogTitle = String.Empty; manifestProcess.Message = "Xsl Transformation - Reflection to Manifest"; manifestProcess.CopyrightNotice = 2; listSteps.Add(manifestProcess); // 5. Create the reflection table of contents // XslTransform.exe // /xsl:"%DXROOT%\ProductionTransforms\createvstoc.xsl" // reflection.xml /out:ApiToc.xml application = Path.Combine(context.SandcastleToolsDirectory, "XslTransform.exe"); if (outputStyle == BuildStyleType.ClassicWhite || outputStyle == BuildStyleType.ClassicBlue) { tempText = Path.Combine(sandcastleDir, @"ProductionTransforms\CreateVSToc.xsl"); } else if (outputStyle == BuildStyleType.Lightweight) { } else if (outputStyle == BuildStyleType.ScriptFree) { } arguments = String.Format("/xsl:\"{0}\" {1} /out:{2}", tempText, reflectionFile, tocFile); StepReferenceToc tocProcess = new StepReferenceToc(workingDir, application, arguments); tocProcess.LogTitle = String.Empty; tocProcess.Message = "Xsl Transformation - Creating References TOC"; tocProcess.Group = group; tocProcess.CopyrightNotice = 2; listSteps.Add(tocProcess); }
private void ReadContents(XmlReader reader) { if (reader.IsEmptyElement) { return; } string startElement = reader.Name; while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { if (String.Equals(reader.Name, "content", StringComparison.OrdinalIgnoreCase)) { switch (reader.GetAttribute("type").ToLower()) { case "comments": if (_commentContent == null) { _commentContent = new CommentContent(); } if (reader.IsEmptyElement) { string sourceFile = reader.GetAttribute("source"); if (!String.IsNullOrEmpty(sourceFile)) { _commentContent.ContentFile = new BuildFilePath(sourceFile); _commentContent.Load(); } } else { if (reader.ReadToDescendant(CommentContent.TagName)) { _commentContent.ReadXml(reader); } } break; case "dependencies": if (_dependencies == null) { _dependencies = new DependencyContent(); } if (!reader.IsEmptyElement && reader.ReadToDescendant( DependencyContent.TagName)) { _dependencies.ReadXml(reader); } break; case "hierarchicaltoc": if (_tocContent == null) { _tocContent = new HierarchicalTocContent(); } if (!reader.IsEmptyElement && reader.ReadToDescendant( HierarchicalTocContent.TagName)) { _tocContent.ReadXml(reader); } break; } } } else if (reader.NodeType == XmlNodeType.EndElement) { if (String.Equals(reader.Name, startElement, StringComparison.OrdinalIgnoreCase)) { break; } } } }
/// <summary> /// This creates the reference content from the available VS.NET items. /// </summary> /// <param name="groupContext"> /// The context of the group which owns this source. /// </param> /// <returns> /// An instance of the <see cref="ReferenceContent"/> if successful; /// otherwise, this is <see langword="null"/>. /// </returns> private ReferenceContent OnCreateContent(BuildGroupContext groupContext) { Dictionary <string, ProjectSection> projects = new Dictionary <string, ProjectSection>( StringComparer.OrdinalIgnoreCase); BuildContext context = groupContext.Context; string platform = context.TargetPlatform; string configuration = context.TargetConfiguration; BuildLogger logger = context.Logger; // For each item, create the project sections... for (int i = 0; i < _listItems.Count; i++) { ReferenceVsNetItem vsNetItem = _listItems[i]; if (vsNetItem != null && !vsNetItem.IsEmpty) { HashSet <string> includeSet = new HashSet <string>( vsNetItem.Includes); IList <ProjectSection> sections = ProjectSectionFactory.CreateSections( vsNetItem.SourcePath.Path, platform, configuration, includeSet); if (sections != null && sections.Count != 0) { string useXamlSyntax = vsNetItem.XamlSyntax.ToString(); for (int j = 0; j < sections.Count; j++) { ProjectSection section = sections[j]; if (!String.IsNullOrEmpty(section.TargetFrameworkVersion) || !String.IsNullOrEmpty(section.TargetFrameworkIdentifier)) { // Since the mapping from the VS.NET items // to the project section is lost after this, // we save this information... section["UseXamlSyntax"] = useXamlSyntax; projects[section.ProjectGuid] = section; } } } } } // This is not expected, no managed project is found... if (projects.Count == 0) { if (logger != null) { logger.WriteLine(String.Format( "The '{0}' reference content source does not contain any valid project.", this.Title), BuildLoggerLevel.Warn); } return(null); } IList <ProjectSection> projectSetions = new List <ProjectSection>( projects.Values); if (String.IsNullOrEmpty(_targetIdentifier)) { // We are not filtering a particular target framework... if (projectSetions.Count > 1) { BuildMultiMap <string, ProjectSection> multiSections = new BuildMultiMap <string, ProjectSection>( StringComparer.OrdinalIgnoreCase); for (int i = 0; i < projectSetions.Count; i++) { ProjectSection section = projectSetions[i]; string targetIdentifier = section.TargetFrameworkIdentifier; if (!String.IsNullOrEmpty(targetIdentifier)) { multiSections.Add(targetIdentifier, section); } } List <string> targetIdentifiers = new List <string>(multiSections.Keys); if (targetIdentifiers.Count > 1) { // Error, there are more one target framework identifier. if (logger != null) { StringBuilder builder = new StringBuilder(); for (int i = 0; i < targetIdentifiers.Count; i++) { builder.Append(targetIdentifiers[i]); if (i < (targetIdentifiers.Count - 1)) { builder.Append(";"); } } logger.WriteLine(String.Format( "The project items of '{0}' contain more than one target framework identifier '{1}'.", this.Title, builder.ToString()), BuildLoggerLevel.Error); } return(null); } } } else { IList <ProjectSection> filteredSetions = new List <ProjectSection>(projectSetions.Count); for (int i = 0; i < projectSetions.Count; i++) { ProjectSection section = projectSetions[i]; if (String.Equals(section.TargetFrameworkIdentifier, _targetIdentifier, StringComparison.OrdinalIgnoreCase)) { filteredSetions.Add(section); } } // We will use the filtered sections projectSetions = filteredSetions; } // This is not expected, no managed project is found... if (projectSetions == null || projectSetions.Count == 0) { if (logger != null) { logger.WriteLine(String.Format( "The '{0}' reference content source does not contain any valid project.", this.Title), BuildLoggerLevel.Warn); } return(null); } ReferenceContent content = new ReferenceContent(); HashSet <string> dependencyDirs = new HashSet <string>( StringComparer.OrdinalIgnoreCase); HashSet <string> referencedAssemblies = new HashSet <string>( StringComparer.OrdinalIgnoreCase); Version frameworkVersion = new Version(1, 0, 0, 0); for (int i = 0; i < projectSetions.Count; i++) { ProjectSection section = projectSetions[i]; string commentFile = section.CommentFile; if (String.IsNullOrEmpty(commentFile) || !File.Exists(commentFile)) { throw new BuildException(String.Format( "The project '{0}' has no comment file.", section.ProjectName)); } string assemblyFile = section.OutputFile; if (String.IsNullOrEmpty(assemblyFile) || !File.Exists(assemblyFile)) { throw new BuildException(String.Format( "The project '{0}' has no assembly file.", section.ProjectName)); } ReferenceItem refItem = new ReferenceItem(commentFile, assemblyFile); string tempText = section["UseXamlSyntax"]; if (!String.IsNullOrEmpty(tempText)) { refItem.XamlSyntax = Convert.ToBoolean(tempText); } // This should normally be in the format: v2.0, v3.0 etc string versionText = section.TargetFrameworkVersion; if (versionText != null && versionText.StartsWith("v", StringComparison.OrdinalIgnoreCase)) { versionText = versionText.Substring(1); } if (!String.IsNullOrEmpty(versionText)) { Version version = new Version(versionText); if (version > frameworkVersion) { frameworkVersion = version; } } content.Add(refItem); // Recursively extract the dependent assemblies information... CreateDependencies(section, dependencyDirs, referencedAssemblies); } // Provide the framework information of the content... BuildFrameworkKind frameworkKind = BuildFrameworkKind.None; string targetIdentifer = projectSetions[0].TargetFrameworkIdentifier; if (String.IsNullOrEmpty(targetIdentifer)) { if (logger != null) { logger.WriteLine("The target framework identifier is not found. Standard .NET Framework is assumed.", BuildLoggerLevel.Warn); } frameworkKind = BuildFrameworkKind.DotNet; } else { switch (targetIdentifer.ToLower()) { case ".netframework": frameworkKind = BuildFrameworkKind.DotNet; break; case "silverlight": frameworkKind = BuildFrameworkKind.Silverlight; break; case ".netportable": frameworkKind = BuildFrameworkKind.Portable; break; case "scriptsharp": // For the Script#, the version starts from 1.0 and // does not match the .NET Framework version frameworkVersion = BuildFrameworks.LatestScriptSharpVersion; frameworkKind = BuildFrameworkKind.ScriptSharp; break; case "compact": frameworkKind = BuildFrameworkKind.Compact; break; default: frameworkKind = BuildFrameworkKind.DotNet; break; } } // Get the best framework for this content... BuildFramework framework = BuildFrameworks.GetFramework( frameworkVersion.Major, frameworkVersion.Minor, frameworkKind); if (framework == null) { if (logger != null) { logger.WriteLine(String.Format( "The expected version '{0}' for '{1}', cannot be found.", frameworkVersion, this.Title), BuildLoggerLevel.Warn); } framework = BuildFrameworks.LatestFramework; if (framework == null) { // If not successful, use the default... framework = BuildFrameworks.DefaultFramework; } } content.FrameworkType = framework.FrameworkType; // Provide the dependency information for the content... DependencyContent depContents = content.Dependencies; IList <BuildDirectoryPath> depPaths = depContents.Paths; foreach (string dependencyDir in dependencyDirs) { if (String.IsNullOrEmpty(dependencyDir) || !Directory.Exists(dependencyDir)) { continue; } depPaths.Add(new BuildDirectoryPath(dependencyDir)); } foreach (string referencedAssembly in referencedAssemblies) { depContents.AddItem(referencedAssembly); } // Provide other user-supplied information to the content... content.Comments = this.Comments; content.HierarchicalToc = this.HierarchicalToc; content.TypeFilters = this.TypeFilters; content.AttributeFilters = this.AttributeFilters; return(content); }