puppet-resource_api 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c0802c277632a57802c1b44466a56470474357dea596c39472c7e23a592aab9
-  data.tar.gz: 66b3de030a9a2b91a2abac411d46e803152e973a10235eaf09c1b3381b41a184
+  metadata.gz: 1470bc0d22d986fc0eccd0580a072ea54f6482b3c830f994b2d83f230ba95b22
+  data.tar.gz: 1346ed773c82d9478dbbcd243f5fe4b1260c487b7b17f971268801bd772c7f83
 SHA512:
-  metadata.gz: c16aea1e79a69f0c6112812c1f5e89884899064ffdcf31c7c2a9567e776435244646a3d0111c3c29acf64cfee8ce061f3684ef012edb7af574615aef910b2cb2
-  data.tar.gz: 7e719c49452ddea14cabddaf3702eac1e15da5717138ce732be25c0f57b6c649df1f2702869adf3265b002fb83ca78f6df7b5671350119ea8b6fdc62f9eb2415
+  metadata.gz: 1f521be6aa211b933e12f712be3af9226af5d5d9df4a8bec2ca075e0faedd5898c7a9d1150024784c8e71c27bcbd996c34b010ecd656e15cf314e40014bb86ed
+  data.tar.gz: 6a473b6d9eb96158008dfc4622da547026f01c3fbe492689fb9478179f645338b8b264b693fdfd6451491fd432d025b05026a5c245db374078222e668241f0cc

data/CHANGELOG.md

@@ -3,6 +3,24 @@
 All significant changes to this repo will be summarized in this file.
 
 
