puppet 8.3.1-universal-darwin → 8.4.0-universal-darwin

data/lib/puppet/plugins/syntax_checkers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Puppet::Plugins
 module SyntaxCheckers
-
   # The lookup **key** for the multibind containing syntax checkers used to syntax check embedded string in non
   # puppet DSL syntax.
   # @api public

data/lib/puppet/plugins.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # The Puppet Plugins module defines extension points where plugins can be configured
 # to add or modify puppet's behavior. See the respective classes in this module for more
 # details.

data/lib/puppet/pops/adaptable.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Adaptable is a mix-in module that adds adaptability to a class.
 # This means that an adapter can
 # associate itself with an instance of the class and store additional data/have behavior.
@@ -188,10 +189,11 @@ module Adaptable
     # Adapter#instance_var_name and then cached.
     # @return [String] the instance variable name for _name_
     # @api private
-    #
+    # rubocop:disable Naming/MemoizedInstanceVariableName
     def self.self_attr_name
       @attr_name_sym ||= :"@#{instance_var_name(type_name)}"
     end
+    # rubocop:enable Naming/MemoizedInstanceVariableName
   end
 end
 end

data/lib/puppet/pops/adapters.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 # The Adapters module contains adapters for Documentation, Origin, SourcePosition, and Loader.
 #
 module Puppet::Pops
 module Adapters
-
   class ObjectIdCacheAdapter < Puppet::Pops::Adaptable::Adapter
     attr_accessor :cache
 
@@ -125,6 +125,7 @@ module Adapters
     def self.loader_name_by_source(environment, instance, file)
       file = instance.file if file.nil?
       return nil if file.nil? || EMPTY_STRING == file
+
       pn_adapter = PathsAndNameCacheAdapter.adapt(environment)
       dir = File.dirname(file)
       pn_adapter.cache.fetch(dir) do |key|
@@ -137,6 +138,7 @@ module Adapters
     # @api private
     def self.find_module_for_dir(environment, paths, dir)
       return nil if dir.nil?
+
       file_path = Pathname.new(dir)
       paths.each do |path|
         begin

data/lib/puppet/pops/evaluator/access_operator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Evaluator
 # AccessOperator handles operator []
@@ -43,36 +44,36 @@ class AccessOperator
   def access_String(o, scope, keys)
     keys.flatten!
     result = case keys.size
-    when 0
-      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
-    when 1
-      # Note that Ruby 1.8.7 requires a length of 1 to produce a String
-      k1 = Utils.to_n(keys[0])
-      bad_string_access_key_type(o, 0, k1.nil? ? keys[0] : k1) unless k1.is_a?(Integer)
-      k2 = 1
-      k1 = k1 < 0 ? o.length + k1 : k1           # abs pos
-      # if k1 is outside, a length of 1 always produces an empty string
-      if k1 < 0
-        EMPTY_STRING
-      else
-        o[ k1, k2 ]
-      end
-    when 2
-      k1 = Utils.to_n(keys[0])
-      k2 = Utils.to_n(keys[1])
-      [k1, k2].each_with_index { |k,i| bad_string_access_key_type(o, i, k.nil? ? keys[i] : k) unless k.is_a?(Integer) }
-
-      k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
-      k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
-      # if k1 is outside, adjust to first position, and adjust length
-      if k1 < 0
-        k2 = k2 + k1
-        k1 = 0
-      end
-      o[ k1, k2 ]
-    else
-      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
-    end
+             when 0
+               fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+             when 1
+               # Note that Ruby 1.8.7 requires a length of 1 to produce a String
+               k1 = Utils.to_n(keys[0])
+               bad_string_access_key_type(o, 0, k1.nil? ? keys[0] : k1) unless k1.is_a?(Integer)
+               k2 = 1
+               k1 = k1 < 0 ? o.length + k1 : k1 # abs pos
+               # if k1 is outside, a length of 1 always produces an empty string
+               if k1 < 0
+                 EMPTY_STRING
+               else
+                 o[ k1, k2 ]
+               end
+             when 2
+               k1 = Utils.to_n(keys[0])
+               k2 = Utils.to_n(keys[1])
+               [k1, k2].each_with_index { |k,i| bad_string_access_key_type(o, i, k.nil? ? keys[i] : k) unless k.is_a?(Integer) }
+
+               k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
+               k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
+               # if k1 is outside, adjust to first position, and adjust length
+               if k1 < 0
+                 k2 = k2 + k1
+                 k1 = 0
+               end
+               o[ k1, k2 ]
+             else
+               fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+             end
     # Specified as: an index outside of range, or empty result == empty string
     (result.nil? || result.empty?) ? EMPTY_STRING : result
   end
