Support for NuGet source mapping.

Author: gfraiteur

.gitignore

@@ -11,3 +11,4 @@ eng/tools
 .teamcity/target
 /.config/dotnet-tools.json
 /.tools
+nuget.config

src/PostSharp.Engineering.BuildTools/Build/Model/BuildInfo.cs

@@ -1,5 +1,6 @@
 // Copyright (c) SharpCrafters s.r.o. See the LICENSE.md file in the root directory of this repository root for details.
 
+using PostSharp.Engineering.BuildTools.Dependencies.Model;
 using System;
 
 namespace PostSharp.Engineering.BuildTools.Build.Model
@@ -15,9 +16,15 @@ namespace PostSharp.Engineering.BuildTools.Build.Model
     public record BuildInfo( string? PackageVersion, string Configuration, string MSBuildConfiguration, string? PackagePreviewVersion )
     {
         public BuildInfo( string? packageVersion, BuildConfiguration configuration, Product product, string? packagePreviewVersion ) : this(
+            packageVersion,
+            configuration,
+            product.DependencyDefinition,
+            packagePreviewVersion ) { }
+
+        public BuildInfo( string? packageVersion, BuildConfiguration configuration, DependencyDefinition dependencyDefinition, string? packagePreviewVersion ) : this(
             packageVersion,
             configuration.ToString(),
-            product.DependencyDefinition.MSBuildConfiguration[configuration],
+            dependencyDefinition.MSBuildConfiguration[configuration],
             packagePreviewVersion ) { }
 
         public bool IsPrerelease => this.PackageVersion?.Contains( "-", StringComparison.Ordinal ) ?? throw new InvalidOperationException();

src/PostSharp.Engineering.BuildTools/Build/Model/Product.cs

@@ -210,8 +210,10 @@ public ParametrizedDependency[] ParametrizedDependencies
         internal bool UseDocker => this.ResolvedBuildAgentRequirements.IsDockerHost;
 
         internal DockerSpec? DockerSpec
-            => this.ResolvedBuildAgentRequirements.IsDockerHost ? new DockerSpec( $"{this.ProductNameWithoutDot}-{this.ProductFamily.Version}".ToLowerInvariant() ) : null;
-        
+            => this.ResolvedBuildAgentRequirements.IsDockerHost
+                ? new DockerSpec( $"{this.ProductNameWithoutDot}-{this.ProductFamily.Version}".ToLowerInvariant() )
+                : null;
+
         public bool IsPublishingNonReleaseBranchesAllowed { get; init; }
 
         /// <summary>
@@ -236,6 +238,13 @@ internal DockerSpec? DockerSpec
         /// </summary>
         public Pattern ConsumableDepsFiles { get; init; } = Pattern.Empty;
 
+        /// <summary>
+        /// Gets or sets a value indicating whether the <c>prepare</c> should generate the <c>nuget.config</c> file.
+        /// </summary>
+        public bool GenerateNuGetConfig { get; init; }
+
+        public string[] OwnPackagePatterns { get; init; } = [];
+
         public bool TryGetDependency( string name, [NotNullWhen( true )] out ParametrizedDependency? dependency )
         {
             dependency = this.ParametrizedDependencies.SingleOrDefault( d => d.Name == name );
@@ -625,7 +634,7 @@ It must be imported by other repos as a dependency.
         private BuildInfo ReadGeneratedVersionFile( string path )
         {
             var versionFilePath = path;
-            var versionFile = Project.FromFile( versionFilePath, new ProjectOptions() );
+            var versionFile = Project.FromFile( versionFilePath, MSBuildLoadOptions.IgnoreImportErrors );
 
             string packageVersion;
 
@@ -716,7 +725,7 @@ public bool TryReadMainVersionFile(
                 return false;
             }
 
-            var versionFile = Project.FromFile( mainVersionFilePath, new ProjectOptions() );
+            var versionFile = Project.FromFile( mainVersionFilePath, MSBuildLoadOptions.IgnoreImportErrors );
 
             var mainVersion = versionFile
                 .Properties
@@ -975,7 +984,7 @@ public string GetConfigurationSpecificVersionsFilePath( BuildContext context, Co
                 return null;
             }
 
-            var versionFile = Project.FromFile( path, new ProjectOptions() );
+            var versionFile = Project.FromFile( path, MSBuildLoadOptions.IgnoreImportErrors );
 
             var configuration = versionFile.Properties.SingleOrDefault( p => p.Name == "EngineeringConfiguration" )
                 ?.UnevaluatedValue;
@@ -1147,12 +1156,12 @@ public bool PrepareVersionsFile(
         {
             var configuration = settings.BuildConfiguration;
 
-            context.Console.WriteMessage( "Preparing the version file" );
+            context.Console.WriteMessage( "Preparing the version file." );
 
             var propsFilePath = this.GetVersionPropertiesFilePath( context, settings );
             Directory.CreateDirectory( Path.GetDirectoryName( propsFilePath )! );
 
-            // Load Versions.g.props.
+            // Load Versions.<Configuration>.g.props.
             if ( !DependenciesOverrideFile.TryLoad( context, settings, configuration, out dependenciesOverrideFile ) )
             {
                 return false;
@@ -1199,6 +1208,12 @@ public bool PrepareVersionsFile(
                 return false;
             }
 
+            // Generate nuget.config.
+            if ( this.GenerateNuGetConfig && !TryGenerateNuGetConfig( context, dependenciesOverrideFile, settings ) )
+            {
+                return false;
+            }
+
             context.Console.WriteMessage( $"Writing '{propsFilePath}'." );
             File.WriteAllText( propsFilePath, props );
 
@@ -1263,7 +1278,7 @@ private bool TryComputeVersion(
                 }
                 else
                 {
-                    var versionFile = Project.FromFile( dependencySource.VersionFile, new ProjectOptions() );
+                    var versionFile = Project.FromFile( dependencySource.VersionFile, MSBuildLoadOptions.IgnoreImportErrors );
 
                     var propertyName = this.MainVersionDependency!.NameWithoutDot + "MainVersion";
 
@@ -1375,6 +1390,129 @@ private bool TryComputeVersion(
             return true;
         }
 
+        private static bool TryGenerateNuGetConfig( BuildContext context, DependenciesOverrideFile dependenciesOverrideFile, BuildSettings buildSettings )
+        {
+            var product = context.Product;
+            var baseFilePath = Path.Combine( context.RepoDirectory, "nuget.base.config" );
+            var targetFilePath = Path.Combine( context.RepoDirectory, "nuget.config" );
+
+            context.Console.WriteMessage( $"Writing '{targetFilePath}'." );
+
+            XDocument document;
+            XElement rootElement;
+
+            if ( File.Exists( baseFilePath ) )
+            {
+                document = XDocument.Load( baseFilePath );
+                rootElement = document.Root!;
+            }
+            else
+            {
+                document = new XDocument();
+                rootElement = new XElement( "configuration" );
+                document.Add( rootElement );
+            }
+
+            var packageSourceMappingElement = rootElement.Element( "packageSourceMapping" );
+
+            if ( packageSourceMappingElement == null )
+            {
+                packageSourceMappingElement = new XElement( "packageSourceMapping" );
+                rootElement.Add( packageSourceMappingElement );
+            }
+
+            var packageSourcesElement = rootElement.Element( "packageSources" );
+
+            if ( packageSourcesElement == null )
+            {
+                packageSourcesElement = new XElement( "packageSources" );
+                rootElement.Add( packageSourcesElement );
+            }
+
+            // Add the current artifact directory.
+            var artifactDirectory = Path.Combine(
+                context.RepoDirectory,
+                product.PrivateArtifactsDirectory.ToString( new BuildInfo( null, buildSettings.BuildConfiguration, product, null ) ) );
+
+            AddDirectory( product.ProductName, artifactDirectory, product.DependencyDefinition.PackagePatterns );
+
+            // Add dependencies.
+            foreach ( var dependency in dependenciesOverrideFile.Dependencies )
+            {
+                var dependencyDefinition = product.GetDependencyDefinition( dependency.Key );
+                var parametrizedDependency = product.ParametrizedDependencies.Single( d => d.Name == dependency.Key );
+                var dependencyDirectory = Path.GetDirectoryName( dependency.Value.VersionFile )!;
+
+                if ( dependency.Value.SourceKind == DependencySourceKind.Local )
+                {
+                    dependencyDirectory = Path.Combine(
+                        dependencyDirectory,
+                        dependencyDefinition.PrivateArtifactsDirectory.ToString(
+                            new BuildInfo(
+                                null,
+                                parametrizedDependency.ConfigurationMapping[buildSettings.BuildConfiguration],
+                                dependencyDefinition,
+                                null ) ) );
+                }
+
+                if ( !AddDirectory( dependency.Key, dependencyDirectory, dependencyDefinition.PackagePatterns ) )
+                {
+                    return false;
+                }
+            }
+
+            document.Save( targetFilePath );
+
+            return true;
+
+            bool AddDirectory( string name, string directory, string[]? patterns )
+            {
+                var addElement = new XElement( "add" );
+                addElement.Add( new XAttribute( "key", name ) );
+                addElement.Add( new XAttribute( "value", directory ) );
+                packageSourcesElement.Add( addElement );
+
+                var packageSourceElement = new XElement( "packageSource" );
+                packageSourceElement.Add( new XAttribute( "key", name ) );
+                packageSourceMappingElement.Add( packageSourceElement );
+
+                foreach ( var pattern in patterns ?? [] )
+                {
+                    AddPattern( pattern );
+                }
+
+                return true;
+
+                void AddPattern( string pattern )
+                {
+                    var packageElement = new XElement( "package" );
+                    packageElement.Add( new XAttribute( "pattern", pattern ) );
+                    packageSourceElement.Add( packageElement );
+                }
+            }
+        }
+
+        private static string? ParsePackageName( string packageFile )
+        {
+            var fileName = Path.GetFileNameWithoutExtension( packageFile );
+
+            // Use NuGet.Versioning to properly extract package name without version suffix
+            var packageNameParts = fileName.Split( '-' )[0].Split( '.' );
+            string? packageName = null;
+
+            for ( var i = packageNameParts.Length - 1; i > 0; i-- )
+            {
+                if ( !int.TryParse( packageNameParts[i], out _ ) )
+                {
+                    packageName = string.Join( ".", packageNameParts.Take( i + 1 ) );
+
+                    break;
+                }
+            }
+
+            return packageName;
+        }
+
         private bool TryGenerateManifestFileContent(
             VersionComponents version,
             BuildConfiguration configuration,
@@ -1518,7 +1656,7 @@ void AppendToArcadeSuffix( string s )
             foreach ( var kvp in this.ExportedProperties )
             {
                 var propsFilePath = Path.Combine( context.RepoDirectory, kvp.Key );
-                var propsFile = Project.FromFile( propsFilePath, new ProjectOptions() );
+                var propsFile = Project.FromFile( propsFilePath, MSBuildLoadOptions.IgnoreImportErrors );
 
                 foreach ( var exportedPropertyName in kvp.Value )
                 {
@@ -2330,7 +2468,7 @@ private bool TryReadDependencyVersionsFromSourceRepos(
                 }
 
                 var document = XDocument.Parse( mainVersionContent );
-                var project = Project.FromXmlReader( document.CreateReader(), new ProjectOptions() );
+                var project = Project.FromXmlReader( document.CreateReader(), MSBuildLoadOptions.IgnoreImportErrors );
                 var mainVersionPropertyValue = project.Properties.FirstOrDefault( p => p.Name == "MainVersion" )?.EvaluatedValue;
 
                 if ( string.IsNullOrEmpty( mainVersionPropertyValue ) )
@@ -2682,7 +2820,7 @@ private static BuildConfiguration GetDependencyConfiguration( DependencyDefiniti
                 throw new InvalidOperationException( $"The dependency '{definition.Name}' is not resolved. " );
             }
 
-            var project = Project.FromFile( source.VersionFile, new ProjectOptions() );
+            var project = Project.FromFile( source.VersionFile, MSBuildLoadOptions.IgnoreImportErrors );
             var property = project.AllEvaluatedProperties.Single( p => p.Name == $"{definition.NameWithoutDot}BuildConfiguration" );
 
             ProjectCollection.GlobalProjectCollection.UnloadAllProjects();

src/PostSharp.Engineering.BuildTools/Dependencies/Definitions/MetalamaDependencies.V2026_0.cs

@@ -56,6 +56,7 @@ public MetalamaDependencyDefinition(
         public static ProductFamily Family { get; } = new( _projectName, "2026.0", DevelopmentDependencies.Family, PostSharpDependencies.V2026_0.Family )
         {
             UpstreamProductFamily = V2025_2.Family
+
             // DownstreamProductFamily = V2026_1.Family
         };
 
@@ -85,6 +86,16 @@ public MetalamaDependencyDefinition(
                 VcsProvider.GitHub,
                 MetalamaGitHubOrganization.Metalama )
             {
+                PackagePatterns =
+                [
+                    "Metalama.Backstage*",
+                    "Metalama.Framework*", 
+                    "Metalama.Extensions*", 
+                    "Metalama.Patterns*",
+                    "Metalama.LinqPad*", 
+                    "Metalama.Migration*"
+                ]
+
                 // SuppressUpstream = true
             };
 

src/PostSharp.Engineering.BuildTools/Dependencies/Definitions/PostSharpDependencies.V2026_0.cs

@@ -39,6 +39,11 @@ public PostSharpDependencyDefinition()
                     false )
             {
                 this.EngineeringDirectory = @"Build\Distribution\eng";
+
+                // We intentionally exclude PostSharp.Engineering.Sdk because it is referenced from global.json
+                // which is not often updated referencing PostSharp.Engineering locally, so exact the package version
+                // is not present in the local artifact directory.
+                this.PackagePatterns = ["PostSharp.Engineering.BuildTools.*"];
             }
         }
 

src/PostSharp.Engineering.BuildTools/Dependencies/DependenciesHelper.cs

@@ -124,7 +124,7 @@ private static bool TryGetTransitiveDependencies(
                 continue;
             }
 
-            var versionFile = Project.FromFile( directDependency.Source.VersionFile!, new ProjectOptions() );
+            var versionFile = Project.FromFile( directDependency.Source.VersionFile!, MSBuildLoadOptions.IgnoreImportErrors );
 
             var transitiveDependencies = versionFile.Items.Where( i => i.ItemType == directDependency.Dependency.NameWithoutDot + "Dependencies" );
 

src/PostSharp.Engineering.BuildTools/Dependencies/Model/DependencyDefinition.cs

@@ -17,6 +17,8 @@ namespace PostSharp.Engineering.BuildTools.Dependencies.Model
     [PublicAPI]
     public class DependencyDefinition
     {
+        private readonly string[]? _packagePatterns;
+
         [return: NotNullIfNotNull( "dependency" )]
         public static implicit operator DependencyDefinition?( ParametrizedDependency? dependency ) => dependency?.Definition;
 
@@ -63,6 +65,12 @@ public class DependencyDefinition
 
         public ParametricString PublicArtifactsDirectory { get; init; } = Path.Combine( "artifacts", "publish", "public" );
 
+        public string[] PackagePatterns
+        {
+            get => this._packagePatterns ?? [this.Name, this.Name + "*"];
+            init => this._packagePatterns = value;
+        }
+
         /// <summary>
         /// Gets or sets the order in which products in the same family should be built. This is a poorman version of a recursive build
         /// taking dependencies into account, because PostSharp.Engineering does not know detailed dependencies.