puppet-resource_api 1.6.2 → 1.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 306133cd86d46867056bd6bf220111b843d0edae82af69e3e428aba627377f56
-  data.tar.gz: 7652de8fdc6c86124994ba0b66d78a403baa779eb4b27ed2de0f1862cb7867be
+  metadata.gz: 5c84f42dbe3cadd9471c1a763bf3981e998bf285df618970ee4b09d5218d3603
+  data.tar.gz: 4575e26e85ee7c52ba389480ccd1348001e48396657fd7dcacc9f074c7ccf0fd
 SHA512:
-  metadata.gz: 45dd940aa1b6cd7aa5378fb2a401158dbb482c6d3171925bcb2ad3a68ed2e017dff6738c6d40c4ee061a6f25a2b4ba582c480ef103a7ebda041f3a7d5ca9657f
-  data.tar.gz: 725ee6aeb23a0ad23905b5f6e39c2d66d24461976a6318d35db4bd0839d70314f743e84cefa4ca63cfe11b8f49099b1a2f9a6a1d4bae987826b95f9545c8a75b
+  metadata.gz: 042a05622f752fb21487292a296fdaa45ef5b468248a513473698834dd20c4129331f69734cb86f0bf22a410dbddefa41e253d3fdd610edf227937961d398154
+  data.tar.gz: 73092a426db653e4b7311684ec6ced636884cf9605c18ce84f99fe697f069dcd5894448feea1f3d1b27c94fd220f33008835efcb76b636ff7429377ac8d0f87c

data/lib/puppet/resource_api.rb

@@ -1,7 +1,12 @@
 require 'pathname'
+require 'puppet/resource_api/data_type_handling'
 require 'puppet/resource_api/glue'
+require 'puppet/resource_api/parameter'
+require 'puppet/resource_api/property'
 require 'puppet/resource_api/puppet_context' unless RUBY_PLATFORM == 'java'
+require 'puppet/resource_api/read_only_parameter'
 require 'puppet/resource_api/type_definition'
+require 'puppet/resource_api/value_creator'
 require 'puppet/resource_api/version'
 require 'puppet/type'
 require 'puppet/util/network_device'
@@ -25,7 +30,7 @@ module Puppet::ResourceApi
       raise Puppet::DevError, '`:title_patterns` must be an array, not `%{other_type}`' % { other_type: definition[:title_patterns].class }
     end
 
-    validate_ensure(definition)
+    Puppet::ResourceApi::DataTypeHandling.validate_ensure(definition)
 
     definition[:features] ||= []
     supported_features = %w[supports_noop canonicalize remote_resource simple_get_filter].freeze
@@ -137,7 +142,10 @@ module Puppet::ResourceApi
         return if @ral_find_absent
 
         definition[:attributes].each do |name, options|
-          type = Puppet::ResourceApi.parse_puppet_type(:name, options[:type])
+          type = Puppet::ResourceApi::DataTypeHandling.parse_puppet_type(
+            :name,
+            options[:type],
+          )
 
           # skip read only vars and the namevar
           next if [:read_only, :namevar].include? options[:behaviour]
@@ -170,13 +178,23 @@ module Puppet::ResourceApi
         # TODO: using newparam everywhere would suppress change reporting
         #       that would allow more fine-grained reporting through context,
         #       but require more invest in hooking up the infrastructure to emulate existing data
-        param_or_property = if [:read_only, :parameter, :namevar].include? options[:behaviour]
-                              :newparam
-                            else
-                              :newproperty
-                            end
+        if [:parameter, :namevar].include? options[:behaviour]
+          param_or_property = :newparam
+          parent = Puppet::ResourceApi::Parameter
+        elsif options[:behaviour] == :read_only
+          param_or_property = :newparam
+          parent = Puppet::ResourceApi::ReadOnlyParameter
+        else
+          param_or_property = :newproperty
+          parent = Puppet::ResourceApi::Property
+        end
 
-        send(param_or_property, name.to_sym) do
+        # This call creates a new parameter or property with all work-arounds or
+        # customizations required by the Resource API applied. Under the hood,
+        # this maps to the relevant DSL methods in Puppet::Type. See
+        # https://puppet.com/docs/puppet/6.0/custom_types.html#reference-5883
+        # for details.
+        send(param_or_property, name.to_sym, parent: parent) do
           unless options[:type]
             raise Puppet::DevError, "#{definition[:name]}.#{name} has no type"
           end
