ruby-pwsh 0.2.0 → 0.5.1

data/lib/puppet/provider/dsc_base_provider/invoke_dsc_resource_functions.ps1

@@ -0,0 +1,120 @@
+function new-pscredential {
+    [CmdletBinding()]
+    param (
+        [parameter(Mandatory = $true,
+            ValueFromPipelineByPropertyName = $true)]
+        [string]
+        $user,
+
+        [parameter(Mandatory = $true,
+            ValueFromPipelineByPropertyName = $true)]
+        [string]
+        $password
+    )
+
+    $secpasswd = ConvertTo-SecureString $password -AsPlainText -Force
+    $credentials = New-Object System.Management.Automation.PSCredential ($user, $secpasswd)
+    return $credentials
+}
+
+Function ConvertTo-CanonicalResult {
+  [CmdletBinding()]
+  param(
+      [Parameter(Mandatory, Position = 1)]
+      [psobject]
+      $Result,
+
+      [Parameter(DontShow)]
+      [string]
+      $PropertyPath,
+
+      [Parameter(DontShow)]
+      [int]
+      $RecursionLevel = 0
+  )
+
+  $MaxDepth = 5
+  $CimInstancePropertyFilter = { $_.Definition -match 'CimInstance' -and $_.Name -ne 'PSDscRunAsCredential' }
+
+  # Get the properties which are/aren't Cim instances
+  $ResultObject = @{ }
+  $ResultPropertyList = $Result | Get-Member -MemberType Property | Where-Object { $_.Name -ne 'PSComputerName' }
+  $CimInstanceProperties = $ResultPropertyList | Where-Object -FilterScript $CimInstancePropertyFilter
+
+  foreach ($Property in $ResultPropertyList) {
+      $PropertyName = $Property.Name
+      if ($Property -notin $CimInstanceProperties) {
+          $Value = $Result.$PropertyName
+          if ($PropertyName -eq 'Ensure' -and [string]::IsNullOrEmpty($Result.$PropertyName)) {
+              # Just set 'Present' since it was found /shrug
+              # If the value IS listed as absent, don't update it unless you want flapping
+              $Value = 'Present'
+          }
+          else {
+              if ($Value -is [string] -or $value -is [string[]]) {
+                  $Value = $Value
+              }
+
+              if ($Value.Count -eq 1 -and $Property.Definition -match '\\[\\]') {
+                  $Value = @($Value)
+              }
+          }
+      }
+      elseif ($null -eq $Result.$PropertyName) {
+          if ($Property -match 'InstanceArray') {
+              $Value = @()
+          }
+          else {
+              $Value = $null
+          }
+      }
+      else {
+          # Looks like a nested CIM instance, recurse if we're not too deep in already.
+          $RecursionLevel++
+
+          if ($PropertyPath -eq [string]::Empty) {
+              $PropertyPath = $PropertyName
+          }
+          else {
+              $PropertyPath = "$PropertyPath.$PropertyName"
+          }
+
+          if ($RecursionLevel -gt $MaxDepth) {
+              # Give up recursing more than this
+              return $Result.ToString()
+          }
+
+          $Value = foreach ($item in $Result.$PropertyName) {
+              ConvertTo-CanonicalResult -Result $item -PropertyPath $PropertyPath -RecursionLevel ($RecursionLevel + 1) -WarningAction Continue
+          }
+
+          # The cim instance type is the last component of the type Name
+          # We need to return this for ruby to compare the result hashes
+          # We do NOT need it for the top-level properties as those are defined in the type
+          If ($RecursionLevel -gt 1 -and ![string]::IsNullOrEmpty($Value) ) {
+              # If there's multiple instances, you need to add the type to each one, but you
+              # need to specify only *one* name, otherwise things end up *very* broken.
+              if ($Value.GetType().Name -match '\[\]') {
+                  $Value | ForEach-Object -Process {
+                      $_.cim_instance_type = $Result.$PropertyName.CimClass.CimClassName[0]
+                  }
+              } else {
+                  $Value.cim_instance_type = $Result.$PropertyName.CimClass.CimClassName
+                  # Ensure that, if it should be an array, it is
+                  if ($Result.$PropertyName.GetType().Name -match '\[\]') {
+                      $Value = @($Value)
+                  }
+              }
+          }
+      }
+
+      if ($Property.Definition -match 'InstanceArray') {
+          if ($Value.Count -lt 2) { $Value = @($Value) }
+      }
+
+      $ResultObject.$PropertyName = $Value
+  }
+
+  # Output the final result
+  $ResultObject
+}

data/lib/puppet/provider/dsc_base_provider/invoke_dsc_resource_postscript.ps1

