dotnet · akshita31 · Sep 5, 2019 · Aug 27, 2019 · Aug 27, 2019 · Aug 27, 2019
diff --git a/MLS.Agent.Tools.Tests/InMemoryDirectoryAccessor.cs b/MLS.Agent.Tools.Tests/InMemoryDirectoryAccessor.cs
@@ -160,7 +160,7 @@ public IEnumerable<RelativeFilePath> GetAllFiles()
         {
             return _files.Keys
                 .OfType<FileInfo>()
-                .Where(key => key.Directory.FullName == WorkingDirectory.FullName)
+                .Where(key => FileSystemInfoComparer.Instance.Equals(key.Directory, WorkingDirectory))
                 .Select(key => new RelativeFilePath(
                     Path.GetRelativePath(WorkingDirectory.FullName, key.FullName)));
         }

diff --git a/MLS.Agent.Tools/DirectoryAccessor.cs b/MLS.Agent.Tools/DirectoryAccessor.cs
@@ -13,11 +13,19 @@ public static bool DirectoryExists(
             string relativePath) =>
             directoryAccessor.DirectoryExists(new RelativeDirectoryPath(relativePath));
 
+        public static bool RootDirectoryExists(
+            this IDirectoryAccessor directoryAccessor) =>
+            directoryAccessor.DirectoryExists(new RelativeDirectoryPath("."));
+
         public static void EnsureDirectoryExists(
             this IDirectoryAccessor directoryAccessor,
             string relativePath) =>
             directoryAccessor.EnsureDirectoryExists(new RelativeDirectoryPath(relativePath));
 
+        public static void EnsureRootDirectoryExists(
+            this IDirectoryAccessor directoryAccessor) =>
+            directoryAccessor.EnsureDirectoryExists(new RelativeDirectoryPath("."));
+
         public static bool FileExists(
             this IDirectoryAccessor directoryAccessor,
             string relativePath) =>
@@ -57,5 +65,8 @@ public static FileInfo GetFullyQualifiedFilePath(this IDirectoryAccessor directo
 
         public static FileInfo GetFullyQualifiedFilePath(this IDirectoryAccessor directoryAccessor, RelativeFilePath relativePath) => 
             (FileInfo) directoryAccessor.GetFullyQualifiedPath(relativePath);
+
+        public static DirectoryInfo GetFullyQualifiedDirectoryPath(this IDirectoryAccessor directoryAccessor, RelativeDirectoryPath relativePath) =>
+            (DirectoryInfo)directoryAccessor.GetFullyQualifiedPath(relativePath);
     }
 }
diff --git a/MLS.Agent.Tools/PathUtilities.cs b/MLS.Agent.Tools/PathUtilities.cs
@@ -8,6 +8,7 @@
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
+using System.Text;
 
 // adapted from http://source.roslyn.io/#System.Reflection.Metadata/System/Reflection/Internal/Utilities/PathUtilities.cs,36b27d7696df4d1e
 
@@ -511,6 +512,11 @@ public static string GetRelativePath(string directory, string fullPath)
                 return GetRelativeChildPath(directory, fullPath);
             }
 
+            if (IsChildPath(fullPath, directory))
+            {
+                return GetRelativeParentPath(directory, fullPath);
+            }
+
             var directoryPathParts = GetPathParts(directory);
             var fullPathParts = GetPathParts(fullPath);
 
@@ -556,6 +562,20 @@ public static string GetRelativePath(string directory, string fullPath)
             return relativePath;
         }
 
+        private static string GetRelativeParentPath(string childPath, string parentPath)
+        {
+            var childPathParts = GetPathParts(childPath);
+            var parentPathParts = GetPathParts(parentPath);
+
+            var relativePath = new StringBuilder();
+            for (int i = 0; i < childPathParts.Length - parentPathParts.Length; i++)
+            {
+                relativePath.Append(ParentRelativeDirectory + DirectorySeparatorStr);
+            }
+
+            return relativePath.ToString();
+        }
+
         /// <summary>
         /// True if the child path is a child of the parent path.
         /// </summary>