@@ -187,129 +205,32 @@ module Puppet::ResourceApi
             warn("#{definition[:name]}.#{name} has no docs")
           end
 
-          if options[:behaviour] == :namevar
-            isnamevar
-          end
-
-          # read-only values do not need type checking, but can have default values
-          if options[:behaviour] != :read_only && options.key?(:default)
-            if options.key? :default
-              if options[:default] == false
-                # work around https://tickets.puppetlabs.com/browse/PUP-2368
-                defaultto :false # rubocop:disable Lint/BooleanSymbol
-              elsif options[:default] == true
-                # work around https://tickets.puppetlabs.com/browse/PUP-2368
-                defaultto :true # rubocop:disable Lint/BooleanSymbol
-              else
-                # marshal the default option to decouple that from the actual value.
-                # we cache the dumped value in `marshalled`, but use a block to unmarshal
-                # everytime the value is requested. Objects that can't be marshalled
-                # See https://stackoverflow.com/a/8206537/4918
-                marshalled = Marshal.dump(options[:default])
-                defaultto { Marshal.load(marshalled) } # rubocop:disable Security/MarshalLoad
-              end
-            end
-          end
-
-          if name == :ensure
-            def insync?(is)
-              rs_value.to_s == is.to_s
-            end
-          end
-
-          type = Puppet::ResourceApi.parse_puppet_type(name, options[:type])
-
-          if param_or_property == :newproperty
-            define_method(:should) do
-              if name == :ensure && rs_value.is_a?(String)
-                rs_value.to_sym
-              elsif rs_value == false
-                # work around https://tickets.puppetlabs.com/browse/PUP-2368
-                :false # rubocop:disable Lint/BooleanSymbol
-              elsif rs_value == true
-                # work around https://tickets.puppetlabs.com/browse/PUP-2368
-                :true # rubocop:disable Lint/BooleanSymbol
-              else
-                rs_value
-              end
-            end
-
-            define_method(:should=) do |value|
-              @shouldorig = value
-
-              if name == :ensure
-                value = value.to_s
-              end
-
-              # 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
-
-            # 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
-
-            define_method(:value=) do |value|
-              if options[:behaviour] == :read_only
-                raise Puppet::ResourceError, "Attempting to set `#{name}` read_only attribute value to `#{value}`"
-              end
-
-              @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
-
-          # 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
-          if type.instance_of? Puppet::Pops::Types::POptionalType
-            type = type.type
-          end
-
-          case type
-          when Puppet::Pops::Types::PStringType
-            # require any string value
-            Puppet::ResourceApi.def_newvalues(self, param_or_property, %r{})
-          when Puppet::Pops::Types::PBooleanType
-            Puppet::ResourceApi.def_newvalues(self, param_or_property, 'true', 'false')
-            aliasvalue true, 'true'
-            aliasvalue false, 'false'
-            aliasvalue :true, 'true' # rubocop:disable Lint/BooleanSymbol
-            aliasvalue :false, 'false' # rubocop:disable Lint/BooleanSymbol
-
-          when Puppet::Pops::Types::PIntegerType
-            Puppet::ResourceApi.def_newvalues(self, param_or_property, %r{^-?\d+$})
-          when Puppet::Pops::Types::PFloatType, Puppet::Pops::Types::PNumericType
-            Puppet::ResourceApi.def_newvalues(self, param_or_property, Puppet::Pops::Patterns::NUMERIC)
+          # The initialize method is called when puppet core starts building up
+          # type objects. The core passes in a hash of shape { resource:
+          # #<Puppet::Type::TypeName> }. We use this to pass through the
+          # required configuration data to the parent (see
+          # Puppet::ResourceApi::Property, Puppet::ResourceApi::Parameter and
+          # Puppet::ResourceApi::ReadOnlyParameter).
+          define_method(:initialize) do |resource_hash|
+            super(definition[:name], self.class.data_type, name, resource_hash)
           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
