puppet-resource_api 1.9.2 → 2.0.1

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.2'
+    VERSION = '2.0.1'
   end
 end