@@ -126,7 +127,6 @@ class AccessOperator
     end
   end
 
-
   # Evaluates <hsh>[] with support for one or more arguments. If more than one argument is used, the result
   # is an array with each lookup.
   # @note
@@ -183,12 +183,14 @@ class AccessOperator
   def access_PTimestampType(o, scope, keys)
     keys.flatten!
     fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>0, :max => 2, :actual => keys.size) if keys.size > 2
+
     Types::TypeFactory.timestamp(*keys)
   end
 
   def access_PTimespanType(o, scope, keys)
     keys.flatten!
     fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>0, :max => 2, :actual => keys.size) if keys.size > 2
+
     Types::TypeFactory.timespan(*keys)
   end
 
@@ -210,6 +212,7 @@ class AccessOperator
       unless keys.size == 2
         fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>2, :max => 2, :actual => keys.size)
       end
+
       unless keys[1].is_a?(Types::PAnyType)
         bad_type_specialization_key_type(o, 1, k, Types::PAnyType)
       end
@@ -248,6 +251,7 @@ class AccessOperator
     unless size.between?(min, max || Float::INFINITY)
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>1, :max => max, :actual => keys.size)
     end
+
     keys.each_with_index do |k, i|
       unless allowed_classes.any? {|clazz| k.is_a?(clazz) }
         bad_type_specialization_key_type(o, i, k, *allowed_classes)
@@ -257,17 +261,17 @@ class AccessOperator
 
   def bad_access_key_type(lhs, key_index, actual, *expected_classes)
     fail(Issues::BAD_SLICE_KEY_TYPE, @semantic.keys[key_index], {
-      :left_value => lhs,
-      :actual => bad_key_type_name(actual),
-      :expected_classes => expected_classes
-    })
+           :left_value => lhs,
+           :actual => bad_key_type_name(actual),
+           :expected_classes => expected_classes
+         })
   end
 
   def bad_string_access_key_type(lhs, key_index, actual)
     fail(Issues::BAD_STRING_SLICE_KEY_TYPE, @semantic.keys[key_index], {
-      :left_value => lhs,
-      :actual_type => bad_key_type_name(actual),
-    })
+           :left_value => lhs,
+           :actual_type => bad_key_type_name(actual),
+         })
   end
 
   def bad_key_type_name(actual)
@@ -285,9 +289,9 @@ class AccessOperator
     label_provider = Model::ModelLabelProvider.new()
     expected = expected_classes.map {|c| label_provider.label(c) }.join(' or ')
     fail(Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[key_index], {
-      :type => type,
-      :message => _("Cannot use %{key} where %{expected} is expected") % { key: bad_key_type_name(actual), expected: expected }
-    })
+           :type => type,
+           :message => _("Cannot use %{key} where %{expected} is expected") % { key: bad_key_type_name(actual), expected: expected }
+         })
   end
 
   def access_PPatternType(o, scope, keys)
@@ -303,6 +307,7 @@ class AccessOperator
       unless Types::PURIType::TYPE_URI_PARAM_TYPE.instance?(param)
         fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'URI-Type', :actual => param.class})
       end
+
       Types::PURIType.new(param)
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'URI-Type', :min => 1, :actual => keys.size})
@@ -333,6 +338,7 @@ class AccessOperator
       unless type.is_a?(Types::PAnyType)
         fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Sensitive-Type', :actual => type.class})
       end
