Fixes bugs with change files microsoft#1465 microsoft#2777 (microsoft#2799)

Author: BernieWhite

docs/changelog.md

@@ -36,6 +36,10 @@ What's changed since pre-release v3.0.0-B0416:
 - Bug fix:
   - Fixed custom emitter loaded too late by @BernieWhite.
     [#2775](https://github.com/microsoft/PSRule/issues/2775)
+  - Fixed Changed files includes excluded paths by @BernieWhite.
+    [#1465](https://github.com/microsoft/PSRule/issues/1465)
+  - Fixed branch ref for working with changes files only examples by @BernieWhite.
+    [#2777](https://github.com/microsoft/PSRule/issues/2777)
 
 ## v3.0.0-B0416 (pre-release)
 

docs/creating-your-pipeline.md

@@ -228,8 +228,23 @@ This option does not work with a shallow or detached checkout, full git history
     Assert-PSRule -Options $options -InputPath '.' -Module $modules -Format File -ErrorAction Stop;
     ```
 
-!!! Tip
-    In some cases it may be necessary to set `Repository.BaseRef` to the default branch of your repository.
-    By default, PSRule will detect the default branch of the repository from the build system environment variables.
-
   [8]: concepts/PSRule/en-US/about_PSRule_Options.md#inputignoreunchangedpath
+
+### Setting the base branch
+
+In some cases it may be necessary to set `Repository.BaseRef` to the default branch of your repository for comparison.
+This option can also be set by using the `PSRULE_REPOSITORY_BASEREF` environment variable.
+By default, PSRule will attempt to detect the default branch of the repository.
+
+```yaml title="ps-rule.yaml"
+repository:
+  baseRef: main
+```
+
+For CI pipelines, the default branch is usually `main` or `master` or an integration branch.
+However, because these branches are not checked out locally by default, you should prepend the remote to the branch name.
+
+```yaml title="ps-rule.yaml"
+repository:
+  baseRef: origin/main
+```

mkdocs.yml

@@ -130,7 +130,9 @@ markdown_extensions:
         - includes/en/abbreviations.md
   - pymdownx.highlight:
       auto_title: false
-      anchor_linenums: false
+      anchor_linenums: true
+      line_spans: __span
+      pygments_lang_class: true
   - pymdownx.superfences
   - pymdownx.pathconverter
   - pymdownx.tabbed:

src/PSRule.CommandLine/Commands/RunCommand.cs

@@ -63,7 +63,7 @@ public static async Task<int> RunAsync(RunOptions operationOptions, ClientContex
 
         // Build command.
         var builder = CommandLineBuilder.Assert(operationOptions.Module ?? [], clientContext.Option, clientContext.Host, file, clientContext.ResolvedModuleVersions);
-        builder.Baseline(Configuration.BaselineOption.FromString(operationOptions.Baseline));
+        builder.Baseline(BaselineOption.FromString(operationOptions.Baseline));
         builder.InputPath(inputPath);
         builder.UnblockPublisher(PUBLISHER);
         builder.Formats(operationOptions.Formats);

src/PSRule.Types/Data/InputFileInfo.cs

@@ -27,9 +27,9 @@ internal InputFileInfo(string basePath, string path)
         BasePath = basePath;
         Name = System.IO.Path.GetFileName(path);
         Extension = System.IO.Path.GetExtension(path);
-        DirectoryName = System.IO.Path.GetDirectoryName(path);
-        DisplayName = Helpers.NormalizePath(basePath, FullName);
-        Path = Helpers.NormalizePath(basePath, FullName);
+        DirectoryName = System.IO.Path.GetDirectoryName(Environment.GetRootedPath(path, normalize: false, basePath: basePath));
+        DisplayName = PathHelpers.NormalizePath(basePath, FullName);
+        Path = PathHelpers.NormalizePath(basePath, FullName);
         _TargetType = string.IsNullOrEmpty(Extension) ? System.IO.Path.GetFileNameWithoutExtension(path) : Extension;
     }
 
@@ -39,10 +39,15 @@ internal InputFileInfo(string basePath, string path)
     public string? FullName { get; }
 
     /// <summary>
-    /// The path to the parent directory containing the file.
+    /// The base path containing the file.
     /// </summary>
     public string? BasePath { get; }
 
+    /// <summary>
+    /// The parent path to the file.
+    /// </summary>
+    public string? ParentPath { get; }
+
     /// <summary>
     /// The file name.
     /// </summary>

src/PSRule.Types/Data/TargetSourceInfo.cs

@@ -132,6 +132,6 @@ public string ToString(string? defaultType, bool useRelativePath)
 
     internal string? GetPath(bool useRelativePath)
     {
-        return useRelativePath ? Helpers.NormalizePath(Environment.GetWorkingPath(), File) : File;
+        return useRelativePath ? PathHelpers.NormalizePath(Environment.GetWorkingPath(), File) : File;
     }
 }

src/PSRule.Types/Expressions/Helpers.cs src/PSRule.Types/Expressions/PathHelpers.cs

@@ -3,7 +3,7 @@
 
 namespace PSRule.Expressions;
 
-internal static class Helpers
+internal static class PathHelpers
 {
     private const char Backslash = '\\';
     private const char Slash = '/';

src/PSRule.Types/Runtime/LoggerExtensions.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using PSRule.Options;
+
 namespace PSRule.Runtime;
 
 /// <summary>
@@ -76,11 +78,45 @@ public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId,
         logger.Log(logLevel, eventId, new FormattedLogValues(message, args), exception, _messageFormatter);
     }
 
+    /// <summary>
+    /// Log a diagnostic message with an <see cref="ExecutionActionPreference"/>.
+    /// The log level is determined by the action preference.
+    /// </summary>
+    /// <param name="logger">A valid <see cref="ILogger"/> instance.</param>
+    /// <param name="actionPreference">The action preference of the diagnostic message.</param>
+    /// <param name="eventId">An event identifier for the diagnostic message.</param>
+    /// <param name="exception">An optional exception which the diagnostic message is related to.</param>
+    /// <param name="message">The format message text.</param>
+    /// <param name="args">Additional arguments to use within the format message.</param>
+    public static void Log(this ILogger logger, ExecutionActionPreference actionPreference, EventId eventId, Exception? exception, string? message, params object?[] args)
+    {
+        var logLevel = GetLogLevel(actionPreference);
+        if (logger == null || !logger.IsEnabled(logLevel))
+            return;
+
+        logger.Log(logLevel, eventId, new FormattedLogValues(message, args), exception, _messageFormatter);
+    }
+
     /// <summary>
     /// Format log messages with values.
     /// </summary>
     private static string MessageFormatter(FormattedLogValues state, Exception? error)
     {
         return state.ToString();
     }
+
+    /// <summary>
+    /// Convert an <see cref="ExecutionActionPreference"/> to a <see cref="LogLevel"/>.
+    /// </summary>
+    private static LogLevel GetLogLevel(ExecutionActionPreference actionPreference)
+    {
+        return actionPreference switch
+        {
+            ExecutionActionPreference.Ignore => LogLevel.None,
+            ExecutionActionPreference.Error => LogLevel.Error,
+            ExecutionActionPreference.Warn => LogLevel.Warning,
+            ExecutionActionPreference.Debug => LogLevel.Debug,
+            _ => LogLevel.None,
+        };
+    }
 }

src/PSRule/Data/InputFileInfoCollection.cs

@@ -2,11 +2,12 @@
 // Licensed under the MIT License.
 
 using System.Collections;
+using PSRule.Expressions;
 
 namespace PSRule.Data;
 
 /// <summary>
-/// A collection of <see cref="InputFileInfo"/>.
+/// A collection of <see cref="InputFileInfo"/> that can be filtered.
 /// </summary>
 internal sealed class InputFileInfoCollection : IInputFileInfoCollection, IEnumerable<InputFileInfo>
 {
@@ -19,14 +20,19 @@ public InputFileInfoCollection(IEnumerable<InputFileInfo> items)
 
     public InputFileInfoCollection(string basePath, string[] items)
     {
-        _Items = items != null && items.Length > 0 ? items.Select(i => new InputFileInfo(basePath, i)).ToArray() : Array.Empty<InputFileInfo>();
+        _Items = items != null && items.Length > 0 ? [.. items.Select(i => new InputFileInfo(basePath, i))] : [];
     }
 
     public IInputFileInfoCollection WithExtension(string extension)
     {
         return new InputFileInfoCollection(_Items.Where(i => i.Extension == extension));
     }
 
+    public IInputFileInfoCollection WithinPath(string path, bool caseSensitive = false)
+    {
+        return new InputFileInfoCollection(_Items.Where(i => PathHelpers.WithinPath(i.Path, path, caseSensitive)));
+    }
+
     #region IEnumerable<InputFileInfo>
 
     public IEnumerator<InputFileInfo> GetEnumerator()

src/PSRule/Data/RepositoryInfo.cs

@@ -16,12 +16,12 @@ namespace PSRule.Emitters;
 internal sealed class EmitterContext : BaseEmitterContext
 {
     private readonly ConcurrentQueue<ITargetObject> _Queue;
-    private readonly PathFilter? _InputFilter;
+    private readonly IPathFilter? _InputFilter;
 
     /// <summary>
     /// Create an instance containing context for an <see cref="IEmitter"/>.
     /// </summary>
-    internal EmitterContext(ConcurrentQueue<ITargetObject> queue, PathFilter? inputFilter, PSRuleOption? option)
+    internal EmitterContext(ConcurrentQueue<ITargetObject> queue, IPathFilter? inputFilter, PSRuleOption? option)
         : base(option?.Input?.StringFormat, option?.Input?.ObjectPath, option?.Input?.FileObjects ?? false)
     {
         _Queue = queue;

src/PSRule/Emitters/EmitterContext.cs

@@ -371,7 +371,7 @@ public static void InvokeRuleBlock(RunspaceContext context, RuleBlock ruleBlock,
     {
         RunspaceContext.CurrentThread = context;
         var condition = ruleBlock.Condition;
-        context.VerboseObjectStart();
+        context.LogObjectStart();
 
         try
         {

src/PSRule/Host/HostHelper.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace PSRule.Pipeline;
+
+#nullable enable
+
+/// <summary>
+/// Wrap a path filter with a filter that only allows files that have changed.
+/// </summary>
+internal sealed class ChangedFilesPathFilter : IPathFilter
+{
+    private readonly IPathFilter _Inner;
+    private readonly string _BasePath;
+    private readonly HashSet<string>? _ChangedFiles;
+    private readonly StringComparison _FilePathComparer = StringComparison.Ordinal;
+
+    public ChangedFilesPathFilter(IPathFilter inner, string basePath, string[] changedFiles)
+    {
+        if (string.IsNullOrEmpty(basePath)) throw new ArgumentNullException(nameof(basePath));
+        if (changedFiles == null) throw new ArgumentNullException(nameof(changedFiles));
+
+        _Inner = inner ?? throw new ArgumentNullException(nameof(inner));
+        _BasePath = Environment.GetRootedBasePath(basePath, normalize: true);
+        _ChangedFiles = changedFiles.Length == 0 ? null : new HashSet<string>(changedFiles, _FilePathComparer == StringComparison.Ordinal ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase);
+    }
+
+    /// <inheritdoc/>
+    public bool Match(string path)
+    {
+        if (_ChangedFiles == null || string.IsNullOrEmpty(path))
+            return false;
+
+        // Check if the path is rooted and starts with the base path.
+        var rootedFilePath = Environment.GetRootedPath(path, normalize: true, basePath: _BasePath);
+        if (!rootedFilePath.StartsWith(_BasePath, _FilePathComparer))
+            return false;
+
+        var relativePath = rootedFilePath.Substring(_BasePath.Length);
+        return _ChangedFiles.Contains(relativePath) && _Inner.Match(path);
+    }
+}
+
+#nullable restore

src/PSRule/Pipeline/ChangedFilesPathFilter.cs

@@ -43,14 +43,16 @@ public void InputPath(string[]? path)
         if (path == null || path.Length == 0)
             return;
 
-        PathFilter? required = null;
-        if (TryChangedFiles(out var files))
+        var basePath = Environment.GetWorkingPath();
+        var filter = GetInputFilter();
+
+        // Wrap with a filter that only allows files that have changed.
+        if (TryChangedFiles(out var files) && files != null)
         {
-            required = PathFilter.Create(Environment.GetWorkingPath(), path);
-            path = files;
+            filter = new ChangedFilesPathFilter(filter, basePath, files);
         }
 
-        var builder = new InputPathBuilder(GetOutput(), Environment.GetWorkingPath(), "*", GetInputFilter(), required);
+        var builder = new InputPathBuilder(PrepareWriter(), basePath, "*", filter, null);
         builder.Add(path);
         _InputPath = builder;
     }

src/PSRule/Pipeline/GetTargetPipelineBuilder.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace PSRule.Pipeline;
+
+/// <summary>
+/// An interface for implementing a path filter.
+/// </summary>
+internal interface IPathFilter
+{
+    /// <summary>
+    /// Determine if the specified path matches the filter meaning it met the conditions to be included.
+    /// </summary>
+    /// <param name="path">The specified path.</param>
+    /// <returns>rReturns <c>true</c> if the path should be included.</returns>
+    bool Match(string path);
+}

src/PSRule/Pipeline/IPathFilter.cs

@@ -6,7 +6,7 @@ namespace PSRule.Pipeline;
 /// <summary>
 /// A builder for input paths.
 /// </summary>
-internal sealed class InputPathBuilder(IPipelineWriter logger, string basePath, string searchPattern, PathFilter filter, PathFilter required)
+internal sealed class InputPathBuilder(IPipelineWriter logger, string basePath, string searchPattern, IPathFilter filter, IPathFilter required)
     : PathBuilder(logger, basePath, searchPattern, filter, required)
 {
 }

src/PSRule/Pipeline/InputPathBuilder.cs

@@ -31,14 +31,16 @@ public void InputPath(string[]? path)
         if (path == null || path.Length == 0)
             return;
 
-        PathFilter? required = null;
-        if (TryChangedFiles(out var files))
+        var basePath = Environment.GetWorkingPath();
+        var filter = GetInputFilter();
+
+        // Wrap with a filter that only allows files that have changed.
+        if (TryChangedFiles(out var files) && files != null)
         {
-            required = PathFilter.Create(Environment.GetWorkingPath(), path, matchResult: true);
-            path = files;
+            filter = new ChangedFilesPathFilter(filter, basePath, files);
         }
 
-        var builder = new InputPathBuilder(PrepareWriter(), Environment.GetWorkingPath(), "*", GetInputFilter(), required);
+        var builder = new InputPathBuilder(PrepareWriter(), basePath, "*", filter, null);
         builder.Add(path);
         _InputPath = builder;
     }