puppet 8.4.0-x64-mingw32 → 8.5.0-x64-mingw32

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

@@ -92,17 +92,18 @@ class DeferredResolver
         # If the value is instance of Sensitive - assign the unwrapped value
         # and mark it as sensitive if not already marked
         #
-        if resolved.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+        case resolved
+        when Puppet::Pops::Types::PSensitiveType::Sensitive
           resolved = resolved.unwrap
           mark_sensitive_parameters(r, k)
         # If the value is a DeferredValue and it has an argument of type PSensitiveType, mark it as sensitive
         # The DeferredValue.resolve method will unwrap it during catalog application
-        elsif resolved.is_a?(Puppet::Pops::Evaluator::DeferredValue)
-          if v.arguments.any? {|arg| arg.is_a?(Puppet::Pops::Types::PSensitiveType)}
+        when Puppet::Pops::Evaluator::DeferredValue
+          if v.arguments.any? { |arg| arg.is_a?(Puppet::Pops::Types::PSensitiveType) }
             mark_sensitive_parameters(r, k)
           end
         end
-        overrides[ k ] = resolved
+        overrides[k] = resolved
       end
       r.parameters.merge!(overrides) unless overrides.empty?
     end
@@ -116,13 +117,13 @@ class DeferredResolver
   private :mark_sensitive_parameters
 
   def resolve(x)
-    if x.class == @deferred_class
+    if x.instance_of?(@deferred_class)
       resolve_future(x)
     elsif x.is_a?(Array)
-      x.map {|v| resolve(v) }
+      x.map { |v| resolve(v) }
     elsif x.is_a?(Hash)
       result = {}
-      x.each_pair {|k,v| result[k] = resolve(v) }
+      x.each_pair { |k, v| result[k] = resolve(v) }
       result
     elsif x.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
       # rewrap in a new Sensitive after resolving any nested deferred values
@@ -136,15 +137,16 @@ class DeferredResolver
   end
 
   def resolve_lazy_args(x)
-    if x.is_a?(DeferredValue)
+    case x
+    when DeferredValue
       x.resolve
-    elsif x.is_a?(Array)
-      x.map {|v| resolve_lazy_args(v) }
-    elsif x.is_a?(Hash)
+    when Array
+      x.map { |v| resolve_lazy_args(v) }
+    when Hash
       result = {}
-      x.each_pair {|k,v| result[k] = resolve_lazy_args(v) }
+      x.each_pair { |k, v| result[k] = resolve_lazy_args(v) }
       result
-    elsif x.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+    when Puppet::Pops::Types::PSensitiveType::Sensitive
       # rewrap in a new Sensitive after resolving any nested deferred values
       Puppet::Pops::Types::PSensitiveType::Sensitive.new(resolve_lazy_args(x.unwrap))
     else
@@ -159,7 +161,7 @@ class DeferredResolver
     mapped_arguments = map_arguments(f.arguments)
     # if name starts with $ then this is a call to dig
     if func_name[0] == DOLLAR
-      var_name = func_name[1..-1]
+      var_name = func_name[1..]
       func_name = DIG
       mapped_arguments.insert(0, @scope[var_name])
     end
@@ -182,7 +184,7 @@ class DeferredResolver
   def map_arguments(args)
     return [] if args.nil?
 
-    args.map {|v| resolve(v) }
+    args.map { |v| resolve(v) }
   end
   private :map_arguments
 end

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

@@ -7,7 +7,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
     unless epp_source.is_a?(String)
       # TRANSLATORS 'inline_epp()' is a method name and 'epp' refers to 'Embedded Puppet (EPP) template' and should not be translated
       raise ArgumentError, _("inline_epp(): the first argument must be a String with the epp source text, got a %{class_name}") %
-          { class_name: epp_source.class }
+                           { class_name: epp_source.class }
     end
 
     # Parse and validate the source
@@ -61,17 +61,17 @@ class Puppet::Pops::Evaluator::EppEvaluator
     unless body.is_a?(Puppet::Pops::Model::LambdaExpression)
       # TRANSLATORS 'LambdaExpression' is a class name and should not be translated
       raise ArgumentError, _("%{function_name}(): the parser did not produce a LambdaExpression, got '%{class_name}'") %