+
       Types::PSensitiveType.new(type)
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Sensitive-Type', :min => 1, :actual => keys.size})
@@ -388,6 +394,7 @@ class AccessOperator
       unless keys[0].is_a?(Types::PAnyType)
         fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Type-Type', :actual => keys[0].class})
       end
+
       Types::PTypeType.new(keys[0])
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Type-Type', :min => 1, :actual => keys.size})
@@ -398,6 +405,7 @@ class AccessOperator
     unless keys[0].is_a?(Types::PAnyType)
       fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Init-Type', :actual => keys[0].class})
     end
+
     Types::TypeFactory.init(*keys)
   end
 
@@ -407,6 +415,7 @@ class AccessOperator
       unless keys[0].is_a?(Types::PAnyType)
         fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Iterable-Type', :actual => keys[0].class})
       end
+
       Types::PIterableType.new(keys[0])
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Iterable-Type', :min => 1, :actual => keys.size})
@@ -419,6 +428,7 @@ class AccessOperator
       unless keys[0].is_a?(Types::PAnyType)
         fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Iterator-Type', :actual => keys[0].class})
       end
+
       Types::PIteratorType.new(keys[0])
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Iterator-Type', :min => 1, :actual => keys.size})
@@ -437,9 +447,10 @@ class AccessOperator
     unless keys.size.between?(1, 2)
       fail(Issues::BAD_INTEGER_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
+
     keys.each_with_index do |x, index|
       fail(Issues::BAD_INTEGER_SLICE_TYPE, @semantic.keys[index],
-        {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
+           {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
     end
     Types::PIntegerType.new(*keys)
   end
@@ -449,9 +460,10 @@ class AccessOperator
     unless keys.size.between?(1, 2)
       fail(Issues::BAD_FLOAT_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
+
     keys.each_with_index do |x, index|
       fail(Issues::BAD_FLOAT_SLICE_TYPE, @semantic.keys[index],
-        {:actual => x.class}) unless (x.is_a?(Float) || x.is_a?(Integer) || x == :default)
+           {:actual => x.class}) unless (x.is_a?(Float) || x.is_a?(Integer) || x == :default)
     end
     from, to = keys
     from = from == :default || from.nil? ? nil : Float(from)
@@ -484,8 +496,8 @@ class AccessOperator
       size_t = collection_size_t(2, keys[2], keys[3])
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {
-        :base_type => 'Hash-Type', :min => 2, :max => 4, :actual => keys.size
-      })
+             :base_type => 'Hash-Type', :min => 2, :max => 4, :actual => keys.size
+           })
     end
     Types::PHashType.new(keys[0], keys[1], size_t)
   end
@@ -500,7 +512,7 @@ class AccessOperator
       size_t = collection_size_t(0, keys[0], keys[1])
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic,
-        {:base_type => 'Collection-Type', :min => 1, :max => 2, :actual => keys.size})
+           {:base_type => 'Collection-Type', :min => 1, :max => 2, :actual => keys.size})
     end
     Types::PCollectionType.new(size_t)
   end
@@ -514,6 +526,7 @@ class AccessOperator
       unless keys[0].is_a?(Types::PAnyType)
         fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
       end
+
       type = keys[0]
       size_t = nil
     when 2
@@ -533,7 +546,7 @@ class AccessOperator
       end
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic,
-        {:base_type => 'Array-Type', :min => 1, :max => 3, :actual => keys.size})
+           {:base_type => 'Array-Type', :min => 1, :max => 3, :actual => keys.size})
     end
     Types::PArrayType.new(type, size_t)
   end
