Skip to content

923 refactoring #926

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
khellang merged 5 commits into from
Feb 10, 2015
Merged

923 refactoring #926

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
8f3bc1b
refactor: simplify conditional, fix whitespace, remove and sort usings
adamralph Feb 7, 2015
ddca0e7
green: add scenario Packages.PackageContainsAFrameworkAssemblyReference
adamralph Feb 7, 2015
1c546d9
red: revert 923 AssemblyUtility changes
adamralph Feb 7, 2015
759560a
green: implement scenario Packages.PackageContainsAFrameworkAssemblyR…
adamralph Feb 7, 2015
d4c0cf9
refactor: AssemblyResolver and PackageAssemblyResolver internals
adamralph Feb 7, 2015
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 4 additions & 1 deletion ScriptCs.sln
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.30501.0
VisualStudioVersion = 12.0.31101.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ScriptCs", "src\ScriptCs\ScriptCs.csproj", "{25080671-1A80-4041-B9C7-260578FF4849}"
EndProject
Expand Down Expand Up @@ -37,6 +37,9 @@ EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ScriptCs.Engine.Mono.Tests", "test\ScriptCs.Engine.Mono.Tests\ScriptCs.Engine.Mono.Tests.csproj", "{D0723C2D-D3B4-40B7-8E5A-84FB3A6E5092}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ScriptCs.Tests.Acceptance", "test\ScriptCs.Tests.Acceptance\ScriptCs.Tests.Acceptance.csproj", "{10684649-2922-41F5-AB9B-20B127CBF92C}"
ProjectSection(ProjectDependencies) = postProject
{25080671-1A80-4041-B9C7-260578FF4849} = {25080671-1A80-4041-B9C7-260578FF4849}
EndProjectSection
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{B138045D-DC04-4A04-A2BA-F771173BCC32}"
ProjectSection(SolutionItems) = preProject
Expand Down
62 changes: 20 additions & 42 deletions src/ScriptCs.Core/AssemblyResolver.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,14 +10,10 @@ namespace ScriptCs
public class AssemblyResolver : IAssemblyResolver
{
private readonly Dictionary<string, List<string>> _assemblyPathCache = new Dictionary<string, List<string>>();

private readonly IFileSystem _fileSystem;

private readonly IPackageAssemblyResolver _packageAssemblyResolver;

private readonly ILog _logger;

private readonly IAssemblyUtility _assemblyUtility;
private readonly ILog _logger;

public AssemblyResolver(
IFileSystem fileSystem,
Expand All @@ -29,11 +25,14 @@ public AssemblyResolver(
Guard.AgainstNullArgumentProperty("fileSystem", "PackagesFolder", fileSystem.PackagesFolder);
Guard.AgainstNullArgumentProperty("fileSystem", "BinFolder", fileSystem.BinFolder);

Guard.AgainstNullArgument("packageAssemblyResolver", packageAssemblyResolver);
Guard.AgainstNullArgument("assemblyUtility", assemblyUtility);
Guard.AgainstNullArgument("logger", logger);

_fileSystem = fileSystem;
_packageAssemblyResolver = packageAssemblyResolver;
_logger = logger;
_assemblyUtility = assemblyUtility;

_logger = logger;
}

public IEnumerable<string> GetAssemblyPaths(string path, bool binariesOnly = false)
Expand All @@ -43,61 +42,40 @@ public IEnumerable<string> GetAssemblyPaths(string path, bool binariesOnly = fal
List<string> assemblies;
if (!_assemblyPathCache.TryGetValue(path, out assemblies))
{
var packageAssemblies = GetPackageAssemblies(path);
var binAssemblies = GetBinAssemblyPaths(path);

assemblies = packageAssemblies.Union(binAssemblies).ToList();

assemblies = GetPackageAssemblyNames(path).Union(GetBinAssemblyPaths(path)).ToList();
_assemblyPathCache.Add(path, assemblies);
}

if (binariesOnly)
{
return assemblies.Where(
m => m.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase) || m.EndsWith(".exe", StringComparison.InvariantCultureIgnoreCase));
}

return assemblies;
return binariesOnly
? assemblies.Where(m =>
m.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase) ||
m.EndsWith(".exe", StringComparison.InvariantCultureIgnoreCase))
: assemblies.ToArray();
}