-          { function_name: func_name, class_name: body.class }
+                           { function_name: func_name, class_name: body.class }
     end
     unless body.body.is_a?(Puppet::Pops::Model::EppExpression)
       # TRANSLATORS 'EppExpression' is a class name and should not be translated
       raise ArgumentError, _("%{function_name}(): the parser did not produce an EppExpression, got '%{class_name}'") %
-          { function_name: func_name, class_name: body.body.class }
+                           { function_name: func_name, class_name: body.body.class }
     end
     unless parse_result.definitions.empty?
       # TRANSLATORS 'EPP' refers to 'Embedded Puppet (EPP) template'
       raise ArgumentError, _("%{function_name}(): The EPP template contains illegal expressions (definitions)") %
-          { function_name: func_name }
+                           { function_name: func_name }
     end
 
     parameters_specified = body.body.parameters_specified
@@ -86,7 +86,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
     filtered_args = {}
     template_args.each_pair do |k, v|
       if k =~ /::/
-        k = k[2..-1] if k.start_with?('::')
+        k = k[2..] if k.start_with?('::')
         scope[k] = v
       else
         filtered_args[k] = v
@@ -112,7 +112,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
       unless template_args.is_a?(Hash)
         # TRANSLATORS 'template_args' is a variable name and should not be translated
         raise ArgumentError, _("%{function_name}(): the template_args must be a Hash, got a %{class_name}") %
-            { function_name: func_name, class_name: template_args.class }
+                             { function_name: func_name, class_name: template_args.class }
       end
       [template_args, true]
     end

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

@@ -101,18 +101,18 @@ class EvaluatorImpl
       else
         # Since it had no location information, treat it as user intended a general purpose
         # error. Pass on its call stack.
-        fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
+        fail(Issues::RUNTIME_ERROR, target, { :detail => e.message }, e)
       end
     rescue Puppet::Error => e
       # PuppetError has the ability to wrap an exception, if so, use the wrapped exception's
       # call stack instead
-      fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e.original || e)
+      fail(Issues::RUNTIME_ERROR, target, { :detail => e.message }, e.original || e)
     rescue StopIteration => e
       # Ensure these are not rescued as StandardError
       raise e
     rescue StandardError => e
       # All other errors, use its message and call stack
-      fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
+      fail(Issues::RUNTIME_ERROR, target, { :detail => e.message }, e)
     end
   end
 
@@ -192,7 +192,7 @@ class EvaluatorImpl
 
   # An array is assignable if all entries are lvalues
   def lvalue_LiteralList(o, scope)
-    o.values.map {|x| lvalue(x, scope) }
+    o.values.map { |x| lvalue(x, scope) }
   end
 
   # Assign value to named variable.
@@ -207,7 +207,7 @@ class EvaluatorImpl
   #
   def assign_String(name, value, o, scope)
     if name =~ /::/
-      fail(Issues::CROSS_SCOPE_ASSIGNMENT, o.left_expr, {:name => name})
+      fail(Issues::CROSS_SCOPE_ASSIGNMENT, o.left_expr, { :name => name })
     end
 
     set_variable(name, value, o, scope)
@@ -215,7 +215,7 @@ class EvaluatorImpl
   end
 
   def assign_Numeric(n, value, o, scope)
-    fail(Issues::ILLEGAL_NUMERIC_ASSIGNMENT, o.left_expr, {:varname => n.to_s})
+    fail(Issues::ILLEGAL_NUMERIC_ASSIGNMENT, o.left_expr, { :varname => n.to_s })
   end
 
   # Catches all illegal assignment (e.g. 1 = 2, {'a'=>1} = 2, etc)
@@ -225,15 +225,16 @@ class EvaluatorImpl
   end
 
   def assign_Array(lvalues, values, o, scope)
-    if values.is_a?(Hash)
+    case values
+    when Hash
       lvalues.map do |lval|
         assign(lval,
-               values.fetch(lval) {|k| fail(Issues::MISSING_MULTI_ASSIGNMENT_KEY, o, :key =>k)},
+               values.fetch(lval) { |k| fail(Issues::MISSING_MULTI_ASSIGNMENT_KEY, o, :key => k) },
                o, scope)
       end
-    elsif values.is_a?(Puppet::Pops::Types::PClassType)
+    when Puppet::Pops::Types::PClassType
       if Puppet[:tasks]
-        fail(Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING, o, {:operation => _('multi var assignment from class')})
+        fail(Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING, o, { :operation => _('multi var assignment from class') })
       end
 
       # assign variables from class variables