+          # get pops data type object for this parameter or property
+          define_singleton_method(:data_type) do
+            @rsapi_data_type ||= Puppet::ResourceApi::DataTypeHandling.parse_puppet_type(
+              name,
+              options[:type],
+            )
           end
 
-          case options[:type]
-          when 'Enum[present, absent]'
-            Puppet::ResourceApi.def_newvalues(self, param_or_property, 'absent', 'present')
-          end
+          # from ValueCreator call create_values which makes alias values and
+          # default values for properties and params
+          Puppet::ResourceApi::ValueCreator.create_values(
+            self,
+            data_type,
+            param_or_property,
+            options,
+          )
         end
       end
 
@@ -563,162 +484,7 @@ MESSAGE
     type_name.to_s.split('_').map(&:capitalize).join
   end
 
-  # Add the value to `this` property or param, depending on whether param_or_property is `:newparam`, or `:newproperty`
-  def self.def_newvalues(this, param_or_property, *values)
-    if param_or_property == :newparam
-      this.newvalues(*values)
-    else
-      values.each do |v|
-        this.newvalue(v) {}
-      end
-    end
-  end
-
   def self.caller_is_resource_app?
     caller.any? { |c| c.match(%r{application/resource.rb:}) }
   end
-
-  # This method handles translating values from the runtime environment to the expected types for the provider.
-  # When being called from `puppet resource`, it tries to transform the strings from the command line into their
-  # expected ruby representations, e.g. `"2"` (a string), will be transformed to `2` (the number) if (and only if)
-  # the target `type` is `Integer`.
-  # Additionally this function also validates that the passed in (and optionally transformed) value matches the
-  # specified type.
-  # @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)
-    if caller_is_resource_app?
-      # When the provider is exercised from the `puppet resource` CLI, we need to unpack strings into
-      # the correct types, e.g. "1" (a string) to 1 (an integer)
-      cleaned_value, error_msg = try_mungify(type, value, error_msg_prefix)
-      raise Puppet::ResourceError, error_msg if error_msg
-    elsif value == :false # rubocop:disable Lint/BooleanSymbol
-      # work around https://tickets.puppetlabs.com/browse/PUP-2368
-      cleaned_value = false
-    elsif value == :true # rubocop:disable Lint/BooleanSymbol
-      # work around https://tickets.puppetlabs.com/browse/PUP-2368
-      cleaned_value = true
-    else
-      # Every other time, we can use the values as is
-      cleaned_value = value
-    end
-    Puppet::ResourceApi.validate(type, cleaned_value, error_msg_prefix)
-    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
-
-    error_msg = try_validate(type, value, error_msg_prefix)
-    if error_msg
-      # an error :-(
-      [nil, error_msg]
-    else
-      # a match!
-      [value, nil]
-    end
-  end
-
-  # Validates the `value` against the specified `type`.
-  # @param type[Puppet::Pops::Types::TypedModelObject] the type to check against
-  # @param value the value to clean
-  # @param error_msg_prefix[String] a prefix for the error messages
-  # @raise [Puppet::ResourceError] if `value` is not of type `type`
-  # @private
-  def self.validate(type, value, error_msg_prefix)
-    error_msg = try_validate(type, value, error_msg_prefix)
-
-    raise Puppet::ResourceError, error_msg if error_msg
-  end
-
-  # Tries to validate the `value` against the specified `type`.
-  # @param type[Puppet::Pops::Types::TypedModelObject] the type to check against
-  # @param value the value to clean
-  # @param error_msg_prefix[String] a prefix for the error messages
-  # @return [String, nil] a error message indicating the problem, or `nil` if the value was valid.
-  # @private
-  def self.try_validate(type, value, error_msg_prefix)
-    return 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)
-    error_msg
-  end
-
-  def self.validate_ensure(definition)
-    return unless definition[:attributes].key? :ensure
-    options = definition[:attributes][:ensure]
-    type = Puppet::ResourceApi.parse_puppet_type(:ensure, options[:type])
-
-    return if type.is_a?(Puppet::Pops::Types::PEnumType) && type.values.sort == %w[absent present].sort
-    raise Puppet::DevError, '`:ensure` attribute must have a type of: `Enum[present, absent]`'
-  end
-
-  def self.parse_puppet_type(attr_name, type)
-    Puppet::Pops::Types::TypeParser.singleton.parse(type)
-  rescue Puppet::ParseErrorWithIssue => e
-    raise Puppet::DevError, "The type of the `#{attr_name}` attribute `#{type}` could not be parsed: #{e.message}"
-  rescue Puppet::ParseError => e
-    raise Puppet::DevError, "The type of the `#{attr_name}` attribute `#{type}` is not recognised: #{e.message}"
-  end
 end

