puppet-resource_api 1.9.0 → 2.0.0

data/lib/puppet/resource_api/parameter.rb

@@ -3,7 +3,7 @@
 require 'puppet/util'
 require 'puppet/parameter'
 
-module Puppet; module ResourceApi; end; end # predeclare the main module # rubocop:disable Style/Documentation,Style/ClassAndModuleChildren
+module Puppet; module ResourceApi; end; end # predeclare the main module # rubocop:disable Style/Documentation
 
 # Class containing parameter functionality for ResourceApi.
 class Puppet::ResourceApi::Parameter < Puppet::Parameter
@@ -30,7 +30,7 @@ class Puppet::ResourceApi::Parameter < Puppet::Parameter
       @data_type,
       value,
       "#{@type_name}.#{@attribute_name}",
-      Puppet::ResourceApi.caller_is_resource_app?,
+      Puppet::ResourceApi.caller_is_resource_app?
     )
   end
 

data/lib/puppet/resource_api/property.rb

@@ -3,7 +3,7 @@
 require 'puppet/util'
 require 'puppet/property'
 
-module Puppet; module ResourceApi; end; end # predeclare the main module # rubocop:disable Style/Documentation,Style/ClassAndModuleChildren
+module Puppet; module ResourceApi; end; end # predeclare the main module # rubocop:disable Style/Documentation
 
 # Class containing property functionality for ResourceApi.
 class Puppet::ResourceApi::Property < Puppet::Property
@@ -27,9 +27,7 @@ class Puppet::ResourceApi::Property < Puppet::Property
       # Define class method insync?(is) if the custom_insync feature flag is set
       if referrable_type&.type_definition&.feature?('custom_insync')
         def_custom_insync?
-        if @attribute_name == :rsapi_custom_insync_trigger
-          @change_to_s_value = 'Custom insync logic determined that this resource is out of sync'
-        end
+        @change_to_s_value = 'Custom insync logic determined that this resource is out of sync' if @attribute_name == :rsapi_custom_insync_trigger
       # Define class method insync?(is) if the name is :ensure and custom_insync feature flag is not set
       elsif @attribute_name == :ensure
         def_ensure_insync?
@@ -62,9 +60,7 @@ class Puppet::ResourceApi::Property < Puppet::Property
   def should=(value)
     @shouldorig = value
 
-    if @attribute_name == :ensure
-      value = value.to_s
-    end
+    value = value.to_s if @attribute_name == :ensure
 
     # Puppet requires the @should value to always be stored as an array. We do not use this
     # for anything else
@@ -74,8 +70,8 @@ class Puppet::ResourceApi::Property < Puppet::Property
         @data_type,
         value,
         "#{@type_name}.#{@attribute_name}",
-        Puppet::ResourceApi.caller_is_resource_app?,
-      ),
+        Puppet::ResourceApi.caller_is_resource_app?
+      )
     ]
   end
 
@@ -104,21 +100,20 @@ class Puppet::ResourceApi::Property < Puppet::Property
 
       provider_insync_result, change_message = provider.insync?(context, title, @attribute_name, is_hash, should_hash)
 
-      unless provider_insync_result.nil? || change_message.nil? || change_message.empty?
-        @change_to_s_value = change_message
-      end
+      @change_to_s_value = change_message unless provider_insync_result.nil? || change_message.nil? || change_message.empty?
 
       case provider_insync_result
       when nil
         # If validating ensure and no custom insync was used, check if rs_value matches is.
         return rs_value.to_s == is.to_s if @attribute_name == :ensure
+
         # Otherwise, super and rely on Puppet::Property.insync?
         super(is)
       when TrueClass, FalseClass
-        return provider_insync_result
+        provider_insync_result
       else
         # When returning anything else, raise a DevError for a non-idiomatic return
-        raise(Puppet::DevError, "Custom insync for #{@attribute_name} returned a #{provider_insync_result.class} with a value of #{provider_insync_result.inspect} instead of true/false; insync? MUST return nil or the boolean true or false") # rubocop:disable Metrics/LineLength
+        raise(Puppet::DevError, "Custom insync for #{@attribute_name} returned a #{provider_insync_result.class} with a value of #{provider_insync_result.inspect} instead of true/false; insync? MUST return nil or the boolean true or false") # rubocop:disable Layout/LineLength
       end
     end
 