@@ -250,17 +251,17 @@ class EvaluatorImpl
             result = get_variable_value(varname, o, scope)
             assign(lval, result, o, scope)
           else
-            fail(Puppet::Pops::Issues::MISSING_MULTI_ASSIGNMENT_VARIABLE, o.left_expr.values[idx], {:name => varname})
+            fail(Puppet::Pops::Issues::MISSING_MULTI_ASSIGNMENT_VARIABLE, o.left_expr.values[idx], { :name => varname })
           end
         end
       else
-        fail(Issues::UNKNOWN_RESOURCE, o.right_expr, {:type_name => 'Class', :title => values.class_name})
+        fail(Issues::UNKNOWN_RESOURCE, o.right_expr, { :type_name => 'Class', :title => values.class_name })
       end
 
     else
       values = [values] unless values.is_a?(Array)
       if values.size != lvalues.size
-        fail(Issues::ILLEGAL_MULTI_ASSIGNMENT_SIZE, o, :expected =>lvalues.size, :actual => values.size)
+        fail(Issues::ILLEGAL_MULTI_ASSIGNMENT_SIZE, o, :expected => lvalues.size, :actual => values.size)
       end
 
       lvalues.zip(values).map { |lval, val| assign(lval, val, o, scope) }
@@ -296,7 +297,7 @@ class EvaluatorImpl
   #
   def eval_ReservedWord(o, scope)
     if !o.future
-      fail(Issues::RESERVED_WORD, o, {:word => o.word})
+      fail(Issues::RESERVED_WORD, o, { :word => o.word })
     else
       o.word
     end
@@ -314,13 +315,13 @@ class EvaluatorImpl
   #
   def eval_QualifiedReference(o, scope)
     type = Types::TypeParser.singleton.interpret(o)
-    fail(Issues::UNKNOWN_RESOURCE_TYPE, o, {:type_name => type.type_string }) if type.is_a?(Types::PTypeReferenceType)
+    fail(Issues::UNKNOWN_RESOURCE_TYPE, o, { :type_name => type.type_string }) if type.is_a?(Types::PTypeReferenceType)
 
     type
   end
 
   def eval_NotExpression(o, scope)
-    ! is_true?(evaluate(o.expr, scope), o.expr)
+    !is_true?(evaluate(o.expr, scope), o.expr)
   end
 
   def eval_UnaryMinusExpression(o, scope)
@@ -349,7 +350,7 @@ class EvaluatorImpl
   # @return <Array<Object, Object>> array with result of evaluating left and right expressions
   #
   def eval_BinaryExpression o, scope
-    [ evaluate(o.left_expr, scope), evaluate(o.right_expr, scope) ]
+    [evaluate(o.left_expr, scope), evaluate(o.right_expr, scope)]
   end
 
   # Evaluates assignment with operators =, +=, -= and
@@ -366,7 +367,7 @@ class EvaluatorImpl
     if o.operator == '='
       assign(name, value, o, scope)
     else
-      fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
+      fail(Issues::UNSUPPORTED_OPERATOR, o, { :operator => o.operator })
     end
     value
   end
@@ -383,7 +384,7 @@ class EvaluatorImpl
     begin
       result = calculate(left, right, o, scope)
     rescue ArgumentError => e
-      fail(Issues::RUNTIME_ERROR, o, {:detail => e.message}, e)
+      fail(Issues::RUNTIME_ERROR, o, { :detail => e.message }, e)
     end
     result
   end
@@ -393,7 +394,7 @@ class EvaluatorImpl
   def calculate(left, right, bin_expr, scope)
     operator = bin_expr.operator
     unless ARITHMETIC_OPERATORS.include?(operator)
-      fail(Issues::UNSUPPORTED_OPERATOR, bin_expr, {:operator => operator})
+      fail(Issues::UNSUPPORTED_OPERATOR, bin_expr, { :operator => operator })
     end
 
     left_o = bin_expr.left_expr
@@ -408,7 +409,7 @@ class EvaluatorImpl
         delete(left, right)
       when '<<'
         unless left.is_a?(Array)
-          fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
+          fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, { :operator => operator, :left_value => left })
         end
 
         left + [right]
@@ -420,9 +421,9 @@ class EvaluatorImpl
       begin
         if operator == '%' && (left.is_a?(Float) || right.is_a?(Float))
           # Deny users the fun of seeing severe rounding errors and confusing results
