/// <summary>Creates service definition that can be registered with a server</summary>
/// <param name="serviceImpl">An object implementing the server-side handling logic.</param>
public static grpc::ServerServiceDefinition BindService(DirectoryBase serviceImpl)
{
return(grpc::ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_GetDirectories, serviceImpl.GetDirectories)
.AddMethod(__Method_GetFiles, serviceImpl.GetFiles)
.AddMethod(__Method_Exists, serviceImpl.Exists).Build());
}
public VirtualFileSystem(IDictionary <string, VirtualFileData> files, string currentDirectory = "")
{
if (string.IsNullOrEmpty(currentDirectory))
{
currentDirectory = System.IO.Path.GetTempPath();
}
_pathVerifier = new PathVerifier(this);
this._files = new Dictionary <string, VirtualFileData>(StringComparer.OrdinalIgnoreCase);
_pathField = new VirtualPath(this);
_file = new VirtualFile(this);
_directory = new VirtualDirectory(this, _file, currentDirectory);
_fileInfoFactory = new VirtualFileInfoFactory(this);
_directoryInfoFactory = new VirtualDirectoryInfoFactory(this);
_driveInfoFactory = new VirtualDriveInfoFactory(this);
if (files != null)
{
foreach (var entry in files)
{
AddFile(entry.Key, entry.Value);
}
}
}
public void Setup()
{
if (_referenceRepository is null)
{
_referenceRepository = new ReferenceRepository();
}
else
{
_referenceRepository.Reset();
}
_file = Substitute.For <FileBase>();
_file.ReadAllText(_commitMessagePath, _encoding).Returns(_commitMessage);
_file.ReadAllText(_mergeMessagePath, _encoding).Returns(_mergeMessage);
_directory = Substitute.For <DirectoryBase>();
var path = Substitute.For <PathBase>();
path.Combine(Arg.Any <string>(), Arg.Any <string>()).Returns(x => Path.Combine((string)x[0], (string)x[1]));
_fileSystem = Substitute.For <IFileSystem>();
_fileSystem.File.Returns(_file);
_fileSystem.Directory.Returns(_directory);
_fileSystem.Path.Returns(path);
_manager = new CommitMessageManager(_workingDirGitDir, _encoding, _fileSystem, overriddenCommitMessage: null);
}
public MockFileSystem(IDictionary <string, MockFileData> files, string currentDirectory = "")
{
if (string.IsNullOrEmpty(currentDirectory))
{
currentDirectory = IO.Path.GetTempPath();
}
pathVerifier = new PathVerifier(this);
this.files = new Dictionary <string, MockFileData>(StringComparer.OrdinalIgnoreCase);
pathField = new MockPath(this);
file = new MockFile(this);
directory = new MockDirectory(this, file, currentDirectory);
fileInfoFactory = new MockFileInfoFactory(this);
directoryInfoFactory = new MockDirectoryInfoFactory(this);
driveInfoFactory = new MockDriveInfoFactory(this);
if (files != null)
{
foreach (var entry in files)
{
AddFile(entry.Key, entry.Value);
}
}
}
public void ConfigRepositoryRemoveSiteTest()
{
FileHelper.FileSystem = new MockFileSystem(new Dictionary <string, MockFileData>()
{
{
@"c:\site1.publishsettings",
new MockFileData(string.Format(ProfileTemplate, "site1"))
},
{
@"c:\site2.foo.publishsettings",
new MockFileData(string.Format(ProfileTemplate, "site2"))
},
{ @"c:\foo.txt", new MockFileData("bar") },
{ @"c:\site1\", new MockDirectoryData() }
});
IConfigRepository repository = new ConfigRepository();
repository.RemoveSite("site1");
repository.RemoveSite("site2");
FileBase fileBase = FileHelper.FileSystem.File;
DirectoryBase dirBase = FileHelper.FileSystem.Directory;
Assert.IsFalse(fileBase.Exists(@"c:\site1.publishSettings"), "site1 publishSettings still exists");
Assert.IsFalse(dirBase.Exists(@"c:\site1"), "site1 folder still exists");
Assert.IsFalse(fileBase.Exists(@"c:\site2.foo.publishsettings"), "sit2 publishSettings still exists");
}
public SystemSnapshotRecorder(DirectoryBase directory, FileBase file, string location)
{
this.directory = directory;
this.file = file;
this.location = location;
this.pathToCurrentSnapshot = Path.Combine(this.location, TemporaryFilename);
}
public SystemSnapshotLoader(DirectoryBase directory, FileBase file, Func <string, FileInfoBase> info, string path)
{
this.directory = directory;
this.file = file;
this.info = info;
this.path = path;
this.searchPattern = WildcardPattern;
}
public OnDiskGitRepository(string repoPath, string releaseBranch, IFileSystem fileSystem)
{
Directory = fileSystem.Directory;
var gitPath = FindGitPath(repoPath);
var repoRef = new Repository(gitPath);
_repository = new ReleaseRepository <IRepository>(gitPath, releaseBranch, repoRef);
}
public MockFileSystem(IDictionary<string, MockFileData> files)
{
this.files = new Dictionary<string, MockFileData>(
files,
StringComparer.InvariantCultureIgnoreCase);
file = new MockFile(this);
directory = new MockDirectory(this, file);
fileInfoFactory = new MockFileInfoFactory(this);
}
public DotnetProjectParser(string projectPath, IFileSystem fileSystem)
{
Path = fileSystem.Path;
Directory = fileSystem.Directory;
var workingDir = Path.GetDirectoryName(projectPath) + "/";
ProjectPath = FindProjPath(projectPath);
_project = DotnetCoreBuildTools.GetCoreProject(ProjectPath);
}
public MockFileSystem(IDictionary <string, MockFileData> files)
{
this.files = new Dictionary <string, MockFileData>(
files,
StringComparer.InvariantCultureIgnoreCase);
file = new MockFile(this);
directory = new MockDirectory(this, file);
fileInfoFactory = new MockFileInfoFactory(this);
path = new MockPath();
directoryInfoFactory = new MockDirectoryInfoFactory(this);
}
public MockFileSystem(IDictionary<string, MockFileData> files, string currentDirectory = @"C:\Foo\Bar")
{
this.files = new Dictionary<string, MockFileData>(StringComparer.OrdinalIgnoreCase);
pathField = new MockPath(this);
file = new MockFile(this);
directory = new MockDirectory(this, file, FixPath(currentDirectory));
fileInfoFactory = new MockFileInfoFactory(this);
directoryInfoFactory = new MockDirectoryInfoFactory(this);
if (files == null) return;
foreach (var entry in files)
AddFile(entry.Key, entry.Value);
}
public void Setup()
{
_fileSystem = Substitute.For <IFileSystem>();
_directory = Substitute.For <DirectoryBase>();
_fileSystem.Directory.Returns(_directory);
_file = Substitute.For <FileBase>();
_fileSystem.File.Returns(_file);
_fileInfo = Substitute.For <FileInfoBase>();
_fileInfoFactory = Substitute.For <IFileInfoFactory>();
_fileInfoFactory.FromFileName(Arg.Any <string>()).Returns(_fileInfo);
_fileSystem.FileInfo.Returns(_fileInfoFactory);
_cache = new DirectoryImageCache(_folderPath, 2, _fileSystem);
}
public void Setup()
{
_gitFile = Path.Combine(_workingDir, ".git");
_gitWorkingDir = _gitFile.EnsureTrailingPathSeparator();
_file = Substitute.For <FileBase>();
_directory = Substitute.For <DirectoryBase>();
_fileSystem = Substitute.For <IFileSystem>();
_fileSystem.Directory.Returns(_directory);
_fileSystem.File.Returns(_file);
_directory.Exists(_workingDir).Returns(true);
_resolver = new GitDirectoryResolver(_fileSystem);
}
public ReflectionBasedPluginLoader(ReflectionBasedPluginLoaderSettings settings, IYarpSerializer serializer, IYarpActivator activator,
IAssemblyLoader assemblyLoader, DirectoryBase directory, FileBase file)
{
if (settings == null) throw new ArgumentNullException(nameof(settings));
if (serializer == null) throw new ArgumentNullException(nameof(serializer));
if (activator == null) throw new ArgumentNullException(nameof(activator));
if (assemblyLoader == null) throw new ArgumentNullException(nameof(assemblyLoader));
if (directory == null) throw new ArgumentNullException(nameof(directory));
if (file == null) throw new ArgumentNullException(nameof(file));
_settings = settings;
_serializer = serializer;
_activator = activator;
_assemblyLoader = assemblyLoader;
_directory = directory;
_file = file;
}
public MockFileSystem(IDictionary<string, MockFileData> files, string currentDirectory = "")
{
if (String.IsNullOrEmpty(currentDirectory))
currentDirectory = IO.Path.GetTempPath();
this.files = new Dictionary<string, MockFileData>(StringComparer.OrdinalIgnoreCase);
pathField = new MockPath(this);
file = new MockFile(this);
directory = new MockDirectory(this, file, currentDirectory);
fileInfoFactory = new MockFileInfoFactory(this);
directoryInfoFactory = new MockDirectoryInfoFactory(this);
if (files == null) return;
foreach (var entry in files)
AddFileWithCreate(entry.Key, entry.Value);
}
public MockFileSystem(IDictionary <string, MockFileData> files, string currentDirectory = @"C:\Foo\Bar")
{
this.files = new Dictionary <string, MockFileData>(StringComparer.InvariantCultureIgnoreCase);
pathField = new MockPath(this);
file = new MockFile(this);
directory = new MockDirectory(this, file, FixPath(currentDirectory));
fileInfoFactory = new MockFileInfoFactory(this);
directoryInfoFactory = new MockDirectoryInfoFactory(this);
if (files == null)
{
return;
}
foreach (var entry in files)
{
AddFile(entry.Key, entry.Value);
}
}
public override void SetUp()
{
base.SetUp();
_fileSystem = Substitute.For <IFileSystem>();
_directory = Substitute.For <DirectoryBase>();
_fileSystem.Directory.Returns(_directory);
_file = Substitute.For <FileBase>();
_fileSystem.File.Returns(_file);
_fileInfo = Substitute.For <FileInfoBase>();
_fileInfo.Exists.Returns(true);
_fileInfoFactory = Substitute.For <IFileInfoFactory>();
_fileInfoFactory.FromFileName(Arg.Any <string>()).Returns(_fileInfo);
_fileSystem.FileInfo.Returns(_fileInfoFactory);
_folderPath = AppSettings.AvatarImageCachePath;
_cache = new FileSystemAvatarCache(_inner, _fileSystem);
}
public void Setup()
{
if (Type.GetType("Mono.Runtime") != null)
{
_folderPath = "/home/user/gitextensions/images";
}
_fileSystem = Substitute.For <IFileSystem>();
_directory = Substitute.For <DirectoryBase>();
_fileSystem.Directory.Returns(_directory);
_file = Substitute.For <FileBase>();
_fileSystem.File.Returns(_file);
_fileInfo = Substitute.For <FileInfoBase>();
_fileInfoFactory = Substitute.For <IFileInfoFactory>();
_fileInfoFactory.FromFileName(Arg.Any <string>()).Returns(_fileInfo);
_fileSystem.FileInfo.Returns(_fileInfoFactory);
_cache = new DirectoryImageCache(_folderPath, 2, _fileSystem);
}
public void Setup()
{
if (Type.GetType("Mono.Runtime") != null)
{
_workingDir = "/home/user/repo";
}
_gitFile = Path.Combine(_workingDir, ".git");
_gitWorkingDir = _gitFile.EnsureTrailingPathSeparator();
_file = Substitute.For <FileBase>();
_directory = Substitute.For <DirectoryBase>();
_fileSystem = Substitute.For <IFileSystem>();
_fileSystem.Directory.Returns(_directory);
_fileSystem.File.Returns(_file);
_directory.Exists(_workingDir).Returns(true);
_resolver = new GitDirectoryResolver(_fileSystem);
}
public void Setup()
{
_gitFile = Path.Combine(_workingDir, ".git");
_gitWorkingDir = _gitFile.EnsureTrailingPathSeparator();
_indexLockFile = Path.Combine(_gitWorkingDir, IndexLock);
_file = Substitute.For <FileBase>();
_directory = Substitute.For <DirectoryBase>();
_fileSystem = Substitute.For <IFileSystem>();
_fileSystem.Directory.Returns(_directory);
_fileSystem.File.Returns(_file);
_module = Substitute.For <IGitModule>();
_module.WorkingDir.Returns(_workingDir);
_gitDirectoryResolver = Substitute.For <IGitDirectoryResolver>();
_gitDirectoryResolver.Resolve(_workingDir).Returns(_gitWorkingDir);
_manager = new IndexLockManager(_module, _gitDirectoryResolver, _fileSystem);
}
public MockFileSystem(IDictionary<string, MockFileData> files)
{
file = new MockFile(this);
directory = new MockDirectory(this, file);
fileInfoFactory = new MockFileInfoFactory(this);
path = new MockPath();
directoryInfoFactory = new MockDirectoryInfoFactory(this);
//For each mock file add a file to the files dictionary
//Also add a file entry for all directories leading up to this file
this.files = new Dictionary<string, MockFileData>(StringComparer.InvariantCultureIgnoreCase);
foreach (var entry in files)
{
var directoryPath = Path.GetDirectoryName(entry.Key);
if (!directory.Exists(directoryPath))
directory.CreateDirectory(directoryPath);
if (!file.Exists(entry.Key))
this.files.Add(entry.Key, entry.Value);
}
}
public override void SetUp()
{
base.SetUp();
_fileSystem = Substitute.For <IFileSystem>();
_directory = Substitute.For <DirectoryBase>();
_fileSystem.Directory.Returns(_directory);
_file = Substitute.For <FileBase>();
_fileSystem.File.Returns(_file);
_fileInfo = Substitute.For <FileInfoBase>();
_fileInfo.Exists.Returns(true);
_fileInfoFactory = Substitute.For <IFileInfoFactory>();
_fileInfoFactory.FromFileName(Arg.Any <string>()).Returns(_fileInfo);
_fileSystem.FileInfo.Returns(_fileInfoFactory);
_avatarGenerator = Substitute.For <IAvatarGenerator>();
_avatarGenerator.GetAvatarImage(_emailMissing, _nameMissing, _size).Returns(_imgGenerated);
_folderPath = AppSettings.AvatarImageCachePath;
_cache = new AvatarPersistentCache(_inner, _avatarGenerator, _fileSystem);
}
private ReflectionBasedPluginLoader CreateSut(ReflectionBasedPluginLoaderSettings settings, IYarpSerializer serializer = null, IYarpActivator activator = null,
IAssemblyLoader loader = null, DirectoryBase directory = null, FileBase file = null)
{
var yarpSerializer = serializer ?? MockRepository.GenerateStub<IYarpSerializer>();
var yarpActivator = activator ?? MockRepository.GenerateStub<IYarpActivator>();
var assemblyLoader = loader ?? MockRepository.GenerateStub<IAssemblyLoader>();
var directoryBase = directory ?? MockRepository.GenerateStub<DirectoryBase>();
var fileBase = file ?? MockRepository.GenerateStub<FileBase>();
return new ReflectionBasedPluginLoader(settings, yarpSerializer, yarpActivator, assemblyLoader, directoryBase, fileBase);
}
private void OpenDirectory(DirectoryInfo directory, bool searchMode = false, string filename = null)
{
// Make sure toolstrip buttons are reset
Button_UnpackSDS.Enabled = false;
Button_PackSDS.Enabled = false;
infoText.Text = "Loading Directory..";
fileListView.Items.Clear();
ListViewItem.ListViewSubItem[] subItems;
ListViewItem item = null;
if (!directory.Exists)
{
MessageBox.Show("Could not find directory! Returning to original path..", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
OpenDirectory(rootDirectory, false);
return;
}
DirectoryBase directoryInfo = new DirectoryBase(directory);
foreach (DirectoryInfo dir in directory.GetDirectories())
{
DirectoryBase childInfo = new DirectoryBase(dir);
if (searchMode && !string.IsNullOrEmpty(filename))
{
if (!dir.Name.Contains(filename))
{
continue;
}
}
item = new ListViewItem(dir.Name, 0);
item.Tag = childInfo;
subItems = new ListViewItem.ListViewSubItem[]
{
new ListViewItem.ListViewSubItem(item, "Directory"),
new ListViewItem.ListViewSubItem(item, (dir.GetDirectories().Length + dir.GetFiles().Length).ToString() + " items"),
new ListViewItem.ListViewSubItem(item, dir.LastWriteTime.ToShortDateString()),
};
item.SubItems.AddRange(subItems);
fileListView.Items.Add(item);
}
foreach (FileInfo info in directory.GetFiles())
{
if (!imageBank.Images.ContainsKey(info.Extension))
{
var icon = Icon.ExtractAssociatedIcon(info.FullName);
if (icon != null)
{
imageBank.Images.Add(info.Extension, icon);
}
}
if (searchMode && !string.IsNullOrEmpty(filename))
{
if (!info.Name.Contains(filename))
{
continue;
}
}
var file = FileFactory.ConstructFromFileInfo(info);
item = new ListViewItem(info.Name, imageBank.Images.IndexOfKey(info.Extension));
item.Tag = file;
subItems = new ListViewItem.ListViewSubItem[]
{
new ListViewItem.ListViewSubItem(item, file.GetExtensionUpper()),
new ListViewItem.ListViewSubItem(item, file.GetFileSizeAsString()),
new ListViewItem.ListViewSubItem(item, file.GetLastTimeWrite()),
};
directoryInfo.AddLoadedFile(file);
item.SubItems.AddRange(subItems);
fileListView.Items.Add(item);
}
infoText.Text = "Done loading directory.";
currentDirectory = directory;
string directoryPath = directory.FullName.Remove(0, directory.FullName.IndexOf(rootDirectory.Name)).TrimEnd('\\');
FolderPath.Text = directoryPath;
fileListView.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
// We have to remove the AfterExpand event before we expand the node.
folderView.AfterExpand -= FolderViewAfterExpand;
TreeNode folderNode = folderView.Nodes.FindTreeNodeByFullPath(directoryPath);
if (folderNode != null)
{
folderNode.Nodes.Clear();
GetSubdirectories(currentDirectory, folderNode);
folderNode.Expand();
}
else
{
MessageBox.Show("Failed to find directory in FolderView!", "Toolkit", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
folderView.AfterExpand += FolderViewAfterExpand;
}