data/lib/puppet/resource_api/provider_get_cache.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/Documentation
+module Puppet; end
+module Puppet::ResourceApi; end
+# rubocop:enable Style/Documentation
+
+# This class provides a simple caching mechanism to support minimizing get()
+# calls into a provider.
+class Puppet::ResourceApi::ProviderGetCache
+  def initialize
+    clear
+  end
+
+  def clear
+    @cache = {}
+    @cached_all = false
+  end
+
+  def all
+    raise 'all method called, but cached_all not called' unless @cached_all
+
+    @cache.values
+  end
+
+  def add(key, value)
+    @cache[key] = value
+  end
+
+  def get(key)
+    @cache[key]
+  end
+
+  def cached_all
+    @cached_all = true
+  end
+
+  def cached_all?
+    @cached_all
+  end
+end

data/lib/puppet/resource_api/puppet_context.rb

@@ -9,6 +9,7 @@ class Puppet::ResourceApi::PuppetContext < Puppet::ResourceApi::BaseContext
   def device
     # TODO: evaluate facter_url setting for loading config if there is no `current` NetworkDevice
     raise 'no device configured' unless Puppet::Util::NetworkDevice.current
+
     Puppet::Util::NetworkDevice.current
   end
 

data/lib/puppet/resource_api/simple_provider.rb

@@ -6,15 +6,17 @@ module Puppet::ResourceApi
   # This class provides a default implementation for set(), when your resource does not benefit from batching.
   # Instead of processing changes yourself, the `create`, `update`, and `delete` functions, are called for you,
   # with proper logging already set up.
-  # Note that your type needs to use `name` as its namevar, and `ensure` in the conventional way to signal presence
-  # and absence of resources.
+  # Note that your type needs to use `ensure` in the conventional way with values of `prsesent`
+  # and `absent` to signal presence and absence of resources.
   class SimpleProvider
     def set(context, changes)
+      namevars = context.type.namevars
+
       changes.each do |name, change|
         is = if context.type.feature?('simple_get_filter')
-               change.key?(:is) ? change[:is] : (get(context, [name]) || []).find { |r| r[:name] == name }
+               change.key?(:is) ? change[:is] : (get(context, [name]) || []).find { |r| SimpleProvider.build_name(namevars, r) == name }
              else
-               change.key?(:is) ? change[:is] : (get(context) || []).find { |r| r[:name] == name }
+               change.key?(:is) ? change[:is] : (get(context) || []).find { |r| SimpleProvider.build_name(namevars, r) == name }
              end
         context.type.check_schema(is) unless change.key?(:is)
 
@@ -22,13 +24,13 @@ module Puppet::ResourceApi
 
         raise 'SimpleProvider cannot be used with a Type that is not ensurable' unless context.type.ensurable?
 
-        is = SimpleProvider.create_absent(:name, name) if is.nil?
-        should = SimpleProvider.create_absent(:name, name) if should.nil?
+        is_ensure = is.nil? ? 'absent' : is[:ensure].to_s
+        should_ensure = should.nil? ? 'absent' : should[:ensure].to_s
 
-        name_hash = if context.type.namevars.length > 1
+        name_hash = if namevars.length > 1
                       # pass a name_hash containing the values of all namevars
                       name_hash = {}
-                      context.type.namevars.each do |namevar|
+                      namevars.each do |namevar|
                         name_hash[namevar] = change[:should][namevar]
                       end
                       name_hash
@@ -36,15 +38,15 @@ module Puppet::ResourceApi
                       name
                     end
 
-        if is[:ensure].to_s == 'absent' && should[:ensure].to_s == 'present'
+        if is_ensure == 'absent' && should_ensure == 'present'
           context.creating(name) do
             create(context, name_hash, should)
           end
-        elsif is[:ensure].to_s == 'present' && should[:ensure].to_s == 'absent'
+        elsif is_ensure == 'present' && should_ensure == 'absent'
           context.deleting(name) do
             delete(context, name_hash)
           end
-        elsif is[:ensure].to_s == 'present'
+        elsif is_ensure == 'present'
           context.updating(name) do
             update(context, name_hash, should)
           end
@@ -65,14 +67,12 @@ module Puppet::ResourceApi
     end
 
     # @api private
