puppet 8.4.0-universal-darwin → 8.5.1-universal-darwin

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

@@ -34,7 +34,7 @@ class AccessOperator
       access_func = type['[]']
       return access_func.invoke(o, scope, keys) unless access_func.nil?
     end
-    fail(Issues::OPERATOR_NOT_APPLICABLE, @semantic.left_expr, :operator=>'[]', :left_value => o)
+    fail(Issues::OPERATOR_NOT_APPLICABLE, @semantic.left_expr, :operator => '[]', :left_value => o)
   end
 
   def access_Binary(o, scope, keys)
@@ -45,7 +45,7 @@ class AccessOperator
     keys.flatten!
     result = case keys.size
              when 0
-               fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+               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])
@@ -56,12 +56,12 @@ class AccessOperator
                if k1 < 0
                  EMPTY_STRING
                else
-                 o[ k1, k2 ]
+                 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, 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)
@@ -70,9 +70,9 @@ class AccessOperator
                  k2 = k2 + k1
                  k1 = 0
                end
-               o[ k1, k2 ]
+               o[k1, k2]
              else
-               fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+               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
@@ -84,7 +84,7 @@ class AccessOperator
     keys.flatten!
     unless keys.size == 1
       blamed = keys.size == 0 ? @semantic : @semantic.keys[1]
-      fail(Issues::BAD_TYPE_SLICE_ARITY, blamed, :base_type => o, :min=>1, :actual => keys.size)
+      fail(Issues::BAD_TYPE_SLICE_ARITY, blamed, :base_type => o, :min => 1, :actual => keys.size)
     end
     assert_keys(keys, o, 1, 1, String, Regexp)
     Types::TypeFactory.regexp(*keys)
@@ -96,7 +96,7 @@ class AccessOperator
     keys.flatten!
     case keys.size
     when 0
-      fail(Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, { :actual => keys.size })
     when 1
       key = coerce_numeric(keys[0], @semantic.keys[0], scope)
       unless key.is_a?(Integer)
@@ -108,7 +108,7 @@ class AccessOperator
       k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
       k2 = coerce_numeric(keys[1], @semantic.keys[1], scope)
 
-      [k1, k2].each_with_index { |k,i| bad_access_key_type(o, i, k, Integer) unless k.is_a?(Integer) }
+      [k1, k2].each_with_index { |k, i| bad_access_key_type(o, i, k, Integer) unless k.is_a?(Integer) }
 
       # Help confused Ruby do the right thing (it truncates to the right, but negative index + length can never overlap
       # the available range.
@@ -120,10 +120,10 @@ class AccessOperator
         k1 = 0
       end
       # Help ruby always return empty array when asking for a sub array
-      result = o[ k1, k2 ]
+      result = o[k1, k2]
       result.nil? ? [] : result
     else
-      fail(Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, { :actual => keys.size })
     end
   end
 
@@ -140,7 +140,7 @@ class AccessOperator
     end
     case result.size
     when 0
-      fail(Issues::BAD_HASH_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_HASH_SLICE_ARITY, @semantic.left_expr, { :actual => keys.size })
     when 1
       result.pop
     else
@@ -182,14 +182,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
+    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
+    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,7 +210,7 @@ class AccessOperator
   def access_PCallableType(o, scope, keys)
     if keys.size > 0 && keys[0].is_a?(Array)
       unless keys.size == 2
-        fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>2, :max => 2, :actual => keys.size)
+        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)
@@ -233,7 +233,7 @@ class AccessOperator
     when 2
       size_t = collection_size_t(0, keys[0], keys[1])
     else
-      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic, {:actual => keys.size})
+      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic, { :actual => keys.size })
     end
     Types::TypeFactory.string(size_t)
   end
@@ -249,11 +249,11 @@ class AccessOperator
   def assert_keys(keys, o, min, max, *allowed_classes)
     size = keys.size
     unless size.between?(min, max || Float::INFINITY)
