public void SaveOptions(CodeAnalysisOptions options)
{
using (var optionsFile = File.Open(Path.Combine(this.basePath, FileConfigName), FileMode.OpenOrCreate, FileAccess.Write))
{
var bytes = Encoding.UTF8.GetBytes(FileConfigurationOptions.GetDefaultJson(options));
optionsFile.Write(bytes, 0, bytes.Length);
optionsFile.Flush();
}
}
public static string GetContainingContext(CSharpSyntaxNode node, CodeAnalysisOptions displayInfo)
{
string ancestorContext = GetAncestorContext(node, displayInfo);
string classModuleContext = GetClassModuleContext(node, displayInfo);
string methodContext = GetMethodContext(node, displayInfo);
string sourceContext = GetSourceContext(node, displayInfo);
return(ancestorContext + classModuleContext + methodContext + sourceContext);
}
private static string GetMethodContext(CSharpSyntaxNode node, CodeAnalysisOptions displayInfo)
{
string methodContext = "";
if (displayInfo.DisplayMethodName)
{
methodContext += string.Format(" Method:({0, -35})", Helpers.CS.GetContainingMethodName(node));
}
else if (displayInfo.DisplayContainingMethodBlock)
{
methodContext += string.Format(" MethodBlock:({0})", Helpers.CS.GetContainingMethodBlock(node));
}
return(methodContext);
}
private static string GetClassModuleContext(CSharpSyntaxNode node, CodeAnalysisOptions displayInfo)
{
string classModuleContext = "";
if (displayInfo.DisplayClassOrModuleName)
{
var inClassBlock = node.Ancestors()
.Where(x => x.IsKind(SyntaxKind.ClassDeclaration))
.Cast <ClassDeclarationSyntax>().ToList();
//var inModuleBlock = node.Ancestors()
// .Where(x => x.IsKind(SyntaxKind.ModuleBlock))
// .Cast<ModuleBlockSyntax>().ToList();
string typeName = "unknown";
string className = "unknown";
string moduleName = "unknown";
if (inClassBlock.Count > 0)
{
typeName = "Class";
className = node.Ancestors()
.Where(x => x.IsKind(SyntaxKind.ClassDeclaration))
.Cast <ClassDeclarationSyntax>().First().Identifier.ToString();
}
//if (inModuleBlock.Count > 0)
//{
// typeName = "Module";
// moduleName = node.Ancestors()
// .Where(x => x.IsKind(SyntaxKind.ModuleBlock))
// .Cast<ModuleBlockSyntax>().First().ModuleStatement.Identifier.ToString();
//}
classModuleContext = String.Format("{0, 8}{1,6}:({2,-25})",
classModuleContext,
typeName,
typeName == "Class" ? className : moduleName);
}
return(classModuleContext);
}
public static CodeAnalysisOptions FromRoot(IConfigurationRoot provider)
{
var options = new CodeAnalysisOptions
{
ExtractAssembler = new ExtractAssemblerOptions
{
ImplementDtoConvert = provider.GetValue("ExtractAssembler:ImplementDtoConvert", CodeAnalysisOptions.Default.ExtractAssembler.ImplementDtoConvert),
ImplementModelConvert = provider.GetValue("ExtractAssembler:ImplementModelConvert", CodeAnalysisOptions.Default.ExtractAssembler.ImplementModelConvert)
},
ExtractDto = new ExtractDtoOptions
{
DefaultNamespace = provider.GetValue("ExtractDto:DefaultNamespace", CodeAnalysisOptions.Default.ExtractDto.DefaultNamespace),
Folders = provider.GetValue("ExtractDto:Folders", CodeAnalysisOptions.Default.ExtractDto.Folders),
ImplementMethods = provider.GetValue("ExtractDto:ImplementMethods", CodeAnalysisOptions.Default.ExtractDto.ImplementMethods),
Project = provider.GetValue("ExtractDto:Project", CodeAnalysisOptions.Default.ExtractDto.Project)
}
};
return(options);
}
private static string GetSourceContext(CSharpSyntaxNode node, CodeAnalysisOptions displayInfo)
{
string sourceContext = "";
if (displayInfo.DisplaySourceLocation)
{
var location = node.GetLocation();
var sourceSpan = location.SourceSpan;
var lineSpan = location.GetLineSpan();
//// NB. Lines start at 0. Add one so when we look in Visual Studio it makes sense.
//var startLine = location.GetLineSpan().StartLinePosition.Line + 1;
//var endLine = location.GetLineSpan().EndLinePosition.Line + 1;
sourceContext = string.Format("SourceSpan: {0} LineSpan: {1}",
sourceSpan.ToString(),
lineSpan.ToString());
}
return(sourceContext);
}
private NameSyntax GetNewNamespaceName(CodeAnalysisOptions options, Document document)
{
string newNamespaceName = string.Empty;
if (string.IsNullOrEmpty(options.ExtractDto.DefaultNamespace))
{
newNamespaceName = document.Project.Name;
}
else
{
newNamespaceName = options.ExtractDto.DefaultNamespace;
}
if (options.ExtractDto.Folders != null && options.ExtractDto.Folders.Any())
{
newNamespaceName += "." + string.Join(".", options.ExtractDto.Folders);
}
else
{
newNamespaceName += "." + string.Join(".", document.Folders);
}
return(SyntaxFactory.ParseName(newNamespaceName));
}
public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContext context, CodeAnalysisOptions options)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
var node = root.FindNode(context.Span);
var namespaceDeclaration = this.GetNameSpaceDeclaration(node);
if (namespaceDeclaration != null)
{
context.RegisterRefactoring(new FixNamespaceCodeAction(context.Document, namespaceDeclaration));
}
}
public async override Task ComputeRefactoringsAsync(CodeRefactoringContext context, CodeAnalysisOptions options)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
var node = root.FindNode(context.Span);
var decl = node as TypeDeclarationSyntax;
if (decl != null)
{
context.RegisterRefactoring(CreateUnitTestsCodeAction.Create(context, decl));
}
}
private static string GetAncestorContext(CSharpSyntaxNode node, CodeAnalysisOptions displayInfo)
{
string ancestorContext = "";
if (displayInfo.DisplayContainingBlock)
{
ancestorContext += GetContainingBlock(node).Kind().ToString();
}
if (displayInfo.InTryBlock)
{
var inTryBlock = node.Ancestors()
.Where(x => x.IsKind(SyntaxKind.TryStatement))
.Cast <TryStatementSyntax>().ToList();
if (inTryBlock.Count > 0)
{
ancestorContext += "T ";
}
}
if (displayInfo.InWhileBlock)
{
var inDoWhileBlock = node.Ancestors()
.Where(x => x.IsKind(SyntaxKind.WhileStatement))
.Cast <WhileStatementSyntax>().ToList();
if (inDoWhileBlock.Count > 0)
{
ancestorContext += "W ";
}
}
if (displayInfo.InForBlock)
{
var inForBlock = node.Ancestors()
.Where(x => x.IsKind(SyntaxKind.ForStatement))
.Cast <ForStatementSyntax>().ToList();
if (inForBlock.Count > 0)
{
ancestorContext += "F ";
}
}
if (displayInfo.InIfBlock)
{
var inMultiLineIfBlock = node.Ancestors()
.Where(x => x.IsKind(SyntaxKind.IfStatement))
.Cast <IfStatementSyntax>().ToList();
if (inMultiLineIfBlock.Count > 0)
{
ancestorContext += "I ";
}
}
if (ancestorContext.Length > 0)
{
ancestorContext = string.Format("{0,8}", ancestorContext);
}
return(ancestorContext);
}
public ExtractDtoCodeAction(CodeAnalysisOptions options, Document document, TypeDeclarationSyntax typeDeclaration)
{
this.document = document;
this.options = options;
this.typeDeclaration = typeDeclaration;
}
public abstract Task ComputeRefactoringsAsync(CodeRefactoringContext context, CodeAnalysisOptions options);
public static string GetDefaultJson(CodeAnalysisOptions options)
{
return(JsonConvert.SerializeObject(options, Formatting.Indented));
}