-    def self.create_absent(namevar, title)
-      result = if title.is_a? Hash
-                 title.dup
-               else
-                 { namevar => title }
-               end
-      result[:ensure] = 'absent'
-      result
+    def self.build_name(namevars, resource_hash)
+      if namevars.size > 1
+        Hash[namevars.map { |attr| [attr, resource_hash[attr]] }]
+      else
+        resource_hash[namevars[0]]
+      end
     end
   end
 end

data/lib/puppet/resource_api/transport/wrapper.rb

@@ -13,6 +13,7 @@ class Puppet::ResourceApi::Transport::Wrapper
       url = URI.parse(url_or_config_or_transport)
       raise "Unexpected url '#{url_or_config_or_transport}' found. Only file:/// URLs for configuration supported at the moment." unless url.scheme == 'file'
       raise "Trying to load config from '#{url.path}, but file does not exist." if url && !File.exist?(url.path)
+
       config = self.class.deep_symbolize(Hocon.load(url.path, syntax: Hocon::ConfigSyntax::HOCON) || {})
     elsif url_or_config_or_transport.is_a? Hash
       config = url_or_config_or_transport
@@ -25,7 +26,7 @@ class Puppet::ResourceApi::Transport::Wrapper
   end
 
   def transport_class?(name, transport)
-    class_name = name.split('_').map { |e| e.capitalize }.join
+    class_name = name.split('_').map(&:capitalize).join
     expected = Puppet::Transport.const_get(class_name).to_s
     expected == transport.class.to_s
   end
@@ -40,9 +41,9 @@ class Puppet::ResourceApi::Transport::Wrapper
     (@transport.respond_to? name) || super
   end
 
-  def method_missing(method_name, *args, &block)
+  def method_missing(method_name, ...)
     if @transport.respond_to? method_name
-      @transport.send(method_name, *args, &block)
+      @transport.send(method_name, ...)
     else
       super
     end
@@ -52,6 +53,7 @@ class Puppet::ResourceApi::Transport::Wrapper
   def self.deep_symbolize(obj)
     return obj.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = deep_symbolize(v); } if obj.is_a? Hash
     return obj.each_with_object([]) { |v, memo| memo << deep_symbolize(v); } if obj.is_a? Array
+
     obj
   end
 end

data/lib/puppet/resource_api/transport.rb

@@ -5,26 +5,26 @@ module Puppet::ResourceApi; end # rubocop:disable Style/Documentation
 # Remote target transport API
 module Puppet::ResourceApi::Transport
   def register(schema)
-    raise Puppet::DevError, 'requires a hash as schema, not `%{other_type}`' % { other_type: schema.class } unless schema.is_a? Hash
+    raise Puppet::DevError, format('requires a hash as schema, not `%<other_type>s`', other_type: schema.class) unless schema.is_a? Hash
     raise Puppet::DevError, 'requires a `:name`' unless schema.key? :name
     raise Puppet::DevError, 'requires `:desc`' unless schema.key? :desc
     raise Puppet::DevError, 'requires `:connection_info`' unless schema.key? :connection_info
-    raise Puppet::DevError, '`:connection_info` must be a hash, not `%{other_type}`' % { other_type: schema[:connection_info].class } unless schema[:connection_info].is_a?(Hash)
+    raise Puppet::DevError, format('`:connection_info` must be a hash, not `%<other_type>s`', other_type: schema[:connection_info].class) unless schema[:connection_info].is_a?(Hash)
+
     if schema[:connection_info_order].nil?
       schema[:connection_info_order] = schema[:connection_info].keys
     else
-      raise Puppet::DevError, '`:connection_info_order` must be an array, not `%{other_type}`' % { other_type: schema[:connection_info_order].class } unless schema[:connection_info_order].is_a?(Array)
+      unless schema[:connection_info_order].is_a?(Array)
+        raise Puppet::DevError,
+              format('`:connection_info_order` must be an array, not `%<other_type>s`', other_type: schema[:connection_info_order].class)
+      end
     end
 
-    unless transports[schema[:name]].nil?
-      raise Puppet::DevError, 'Transport `%{name}` is already registered for `%{environment}`' % {
-        name: schema[:name],
-        environment: current_environment_name,
-      }
-    end
+    raise Puppet::DevError, format('Transport `%<name>s` is already registered for `%<environment>s`', name: schema[:name], environment: current_environment_name) unless transports[schema[:name]].nil?
+
     transports[schema[:name]] = Puppet::ResourceApi::TransportSchemaDef.new(schema)
   end