-      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>1, :max => max, :actual => keys.size)
+      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) }
+      unless allowed_classes.any? { |clazz| k.is_a?(clazz) }
         bad_type_specialization_key_type(o, i, k, *allowed_classes)
       end
     end
@@ -287,7 +287,7 @@ class AccessOperator
 
   def bad_type_specialization_key_type(type, key_index, actual, *expected_classes)
     label_provider = Model::ModelLabelProvider.new()
-    expected = expected_classes.map {|c| label_provider.label(c) }.join(' or ')
+    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 }
@@ -305,12 +305,12 @@ class AccessOperator
     if keys.size == 1
       param = keys[0]
       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})
+        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})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, { :base_type => 'URI-Type', :min => 1, :actual => keys.size })
     end
   end
 
@@ -322,12 +322,12 @@ class AccessOperator
         if type.is_a?(String)
           type = Types::TypeFactory.string(type)
         else
-          fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => type.class})
+          fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], { :base_type => 'Optional-Type', :actual => type.class })
         end
       end
       Types::POptionalType.new(type)
     else
-      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Optional-Type', :min => 1, :actual => keys.size})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, { :base_type => 'Optional-Type', :min => 1, :actual => keys.size })
     end
   end
 
@@ -336,12 +336,12 @@ class AccessOperator
     if keys.size == 1
       type = keys[0]
       unless type.is_a?(Types::PAnyType)
-        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Sensitive-Type', :actual => type.class})
+        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})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, { :base_type => 'Sensitive-Type', :min => 1, :actual => keys.size })
     end
   end
 
@@ -349,12 +349,10 @@ class AccessOperator
     keys.flatten!
     if o.resolved? && !o.name.nil?
       Types::PObjectTypeExtension.create(o, keys)
+    elsif keys.size == 1
+      Types::TypeFactory.object(keys[0])
     else
-      if keys.size == 1
-        Types::TypeFactory.object(keys[0])
-      else
-        fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Object-Type', :min => 1, :actual => keys.size})
-      end
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, { :base_type => 'Object-Type', :min => 1, :actual => keys.size })
     end
   end
 
@@ -363,7 +361,7 @@ class AccessOperator
     if keys.size == 1
       Types::TypeFactory.type_set(keys[0])
     else
-      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'TypeSet-Type', :min => 1, :actual => keys.size})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, { :base_type => 'TypeSet-Type', :min => 1, :actual => keys.size })
     end
   end
 
@@ -378,13 +376,13 @@ class AccessOperator
       when String
         type = Types::TypeFactory.string(type)
       when Types::PAnyType
-        type = nil if type.class == Types::PAnyType
+        type = nil if type.instance_of?(Types::PAnyType)
       else
-        fail(Issues::BAD_NOT_UNDEF_SLICE_TYPE, @semantic.keys[0], {:base_type => 'NotUndef-Type', :actual => type.class})
+        fail(Issues::BAD_NOT_UNDEF_SLICE_TYPE, @semantic.keys[0], { :base_type => 'NotUndef-Type', :actual => type.class })
       end
       Types::TypeFactory.not_undef(type)
     else
-      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'NotUndef-Type', :min => 0, :max => 1, :actual => keys.size})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, { :base_type => 'NotUndef-Type', :min => 0, :max => 1, :actual => keys.size })
     end
   end
 
@@ -392,18 +390,18 @@ class AccessOperator
     keys.flatten!
     if keys.size == 1
       unless keys[0].is_a?(Types::PAnyType)
-        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Type-Type', :actual => keys[0].class})
+        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})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, { :base_type => 'Type-Type', :min => 1, :actual => keys.size })
     end
   end
 
   def access_PInitType(o, scope, keys)
     unless keys[0].is_a?(Types::PAnyType)
-      fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Init-Type', :actual => keys[0].class})
+      fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], { :base_type => 'Init-Type', :actual => keys[0].class })
     end
 
     Types::TypeFactory.init(*keys)
