public override void Refactor(MoveFolderModel model, IRewriteSession rewriteSession)
{
var sourceFolderParent = model.FolderToMove.ParentFolder();
var changeFolderModel = new ChangeFolderModel(sourceFolderParent, model.ModulesToMove, model.TargetFolder);
_changeFolder.Refactor(changeFolderModel, rewriteSession);
}
public override void Refactor(MoveMultipleToFolderModel model, IRewriteSession rewriteSession)
{
foreach (var target in model.Targets.Distinct())
{
var targetModel = new MoveToFolderModel(target, model.TargetFolder);
_moveToFolder.Refactor(targetModel, rewriteSession);
}
}
public override void Refactor(MoveMultipleFoldersModel model, IRewriteSession rewriteSession)
{
foreach (var sourceFolder in model.ModulesBySourceFolder.Keys)
{
var targetModel = new MoveFolderModel(sourceFolder, model.ModulesBySourceFolder[sourceFolder], model.TargetFolder);
_moveFolder.Refactor(targetModel, rewriteSession);
}
}
private void Rename(IReadOnlyCollection <IEncapsulateFieldCandidate> fields, IRewriteSession rewriteSession)
{
var fieldToNewNamePairs = fields.Where(f => !f.BackingIdentifier.Equals(f.Declaration.IdentifierName, StringComparison.InvariantCultureIgnoreCase))
.Select(f => (f.Declaration, f.BackingIdentifier));
var model = new ReplaceDeclarationIdentifierModel(fieldToNewNamePairs);
_replaceDeclarationIdentifiers.Refactor(model, rewriteSession);
}
public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
{
var model = new ImplicitTypeToExplicitModel(result.Target)
{
ForceVariantAsType = true
};
_refactoring.Refactor(model, rewriteSession);
}
private void AddInterfaceMembersToClass(ExtractInterfaceModel model, IRewriteSession rewriteSession)
{
var targetModule = model.TargetDeclaration.QualifiedModuleName;
var interfaceName = model.InterfaceName;
var membersToImplement = model.SelectedMembers.Select(m => m.Member).ToList();
var addMembersModel = new AddInterfaceImplementationsModel(targetModule, interfaceName, membersToImplement);
_addImplementationsRefactoringAction.Refactor(addMembersModel, rewriteSession);
}
public virtual string Preview(TModel model)
{
var rewriteSession = RewriteSession(RewriteSessionCodeKind);
_refactoringAction.Refactor(model, rewriteSession);
var componentToShow = ComponentToShow(model);
var rewriter = rewriteSession.CheckOutModuleRewriter(componentToShow);
return(rewriter.GetText());
}
public override void Refactor(RenameFolderModel model, IRewriteSession rewriteSession)
{
var sourceFolderParent = model.OriginalFolder.ParentFolder();
var targetFolder = string.IsNullOrEmpty(sourceFolderParent)
? model.NewSubFolder
: $"{sourceFolderParent}{FolderExtensions.FolderDelimiter}{model.NewSubFolder}";
var changeFolderModel = new ChangeFolderModel(model.OriginalFolder, model.ModulesToMove, targetFolder);
_changeFolder.Refactor(changeFolderModel, rewriteSession);
}
private void InsertNewContent(EncapsulateFieldUseBackingFieldModel model, List <IEncapsulateFieldCandidate> candidatesRequiringNewBackingFields, IRewriteSession rewriteSession)
{
var aggregator = model.NewContentAggregator ?? _newContentAggregatorFactory.Create();
model.NewContentAggregator = null;
var encapsulateFieldInsertNewCodeModel = new EncapsulateFieldInsertNewCodeModel(model.SelectedFieldCandidates)
{
CandidatesRequiringNewBackingFields = candidatesRequiringNewBackingFields,
NewContentAggregator = aggregator
};
_encapsulateFieldInsertNewCodeRefactoringAction.Refactor(encapsulateFieldInsertNewCodeModel, rewriteSession);
}
private void ReplaceEncapsulatedFieldReferences(IEnumerable <IEncapsulateFieldCandidate> fieldCandidates, IRewriteSession rewriteSession)
{
var model = new ReplaceReferencesModel()
{
ModuleQualifyExternalReferences = true
};
foreach (var field in fieldCandidates)
{
InitializeModel(model, field);
}
_replaceReferencesRefactoringAction.Refactor(model, rewriteSession);
}
private void InsertNewContent(EncapsulateFieldUseBackingUDTMemberModel model, IRewriteSession rewriteSession)
{
var aggregator = model.NewContentAggregator ?? _newContentAggregatorFactory.Create();
model.NewContentAggregator = null;
var encapsulateFieldInsertNewCodeModel = new EncapsulateFieldInsertNewCodeModel(model.SelectedFieldCandidates)
{
NewContentAggregator = aggregator,
ObjectStateUDTField = model.ObjectStateUDTField
};
_encapsulateFieldInsertNewCodeRefactoringAction.Refactor(encapsulateFieldInsertNewCodeModel, rewriteSession);
}
private void ReplaceUDTMemberReferencesOfPrivateUDTFields(IEnumerable <IEncapsulateFieldCandidate> udtFieldCandidates, IRewriteSession rewriteSession)
{
if (!udtFieldCandidates.Any())
{
return;
}
var replacePrivateUDTMemberReferencesModel
= _replaceUDTMemberReferencesModelFactory.Create(udtFieldCandidates.Select(f => f.Declaration).Cast <VariableDeclaration>());
foreach (var udtfield in udtFieldCandidates)
{
InitializeModel(replacePrivateUDTMemberReferencesModel, udtfield);
}
_replaceUDTMemberReferencesRefactoringAction.Refactor(replacePrivateUDTMemberReferencesModel, rewriteSession);
}
private void ImplementMissingMembers(ModuleDeclaration targetInterface, ModuleDeclaration targetClass, IRewriteSession rewriteSession)
{
var implemented = targetClass.Members
.Where(decl => decl is ModuleBodyElementDeclaration member && ReferenceEquals(member.InterfaceImplemented, targetInterface))
.Cast <ModuleBodyElementDeclaration>()
.Select(member => member.InterfaceMemberImplemented).ToList();
var interfaceMembers = targetInterface.Members.OrderBy(member => member.Selection.StartLine)
.ThenBy(member => member.Selection.StartColumn);
var nonImplementedMembers = interfaceMembers.Where(member => !implemented.Contains(member));
var addMembersModel = new AddInterfaceImplementationsModel(targetClass.QualifiedModuleName, targetInterface.IdentifierName, nonImplementedMembers.ToList());
_addImplementationsRefactoringAction.Refactor(addMembersModel, rewriteSession);
}
private void ReplaceEncapsulatedFieldReferences(IEnumerable <IEncapsulateFieldCandidate> nonPrivateUDTFields, IObjectStateUDT objectStateUDTField, IRewriteSession rewriteSession)
{
if (!nonPrivateUDTFields.Any())
{
return;
}
var replaceReferencesModel = new ReplaceReferencesModel()
{
ModuleQualifyExternalReferences = true,
};
foreach (var field in nonPrivateUDTFields)
{
InitializeModel(replaceReferencesModel, field, objectStateUDTField);
}
_replaceReferencesRefactoringAction.Refactor(replaceReferencesModel, rewriteSession);
}
private void ModifyFields(EncapsulateFieldUseBackingUDTMemberModel encapsulateFieldModel, IRewriteSession rewriteSession)
{
var rewriter = rewriteSession.CheckOutModuleRewriter(encapsulateFieldModel.QualifiedModuleName);
if (encapsulateFieldModel.ObjectStateUDTField.IsExistingDeclaration)
{
var model = new ModifyUserDefinedTypeModel(encapsulateFieldModel.ObjectStateUDTField.AsTypeDeclaration);
foreach (var candidate in encapsulateFieldModel.SelectedFieldCandidates)
{
model.AddNewMemberPrototype(candidate.Declaration, candidate.BackingIdentifier);
}
_modifyUDTRefactoringAction.Refactor(model, rewriteSession);
}
rewriter.RemoveVariables(encapsulateFieldModel.SelectedFieldCandidates.Select(f => f.Declaration)
.Cast <VariableDeclaration>());
}
public override void Refactor(ChangeFolderModel model, IRewriteSession rewriteSession)
{
var originalFolder = model.OriginalFolder;
foreach (var module in model.ModulesToMove.Distinct())
{
var currentFolder = module.CustomFolder;
if (!currentFolder.StartsWith(originalFolder))
{
continue;
}
var newFolder = currentFolder.Equals(originalFolder)
? model.NewFolder
: $"{model.NewFolder}{FolderExtensions.FolderDelimiter}{currentFolder.SubFolderPathRelativeTo(model.OriginalFolder)}";
var moduleModel = new MoveToFolderModel(module, newFolder);
_moveToFolder.Refactor(moduleModel, rewriteSession);
}
}
public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
{
_refactoring.Refactor(new ImplicitTypeToExplicitModel(result.Target), rewriteSession);
}