-  module_function :register # rubocop:disable Style/AccessModifierDeclarations
+  module_function :register
 
   # retrieve a Hash of transport schemas, keyed by their name.
   # Only already loaded transports are returned.
@@ -33,7 +33,7 @@ module Puppet::ResourceApi::Transport
   def list
     Marshal.load(Marshal.dump(transports))
   end
-  module_function :list # rubocop:disable Style/AccessModifierDeclarations
+  module_function :list
 
   # retrieve a Hash of transport schemas, keyed by their name.
   # This uses the Puppet autoloader, provide an environment name as `force_environment`
@@ -46,7 +46,7 @@ module Puppet::ResourceApi::Transport
       Marshal.load(Marshal.dump(transports))
     end
   end
-  module_function :list_all_transports # rubocop:disable Style/AccessModifierDeclarations
+  module_function :list_all_transports
 
   # Loads all schemas using the Puppet Autoloader. This method is clearing the cache and forcing `Kernel.load`, so that the cache is up-to-date.
   def self.load_all_schemas
@@ -73,10 +73,10 @@ module Puppet::ResourceApi::Transport
   def connect(name, connection_info)
     validate(name, connection_info)
     require "puppet/transport/#{name}"
-    class_name = name.split('_').map { |e| e.capitalize }.join
+    class_name = name.split('_').map(&:capitalize).join
     Puppet::Transport.const_get(class_name).new(get_context(name), wrap_sensitive(name, connection_info))
   end
-  module_function :connect # rubocop:disable Style/AccessModifierDeclarations
+  module_function :connect
 
   def inject_device(name, transport)
     transport_wrapper = Puppet::ResourceApi::Transport::Wrapper.new(name, transport)
@@ -87,21 +87,14 @@ module Puppet::ResourceApi::Transport
       Puppet::Util::NetworkDevice.instance_variable_set(:@current, transport_wrapper)
     end
   end
-  module_function :inject_device # rubocop:disable Style/AccessModifierDeclarations
+  module_function :inject_device
 
   def self.validate(name, connection_info)
     require "puppet/transport/schema/#{name}" unless transports.key? name
     transport_schema = transports[name]
-    if transport_schema.nil?
-      raise Puppet::DevError, 'Transport for `%{target}` not registered with `%{environment}`' % {
-        target: name,
-        environment: current_environment_name,
-      }
-    end
+    raise Puppet::DevError, format('Transport for `%<target>s` not registered with `%<environment>s`', target: name, environment: current_environment_name) if transport_schema.nil?
 
-    if connection_info.key?(:"remote-transport")
-      clean_bolt_attributes(transport_schema, connection_info)
-    end
+    clean_bolt_attributes(transport_schema, connection_info) if connection_info.key?(:'remote-transport')
 
     apply_defaults(transport_schema, connection_info)
     message_prefix = 'The connection info provided does not match the Transport Schema'
@@ -133,7 +126,7 @@ module Puppet::ResourceApi::Transport
     context = get_context(transport_schema.name)
     transport_schema.attributes.each do |attr_name, options|
       if options.key?(:default) && connection_info.key?(attr_name) == false
-        context.debug('Using default value for attribute: %{attribute_name}, value: %{default_value}' % { attribute_name: attr_name, default_value: options[:default].inspect })
+        context.debug(format('Using default value for attribute: %<attribute_name>s, value: %<default_value>s', attribute_name: attr_name, default_value: options[:default].inspect))
         connection_info[attr_name] = options[:default]
       end
     end
@@ -161,25 +154,25 @@ module Puppet::ResourceApi::Transport
     context = get_context(transport_schema.name)
 
     # Attributes we expect from bolt, but want to ignore if the transport does not expect them
-    [:uri, :host, :protocol, :user, :port, :password].each do |attribute_name|
+    %i[uri host protocol user port password].each do |attribute_name|
       if connection_info.key?(attribute_name) && !transport_schema.attributes.key?(attribute_name)
-        context.info('Discarding superfluous bolt attribute: %{attribute_name}' % { attribute_name: attribute_name })
+        context.info(format('Discarding superfluous bolt attribute: %<attribute_name>s', attribute_name: attribute_name))
         connection_info.delete(attribute_name)
       end
     end
 
     # Attributes that bolt emits, but we want to ignore if the transport does not expect them