@@ -413,12 +411,12 @@ class AccessOperator
     keys.flatten!
     if keys.size == 1
       unless keys[0].is_a?(Types::PAnyType)
-        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Iterable-Type', :actual => keys[0].class})
+        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})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, { :base_type => 'Iterable-Type', :min => 1, :actual => keys.size })
     end
   end
 
@@ -426,12 +424,12 @@ class AccessOperator
     keys.flatten!
     if keys.size == 1
       unless keys[0].is_a?(Types::PAnyType)
-        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Iterator-Type', :actual => keys[0].class})
+        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})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, { :base_type => 'Iterator-Type', :min => 1, :actual => keys.size })
     end
   end
 
@@ -445,12 +443,12 @@ class AccessOperator
   def access_PIntegerType(o, scope, keys)
     keys.flatten!
     unless keys.size.between?(1, 2)
-      fail(Issues::BAD_INTEGER_SLICE_ARITY, @semantic, {:actual => keys.size})
+      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
@@ -458,12 +456,12 @@ class AccessOperator
   def access_PFloatType(o, scope, keys)
     keys.flatten!
     unless keys.size.between?(1, 2)
-      fail(Issues::BAD_FLOAT_SLICE_ARITY, @semantic, {:actual => keys.size})
+      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)
@@ -481,9 +479,9 @@ class AccessOperator
       return Types::PHashType.new(nil, nil, Types::PIntegerType.new(*keys))
     end
 
-    keys[0,2].each_with_index do |k, index|
+    keys[0, 2].each_with_index do |k, index|
       unless k.is_a?(Types::PAnyType)
-        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[index], {:base_type => 'Hash-Type', :actual => k.class})
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[index], { :base_type => 'Hash-Type', :actual => k.class })
       end
     end
     case keys.size
@@ -512,7 +510,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
@@ -524,7 +522,7 @@ class AccessOperator
     case keys.size
     when 1
       unless keys[0].is_a?(Types::PAnyType)
-        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], { :base_type => 'Array-Type', :actual => keys[0].class })
       end
 
       type = keys[0]
@@ -542,11 +540,11 @@ class AccessOperator
         size_t = collection_size_t(1, keys[1], keys[2])
         type = keys[0]
       else
-        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], { :base_type => 'Array-Type', :actual => keys[0].class })
       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
@@ -558,7 +556,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
@@ -577,7 +575,7 @@ class AccessOperator
 
   # If a type reference is encountered here, it's an error
   def access_PTypeReferenceType(o, scope, keys)
-    fail(Issues::UNKNOWN_RESOURCE_TYPE, @semantic, {:type_name => o.type_string })
+    fail(Issues::UNKNOWN_RESOURCE_TYPE, @semantic, { :type_name => o.type_string })
   end
 
   # A Resource can create a new more specific Resource type, and/or an array of resource types
@@ -612,12 +610,12 @@ class AccessOperator
                 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)})
+                  fail(Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, { :actual => bad_key_type_name(type_name) })
                 end
 
     # type name must conform
     if type_name !~ Patterns::CLASSREF_EXT
-      fail(Issues::ILLEGAL_CLASSREF, blamed, {:name=>type_name})
+      fail(Issues::ILLEGAL_CLASSREF, blamed, { :name => type_name })
     end
 
     # The result is an array if multiple titles are given, or if titles are specified with an array
@@ -641,13 +639,13 @@ class AccessOperator
       # lookup resource and return one or more parameter values
       resource = find_resource(scope, o.type_name, o.title)
       unless resource
-        fail(Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => o.type_name, :title => o.title})
+        fail(Issues::UNKNOWN_RESOURCE, @semantic, { :type_name => o.type_name, :title => o.title })
       end
 
       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
@@ -657,7 +655,7 @@ class AccessOperator
     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
