rwidmark
diff --git a/‎.src/MaintainModule.psd1.source‎
Lines changed: 0 additions & 154 deletions b/‎.src/MaintainModule.psd1.source‎
Lines changed: 0 additions & 154 deletions
diff --git a/‎.src/Public/Function/Uninstall-RSModule.ps1‎
Lines changed: 7 additions & 7 deletions b/‎.src/Public/Function/Uninstall-RSModule.ps1‎
Lines changed: 7 additions & 7 deletions
diff --git a/‎.src/Public/Function/Update-RSModule.ps1‎
Lines changed: 17 additions & 17 deletions b/‎.src/Public/Function/Update-RSModule.ps1‎
Lines changed: 17 additions & 17 deletions
@@ -55,17 +55,17 @@
         Write-Verbose "Looking so the modules exists in the system..."
         foreach ($m in $OldModule) {
             if ($m -in $InstalledModules.name) {
-                Write-Verbose "$($m) did exists in the system..."
+                Write-Verbose "$m did exists in the system..."
                 [void]($Module.Add($m))
             }
             else {
-                Write-Warning "$($m) did not exists in the system, skipping this module..."
+                Write-Warning "$m did not exists in the system, skipping this module..."
             }
         }
     }
 
     foreach ($m in $Module) {
-        Write-Verbose "Collecting all installed version of the module $($m)"
+        Write-Verbose "Collecting all installed version of the module $m"
         $GetAllInstalledVersions = Get-InstalledModule -Name $m -AllVersions | Sort-Object { $_.Version -as [version] } -Descending | Select-Object -ExpandProperty Version
 
         # If the module has more then one version loop trough the versions and only keep the most current one
@@ -74,20 +74,20 @@
             [version]$MostRecentVersion = $GetAllInstalledVersions[0]
             Foreach ($Version in $GetAllInstalledVersions | Where-Object { [version]$_ -lt [version]$MostRecentVersion }) {
                 try {
-                    Write-Output "Uninstalling previous version $($Version) of module $($m)..."
+                    Write-Output "Uninstalling previous version $Version of module $m..."
                     Uninstall-Module -Name $m -RequiredVersion $Version -Force -ErrorAction SilentlyContinue
-                    Write-Output "Version $($Version) of $($m) are now uninstalled!"
+                    Write-Output "Version $Version of $m are now uninstalled!"
                 }
                 catch {
                     Write-Error "$($PSItem.Exception)"
                     continue
                 }
             }
             # bygga in en check så att den verkligen kan verifiera detta
-            Write-Output "All older versions of $($m) are now uninstalled, the only installed version of $($m) is $($MostRecentVersion)"
+            Write-Output "All older versions of $m are now uninstalled, the only installed version of $m is $MostRecentVersion"
         }
         else {
-            Write-Verbose "$($m) don't have any older versions installed then $($GetAllInstalledVersions), no need to uninstall anything."
+            Write-Verbose "$m don't have any older versions installed then $GetAllInstalledVersions, no need to uninstall anything."
         }
     }
     Write-Output "`n=== \\\ Script Finished! /// ===`n"
 
@@ -97,7 +97,7 @@
                     [void]($Module.Add($m))
                 }
                 else {
-                    Write-Warning "$($m) did not exists in the system, skipping this module..."
+                    Write-Warning "$m did not exists in the system, skipping this module..."
                 }
             }
         }
