Merge pull request #43 from santisq/42-add-a-more-verbose-module-description

updates manifest description. bit of code refactoring

Author: santisq

module/PSParallelPipeline.psd1

@@ -11,7 +11,7 @@
     RootModule        = 'bin/netstandard2.0/PSParallelPipeline.dll'
 
     # Version number of this module.
-    ModuleVersion     = '1.2.0'
+    ModuleVersion     = '1.2.1'
 
     # Supported PSEditions
     # CompatiblePSEditions = @()
@@ -29,7 +29,7 @@
     Copyright         = '(c) Santiago Squarzon. All rights reserved.'
 
     # Description of the functionality provided by this module
-    Description       = 'Enables parallel processing of pipeline input objects.'
+    Description       = 'Includes Invoke-Parallel cmdlet, allowing for parallel processing of input objects, sharing similar capabilities as ForEach-Object -Parallel.'
 
     # Minimum version of the PowerShell engine required by this module
     PowerShellVersion = '5.1'
@@ -94,11 +94,13 @@
             # Tags applied to this module. These help with module discovery in online galleries.
             Tags       = @(
                 'parallel'
-                'concurrency'
                 'runspace'
                 'parallel-processing'
-                'powershell'
                 'multithreading'
+                'foreach'
+                'pipeline'
+                'threads'
+                'ForEach-Object'
             )
 
             # A URL to the license for this module.

src/PSParallelPipeline/CommandCompleter.cs