+        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"
@@ -699,13 +697,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)
+        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
+        name = name[2..] if name[0, 2] == NS
 
-        fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c}) unless name =~ Patterns::NAME
+        fail(Issues::ILLEGAL_NAME, @semantic.keys[i], { :name => c }) unless name =~ Patterns::NAME
 
         Types::PClassType.new(name)
       end
@@ -718,11 +716,11 @@ 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
-        fail(Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => 'Class', :title => o.class_name})
+        fail(Issues::UNKNOWN_RESOURCE, @semantic, { :type_name => 'Class', :title => o.class_name })
       end
     end
 

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

@@ -163,7 +163,7 @@ module Evaluator
     CLOSURE_NAME = 'lambda'
 
     # @api public
-    def closure_name()
+    def closure_name
       CLOSURE_NAME
     end
 
@@ -253,20 +253,18 @@ module Evaluator
                 # correct non array default value
                 value = [value]
               end
-            else
+            elsif param_captures
               # not given, does not have default
-              if param_captures
-                # default for captures rest is an empty array
-                value = []
-              else
-                @evaluator.fail(Issues::MISSING_REQUIRED_PARAMETER, parameter, { :param_name => parameter.name })
-              end
+              value = []
+            # default for captures rest is an empty array
+            else
+              @evaluator.fail(Issues::MISSING_REQUIRED_PARAMETER, parameter, { :param_name => parameter.name })
             end
           else
             given_argument = args[index]
             if param_captures
               # get excess arguments
-              value = args[(parameter_count-1)..-1]
+              value = args[(parameter_count - 1)..]
               # If the input was a single nil, or undef, and there is a default, use the default
               # This supports :undef in case it was used in a 3x data structure and it is passed as an arg
               #
@@ -285,7 +283,7 @@ module Evaluator
       end
     end
 
-    def create_callable_type()
+    def create_callable_type
       types = []
       from = 0
       to = 0
@@ -361,7 +359,7 @@ module Evaluator
 
     # Produces information about parameters compatible with a 4x Function (which can have multiple signatures)
     def signatures
-      [ self ]
+      [self]
     end
 
     ANY_NUMBER_RANGE = [0, Float::INFINITY]

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

