private static void TestMain(BuildDocumenter documenter,
TestOptions options)
{
string helpTestDir = Path.Combine(sampleDir, @"SampleTopics\");
// Prepare the documents and project file paths
//string projectFile = Path.Combine(helpTestDir, "Topics.xml");
string projectFile = Path.Combine(helpTestDir, "Topics.sandtopics");
string documentsDir = Path.Combine(helpTestDir, "Documents");
// First add the conceptual contents for the topics...
ConceptualGroup testsGroup = new ConceptualGroup(
"Test Topics", TestGroupIds.SampleTopicsGroupId);
testsGroup.ChangeHistory = ConceptualChangeHistory.ShowFreshnessDate;
testsGroup.RunningHeaderText = "Sandcastle Helpers: Test Topics";
testsGroup.CreateContent(documentsDir, projectFile);
string mediaLinks = Path.Combine(helpTestDir, "MediaContent.media");
MediaContent mediaContent = new MediaContent(mediaLinks,
Path.Combine(helpTestDir, "Media"));
//mediaContent.Load();
testsGroup.AddMedia(mediaContent);
testsGroup.AddSnippet(new CodeSnippetContent(Path.Combine(
helpTestDir, "CodeSnippetSample.snippets")));
ConceptualContent content = testsGroup.Content;
testsGroup.ContentFile = new BuildFilePath(Path.Combine(workingDir,
"MainConceptual" + BuildFileExts.ConceptualGroupExt));
content.ContentFile = new BuildFilePath(Path.Combine(workingDir,
"MainConceptual" + BuildFileExts.ConceptualContentExt));
documenter.AddGroup(testsGroup);
}
public override IList <BuildGroup> Create(BuildSettings settings,
BuildContext context)
{
bool includesConceptuals = this.IncludesConceptuals;
bool includesReferences = this.IncludesReferences;
BuildLogger logger = null;
if (context != null && context.IsInitialized)
{
logger = context.Logger;
if (!settings.BuildConceptual)
{
includesConceptuals = false;
}
if (!settings.BuildReferences)
{
includesReferences = false;
}
}
// 1. This source must be usable...
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 import group source '{0}' is invalid.", this.Title),
BuildLoggerLevel.Warn);
}
return(null);
}
// 2. At least one group must be allowed...
if (!includesConceptuals && !includesReferences)
{
return(null);
}
// 3. Go over the list and create the requested groups...
List <BuildGroup> groups = new List <BuildGroup>();
for (int i = 0; i < _listImports.Count; i++)
{
BuildGroup group = null;
BuildFilePath importFile = _listImports[i];
if (importFile == null || !importFile.Exists)
{
if (logger != null)
{
logger.WriteLine(String.Format(
"The import file '{0}' for '{1}' does not exist.",
importFile.Path, this.Title), BuildLoggerLevel.Warn);
}
continue;
}
string importExt = importFile.Extension;
if (!String.IsNullOrEmpty(importExt))
{
if (logger != null)
{
logger.WriteLine(String.Format(
"The import file '{0}' for '{1}' does not have a valid file extension.",
importFile.Path, this.Title), BuildLoggerLevel.Warn);
}
continue;
}
if (includesConceptuals && includesReferences)
{
if (importExt.Equals(BuildFileExts.ConceptualGroupExt,
StringComparison.OrdinalIgnoreCase))
{
group = new ConceptualGroup();
}
else if (importExt.Equals(BuildFileExts.ReferenceGroupExt,
StringComparison.OrdinalIgnoreCase))
{
group = new ReferenceGroup();
}
}
else if (includesConceptuals)
{
if (importExt.Equals(BuildFileExts.ConceptualGroupExt,
StringComparison.OrdinalIgnoreCase))
{
group = new ConceptualGroup();
}
}
else if (includesReferences)
{
if (importExt.Equals(BuildFileExts.ReferenceGroupExt,
StringComparison.OrdinalIgnoreCase))
{
group = new ReferenceGroup();
}
}
// Try loading the group, if created...
if (group != null)
{
group.Load(importFile);
}
// Add the group if valid...
if (group != null && !group.IsEmpty)
{
groups.Add(group);
}
}
return(groups);
}
private static void TestXsdDocsWiX(BuildDocumenter documenter,
TestOptions options)
{
string baseDir = Path.Combine(sampleDir, @"SampleXsdDocs\WiX\");
if (!Directory.Exists(baseDir))
{
throw new InvalidOperationException(String.Format(
"The directory '{0}' does not exists.", baseDir));
}
// First add the conceptual contents for the topics...
ConceptualGroup xsdGroup = new ConceptualGroup(
"XsdDocs - WiX Schema", TestGroupIds.XsdDocsWizGroupId);
xsdGroup.SyntaxType = BuildSyntaxType.None;
xsdGroup.RunningHeaderText = "Sandcastle XsdDocs: WiX Schema";
ConceptualXsdDocSource xsdSource = new ConceptualXsdDocSource();
// Use the default properties with the following changes...
xsdSource.SchemaSetContainer = true;
xsdSource.SchemaSetTitle = "WiX Installer Schema References";
xsdSource.TransformFileName = new BuildFilePath(Path.Combine(baseDir,
"AnnotationTranform.xslt"));
IList <BuildFilePath> documentFiles = xsdSource.ExternalDocumentFileNames;
if (documentFiles == null)
{
documentFiles = new BuildList <BuildFilePath>();
xsdSource.ExternalDocumentFileNames = documentFiles;
}
documentFiles.Add(new BuildFilePath(Path.Combine(baseDir,
"SchemaSetDoc.xml")));
IList <BuildFilePath> schemaFiles = xsdSource.SchemaFileNames;
if (schemaFiles == null)
{
schemaFiles = new BuildList <BuildFilePath>();
xsdSource.SchemaFileNames = schemaFiles;
}
string[] files = Directory.GetFiles(Path.Combine(baseDir, "Schemas"));
if (files == null || files.Length == 0)
{
return;
}
for (int i = 0; i < files.Length; i++)
{
schemaFiles.Add(new BuildFilePath(files[i]));
}
IDictionary <string, string> nsRenaming = xsdSource.NamespaceRenaming;
if (nsRenaming == null)
{
nsRenaming = new BuildProperties();
xsdSource.NamespaceRenaming = nsRenaming;
}
nsRenaming["http://schemas.microsoft.com/wix/2006/localization"]
= "Localization Schema";
nsRenaming["http://schemas.microsoft.com/wix/2006/wi"]
= "Database Schema";
nsRenaming["http://schemas.microsoft.com/wix/ComPlusExtension"]
= "COM+ Extension Schema";
nsRenaming["http://schemas.microsoft.com/wix/DifxAppExtension"]
= "Driver Extension Schema";
nsRenaming["http://schemas.microsoft.com/wix/FirewallExtension"]
= "Firewall Extension Schema";
nsRenaming["http://schemas.microsoft.com/wix/GamingExtension"]
= "Gaming Extension Schema";
nsRenaming["http://schemas.microsoft.com/wix/IIsExtension"]
= "IIS Extension Schema";
nsRenaming["http://schemas.microsoft.com/wix/MsmqExtension"]
= "MSMQ Extension Schema";
nsRenaming["http://schemas.microsoft.com/wix/NetFxExtension"]
= ".NET Framework Extension Schema";
nsRenaming["http://schemas.microsoft.com/wix/PSExtension"]
= "PowerShell Extension Schema";
nsRenaming["http://schemas.microsoft.com/wix/SqlExtension"]
= "SQL Server Extension Schema";
nsRenaming["http://schemas.microsoft.com/wix/UtilExtension"]
= "Utility Extension Schema";
nsRenaming["http://schemas.microsoft.com/wix/VSExtension"]
= "Visual Studio Extension Schema";
xsdGroup.Source = xsdSource;
documenter.AddGroup(xsdGroup);
}
private bool CreateConfiguration(ConceptualGroup group)
{
BuildExceptions.NotNull(group, "group");
BuildContext context = this.Context;
BuildLogger logger = context.Logger;
BuildSettings settings = context.Settings;
BuildGroupContext groupContext = context.GroupContexts[group.Id];
if (groupContext == null)
{
throw new BuildException(
"The group context is not provided, and it is required by the build system.");
}
string workingDir = context.WorkingDirectory;
string configDir = settings.ConfigurationDirectory;
if (String.IsNullOrEmpty(workingDir))
{
if (logger != null)
{
logger.WriteLine(
"The working directory is required, it is not specified.",
BuildLoggerLevel.Error);
}
return(false);
}
ConceptualConfigurator assembler = new ConceptualConfigurator();
try
{
assembler.Initialize(context);
string configFile = String.Empty;
string finalConfigFile = String.Empty;
if (!String.IsNullOrEmpty(configDir) && Directory.Exists(configDir))
{
configFile = Path.Combine(configDir, "Conceptual.config");
finalConfigFile = Path.Combine(workingDir,
groupContext["$ConfigurationFile"]);
}
if (!File.Exists(configFile))
{
configFile = String.Empty;
}
// 1. Configure the build assembler...
if (!String.IsNullOrEmpty(configFile))
{
assembler.Configure(group, configFile, finalConfigFile);
_manifestFile = Path.Combine(workingDir,
groupContext["$ManifestFile"]);
_configurationFile = finalConfigFile;
}
}
finally
{
if (assembler != null)
{
assembler.Uninitialize();
}
}
return(true);
}
public StepConceptualInit(ConceptualGroup group)
{
BuildExceptions.NotNull(group, "group");
_group = group;
}
/// <summary>
/// This reads and sets its state or attributes stored in a <c>XML</c> format
/// with the given reader.
/// </summary>
/// <param name="reader">
/// The reader with which the <c>XML</c> attributes of this object are accessed.
/// </param>
/// <exception cref="ArgumentNullException">
/// If the <paramref name="reader"/> is <see langword="null"/>.
/// </exception>
public override void ReadXml(XmlReader reader)
{
BuildExceptions.NotNull(reader, "reader");
Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (reader.NodeType != XmlNodeType.Element)
{
return;
}
if (!String.Equals(reader.Name, TagName,
StringComparison.OrdinalIgnoreCase))
{
Debug.Assert(false, String.Format(
"The element name '{0}' does not match the expected '{1}'.",
reader.Name, TagName));
return;
}
// Read the version information of the file group...
string tempText = reader.GetAttribute("version");
if (!String.IsNullOrEmpty(tempText))
{
_version = new Version(tempText);
}
if (reader.IsEmptyElement)
{
return;
}
if (_listGroups == null || _listGroups.Count != 0)
{
_listGroups = new BuildKeyedList <BuildGroup>();
}
if (_listSources == null || _listSources.Count != 0)
{
_listSources = new BuildKeyedList <BuildGroupSource>();
}
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (String.Equals(reader.Name, BuildSettings.TagName,
StringComparison.OrdinalIgnoreCase))
{
if (_settings == null)
{
_settings = new BuildSettings();
}
_settings.ReadXml(reader);
}
else if (String.Equals(reader.Name, BuildGroup.TagName,
StringComparison.OrdinalIgnoreCase))
{
BuildGroup group = null;
tempText = reader.GetAttribute("type");
if (String.Equals(tempText, "Conceptual",
StringComparison.OrdinalIgnoreCase))
{
group = new ConceptualGroup();
}
else if (String.Equals(tempText, "Reference",
StringComparison.OrdinalIgnoreCase))
{
group = new ReferenceGroup();
}
else
{
throw new NotImplementedException(tempText);
}
if (reader.IsEmptyElement)
{
string sourceFile = reader.GetAttribute("source");
if (!String.IsNullOrEmpty(sourceFile))
{
group.ContentFile = new BuildFilePath(sourceFile);
group.Load();
}
}
else
{
group.ReadXml(reader);
}
_listGroups.Add(group);
}
else if (String.Equals(reader.Name, BuildGroupSource.TagName,
StringComparison.OrdinalIgnoreCase))
{
BuildGroupSource source = BuildGroupSource.CreateSource(
reader.GetAttribute("name"));
if (source == null)
{
throw new BuildException(String.Format(
"The creation of the group source '{0}' failed.",
reader.GetAttribute("name")));
}
source.ReadXml(reader);
_listSources.Add(source);
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
if (String.Equals(reader.Name, TagName,
StringComparison.OrdinalIgnoreCase))
{
break;
}
}
}
}