-          fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left}) if left.is_a?(Float)
+          fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, { :operator => operator, :left_value => left }) if left.is_a?(Float)
 
-          fail(Issues::OPERATOR_NOT_APPLICABLE_WHEN, left_o, {:operator => operator, :left_value => left, :right_value => right})
+          fail(Issues::OPERATOR_NOT_APPLICABLE_WHEN, left_o, { :operator => operator, :left_value => left, :right_value => right })
         end
         if right.is_a?(Time::TimeData) && !left.is_a?(Time::TimeData)
           if operator == '+' || operator == '*' && right.is_a?(Time::Timespan)
@@ -433,23 +434,23 @@ class EvaluatorImpl
           elsif operator == '-' && right.is_a?(Time::Timespan)
             left = Time::Timespan.new((left * Time::NSECS_PER_SEC).to_i)
           else
-            fail(Issues::OPERATOR_NOT_APPLICABLE_WHEN, left_o, {:operator => operator, :left_value => left, :right_value => right})
+            fail(Issues::OPERATOR_NOT_APPLICABLE_WHEN, left_o, { :operator => operator, :left_value => left, :right_value => right })
           end
         end
         result = left.send(operator, right)
       rescue NoMethodError
-        fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
+        fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, { :operator => operator, :left_value => left })
       rescue ZeroDivisionError
         fail(Issues::DIV_BY_ZERO, bin_expr.right_expr)
       end
       case result
       when Float
         if result == Float::INFINITY || result == -Float::INFINITY
-          fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
+          fail(Issues::RESULT_IS_INFINITY, left_o, { :operator => operator })
         end
       when Integer
         if result < MIN_INTEGER || result > MAX_INTEGER
-          fail(Issues::NUMERIC_OVERFLOW, bin_expr, {:value => result})
+          fail(Issues::NUMERIC_OVERFLOW, bin_expr, { :value => result })
         end
       end
       result
@@ -509,9 +510,9 @@ class EvaluatorImpl
     keys = o.keys || []
     if left.is_a?(Types::PClassType)
       # Evaluate qualified references without errors no undefined types
-      keys = keys.map {|key| key.is_a?(Model::QualifiedReference) ? Types::TypeParser.singleton.interpret(key) : evaluate(key, scope) }
+      keys = keys.map { |key| key.is_a?(Model::QualifiedReference) ? Types::TypeParser.singleton.interpret(key) : evaluate(key, scope) }
     else
-      keys = keys.map {|key| evaluate(key, scope) }
+      keys = keys.map { |key| evaluate(key, scope) }
       # Resource[File] becomes File
       return keys[0] if Types::PResourceType::DEFAULT == left && keys.size == 1 && keys[0].is_a?(Types::PResourceType)
     end
@@ -529,42 +530,42 @@ class EvaluatorImpl
       if left.is_a?(Types::PAnyType)
         case o.operator
         when '=='
-          @@type_calculator.equals(left,right)
+          @@type_calculator.equals(left, right)
 
         when '!='
-          !@@type_calculator.equals(left,right)
+          !@@type_calculator.equals(left, right)
 
         when '<'
           # left can be assigned to right, but they are not equal
-          @@type_calculator.assignable?(right, left) && ! @@type_calculator.equals(left,right)
+          @@type_calculator.assignable?(right, left) && !@@type_calculator.equals(left, right)
         when '<='
           # left can be assigned to right
           @@type_calculator.assignable?(right, left)
         when '>'
           # right can be assigned to left, but they are not equal
-          @@type_calculator.assignable?(left,right) && ! @@type_calculator.equals(left,right)
+          @@type_calculator.assignable?(left, right) && !@@type_calculator.equals(left, right)
         when '>='
           # right can be assigned to left
           @@type_calculator.assignable?(left, right)
         else
-          fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
+          fail(Issues::UNSUPPORTED_OPERATOR, o, { :operator => o.operator })
         end
       else
         case o.operator
         when '=='
-          @@compare_operator.equals(left,right)
+          @@compare_operator.equals(left, right)
         when '!='
-          ! @@compare_operator.equals(left,right)
+          !@@compare_operator.equals(left, right)
         when '<'
-          @@compare_operator.compare(left,right) < 0
+          @@compare_operator.compare(left, right) < 0
         when '<='