@@ -28,7 +28,7 @@ class CollectorTransformer
 
     if !o.operations.empty?
       overrides = {
-        :parameters => o.operations.map{ |x| @@evaluator.evaluate(x, scope)}.flatten,
+        :parameters => o.operations.map { |x| @@evaluator.evaluate(x, scope) }.flatten,
         :file => o.file,
         :line => o.line,
         :source => scope.source,
@@ -101,7 +101,7 @@ class CollectorTransformer
         if right_code.is_a?(Array)
           tags = right_code
         else
-          tags = [ right_code ]
+          tags = [right_code]
         end
         tags = tags.collect do |t|
           raise ArgumentError, _('Cannot transform a number to a tag') if t.is_a?(Numeric)

data/lib/puppet/pops/evaluator/collectors/abstract_collector.rb

@@ -63,7 +63,7 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
 
     return false if objects.empty?
 
-    objects.reduce(@collected) { |c,o| c[o.ref]=o; c }
+    objects.each_with_object(@collected) { |o, c| c[o.ref] = o; }
 
     objects
   end

data/lib/puppet/pops/evaluator/collectors/catalog_collector.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Puppet::Pops::Evaluator::Collectors::CatalogCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
-  # Creates a CatalogCollector using the AbstractCollector's 
+  # Creates a CatalogCollector using the AbstractCollector's
   # constructor to set the scope and overrides
   #
   # param [Puppet::CompilableResourceType] type the resource type to be collected

data/lib/puppet/pops/evaluator/collectors/exported_collector.rb

@@ -40,9 +40,9 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
       end
 
       found = Puppet::Resource.indirection
-        .search(@type, :host => @scope.compiler.node.name, :filter => @equery, :scope => @scope)
+                              .search(@type, :host => @scope.compiler.node.name, :filter => @equery, :scope => @scope)
 
-      found_resources = found.map {|x| x.is_a?(Puppet::Parser::Resource) ? x : x.to_resource(@scope)}
+      found_resources = found.map { |x| x.is_a?(Puppet::Parser::Resource) ? x : x.to_resource(@scope) }
 
       found_resources.each do |item|
         existing = @scope.findresource(item.resource_type, item.title)

data/lib/puppet/pops/evaluator/collectors/fixed_set_collector.rb

@@ -9,21 +9,20 @@ class Puppet::Pops::Evaluator::Collectors::FixedSetCollector < Puppet::Pops::Eva
   # @param [Array] resources the fixed set of resources we want to realize
   def initialize(scope, resources)
     super(scope)
-    @resources = resources.is_a?(Array)? resources.dup : [resources]
+    @resources = resources.is_a?(Array) ? resources.dup : [resources]
   end
 
   # Collects a fixed set of resources and realizes them. Used
   # by the realize function
   def collect
     resolved = []
-    result = @resources.reduce([]) do |memo, ref|
+    result = @resources.each_with_object([]) do |ref, memo|
       res = @scope.findresource(ref.to_s)
       if res
         res.virtual = false
         memo << res
         resolved << ref
       end
-      memo
     end
 
     @resources = @resources - resolved

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

@@ -61,9 +61,10 @@ class CompareOperator
   end
 
   def cmp_Numeric(a, b)
-    if b.is_a?(Numeric)
+    case b
+    when Numeric
       a <=> b
-    elsif b.is_a?(Time::Timespan) || b.is_a?(Time::Timestamp)
+    when Time::Timespan, Time::Timestamp
       -(b <=> a) # compare other way and invert result
     else
       raise ArgumentError.new(_("A Numeric is not comparable to non Numeric"))
@@ -81,14 +82,14 @@ class CompareOperator
   def equals_Array(a, b)
     return false unless b.is_a?(Array) && a.size == b.size
 
-    a.each_index {|i| return false unless equals(a.slice(i), b.slice(i)) }
+    a.each_index { |i| return false unless equals(a.slice(i), b.slice(i)) }
     true
   end
 
   def equals_Hash(a, b)
     return false unless b.is_a?(Hash) && a.size == b.size
 
-    a.each {|ak, av| return false unless equals(b[ak], av)}
+    a.each { |ak, av| return false unless equals(b[ak], av) }
     true
   end
 
@@ -186,10 +187,10 @@ class CompareOperator
     when String, SemanticPuppet::Version
       a.any? { |element| match(b, element, scope) }
     when Types::PAnyType
-      a.each {|element| return true if b.instance?(element) }
+      a.each { |element| return true if b.instance?(element) }
       return false
     else
-      a.each {|element| return true if equals(element, b) }
+      a.each { |element| return true if equals(element, b) }
       return false
     end
   end
@@ -218,9 +219,10 @@ class CompareOperator
 
   # Matches against semvers and strings
   def match_Version(version, left, scope)
-    if left.is_a?(SemanticPuppet::Version)
+    case left
+    when SemanticPuppet::Version
       version == left
-    elsif left.is_a? String
+    when String
       begin
         version == SemanticPuppet::Version.parse(left)
       rescue ArgumentError
@@ -248,13 +250,13 @@ class CompareOperator
     return false unless left.is_a?(Array)
     return false unless left.length == array.length
 
-    array.each_with_index.all? { | pattern, index| match(left[index], pattern, scope) }
+    array.each_with_index.all? { |pattern, index| match(left[index], pattern, scope) }
   end
 
   def match_Hash(hash, left, scope)
     return false unless left.is_a?(Hash)
 
-    hash.all? {|x,y| match(left[x], y, scope) }
+    hash.all? { |x, y| match(left[x], y, scope) }
   end
 
   def match_Symbol(symbol, left, scope)