data/lib/puppet/resource_api/data_type_handling.rb

@@ -0,0 +1,198 @@
+module Puppet; module ResourceApi; end; end # predeclare the main module # rubocop:disable Style/Documentation,Style/ClassAndModuleChildren
+
+# This module is used to handle data inside types, contains methods for munging
+# and validation of the type values.
+module Puppet::ResourceApi::DataTypeHandling
+  # This method handles translating values from the runtime environment to the
+  # expected types for the provider with validation.
+  # When being called from `puppet resource`, it tries to transform the strings
+  # from the command line into their expected ruby representations,
+  # e.g. `"2"` (a string), will be transformed to `2` (the number)
+  # if (and only if) the target `type` is `Integer`.
+  # Additionally this function also validates that the passed in
+  # (and optionally transformed) value matches the specified type.
+  # @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
+  # @param unpack_strings[Boolean] unpacking of strings for migrating off
+  # legacy type
+  # @return [type] the cleaned value
+  def self.mungify(type, value, error_msg_prefix, unpack_strings = false)
+    cleaned_value = mungify_core(
+      type,
+      value,
+      error_msg_prefix,
+      unpack_strings,
+    )
+    validate(type, cleaned_value, error_msg_prefix)
+    cleaned_value
+  end
+
+  # This is core method used in mungify which handles translating values to expected
+  # cleaned type values, result is not validated.
+  # @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
+  # @param unpack_strings[Boolean] unpacking of strings for migrating off
+  # legacy type
+  # @return [type] the cleaned value
+  # @raise [Puppet::ResourceError] if `value` could not be parsed into `type`
+  # @private
+  def self.mungify_core(type, value, error_msg_prefix, unpack_strings = false)
+    if unpack_strings
+      # When the provider is exercised from the `puppet resource` CLI, we need
+      # to unpack strings into the correct types, e.g. "1" (a string)
+      # to 1 (an integer)
+      cleaned_value, error_msg = try_mungify(type, value, error_msg_prefix)
+      raise Puppet::ResourceError, error_msg if error_msg
+      cleaned_value
+    elsif value == :false # rubocop:disable Lint/BooleanSymbol
+      # work around https://tickets.puppetlabs.com/browse/PUP-2368
+      false
+    elsif value == :true # rubocop:disable Lint/BooleanSymbol
+      # work around https://tickets.puppetlabs.com/browse/PUP-2368
+      true
+    else
+      # Every other time, we can use the values as is
+      value
+    end
+  end
+
+  # Recursive implementation part of #mungify_core. 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 = boolean_munge(value)
+    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
+      value = value.to_s if value.is_a? Symbol
+    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
+      if conversion_results.length > 1
+        return [nil, ambiguous_error_msg(error_msg_prefix, value, type)]
+      end
+
+      # try to interpret as string
+      return try_mungify(string_type, value, error_msg_prefix) if string_type
+
+      # fall through to default handling
+    end
+
+    error_msg = try_validate(type, value, error_msg_prefix)
+    return [nil, error_msg] if error_msg # an error
+    [value, nil]                         # match
+  end
+
+  # Returns correct boolean `value` based on one specified in `type`.
+  # @param value the value to boolean munge
+  # @private
+  def self.boolean_munge(value)
+    case value
+    when 'true', :true # rubocop:disable Lint/BooleanSymbol
+      true
+    when 'false', :false # rubocop:disable Lint/BooleanSymbol
+      false
+    else
+      value
+    end
+  end
+
+  # Returns ambiguous error message based on `error_msg_prefix`, `value` and
+  # `type`.
+  # @param type[Puppet::Pops::Types::TypedModelObject] the type to check against
+  # @param value the value to clean
+  # @param error_msg_prefix[String] a prefix for the error messages
+  # @private
+  def self.ambiguous_error_msg(error_msg_prefix, value, type)
+    "#{error_msg_prefix} #{value.inspect} is not unabiguously convertable to " \
+    "#{type}"
+  end
+
+  # Validates the `value` against the specified `type`.
+  # @param type[Puppet::Pops::Types::TypedModelObject] the type to check against
+  # @param value the value to clean
+  # @param error_msg_prefix[String] a prefix for the error messages
+  # @raise [Puppet::ResourceError] if `value` is not of type `type`
+  # @private
+  def self.validate(type, value, error_msg_prefix)
+    error_msg = try_validate(type, value, error_msg_prefix)
+    raise Puppet::ResourceError, error_msg if error_msg
+  end
+
+  # Tries to validate the `value` against the specified `type`.
+  # @param type[Puppet::Pops::Types::TypedModelObject] the type to check against
+  # @param value the value to clean
+  # @param error_msg_prefix[String] a prefix for the error messages
+  # @return [String, nil] a error message indicating the problem, or `nil` if the value was valid.
+  # @private
+  def self.try_validate(type, value, error_msg_prefix)
+    return 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,
+    )
+    error_msg
+  end
+
+  def self.validate_ensure(definition)
+    return unless definition[:attributes].key? :ensure
+    options = definition[:attributes][:ensure]
+    type = parse_puppet_type(:ensure, options[:type])
+
+    return if type.is_a?(Puppet::Pops::Types::PEnumType) && type.values.sort == %w[absent present].sort
+    raise Puppet::DevError, '`:ensure` attribute must have a type of: `Enum[present, absent]`'
+  end
+
+  def self.parse_puppet_type(attr_name, type)
+    Puppet::Pops::Types::TypeParser.singleton.parse(type)
+  rescue Puppet::ParseErrorWithIssue => e
+    raise Puppet::DevError, "The type of the `#{attr_name}` attribute " \
+          "`#{type}` could not be parsed: #{e.message}"
+  rescue Puppet::ParseError => e
+    raise Puppet::DevError, "The type of the `#{attr_name}` attribute " \
+          "`#{type}` is not recognised: #{e.message}"
+  end
+end