@@ -585,15 +605,15 @@ private static string GetRelativeChildPath(string parentPath, string childPath)
 
         private static string[] GetPathParts(string path)
         {
-            var pathParts = path.Split(s_pathChars);
+            var pathParts = path.Split(s_pathChars).Where(p => !string.IsNullOrWhiteSpace(p));
 
             // remove references to self directories ('.')
             if (pathParts.Contains(ThisDirectory))
             {
                 pathParts = pathParts.Where(s => s != ThisDirectory).ToArray();
             }
 
-            return pathParts;
+            return pathParts.ToArray();
         }
 
         /// <summary>

diff --git a/MLS.Agent.Tools/TypeExtensions.cs b/MLS.Agent.Tools/TypeExtensions.cs
@@ -16,5 +16,12 @@ public static string ReadManifestResource(this Type type, string resourceName)
                 return reader.ReadToEnd();
             }
         }
+
+        public static bool CanBeInstantiated(this Type type)
+        {
+            return !type.IsAbstract
+                    && !type.IsGenericTypeDefinition
+                    && !type.IsInterface;
+        }
     }
 }
diff --git a/Microsoft.DotNet.Interactive.Tests/Microsoft.DotNet.Interactive.Tests.csproj b/Microsoft.DotNet.Interactive.Tests/Microsoft.DotNet.Interactive.Tests.csproj
@@ -31,6 +31,7 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Microsoft.DotNet.Interactive\Microsoft.DotNet.Interactive.csproj" />
+    <ProjectReference Include="..\MLS.Agent.Tools.Tests\MLS.Agent.Tools.Tests.csproj" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Update="Microsoft.NET.Test.Sdk" Version="16.2.0" />

diff --git a/Microsoft.DotNet.Interactive.Tests/NuGetPackagePathResolverTests.cs b/Microsoft.DotNet.Interactive.Tests/NuGetPackagePathResolverTests.cs
@@ -0,0 +1,31 @@
+using Xunit;
+using MLS.Agent.Tools;
+using Microsoft.DotNet.Interactive;
+using FluentAssertions;
+using System.Linq;
+using MLS.Agent.Tools.Tests;
+using System.IO;
+using System.Runtime.InteropServices.ComTypes;
+using System.ComponentModel.DataAnnotations;
+
+namespace Microsoft.DotNet.Interactive.Tests
+{
+    public class NuGetPackagePathResolverTests
+    {
+        [Fact]
+        public void Can_find_path_of_nuget_package()
+        {
+            var firstPackageRef = new NugetPackageReference("first", "2.0.0");
+            var secondPackageRef = new NugetPackageReference("second", "3.0.0");
+            var directory = new InMemoryDirectoryAccessor()
+            {
+                ($"{firstPackageRef.PackageName}/{firstPackageRef.PackageVersion}/lib/netstandard2.0/{firstPackageRef.PackageName}.dll", ""),
+                ($"{secondPackageRef.PackageName}/{secondPackageRef.PackageVersion}/lib/netstandard2.0/{secondPackageRef.PackageName}.dll", "")
+            };
+
+            NuGetPackagePathResolver.TryGetNuGetPackageBasePath(firstPackageRef, directory.GetAllFilesRecursively().Select(file => directory.GetFullyQualifiedFilePath(file)), out var nugetPackageDirectory);
+
+            nugetPackageDirectory.GetFullyQualifiedRoot().FullName.Should().Be(directory.GetFullyQualifiedPath(new RelativeDirectoryPath($"{firstPackageRef.PackageName}/{firstPackageRef.PackageVersion}")).FullName);
+        }
+    }
+}
diff --git a/Microsoft.DotNet.Interactive/CommandDeserializer.cs b/Microsoft.DotNet.Interactive/CommandDeserializer.cs
@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Reflection;
 using Microsoft.DotNet.Interactive.Commands;
+using MLS.Agent.Tools;
 using Newtonsoft.Json.Linq;
 
 namespace Microsoft.DotNet.Interactive
@@ -19,10 +20,7 @@ public CommandDeserializer()
             _map = Assembly
                .GetExecutingAssembly()
                .GetTypes()
-               .Where(t => typeof(IKernelCommand).IsAssignableFrom(t)
-                        && !t.IsAbstract
-                        && !t.IsGenericTypeDefinition
-                        && !t.IsInterface)
+               .Where(t => t.CanBeInstantiated() && (typeof(IKernelCommand).IsAssignableFrom(t)))
                .ToDictionary(t => t.Name, t => t, StringComparer.InvariantCultureIgnoreCase);
         }
 

