Track Project files instead of folders for DotNet

Jaykul · Jaykul · commit 6465e458cc16 · 2023-10-28T01:32:06.000-04:00
Also split pack and push
diff --git a/DockerBuild.Task.ps1 b/DockerBuild.Task.ps1
@@ -2,18 +2,20 @@ Add-BuildTask DockerBuild @{
     # This task can only be skipped if the images are newer than the source files
     If      = $dotnetProjects
     Inputs  = {
-        $dotnetProjects.Where{ Get-ChildItem $_ -File -Filter Dockerfile } |
+        $dotnetProjects.Where{ Get-ChildItem (Split-Path $_) -File -Filter Dockerfile } |
             Get-ChildItem -File
     }
     Outputs = {
         # We use the iidfile as a standing for date of the image
-        $dotnetProjects.Where{ Get-ChildItem $_ -File -Filter Dockerfile } |
-            Split-Path -Leaf | Join-Path -Path $OutputRoot -ChildPath { $_.ToLower() }
+        # Projects that have an adjacent Dockerfile
+        $dotnetProjects
+        | Where-Object { Get-ChildItem (Split-Path $_) -File -Filter Dockerfile }
+        | Join-Path -Path $OutputRoot -ChildPath { (Split-Path $_ -LeafBase).ToLower() }
     }
     Jobs    = {
-        foreach ($project in $dotnetProjects.Where{ Get-ChildItem $_ -File -Filter Dockerfile }) {
-            Set-Location $project
-            $name = (Split-Path $project -Leaf).ToLower()
+        foreach ($project in $dotnetProjects.Where{ Get-ChildItem (Split-Path $_) -File -Filter Dockerfile }) {
+            Set-Location (Split-Path $project)
+            $name = (Split-Path $project -LeafBase).ToLower()
 
             Write-Build Gray "docker build . --tag $name --iidfile $(Join-Path $OutputRoot $name)"
             docker build . --tag $name --iidfile (Join-Path $OutputRoot $name)
diff --git a/DotNetBuild.Task.ps1 b/DotNetBuild.Task.ps1
@@ -3,13 +3,13 @@ Add-BuildTask DotNetBuild @{
     If      = $dotnetProjects
     Inputs  = {
         # Exclude generated source files in /obj/ folders
-        Get-ChildItem $dotnetProjects -Recurse -File -Filter *.cs |
+        Get-ChildItem (Split-Path $dotnetProjects) -Recurse -File -Filter *.cs |
             Where-Object FullName -NotMatch "[\\/]obj[\\/]"
     }
     Outputs = {
         foreach ($project in $dotnetProjects) {
-            $BaseName = (Get-Item $project -Filter *.csproj).BaseName
-            (Get-ChildItem $project/bin -Filter "$BaseName.dll" -Recurse -ErrorAction Ignore) ?? $BuildRoot
+            $BaseName = Split-Path $project -LeafBase
+            (Get-ChildItem (Join-Path (Split-Path $project) bin) -Filter "$BaseName.dll" -Recurse -ErrorAction Ignore) ?? $BuildRoot
         }
     }
     Jobs    = "DotNetRestore", "GitVersion", {
@@ -21,8 +21,8 @@ Add-BuildTask DotNetBuild @{
         }
 
         foreach ($project in $dotnetProjects) {
-            if (Test-Path "Variable:GitVersion.$((Split-Path $project -Leaf).ToLower())") {
-                $options["p"] = "Version=$((Get-Variable "GitVersion.$((Split-Path $project -Leaf).ToLower())" -ValueOnly).InformationalVersion)"
+            if (Test-Path "Variable:GitVersion.$((Split-Path $project -LeafBase).ToLower())") {
+                $options["p"] = "Version=$((Get-Variable "GitVersion.$((Split-Path $project -LeafBase).ToLower())" -ValueOnly).InformationalVersion)"
             }
 
             Write-Build Gray "dotnet build $project --configuration $configuration -p $($options["p"])"
diff --git a/DotNetPack.Task.ps1 b/DotNetPack.Task.ps1
@@ -7,31 +7,17 @@ Add-BuildTask DotNetPack @{
         $script:DotNetPublishRoot = New-Item $script:DotNetPublishRoot -ItemType Directory -Force -ErrorAction SilentlyContinue | Convert-Path
 
         foreach ($project in $dotnetProjects) {
-            if (Test-Path "Variable:GitVersion.$((Split-Path $project -Leaf).ToLower())") {
-                $options["p"] = "Version=$((Get-Variable "GitVersion.$((Split-Path $project -Leaf).ToLower())" -ValueOnly).InformationalVersion)"
+            $Name = Split-Path $project -LeafBase
+            if (Test-Path "Variable:GitVersion.$($Name.ToLower())") {
+                $options["p"] = "Version=$((Get-Variable "GitVersion.$($Name.ToLower())" -ValueOnly).InformationalVersion)"
             }
 
-            Write-Host "Publishing $project"
-            $Name = Split-Path $project -Leaf
+            Write-Host "Publishing $Name"
 
-            Set-Location $project
-            $OutputFolder = @($dotnetProjects).Count -gt 1 ? "$DotNetPublishRoot${/}$Name" : $DotNetPublishRoot
+            Set-Location (Split-Path $project)
+            $OutputFolder = $DotNetPublishRoot
             Write-Build Gray "dotnet pack $project --output '$OutputFolder' --no-build --configuration $configuration -p $($options["p"])"
             dotnet pack $project --output "$OutputFolder" --no-build --configuration $configuration @options --include-symbols
-
-            if ($BuildSystem -ne 'None' -and
-                $BranchName -in "master", "main" -and
-                -not [string]::IsNullOrWhiteSpace($NuGetPublishKey)) {
-                    Write-Host "$OutputFolder" "-Recurse" "-Filter" "*$Name*$($GitVersion.MajorMinorPatch).nupkg"
-                    $Package = Get-ChildItem $OutputFolder -Recurse -Filter "*$Name*$($GitVersion.MajorMinorPatch).nupkg"
-                    Write-Build Gray "dotnet nuget push $package --api-key $NuGetPublishKey --source $NuGetPublishUri"
-                    dotnet nuget push $package --api-key $NuGetPublishKey --source $NuGetPublishUri
-            } else {
-                Write-Warning ("Skipping push: To push, ensure that...`n" +
-                    "`t* You are in a known build system (Current: $BuildSystem)`n" +
-                    "`t* You are committing to the main branch (Current: $BranchName) `n" +
-                    "`t* The repository APIKey is defined in `$NuGetPublishKey (Current: $(![string]::IsNullOrWhiteSpace($NuGetPublishKey)))")
-            }
         }
     }
 }
diff --git a/DotNetPublish.Task.ps1 b/DotNetPublish.Task.ps1
@@ -3,12 +3,12 @@ Add-BuildTask DotNetPublish @{
     If      = $dotnetProjects
     Inputs  = {
         # Exclude generated source files in /obj/ folders
-        Get-ChildItem $dotnetProjects -Recurse -File -Filter *.cs |
+        Get-ChildItem (Split-Path $dotnetProjects) -Recurse -File -Filter *.cs |
             Where-Object FullName -NotMatch "[\\/]obj[\\/]"
     }
     Outputs = {
         foreach ($project in $dotnetProjects) {
-            $Name = Split-Path $project -Leaf
+            $Name = Split-Path $project -LeafBase
             $OutputFolder = @($dotnetProjects).Count -gt 1 ? "$DotNetPublishRoot${/}$Name" : $DotNetPublishRoot
             $Expected = Join-Path $OutputFolder -ChildPath "$Name.dll"
             Write-Host "Expected Output: $Expected"
@@ -26,16 +26,16 @@ Add-BuildTask DotNetPublish @{
         }
 
         foreach ($project in $dotnetProjects) {
-            Write-Host "Publishing $project"
-            $Name = Split-Path $project -Leaf
-            if (Test-Path "Variable:GitVersion.$((Split-Path $project -Leaf).ToLower())") {
-                $options["p"] = "Version=$((Get-Variable "GitVersion.$((Split-Path $project -Leaf).ToLower())" -ValueOnly).InformationalVersion)"
+            $Name = Split-Path $project -LeafBase
+            Write-Host "Publishing $Name"
+            if (Test-Path "Variable:GitVersion.$($Name.ToLower())") {
+                $options["p"] = "Version=$((Get-Variable "GitVersion.$($Name.ToLower())" -ValueOnly).InformationalVersion)"
             }
 
-            Set-Location $project
+            Set-Location (Split-Path $project)
             $OutputFolder = @($dotnetProjects).Count -gt 1 ? "$DotNetPublishRoot${/}$Name" : $DotNetPublishRoot
-            Write-Build Gray "dotnet publish --output $OutputFolder --no-build --configuration $configuration -p $($options["p"])"
-            dotnet publish --output "$OutputFolder" --no-build --configuration $configuration
+            Write-Build Gray "dotnet publish $project --output $OutputFolder --no-build --configuration $configuration -p $($options["p"])"
+            dotnet publish $project --output "$OutputFolder" --no-build --configuration $configuration
         }
     }
 }
diff --git a/DotNetPush.Task.ps1 b/DotNetPush.Task.ps1
@@ -0,0 +1,36 @@
+Add-BuildTask DotNetPush @{
+    # This task should be skipped if there are no C# projects to build
+    If      = $dotnetProjects
+    Jobs    = "DotNetPack", {
+        $local:options = @{} # + $script:dotnetOptions
+
+        $script:DotNetPublishRoot = New-Item $script:DotNetPublishRoot -ItemType Directory -Force -ErrorAction SilentlyContinue | Convert-Path
+
+        foreach ($project in $dotnetProjects) {
+            $Name = Split-Path $project -LeafBase
+            if (Test-Path "Variable:GitVersion.$($Name.ToLower())") {
+                $options["p"] = "Version=$((Get-Variable "GitVersion.$($Name.ToLower())" -ValueOnly).InformationalVersion)"
+            }
+
+            Write-Host "Publishing $name"
+
+            Set-Location (Split-Path $project)
+            $OutputFolder = @($dotnetProjects).Count -gt 1 ? "$DotNetPublishRoot${/}$Name" : $DotNetPublishRoot
+
+            $Package = Get-ChildItem $OutputFolder -Recurse -Filter "*$Name*$($GitVersion.MajorMinorPatch).nupkg"
+
+            if ($BuildSystem -ne 'None' -and
+                $BranchName -in "master", "main" -and
+                -not [string]::IsNullOrWhiteSpace($NuGetPublishKey)) {
+                    Write-Host "$OutputFolder" "-Recurse" "-Filter" "*$Name*$($GitVersion.MajorMinorPatch).nupkg"
+                    Write-Build Gray "dotnet nuget push $package --api-key $NuGetPublishKey --source $NuGetPublishUri"
+                    dotnet nuget push $package --api-key $NuGetPublishKey --source $NuGetPublishUri
+            } else {
+                Write-Warning ("Skipping push: To push $Package ensure that...`n" +
+                    "`t* You are in a known build system (Current: $BuildSystem)`n" +
+                    "`t* You are committing to the main branch (Current: $BranchName) `n" +
+                    "`t* The repository APIKey is defined in `$NuGetPublishKey (Current: $(![string]::IsNullOrWhiteSpace($NuGetPublishKey)))")
+            }
+        }
+    }
+}
diff --git a/DotNetRestore.Task.ps1 b/DotNetRestore.Task.ps1
@@ -2,10 +2,10 @@ Add-BuildTask DotNetRestore @{
     # This task should be skipped if there are no C# projects to build
     If      = $dotnetProjects
     Inputs  = {
-        Get-ChildItem $dotnetProjects -Recurse -File -Filter *.*proj
+        Get-Item $dotnetProjects
     }
     Outputs = {
-        Join-Path $dotnetProjects obj project.assets.json
+        $dotnetProjects.ForEach{ Join-Path (Split-Path $_) obj project.assets.json }
     }
     Jobs    = {
         $local:options = @{} + $script:dotnetOptions
diff --git a/DotNetTest.Task.ps1 b/DotNetTest.Task.ps1
@@ -2,8 +2,8 @@ Add-BuildTask DotNetTest @{
     # This task should be skipped if there are no C# projects to build
     If      = $dotnetTestProjects
     Inputs  = {
-        Get-ChildItem $dotnetProjects -Recurse -File -Filter *.cs |
-            Where-Object FullName -NotMatch "[\\/]obj[\\/]"
+        Get-ChildItem (Split-Path $dotnetProjects) -Recurse -File -Filter *.cs
+        | Where-Object FullName -NotMatch "[\\/]obj[\\/]"
     }
     Outputs = {
         (Get-ChildItem $TestResultsRoot -Filter *.trx -Recurse -ErrorAction Ignore) ?? $TestResultsRoot
diff --git a/PSModuleBinaryTrim.Task.ps1 b/PSModuleBinaryTrim.Task.ps1
@@ -3,5 +3,6 @@ Add-BuildTask PSModuleBinaryTrim @{
     Jobs    = {
         $InformationPreference = "Continue"
         Get-ChildItem $PSModuleOutputPath -Recurse -Filter System.*.dll | Remove-Item
+        Get-ChildItem $PSModuleOutputPath -Recurse -Filter *.nupkg | Move-Item -Destination $PSModuleOutputPath -Verbose
     }
 }
diff --git a/_Initialize.ps1 b/_Initialize.ps1
@@ -122,17 +122,18 @@ if (([bool]$DotNet = $dotnetProjects -or $DotNetPublishRoot)) {
     # The DotNetPublishRoot is the "publish" folder within the OutputRoot (used for dotnet publish output)
     $script:DotNetPublishRoot ??= Join-Path $script:OutputRoot publish
 
-    # The projects are expected to each be in their own folder
-    # Dotnet allows us to pass it the _folder_ that we want to build/test
-    # So our $buildProjects are the names of the folders that contain the projects
+    # Our $buildProjects are either:
+    # - Just the name
+    # - The full path to a csproj file
+    # We're going to normalize to the full csproj path
     $script:dotnetProjects = @(
         if (!$dotnetProjects) {
             Write-Information "  No `$DotNetProjects specified"
-            Get-ChildItem -Path $BuildRoot -Include *.*proj -Recurse | Split-Path
+            Get-ChildItem -Path $BuildRoot -Include *.*proj -Recurse
         } elseif (![IO.Path]::IsPathRooted(@($dotnetProjects)[0])) {
             Write-Information "  Relative `$DotNetProjects specified"
             Get-ChildItem -Path $BuildRoot -Include *.*proj -Recurse |
-                Where-Object { $dotnetProjects -contains $_.BaseName } | Split-Path
+                Where-Object { $dotnetProjects -contains $_.BaseName }
         } else {
             $dotnetProjects
         }
@@ -142,11 +143,11 @@ if (([bool]$DotNet = $dotnetProjects -or $DotNetPublishRoot)) {
     $script:dotnetTestProjects = @(
         if (!$dotnetTestProjects) {
             Write-Information "  No `$DotNetTestProjects specified"
-            Get-ChildItem -Path $BuildRoot -Include *Test.*proj -Recurse | Split-Path
+            Get-ChildItem -Path $BuildRoot -Include *Test.*proj -Recurse
         } elseif (![IO.Path]::IsPathRooted(@($dotnetTestProjects)[0])) {
             Write-Information "  Relative `$DotNetTestProjects specified"
-            Get-ChildItem -Path $BuildRoot -Include *Test.*proj -Recurse |
-                Where-Object { $dotnetTestProjects -contains $_.BaseName } | Split-Path
+            Get-ChildItem -Path $BuildRoot -Include *.*proj -Recurse |
+                Where-Object { $dotnetTestProjects -contains $_.BaseName }
         } else {
             $dotnetTestProjects
         }
@@ -246,7 +247,7 @@ if ($PSModuleName) {
 # PackageNames allows you to build and tag multiple packages from the same repository
 $script:PackageNames = $script:PackageNames ?? @(
 if ($dotnetProjects) {
-    (Split-Path $dotnetProjects -Leaf).ToLower()
+    (Split-Path $dotnetProjects -LeafBase).ToLower()
 } elseif ($PSModuleName) {
     @($PSModuleName)
 } else {
@@ -258,15 +259,15 @@ if ($dotnetProjects) {
 if ($PSModuleName -and $dotnetProjects -or $DotNetPublishRoot) {
     Add-BuildTask Test Build, DotNetTest, PSModuleAnalyze, PSModuleTest
     Add-BuildTask Build DotNetRestore, PSModuleRestore, GitVersion, DotNetBuild, DotNetPublish, PSModuleBuild, PSModuleBinaryTrim #, PSModuleBuildHelp
-    Add-BuildTask Publish TagSource, DotNetPack, PSModulePublish
+    Add-BuildTask Publish TagSource, DotNetPack, DotNetPush, PSModulePublish
 } elseif ($PSModuleName) {
     Add-BuildTask Test Build, PSModuleAnalyze, PSModuleTest
     Add-BuildTask Build PSModuleRestore, GitVersion, PSModuleBuild #, PSModuleBuildHelp
     Add-BuildTask Publish Test, TagSource, PSModulePublish
 } elseif ($dotnetProjects) {
     Add-BuildTask Test Build, DotNetTest
     Add-BuildTask Build DotNetRestore, GitVersion, DotNetBuild, DotNetPublish
-    Add-BuildTask Publish Test, TagSource, DotNetPack
+    Add-BuildTask Publish Test, TagSource, DotNetPack, DotNetPush
 }
 
 

Original file line number	Diff line number	Diff line change
`@@ -3,13 +3,13 @@ Add-BuildTask DotNetBuild @{`
`3`	`3`	`If = $dotnetProjects`
`4`	`4`	`Inputs = {`
`5`	`5`	`# Exclude generated source files in /obj/ folders`
`6`		`- Get-ChildItem $dotnetProjects -Recurse -File -Filter *.cs \|`
	`6`	`+ Get-ChildItem (Split-Path $dotnetProjects) -Recurse -File -Filter *.cs \|`
`7`	`7`	`Where-Object FullName -NotMatch "[\\/]obj[\\/]"`
`8`	`8`	`}`
`9`	`9`	`Outputs = {`
`10`	`10`	`foreach ($project in $dotnetProjects) {`
`11`		`- $BaseName = (Get-Item $project -Filter *.csproj).BaseName`
`12`		`- (Get-ChildItem $project/bin -Filter "$BaseName.dll" -Recurse -ErrorAction Ignore) ?? $BuildRoot`
	`11`	`+ $BaseName = Split-Path $project -LeafBase`
	`12`	`+ (Get-ChildItem (Join-Path (Split-Path $project) bin) -Filter "$BaseName.dll" -Recurse -ErrorAction Ignore) ?? $BuildRoot`
`13`	`13`	`}`
`14`	`14`	`}`
`15`	`15`	`Jobs = "DotNetRestore", "GitVersion", {`
`@@ -21,8 +21,8 @@ Add-BuildTask DotNetBuild @{`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`foreach ($project in $dotnetProjects) {`
`24`		`- if (Test-Path "Variable:GitVersion.$((Split-Path $project -Leaf).ToLower())") {`
`25`		`- $options["p"] = "Version=$((Get-Variable "GitVersion.$((Split-Path $project -Leaf).ToLower())" -ValueOnly).InformationalVersion)"`
	`24`	`+ if (Test-Path "Variable:GitVersion.$((Split-Path $project -LeafBase).ToLower())") {`
	`25`	`+ $options["p"] = "Version=$((Get-Variable "GitVersion.$((Split-Path $project -LeafBase).ToLower())" -ValueOnly).InformationalVersion)"`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`Write-Build Gray "dotnet build $project --configuration $configuration -p $($options["p"])"`
Original file line number	Diff line number	Diff line change
`@@ -2,10 +2,10 @@ Add-BuildTask DotNetRestore @{`
`2`	`2`	`# This task should be skipped if there are no C# projects to build`
`3`	`3`	`If = $dotnetProjects`
`4`	`4`	`Inputs = {`
`5`		`- Get-ChildItem $dotnetProjects -Recurse -File -Filter .proj`
	`5`	`+ Get-Item $dotnetProjects`
`6`	`6`	`}`
`7`	`7`	`Outputs = {`
`8`		`- Join-Path $dotnetProjects obj project.assets.json`
	`8`	`+ $dotnetProjects.ForEach{ Join-Path (Split-Path $_) obj project.assets.json }`
`9`	`9`	`}`
`10`	`10`	`Jobs = {`
`11`	`11`	`$local:options = @{} + $script:dotnetOptions`
Original file line number	Diff line number	Diff line change
`@@ -3,5 +3,6 @@ Add-BuildTask PSModuleBinaryTrim @{`
`3`	`3`	`Jobs = {`
`4`	`4`	`$InformationPreference = "Continue"`
`5`	`5`	`Get-ChildItem $PSModuleOutputPath -Recurse -Filter System.*.dll \| Remove-Item`
	`6`	`+ Get-ChildItem $PSModuleOutputPath -Recurse -Filter *.nupkg \| Move-Item -Destination $PSModuleOutputPath -Verbose`
`6`	`7`	`}`
`7`	`8`	`}`