@@ -126,25 +126,25 @@
 
     # Start looping trough every module that are stored in the string Module
     foreach ($m in $Module) {
-        Write-Verbose "Checks if $($m) are installed"
+        Write-Verbose "Checks if $m are installed"
         if ($m -in $InstalledModules.Name) {
 
             # Getting the latest installed version of the module
-            Write-Verbose "Collecting all installed version of $($m)..."
+            Write-Verbose "Collecting all installed version of $m..."
             $GetAllInstalledVersions = Get-InstalledModule -Name $m -AllVersions | Sort-Object { $_.Version -as [version] } -Descending | Select-Object Version
             [version]$LatestInstalledVersion = $($GetAllInstalledVersions | Select-Object Version -First 1).version
 
             # Collects the latest version of module from the source where the module was installed from
-            Write-Verbose "Looking up the latest version of $($m)..."
+            Write-Verbose "Looking up the latest version of $m..."
             [version]$CollectLatestVersion = $(Find-Module -Name $m -AllVersions | Sort-Object { $_.Version -as [version] } -Descending | Select-Object Version -First 1).version
 
             # Looking if the version of the module are the latest version, it it's not the latest it will install the latest version.
             if ($LatestInstalledVersion -lt $CollectLatestVersion) {
                 try {
-                    Write-Output "Found a newer version of $($m), version $($CollectLatestVersion)"
-                    Write-Output "Updating $($m) from $($LatestInstalledVersion) to version $($CollectLatestVersion)..."
-                    Update-Module -Name $($m) -Scope $Scope -Force
-                    Write-Output "$($m) has now been updated to version $($CollectLatestVersion)!`n"
+                    Write-Output "Found a newer version of $m, version $CollectLatestVersion"
+                    Write-Output "Updating $m from $($LatestInstalledVersion) to version $CollectLatestVersion..."
+                    Update-Module -Name $m -Scope $Scope -Force
+                    Write-Output "$m has now been updated to version $CollectLatestVersion!`n"
                 }
                 catch {
                     Write-Error "$($PSItem.Exception)"
@@ -155,29 +155,29 @@
             # If switch -UninstallOldVersion has been used then the old versions will be uninstalled from the module
             if ($UninstallOldVersion -eq $true) {
                 if ($GetAllInstalledVersions.Count -gt 1) {
-                    Write-Output "Uninstalling old versions $($LatestInstalledVersion) of $($m)..."
+                    Write-Output "Uninstalling old versions $LatestInstalledVersion of $m..."
                     Uninstall-RSModule -Module $m
                 }
             }
             else {
-                Write-Verbose "$($m) already has the newest version installed, no need to install anything!"
+                Write-Verbose "$m already has the newest version installed, no need to install anything!"
             }
         }
         else {
             # If the switch InstallMissing are set to true the modules will get installed if they are missing
             if ($InstallMissing -eq $true) {
                 try {
-                    Write-Output "$($m) are not installed, installing $($m)..."
-                    Install-Module -Name $($m) -Scope $Scope -Force
-                    Write-Output "$($m) has now been installed!"
+                    Write-Output "$m are not installed, installing $m..."
+                    Install-Module -Name $m -Scope $Scope -Force
+                    Write-Output "$m has now been installed!"
                 }
                 catch {
                     Write-Error "$($PSItem.Exception)"
                     continue
                 }
             }
             else {
-                Write-Warning "$($m) module are not installed, and you have not chosen to install missing modules. Continuing without any actions!"
+                Write-Warning "$m module are not installed, and you have not chosen to install missing modules. Continuing without any actions!"
             }
         }
     }
@@ -191,13 +191,13 @@
             Write-Verbose "Starting to import the modules..."
             foreach ($m in $Module) {
                 if ($m -in $ImportedModules.Name) {
-                    Write-Verbose "$($m) are already imported!"
+                    Write-Verbose "$m are already imported!"
                 }
                 else {
                     try {
-                        Write-Output "Importing $($m)..."
+                        Write-Output "Importing $m..."
                         Import-Module -Name $m -Force
-                        Write-Output "$($m) has been imported!"
+                        Write-Output "$m has been imported!"
                     }
                     catch {
                         Write-Error "$($PSItem.Exception)"
Original file line number	Diff line number	Diff line change
`@@ -55,17 +55,17 @@`
`55`	`55`	`Write-Verbose "Looking so the modules exists in the system..."`
`56`	`56`	`foreach ($m in $OldModule) {`
`57`	`57`	`if ($m -in $InstalledModules.name) {`
`58`		`- Write-Verbose "$($m) did exists in the system..."`
	`58`	`+ Write-Verbose "$m did exists in the system..."`
`59`	`59`	`[void]($Module.Add($m))`
`60`	`60`	`}`
`61`	`61`	`else {`
`62`		`- Write-Warning "$($m) did not exists in the system, skipping this module..."`
	`62`	`+ Write-Warning "$m did not exists in the system, skipping this module..."`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`foreach ($m in $Module) {`
`68`		`- Write-Verbose "Collecting all installed version of the module $($m)"`
	`68`	`+ Write-Verbose "Collecting all installed version of the module $m"`
`69`	`69`	`$GetAllInstalledVersions = Get-InstalledModule -Name $m -AllVersions \| Sort-Object { $_.Version -as [version] } -Descending \| Select-Object -ExpandProperty Version`
`70`	`70`
`71`	`71`	`# If the module has more then one version loop trough the versions and only keep the most current one`
`@@ -74,20 +74,20 @@`
`74`	`74`	`[version]$MostRecentVersion = $GetAllInstalledVersions[0]`
`75`	`75`	`Foreach ($Version in $GetAllInstalledVersions \| Where-Object { [version]$_ -lt [version]$MostRecentVersion }) {`
`76`	`76`	`try {`
`77`		`- Write-Output "Uninstalling previous version $($Version) of module $($m)..."`
	`77`	`+ Write-Output "Uninstalling previous version $Version of module $m..."`
`78`	`78`	`Uninstall-Module -Name $m -RequiredVersion $Version -Force -ErrorAction SilentlyContinue`
`79`		`- Write-Output "Version $($Version) of $($m) are now uninstalled!"`
	`79`	`+ Write-Output "Version $Version of $m are now uninstalled!"`
`80`	`80`	`}`
`81`	`81`	`catch {`
`82`	`82`	`Write-Error "$($PSItem.Exception)"`
`83`	`83`	`continue`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`	`# bygga in en check så att den verkligen kan verifiera detta`
`87`		`- Write-Output "All older versions of $($m) are now uninstalled, the only installed version of $($m) is $($MostRecentVersion)"`
	`87`	`+ Write-Output "All older versions of $m are now uninstalled, the only installed version of $m is $MostRecentVersion"`
`88`	`88`	`}`
`89`	`89`	`else {`
`90`		`- Write-Verbose "$($m) don't have any older versions installed then $($GetAllInstalledVersions), no need to uninstall anything."`
	`90`	`+ Write-Verbose "$m don't have any older versions installed then $GetAllInstalledVersions, no need to uninstall anything."`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`	Write-Output "`n=== \\\ Script Finished! /// ===`n"
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@`
`97`	`97`	`[void]($Module.Add($m))`
`98`	`98`	`}`
`99`	`99`	`else {`
`100`		`- Write-Warning "$($m) did not exists in the system, skipping this module..."`
	`100`	`+ Write-Warning "$m did not exists in the system, skipping this module..."`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`	`}`
`@@ -126,25 +126,25 @@`
`126`	`126`
`127`	`127`	`# Start looping trough every module that are stored in the string Module`
`128`	`128`	`foreach ($m in $Module) {`
`129`		`- Write-Verbose "Checks if $($m) are installed"`
	`129`	`+ Write-Verbose "Checks if $m are installed"`
`130`	`130`	`if ($m -in $InstalledModules.Name) {`
`131`	`131`
`132`	`132`	`# Getting the latest installed version of the module`
`133`		`- Write-Verbose "Collecting all installed version of $($m)..."`
	`133`	`+ Write-Verbose "Collecting all installed version of $m..."`
`134`	`134`	`$GetAllInstalledVersions = Get-InstalledModule -Name $m -AllVersions \| Sort-Object { $_.Version -as [version] } -Descending \| Select-Object Version`
`135`	`135`	`[version]$LatestInstalledVersion = $($GetAllInstalledVersions \| Select-Object Version -First 1).version`
`136`	`136`
`137`	`137`	`# Collects the latest version of module from the source where the module was installed from`
`138`		`- Write-Verbose "Looking up the latest version of $($m)..."`
	`138`	`+ Write-Verbose "Looking up the latest version of $m..."`
`139`	`139`	`[version]$CollectLatestVersion = $(Find-Module -Name $m -AllVersions \| Sort-Object { $_.Version -as [version] } -Descending \| Select-Object Version -First 1).version`
`140`	`140`
`141`	`141`	`# Looking if the version of the module are the latest version, it it's not the latest it will install the latest version.`
`142`	`142`	`if ($LatestInstalledVersion -lt $CollectLatestVersion) {`
`143`	`143`	`try {`
`144`		`- Write-Output "Found a newer version of $($m), version $($CollectLatestVersion)"`
`145`		`- Write-Output "Updating $($m) from $($LatestInstalledVersion) to version $($CollectLatestVersion)..."`
`146`		`- Update-Module -Name $($m) -Scope $Scope -Force`
`147`		- Write-Output "$($m) has now been updated to version $($CollectLatestVersion)!`n"
	`144`	`+ Write-Output "Found a newer version of $m, version $CollectLatestVersion"`
	`145`	`+ Write-Output "Updating $m from $($LatestInstalledVersion) to version $CollectLatestVersion..."`
	`146`	`+ Update-Module -Name $m -Scope $Scope -Force`
	`147`	+ Write-Output "$m has now been updated to version $CollectLatestVersion!`n"
`148`	`148`	`}`
`149`	`149`	`catch {`
`150`	`150`	`Write-Error "$($PSItem.Exception)"`
`@@ -155,29 +155,29 @@`
`155`	`155`	`# If switch -UninstallOldVersion has been used then the old versions will be uninstalled from the module`
`156`	`156`	`if ($UninstallOldVersion -eq $true) {`
`157`	`157`	`if ($GetAllInstalledVersions.Count -gt 1) {`
`158`		`- Write-Output "Uninstalling old versions $($LatestInstalledVersion) of $($m)..."`
	`158`	`+ Write-Output "Uninstalling old versions $LatestInstalledVersion of $m..."`
`159`	`159`	`Uninstall-RSModule -Module $m`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`	`else {`
`163`		`- Write-Verbose "$($m) already has the newest version installed, no need to install anything!"`
	`163`	`+ Write-Verbose "$m already has the newest version installed, no need to install anything!"`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`	`else {`
`167`	`167`	`# If the switch InstallMissing are set to true the modules will get installed if they are missing`
`168`	`168`	`if ($InstallMissing -eq $true) {`
`169`	`169`	`try {`
`170`		`- Write-Output "$($m) are not installed, installing $($m)..."`
`171`		`- Install-Module -Name $($m) -Scope $Scope -Force`
`172`		`- Write-Output "$($m) has now been installed!"`
	`170`	`+ Write-Output "$m are not installed, installing $m..."`
	`171`	`+ Install-Module -Name $m -Scope $Scope -Force`
	`172`	`+ Write-Output "$m has now been installed!"`
`173`	`173`	`}`
`174`	`174`	`catch {`
`175`	`175`	`Write-Error "$($PSItem.Exception)"`
`176`	`176`	`continue`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`	`else {`
`180`		`- Write-Warning "$($m) module are not installed, and you have not chosen to install missing modules. Continuing without any actions!"`
	`180`	`+ Write-Warning "$m module are not installed, and you have not chosen to install missing modules. Continuing without any actions!"`
`181`	`181`	`}`
`182`	`182`	`}`
`183`	`183`	`}`
`@@ -191,13 +191,13 @@`
`191`	`191`	`Write-Verbose "Starting to import the modules..."`
`192`	`192`	`foreach ($m in $Module) {`
`193`	`193`	`if ($m -in $ImportedModules.Name) {`
`194`		`- Write-Verbose "$($m) are already imported!"`
	`194`	`+ Write-Verbose "$m are already imported!"`
`195`	`195`	`}`
`196`	`196`	`else {`
`197`	`197`	`try {`
`198`		`- Write-Output "Importing $($m)..."`
	`198`	`+ Write-Output "Importing $m..."`
`199`	`199`	`Import-Module -Name $m -Force`
`200`		`- Write-Output "$($m) has been imported!"`
	`200`	`+ Write-Output "$m has been imported!"`
`201`	`201`	`}`
`202`	`202`	`catch {`
`203`	`203`	`Write-Error "$($PSItem.Exception)"`