temp [rebase]

Author: 0UserName

.github/workflows/main.yml

@@ -2,33 +2,27 @@ name: 'Build'
 'on':
   push:
     branches:
-      - 'develop'
       - 'master'
 
 jobs:
   build:
 
     runs-on: 'windows-latest'
 
-    env:
-      RepositoryUrl: 'https://github.com/${{ github.repository }}'
-      RepositoryBranch: '${{ github.ref }}'
-      SourceRevisionId: '${{ github.sha }}'
-
     steps:
-      - name: 'Checkout repository'
-        uses: 'actions/checkout@v2'
+      - name: 'Checkout'
+        uses: 'actions/checkout@v6'
 
 
       - name: 'Setup .NET'
-        uses: 'actions/setup-dotnet@v1'
+        uses: 'actions/setup-dotnet@v5'
         with:
-          dotnet-version: 5.0.x
-      
-      
-      - name: 'Setup MSBuild'
-        uses: 'microsoft/[email protected]'
-      
+          dotnet-version: 10.0.x
+          
 
       - name: 'Build'
-        run : 'msbuild NuGetSwitcher.sln /t:Restore /t:Rebuild -property:Configuration=Release'
+        run : 'dotnet build -c Release'
+
+
+      - name: 'Pack'
+        uses: 'dotnet pack -p:PackAsTool=true -p:ToolCommandName=nswitch -p:PackageOutputPath=../nupkg'

lib/nugetswitcher.core/Commands/AbstractCommand.cs

@@ -0,0 +1,95 @@
+using CliWrap;
+using CliWrap.Buffered;
+using CliWrap.Builders;
+
+using NuGet.ProjectModel;
+
+using NuGetSwitcher.Interface.Logger;
+using NuGetSwitcher.Interface.Logger.Enums;
+
+using NuGetSwitcher.Interface.Options;
+using NuGetSwitcher.Interface.References;
+
+using System;
+using System.Collections.Generic;
+
+using System.IO;
+using System.Linq;
+
+namespace NuGetSwitcher.Core.Commands
+{
+    public abstract class AbstractCommand(string referenceType, IOptions option, ILogger logger)
+    {
+        public abstract void Switch();
+
+        /// <summary>
+        /// Iterates through the dependencies provided in the lock file and matches 
+        /// against items found in the directories listed in the configuration file. 
+        /// For each matched item, the passed delegate is executed.
+        /// </summary>
+        protected virtual void IterateAndExecute<TReference>(IEnumerable<TReference> references, Action<IProjectReference, LockFileTargetLibrary, string> func) where TReference : IProjectReference
+        {
+            logger.Clear();
+
+            IReadOnlyDictionary<string, string> items = option.GetIncludeItems(referenceType);
+
+            foreach (IProjectReference reference in references)
+            {
+                foreach (LockFileTargetLibrary library in reference.GetLockFileLibraries())
+                {
+                    if (items.TryGetValue(library.Name, out string absolutePath))
+                    {
+                        func(reference, library, absolutePath);
+                    }
+                }
+
+                reference.Save();
+            }
+        }
+
+        /// <summary>
+        /// Adds reference to the project. It is assumed
+        /// that the original reference has been removed 
+        /// earlier.
+        /// </summary>
+        /// 
+        /// <param name="unevaluatedInclude">
+        /// Must contain the assembly 
+        /// name or the absolute path 
+        /// to the project or Package
+        /// Id.
+        /// </param>
+        protected virtual void AddReference(IProjectReference reference, string referenceType, string unevaluatedInclude, Dictionary<string, string> metadata)
+        {
+            if (reference.TryAddReference(unevaluatedInclude, referenceType, metadata))
+            {
+                logger.LogMessage($"{referenceType}: {Path.GetFileName(unevaluatedInclude)} has been added", Category.I, project: reference.Project.FullPath);
+            }
+        }
+
+        /// <summary>
+        /// Performs an action on the solution file, taking 
+        /// into account the passed <paramref name="builder"/>.
+        /// </summary>
+        protected virtual void SlnAction(string solution, IEnumerable<string> projects, ArgumentsBuilder builder)
+        {
+            void Log(string source, Category category)
+            {
+                if (!string.IsNullOrWhiteSpace(source))
+                {
+                    logger.Clear();
+                    logger.LogMessage(source, category);
+                }
+            }
+
+            if (projects.Any())
+            {
+                // TODO: Switch to async.
+                BufferedCommandResult result = Cli.Wrap("dotnet").WithWorkingDirectory(Path.GetDirectoryName(solution)).WithArguments(args => args.Add("sln").Add(solution).Add(builder.Build(), false)).ExecuteBufferedAsync().GetAwaiter().GetResult();
+
+                Log(result.StandardOutput, Category.I);
+                Log(result.StandardError, Category.E);
+            }
+        }
+    }
+}

