scriptcs · glennblock · Jun 12, 2013 · May 26, 2013 · May 26, 2013 · May 26, 2013
diff --git a/src/ScriptCs.Core/AssemblyName.cs b/src/ScriptCs.Core/AssemblyName.cs
diff --git a/src/ScriptCs.Core/AssemblyResolver.cs b/src/ScriptCs.Core/AssemblyResolver.cs
@@ -0,0 +1,84 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using Common.Logging;
+
+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;
+
+        public AssemblyResolver(
+            IFileSystem fileSystem,
+            IPackageAssemblyResolver packageAssemblyResolver,
+            IAssemblyUtility assemblyUtility,
+            ILog logger)
+        {
+            _fileSystem = fileSystem;
+            _packageAssemblyResolver = packageAssemblyResolver;
+            _logger = logger;
+            _assemblyUtility = assemblyUtility;
+        }
+
+        public IEnumerable<string> GetAssemblyPaths(string path)
+        {
+            Guard.AgainstNullArgument("path", path);
+
+            List<string> assemblies;
+            if (_assemblyPathCache.TryGetValue(path, out assemblies)) return assemblies;
+
+            var packageAssemblies = GetPackageAssemblies(path);
+            var binAssemblies = GetBinAssemblies(path);
+
+            assemblies = packageAssemblies.Union(binAssemblies).ToList();
+            _assemblyPathCache.Add(path, assemblies);
+
+            return assemblies;
+        }
+
+        private IEnumerable<string> GetBinAssemblies(string path)
+        {
+            var binFolder = Path.Combine(path, Constants.BinFolder);
+            if (!_fileSystem.DirectoryExists(binFolder)) 
+                return Enumerable.Empty<string>();
+
+            var assemblies = _fileSystem.EnumerateFiles(binFolder, "*.dll")
+                .Union(_fileSystem.EnumerateFiles(binFolder, "*.exe"))
+                .Where(_assemblyUtility.IsManagedAssembly)
+                .ToList();
+
+            foreach (var assembly in assemblies)
+            {
+                _logger.DebugFormat("Found assembly in bin folder: {0}", Path.GetFileName(assembly));
+            }
+
+            return assemblies;
+        }
+
+        private IEnumerable<string> GetPackageAssemblies(string path)
+        {
+            var packagesFolder = Path.Combine(path, Constants.PackagesFolder);
+            if (!_fileSystem.DirectoryExists(packagesFolder)) 
+                return Enumerable.Empty<string>();
+
+            var assemblies = _packageAssemblyResolver.GetAssemblyNames(path).ToList();
+
+            foreach (var packageAssembly in assemblies)
+            {
+                _logger.DebugFormat("Found package assembly: {0}", Path.GetFileName(packageAssembly));
+            }
+
+            return assemblies;
+        }
+    }
+}
diff --git a/src/ScriptCs.Core/AssemblyUtility.cs b/src/ScriptCs.Core/AssemblyUtility.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Reflection;
+
+namespace ScriptCs
+{
+    public class AssemblyUtility : IAssemblyUtility 
+    {
+        public bool IsManagedAssembly(string path)
+        {
+            try
+            {
+                AssemblyName.GetAssemblyName(path);
+                return true;
+            }
+            catch (BadImageFormatException)
+            {
+                return false;
+            }
+        }
+    }
+}
diff --git a/src/ScriptCs.Core/Constants.cs b/src/ScriptCs.Core/Constants.cs
@@ -7,7 +7,6 @@ public static class Constants
         public const string PackagesFolder = "packages";
         public const string BinFolder = "bin";
         public const string DefaultRepositoryUrl = "https://nuget.org/api/v2/";
-
         public const string DebugContractName = "Debug";
         public const string RunContractName = "Run";
     }