data/lib/puppet/resource_api/parameter.rb

@@ -0,0 +1,46 @@
+require 'puppet/util'
+require 'puppet/parameter'
+
+module Puppet; module ResourceApi; end; end # predeclare the main module # rubocop:disable Style/Documentation,Style/ClassAndModuleChildren
+
+# Class containing parameter functionality for ResourceApi.
+class Puppet::ResourceApi::Parameter < Puppet::Parameter
+  attr_reader :value
+
+  # This initialize takes arguments and sets up new parameter.
+  # @param type_name the name of the Puppet Type
+  # @param data_type the data type of parameter instance
+  # @param attribute_name the name of attribue of the parameter
+  # @param resource_hash the resource hash instance which is passed to the
+  # parent class.
+  def initialize(type_name, data_type, attribute_name, resource_hash)
+    @type_name = type_name
+    @data_type = data_type
+    @attribute_name = attribute_name
+    super(resource_hash) # Pass resource to parent Puppet class.
+  end
+
+  # This method assigns value to the parameter and cleans value.
+  # @param value the value to be set and clean
+  # @return [type] the cleaned value
+  def value=(value)
+    @value = Puppet::ResourceApi::DataTypeHandling.mungify(
+      @data_type,
+      value,
+      "#{@type_name}.#{@attribute_name}",
+      Puppet::ResourceApi.caller_is_resource_app?,
+    )
+  end
+
+  # used internally
+  # @returns the final mungified value of this parameter
+  def rs_value
+    @value
+  end
+
+  # 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 }
+end

data/lib/puppet/resource_api/property.rb