-    ([:name, :path, :query, :"run-on", :"remote-transport", :implementations] + connection_info.keys.select { |k| k.to_s.start_with? 'remote-' }).each do |attribute_name|
+    (%i[name path query run-on remote-transport implementations] + connection_info.keys.select { |k| k.to_s.start_with? 'remote-' }).each do |attribute_name|
       if connection_info.key?(attribute_name) && !transport_schema.attributes.key?(attribute_name)
-        context.debug('Discarding bolt metaparameter: %{attribute_name}' % { attribute_name: attribute_name })
+        context.debug(format('Discarding bolt metaparameter: %<attribute_name>s', attribute_name: attribute_name))
         connection_info.delete(attribute_name)
       end
     end
 
     # remove any other attributes the transport is not prepared to handle
-    connection_info.keys.each do |attribute_name|
+    connection_info.each_key do |attribute_name|
       if connection_info.key?(attribute_name) && !transport_schema.attributes.key?(attribute_name)
-        context.warning('Discarding unknown attribute: %{attribute_name}' % { attribute_name: attribute_name })
+        context.warning(format('Discarding unknown attribute: %<attribute_name>s', attribute_name: attribute_name))
         connection_info.delete(attribute_name)
       end
     end

data/lib/puppet/resource_api/type_definition.rb

@@ -25,12 +25,12 @@ module Puppet::ResourceApi
     end
 
     def validate_schema(definition, attr_key)
-      super(definition, attr_key)
-      [:title, :provider, :alias, :audit, :before, :consume, :export, :loglevel, :noop, :notify, :require, :schedule, :stage, :subscribe, :tag].each do |name|
-        raise Puppet::DevError, 'must not define an attribute called `%{name}`' % { name: name.inspect } if definition[attr_key].key? name
+      super
+      %i[title provider alias audit before consume export loglevel noop notify require schedule stage subscribe tag].each do |name|
+        raise Puppet::DevError, format('must not define an attribute called `%<name>s`', name: name.inspect) if definition[attr_key].key? name
       end
       if definition.key?(:title_patterns) && !definition[:title_patterns].is_a?(Array)
-        raise Puppet::DevError, '`:title_patterns` must be an array, not `%{other_type}`' % { other_type: definition[:title_patterns].class }
+        raise Puppet::DevError, format('`:title_patterns` must be an array, not `%<other_type>s`', other_type: definition[:title_patterns].class)
       end
 
       Puppet::ResourceApi::DataTypeHandling.validate_ensure(definition)
@@ -54,9 +54,7 @@ module Puppet::ResourceApi
     # options: The hash of attribute options, including type, desc, default, and behaviour
     def create_attribute_in(type, attribute_name, param_or_property, parent, options)
       type.send(param_or_property, attribute_name.to_sym, parent: parent) do
-        if options[:desc]
-          desc "#{options[:desc]} (a #{options[:type]})"
-        end
+        desc "#{options[:desc]} (a #{options[:type]})" if options[:desc]
 
         # The initialize method is called when puppet core starts building up
         # type objects. The core passes in a hash of shape { resource:
@@ -70,9 +68,9 @@ module Puppet::ResourceApi
 
         # 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(
+          @rsapi_data_type ||= Puppet::ResourceApi::DataTypeHandling.parse_puppet_type( # rubocop:disable Naming/MemoizedInstanceVariableName
             attribute_name,
-            options[:type],
+            options[:type]
           )
         end
 
@@ -82,7 +80,7 @@ module Puppet::ResourceApi
           self,
           data_type,
           param_or_property,
-          options,
+          options
         )
       end
     end
@@ -101,12 +99,10 @@ module Puppet::ResourceApi
       attributes.each do |name, _options|
         type = @data_type_cache[attributes[name][:type]]
 
-        if resource[name].nil? && !(type.instance_of? Puppet::Pops::Types::POptionalType)
-          missing_attrs << name
-        end
+        missing_attrs << name if resource[name].nil? && !(type.instance_of? Puppet::Pops::Types::POptionalType)
       end
 