private IEnumerable<string> GetBinAssemblyPaths(string path)
{
var binFolder = Path.Combine(path, _fileSystem.BinFolder);
if (!_fileSystem.DirectoryExists(binFolder))
{
return Enumerable.Empty<string>();
yield break;
}

var assemblies = _fileSystem.EnumerateBinaries(binFolder, SearchOption.TopDirectoryOnly)
.Where(f => _assemblyUtility.IsManagedAssembly(f))
.ToList();

foreach (var assembly in assemblies)
foreach (var assembly in _fileSystem.EnumerateBinaries(binFolder, SearchOption.TopDirectoryOnly)
.Where(f => _assemblyUtility.IsManagedAssembly(f)))
{
_logger.DebugFormat("Found assembly in bin folder: {0}", Path.GetFileName(assembly));
yield return assembly;
}

return assemblies;
}

private IEnumerable<string> GetPackageAssemblies(string path)
private IEnumerable<string> GetPackageAssemblyNames(string path)
{
var packagesFolder = Path.Combine(path, _fileSystem.PackagesFolder);
if (!_fileSystem.DirectoryExists(packagesFolder))
foreach (var assembly in _packageAssemblyResolver.GetAssemblyNames(path))
{
return Enumerable.Empty<string>();
_logger.DebugFormat("Found package assembly: {0}", Path.GetFileName(assembly));
yield return assembly;
}

var assemblies = _packageAssemblyResolver.GetAssemblyNames(path)
.Where(f => _assemblyUtility.IsManagedAssembly(f))
.ToList();

foreach (var packageAssembly in assemblies)
{
_logger.DebugFormat("Found package assembly: {0}", Path.GetFileName(packageAssembly));
}

return assemblies;
}
}
}
13 changes: 2 additions & 11 deletions src/ScriptCs.Core/AssemblyUtility.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,22 +1,13 @@
using System;
using System.Reflection;

using ScriptCs.Contracts;

namespace ScriptCs
{
using System.IO;

public class AssemblyUtility : IAssemblyUtility
public class AssemblyUtility : IAssemblyUtility
{
public bool IsManagedAssembly(string path)
{
if (!Path.IsPathRooted(path) && !(path.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase) ||
path.EndsWith(".exe", StringComparison.InvariantCultureIgnoreCase)))
{
return true;
}

try
{
AssemblyName.GetAssemblyName(path);
Expand All @@ -43,4 +34,4 @@ public AssemblyName GetAssemblyName(string path)
return AssemblyName.GetAssemblyName(path);
}
}
}
}
91 changes: 45 additions & 46 deletions src/ScriptCs.Core/PackageAssemblyResolver.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,23 +12,30 @@ public class PackageAssemblyResolver : IPackageAssemblyResolver
private readonly IFileSystem _fileSystem;
private readonly IPackageContainer _packageContainer;
private readonly ILog _logger;
private readonly IAssemblyUtility _assemblyUtility;

private List<IPackageReference> _topLevelPackages;

public PackageAssemblyResolver(IFileSystem fileSystem, IPackageContainer packageContainer, ILog logger)
public PackageAssemblyResolver(
IFileSystem fileSystem, IPackageContainer packageContainer, ILog logger, IAssemblyUtility assemblyUtility)
{
Guard.AgainstNullArgument("fileSystem", fileSystem);
Guard.AgainstNullArgumentProperty("fileSystem", "PackagesFolder", fileSystem.PackagesFolder);
Guard.AgainstNullArgumentProperty("fileSystem", "PackagesFile", fileSystem.PackagesFile);

Guard.AgainstNullArgument("packageContainer", packageContainer);
Guard.AgainstNullArgument("logger", logger);
Guard.AgainstNullArgument("assemblyUtility", assemblyUtility);

_fileSystem = fileSystem;
_packageContainer = packageContainer;
_logger = logger;
_assemblyUtility = assemblyUtility;
}

public void SavePackages()
{
var packagesFolder = Path.Combine(_fileSystem.CurrentDirectory, _fileSystem.PackagesFolder);

if (!_fileSystem.DirectoryExists(packagesFolder))
{
_logger.Info("Packages directory does not exist!");
Expand All @@ -40,12 +47,9 @@ public void SavePackages()

public IEnumerable<IPackageReference> GetPackages(string workingDirectory)
{
var packageFile = Path.Combine(workingDirectory, _fileSystem.PackagesFile);
var packages = _packageContainer.FindReferences(packageFile).ToList();

_topLevelPackages = packages;

return packages;
var packagesFile = Path.Combine(workingDirectory, _fileSystem.PackagesFile);
_topLevelPackages = _packageContainer.FindReferences(packagesFile).ToList();
return _topLevelPackages.ToArray();
}

public IEnumerable<string> GetAssemblyNames(string workingDirectory)
Expand All @@ -56,75 +60,70 @@ public IEnumerable<string> GetAssemblyNames(string workingDirectory)
return Enumerable.Empty<string>();
}

var packageFile = Path.Combine(workingDirectory, _fileSystem.PackagesFile);
var packageDir = Path.Combine(workingDirectory, _fileSystem.PackagesFolder);
var packagesFile = Path.Combine(workingDirectory, _fileSystem.PackagesFile);
var packagesFolder = Path.Combine(workingDirectory, _fileSystem.PackagesFolder);

var foundAssemblyPaths = new List<string>();

LoadFiles(packageDir, packages, foundAssemblyPaths, _fileSystem.FileExists(packageFile));

return foundAssemblyPaths;
var names = new List<string>();
GetAssemblyNames(packagesFolder, packages, names, _fileSystem.FileExists(packagesFile));
return names;
}

