puppet-resource_api 1.9.2 → 2.0.1

data/lib/puppet/resource_api/base_context.rb

@@ -19,7 +19,7 @@ class Puppet::ResourceApi::BaseContext
     elsif definition.is_a? Puppet::ResourceApi::BaseTypeDefinition
       @type = definition
     else
-      raise ArgumentError, 'BaseContext requires definition to be a child of Puppet::ResourceApi::BaseTypeDefinition, not <%{actual_type}>' % { actual_type: definition.class }
+      raise ArgumentError, format('BaseContext requires definition to be a child of Puppet::ResourceApi::BaseTypeDefinition, not <%<actual_type>s>', actual_type: definition.class)
     end
   end
 
@@ -44,7 +44,7 @@ class Puppet::ResourceApi::BaseContext
     type.feature?(feature)
   end
 
-  [:debug, :info, :notice, :warning, :err].each do |level|
+  %i[debug info notice warning err].each do |level|
     define_method(level) do |*args|
       if args.length == 1
         message = "#{@context || @type.name}: #{args.last}"
@@ -58,7 +58,7 @@ class Puppet::ResourceApi::BaseContext
     end
   end
 
-  [:creating, :updating, :deleting].each do |method|
+  %i[creating updating deleting].each do |method|
     define_method(method) do |titles, message: method.to_s.capitalize, &block|
       start_time = Time.now
       setup_context(titles, message)
@@ -92,6 +92,7 @@ class Puppet::ResourceApi::BaseContext
 
   def processing(title, is, should, message = 'Processing')
     raise "#{__method__} only accepts a single resource title" if title.respond_to?(:each)
+
     start_time = Time.now
     setup_context(title, message)
     begin
@@ -106,7 +107,7 @@ class Puppet::ResourceApi::BaseContext
     end
   end
 
-  [:created, :updated, :deleted].each do |method|
+  %i[created updated deleted].each do |method|
     define_method(method) do |titles, message: method.to_s.capitalize|
       notice("#{message}: #{titles}")
     end
@@ -114,11 +115,13 @@ class Puppet::ResourceApi::BaseContext
 
   def processed(title, is, should)
     raise "#{__method__} only accepts a single resource title" if title.respond_to?(:each)
+
     notice("Processed #{title} from #{is} to #{should}")
   end
 
   def attribute_changed(title, attribute, is, should, message: nil)
     raise "#{__method__} only accepts a single resource title" if title.respond_to?(:each)
+
     printable_is = 'nil'
     printable_should = 'nil'
     if is
@@ -156,7 +159,7 @@ class Puppet::ResourceApi::BaseContext
   private
 
   def format_titles(titles)
-    if titles.length.zero? && !titles.is_a?(String)
+    if titles.empty? && !titles.is_a?(String)
       @type.name
     else
       "#{@type.name}[#{[titles].flatten.compact.join(', ')}]"
@@ -169,7 +172,8 @@ class Puppet::ResourceApi::BaseContext
   end
 
   def format_seconds(seconds)
-    return '%.6f' % seconds if seconds < 1
-    '%.2f' % seconds
+    return format('%.6f', seconds) if seconds < 1
+
+    format('%.2f', seconds)
   end
 end

data/lib/puppet/resource_api/data_type_handling.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 used to handle data inside types, contains methods for munging
 # and validation of the type values.
@@ -20,12 +20,12 @@ module Puppet::ResourceApi::DataTypeHandling
   # @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)
+  def self.mungify(type, value, error_msg_prefix, unpack_strings = false) # rubocop:disable Style/OptionalBooleanParameter
     cleaned_value = mungify_core(
       type,
       value,
       error_msg_prefix,
-      unpack_strings,
+      unpack_strings
     )
     validate(type, cleaned_value, error_msg_prefix)
     cleaned_value
@@ -42,13 +42,14 @@ module Puppet::ResourceApi::DataTypeHandling
   # @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)