-          @@compare_operator.compare(left,right) <= 0
+          @@compare_operator.compare(left, right) <= 0
         when '>'
-          @@compare_operator.compare(left,right) > 0
+          @@compare_operator.compare(left, right) > 0
         when '>='
-          @@compare_operator.compare(left,right) >= 0
+          @@compare_operator.compare(left, right) >= 0
         else
-          fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
+          fail(Issues::UNSUPPORTED_OPERATOR, o, { :operator => o.operator })
         end
       end
     rescue ArgumentError => e
@@ -572,7 +573,8 @@ class EvaluatorImpl
              :operator => o.operator,
              :left_value => left,
              :right_value => right,
-             :detail => e.message}, e)
+             :detail => e.message
+           }, e)
     end
   end
 
@@ -615,14 +617,14 @@ class EvaluatorImpl
     begin
       pattern = Regexp.new(pattern) unless pattern.is_a?(Regexp)
     rescue StandardError => e
-      fail(Issues::MATCH_NOT_REGEXP, o.right_expr, {:detail => e.message}, e)
+      fail(Issues::MATCH_NOT_REGEXP, o.right_expr, { :detail => e.message }, e)
     end
     unless left.is_a?(String)
-      fail(Issues::MATCH_NOT_STRING, o.left_expr, {:left_value => left})
+      fail(Issues::MATCH_NOT_STRING, o.left_expr, { :left_value => left })
     end
 
     matched = pattern.match(left) # nil, or MatchData
-    set_match_data(matched,scope) # creates ephemeral
+    set_match_data(matched, scope) # creates ephemeral
 
     # convert match result to Boolean true, or false
     o.operator == '=~' ? !!matched : !matched
@@ -665,13 +667,13 @@ class EvaluatorImpl
   #
   def eval_LiteralHash o, scope
     # optimized
-    o.entries.reduce({}) {|h,entry| h[evaluate(entry.key, scope)] = evaluate(entry.value, scope); h }
+    o.entries.each_with_object({}) { |entry, h| h[evaluate(entry.key, scope)] = evaluate(entry.value, scope); }
   end
 
   # Evaluates all statements and produces the last evaluated value
   #
   def eval_BlockExpression o, scope
-    o.statements.reduce(nil) {|_memo, s| evaluate(s, scope)}
+    o.statements.reduce(nil) { |_memo, s| evaluate(s, scope) }
   end
 
   # Performs optimized search over case option values, lazily evaluating each
@@ -700,7 +702,7 @@ class EvaluatorImpl
           when Model::UnfoldExpression
             # not ideal for error reporting, since it is not known which unfolded result
             # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
-            evaluate(c, scope).any? {|v| is_match?(test, v, c, co, scope) }
+            evaluate(c, scope).any? { |v| is_match?(test, v, c, co, scope) }
           else
             is_match?(test, evaluate(c, scope), c, co, scope)
           end
@@ -724,7 +726,7 @@ class EvaluatorImpl
     if o.query.is_a?(Model::ExportedQuery)
       optionally_fail(Issues::RT_NO_STORECONFIGS, o);
     end
-    CollectorTransformer.new().transform(o,scope)
+    CollectorTransformer.new().transform(o, scope)
   end
 
   def eval_ParenthesizedExpression(o, scope)
@@ -779,37 +781,37 @@ class EvaluatorImpl
         evaluated_name = evaluate(tmp_name, scope)
         unless type_name_acceptable
           actual = type_calculator.generalize(type_calculator.infer(evaluated_name)).to_s
-          fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual => actual})
+          fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, { :actual => actual })
         end
 
         # must be a CatalogEntry subtype
         case evaluated_name
         when Types::PClassType
           unless evaluated_name.class_name.nil?
-            fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
+            fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, { :actual => evaluated_name.to_s })
           end
 
           'class'
 
         when Types::PResourceType
           unless evaluated_name.title().nil?
-            fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
+            fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, { :actual => evaluated_name.to_s })
           end
 
           evaluated_name.type_name # assume validated
 
         when Types::PTypeReferenceType
-          fail(Issues::UNKNOWN_RESOURCE_TYPE, o.type_string, {:type_name => evaluated_name.to_s})
+          fail(Issues::UNKNOWN_RESOURCE_TYPE, o.type_string, { :type_name => evaluated_name.to_s })
 
         else
           actual = type_calculator.generalize(type_calculator.infer(evaluated_name)).to_s