diff --git a/src/ScriptCs.Core/FileSystem.cs b/src/ScriptCs.Core/FileSystem.cs
@@ -6,9 +6,9 @@ namespace ScriptCs
 {
     public class FileSystem : IFileSystem
     {
-        public IEnumerable<string> EnumerateFiles(string dir, string searchPattern)
+        public IEnumerable<string> EnumerateFiles(string dir, string searchPattern, SearchOption searchOption = SearchOption.AllDirectories)
         {
-            return Directory.EnumerateFiles(dir, searchPattern, SearchOption.AllDirectories);
+            return Directory.EnumerateFiles(dir, searchPattern, searchOption);
         }
 
         public void Copy(string source, string dest, bool overwrite)
@@ -81,6 +81,11 @@ public IEnumerable<string> SplitLines(string value)
             return value.Split(new[] { NewLine }, StringSplitOptions.None);
         }
 
+        public void WriteToFile(string path, string text)
+        {
+            File.WriteAllText(path, text);
+        }
+
         public Stream CreateFileStream(string filePath, FileMode mode)
         {
             return new FileStream(filePath, mode);

diff --git a/src/ScriptCs.Core/IAssemblyName.cs b/src/ScriptCs.Core/IAssemblyName.cs
diff --git a/src/ScriptCs.Core/IAssemblyResolver.cs b/src/ScriptCs.Core/IAssemblyResolver.cs
@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace ScriptCs
+{
+    public interface IAssemblyResolver
+    {
+        IEnumerable<string> GetAssemblyPaths(string path);
+    }
+}
diff --git a/src/ScriptCs.Core/IAssemblyUtility.cs b/src/ScriptCs.Core/IAssemblyUtility.cs
@@ -0,0 +1,7 @@
+namespace ScriptCs
+{
+    public interface IAssemblyUtility
+    {
+        bool IsManagedAssembly(string assemblyPath);
+    }
+}
diff --git a/src/ScriptCs.Core/IFileSystem.cs b/src/ScriptCs.Core/IFileSystem.cs
@@ -6,7 +6,7 @@ namespace ScriptCs
 {
     public interface IFileSystem
     {
-        IEnumerable<string> EnumerateFiles(string dir, string search);
+        IEnumerable<string> EnumerateFiles(string dir, string search, SearchOption searchOption = SearchOption.AllDirectories);
 
         void Copy(string source, string dest, bool overwrite);
 
@@ -39,6 +39,8 @@ public interface IFileSystem
         void FileDelete(string path);
 
         IEnumerable<string> SplitLines(string value);
+
+        void WriteToFile(string path, string text);
 
         Stream CreateFileStream(string filePath, FileMode mode);
     }

diff --git a/src/ScriptCs.Core/ScriptCs.Core.csproj b/src/ScriptCs.Core/ScriptCs.Core.csproj
@@ -42,7 +42,8 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AssemblyName.cs" />
+    <Compile Include="AssemblyResolver.cs" />
+    <Compile Include="AssemblyUtility.cs" />
     <Compile Include="DebugScriptExecutor.cs" />
     <Compile Include="Exceptions\ScriptExecutionException.cs" />
     <Compile Include="Exceptions\MissingAssemblyException.cs" />
@@ -56,7 +57,8 @@
     <Compile Include="FilePreProcessorResult.cs" />
     <Compile Include="FileSystem.cs" />
     <Compile Include="Guard.cs" />
-    <Compile Include="IAssemblyName.cs" />
+    <Compile Include="IAssemblyResolver.cs" />
+    <Compile Include="IAssemblyUtility.cs" />
     <Compile Include="IFilePreProcessor.cs" />
     <Compile Include="IFileSystem.cs" />
     <Compile Include="IPackageAssemblyResolver.cs" />

diff --git a/src/ScriptCs/Command/CleanCommand.cs b/src/ScriptCs/Command/CleanCommand.cs
@@ -1,24 +1,21 @@
 using System;
 using System.IO;
-using System.Linq;
 using Common.Logging;
 
 namespace ScriptCs.Command
 {
     internal class CleanCommand : ICleanCommand
     {
         private readonly string _scriptName;
+
         private readonly IFileSystem _fileSystem;
-        private readonly IPackageAssemblyResolver _packageAssemblyResolver;
+
         private readonly ILog _logger;
 
-        public CleanCommand(string scriptName, 
-            IFileSystem fileSystem, 
-            IPackageAssemblyResolver packageAssemblyResolver, ILog logger)
+        public CleanCommand(string scriptName, IFileSystem fileSystem, ILog logger)
         {
             _scriptName = scriptName;
             _fileSystem = fileSystem;
-            _packageAssemblyResolver = packageAssemblyResolver;
             _logger = logger;
         }
 
@@ -29,32 +26,11 @@ public CommandResult Execute()
             var workingDirectory = _fileSystem.GetWorkingDirectory(_scriptName);
             _logger.TraceFormat("Working directory: {0}", workingDirectory);
 
-            var binFolder = Path.Combine(workingDirectory, Constants.BinFolder);
-            _logger.TraceFormat("Bin folder: {0}", binFolder);
-
             var packageFolder = Path.Combine(workingDirectory, Constants.PackagesFolder);
             _logger.TraceFormat("Packages folder: {0}", packageFolder);
 
             try
             {
-                if (_fileSystem.DirectoryExists(binFolder))
-                {
-                    var packages = _packageAssemblyResolver.GetAssemblyNames(workingDirectory);
-
-                    foreach (var package in packages)
-                    {
-                        _logger.DebugFormat("Deleting file: {0}", package);
-                        DeleteFile(package, binFolder);
-                    }
-
-                    var remaining = _fileSystem.EnumerateFiles(binFolder, "*.*").Any();
-                    if (!remaining)
-                    {
-                        _logger.DebugFormat("Deleting bin directory: {0}", binFolder);
-                        _fileSystem.DeleteDirectory(binFolder);
-                    }
-                }
-
                 if (_fileSystem.DirectoryExists(packageFolder))
                 {
                     _logger.DebugFormat("Deleting package directory: {0}", packageFolder);
@@ -70,18 +46,5 @@ public CommandResult Execute()
                 return CommandResult.Error;
             }
         }
-
-        private void DeleteFile(string package, string binFolder)
-        {
-            var assemblyFileName = Path.GetFileName(package);
-            if (assemblyFileName == null) return;
-
-            var destFile = Path.Combine(binFolder, assemblyFileName);
-
-            if (_fileSystem.FileExists(destFile))
-            {
-                _fileSystem.FileDelete(destFile);
-            }
-        }
     }
 }
diff --git a/src/ScriptCs/Command/CommandFactory.cs b/src/ScriptCs/Command/CommandFactory.cs
@@ -23,9 +23,14 @@ public ICommand CreateCommand(ScriptCsArgs args, string[] scriptArgs)
             if (args.Repl)
             {
                 var replCommand = new ExecuteReplCommand(
-                    _scriptServiceRoot.FileSystem, _scriptServiceRoot.ScriptPackResolver,
-                    _scriptServiceRoot.Engine, _scriptServiceRoot.FilePreProcessor, _scriptServiceRoot.Logger, _scriptServiceRoot.Console,
-                    _scriptServiceRoot.AssemblyName);
+                    _scriptServiceRoot.FileSystem,
+                    _scriptServiceRoot.ScriptPackResolver,
+                    _scriptServiceRoot.Engine,
+                    _scriptServiceRoot.FilePreProcessor,
+                    _scriptServiceRoot.Logger,
+                    _scriptServiceRoot.Console,
+                    _scriptServiceRoot.AssemblyResolver);
+
                 return replCommand;
             }
 
@@ -38,7 +43,7 @@ public ICommand CreateCommand(ScriptCsArgs args, string[] scriptArgs)
                     _scriptServiceRoot.Executor,
                     _scriptServiceRoot.ScriptPackResolver,
                     _scriptServiceRoot.Logger,
-                    _scriptServiceRoot.AssemblyName);
+                    _scriptServiceRoot.AssemblyResolver);
 
                 var fileSystem = _scriptServiceRoot.FileSystem;
                 var currentDirectory = fileSystem.CurrentDirectory;