@@ -0,0 +1,23 @@
+Try {
+  $Result = Invoke-DscResource @InvokeParams
+} catch {
+  $Response.errormessage   = $_.Exception.Message
+  return ($Response | ConvertTo-Json -Compress)
+}
+
+# keep the switch for when Test passes back changed properties
+Switch ($invokeParams.Method) {
+  'Test' {
+    $Response.indesiredstate = $Result.InDesiredState
+    return ($Response | ConvertTo-Json -Compress)
+  }
+  'Set' {
+    $Response.indesiredstate = $true
+    $Response.rebootrequired = $Result.RebootRequired
+    return ($Response | ConvertTo-Json -Compress)
+  }
+  'Get' {
+    $CanonicalizedResult = ConvertTo-CanonicalResult -Result $Result
+    return ($CanonicalizedResult | ConvertTo-Json -Compress -Depth 10)
+  }
+}

data/lib/puppet/provider/dsc_base_provider/invoke_dsc_resource_preamble.ps1

@@ -0,0 +1,8 @@
+$script:ErrorActionPreference = 'Stop'
+$script:WarningPreference = 'SilentlyContinue'
+
+$response = @{
+    indesiredstate = $false
+    rebootrequired = $false
+    errormessage   = ''
+}

data/lib/pwsh.rb

@@ -54,7 +54,7 @@ module Pwsh
       if manager.nil? || !manager.alive?
         # ignore any errors trying to tear down this unusable instance
         begin
-          manager&.exit
+          manager.exit unless manager.nil? # rubocop:disable Style/SafeNavigation
         rescue
           nil
         end
@@ -117,6 +117,7 @@ module Pwsh
         # This named pipe path is Windows specific.
         pipe_path = "\\\\.\\pipe\\#{named_pipe_name}"
       else
+        require 'tmpdir'
         # .Net implements named pipes under Linux etc. as Unix Sockets in the filesystem
         # Paths that are rooted are not munged within C# Core.
         # https://github.com/dotnet/corefx/blob/94e9d02ad70b2224d012ac4a66eaa1f913ae4f29/src/System.IO.Pipes/src/System/IO/Pipes/PipeStream.Unix.cs#L49-L60
@@ -470,7 +471,7 @@ Invoke-PowerShellUserCode @params
     # @return [String] The UTF-8 encoded string containing the payload
     def self.read_length_prefixed_string!(bytes)
       # 32 bit integer in Little Endian format
-      length = bytes.slice!(0, 4).unpack('V').first
+      length = bytes.slice!(0, 4).unpack1('V')
       return nil if length.zero?
 
       bytes.slice!(0, length).force_encoding(Encoding::UTF_8)
@@ -585,7 +586,7 @@ Invoke-PowerShellUserCode @params
 
       pipe_reader = Thread.new(@pipe) do |pipe|
         # Read a Little Endian 32-bit integer for length of response
-        expected_response_length = pipe.sysread(4).unpack('V').first
+        expected_response_length = pipe.sysread(4).unpack1('V')
 
         next nil if expected_response_length.zero?
 

data/lib/pwsh/util.rb

@@ -12,7 +12,7 @@ module Pwsh
     def on_windows?
       # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
       # library uses that to test what platform it's on.
-      !!File::ALT_SEPARATOR # rubocop:disable Style/DoubleNegation
+      !!File::ALT_SEPARATOR
     end
 
     # Verify paths specified are valid directories which exist.
@@ -31,50 +31,51 @@ module Pwsh
       invalid_paths
     end
 
-    # Return a string converted to snake_case
+    # Return a string or symbol converted to snake_case
     #
     # @return [String] snake_cased string
-    def snake_case(string)
+    def snake_case(object)
       # Implementation copied from: https://github.com/rubyworks/facets/blob/master/lib/core/facets/string/snakecase.rb
       # gsub(/::/, '/').
-      string.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-            .tr('-', '_')
-            .gsub(/\s/, '_')
-            .gsub(/__+/, '_')
-            .downcase
+      should_symbolize = object.is_a?(Symbol)
+      raise "snake_case method only handles strings and symbols, passed a #{object.class}: #{object}" unless should_symbolize || object.is_a?(String)
+
+      text = object.to_s
+                   .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                   .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                   .tr('-', '_')
+                   .gsub(/\s/, '_')
+                   .gsub(/__+/, '_')
+                   .downcase
+      should_symbolize ? text.to_sym : text
     end
 
     # Iterate through a hashes keys, snake_casing them
     #
     # @return [Hash] Hash with all keys snake_cased
-    def snake_case_hash_keys(hash)
-      modified_hash = {}
-      hash.each do |key, value|
-        value = snake_case_hash_keys(value) if value.is_a?(Hash)
-        modified_hash[snake_case(key.to_s).to_sym] = value
-      end
-      modified_hash
+    def snake_case_hash_keys(object)
+      snake_case_proc = proc { |key| snake_case(key) }
+      apply_key_mutator(object, snake_case_proc)
     end
 