+## [v1.1.0](https://github.com/puppetlabs/puppet-resource_api/tree/v1.1.0) (2018-04-12)
+[Full Changelog](https://github.com/puppetlabs/puppet-resource_api/compare/v1.0.3...v1.1.0)
+
+**Implemented enhancements:**
+
+- \(PDK-895\) basic array support [\#59](https://github.com/puppetlabs/puppet-resource_api/pull/59) ([DavidS](https://github.com/DavidS))
+
+**Fixed bugs:**
+
+- \(PDK-919\) Workaround PUP-2368 "using booleans result in unmanaged pro… [\#62](https://github.com/puppetlabs/puppet-resource_api/pull/62) ([DavidS](https://github.com/DavidS))
+
+**Merged pull requests:**
+
+- \(PDK-526\) do not rely on git when building the gem on jenkins [\#61](https://github.com/puppetlabs/puppet-resource_api/pull/61) ([DavidS](https://github.com/DavidS))
+- \(PDK-896\) Advanced Array tests [\#60](https://github.com/puppetlabs/puppet-resource_api/pull/60) ([DavidS](https://github.com/DavidS))
+- Update puppetlabs\_spec\_helper to fixed master version [\#58](https://github.com/puppetlabs/puppet-resource_api/pull/58) ([DavidS](https://github.com/DavidS))
+- Release prep for v1.0.3 [\#57](https://github.com/puppetlabs/puppet-resource_api/pull/57) ([DavidS](https://github.com/DavidS))
+
 ## [v1.0.3](https://github.com/puppetlabs/puppet-resource_api/tree/v1.0.3) (2018-04-06)
 [Full Changelog](https://github.com/puppetlabs/puppet-resource_api/compare/v1.0.2...v1.0.3)
 

data/Gemfile

@@ -16,7 +16,7 @@ group :tests do
   gem 'rubocop'
   gem 'simplecov-console'
   # the test gems required for module testing
-  gem 'puppetlabs_spec_helper', github: 'DavidS/puppetlabs_spec_helper', ref: 'refactor'
+  gem 'puppetlabs_spec_helper', '~> 2.7'
   gem 'rspec-puppet'
 end
 

data/README.md

@@ -191,11 +191,12 @@ This gem is still under heavy development. This section is a living document of
 Currently working:
 * Basic type and provider definition, using `name`, `desc`, and `attributes`.
 * Scalar puppet 4 [data types](https://puppet.com/docs/puppet/5.3/lang_data_type.html#core-data-types):
-  * String
+  * String, Enum, Pattern
   * Integer, Float, Numeric
   * Boolean
-  * Enum[absent, present]
-  * simple Optionals
+  * Array
+  * Optional
+  * Variant
 * The `canonicalize`, `simple_get_filter`, and `remote_resource` features.
 * All the logging facilities.
 * Executing the new provider under the following commands:
@@ -205,7 +206,7 @@ Currently working:
   * `puppet device` (if applicable)
 
 There are still a few notable gaps between the implementation and the specification:
-* Complex data types, like Array, Hash, Tuple or Struct are not yet implemented.
+* Complex data types, like Hash, Tuple or Struct are not yet implemented.
 * Only a single runtime environment (the Puppet commands) is currently implemented.
 
 Restrictions of running under puppet:

data/appveyor.yml

@@ -9,17 +9,6 @@ install:
   - set PATH=C:\Ruby%RUBY_VERSION%\bin;C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
   - SET LOG_SPEC_ORDER=true
   - SET COVERAGE=yes
-  # Due to a bug in the version of OpenSSL shipped with Ruby 2.4.1 on Windows
-  # (https://bugs.ruby-lang.org/issues/11033). Errors are ignored because the
-  # mingw gem calls out to pacman to install OpenSSL which is already
-  # installed, causing gem to raise a warning that powershell determines to be
-  # a fatal error.
-  - ps: |
-      $ErrorActionPreference = "SilentlyContinue"
-      if($env:RUBY_VERSION -eq "24-x64") {
-        gem install openssl "~> 2.0.4" --no-rdoc --no-ri -- --with-openssl-dir=C:\msys64\mingw64
-      }
-      $host.SetShouldExit(0)
   - bundle install --jobs 4 --retry 2 --without development
 
 build: off

data/lib/puppet/resource_api.rb

@@ -145,26 +145,46 @@ module Puppet::ResourceApi
           end
 
           type = Puppet::Pops::Types::TypeParser.singleton.parse(options[:type])
-          validate do |value|
-            if options[:behaviour] == :read_only
-              raise Puppet::ResourceError, "Attempting to set `#{name}` read_only attribute value to `#{value}`"
+          if param_or_property == :newproperty
+            define_method(:should) do
+              if type.is_a? Puppet::Pops::Types::PBooleanType
+                # work around https://tickets.puppetlabs.com/browse/PUP-2368
+                rs_value ? :true : :false # rubocop:disable Lint/BooleanSymbol
+              else
+                rs_value
+              end
+            end
+
+            define_method(:should=) do |value|
+              @shouldorig = value
+              # Puppet requires the @should value to always be stored as an array. We do not use this
+              # for anything else
+              # @see Puppet::Property.should=(value)
+              @should = [Puppet::ResourceApi.mungify(type, value, "#{definition[:name]}.#{name}")]
             end
 
-            return true if type.instance?(value)
+            # used internally
+            # @returns the final mungified value of this property
+            define_method(:rs_value) do
+              @should ? @should.first : @should
+            end
+          else
+            define_method(:value) do
+              @value
+            end
 
-            if value.is_a? String
-              # when running under `puppet resource`, we need to try to coerce from strings to the real type
-              case value
-              when %r{^-?\d+$}, Puppet::Pops::Patterns::NUMERIC
-                value = Puppet::Pops::Utils.to_n(value)
-              when %r{\Atrue|false\Z}
-                value = value == 'true'
+            define_method(:value=) do |value|
+              if options[:behaviour] == :read_only
+                raise Puppet::ResourceError, "Attempting to set `#{name}` read_only attribute value to `#{value}`"
               end
-              return true if type.instance?(value)
 
-              inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value)
-              error_msg = Puppet::Pops::Types::TypeMismatchDescriber.new.describe_mismatch("#{definition[:name]}.#{name}", type, inferred_type)
-              raise Puppet::ResourceError, error_msg
+              @value = Puppet::ResourceApi.mungify(type, value, "#{definition[:name]}.#{name}")
+            end
+
+            # used internally
+            # @returns the final mungified value of this parameter
+            define_method(:rs_value) do
+              @value
             end
           end
 
@@ -172,49 +192,40 @@ module Puppet::ResourceApi
             type = type.type
           end
 
-          # provide better handling of the standard types
+          # puppet symbolizes some values through puppet/parameter/value.rb (see .convert()), but (especially) Enums
+          # are strings. specifying a munge block here skips the value_collection fallback in puppet/parameter.rb's
+          # default .unsafe_munge() implementation.
+          munge { |v| v }
+
+          # provide hints to `puppet type generate` for better parsing
           case type
           when Puppet::Pops::Types::PStringType
             # require any string value
             Puppet::ResourceApi.def_newvalues(self, param_or_property, %r{})
-          # rubocop:disable Lint/BooleanSymbol
           when Puppet::Pops::Types::PBooleanType
             Puppet::ResourceApi.def_newvalues(self, param_or_property, 'true', 'false')
+            # rubocop:disable Lint/BooleanSymbol
             aliasvalue true, 'true'
             aliasvalue false, 'false'
             aliasvalue :true, 'true'
             aliasvalue :false, 'false'
-
-            munge do |v|
-              case v
-              when 'true', :true
-                true
-              when 'false', :false
-                false
-              else
-                v
-              end
-            end
-          # rubocop:enable Lint/BooleanSymbol
+            # rubocop:enable Lint/BooleanSymbol
           when Puppet::Pops::Types::PIntegerType
             Puppet::ResourceApi.def_newvalues(self, param_or_property, %r{^-?\d+$})
-            munge do |v|
-              Puppet::Pops::Utils.to_n(v)
-            end
           when Puppet::Pops::Types::PFloatType, Puppet::Pops::Types::PNumericType
             Puppet::ResourceApi.def_newvalues(self, param_or_property, Puppet::Pops::Patterns::NUMERIC)
-            munge do |v|
-              Puppet::Pops::Utils.to_n(v)
-            end
+          end
+
+          if param_or_property == :newproperty
+            # stop puppet from trying to call into the provider when
+            # no pre-defined values have been specified
+            # "This is not the provider you are looking for." -- Obi-Wan Kaniesobi.
+            def call_provider(value); end
           end
 
           case options[:type]
           when 'Enum[present, absent]'
             Puppet::ResourceApi.def_newvalues(self, param_or_property, 'absent', 'present')
-            # puppet symbolizes these values through puppet/paramter/value.rb (see .convert()), but Enums are strings
-            # specifying a munge block here skips the value_collection fallback in puppet/parameter.rb's
-            # default .unsafe_munge() implementation
-            munge { |v| v }
           end
         end
       end
@@ -266,9 +277,8 @@ module Puppet::ResourceApi
 
       define_method(:flush) do
         # puts 'flush'
-        target_state = Hash[@parameters.map { |k, v| [k, v.value] }]
-        # remove puppet's injected metaparams
-        target_state.delete(:loglevel)
+        # skip puppet's injected metaparams
+        target_state = Hash[@parameters.reject { |k, _v| [:loglevel, :noop].include? k }.map { |k, v| [k, v.rs_value] }]
         target_state = my_provider.canonicalize(context, [target_state]).first if feature_support?('canonicalize')
 
         retrieve unless @rapi_current_state
@@ -385,4 +395,87 @@ MESSAGE
       end
     end
   end
+
+  # Validates and munges values coming from puppet into a shape palatable to the provider.
+  # This includes parsing values from strings, e.g. when running in `puppet resource`.
+  # @param type[Puppet::Pops::Types::TypedModelObject] the type to check/clean against
+  # @param value the value to clean
+  # @param error_msg_prefix[String] a prefix for the error messages
+  # @return [type] the cleaned value
+  # @raise [Puppet::ResourceError] if `value` could not be parsed into `type`
+  def self.mungify(type, value, error_msg_prefix)
+    cleaned_value, error = try_mungify(type, value, error_msg_prefix)
+
+    raise Puppet::ResourceError, error if error
+
+    cleaned_value
+  end
+
+  # Recursive implementation part of #mungify. Uses a multi-valued return value to avoid excessive
+  #   exception throwing for regular usage
+  # @return [Array] if the mungify worked, the first element is the cleaned value, and the second
+  #   element is nil. If the mungify failed, the first element is nil, and the second element is an error
+  #   message
+  # @private
+  def self.try_mungify(type, value, error_msg_prefix)
+    case type
+    when Puppet::Pops::Types::PArrayType
+      if value.is_a? Array
+        conversions = value.map do |v|
+          try_mungify(type.element_type, v, error_msg_prefix)
+        end
+        # only convert the values if none failed. otherwise fall through and rely on puppet to render a proper error
+        if conversions.all? { |c| c[1].nil? }
+          value = conversions.map { |c| c[0] }
+        end
+      end
+    when Puppet::Pops::Types::PBooleanType
+      value = case value
+              when 'true', :true # rubocop:disable Lint/BooleanSymbol
+                true
+              when 'false', :false # rubocop:disable Lint/BooleanSymbol
+                false
+              else
+                value
+              end
+    when Puppet::Pops::Types::PIntegerType, Puppet::Pops::Types::PFloatType, Puppet::Pops::Types::PNumericType
+      if value =~ %r{^-?\d+$} || value =~ Puppet::Pops::Patterns::NUMERIC
+        value = Puppet::Pops::Utils.to_n(value)
+      end
+    when Puppet::Pops::Types::PEnumType, Puppet::Pops::Types::PStringType, Puppet::Pops::Types::PPatternType
+      if value.is_a? Symbol
+        value = value.to_s
+      end
+    when Puppet::Pops::Types::POptionalType
+      return value.nil? ? [nil, nil] : try_mungify(type.type, value, error_msg_prefix)
+    when Puppet::Pops::Types::PVariantType
+      # try converting to anything except string first
+      string_type = type.types.find { |t| t.is_a? Puppet::Pops::Types::PStringType }
+      conversion_results = (type.types - [string_type]).map do |t|
+        try_mungify(t, value, error_msg_prefix)
+      end
+
+      # only consider valid results
+      conversion_results = conversion_results.select { |r| r[1].nil? }.to_a
+
+      # use the conversion result if unambiguous
+      return conversion_results[0] if conversion_results.length == 1
+
+      # return an error if ambiguous
+      return [nil, "#{error_msg_prefix} #{value.inspect} is not unabiguously convertable to #{type}"] if conversion_results.length > 1
+
+      # try to interpret as string
+      return try_mungify(string_type, value, error_msg_prefix) if string_type
+
+      # fall through to default handling
+    end
+
+    # a match!
+    return [value, nil] if type.instance?(value)
+
+    # an error :-(
+    inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value)
+    error_msg = Puppet::Pops::Types::TypeMismatchDescriber.new.describe_mismatch(error_msg_prefix, type, inferred_type)
+    return [nil, error_msg] # the entire function is using returns for clarity # rubocop:disable Style/RedundantReturn
+  end
 end

data/lib/puppet/resource_api/version.rb

@@ -1,5 +1,5 @@
 module Puppet
   module ResourceApi
-    VERSION = '1.0.3'.freeze
+    VERSION = '1.1.0'.freeze
   end
 end

data/puppet-resource_api.gemspec

@@ -11,9 +11,15 @@ Gem::Specification.new do |spec|
   spec.summary       = 'This library provides a simple way to write new native resources for puppet.'
   spec.homepage      = 'https://github.com/puppetlabs/puppet-resource_api'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
+  # on out internal jenkins, there is no `.git` directory, but since it is a clean machine, we don't need to worry about anything else
+  spec.files         = if Dir.exist?('.git')
+                         `git ls-files -z`.split("\x0")
+                       else
+                         Dir.glob('**/*')
+                       end.reject do |f|
+                         f.match(%r{^(test|spec|features)/})
+                       end
+
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-resource_api
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - David Schmitt
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-06 00:00:00.000000000 Z
+date: 2018-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hocon