-          fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=>actual})
+          fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, { :actual => actual })
         end
       end
 
     # This is a runtime check - the model is valid, but will have runtime issues when evaluated
     # and storeconfigs is not set.
-    if(o.exported)
+    if (o.exported)
       optionally_fail(Issues::RT_NO_STORECONFIGS_EXPORT, o);
     end
 
@@ -818,7 +820,7 @@ class EvaluatorImpl
     body_to_params = {}
 
     # titles are evaluated before attribute operations
-    o.bodies.map do | body |
+    o.bodies.map do |body|
       titles = evaluate(body.title, scope)
 
       # Title may not be nil
@@ -836,17 +838,17 @@ class EvaluatorImpl
       # Check types of evaluated titles and duplicate entries
       titles.each_with_index do |title, index|
         if title.nil?
-          fail(Issues::MISSING_TITLE_AT, body.title, {:index => index})
+          fail(Issues::MISSING_TITLE_AT, body.title, { :index => index })
 
         elsif !title.is_a?(String) && title != :default
           actual = type_calculator.generalize(type_calculator.infer(title)).to_s
-          fail(Issues::ILLEGAL_TITLE_TYPE_AT, body.title, {:index => index, :actual => actual})
+          fail(Issues::ILLEGAL_TITLE_TYPE_AT, body.title, { :index => index, :actual => actual })
 
         elsif title == EMPTY_STRING
-          fail(Issues::EMPTY_STRING_TITLE_AT, body.title, {:index => index})
+          fail(Issues::EMPTY_STRING_TITLE_AT, body.title, { :index => index })
 
         elsif titles_to_body[title]
-          fail(Issues::DUPLICATE_TITLE, o, {:title => title})
+          fail(Issues::DUPLICATE_TITLE, o, { :title => title })
         end
 
         titles_to_body[title] = body
@@ -859,17 +861,16 @@ class EvaluatorImpl
 
       # Store evaluated parameters in a hash associated with the body, but do not yet create resource
       # since the entry containing :defaults may appear later
-      body_to_params[body] = body.operations.reduce({}) do |param_memo, op|
+      body_to_params[body] = body.operations.each_with_object({}) do |op, param_memo|
         params = evaluate(op, scope)
         params = [params] unless params.is_a?(Array)
         params.each do |p|
           if param_memo.include? p.name
-            fail(Issues::DUPLICATE_ATTRIBUTE, o, {:attribute => p.name})
+            fail(Issues::DUPLICATE_ATTRIBUTE, o, { :attribute => p.name })
           end
 
           param_memo[p.name] = p
         end
-        param_memo
       end
     end
 
@@ -878,7 +879,7 @@ class EvaluatorImpl
     # evaluating the ResourceExpression.
     #
     defaults_hash = body_to_params[titles_to_body[:default]] || {}
-    o.bodies.map do | body |
+    o.bodies.map do |body|
       titles = body_to_titles[body]
       params = defaults_hash.merge(body_to_params[body] || {})
       create_resources(o, scope, virtual, exported, type_name, titles, params.values)
@@ -913,9 +914,9 @@ class EvaluatorImpl
     hashed_params = evaluate(o.expr, scope)
     unless hashed_params.is_a?(Hash)
       actual = type_calculator.generalize(type_calculator.infer(hashed_params)).to_s
-      fail(Issues::TYPE_MISMATCH, o.expr, {:expected => 'Hash', :actual => actual})
+      fail(Issues::TYPE_MISMATCH, o.expr, { :expected => 'Hash', :actual => actual })
     end
-    hashed_params.map { |k,v| create_resource_parameter(o, scope, k, v, '=>') }
+    hashed_params.map { |k, v| create_resource_parameter(o, scope, k, v, '=>') }
   end
 
   # Sets default parameter values for a type, produces the type
@@ -927,9 +928,9 @@ class EvaluatorImpl
         type.type_name # assume it is a valid name
       else
         actual = type_calculator.generalize(type_calculator.infer(type))
-        fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_ref, {:actual => actual})
+        fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_ref, { :actual => actual })
       end
-    evaluated_parameters = o.operations.map {|op| evaluate(op, scope) }
+    evaluated_parameters = o.operations.map { |op| evaluate(op, scope) }
     create_resource_defaults(o, scope, type_name, evaluated_parameters)
     # Produce the type
     type