lib/nugetswitcher.core/Commands/PackageCommand.cs

@@ -0,0 +1,97 @@
+using CliWrap.Builders;
+
+using Microsoft.Build.Evaluation;
+
+using NuGetSwitcher.Core.Constants;
+using NuGetSwitcher.Core.References;
+using NuGetSwitcher.Interface.Logger;
+using NuGetSwitcher.Interface.Logger.Enums;
+
+using NuGetSwitcher.Interface.Options;
+using NuGetSwitcher.Interface.References;
+using NuGetSwitcher.Interface.Solution;
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace NuGetSwitcher.Core.Commands
+{
+    public sealed class PackageCommand(IOptions option, ISolution solution, ILogger logger) : AbstractCommand(ReferenceType.PackageReference, option, logger)
+    {
+        /// <summary>
+        /// Returns references that match the passed type and are marked with the Temp attribute.
+        /// </summary>
+        private static IEnumerable<ProjectItem> GetTempItems(IProjectReference reference, string referenceType)
+        {
+            return reference.Project.GetItems(referenceType).Where(i => i.HasMetadata("Temp")).ToList();
+        }
+
+        /// <summary>
+        /// Removes projects from the solution file.
+        /// </summary>
+        private void RemoveFromSolution(string absolutePath, IEnumerable<string> projects)
+        {
+            SlnAction(absolutePath, projects, new ArgumentsBuilder().Add("remove").Add(projects));
+        }
+
+        /// <summary>
+        /// Removes references 
+        /// that marked with the Temp attribute and originated from 
+        /// the Dependencies or FrameworkAssemblies sections of the 
+        /// lock file.
+        /// </summary>
+        public IEnumerable<string> SwitchDependencies(IProjectReference reference, string referenceType)
+        {
+            List<string> projects = new
+            List<string>
+            ();
+
+            foreach (ProjectItem item in GetTempItems(reference, referenceType))
+            {
+                if (referenceType == ReferenceType.ProjectReference)
+                {
+                    projects.Add(item.EvaluatedInclude);
+                }
+
+                // Implicit.
+                if (!item.HasMetadata("Version"))
+                {
+                    reference.Project.RemoveItem(item);
+                }
+                // Explicit.
+                else
+                {
+                    item.UnevaluatedInclude = item.GetMetadataValue("Temp");
+
+                    item.RemoveMetadata("Temp");
+                    item.RemoveMetadata("Name");
+
+                    item.ItemType = referenceType;
+                }
+
+                logger.LogMessage($"{referenceType}: {Path.GetFileName(item.EvaluatedInclude)} has been switched back", Category.I, project: reference.Project.FullPath);
+            }
+
+            return projects;
+        }
+
+        /// <inheritdoc/>
+        public override void Switch()
+        {
+            HashSet<string> projects = new
+            HashSet<string>
+            ();
+
+            foreach (IProjectReference reference in solution.GetLoadedProjects<ProjectReference>())
+            {
+                projects.UnionWith(SwitchDependencies(reference, ReferenceType.Reference));
+                projects.UnionWith(SwitchDependencies(reference, ReferenceType.ProjectReference));
+
+                reference.Save();
+            }
+
+            RemoveFromSolution(solution.AbsolutePath, projects);
+        }
+    }
+}