@@ -0,0 +1,86 @@
+require 'puppet/util'
+require 'puppet/property'
+
+module Puppet; module ResourceApi; end; end # predeclare the main module # rubocop:disable Style/Documentation,Style/ClassAndModuleChildren
+
+# Class containing property functionality for ResourceApi.
+class Puppet::ResourceApi::Property < Puppet::Property
+  # This initialize takes arguments and sets up new property.
+  # @param type_name the name of the Puppet Type
+  # @param data_type the data type of property instance
+  # @param attribute_name the name of attribue of the property
+  # @param resource_hash the resource hash instance which is passed to the
+  # parent class.
+  def initialize(type_name, data_type, attribute_name, resource_hash)
+    @type_name = type_name
+    @data_type = data_type
+    @attribute_name = attribute_name
+    # Define class method insync?(is) if the name is :ensure
+    def_insync? if @attribute_name == :ensure && self.class != Puppet::ResourceApi::Property
+    # Pass resource to parent Puppet class.
+    super(resource_hash)
+  end
+
+  # This method returns value of the property.
+  # @return [type] the property value
+  def should
+    if @attribute_name == :ensure && rs_value.is_a?(String)
+      rs_value.to_sym
+    elsif rs_value == false
+      # work around https://tickets.puppetlabs.com/browse/PUP-2368
+      :false # rubocop:disable Lint/BooleanSymbol
+    elsif rs_value == true
+      # work around https://tickets.puppetlabs.com/browse/PUP-2368
+      :true # rubocop:disable Lint/BooleanSymbol
+    else
+      rs_value
+    end
+  end
+
+  # This method sets and returns value of the property and sets @shouldorig.
+  # @param value the value to be set and clean
+  # @return [type] the property value
+  def should=(value)
+    @shouldorig = value
+
+    if @attribute_name == :ensure
+      value = value.to_s
+    end
+
+    # 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::DataTypeHandling.mungify(
+        @data_type,
+        value,
+        "#{@type_name}.#{@attribute_name}",
+        Puppet::ResourceApi.caller_is_resource_app?,
+      ),
+    ]
+  end
+
+  # used internally
+  # @returns the final mungified value of this property
+  def rs_value
+    @should ? @should.first : @should
+  end
+
+  # method overloaded only for the :ensure property, add option to check if the
+  # rs_value matches is. Only if the class is child of
+  # Puppet::ResourceApi::Property.
+  def def_insync?
+    define_singleton_method(:insync?) { |is| rs_value.to_s == is.to_s }
+  end
+
+  # 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 }
+
+  # 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

data/lib/puppet/resource_api/read_only_parameter.rb

@@ -0,0 +1,19 @@
+require 'puppet/util'
+require 'puppet/resource_api/parameter'
+
+# Class containing read only parameter functionality for ResourceApi.
+class Puppet::ResourceApi::ReadOnlyParameter < Puppet::ResourceApi::Parameter
+  # This method raises error if the there is attempt to set value in parameter.
+  # @return [Puppet::ResourceError] the error with information.
+  def value=(value)
+    raise Puppet::ResourceError,
+          "Attempting to set `#{@attribute_name}` read_only attribute value " \
+          "to `#{value}`"
+  end
+
+  # used internally
+  # @returns the final mungified value of this parameter
+  def rs_value
+    @value
+  end
+end

data/lib/puppet/resource_api/type_definition.rb

@@ -84,8 +84,15 @@ class Puppet::ResourceApi::TypeDefinition
     bad_vals = {}
     resource.each do |key, value|
       next unless attributes[key]
-      type = Puppet::ResourceApi.parse_puppet_type(key, attributes[key][:type])
-      error_message = Puppet::ResourceApi.try_validate(type, value, '')
+      type = Puppet::ResourceApi::DataTypeHandling.parse_puppet_type(
+        key,
+        attributes[key][:type],
+      )
+      error_message = Puppet::ResourceApi::DataTypeHandling.try_validate(
+        type,
+        value,
+        '',
+      )
       bad_vals[key] = value unless error_message.nil?
     end
     bad_vals

data/lib/puppet/resource_api/value_creator.rb

