/// <summary>
/// Initializes a new instance of the <see cref="RemoveRegionCommand" /> class.
/// </summary>
/// <param name="package">The hosting package.</param>
internal RemoveRegionCommand(CodeMaidPackage package)
: base(package,
new CommandID(PackageGuids.GuidCodeMaidCommandRemoveRegion, PackageIds.CmdIDCodeMaidRemoveRegion))
{
_codeModelHelper = CodeModelHelper.GetInstance(package);
_removeRegionLogic = RemoveRegionLogic.GetInstance(package);
}
/// <summary>
/// Initializes a new instance of the <see cref="RemoveRegionCommand" /> class.
/// </summary>
/// <param name="package">The hosting package.</param>
internal RemoveRegionCommand(CodeMaidPackage package)
: base(package,
new CommandID(PackageGuids.GuidCodeMaidCommandRemoveRegion, PackageIds.CmdIDCodeMaidRemoveRegion))
{
_codeModelHelper = CodeModelHelper.GetInstance(package);
_removeRegionLogic = RemoveRegionLogic.GetInstance(package);
}
public override bool IsEnabledFor(object target)
{
ProjectItem item = target as ProjectItem;
if (item != null)
{
try
{
if (CodeModelHelper.IsWebReferenceOrServiceReference(item))
{
return(item.ContainingProject.CodeModel.Language == CodeModelLanguageConstants.vsCMLanguageVB);
}
}
catch (Exception)
{
}
}
Project project = target as Project;
if (project != null)
{
return(project.CodeModel.Language == CodeModelLanguageConstants.vsCMLanguageVB);
}
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="RemoveRegionCommand" /> class.
/// </summary>
/// <param name="package">The hosting package.</param>
internal RemoveRegionCommand(CodeMaidPackage package)
: base(package,
new CommandID(GuidList.GuidCodeMaidCommandRemoveRegion, (int)PkgCmdIDList.CmdIDCodeMaidRemoveRegion))
{
_codeModelHelper = CodeModelHelper.GetInstance(package);
_removeRegionLogic = RemoveRegionLogic.GetInstance(package);
}
/// <summary>
/// Initializes a new instance of the <see cref="RemoveRegionCommand" /> class.
/// </summary>
/// <param name="package">The hosting package.</param>
internal RemoveRegionCommand(CodeMaidPackage package)
: base(package,
new CommandID(GuidList.GuidCodeMaidCommandRemoveRegion, (int)PkgCmdIDList.CmdIDCodeMaidRemoveRegion))
{
_codeModelHelper = CodeModelHelper.GetInstance(package);
_removeRegionLogic = RemoveRegionLogic.GetInstance(package);
}
private bool Evaluate(out object newValue)
{
newValue = null;
CodeClass currentDSAClass = ExpressionEvaluationHelper.EvaluateExpression((IDictionaryService)GetService(typeof(IDictionaryService)),
currentDSAClassExpression) as CodeClass;
if (currentDSAClass != null)
{
CodeProperty onlineProxyTypeProperty = CodeModelHelper.GetProperty(currentDSAClass, "OnlineProxyType", vsCMAccess.vsCMAccessPublic);
if (onlineProxyTypeProperty != null)
{
CodeFunction getMethod = onlineProxyTypeProperty.Getter;
EditPoint edit = getMethod.StartPoint.CreateEditPoint();
EditPoint endpoint = null;
TextRanges tags = null;
if (edit.FindPattern(@"(typeof|GetType)\((.+)\)", (int)vsFindOptions.vsFindOptionsRegularExpression, ref endpoint, ref tags))
{
EditPoint begin = edit.CreateEditPoint();
string proxyTypeName = begin.GetText(endpoint);
Regex extractRegex = new Regex(@"(typeof|GetType)\((.+)\)");
if (extractRegex.IsMatch(proxyTypeName) && extractRegex.Match(proxyTypeName).Groups.Count == 3)
{
proxyTypeName = extractRegex.Match(proxyTypeName).Groups[2].Value;
newValue = proxyTypeName;
return(true);
}
}
}
}
return(false);
}
public override bool IsEnabledFor(object target)
{
string expectedLanguage = CodeModelLanguageConstants.vsCMLanguageCSharp;
if (target is Project)
{
Project project = (Project)target;
return((project.CodeModel.Language == expectedLanguage) && ContainsRequiredReferences((Project)target));
}
if (target is ProjectItem)
{
ProjectItem item = (ProjectItem)target;
bool haveADSAClass;
CodeClass codeClass;
// We avoid the "Class not yet compiled" exception. Because this is a Reference class.
try
{
haveADSAClass = CodeModelHelper.HaveAClassInProjectItems(target, out codeClass, CodeModelHelper.IsDSAClass);
}
catch
{
haveADSAClass = false;
}
if (item.Kind == "{6BB5F8EF-4483-11D3-8BCF-00C04F8EC28C}" &&
IsNotWebReference(item) &&
(item.ContainingProject.CodeModel.Language == expectedLanguage) &&
!haveADSAClass)
{
return(ContainsRequiredReferences(item.ContainingProject));
}
return(false);
}
return(false);
}
public static void ClassInitialize(TestContext testContext)
{
_codeModelHelper = CodeModelHelper.GetInstance(TestEnvironment.Package);
Assert.IsNotNull(_codeModelHelper);
_removeRegionLogic = RemoveRegionLogic.GetInstance(TestEnvironment.Package);
Assert.IsNotNull(_removeRegionLogic);
}
public static void ClassInitialize(TestContext testContext)
{
_codeModelHelper = CodeModelHelper.GetInstance(TestEnvironment.Package);
Assert.IsNotNull(_codeModelHelper);
_removeRegionLogic = RemoveRegionLogic.GetInstance(TestEnvironment.Package);
Assert.IsNotNull(_removeRegionLogic);
}
/// <summary>
/// Retrieves the <see cref="Type"/> corresponding to the first <see cref="CodeClass"/> found in the
/// <paramref name="codeModel"/>
/// </summary>
public static Type ToType(FileCodeModel codeModel)
{
Guard.ArgumentNotNull(codeModel, "codeModel");
CodeClass cc = CodeModelHelper.FindFirstClass(codeModel.CodeElements);
return(ToType(cc));
}
private static void RunInsertBlankLinePaddingBeforeUsingStatementBlocks(Document document)
{
var codeItems = TestOperations.CodeModelManager.RetrieveAllCodeItems(document);
var usingStatements = codeItems.OfType <CodeItemUsingStatement>().ToList();
var usingStatementBlocks = CodeModelHelper.GetCodeItemBlocks(usingStatements).ToList();
var usingStatementsThatStartBlocks = (from IEnumerable <CodeItemUsingStatement> block in usingStatementBlocks select block.First()).ToList();
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(usingStatementsThatStartBlocks);
}
private static void Generate(
IEnumerable <TableDefinition> tableDefinitions,
ProjectItem mappingsProjectItem,
string templatePath)
{
// Create mapping files
foreach (var tableDefinition in tableDefinitions)
{
var mappingFileName = TableDefinitionHelper.GetMappingFileName(tableDefinition) + ".cs";
mappingsProjectItem.ProjectItems.AddFromTemplate(templatePath, mappingFileName);
}
// Add mapping instructions
foreach (ProjectItem projectItem in mappingsProjectItem.ProjectItems)
{
var name = projectItem.Name;
var tableDefinition = tableDefinitions.SingleOrDefault(t => TableDefinitionHelper.GetMappingFileName(t) + ".cs" == name);
var codeNamespace = CodeModelHelper.GetNameSpaceFromFileCode(projectItem.FileCodeModel);
var fullNamespace = codeNamespace.FullName.Replace(NamespaceValues.Mappings, NamespaceValues.Models);
// Add the import instructions.
var fileCodeModel = (FileCodeModel2)projectItem.FileCodeModel;
fileCodeModel.AddImport(fullNamespace);
fileCodeModel.AddImport(NamespaceValues.OrmMappings);
// Add inheritance to BaseMapping.
var cls = CodeModelHelper.GetCodeClassFromFileCode(projectItem.FileCodeModel);
cls.Access = vsCMAccess.vsCMAccessPublic;
var fullyQualifiedName = string.Format("BaseMapping<{0}>", tableDefinition.TableName);
cls.AddBase(fullyQualifiedName);
// Modify the constructor
cls.AddFunction(TableDefinitionHelper.GetMappingFileName(tableDefinition),
vsCMFunction.vsCMFunctionConstructor,
null,
-1,
vsCMAccess.vsCMAccessPublic, null);
var constructor = (CodeFunction)cls.Children.Item(1);
var startPoint = constructor.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
startPoint.StartOfLine();
startPoint.Indent();
startPoint.Insert("ToTable(\"" + tableDefinition.TableSchema + "." + tableDefinition.TableName + "\"); \n");
foreach (var columnDefinition in tableDefinition.ColumnDefinitions)
{
var statement = "Property(t => t." + columnDefinition.ColumnName + ").HasColumnName(\"" +
columnDefinition.ColumnName + "\"); \n";
startPoint.Indent(Count: 3);
startPoint.Insert(statement);
}
startPoint.EndOfLine();
startPoint.Indent(Count: 2);
}
}
public override bool IsEnabledFor(object target)
{
CodeClass codeClass = null;
if (CodeModelHelper.HaveAClass(target, out codeClass))
{
if (!Utility.IsSealedOrStatic(codeClass))
{
return(codeClass.Language == CodeModelLanguageConstants.vsCMLanguageCSharp);
}
}
return(false);
}
public override bool OnBeginRecipe(object currentValue, out object newValue)
{
newValue = null;
if (currentValue == null)
{
ProjectItem currentItem = ExpressionEvaluationHelper.EvaluateExpression((IDictionaryService)GetService(typeof(IDictionaryService)),
currentItemExpression) as ProjectItem;
if (currentItem != null)
{
CodeClass codeClass;
if (CodeModelHelper.HaveAClassInProjectItems(currentItem, out codeClass, CodeModelHelper.IsDSAClass))
{
newValue = codeClass;
}
return(true);
}
}
return(false);
}
public override bool IsEnabledFor(object target)
{
CodeClass codeClass = null;
bool haveADSAClass;
// We avoid the "Class not yet compiled" exception. Because this is a Reference class.
try
{
haveADSAClass = CodeModelHelper.HaveAClassInProjectItems(target, out codeClass, CodeModelHelper.IsDSAClass);
}
catch
{
haveADSAClass = false;
}
if (target is ProjectItem &&
haveADSAClass)
{
return(codeClass.Language == CodeModelLanguageConstants.vsCMLanguageCSharp);
}
return(false);
}
public override bool OnBeginRecipe(object currentValue, out object newValue)
{
DTE vs = GetService <DTE>(true);
newValue = null;
if (vs.SelectedItems.Item(1).Project == null)
{
ProjectItem webRef = vs.SelectedItems.Item(1).ProjectItem;
if (webRef == null)
{
throw new InvalidOperationException(Properties.Resources.NoProxyFound);
}
ProjectItem proxyItem = FindProxyClass(webRef.ProjectItems);
if (proxyItem == null)
{
throw new InvalidOperationException(Properties.Resources.NoProxyFound);
}
if (proxyItem.FileCodeModel == null)
{
throw new InvalidOperationException(Properties.Resources.NoProxyFound);
}
bool built = true;
object builtValue = ExpressionEvaluationHelper.EvaluateExpression((IDictionaryService)GetService(typeof(IDictionaryService)),
builtExpression);
if (builtValue != null)
{
built = (bool)builtValue;
}
if (built)
{
CodeClass proxyTypeCodeClass = CodeModelHelper.FindFirstClass(proxyItem.FileCodeModel.CodeElements, CodeModelHelper.IsProxyClass);
newValue = DteConverter.ToType(proxyTypeCodeClass);
}
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeModelBuilder" /> class.
/// </summary>
/// <param name="package">The hosting package.</param>
private CodeModelBuilder(CodeMaidPackage package)
{
_package = package;
_codeModelHelper = CodeModelHelper.GetInstance(_package);
}
private static void GenerateModels(
IEnumerable <TableDefinition> tableDefinitions,
ProjectItem modelProjectItem,
string templatePath)
{
// Generate the files
foreach (var tableDefinition in tableDefinitions)
{
modelProjectItem.ProjectItems.AddFromTemplate(templatePath,
TableDefinitionHelper.GetModelFileName(tableDefinition) + ".cs");
}
foreach (ProjectItem projectItem in modelProjectItem.ProjectItems)
{
var name = projectItem.Name;
var tableDefinition =
tableDefinitions.Single(t => TableDefinitionHelper.GetModelFileName(t) + ".cs" == name);
var cls = CodeModelHelper.GetCodeClassFromFileCode(projectItem.FileCodeModel);
cls.Access = vsCMAccess.vsCMAccessPublic;
// Create the fields
foreach (var columnDefinition in tableDefinition.ColumnDefinitions)
{
var type = ColumnDefinitionHelper.GetRefTypeOfColumnDefinition(columnDefinition);
var fieldName = ColumnDefinitionHelper.GetPropertyName(columnDefinition);
cls.AddVariable(
fieldName,
type,
-1,
vsCMAccess.vsCMAccessPrivate);
}
// Create the properties
foreach (var columnDefinition in tableDefinition.ColumnDefinitions)
{
var type = ColumnDefinitionHelper.GetRefTypeOfColumnDefinition(columnDefinition);
var fieldName = ColumnDefinitionHelper.GetPropertyName(columnDefinition);
CodeProperty property = cls.AddProperty(columnDefinition.ColumnName,
columnDefinition.ColumnName,
type, -1,
vsCMAccess.vsCMAccessPublic,
null);
// For more information about how to add a property read this book :
// http://tinyurl.com/pao4fu5
var epGetter =
property.Getter.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
epGetter.Delete(property.Getter.GetEndPoint(vsCMPart.vsCMPartBody));
epGetter.Indent();
epGetter.Insert(string.Format("return {0}; \n", fieldName));
epGetter.Indent(Count: 3);
var epSetter =
property.Setter.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
epSetter.Delete(property.Setter.GetEndPoint(vsCMPart.vsCMPartBody));
epSetter.Indent();
epSetter.Insert(string.Format("{0} = value; \n", fieldName));
epSetter.Indent(Count: 3);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RemoveRegionLogic" /> class.
/// </summary>
/// <param name="package">The hosting package.</param>
private RemoveRegionLogic(CodeMaidPackage package)
{
_package = package;
_codeModelHelper = CodeModelHelper.GetInstance(_package);
}
/// <summary>
/// Attempts to run code cleanup on the specified VB.Net document.
/// </summary>
/// <param name="document">The document for cleanup.</param>
private void RunCodeCleanupVB(Document document)
{
var textDocument = document.GetTextDocument();
// Perform any actions that can modify the file code model first.
RunExternalFormatting(textDocument);
if (!document.IsExternal())
{
_usingStatementCleanupLogic.RemoveAndSortUsingStatements(textDocument);
}
// Interpret the document into a collection of elements.
var codeItems = _codeModelManager.RetrieveAllCodeItems(document);
var regions = codeItems.OfType <CodeItemRegion>().ToList();
var usingStatements = codeItems.OfType <CodeItemUsingStatement>().ToList();
var namespaces = codeItems.OfType <CodeItemNamespace>().ToList();
var classes = codeItems.OfType <CodeItemClass>().ToList();
var delegates = codeItems.OfType <CodeItemDelegate>().ToList();
var enumerations = codeItems.OfType <CodeItemEnum>().ToList();
var events = codeItems.OfType <CodeItemEvent>().ToList();
var fields = codeItems.OfType <CodeItemField>().ToList();
var interfaces = codeItems.OfType <CodeItemInterface>().ToList();
var methods = codeItems.OfType <CodeItemMethod>().ToList();
var properties = codeItems.OfType <CodeItemProperty>().ToList();
var structs = codeItems.OfType <CodeItemStruct>().ToList();
// Build up more complicated collections.
var usingStatementBlocks = CodeModelHelper.GetCodeItemBlocks(usingStatements).ToList();
var usingStatementsThatStartBlocks = (from IEnumerable <CodeItemUsingStatement> block in usingStatementBlocks select block.First()).ToList();
var usingStatementsThatEndBlocks = (from IEnumerable <CodeItemUsingStatement> block in usingStatementBlocks select block.Last()).ToList();
// Perform file header cleanup.
_fileHeaderLogic.UpdateFileHeader(textDocument);
// Perform removal cleanup.
_removeRegionLogic.RemoveRegionsPerSettings(regions);
_removeWhitespaceLogic.RemoveEOLWhitespace(textDocument);
_removeWhitespaceLogic.RemoveBlankLinesAtTop(textDocument);
_removeWhitespaceLogic.RemoveBlankLinesAtBottom(textDocument);
_removeWhitespaceLogic.RemoveEOFTrailingNewLine(textDocument);
_removeWhitespaceLogic.RemoveBlankLinesAfterAttributes(textDocument);
_removeWhitespaceLogic.RemoveBlankLinesBetweenChainedStatements(textDocument);
_removeWhitespaceLogic.RemoveMultipleConsecutiveBlankLines(textDocument);
// Perform insertion of blank line padding cleanup.
_insertBlankLinePaddingLogic.InsertPaddingBeforeRegionTags(regions);
_insertBlankLinePaddingLogic.InsertPaddingAfterRegionTags(regions);
_insertBlankLinePaddingLogic.InsertPaddingBeforeEndRegionTags(regions);
_insertBlankLinePaddingLogic.InsertPaddingAfterEndRegionTags(regions);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(usingStatementsThatStartBlocks);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(usingStatementsThatEndBlocks);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(namespaces);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(namespaces);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(classes);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(classes);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(delegates);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(delegates);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(enumerations);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(enumerations);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(events);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(events);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(fields);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(fields);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(interfaces);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(interfaces);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(methods);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(methods);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(properties);
_insertBlankLinePaddingLogic.InsertPaddingBetweenMultiLinePropertyAccessors(properties);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(properties);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(structs);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(structs);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCaseStatements(textDocument);
_insertBlankLinePaddingLogic.InsertPaddingBeforeSingleLineComments(textDocument);
// Perform insertion of whitespace cleanup.
_insertWhitespaceLogic.InsertEOFTrailingNewLine(textDocument);
// Perform comment cleaning.
_commentFormatLogic.FormatComments(textDocument);
}
private static void Generate(
IEnumerable <TableDefinition> tableDefinitions,
ProjectItem dbContextProjectItem,
string templatePath)
{
dbContextProjectItem.ProjectItems.AddFromTemplate(templatePath, "DbContext.cs");
var projectItem = dbContextProjectItem.ProjectItems.Item(1);
var codeNamespace = CodeModelHelper.GetNameSpaceFromFileCode(projectItem.FileCodeModel);
var modelNamespace = codeNamespace.FullName.Replace(NamespaceValues.DbContext, NamespaceValues.Models);
var mappingNamespace = codeNamespace.FullName.Replace(NamespaceValues.DbContext, NamespaceValues.Mappings);
// Add the import instruction
var fileCodeModel = (FileCodeModel2)projectItem.FileCodeModel;
fileCodeModel.AddImport(NamespaceValues.OrmMappings);
fileCodeModel.AddImport(NamespaceValues.OrmCore);
fileCodeModel.AddImport(modelNamespace);
fileCodeModel.AddImport(mappingNamespace);
// Add inheritance to BaseDbContext
var cls = CodeModelHelper.GetCodeClassFromFileCode(projectItem.FileCodeModel);
cls.Access = vsCMAccess.vsCMAccessPublic;
cls.AddBase("BaseDbContext");
// Add fields
foreach (var tableDefinition in tableDefinitions)
{
var fieldName = "_" + tableDefinition.TableName.ToLower();
cls.AddVariable(
fieldName,
"IDbSet<" + tableDefinition.TableName + ">",
-1,
vsCMAccess.vsCMAccessPrivate);
}
// Add constructor
var constructorStartPoint = cls.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
constructorStartPoint.LineDown(tableDefinitions.Count());
constructorStartPoint.Indent(Count: 1);
constructorStartPoint.Insert("public DbContext() : base(\"CustomConnectionString\") { } \n");
// Add properties
foreach (var tableDefinition in tableDefinitions)
{
var fieldName = "_" + tableDefinition.TableName.ToLower();
CodeProperty property = cls.AddProperty(tableDefinition.TableName + "s",
tableDefinition.TableName + "s",
"IDbSet<" + tableDefinition.TableName + ">",
-1,
vsCMAccess.vsCMAccessPublic,
null);
var epGetter =
property.Getter.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
epGetter.Delete(property.Getter.GetEndPoint(vsCMPart.vsCMPartBody));
epGetter.Indent();
epGetter.Insert(string.Format("return {0}; \n", fieldName));
epGetter.Indent(Count: 3);
var epSetter =
property.Setter.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
epSetter.Delete(property.Setter.GetEndPoint(vsCMPart.vsCMPartBody));
epSetter.Indent();
epSetter.Insert(string.Format("{0} = value; \n", fieldName));
epSetter.Indent(Count: 3);
}
// Add mappings
var mappingEndPoint = cls.GetEndPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
mappingEndPoint.Indent(Count: 1);
mappingEndPoint.Insert("protected override void Mappings(IEntityMappingContainer entityMappingContainer) { \n");
foreach (var tableDefinition in tableDefinitions)
{
var mappingName = tableDefinition.TableName + "Mapping";
mappingEndPoint.Indent(Count: 3);
mappingEndPoint.Insert("entityMappingContainer.AddMapping(new " + mappingName + "()); \n");
}
mappingEndPoint.Indent(Count: 2);
mappingEndPoint.Insert("} \n");
}
/// <summary>
/// Initializes a new instance of the <see cref="RemoveRegionLogic" /> class.
/// </summary>
/// <param name="package">The hosting package.</param>
private RemoveRegionLogic(CodeMaidPackage package)
{
_package = package;
_codeModelHelper = CodeModelHelper.GetInstance(_package);
}
/// <summary>
/// Attempts to run code cleanup on the specified CSharp document.
/// </summary>
/// <param name="document">The document for cleanup.</param>
/// <param name="isAutoSave">A flag indicating if occurring due to auto-save.</param>
private void RunCodeCleanupCSharp(Document document, bool isAutoSave)
{
var textDocument = document.GetTextDocument();
bool isExternal = _codeCleanupAvailabilityLogic.IsDocumentExternal(document);
// Perform any actions that can modify the file code model first.
RunExternalFormatting(textDocument);
if (!isExternal)
{
_usingStatementCleanupLogic.RemoveUnusedUsingStatements(textDocument, isAutoSave);
_usingStatementCleanupLogic.SortUsingStatements(isAutoSave);
}
// Interpret the document into a collection of elements.
var codeItems = _codeModelManager.RetrieveAllCodeItems(document);
var regions = codeItems.OfType <CodeItemRegion>().ToList();
var usingStatements = codeItems.OfType <CodeItemUsingStatement>().ToList();
var namespaces = codeItems.OfType <CodeItemNamespace>().ToList();
var classes = codeItems.OfType <CodeItemClass>().ToList();
var delegates = codeItems.OfType <CodeItemDelegate>().ToList();
var enumerations = codeItems.OfType <CodeItemEnum>().ToList();
var events = codeItems.OfType <CodeItemEvent>().ToList();
var fields = codeItems.OfType <CodeItemField>().ToList();
var interfaces = codeItems.OfType <CodeItemInterface>().ToList();
var methods = codeItems.OfType <CodeItemMethod>().ToList();
var properties = codeItems.OfType <CodeItemProperty>().ToList();
var structs = codeItems.OfType <CodeItemStruct>().ToList();
// Build up more complicated collections.
var usingStatementBlocks = CodeModelHelper.GetCodeItemBlocks(usingStatements).ToList();
var usingStatementsThatStartBlocks = (from IEnumerable <CodeItemUsingStatement> block in usingStatementBlocks select block.First()).ToList();
var usingStatementsThatEndBlocks = (from IEnumerable <CodeItemUsingStatement> block in usingStatementBlocks select block.Last()).ToList();
var fieldsWithComments = fields.Where(x => x.StartPoint.Line < x.EndPoint.Line).ToList();
// Perform removal cleanup.
_removeRegionLogic.RemoveRegionsPerSettings(regions);
_removeWhitespaceLogic.RemoveEOLWhitespace(textDocument);
_removeWhitespaceLogic.RemoveBlankLinesAtTop(textDocument);
_removeWhitespaceLogic.RemoveBlankLinesAtBottom(textDocument);
_removeWhitespaceLogic.RemoveEOFTrailingNewLine(textDocument);
_removeWhitespaceLogic.RemoveBlankLinesAfterAttributes(textDocument);
_removeWhitespaceLogic.RemoveBlankLinesAfterOpeningBrace(textDocument);
_removeWhitespaceLogic.RemoveBlankLinesBeforeClosingBrace(textDocument);
_removeWhitespaceLogic.RemoveBlankLinesBetweenChainedStatements(textDocument);
_removeWhitespaceLogic.RemoveMultipleConsecutiveBlankLines(textDocument);
// Perform insertion of blank line padding cleanup.
_insertBlankLinePaddingLogic.InsertPaddingBeforeRegionTags(regions);
_insertBlankLinePaddingLogic.InsertPaddingAfterRegionTags(regions);
_insertBlankLinePaddingLogic.InsertPaddingBeforeEndRegionTags(regions);
_insertBlankLinePaddingLogic.InsertPaddingAfterEndRegionTags(regions);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(usingStatementsThatStartBlocks);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(usingStatementsThatEndBlocks);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(namespaces);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(namespaces);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(classes);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(classes);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(delegates);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(delegates);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(enumerations);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(enumerations);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(events);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(events);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(fieldsWithComments);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(fieldsWithComments);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(interfaces);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(interfaces);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(methods);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(methods);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(properties);
_insertBlankLinePaddingLogic.InsertPaddingBetweenMultiLinePropertyAccessors(properties);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(properties);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCodeElements(structs);
_insertBlankLinePaddingLogic.InsertPaddingAfterCodeElements(structs);
_insertBlankLinePaddingLogic.InsertPaddingBeforeCaseStatements(textDocument);
_insertBlankLinePaddingLogic.InsertPaddingBeforeSingleLineComments(textDocument);
// Perform insertion of explicit access modifier cleanup.
_insertExplicitAccessModifierLogic.InsertExplicitAccessModifiersOnClasses(classes);
_insertExplicitAccessModifierLogic.InsertExplicitAccessModifiersOnDelegates(delegates);
_insertExplicitAccessModifierLogic.InsertExplicitAccessModifiersOnEnumerations(enumerations);
_insertExplicitAccessModifierLogic.InsertExplicitAccessModifiersOnEvents(events);
_insertExplicitAccessModifierLogic.InsertExplicitAccessModifiersOnFields(fields);
_insertExplicitAccessModifierLogic.InsertExplicitAccessModifiersOnInterfaces(interfaces);
_insertExplicitAccessModifierLogic.InsertExplicitAccessModifiersOnMethods(methods);
_insertExplicitAccessModifierLogic.InsertExplicitAccessModifiersOnProperties(properties);
_insertExplicitAccessModifierLogic.InsertExplicitAccessModifiersOnStructs(structs);
// Perform update cleanup.
_updateLogic.UpdateEndRegionDirectives(textDocument);
_updateLogic.UpdateEventAccessorsToBothBeSingleLineOrMultiLine(events);
_updateLogic.UpdatePropertyAccessorsToBothBeSingleLineOrMultiLine(properties);
_updateLogic.UpdateSingleLineMethods(methods);
// Perform comment cleaning.
_commentFormatLogic.FormatComments(textDocument);
}