DirectoryNode CreatePropertiesFolderNodeWithParentProjectNodeCalledControllers()
{
var projectNode = CreateProjectNode(@"d:\projects\MyProject\Controllers.csproj", "Controllers");
var propertiesNode = new DirectoryNode(@"d:\projects\MyProject\Properties");
propertiesNode.AddTo(projectNode);
return propertiesNode;
}
DirectoryNode CreateControllersChildFolderNode()
{
DirectoryNode controllersNode = CreateControllersFolderNode();
string path = @"d:\projects\MyAspNetProject\Controllers\Child";
var childNode = new DirectoryNode(path);
childNode.AddTo(controllersNode);
return childNode;
}
DirectoryNode CreateViewsChildFolderNode()
{
DirectoryNode viewsNode = CreateViewsFolderNode();
string path = @"d:\projects\MyAspNetProject\Views\Child";
var childNode = new DirectoryNode(path);
childNode.AddTo(viewsNode);
return childNode;
}
public override object Visit(DirectoryNode directoryNode, object data)
{
if (FileUtility.IsBaseDirectory(oldName, directoryNode.Directory)) {
directoryNode.Directory = DirectoryName.Create(FileUtility.RenameBaseDirectory(directoryNode.Directory, oldName, newName));
directoryNode.AcceptChildren(this, data);
} else if (FileUtility.IsBaseDirectory(directoryNode.Directory, oldName)) {
directoryNode.AcceptChildren(this, data);
}
return data;
}
void CreateSelectedFolderNode(string folder)
{
projectForSelectedFolder = TestableProject.CreateProject();
projectNode = new ProjectNode(projectForSelectedFolder);
directoryNode = new DirectoryNode(folder);
directoryNode.AddTo(projectNode);
selectedFolderNode = new SelectedFolderNodeInProjectsView(directoryNode);
}
public static DirectoryNode CreateDirectoryNode(ProjectItem item, FileNodeStatus status)
{
DirectoryNode node;
if (item is WebReferencesProjectItem) {
node = new WebReferencesFolderNode((WebReferencesProjectItem)item);
node.FileNodeStatus = status;
} else {
node = new DirectoryNode(item.FileName.Trim('\\', '/'), status);
node.ProjectItem = item;
}
return node;
}
public static DirectoryNode CreateDirectoryNode(TreeNode parent, IProject project, string directory)
{
DirectoryNode node = new DirectoryNode(directory);
if (!string.IsNullOrEmpty(project.AppDesignerFolder)
&& directory == Path.Combine(project.Directory, project.AppDesignerFolder))
{
node.SpecialFolder = SpecialFolder.AppDesigner;
} else if (DirectoryNode.IsWebReferencesFolder(project, directory)) {
node = new WebReferencesFolderNode(directory);
} else if (parent != null && parent is WebReferencesFolderNode) {
node = new WebReferenceNode(directory);
}
return node;
}
public override object Visit(DirectoryNode directoryNode, object data)
{
if (FileUtility.IsBaseDirectory(fileName, directoryNode.Directory)) {
ExtTreeNode parent = directoryNode.Parent as ExtTreeNode;
directoryNode.Remove();
if (parent != null) {
parent.Refresh();
}
} else {
if (FileUtility.IsBaseDirectory(directoryNode.Directory, fileName)) {
directoryNode.AcceptChildren(this, data);
}
}
return data;
}
public override object Visit(DirectoryNode directoryNode, object data)
{
if (!ShouldVisitDirectoryNode(directoryNode))
return null;
if (IsImmediateParentForNewFile(directoryNode)) {
if (IsChildFileNodeMissingForNewFile(directoryNode)) {
AddFileOrDirectoryNodeTo(directoryNode);
}
} else if (IsChildDirectoryNodeMissingForNewFile(directoryNode)) {
AddChildDirectoryNodeForNewFileTo(directoryNode);
} else {
return base.Visit(directoryNode, data);
}
return null;
}
public void AddParentFolder(string virtualName, string relativeDirectoryPath, Dictionary<string, DirectoryNode> directoryNodeList)
{
if ((relativeDirectoryPath.Length == 0)
|| (string.Compare(virtualName, 0, relativeDirectoryPath, 0, relativeDirectoryPath.Length, StringComparison.InvariantCultureIgnoreCase) == 0))
{
int pos = virtualName.IndexOf('/', relativeDirectoryPath.Length + 1);
if (pos > 0) {
string subFolderName = virtualName.Substring(relativeDirectoryPath.Length, pos - relativeDirectoryPath.Length);
DirectoryNode node;
if (directoryNodeList.TryGetValue(subFolderName, out node)) {
if (node.FileNodeStatus == FileNodeStatus.None) {
node.FileNodeStatus = FileNodeStatus.InProject;
}
} else {
node = new DirectoryNode(Path.Combine(this.Directory, subFolderName), FileNodeStatus.Missing);
node.AddTo(this);
directoryNodeList[subFolderName] = node;
}
}
}
}
public void SetUpFixture()
{
MSBuildBasedProject project = WebReferenceTestHelper.CreateTestProject("C#");
project.FileName = Path.Combine(projectDirectory, "foo.csproj");
project.AppDesignerFolder = "Properties";
WebReferencesProjectItem webReferencesItem = new WebReferencesProjectItem(project);
webReferencesItem.Include = "Web References\\";
ProjectService.AddProjectItem(project, webReferencesItem);
FileProjectItem fileItem = new FileProjectItem(project, ItemType.Folder);
fileItem.Include = "MissingFolder\\";
ProjectService.AddProjectItem(project, fileItem);
ProjectNode projectNode = new ProjectNode(project);
appDesignerFolderNode = DirectoryNodeFactory.CreateDirectoryNode(projectNode, project, Path.Combine(projectDirectory, "Properties"));
ordinaryFolderNode = DirectoryNodeFactory.CreateDirectoryNode(projectNode, project, Path.Combine(project.Directory, "Test"));
webReferencesFolderNode = DirectoryNodeFactory.CreateDirectoryNode(projectNode, project, Path.Combine(project.Directory, webReferencesItem.Include));
webReferenceNode = DirectoryNodeFactory.CreateDirectoryNode(webReferencesFolderNode, project, Path.Combine(Path.Combine(project.Directory, webReferencesItem.Include), "localhost"));
missingWebReferencesFolderNode = DirectoryNodeFactory.CreateDirectoryNode(webReferencesItem, FileNodeStatus.Missing);
missingOrdinaryFolderNode = DirectoryNodeFactory.CreateDirectoryNode(fileItem, FileNodeStatus.Missing);
}
bool IsNewFileInsideDirectory(DirectoryNode directoryNode)
{
return FileUtility.IsBaseDirectory(directoryNode.Directory, DirectoryForNewFileAddedToProject);
}
bool ShouldVisitDirectoryNode(DirectoryNode directoryNode)
{
return directoryNode.IsInitialized && IsNewFileInsideDirectory(directoryNode);
}
bool DirectoryOfNewFileStartsWith(DirectoryNode directoryNode)
{
return FileUtility.IsBaseDirectory(directoryNode.Directory, DirectoryForNewFileAddedToProject);
}
bool IsChildDirectoryNodeAlreadyAddedForNewFile(DirectoryNode parentDirectoryNode)
{
return GetChildDirectoryNodes(parentDirectoryNode)
.Any(childDirectoryNode => DirectoryOfNewFileStartsWith(childDirectoryNode));
}
bool IsChildDirectoryNodeMissingForNewFile(DirectoryNode parentDirectoryNode)
{
return !IsChildDirectoryNodeAlreadyAddedForNewFile(parentDirectoryNode);
}
public void CopyDirectoryHere(DirectoryNode node, bool performMove)
{
CopyDirectoryHere(node.Directory, performMove);
}
bool IsMatch(DirectoryNode directoryNode)
{
return MvcParentFolderName.Equals(directoryNode.Text, StringComparison.InvariantCultureIgnoreCase);
}
void AddDirectoryNodeTo(TreeNode parentNode, string directory)
{
var directoryNode = new DirectoryNode(directory, FileNodeStatus.InProject);
directoryNode.InsertSorted(parentNode);
}
void AddChildDirectoryNodeForNewFileTo(DirectoryNode parentNode)
{
string childDirectory = GetMissingChildDirectory(parentNode.Directory);
AddDirectoryNodeTo(parentNode, childDirectory);
}
public SelectedMvcViewFolder(DirectoryNode directoryNode)
: base(directoryNode)
{
}
public SelectedFolderNodeInProjectsView(DirectoryNode directoryNode)
{
this.directoryNode = directoryNode;
this.project = new MvcProject(directoryNode.Project);
}
public override object Visit(DirectoryNode directoryNode, object data)
{
return data;
}
void AddParentFolder(string virtualName, string relativeDirectoryPath, Dictionary<string, DirectoryNode> directoryNodeList)
{
if (relativeDirectoryPath.Length == 0
|| string.Compare(virtualName, 0, relativeDirectoryPath, 0, relativeDirectoryPath.Length, StringComparison.OrdinalIgnoreCase) == 0)
{
// virtualName is a file in this folder, so we have to add its containing folder
// to the project
int pos = virtualName.IndexOf('/', relativeDirectoryPath.Length + 1);
if (pos < 0)
return;
string subFolderName = virtualName.Substring(relativeDirectoryPath.Length, pos - relativeDirectoryPath.Length);
DirectoryNode node;
if (directoryNodeList.TryGetValue(subFolderName, out node)) {
if (node.FileNodeStatus == FileNodeStatus.None) {
node.FileNodeStatus = FileNodeStatus.InProject;
}
} else {
node = new DirectoryNode(Path.Combine(Directory, subFolderName), FileNodeStatus.Missing);
node.InsertSorted(this);
directoryNodeList[subFolderName] = node;
}
}
}
public SelectedMvcFolder(DirectoryNode directoryNode)
: this(
new SelectedFolderNodeInProjectsView(directoryNode),
new MvcFileService())
{
}
void AddFileOrDirectoryNodeTo(DirectoryNode directoryNode)
{
if (newFileAddedToProject.ItemType == ItemType.Folder) {
AddDirectoryNodeTo(directoryNode, newFileAddedToProject.FileName);
} else {
AddFileNodeTo(directoryNode);
}
}
public SelectedMvcControllerFolder(DirectoryNode directoryNode)
: base(directoryNode)
{
}
bool IsChildFileNodeAlreadyAddedForNewFile(DirectoryNode parentDirectoryNode)
{
return GetChildFileNodes(parentDirectoryNode)
.Any(childFileNode => FileNodeMatchesNewFileAdded(childFileNode));
}
protected override void Initialize()
{
if (removeMe != null)
{
Nodes.Remove(removeMe);
removeMe = null;
}
LoggingService.Info("Initialize DirectoryNode " + Directory);
Dictionary <string, FileNode> fileNodeDictionary
= new Dictionary <string, FileNode>(StringComparer.OrdinalIgnoreCase);
Dictionary <FileNode, string> dependendFileDictionary = new Dictionary <FileNode, string>();
Dictionary <string, DirectoryNode> directoryNodeList = new Dictionary <string, DirectoryNode>(StringComparer.OrdinalIgnoreCase);
// Add files found in file system
if (System.IO.Directory.Exists(Directory))
{
foreach (string subDirectory in System.IO.Directory.GetDirectories(Directory))
{
if (Path.GetFileName(subDirectory) != ".svn")
{
DirectoryNode newDirectoryNode = DirectoryNodeFactory.CreateDirectoryNode(this, Project, subDirectory);
newDirectoryNode.InsertSorted(this);
directoryNodeList[Path.GetFileName(subDirectory)] = newDirectoryNode;
}
}
foreach (string file in System.IO.Directory.GetFiles(Directory))
{
FileNode fileNode = new FileNode(file);
fileNodeDictionary[Path.GetFileName(file)] = fileNode;
fileNode.InsertSorted(this);
}
}
if (Nodes.Count == 0)
{
SetClosedImage();
}
string relativeDirectoryPath = this.RelativePath;
if (relativeDirectoryPath.Length > 0)
{
relativeDirectoryPath = relativeDirectoryPath.Replace('\\', '/') + '/';
}
// Add project items
foreach (ProjectItem item in Project.Items)
{
if (item.ItemType == ItemType.WebReferenceUrl)
{
DirectoryNode node;
if (directoryNodeList.TryGetValue(Path.GetFileName(item.FileName), out node))
{
if (node.FileNodeStatus == FileNodeStatus.None)
{
node.FileNodeStatus = FileNodeStatus.InProject;
}
node.ProjectItem = item;
}
continue;
}
FileProjectItem fileItem = item as FileProjectItem;
if (fileItem == null)
{
continue;
}
string virtualName = fileItem.VirtualName.Replace('\\', '/');
if (virtualName.EndsWith("/"))
{
virtualName = virtualName.Substring(0, virtualName.Length - 1);
}
string fileName = Path.GetFileName(virtualName);
if (!string.Equals(virtualName, relativeDirectoryPath + fileName, StringComparison.OrdinalIgnoreCase))
{
AddParentFolder(virtualName, relativeDirectoryPath, directoryNodeList);
continue;
}
if (item.ItemType == ItemType.Folder || item.ItemType == ItemType.WebReferences)
{
DirectoryNode node;
if (directoryNodeList.TryGetValue(fileName, out node))
{
if (node.FileNodeStatus == FileNodeStatus.None)
{
node.FileNodeStatus = FileNodeStatus.InProject;
}
node.ProjectItem = item;
}
else
{
node = DirectoryNodeFactory.CreateDirectoryNode(item, FileNodeStatus.Missing);
node.InsertSorted(this);
directoryNodeList[fileName] = node;
}
}
else
{
FileNode node;
if (fileItem.IsLink)
{
node = new FileNode(fileItem.FileName, FileNodeStatus.InProject);
node.InsertSorted(this);
fileNodeDictionary[fileName] = node;
}
else
{
if (fileNodeDictionary.TryGetValue(fileName, out node))
{
if (node.FileNodeStatus == FileNodeStatus.None)
{
node.FileNodeStatus = FileNodeStatus.InProject;
}
}
else
{
node = new FileNode(fileItem.FileName, FileNodeStatus.Missing);
node.InsertSorted(this);
fileNodeDictionary[fileName] = node;
}
}
node.ProjectItem = fileItem;
if (fileItem != null && fileItem.DependentUpon != null && fileItem.DependentUpon.Length > 0)
{
dependendFileDictionary[node] = fileItem.DependentUpon;
}
}
}
// Insert 'code behind files'
foreach (KeyValuePair <FileNode, string> pair in dependendFileDictionary)
{
string fileName = Path.GetFileName(pair.Value);
if (!fileNodeDictionary.ContainsKey(fileName))
{
continue;
}
AbstractProjectBrowserTreeNode parentNode = fileNodeDictionary[fileName];
pair.Key.Parent.Nodes.Remove(pair.Key);
if (NodeIsParent(parentNode, pair.Key))
{
// is pair.Key a parent of parentNode?
// if yes, we have a parent cycle - break it by adding one node to the directory
pair.Key.InsertSorted(this);
}
else
{
pair.Key.InsertSorted(parentNode);
if (pair.Key.FileNodeStatus != FileNodeStatus.Missing)
{
pair.Key.FileNodeStatus = FileNodeStatus.BehindFile;
}
}
}
base.Initialize();
}
public static IDataObject CreateDataObject(DirectoryNode node, bool performMove)
{
return new DataObject(typeof(DirectoryNode).ToString(),
new FileOperationClipboardObject(node.Directory, performMove));
}
bool IsImmediateParentForNewFile(DirectoryNode directoryNode)
{
return FileUtility.IsBaseDirectory(DirectoryForNewFileAddedToProject, directoryNode.Directory);
}
public virtual object Visit(DirectoryNode directoryNode, object data)
{
directoryNode.AcceptChildren(this, data);
return(data);
}