@@ -22,7 +22,7 @@ public IEnumerable<CompletionResult> CompleteArgument(
     {
         try
         {
-            _builtinFuncs ??= new HashSet<string>(GetBuiltinFunctions());
+            _builtinFuncs ??= [.. GetBuiltinFunctions()];
 
             return CompletionCompleters
                 .CompleteCommand(

src/PSParallelPipeline/Commands/InvokeParallelCommand.cs

@@ -2,14 +2,17 @@
 using System.Collections;
 using System.Management.Automation;
 using System.Management.Automation.Runspaces;
+using PSParallelPipeline.Poly;
 
-namespace PSParallelPipeline;
+namespace PSParallelPipeline.Commands;
 
 [Cmdlet(VerbsLifecycle.Invoke, "Parallel")]
 [Alias("parallel")]
 [OutputType(typeof(object))]
 public sealed class InvokeParallelCommand : PSCmdlet, IDisposable
 {
+    private Worker? _worker;
+
     [Parameter(Position = 0, Mandatory = true)]
     public ScriptBlock ScriptBlock { get; set; } = null!;
 
@@ -41,21 +44,12 @@ public sealed class InvokeParallelCommand : PSCmdlet, IDisposable
     [Alias("unr")]
     public SwitchParameter UseNewRunspace { get; set; }
 
-    private Worker? _worker;
-
     protected override void BeginProcessing()
     {
-        InitialSessionState iss = InitialSessionState.CreateDefault2();
-
-        if (Functions is not null)
-        {
-            iss.AddFunctions(Functions, this);
-        }
-
-        if (Variables is not null)
-        {
-            iss.AddVariables(Variables, this);
-        }
+        InitialSessionState iss = InitialSessionState
+            .CreateDefault2()
+            .AddFunctions(Functions, this)
+            .AddVariables(Variables, this);
 
         PoolSettings poolSettings = new()
         {

src/PSParallelPipeline/Extensions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using System.Management.Automation;
 using System.Management.Automation.Language;
 using System.Management.Automation.Runspaces;
@@ -10,52 +11,67 @@ namespace PSParallelPipeline;
 
 internal static class Extensions
 {
-    internal static void AddFunctions(
+    internal static InitialSessionState AddFunctions(
         this InitialSessionState initialSessionState,
-        string[] functionsToAdd,
+        string[]? functionsToAdd,
         PSCmdlet cmdlet)
     {
-        foreach (string function in functionsToAdd)
+        if (functionsToAdd is not null)
         {
-            CommandInfo? commandInfo = cmdlet
-                .InvokeCommand
-                .GetCommand(function, CommandTypes.Function);
-
-            if (commandInfo is null)
+            foreach (string function in functionsToAdd)
             {
-                continue;
+                CommandInfo? commandInfo = cmdlet
+                    .InvokeCommand
+                    .GetCommand(function, CommandTypes.Function);
+
+                if (commandInfo is null)
+                {
+                    continue;
+                }
+
+                initialSessionState.Commands.Add(new SessionStateFunctionEntry(
+                    name: function,
+                    definition: commandInfo.Definition));
             }
-
-            initialSessionState.Commands.Add(new SessionStateFunctionEntry(
-                name: function,
-                definition: commandInfo.Definition));
         }
+
+        return initialSessionState;
     }
 
-    internal static void AddVariables(
+    internal static InitialSessionState AddVariables(
         this InitialSessionState initialSessionState,
-        Hashtable variables,
+        Hashtable? variables,
         PSCmdlet cmdlet)
     {
-        foreach (DictionaryEntry pair in variables)
+        if (variables is not null)
         {
-            cmdlet.ThrowIfVariableIsScriptBlock(pair.Value);
-            initialSessionState.Variables.Add(new SessionStateVariableEntry(
-                name: LanguagePrimitives.ConvertTo<string>(pair.Key),
-                value: pair.Value,
-                description: null));
+            foreach (DictionaryEntry pair in variables)
+            {
+                cmdlet.ThrowIfVariableIsScriptBlock(pair.Value);
+                initialSessionState.Variables.Add(new SessionStateVariableEntry(
+                    name: LanguagePrimitives.ConvertTo<string>(pair.Key),
+                    value: pair.Value,
+                    description: null));
+            }
         }
+
+        return initialSessionState;
     }
 
     internal static Dictionary<string, object?> GetUsingParameters(
         this ScriptBlock script,
         PSCmdlet cmdlet)
     {
         Dictionary<string, object?> usingParams = [];
+        IEnumerable<UsingExpressionAst> usingExpressionAsts = script.Ast
+            .FindAll((a) => a is UsingExpressionAst, true)
+            .Cast<UsingExpressionAst>();
 
-        foreach (UsingExpressionAst usingStatement in script.Ast.FindAll((a) => a is UsingExpressionAst, true))
+        foreach (UsingExpressionAst usingStatement in usingExpressionAsts)
         {
-            VariableExpressionAst backingVariableAst = UsingExpressionAst.ExtractUsingVariable(usingStatement);
+            VariableExpressionAst backingVariableAst = UsingExpressionAst
+                .ExtractUsingVariable(usingStatement);
+
             string varPath = backingVariableAst.VariablePath.UserPath;
 
             string varText = usingStatement.ToString();
@@ -89,7 +105,9 @@ internal static void AddVariables(
         object? value,
         ExpressionAst ast)
     {
-        VariableExpressionAst usingVariable = (VariableExpressionAst)ast.Find(a => a is VariableExpressionAst, false);
+        VariableExpressionAst usingVariable = (VariableExpressionAst)ast
+            .Find(a => a is VariableExpressionAst, false);
+
         ExpressionAst lookupAst = new ConstantExpressionAst(ast.Extent, value);
         Ast? currentAst = usingVariable;
 

src/PSParallelPipeline/PSOutputData.cs

@@ -1,5 +1,3 @@
-using System.Management.Automation;
-
 namespace PSParallelPipeline;
 
 internal enum Type

src/PSParallelPipeline/PSOutputStreams.cs

@@ -9,8 +9,6 @@ internal sealed class PSOutputStreams : IDisposable
 {
     private BlockingCollection<PSOutputData> OutputPipe { get => _worker.OutputPipe; }
 
-    private CancellationToken Token { get => _worker.Token; }
-
     internal PSDataCollection<PSObject> Success { get; } = [];
 
     internal PSDataCollection<ErrorRecord> Error { get; } = [];

src/PSParallelPipeline/Dbg/Dbg.cs renamed to src/PSParallelPipeline/Poly/Dbg.cs

@@ -1,7 +1,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 
-namespace PSParallelPipeline;
+namespace PSParallelPipeline.Poly;
 
 internal static class Dbg
 {

src/PSParallelPipeline/Dbg/Nullable.cs renamed to src/PSParallelPipeline/Poly/Nullable.cs

@@ -42,13 +42,6 @@ internal RunspacePool(PoolSettings settings, Worker worker)
 
     internal void Release() => _semaphore.Release();
 
-    private Runspace CreateRunspace()
-    {
-        Runspace rs = RunspaceFactory.CreateRunspace(InitialSessionState);
-        rs.Open();
-        return rs;
-    }
-
     internal void CompleteTask(PSTask psTask)
     {
         psTask.Dispose();
@@ -62,17 +55,6 @@ internal void CompleteTask(PSTask psTask)
         _pool.Enqueue(psTask.Runspace);
     }
 
-    private async Task<Runspace> GetRunspaceAsync()
-    {
-        await _semaphore.WaitAsync(Token);
-        if (_pool.TryDequeue(out Runspace runspace))
-        {
-            return runspace;
-        }
-
-        return CreateRunspace();
-    }
-
     internal async Task EnqueueAsync(PSTask psTask)
     {
         psTask.AddUsingStatements(UsingStatements);
@@ -88,17 +70,35 @@ internal async Task ProcessAllAsync()
         }
     }
 
+    internal CancellationTokenRegistration RegisterCancellation(Action callback) =>
+        Token.Register(callback);
+
+    internal async Task WaitOnCancelAsync() => await Task.WhenAll(_tasks);
+
     private async Task ProcessAnyAsync()
     {
         Task task = await Task.WhenAny(_tasks);
         _tasks.Remove(task);
         await task;
     }
 
-    internal CancellationTokenRegistration RegisterCancellation(Action callback) =>
-        Token.Register(callback);
+    private Runspace CreateRunspace()
+    {
+        Runspace rs = RunspaceFactory.CreateRunspace(InitialSessionState);
+        rs.Open();
+        return rs;
+    }
 
-    internal async Task WaitOnCancelAsync() => await Task.WhenAll(_tasks);
+    private async Task<Runspace> GetRunspaceAsync()
+    {
+        await _semaphore.WaitAsync(Token);
+        if (_pool.TryDequeue(out Runspace runspace))
+        {
+            return runspace;
+        }
+
+        return CreateRunspace();
+    }
 
     public void Dispose()
     {