@@ -943,7 +944,7 @@ class EvaluatorImpl
     #
     functor = o.functor_expr
     if functor.is_a?(Model::QualifiedReference) ||
-      functor.is_a?(Model::AccessExpression) && functor.left_expr.is_a?(Model::QualifiedReference)
+       functor.is_a?(Model::AccessExpression) && functor.left_expr.is_a?(Model::QualifiedReference)
       # instantiation
       type = evaluate(functor, scope)
       return call_function_with_block('new', unfold([type], o.arguments || [], scope), o, scope)
@@ -958,7 +959,7 @@ class EvaluatorImpl
       # helpful to point out this easy to make Epp error
       fail(Issues::ILLEGAL_EPP_PARAMETERS, o)
     else
-      fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
+      fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, { :feature => 'function name', :container => o })
     end
     name = o.functor_expr.value
     call_function_with_block(name, unfold([], o.arguments, scope), o, scope)
@@ -968,13 +969,13 @@ class EvaluatorImpl
   #
   def eval_CallMethodExpression(o, scope)
     unless o.functor_expr.is_a? Model::NamedAccessExpression
-      fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function accessor', :container => o})
+      fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, { :feature => 'function accessor', :container => o })
     end
 
     receiver = unfold([], [o.functor_expr.left_expr], scope)
     name = o.functor_expr.right_expr
     unless name.is_a? Model::QualifiedName
-      fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
+      fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, { :feature => 'function name', :container => o })
     end
 
     name = name.value # the string function name
@@ -1027,7 +1028,7 @@ class EvaluatorImpl
         when Model::UnfoldExpression
           # not ideal for error reporting, since it is not known which unfolded result
           # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
-          evaluate(me, scope).any? {|v| is_match?(test, v, me, s, scope) }
+          evaluate(me, scope).any? { |v| is_match?(test, v, me, s, scope) }
         else
           is_match?(test, evaluate(me, scope), me, s, scope)
         end
@@ -1101,7 +1102,7 @@ class EvaluatorImpl
   # Evaluates double quoted strings that may contain interpolation
   #
   def eval_ConcatenatedString o, scope
-    o.segments.collect {|expr| string(evaluate(expr, scope), scope)}.join
+    o.segments.collect { |expr| string(evaluate(expr, scope), scope) }.join
   end
 
   # If the wrapped expression is a QualifiedName, it is taken as the name of a variable in scope.
@@ -1135,11 +1136,11 @@ class EvaluatorImpl
   end
 
   def string_Array(o, scope)
-    "[#{o.map {|e| string(e, scope)}.join(COMMA_SEPARATOR)}]"
+    "[#{o.map { |e| string(e, scope) }.join(COMMA_SEPARATOR)}]"
   end
 
   def string_Hash(o, scope)
-    "{#{o.map {|k,v| "#{string(k, scope)} => #{string(v, scope)}"}.join(COMMA_SEPARATOR)}}"
+    "{#{o.map { |k, v| "#{string(k, scope)} => #{string(v, scope)}" }.join(COMMA_SEPARATOR)}}"
   end
 
   def string_Regexp(o, scope)
@@ -1230,7 +1231,7 @@ class EvaluatorImpl
             # of call
             t = @@type_calculator.infer(y)
             if t.element_type.is_a? Types::PArrayType
-              Hash[y]
+              y.to_h
             else
               Hash[*y]
             end
@@ -1266,14 +1267,14 @@ class EvaluatorImpl
           when Hash  then y.to_a
           else            [y]
           end
-      y.each {|e| result.delete(e) }
+      y.each { |e| result.delete(e) }
     when Hash
       y = case y
           when Array then y
           when Hash  then y.keys
           else            [y]
           end
-      y.each {|e| result.delete(e) }
+      y.each { |e| result.delete(e) }
     else
       raise ArgumentError.new(_("Can only delete from an Array or Hash."))
     end

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

@@ -30,7 +30,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
   #
   def checker_for_syntax(_, syntax)
     checkers_hash = Puppet.lookup(:plugins)[Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_KEY]
-    checkers_hash[lookup_keys_for_syntax(syntax).find {|x| checkers_hash[x] }]
+    checkers_hash[lookup_keys_for_syntax(syntax).find { |x| checkers_hash[x] }]
   end
 
   # Returns an array of possible syntax names