-    # Return a string converted to PascalCase
+    # Return a string or symbol converted to PascalCase
     #
     # @return [String] PascalCased string
-    def pascal_case(string)
+    def pascal_case(object)
+      should_symbolize = object.is_a?(Symbol)
+      raise "snake_case method only handles strings and symbols, passed a #{object.class}: #{object}" unless should_symbolize || object.is_a?(String)
+
       # Break word boundaries to snake case first
-      snake_case(string).split('_').collect(&:capitalize).join
+      text = snake_case(object.to_s).split('_').collect(&:capitalize).join
+      should_symbolize ? text.to_sym : text
     end
 
     # Iterate through a hashes keys, PascalCasing them
     #
     # @return [Hash] Hash with all keys PascalCased
-    def pascal_case_hash_keys(hash)
-      modified_hash = {}
-      hash.each do |key, value|
-        value = pascal_case_hash_keys(value) if value.is_a?(Hash)
-        modified_hash[pascal_case(key.to_s).to_sym] = value
-      end
-      modified_hash
+    def pascal_case_hash_keys(object)
+      pascal_case_proc = proc { |key| pascal_case(key) }
+      apply_key_mutator(object, pascal_case_proc)
     end
 
     # Ensure that quotes inside a passed string will continue to be passed
@@ -84,6 +85,27 @@ module Pwsh
       text.gsub("'", "''")
     end
 
+    # Ensure that all keys in a hash are symbols, not strings.
+    #
+    # @return [Hash] a hash whose keys have been converted to symbols.
+    def symbolize_hash_keys(object)
+      symbolize_proc = proc(&:to_sym)
+      apply_key_mutator(object, symbolize_proc)
+    end
+
+    def apply_key_mutator(object, proc)
+      return object.map { |item| apply_key_mutator(item, proc) } if object.is_a?(Array)
+      return object unless object.is_a?(Hash)
+
+      modified_hash = {}
+      object.each do |key, value|
+        modified_hash[proc.call(key)] = apply_key_mutator(value, proc)
+      end
+      modified_hash
+    end
+
+    private_class_method :apply_key_mutator
+
     # Convert a ruby value into a string to be passed along to PowerShell for interpolation in a command
     # Handles:
     # - Strings

data/lib/pwsh/version.rb

@@ -2,5 +2,5 @@
 
 module Pwsh
   # The version of the ruby-pwsh gem
-  VERSION = '0.2.0'
+  VERSION = '0.5.1'
 end

data/metadata.json

@@ -1,11 +1,11 @@
 {
   "name": "puppetlabs-pwshlib",
-  "version": "0.2.0",
+  "version": "0.5.1",
   "author": "puppetlabs",
   "summary": "Provide library code for interoperating with PowerShell.",
   "license": "MIT",
   "source": "https://github.com/puppetlabs/ruby-pwsh",
-  "project_page": "https://github.com/puppetlabs/ruby-pwsh/pwshlib.md",
+  "project_page": "https://github.com/puppetlabs/ruby-pwsh/blob/master/pwshlib.md",
   "issues_url": "https://github.com/puppetlabs/ruby-pwsh/issues",
   "dependencies": [
 
@@ -76,7 +76,7 @@
   "requirements": [
     {
       "name": "puppet",
-      "version_requirement": ">= 4.10.0 < 7.0.0"
+      "version_requirement": ">= 5.5.0 < 7.0.0"
     }
   ],
   "pdk-version": "1.13.0",

data/pwshlib.md

@@ -88,3 +88,5 @@ Puppet.debug(posh.execute('[String]$PSVersionTable.PSVersion'))
 ps_version = posh.execute('[String]$PSVersionTable.PSVersion')[:stdout].strip
 Puppet.debug("The PowerShell version of the currently running Manager is #{ps_version}")
 ```
+
+For more information, please review the [online reference documentation for the gem](https://rubydoc.info/gems/ruby-pwsh).

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-pwsh
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Puppet, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-26 00:00:00.000000000 Z
+date: 2020-09-25 00:00:00.000000000 Z
 dependencies: []
 description: PowerShell code manager for ruby.
 email:
@@ -31,7 +31,13 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- appveyor.yml
 - design-comms.png
+- lib/puppet/feature/pwshlib.rb
+- lib/puppet/provider/dsc_base_provider/dsc_base_provider.rb
+- lib/puppet/provider/dsc_base_provider/invoke_dsc_resource_functions.ps1
+- lib/puppet/provider/dsc_base_provider/invoke_dsc_resource_postscript.ps1
+- lib/puppet/provider/dsc_base_provider/invoke_dsc_resource_preamble.ps1
 - lib/pwsh.rb
 - lib/pwsh/util.rb
 - lib/pwsh/version.rb