diff --git a/Microsoft.DotNet.Interactive/Commands/LoadExtensionFromNuGetPackage.cs b/Microsoft.DotNet.Interactive/Commands/LoadExtensionFromNuGetPackage.cs
@@ -0,0 +1,22 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Microsoft.DotNet.Interactive.Commands
+{
+    public class LoadExtensionFromNuGetPackage : KernelCommandBase
+    {
+        public LoadExtensionFromNuGetPackage(NugetPackageReference nugetPackageReference, IEnumerable<FileInfo> metadataReferences)
+        {
+            NugetPackageReference = nugetPackageReference ?? throw new ArgumentNullException(nameof(nugetPackageReference));
+            MetadataReferences = metadataReferences ?? throw new ArgumentNullException(nameof(metadataReferences));
+        }
+
+        public NugetPackageReference NugetPackageReference { get; }
+        public IEnumerable<FileInfo> MetadataReferences { get; }
+    }
+}
diff --git a/Microsoft.DotNet.Interactive/Events/ExtensionLoading.cs b/Microsoft.DotNet.Interactive/Events/ExtensionLoading.cs
diff --git a/Microsoft.DotNet.Interactive/Events/KernelExtensionLoadException.cs b/Microsoft.DotNet.Interactive/Events/KernelExtensionLoadException.cs
@@ -0,0 +1,19 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.DotNet.Interactive.Commands;
+
+namespace Microsoft.DotNet.Interactive.Events
+{
+    public class KernelExtensionLoadException : KernelEventBase
+    {
+        public KernelExtensionLoadException(string message)
+        {
+            Message = message ?? throw new System.ArgumentNullException(nameof(message));
+        }
+
+        public string Message { get; }
+
+        public override string ToString() => $"{base.ToString()}: {Message}";
+    }
+}
diff --git a/Microsoft.DotNet.Interactive/Events/NuGetPackageAdded.cs b/Microsoft.DotNet.Interactive/Events/NuGetPackageAdded.cs
@@ -1,12 +1,19 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using Microsoft.DotNet.Interactive.Commands;
+
 namespace Microsoft.DotNet.Interactive.Events
 {
     public class NuGetPackageAdded : KernelEventBase
     {
-        public NuGetPackageAdded(NugetPackageReference packageReference)
+        public NuGetPackageAdded(AddNugetPackage addNugetPackage,  NugetPackageReference packageReference): base(addNugetPackage)
         {
+            if (addNugetPackage == null)
+            {
+                throw new System.ArgumentNullException(nameof(addNugetPackage));
+            }
+
             PackageReference = packageReference;
         }
 

diff --git a/Microsoft.DotNet.Interactive/ExtensionLoaded.cs b/Microsoft.DotNet.Interactive/ExtensionLoaded.cs
@@ -0,0 +1,19 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.DotNet.Interactive.Commands;
+using Microsoft.DotNet.Interactive.Events;
+using System.IO;
+
+namespace Microsoft.DotNet.Interactive
+{
+    public class ExtensionLoaded : KernelEventBase
+    { 
+        public ExtensionLoaded(FileInfo extensionPath)
+        {
+            ExtensionPath = extensionPath ?? throw new System.ArgumentNullException(nameof(extensionPath));
+        }
+
+        public FileInfo ExtensionPath { get; }
+    }
+}
diff --git a/Microsoft.DotNet.Interactive/IExtensibleKernel.cs b/Microsoft.DotNet.Interactive/IExtensibleKernel.cs
@@ -0,0 +1,13 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using MLS.Agent.Tools;
+using System.Threading.Tasks;
+
+namespace Microsoft.DotNet.Interactive
+{
+    public interface IExtensibleKernel
+    {
+        public Task LoadExtensionsInDirectory(IDirectoryAccessor directory, KernelInvocationContext invocationContext);
+    }
+}
diff --git a/Microsoft.DotNet.Interactive/IKernel.cs b/Microsoft.DotNet.Interactive/IKernel.cs
@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.DotNet.Interactive.Commands;
 using Microsoft.DotNet.Interactive.Events;
+using MLS.Agent.Tools;
 
 namespace Microsoft.DotNet.Interactive
 {