@@ -545,7 +558,7 @@ class AccessOperator
     else
       keys.each_with_index do |x, index|
         fail(Issues::BAD_COLLECTION_SLICE_TYPE, @semantic.keys[start_index + index],
-          {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
+             {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
       end
       Types::PIntegerType.new(*keys)
     end
@@ -584,7 +597,7 @@ class AccessOperator
 
     if keys.size == 0
       fail(Issues::BAD_TYPE_SLICE_ARITY, blamed,
-        :base_type => o.to_s, :min => 1, :max => -1, :actual => 0)
+           :base_type => o.to_s, :min => 1, :max => -1, :actual => 0)
     end
 
     # Must know which concrete resource type to operate on in all cases.
@@ -592,15 +605,15 @@ class AccessOperator
     # type_name is LHS type_name if set, else the first given arg
     type_name = o.type_name || Types::TypeFormatter.singleton.capitalize_segments(keys.shift)
     type_name = case type_name
-    when Types::PResourceType
-      type_name.type_name
-    when String
-      type_name
-    else
-      # blame given left expression if it defined the type, else the first given key expression
-      blame = o.type_name.nil? ? @semantic.keys[0] : @semantic.left_expr
-      fail(Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => bad_key_type_name(type_name)})
-    end
+                when Types::PResourceType
+                  type_name.type_name
+                when String
+                  type_name
+                else
+                  # blame given left expression if it defined the type, else the first given key expression
+                  blame = o.type_name.nil? ? @semantic.keys[0] : @semantic.left_expr
+                  fail(Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => bad_key_type_name(type_name)})
+                end
 
     # type name must conform
     if type_name !~ Patterns::CLASSREF_EXT
@@ -634,22 +647,21 @@ class AccessOperator
       result = keys.map do |k|
         unless is_parameter_of_resource?(scope, resource, k)
           fail(Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
-            {:type_name => o.type_name, :title => o.title, :param_name=>k})
+               {:type_name => o.type_name, :title => o.title, :param_name=>k})
         end
         get_resource_parameter_value(scope, resource, k)
       end
       return result_type_array ? result : result.pop
     end
 
-
     keys = [:no_title] if keys.size < 1 # if there was only a type_name and it was consumed
     result = keys.each_with_index.map do |t, i|
       unless t.is_a?(String) || t == :no_title
         index = keys_orig_size != keys.size ? i+1 : i
         fail(Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[index], {
-          :type => o,
-          :message => "Cannot use #{bad_key_type_name(t)} where a resource title String is expected"
-        })
+               :type => o,
+               :message => "Cannot use #{bad_key_type_name(t)} where a resource title String is expected"
+             })
       end
 
       Types::PResourceType.new(type_name, t == :no_title ? nil : t)
@@ -666,7 +678,7 @@ class AccessOperator
 
     if keys_orig_size == 0
       fail(Issues::BAD_TYPE_SLICE_ARITY, blamed,
-        :base_type => o.to_s, :min => 1, :max => -1, :actual => 0)
+           :base_type => o.to_s, :min => 1, :max => -1, :actual => 0)
     end
 
     # The result is an array if multiple classnames are given, or if classnames are specified with an array
@@ -688,11 +700,13 @@ class AccessOperator
     if o.class_name.nil?
       result = keys.each_with_index.map do |c, i|
         fail(Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c}) unless c.is_a?(String)
+
         name = c.downcase
         # Remove leading '::' since all references are global, and 3x runtime does the wrong thing
         name = name[2..-1] if name[0,2] == NS
 
         fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c}) unless name =~ Patterns::NAME
+
         Types::PClassType.new(name)
       end
     else
@@ -704,7 +718,7 @@ class AccessOperator
             get_resource_parameter_value(scope, resource, k)
           else
             fail(Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
-              {:type_name => 'Class', :title => o.class_name, :param_name=>k})
+                 {:type_name => 'Class', :title => o.class_name, :param_name=>k})
           end
         end
       else

data/lib/puppet/pops/evaluator/callable_signature.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # CallableSignature
 # ===
 # A CallableSignature describes how something callable expects to be called.
@@ -7,7 +8,6 @@
 # @api public
 #
 class Puppet::Pops::Evaluator::CallableSignature
-
   # Returns the names of the parameters as an array of strings. This does not include the name
   # of an optional block parameter.
   #