public FakeDirectory(FakeFileSystem fileSystem, DirectoryPath path, bool creatable)
{
_fileSystem = fileSystem;
_path = path;
_exist = false;
_creatable = creatable;
}
public void DeleteDirectory(DirectoryPath path)
{
if (Directories.ContainsKey(path))
{
Directories[path].Exists = false;
}
}
private IDirectory GetDirectory(DirectoryPath path, bool creatable)
{
if (!Directories.ContainsKey(path))
{
Directories.Add(path, new FakeDirectory(this, path, creatable));
}
return Directories[path];
}
public void Should_Combine_Paths(string first, string second, string expected)
{
// Given
var path = new DirectoryPath(first);
// When
var result = path.Combine(new DirectoryPath(second));
// Then
Assert.Equal(expected, result.FullPath);
}
public void Should_Throw_If_Path_Is_Null()
{
// Given
var path = new DirectoryPath("assets");
// When
var result = Record.Exception(() => path.CombineWithFilePath(null));
// Then
Assert.IsType<ArgumentNullException>(result);
Assert.Equal("path", ((ArgumentNullException)result).ParamName);
}
public void Can_Not_Combine_Directory_Path_With_Absolute_File_Path()
{
// Given
var path = new DirectoryPath("assets");
// When
var result = Record.Exception(() => path.CombineWithFilePath(new FilePath("/other/asset.txt")));
// Then
Assert.IsType<InvalidOperationException>(result);
Assert.Equal("Cannot combine a directory path with an absolute file path.", result.Message);
}
/// <summary>
/// Combines the current path with another <see cref="DirectoryPath"/>.
/// The provided <see cref="DirectoryPath"/> must be absolute.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>A combination of the current path and the provided <see cref="DirectoryPath"/>.</returns>
public DirectoryPath Combine(DirectoryPath path)
{
if (path == null)
{
throw new ArgumentNullException("path");
}
if (!path.IsRelative)
{
throw new InvalidOperationException("Cannot combine a directory path with an absolute directory path.");
}
var combinedPath = System.IO.Path.Combine(FullPath, path.FullPath);
return new DirectoryPath(combinedPath);
}
/// <summary>
/// Makes the path absolute to another (absolute) path.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>An absolute path.</returns>
public DirectoryPath MakeAbsolute(DirectoryPath path)
{
if (path == null)
{
throw new ArgumentNullException("path");
}
if (path.IsRelative)
{
throw new PathException("The provided path cannot be relative.");
}
return IsRelative
? path.Combine(this)
: new DirectoryPath(FullPath);
}
public Directory(DirectoryPath path)
{
_path = path;
_directory = new DirectoryInfo(_path.FullPath);
}
public Directory(DirectoryPath path)
{
_path = path;
_directory = new DirectoryInfo(_path.FullPath);
}
public IDirectory GetDirectory(DirectoryPath path)
{
return GetDirectory(path, creatable: true);
}
public void Should_Create_New_Absolute_Path_Identical_To_The_Path()
{
// Given
var path = new DirectoryPath("/assets");
// When
var result = path.MakeAbsolute("/absolute");
// Then
Assert.Equal("/assets", result.FullPath);
}
public void Should_Create_New_Absolute_Path_When_Path_Is_Relative()
{
// Given
var path = new DirectoryPath("assets");
// When
var result = path.MakeAbsolute("/absolute");
// Then
Assert.Equal("/absolute/assets", result.FullPath);
}
public void Should_Throw_If_Provided_Path_Is_Relative()
{
// Given
var path = new DirectoryPath("assets");
// When
var result = Record.Exception(() => path.MakeAbsolute("Working"));
// Then
Assert.IsType<PathException>(result);
Assert.Equal("The provided path cannot be relative.", result.Message);
}
public void Should_Throw_If_Provided_Path_Is_Null()
{
// Given
var path = new DirectoryPath("assets");
// When
var result = Record.Exception(
() => path.MakeAbsolute((DirectoryPath)null));
// Then
Assert.IsType<ArgumentNullException>(result);
Assert.Equal("path", ((ArgumentNullException)result).ParamName);
}
public void Should_Create_New_Absolute_Path_Identical_To_The_Path()
{
// Given
var environment = Substitute.For<IEnvironment>();
var path = new DirectoryPath("/assets");
// When
var result = path.MakeAbsolute(environment);
// Then
Assert.Equal("/assets", result.FullPath);
}
public void Should_Create_New_Absolute_Path_When_Path_Is_Relative()
{
// Given
var environment = Substitute.For<IEnvironment>();
environment.GetApplicationRoot().Returns("/Working");
var path = new DirectoryPath("assets");
// When
var result = path.MakeAbsolute(environment);
// Then
Assert.Equal("/Working/assets", result.FullPath);
}
public static void LoadExtensions(this IContainer container, DirectoryPath path)
{
var fileSystem = container.Resolve<IFileSystem>();
var finder = container.Resolve<IAssemblyNameFinder>();
var logger = container.Resolve<ILogger<HadoukenService>>();
var files = fileSystem.GetDirectory(path)
.GetFiles("*.dll", SearchScope.Current)
.Select(f => f.Path.FullPath);
// Search through the path for assemblies to register
var assemblyNames = finder.GetAssemblyNames<IExtension>(files);
// The container builder which later updates the provided container
var builder = new ContainerBuilder();
foreach (var assemblyName in assemblyNames)
{
var filePath = new FilePath(assemblyName.CodeBase);
logger.Info("Loading extension {FileName}.", filePath.GetFilename());
var assembly = Assembly.Load(assemblyName);
// Find extensions, services and custom components
var extensions = assembly.GetTypesAssignableFrom<IExtension>();
var services = assembly.GetTypesAssignableFrom<IJsonRpcService>();
var components = (from type in assembly.GetTypes()
where !type.IsAbstract
let cattr = type.GetCustomAttribute<ComponentAttribute>()
where cattr != null
select type);
// Register extensions
foreach (var extension in extensions)
{
var attr = extension.GetCustomAttribute<ExtensionAttribute>();
if (attr == null) continue;
builder.RegisterType(extension)
.AsImplementedInterfaces()
.SingleInstance();
}
// Register JSONRPC services
foreach (var service in services)
{
builder.RegisterType(service)
.As<IJsonRpcService>()
.SingleInstance();
}
// Register custom components
foreach (var component in components)
{
var attr = component.GetCustomAttribute<ComponentAttribute>();
var registration = builder.RegisterType(component).AsImplementedInterfaces();
switch (attr.Lifestyle)
{
case ComponentLifestyle.Singleton:
registration.SingleInstance();
break;
case ComponentLifestyle.Transient:
registration.InstancePerDependency();
break;
}
}
}
// Update the container
builder.Update(container);
}
public IDirectory GetCreatedDirectory(DirectoryPath path)
{
var directory = GetDirectory(path, creatable: true);
directory.Create();
return directory;
}
/// <summary>
/// Returns <see cref="Path" /> instances matching the specified pattern.
/// </summary>
/// <param name="pattern">The pattern to match.</param>
/// <returns>
/// <see cref="Path" /> instances matching the specified pattern.
/// </returns>
public IEnumerable<Path> Match(string pattern)
{
var scanner = new Scanner(pattern);
var parser = new Parser(scanner, _environment);
var path = parser.Parse();
var rootNodes = new List<Node>();
while (path.Count > 0)
{
// Pop the first path item.
var segment = path[0];
path.RemoveAt(0);
if (segment.IsWildcard)
{
path.Insert(0, segment);
break;
}
rootNodes.Add(segment);
}
// Fix up the tree.
var newRoot = FixRootNode(rootNodes);
if (newRoot != null)
{
rootNodes[0] = newRoot;
}
// Ge the root.
var rootDirectory = new DirectoryPath(string.Join("/", rootNodes.Select(x => x.Render())));
// Nothing left in the path?
if (path.Count == 0)
{
// We have an absolute path with no wild cards.
return new Path[] { rootDirectory };
}
// Walk the root and return the unique results.
var segments = new Stack<Node>(((IEnumerable<Node>)path).Reverse());
var results = Walk(rootDirectory, segments);
return new HashSet<Path>(results, new PathComparer(_environment.IsUnix())).ToArray();
}
private List<Path> Walk(DirectoryPath rootPath, Stack<Node> segments)
{
var results = new List<Path>();
var segment = segments.Pop();
var expression = new Regex("^" + segment.Render() + "$", _options);
var isDirectoryWildcard = false;
if (segment is WildcardSegmentNode)
{
segments.Push(segment);
isDirectoryWildcard = true;
}
// Get all files and folders.
var root = _fileSystem.GetDirectory(rootPath);
if (!root.Exists)
{
return results;
}
foreach (var directory in root.GetDirectories("*", SearchScope.Current))
{
var part = directory.Path.FullPath.Substring(root.Path.FullPath.Length + 1);
var pathTest = expression.IsMatch(part);
var subWalkCount = 0;
if (isDirectoryWildcard)
{
// Walk recursivly down the segment.
var nextSegments = new Stack<Node>(segments.Reverse());
var subwalkResult = Walk(directory.Path, nextSegments);
if (subwalkResult.Count > 0)
{
results.AddRange(subwalkResult);
}
subWalkCount++;
}
// Check without directory wildcard.
if (segments.Count > subWalkCount && (subWalkCount == 1 || pathTest))
{
// Walk the next segment in the list.
var nextSegments = new Stack<Node>(segments.Skip(subWalkCount).Reverse());
var subwalkResult = Walk(directory.Path, nextSegments);
if (subwalkResult.Count > 0)
{
results.AddRange(subwalkResult);
}
}
// Got a match?
if (pathTest && segments.Count == 0)
{
results.Add(directory.Path);
}
}
foreach (var file in root.GetFiles("*", SearchScope.Current))
{
var part = file.Path.FullPath.Substring(root.Path.FullPath.Length + 1);
var pathTest = expression.IsMatch(part);
// Got a match?
if (pathTest && segments.Count == 0)
{
results.Add(file.Path);
}
else if(pathTest)
{
/////////////////////////////////////////////////////////////B
// We got a match, but we still have segments left.
// Is the next part a directory wild card?
/////////////////////////////////////////////////////////////
var nextNode = segments.Peek();
if (nextNode is WildcardSegmentNode)
{
var nextSegments = new Stack<Node>(segments.Skip(1).Reverse());
var subwalkResult = Walk(root.Path, nextSegments);
if (subwalkResult.Count > 0)
{
results.AddRange(subwalkResult);
}
}
}
}
return results;
}
public IDirectory GetNonCreatableDirectory(DirectoryPath path)
{
return GetDirectory(path, creatable: false);
}