@@ -0,0 +1,75 @@
+module Puppet; module ResourceApi; end; end # predeclare the main module # rubocop:disable Style/Documentation,Style/ClassAndModuleChildren
+
+# This module is responsible for setting default and alias values for the
+# resource class.
+module Puppet::ResourceApi::ValueCreator
+  # This method is responsible for all setup of the value mapping for desired
+  # resource class which can be Puppet::ResourceApi::Parameter,
+  # Puppet::ResourceApi::ReadOnlyParameter, Puppet::ResourceApi::Property.
+  # @param resource_class the class of selected resource to be extended
+  # @param data_type the type instance
+  # @param definition the definition of the property
+  # @param options the ResourceAPI options hash containing setup information for
+  # selected parameter or property
+  def self.create_values(attribute_class, data_type, param_or_property, options = {})
+    attribute_class.isnamevar if options[:behaviour] == :namevar
+
+    # read-only values do not need type checking, but can have default values
+    if options[:behaviour] != :read_only && options.key?(:default)
+      if options[:default] == false
+        # work around https://tickets.puppetlabs.com/browse/PUP-2368
+        attribute_class.defaultto :false # rubocop:disable Lint/BooleanSymbol
+      elsif options[:default] == true
+        # work around https://tickets.puppetlabs.com/browse/PUP-2368
+        attribute_class.defaultto :true # rubocop:disable Lint/BooleanSymbol
+      else
+        # marshal the default option to decouple that from the actual value.
+        # we cache the dumped value in `marshalled`, but use a block to
+        # unmarshal everytime the value is requested. Objects that can't be
+        # marshalled
+        # See https://stackoverflow.com/a/8206537/4918
+        marshalled = Marshal.dump(options[:default])
+        attribute_class.defaultto { Marshal.load(marshalled) } # rubocop:disable Security/MarshalLoad
+      end
+    end
+
+    # provide hints to `puppet type generate` for better parsing
+    if data_type.instance_of? Puppet::Pops::Types::POptionalType
+      data_type = data_type.type
+    end
+
+    case data_type
+    when Puppet::Pops::Types::PStringType
+      # require any string value
+      def_newvalues(attribute_class, param_or_property, %r{})
+    when Puppet::Pops::Types::PBooleanType
+      def_newvalues(attribute_class, param_or_property, 'true', 'false')
+      attribute_class.aliasvalue true, 'true'
+      attribute_class.aliasvalue false, 'false'
+      attribute_class.aliasvalue :true, 'true' # rubocop:disable Lint/BooleanSymbol
+      attribute_class.aliasvalue :false, 'false' # rubocop:disable Lint/BooleanSymbol
+    when Puppet::Pops::Types::PIntegerType
+      def_newvalues(attribute_class, param_or_property, %r{^-?\d+$})
+    when Puppet::Pops::Types::PFloatType, Puppet::Pops::Types::PNumericType
+      def_newvalues(attribute_class, param_or_property, Puppet::Pops::Patterns::NUMERIC)
+    end
+
+    case options[:type]
+    when 'Enum[present, absent]'
+      def_newvalues(attribute_class, param_or_property, 'absent', 'present')
+    end
+    attribute_class
+  end
+
+  # add the value to `this` property or param, depending on whether
+  # param_or_property is `:newparam`, or `:newproperty`
+  def self.def_newvalues(this, param_or_property, *values)
+    if param_or_property == :newparam
+      this.newvalues(*values)
+    else
+      values.each do |v|
+        this.newvalue(v) {}
+      end
+    end
+  end
+end

data/lib/puppet/resource_api/version.rb

@@ -1,5 +1,5 @@
 module Puppet
   module ResourceApi
-    VERSION = '1.6.2'.freeze
+    VERSION = '1.6.3'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-resource_api
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.6.3
 platform: ruby
 authors:
 - David Schmitt
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-25 00:00:00.000000000 Z
+date: 2019-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hocon
@@ -53,11 +53,16 @@ files:
 - contrib/pre-commit
 - lib/puppet/resource_api.rb
 - lib/puppet/resource_api/base_context.rb
+- lib/puppet/resource_api/data_type_handling.rb
 - lib/puppet/resource_api/glue.rb
 - lib/puppet/resource_api/io_context.rb
+- lib/puppet/resource_api/parameter.rb
+- lib/puppet/resource_api/property.rb
 - lib/puppet/resource_api/puppet_context.rb
+- lib/puppet/resource_api/read_only_parameter.rb
 - lib/puppet/resource_api/simple_provider.rb
 - lib/puppet/resource_api/type_definition.rb
+- lib/puppet/resource_api/value_creator.rb
 - lib/puppet/resource_api/version.rb
 - lib/puppet/util/network_device/simple/device.rb
 - misc/ANNOUNCEMENT_TEMPLATE.md
@@ -82,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: This library provides a simple way to write new native resources for puppet.