+  def self.mungify_core(type, value, error_msg_prefix, unpack_strings = false) # rubocop:disable Style/OptionalBooleanParameter
     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
@@ -77,18 +78,14 @@ module Puppet::ResourceApi::DataTypeHandling
         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
+        value = conversions.map { |c| c[0] } if conversions.all? { |c| c[1].nil? }
       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.is_a?(String) && (value.match?(%r{^-?\d+$}) || value.match?(Puppet::Pops::Patterns::NUMERIC))
-        value = Puppet::Pops::Utils.to_n(value)
-      end
+      value = Puppet::Pops::Utils.to_n(value) if value.is_a?(String) && (value.match?(/^-?\d+$/) || value.match?(Puppet::Pops::Patterns::NUMERIC))
     when Puppet::Pops::Types::PEnumType,
          Puppet::Pops::Types::PStringType,
          Puppet::Pops::Types::PPatternType
@@ -109,9 +106,7 @@ module Puppet::ResourceApi::DataTypeHandling
       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
+      return [nil, ambiguous_error_msg(error_msg_prefix, value, type)] if conversion_results.length > 1
 
       # try to interpret as string
       return try_mungify(string_type, value, error_msg_prefix) if string_type
@@ -121,6 +116,7 @@ module Puppet::ResourceApi::DataTypeHandling
 
     error_msg = try_validate(type, value, error_msg_prefix)
     return [nil, error_msg] if error_msg # an error
+
     [value, nil]                         # match
   end
 
@@ -146,7 +142,7 @@ module Puppet::ResourceApi::DataTypeHandling
   # @private
   def self.ambiguous_error_msg(error_msg_prefix, value, type)
     "#{error_msg_prefix} #{value.inspect} is not unabiguously convertable to " \
-    "#{type}"
+      "#{type}"
   end
 
   # Validates the `value` against the specified `type`.
@@ -171,16 +167,16 @@ module Puppet::ResourceApi::DataTypeHandling
 
     # an error :-(
     inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value)
-    error_msg = Puppet::Pops::Types::TypeMismatchDescriber.new.describe_mismatch(
+    Puppet::Pops::Types::TypeMismatchDescriber.new.describe_mismatch(
       error_msg_prefix,
       type,
-      inferred_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])
 
@@ -199,9 +195,9 @@ module Puppet::ResourceApi::DataTypeHandling
     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}"
+                            "`#{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}"
+                            "`#{type}` is not recognised: #{e.message}"
   end
 end

data/lib/puppet/resource_api/glue.rb

@@ -3,6 +3,7 @@
 require 'yaml'
 
 module Puppet; end # rubocop:disable Style/Documentation
+
 module Puppet::ResourceApi
   # A trivial class to provide the functionality required to push data through the existing type/provider parts of puppet
   class ResourceShim
@@ -45,7 +46,7 @@ module Puppet::ResourceApi
     # Convert our resource to yaml for Hiera purposes.
     def to_hierayaml
       attributes = Hash[filtered_keys.map { |k| [k.to_s, values[k]] }]
-      YAML.dump('type' => { title => attributes }).split("\n").drop(2).join("\n") + "\n"
+      "#{YAML.dump('type' => { title => attributes }).split("\n").drop(2).join("\n")}\n"
     end
 
     def to_json(*)
@@ -70,12 +71,8 @@ module Puppet::ResourceApi
   class MonkeyHash < Hash
     def <=>(other)
       result = self.class.name <=> other.class.name
-      if result.zero?
-        result = keys.sort <=> other.keys.sort
-      end
-      if result.zero?
-        result = keys.sort.map { |k| self[k] } <=> other.keys.sort.map { |k| other[k] }
-      end
+      result = keys.sort <=> other.keys.sort if result.zero?
+      result = keys.sort.map { |k| self[k] } <=> other.keys.sort.map { |k| other[k] } if result.zero?
       result
     end
   end

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