| public static SanitizeFolder ( string folderName ) : string | ||
| folderName | string | |
| 리턴 | string | |
private void AddDocumentToFolder(Folder folder, string document, string[] subfolders)
{
if (subfolders == null || subfolders.Length == 0)
{
folder.Add(document);
return;
}
if (subfolders[0].EndsWith(":"))
{
return;
}
var folderName = Paths.SanitizeFolder(subfolders[0]);
Folder subfolder = folder.GetOrCreateFolder(folderName);
AddDocumentToFolder(subfolder, document, subfolders.Skip(1).ToArray());
}
private static string[] GetFolderChain(INamedTypeSymbol symbol)
{
var containingNamespace = symbol.ContainingNamespace;
var folders = new List<string>();
while (containingNamespace != null && !containingNamespace.IsGlobalNamespace)
{
if (!containingNamespace.CanBeReferencedByName)
{
// namespace name is mangled - we don't want it
return null;
}
var sanitizedNamespaceName = Paths.SanitizeFolder(containingNamespace.Name);
folders.Add(sanitizedNamespaceName);
containingNamespace = containingNamespace.ContainingNamespace;
}
folders.Reverse();
return folders.ToArray();
}
public async Task Generate()
{
if (Configuration.CalculateRoslynSemantics)
{
this.Text = await Document.GetTextAsync();
this.Root = await Document.GetSyntaxRootAsync();
this.SemanticModel = await Document.GetSemanticModelAsync();
this.SemanticFactsService = WorkspaceHacks.GetSemanticFactsService(this.Document);
this.SyntaxFactsService = WorkspaceHacks.GetSyntaxFactsService(this.Document);
var semanticFactsServiceType = SemanticFactsService.GetType();
var isWrittenTo = semanticFactsServiceType.GetMethod("IsWrittenTo");
this.isWrittenToDelegate = (Func <SemanticModel, SyntaxNode, CancellationToken, bool>)
Delegate.CreateDelegate(typeof(Func <SemanticModel, SyntaxNode, CancellationToken, bool>), SemanticFactsService, isWrittenTo);
var syntaxFactsServiceType = SyntaxFactsService.GetType();
var getBindableParent = syntaxFactsServiceType.GetMethod("GetBindableParent");
this.getBindableParentDelegate = (Func <SyntaxToken, SyntaxNode>)
Delegate.CreateDelegate(typeof(Func <SyntaxToken, SyntaxNode>), SyntaxFactsService, getBindableParent);
this.DeclaredSymbols = new HashSet <ISymbol>();
Interlocked.Increment(ref projectGenerator.DocumentCount);
Interlocked.Add(ref projectGenerator.LinesOfCode, Text.Lines.Count);
Interlocked.Add(ref projectGenerator.BytesOfCode, Text.Length);
}
CalculateDocumentDestinationPath();
CalculateRelativePathToRoot();
// add the file itself as a "declared symbol", so that clicking on document in search
// results redirects to the document
ProjectGenerator.AddDeclaredSymbolToRedirectMap(
this.projectGenerator.SymbolIDToListOfLocationsMap,
SymbolIdService.GetId(this.Document),
documentRelativeFilePathWithoutHtmlExtension,
0);
if (File.Exists(documentDestinationFilePath))
{
// someone already generated this file, likely a shared linked file from elsewhere
return;
}
this.classifier = new Classification();
Log.Write(documentDestinationFilePath);
try
{
var directoryName = Path.GetDirectoryName(documentDestinationFilePath);
var sanitized = Paths.SanitizeFolder(directoryName);
if (directoryName != sanitized)
{
Log.Exception("Illegal characters in path: " + directoryName + " Project: " + this.projectGenerator.AssemblyName);
}
if (Configuration.CreateFoldersOnDisk)
{
Directory.CreateDirectory(directoryName);
}
}
catch (PathTooLongException)
{
// there's one case where a path is too long - we don't care enough about it
return;
}
if (Configuration.WriteDocumentsToDisk)
{
using (var streamWriter = new StreamWriter(
documentDestinationFilePath,
append: false,
encoding: Encoding.UTF8))
{
await GenerateHtml(streamWriter);
}
}
else
{
using (var memoryStream = new MemoryStream())
using (var streamWriter = new StreamWriter(memoryStream))
{
await GeneratePre(streamWriter);
}
}
}