public void RenameRefactoring_RenameSub_ConflictingNames_Accept()
{
//Input
const string inputCode =
@"Private Sub Foo()
Dim Goo As Integer
End Sub";
var selection = new Selection(1, 14, 1, 14);
//Expectation
const string expectedCode =
@"Private Sub Goo()
Dim Goo As Integer
End Sub";
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection);
var state = MockParser.CreateAndParse(vbe.Object);
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
var vbeWrapper = vbe.Object;
var model = new RenameModel(vbeWrapper, state, qualifiedSelection, null)
{
NewName = "Goo"
};
//SetupFactory
var factory = SetupFactory(model);
var messageBox = new Mock <IMessageBox>();
messageBox.Setup(
m =>
m.Show(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <MessageBoxButtons>(),
It.IsAny <MessageBoxIcon>())).Returns(DialogResult.Yes);
var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, messageBox.Object, state);
refactoring.Refactor(qualifiedSelection);
Assert.AreEqual(expectedCode, component.CodeModule.Content());
}
public object Rename(RenameModel model)
{
var systemPath = model.SourcePath.ToSystemPath(0);
model.NewName = model.NewName.MakeSafe().Replace("\\", "");
var newSystemPath = Path.GetDirectoryName(systemPath) + "\\" + model.NewName;
if (!model.IsFolder)
{
newSystemPath += ".md";
}
Directory.Move(systemPath, newSystemPath);
return(new
{
Status = "Renamed."
});
}
public void RenameRefactoring_RenameFunction()
{
//Input
const string inputCode =
@"Private Function Foo() As Boolean
Foo = True
End Function";
var selection = new Selection(1, 21, 1, 21);
//Expectation
const string expectedCode =
@"Private Function Goo() As Boolean
Goo = True
End Function";
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection);
var state = MockParser.CreateAndParse(vbe.Object);
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
var msgbox = new Mock <IMessageBox>();
msgbox.Setup(m => m.Show(It.IsAny <string>(), It.IsAny <string>(), MessageBoxButtons.YesNo, It.IsAny <MessageBoxIcon>()))
.Returns(DialogResult.Yes);
var vbeWrapper = vbe.Object;
var model = new RenameModel(vbeWrapper, state, qualifiedSelection, msgbox.Object)
{
NewName = "Goo"
};
//SetupFactory
var factory = SetupFactory(model);
var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, msgbox.Object, state);
refactoring.Refactor(qualifiedSelection);
Assert.AreEqual(expectedCode, component.CodeModule.Content());
}
public void RenameRefactoring_RenameParameter_UpdatesReferences()
{
//Input
const string inputCode =
@"Private Sub Foo(ByVal arg1 As String)
arg1 = ""test""
End Sub";
var selection = new Selection(1, 25, 1, 25);
//Expectation
const string expectedCode =
@"Private Sub Foo(ByVal arg2 As String)
arg2 = ""test""
End Sub";
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection);
var state = MockParser.CreateAndParse(vbe.Object);
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
var msgbox = new Mock <IMessageBox>();
msgbox.Setup(m => m.Show(It.IsAny <string>(), It.IsAny <string>(), MessageBoxButtons.YesNo, It.IsAny <MessageBoxIcon>()))
.Returns(DialogResult.Yes);
var vbeWrapper = vbe.Object;
var model = new RenameModel(vbeWrapper, state, qualifiedSelection, msgbox.Object)
{
NewName = "arg2"
};
//SetupFactory
var factory = SetupFactory(model);
var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, msgbox.Object, state);
refactoring.Refactor(qualifiedSelection);
Assert.AreEqual(expectedCode, component.CodeModule.Content());
}
public async Task Rename()
{
var tree = await Facade.GetTreeAsync();
var child = tree.Children.First();
using var client = Fixture.Server.CreateClient();
var model = new RenameModel
{
Id = child.Id,
Type = child.Type,
NewName = "new name"
};
await client.PutAsJsonAsync("component/rename", model)
.Status(HttpStatusCode.OK);
child = tree.Children.First(x => x.Id == child.Id);
Assert.Equal("new name", child.Name);
}
public void RenameRefactoring_RenameCodeModule()
{
const string newName = "RenameModule";
//Input
const string inputCode =
@"Private Sub Foo(ByVal a As Integer, ByVal b As String)
End Sub";
var selection = new Selection(3, 27, 3, 27);
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleModule(inputCode, "Class1", ComponentType.ClassModule, out component, selection);
var state = MockParser.CreateAndParse(vbe.Object);
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
var msgbox = new Mock <IMessageBox>();
msgbox.Setup(m => m.Show(It.IsAny <string>(), It.IsAny <string>(), MessageBoxButtons.YesNo, It.IsAny <MessageBoxIcon>()))
.Returns(DialogResult.Yes);
var vbeWrapper = vbe.Object;
var model = new RenameModel(vbeWrapper, state, qualifiedSelection, msgbox.Object)
{
NewName = newName
};
model.Target = model.Declarations.FirstOrDefault(i => i.DeclarationType == DeclarationType.ClassModule && i.IdentifierName == "Class1");
//SetupFactory
var factory = SetupFactory(model);
var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, msgbox.Object, state);
refactoring.Refactor(model.Target);
Assert.AreSame(newName, component.CodeModule.Name);
}
public void CanMutateMock_Direct_Dialog()
{
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out var component);
var parser = MockParser.Create(vbe.Object);
using (var state = parser.State)
{
var actual = new RenameModel(state.DeclarationFinder,
new QualifiedSelection(new QualifiedModuleName(component), new Selection(2, 2)));
var container = RefactoringContainerInstaller.GetContainer();
var factory = container.Resolve <IRefactoringPresenterFactory>();
var model = new RenameModel(state.DeclarationFinder,
new QualifiedSelection(new QualifiedModuleName(component), new Selection(1, 1)));
var presenter = (RenamePresenter)factory.Create <IRenamePresenter, RenameModel>(model);
var mock = Mock.Get(presenter.Dialog);
mock.SetupGet(m => m.Model).Returns(actual);
var expected = presenter.Dialog.Model;
Assert.AreEqual(actual, expected);
}
}
void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
RenameWorkerArgument workerArgs = (RenameWorkerArgument)e.Argument;
RenameModel model = workerArgs.model;
BackgroundWorker backgroundWorker = (BackgroundWorker)sender;
backgroundWorker.ReportProgress(0);
// create worker
RenameWorker worker = new RenameWorker();
worker.currentPicture = this.currentPicture;
worker.rootDirectory = this.currentDirectory;
worker.SetFileList(workerArgs.filenames);
worker.OneFileProcessed += delegate(object s, ProgressChangedEventArgs args) { backgroundWorker.ReportProgress(args.ProgressPercentage); };
// start working
worker.ProcessFiles(model);
worker.ChangeDirectorynames = model.ChangeDirectorynames;
e.Result = worker;
}
public void RenameRefactoring_RenameProject()
{
const string oldName = "TestProject1";
const string newName = "Renamed";
var builder = new MockVbeBuilder();
var vbe = builder.ProjectBuilder(oldName, ProjectProtection.Unprotected)
.AddComponent("Module1", ComponentType.StandardModule, string.Empty)
.MockVbeBuilder()
.Build();
var state = MockParser.CreateAndParse(vbe.Object);
var msgbox = new Mock <IMessageBox>();
msgbox.Setup(m => m.Show(It.IsAny <string>(), It.IsAny <string>(), MessageBoxButtons.YesNo, It.IsAny <MessageBoxIcon>()))
.Returns(DialogResult.Yes);
var vbeWrapper = vbe.Object;
var model = new RenameModel(vbeWrapper, state, default(QualifiedSelection), msgbox.Object)
{
NewName = newName
};
model.Target = model.Declarations.First(i => i.DeclarationType == DeclarationType.Project && !i.IsBuiltIn);
//SetupFactory
var factory = SetupFactory(model);
var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, msgbox.Object, state);
refactoring.Refactor(model.Target);
Assert.AreEqual(newName, vbe.Object.VBProjects[0].Name);
}
public void RenameRefactoring_InterfaceRenamed_RejectPrompt()
{
//Input
const string inputCode1 =
@"Implements IClass1
Private Sub IClass1_DoSomething(ByVal a As Integer, ByVal b As String)
End Sub";
const string inputCode2 =
@"Public Sub DoSomething(ByVal a As Integer, ByVal b As String)
End Sub";
var selection = new Selection(3, 23, 3, 27);
var builder = new MockVbeBuilder();
var project = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected)
.AddComponent("Class1", ComponentType.ClassModule, inputCode1)
.AddComponent("IClass1", ComponentType.ClassModule, inputCode2)
.Build();
var vbe = builder.AddProject(project).Build();
var state = MockParser.CreateAndParse(vbe.Object);
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(project.Object.VBComponents[0]), selection);
var messageBox = new Mock <IMessageBox>();
messageBox.Setup(
m => m.Show(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <MessageBoxButtons>(), It.IsAny <MessageBoxIcon>()))
.Returns(DialogResult.No);
var vbeWrapper = vbe.Object;
var model = new RenameModel(vbeWrapper, state, qualifiedSelection, messageBox.Object);
Assert.AreEqual(null, model.Target);
}
public void Rename_Click(object sender, EventArgs e)
{
// get the model
RenameModel model = renameView.GetModel();
if (model.ChangeDirectorynames == false && model.ChangeFilenames == false)
{
return; // nothing to do
}
List <string> files = this.GetAllFileList(this.processFilesInSubdirectories);
if (files.Count == 0)
{
return; // nothing to do
}
// do gui / settings work
renameView.SaveLastModel();
Settings.Default.FilenameFormats.AddIfGrowing(model.FilenamePattern);
Settings.Default.DirectorynameFormats.AddIfGrowing(model.DirectoryPattern);
StopOtherWorker();
backgroundWorker.RunWorkerAsync(new RenameWorkerArgument(files, model));
}
public override void SetModel(RenameModel m)
{
base.SetModel(m);
this.bindingSource.DataSource = this.model;
}
private static Mock <IRefactoringPresenterFactory <IRenamePresenter> > SetupFactory(RenameModel model)
{
var presenter = new Mock <IRenamePresenter>();
presenter.Setup(p => p.Show()).Returns(model);
presenter.Setup(p => p.Show(It.IsAny <Declaration>())).Returns(model);
var factory = new Mock <IRefactoringPresenterFactory <IRenamePresenter> >();
factory.Setup(f => f.Create()).Returns(presenter.Object);
return(factory);
}
public RenameWorkerArgument(List <string> filenames, RenameModel model)
{
this.filenames = filenames;
this.model = model;
}
public async Task RenameAsync(RenameModel renameModel) => await GridFSBucket.RenameAsync(renameModel.DocumentId.ToObjectId(), renameModel.NewFileName);
public void RenameRefactoring_RenameFirstPropertyParameter_UpdatesAllRelatedParameters()
{
//Input
const string inputCode =
@"Property Get Foo(ByVal index As Integer) As Variant
Dim d As Integer
d = index
End Property
Property Let Foo(ByVal index As Integer, ByVal value As Variant)
Dim d As Integer
d = index
End Property
Property Set Foo(ByVal index As Integer, ByVal value As Variant)
Dim d As Integer
d = index
End Property";
var selection = new Selection(1, 28, 1, 28);
//Expectation
const string expectedCode =
@"Property Get Foo(ByVal renamed As Integer) As Variant
Dim d As Integer
d = renamed
End Property
Property Let Foo(ByVal renamed As Integer, ByVal value As Variant)
Dim d As Integer
d = renamed
End Property
Property Set Foo(ByVal renamed As Integer, ByVal value As Variant)
Dim d As Integer
d = renamed
End Property";
IVBComponent component;
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, selection);
var state = MockParser.CreateAndParse(vbe.Object);
var qualifiedSelection = new QualifiedSelection(new QualifiedModuleName(component), selection);
var msgbox = new Mock <IMessageBox>();
msgbox.Setup(m => m.Show(It.IsAny <string>(), It.IsAny <string>(), MessageBoxButtons.YesNo, It.IsAny <MessageBoxIcon>()))
.Returns(DialogResult.Yes);
var vbeWrapper = vbe.Object;
var model = new RenameModel(vbeWrapper, state, qualifiedSelection, msgbox.Object)
{
NewName = "renamed"
};
//SetupFactory
var factory = SetupFactory(model);
var refactoring = new RenameRefactoring(vbeWrapper, factory.Object, msgbox.Object, state);
refactoring.Refactor(qualifiedSelection);
Assert.AreEqual(expectedCode, component.CodeModule.Content());
}
public ActionResult Rename(RenameModel model)
{
model.TargetUrl = "/" + model.TargetUrl;
bool processParent = model.TargetUrl != Constants.CdnUrl;
model.CurrentEntry = new EntryModel(model.TargetUrl, true, processParent);
if (model.TargetUrl.Contains("..") ||
!model.TargetUrl.StartsWith(Constants.CdnUrl))
{
return(NotFoundView());
}
if (!ModelState.IsValid)
{
ModelState.AddModelError("", ValidationResources.InvalidState);
return(View(model));
}
if (string.IsNullOrEmpty(model.NewName))
{
return(RedirectToAction("List",
new
{
currentUrl =
FileManagerModel.EnsureIsDirectoryOrExtractParent(model.TargetUrl)
}));
}
if (Path.GetExtension(model.NewName) == "")
{
model.NewName += Path.GetExtension(model.OldName);
}
string targetPath = Server.MapPath(model.TargetUrl);
DirectoryInfo parent = Directory.GetParent(targetPath);
string newPath = Path.Combine(parent.FullName, model.NewName);
if (string.Compare(targetPath, newPath, StringComparison.OrdinalIgnoreCase) == 0)
{
return(RedirectToAction("List", new { currentUrl = model.TargetUrl }));
}
if ((!Directory.Exists(targetPath) && !System.IO.File.Exists(targetPath)))
{
return(NotFoundView());
}
bool isSaved;
try
{
if (Directory.Exists(targetPath))
{
Directory.Move(targetPath, newPath);
}
else
{
System.IO.File.Move(targetPath, newPath);
}
isSaved = true;
}
catch
{
isSaved = false;
}
if (isSaved)
{
Logger.SaveLog(new RenameDirectoryOrFileProvider(model));
}
else
{
TempData["Error"] = ValidationResources.RenameFailure;
}
return(RedirectToAction("List", new { currentUrl = _webHelper.MapUrl(parent.FullName) }));
}
public static void InitUserSettings()
{
if (Settings.Default.Headlines == null)
{
Settings.Default.Headlines = new TagList();
}
if (Settings.Default.Captions == null)
{
Settings.Default.Captions = new TagList();
}
if (Settings.Default.Contacts == null)
{
Settings.Default.Contacts = new TagList(true);
}
if (Settings.Default.Copyrights == null)
{
Settings.Default.Copyrights = new TagList(true);
}
if (Settings.Default.Authors == null)
{
Settings.Default.Authors = new TagList(true);
}
if (Settings.Default.Writers == null)
{
Settings.Default.Writers = new TagList(true);
}
if (Settings.Default.Objectnames == null)
{
Settings.Default.Objectnames = new TagList();
}
if (Settings.Default.Locations == null)
{
Settings.Default.Locations = new LocationList(true);
}
if (Settings.Default.FilenameFormats == null)
{
Settings.Default.FilenameFormats = new TagList(true);
Settings.Default.FilenameFormats.Add(DEFAULT_FILE_FORMAT);
}
if (Settings.Default.DirectorynameFormats == null)
{
Settings.Default.DirectorynameFormats = new TagList(true);
Settings.Default.DirectorynameFormats.Add(DEFAULT_DIRECTORY_FORMAT);
}
if (Settings.Default.GroupedKeywords == null)
{
if (Settings.Default.Keywords == null)
{
Settings.Default.GroupedKeywords = new GroupedTagList(true);
}
else
{
Settings.Default.GroupedKeywords = new GroupedTagList(Settings.Default.Keywords);
Settings.Default.Keywords = null;
}
}
if (Settings.Default.PresetModels == null)
{
Settings.Default.PresetModels = new PresetStore();
CopyMoveModel cpm = new CopyMoveModel();
cpm.FilenameFormat = DEFAULT_FILE_FORMAT;
cpm.DirectorynameFormat = DEFAULT_DIRECTORY_FORMAT;
Settings.Default.PresetModels.SaveLastModel(cpm);
RenameModel rm = new RenameModel();
rm.FilenamePattern = DEFAULT_FILE_FORMAT;
rm.DirectoryPattern = DEFAULT_DIRECTORY_FORMAT;
rm.ChangeDirectorynames = false;
rm.ChangeFilenames = false;
Settings.Default.PresetModels.SaveLastModel(rm);
}
if (Settings.Default.MacroRecentFiles == null)
{
Settings.Default.MacroRecentFiles = new RecentList();
}
else
{
// remove files that does not exist
Settings.Default.MacroRecentFiles.RemoveAll(delegate(string s) { return(!File.Exists(s)); });
}
}
public async Task RenameAsync([FromBody] RenameModel model)
{
await _facade.RenameAsync(model.Type, model.Id, model.NewName);
}