-      error_msg = "The following mandatory attributes were not provided:\n    *  " + missing_attrs.join(", \n    *  ")
+      error_msg = "The following mandatory attributes were not provided:\n    *  #{missing_attrs.join(", \n    *  ")}"
       raise Puppet::ResourceError, error_msg if missing_attrs.any?
     end
 
@@ -131,57 +127,54 @@ module Puppet::ResourceApi
     end
 
     def namevars
-      @namevars ||= attributes.select { |_name, options|
+      @namevars ||= attributes.select do |_name, options|
         options.key?(:behaviour) && options[:behaviour] == :namevar
-      }.keys
+      end.keys
     end
 
     def insyncable_attributes
-      @insyncable_attributes ||= attributes.reject { |_name, options|
+      @insyncable_attributes ||= attributes.reject do |_name, options|
         # Only attributes without any behavior are normal Puppet Properties and get insynced
         options.key?(:behaviour)
-      }.keys
+      end.keys
     end
 
     def validate_schema(definition, attr_key)
-      raise Puppet::DevError, '%{type_class} must be a Hash, not `%{other_type}`' % { type_class: self.class.name, other_type: definition.class } unless definition.is_a?(Hash)
+      raise Puppet::DevError, format('%<type_class>s must be a Hash, not `%<other_type>s`', type_class: self.class.name, other_type: definition.class) unless definition.is_a?(Hash)
+
       @attributes = definition[attr_key]
-      raise Puppet::DevError, '%{type_class} must have a name' % { type_class: self.class.name } unless definition.key? :name
-      raise Puppet::DevError, '%{type_class} must have `%{attr_key}`' % { type_class: self.class.name, attrs: attr_key } unless definition.key? attr_key
-      unless attributes.is_a?(Hash)
-        raise Puppet::DevError, '`%{name}.%{attrs}` must be a hash, not `%{other_type}`' % {
-          name: definition[:name], attrs: attr_key, other_type: attributes.class
-        }
-      end
+      raise Puppet::DevError, format('%<type_class>s must have a name', type_class: self.class.name) unless definition.key? :name
+      raise Puppet::DevError, format('%<type_class>s must have `%<attr_key>s`', type_class: self.class.name, attrs: attr_key) unless definition.key? attr_key
+
+      raise Puppet::DevError, format('`%<name>s.%<attrs>s` must be a hash, not `%<other_type>s`', name: definition[:name], attrs: attr_key, other_type: attributes.class) unless attributes.is_a?(Hash)
 
       # fixup desc/docs backwards compatibility
       if definition.key? :docs
-        if definition[:desc]
-          raise Puppet::DevError, '`%{name}` has both `desc` and `docs`, prefer using `desc`' % { name: definition[:name] }
-        end
+        raise Puppet::DevError, format('`%<name>s` has both `desc` and `docs`, prefer using `desc`', name: definition[:name]) if definition[:desc]
+
         definition[:desc] = definition[:docs]
         definition.delete(:docs)
       end
-      Puppet.warning('`%{name}` has no documentation, add it using a `desc` key' % { name: definition[:name] }) unless definition.key? :desc
+      Puppet.warning(format('`%<name>s` has no documentation, add it using a `desc` key', name: definition[:name])) unless definition.key? :desc
 
       attributes.each do |key, attr|
-        raise Puppet::DevError, '`rsapi_custom_insync_trigger` cannot be specified as an attribute; it is reserved for propertyless types with the custom_insync feature' if key == :rsapi_custom_insync_trigger # rubocop:disable Metrics/LineLength
+        raise Puppet::DevError, '`rsapi_custom_insync_trigger` cannot be specified as an attribute; it is reserved for propertyless types with the custom_insync feature' if key == :rsapi_custom_insync_trigger # rubocop:disable Layout/LineLength
         raise Puppet::DevError, "`#{definition[:name]}.#{key}` must be a Hash, not a #{attr.class}" unless attr.is_a? Hash
         raise Puppet::DevError, "`#{definition[:name]}.#{key}` has no type" unless attr.key? :type
-        Puppet.warning('`%{name}.%{key}` has no documentation, add it using a `desc` key' % { name: definition[:name], key: key }) unless attr.key? :desc
+
+        Puppet.warning(format('`%<name>s.%<key>s` has no documentation, add it using a `desc` key', name: definition[:name], key: key)) unless attr.key? :desc
 
         # validate the type by attempting to parse into a puppet type
         @data_type_cache[attributes[key][:type]] ||=
           Puppet::ResourceApi::DataTypeHandling.parse_puppet_type(
             key,
-            attributes[key][:type],
+            attributes[key][:type]
           )
 
         # fixup any weird behavior  ;-)
         next unless attr[:behavior]