@@ -55,24 +60,7 @@ public ICommand CreateCommand(ScriptCsArgs args, string[] scriptArgs)
                         _scriptServiceRoot.PackageInstaller,
                         _scriptServiceRoot.Logger);
 
-                    var restoreCommand = new RestoreCommand(
-                        args.ScriptName,
-                        _scriptServiceRoot.FileSystem,
-                        _scriptServiceRoot.PackageAssemblyResolver,
-                        _scriptServiceRoot.Logger);
-
-                    return new CompositeCommand(installCommand, restoreCommand, executeCommand);
-                }
-
-                if (args.Restore)
-                {
-                    var restoreCommand = new RestoreCommand(
-                        args.ScriptName, 
-                        _scriptServiceRoot.FileSystem, 
-                        _scriptServiceRoot.PackageAssemblyResolver,
-                        _scriptServiceRoot.Logger);
-
-                    return new CompositeCommand(restoreCommand, executeCommand);
+                    return new CompositeCommand(installCommand, executeCommand);
                 }
 
                 return executeCommand;
@@ -88,22 +76,16 @@ public ICommand CreateCommand(ScriptCsArgs args, string[] scriptArgs)
                     _scriptServiceRoot.PackageInstaller,
                     _scriptServiceRoot.Logger);
 
-                var restoreCommand = new RestoreCommand(
-                    args.Install,
-                    _scriptServiceRoot.FileSystem,
-                    _scriptServiceRoot.PackageAssemblyResolver,
-                    _scriptServiceRoot.Logger);
-
                 var currentDirectory = _scriptServiceRoot.FileSystem.CurrentDirectory;
                 var packageFile = Path.Combine(currentDirectory, Constants.PackagesFile);
 
                 if (!_scriptServiceRoot.FileSystem.FileExists(packageFile))
                 {
                     var saveCommand = new SaveCommand(_scriptServiceRoot.PackageAssemblyResolver);
-                    return new CompositeCommand(installCommand, restoreCommand, saveCommand);
+                    return new CompositeCommand(installCommand, saveCommand);
                 }
 
-                return new CompositeCommand(installCommand, restoreCommand);
+                return installCommand;
             }
 
             if (args.Clean)
@@ -113,7 +95,6 @@ public ICommand CreateCommand(ScriptCsArgs args, string[] scriptArgs)
                 var cleanCommand = new CleanCommand(
                     args.ScriptName,
                     _scriptServiceRoot.FileSystem,
-                    _scriptServiceRoot.PackageAssemblyResolver,
                     _scriptServiceRoot.Logger);
 
                 return new CompositeCommand(saveCommand, cleanCommand);