lib/nugetswitcher.core/Commands/ProjectCommand.cs

@@ -0,0 +1,119 @@
+using CliWrap.Builders;
+
+using Microsoft.Build.Evaluation;
+
+using NuGet.ProjectModel;
+
+using NuGetSwitcher.Core.Constants;
+using NuGetSwitcher.Core.References;
+using NuGetSwitcher.Interface.Logger;
+using NuGetSwitcher.Interface.Logger.Enums;
+
+using NuGetSwitcher.Interface.Options;
+using NuGetSwitcher.Interface.References;
+using NuGetSwitcher.Interface.Solution;
+
+using System.Collections.Generic;
+
+namespace NuGetSwitcher.Core.Commands
+{
+    public class ProjectCommand(IOptions option, ISolution solution, ILogger logger) : AbstractCommand(ReferenceType.ProjectReference, option, logger)
+    {
+        /// <summary>
+        /// Adds one or more projects to the solution file.
+        /// </summary>
+        private void AddToSolution(string absolutePath, IEnumerable<string> projects)
+        {
+            base.SlnAction(absolutePath, projects, new ArgumentsBuilder().Add("add").Add(projects).Add("--solution-folder").Add("Temporary"));
+        }
+
+        /// <summary>
+        /// Includes references to the GAC assemblies
+        /// listed in the FrameworkAssemblies section
+        /// of the lock file.
+        /// </summary>
+        public virtual void SwitchSysDependency(IProjectReference reference, LockFileTargetLibrary library)
+        {
+            Dictionary<string, string> metadata = new
+            Dictionary<string, string>
+            {
+                { "Temp", library.Name }
+            };
+
+            foreach (string assembly in library.FrameworkAssemblies)
+            {
+                base.AddReference(reference, ReferenceType.Reference, assembly, metadata);
+            }
+        }
+
+        /// <summary>
+        /// Includes implicit, explicit project references
+        /// listed in the Dependencies section of the lock
+        /// file.
+        /// </summary>
+        /// 
+        /// <remarks>
+        /// Implicit dependencies mean transitive.
+        /// </remarks>
+        public virtual void SwitchPkgDependency(IProjectReference reference, LockFileTargetLibrary library, string absolutePath)
+        {
+            /*
+             * References can be represented by several values in
+             * an ItemGroup, for example, when included using the 
+             * Condition attribute.
+             */
+
+            ICollection<ProjectItem> items = reference.Project.GetItemsByEvaluatedInclude(library.Name);
+
+            // Implicit.
+            if (items.Count == 0)
+            {
+                base.AddReference(reference, ReferenceType.ProjectReference, absolutePath, new Dictionary<string, string>(2)
+                {
+                    { "Temp", library.Name }
+                });
+            }
+            // Explicit.
+            else
+            {
+                /*
+                 * Re-creating an item can lead to the loss
+                 * of user metadata; in order to avoid this,
+                 * the item is redefined.
+                 */
+
+                foreach (ProjectItem item in items)
+                {
+                    item.ItemType = ReferenceType.ProjectReference;
+
+                    item.SetMetadataValue("Temp", item.EvaluatedInclude);
+                    item.SetMetadataValue("Name", item.EvaluatedInclude);
+
+                    item.UnevaluatedInclude = absolutePath;
+                }
+
+                logger.LogMessage($"Dependency: {library.Name} has been switched. Type: {ReferenceType.ProjectReference}", Category.I, project: reference.Project.FullPath);
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void Switch()
+        {
+            HashSet<string> packages = new
+            HashSet<string>
+            ();
+
+            void Executor(IProjectReference reference, LockFileTargetLibrary library, string absolutePath)
+            {
+                SwitchSysDependency(reference, library);
+                SwitchPkgDependency(reference, library, absolutePath);
+
+                packages.Add(absolutePath);
+            }
+
+            IterateAndExecute(solution.GetLoadedProjects<ProjectReference>(), Executor);
+
+            AddToSolution(solution.AbsolutePath, packages);
+        }
+    }
+}