-        if attr[:behaviour]
-          raise Puppet::DevError, "the '#{key}' attribute has both a `behavior` and a `behaviour`, only use one"
-        end
+        raise Puppet::DevError, "the '#{key}' attribute has both a `behavior` and a `behaviour`, only use one" if attr[:behaviour]
+
         attr[:behaviour] = attr[:behavior]
         attr.delete(:behavior)
       end
@@ -190,9 +183,7 @@ module Puppet::ResourceApi
     # validates a resource hash against its type schema
     def check_schema(resource, message_prefix = nil)
       namevars.each do |namevar|
-        if resource[namevar].nil?
-          raise Puppet::ResourceError, "`#{name}.get` did not return a value for the `#{namevar}` namevar attribute"
-        end
+        raise Puppet::ResourceError, "`#{name}.get` did not return a value for the `#{namevar}` namevar attribute" if resource[namevar].nil?
       end
 
       message_prefix = 'Provider returned data that does not match the Type Schema' if message_prefix.nil?
@@ -216,12 +207,13 @@ module Puppet::ResourceApi
     end
 
     def notify_schema_errors(message)
-      if Puppet.settings[:strict] == :off
+      case Puppet.settings[:strict]
+      when :off
         Puppet.debug(message)
-      elsif Puppet.settings[:strict] == :warning
+      when :warning
         Puppet::ResourceApi.warning_count += 1
         Puppet.warning(message) if Puppet::ResourceApi.warning_count <= 100 # maximum number of schema warnings to display in a run
-      elsif Puppet.settings[:strict] == :error
+      when :error
         raise Puppet::DevError, message
       end
     end
@@ -240,15 +232,16 @@ module Puppet::ResourceApi
       bad_vals = {}
       resource.each do |key, value|
         next unless attributes[key]
+
         type = @data_type_cache[attributes[key][:type]]
-        is_sensitive = (attributes[key].key?(:sensitive) && (attributes[key][:sensitive] == true))
+        is_sensitive = attributes[key].key?(:sensitive) && (attributes[key][:sensitive] == true)
         error_message = Puppet::ResourceApi::DataTypeHandling.try_validate(
           type,
           value,
-          '',
+          ''
         )
         if is_sensitive
-          bad_vals[key] = '<< redacted value >> ' + error_message unless error_message.nil?
+          bad_vals[key] = "<< redacted value >> #{error_message}" unless error_message.nil?
         else
           bad_vals[key] = "#{value} (#{error_message})" unless error_message.nil?
         end

data/lib/puppet/resource_api/value_creator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Puppet; module ResourceApi; end; end # predeclare the main module # rubocop:disable Style/Documentation,Style/ClassAndModuleChildren
+module Puppet; module ResourceApi; end; end # predeclare the main module # rubocop:disable Style/Documentation
 
 # This module is responsible for setting default and alias values for the
 # resource class.
@@ -36,14 +36,12 @@ module Puppet::ResourceApi::ValueCreator
     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
+    data_type = data_type.type if data_type.instance_of? Puppet::Pops::Types::POptionalType
 
     case data_type
     when Puppet::Pops::Types::PStringType
       # require any string value
-      def_newvalues(attribute_class, param_or_property, %r{})
+      def_newvalues(attribute_class, param_or_property, //)
     when Puppet::Pops::Types::PBooleanType
       def_newvalues(attribute_class, param_or_property, 'true', 'false')
       attribute_class.aliasvalue true, 'true'
@@ -51,7 +49,7 @@ module Puppet::ResourceApi::ValueCreator
       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+$})
+      def_newvalues(attribute_class, param_or_property, /^-?\d+$/)
     when Puppet::Pops::Types::PFloatType, Puppet::Pops::Types::PNumericType
       def_newvalues(attribute_class, param_or_property, Puppet::Pops::Patterns::NUMERIC)
     end

data/lib/puppet/resource_api/version.rb

@@ -2,6 +2,6 @@
 
 module Puppet
   module ResourceApi
-    VERSION = '1.9.0'
+    VERSION = '2.0.0'
   end
 end