private void LoadFiles(
private void GetAssemblyNames(
string packageDir,
IEnumerable<IPackageReference> packageReferences,
List<string> foundAssemblies,
bool strictLoad = true)
ICollection<string> names,
bool strictLoad)
{
foreach (var packageRef in packageReferences)
foreach (var packageReference in packageReferences)
{
var nugetPackage = _packageContainer.FindPackage(packageDir, packageRef);
if (nugetPackage == null)
var packageObject = _packageContainer.FindPackage(packageDir, packageReference);
if (packageObject == null)
{
_logger.WarnFormat(
CultureInfo.InvariantCulture,
"Cannot find: {0} {1}",
packageRef.PackageId,
packageRef.Version);
packageReference.PackageId,
packageReference.Version);

continue;
}

var compatibleFiles = nugetPackage.GetCompatibleDlls(packageRef.FrameworkName);
if (compatibleFiles == null)
var compatibleDlls = packageObject.GetCompatibleDlls(packageReference.FrameworkName);
if (compatibleDlls == null)
{
_logger.WarnFormat(
CultureInfo.InvariantCulture,
"Cannot find compatible binaries for {0} in: {1} {2}",
packageRef.FrameworkName,
packageRef.PackageId,
packageRef.Version);
packageReference.FrameworkName,
packageReference.PackageId,
packageReference.Version);

continue;
}

var compatibleFilePaths = compatibleFiles
.Select(packageFile => Path.Combine(packageDir, nugetPackage.FullName, packageFile))
.Concat(nugetPackage.FrameworkAssemblies);

foreach (var path in compatibleFilePaths)
foreach (var name in compatibleDlls
.Select(packageFile => Path.Combine(packageDir, packageObject.FullName, packageFile))
.Where(path => _assemblyUtility.IsManagedAssembly(path))
.Concat(packageObject.FrameworkAssemblies)
.Where(name => !names.Contains(name)))
{
if (foundAssemblies.Contains(path))
{
continue;
}

foundAssemblies.Add(path);
_logger.Debug("Found: " + path);
names.Add(name);
_logger.Debug("Found: " + name);
}

if (nugetPackage.Dependencies == null || !nugetPackage.Dependencies.Any() || !strictLoad)
if (packageObject.Dependencies == null || !packageObject.Dependencies.Any() || !strictLoad)
{
continue;
}

var dependencyReferences = nugetPackage.Dependencies
.Where(i => _topLevelPackages.All(x => x.PackageId != i.Id))
.Select(i => new PackageReference(i.Id, i.FrameworkName, i.Version));
var dependencyReferences = packageObject.Dependencies
.Where(dependency =>
_topLevelPackages.All(topLevelPackage => topLevelPackage.PackageId != dependency.Id))
.Select(dependency =>
new PackageReference(dependency.Id, dependency.FrameworkName, dependency.Version));

LoadFiles(packageDir, dependencyReferences, foundAssemblies, true);
GetAssemblyNames(packageDir, dependencyReferences, names, true);
}
}
}
}
}
16 changes: 5 additions & 11 deletions test/ScriptCs.Core.Tests/AssemblyUtilityTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,26 +1,20 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ScriptCs.Contracts;
using Should;
using Xunit;

namespace ScriptCs.Tests
{
using System.IO;
using Contracts;
using Xunit;
using Should;

public class AssemblyUtilityTests
{
public class TheIsManagedAssemblyMethod
{
private readonly IAssemblyUtility _assemblyUtility = new AssemblyUtility();

[Fact]
public void ShouldReturnTrueWhenThePathIsNotRootedAndDoesNotHaveADllOrExeExtension()
public void ShouldReturnFalseWhenThePathDoesNotPointToAManagedAssembly()
{
_assemblyUtility.IsManagedAssembly("System.Data").ShouldBeTrue();
_assemblyUtility.IsManagedAssembly("ScriptCs.Core.Tests.dll.config").ShouldBeFalse();
}

[Fact]
Expand Down
Loading