puppet 4.0.0 → 4.5.0

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

@@ -1,3 +1,5 @@
+module Puppet::Pops
+module Evaluator
 # A Closure represents logic bound to a particular scope.
 # As long as the runtime (basically the scope implementation) has the behavior of Puppet 3x it is not
 # safe to return and later use this closure.
@@ -11,7 +13,7 @@
 # Note that this class is a CallableSignature, and the methods defined there should be used
 # as the API for obtaining information in a callable-implementation agnostic way.
 #
-class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignature
+class Closure < CallableSignature
   attr_reader :evaluator
   attr_reader :model
   attr_reader :enclosing_scope
@@ -25,61 +27,45 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
   # Evaluates a closure in its enclosing scope after having matched given arguments with parameters (from left to right)
   # @api public
   def call(*args)
-    variable_bindings = combine_values_with_parameters(args)
-
-    tc = Puppet::Pops::Types::TypeCalculator
-    final_args = tc.infer_set(parameters.inject([]) do |tmp_args, param|
-      if param.captures_rest
-        tmp_args.concat(variable_bindings[param.name])
-      else
-        tmp_args << variable_bindings[param.name]
-      end
-    end)
+    call_with_scope(@enclosing_scope, args)
+  end
 
-    if tc.callable?(type, final_args)
-      @evaluator.evaluate_block_with_bindings(@enclosing_scope, variable_bindings, @model.body)
-    else
-      raise ArgumentError, "lambda called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string('lambda', final_args, [self])}"
+  # This method makes a Closure compatible with a Dispatch. This is used when the closure is wrapped in a Function
+  # and the function is called. (Saves an extra Dispatch that just delegates to a Closure and avoids having two
+  # checks of the argument type/arity validity).
+  # @api private
+  def invoke(instance, calling_scope, args, &block)
+    @enclosing_scope.with_global_scope do |global_scope|
+      call_with_scope(global_scope, args, &block)
     end
   end
 
   # Call closure with argument assignment by name
   def call_by_name(args_hash, enforce_parameters)
     if enforce_parameters
-      if args_hash.size > parameters.size
-        raise ArgumentError, "Too many arguments: #{args_hash.size} for #{parameters.size}"
-      end
-
-      # associate values with parameters
-      scope_hash = {}
-      parameters.each do |p|
-        name = p.name
-        if (arg_value = args_hash[name]).nil?
-          # only set result of default expr if it is defined (it is otherwise not possible to differentiate
-          # between explicit undef and no default expression
-          unless p.value.nil?
-            scope_hash[name] = @evaluator.evaluate(p.value, @enclosing_scope)
+      # Push a temporary parameter scope used while resolving the parameter defaults
+      @enclosing_scope.with_parameter_scope(parameter_names) do |param_scope|
+        # Assign all non-nil values, even those that represent non-existent paramaters.
+        args_hash.each { |k, v| param_scope[k] = v unless v.nil? }
+        parameters.each do |p|
+          name = p.name
+          arg = args_hash[name]
+          if arg.nil?
+            # Arg either wasn't given, or it was undef
+            if p.value.nil?
+              # No default. Assign nil if the args_hash included it
+              param_scope[name] = nil if args_hash.include?(name)
+            else
+              param_scope[name] = param_scope.evaluate(name, p.value, @enclosing_scope, @evaluator)
+            end
           end
-        else
-          scope_hash[name] = arg_value
         end
+        args_hash = param_scope.to_hash
       end
-
-      missing = parameters.select { |p| !scope_hash.include?(p.name) }
-      if missing.any?
-        raise ArgumentError, "Too few arguments; no value given for required parameters #{missing.collect(&:name).join(" ,")}"
-      end
-
-      tc = Puppet::Pops::Types::TypeCalculator
-      final_args = tc.infer_set(parameter_names.collect { |param| scope_hash[param] })
-      if !tc.callable?(type, final_args)
-        raise ArgumentError, "lambda called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string('lambda', final_args, [self])}"
-      end
-    else
-      scope_hash = args_hash
+      Types::TypeMismatchDescriber.validate_parameters(closure_name, params_struct, args_hash)
     end
 
-    @evaluator.evaluate_block_with_bindings(@enclosing_scope, scope_hash, @model.body)
+    @evaluator.evaluate_block_with_bindings(@enclosing_scope, args_hash, @model.body)
   end
 
   def parameters
@@ -103,6 +89,11 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
     @callable ||= create_callable_type
   end
 
+  # @api public
+  def params_struct
+    @params_struct ||= create_params_struct
+  end
+
   # @api public
   def last_captures_rest?
     last = @model.parameters[-1]
@@ -115,54 +106,90 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
     'unsupported_block'
   end
 
+  CLOSURE_NAME = 'lambda'.freeze
+
+  # @api public
+  def closure_name()
+    CLOSURE_NAME
+  end
+
+  class Named < Closure
+    def initialize(name, evaluator, model, scope)
+      @name = name
+      super(evaluator, model, scope)
+    end
+
+    def closure_name
+      @name
+    end
+  end
+
   private
 
-  def combine_values_with_parameters(args)
-    variable_bindings = {}
+  def call_with_scope(scope, args)
+    variable_bindings = combine_values_with_parameters(scope, args)
+
+    tc = Types::TypeCalculator.singleton
+    final_args = tc.infer_set(parameters.reduce([]) do |tmp_args, param|
+      if param.captures_rest
+        tmp_args.concat(variable_bindings[param.name])
+      else
+        tmp_args << variable_bindings[param.name]
+      end
+    end)
+
+    if type.callable?(final_args)
+      @evaluator.evaluate_block_with_bindings(scope, variable_bindings, @model.body)
+    else
+      raise ArgumentError, Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], final_args)
+    end
+  end
+
+  def combine_values_with_parameters(scope, args)
+    scope.with_parameter_scope(parameter_names) do |param_scope|
+      parameters.each_with_index do |parameter, index|
+        param_captures     = parameter.captures_rest
+        default_expression = parameter.value
 
-    parameters.each_with_index do |parameter, index|
-      param_captures     = parameter.captures_rest
-      default_expression = parameter.value
+        if index >= args.size
+          if default_expression
+            # not given, has default
+            value = param_scope.evaluate(parameter.name, default_expression, scope, @evaluator)
 
-      if index >= args.size
-        if default_expression
-          # not given, has default
-          value = @evaluator.evaluate(default_expression, @enclosing_scope)
-          if param_captures && !value.is_a?(Array)
-            # correct non array default value
-            value = [value]
+            if param_captures && !value.is_a?(Array)
+              # correct non array default value
+              value = [value]
+            end
+          else
+            # 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
           end
         else
-          # not given, does not have default
+          given_argument = args[index]
           if param_captures
-            # default for captures rest is an empty array
-            value = []
+            # get excess arguments
+            value = args[(parameter_count-1)..-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
+            #
+            if value.size == 1 && (given_argument.nil? || given_argument == :undef) && default_expression
+              value = param_scope.evaluate(parameter.name, default_expression, scope, @evaluator)
+              # and ensure it is an array
+              value = [value] unless value.is_a?(Array)
+            end
           else
-            @evaluator.fail(Puppet::Pops::Issues::MISSING_REQUIRED_PARAMETER, parameter, { :param_name => parameter.name })
-          end
-        end
-      else
-        given_argument = args[index]
-        if param_captures
-          # get excess arguments
-          value = args[(parameter_count-1)..-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
-          #
-          if value.size == 1 && (given_argument.nil? || given_argument == :undef) && default_expression
-            value = @evaluator.evaluate(default_expression, @enclosing_scope)
-            # and ensure it is an array
-            value = [value] unless value.is_a?(Array)
+            value = given_argument
           end
-        else
-          value = given_argument
         end
+        param_scope[parameter.name] = value
       end
-
-      variable_bindings[parameter.name] = value
+      param_scope.to_hash
     end
-
-    variable_bindings
   end
 
   def create_callable_type()
@@ -170,35 +197,14 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
     range = [0, 0]
     in_optional_parameters = false
     parameters.each do |param|
-      type = if param.type_expr
-               @evaluator.evaluate(param.type_expr, @enclosing_scope)
-             else
-               Puppet::Pops::Types::TypeFactory.any()
-             end
-
-      if param.captures_rest && type.is_a?(Puppet::Pops::Types::PArrayType)
-        # An array on a slurp parameter is how a size range is defined for a
-        # slurp (Array[Integer, 1, 3] *$param). However, the callable that is
-        # created can't have the array in that position or else type checking
-        # will require the parameters to be arrays, which isn't what is
-        # intended. The array type contains the intended information and needs
-        # to be unpacked.
-        param_range = type.size_range
-        type = type.element_type
-      elsif param.captures_rest && !type.is_a?(Puppet::Pops::Types::PArrayType)
-        param_range = ANY_NUMBER_RANGE
-      elsif param.value
-        param_range = OPTIONAL_SINGLE_RANGE
-      else
-        param_range = REQUIRED_SINGLE_RANGE
-      end
+      type, param_range = create_param_type(param)
 
       types << type
 
       if param_range[0] == 0
         in_optional_parameters = true
       elsif param_range[0] != 0 && in_optional_parameters
-        @evaluator.fail(Puppet::Pops::Issues::REQUIRED_PARAMETER_AFTER_OPTIONAL, param, { :param_name => param.name })
+        @evaluator.fail(Issues::REQUIRED_PARAMETER_AFTER_OPTIONAL, param, { :param_name => param.name })
       end
 
       range[0] += param_range[0]
@@ -209,7 +215,46 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
       range[1] = :default
     end
 
-    Puppet::Pops::Types::TypeFactory.callable(*(types + range))
+    Types::TypeFactory.callable(*(types + range))
+  end
+
+  def create_params_struct
+    type_factory = Types::TypeFactory
+    members = {}
+
+    parameters.each do |param|
+      arg_type, param_range = create_param_type(param)
+      key_type = type_factory.string(nil, param.name.to_s)
+      key_type = type_factory.optional(key_type) unless param.value.nil?
+      members[key_type] = arg_type
+    end
+    type_factory.struct(members)
+  end
+
+  def create_param_type(param)
+    type = if param.type_expr
+             @evaluator.evaluate(param.type_expr, @enclosing_scope)
+           else
+             Types::PAnyType::DEFAULT
+           end
+
+    if param.captures_rest && type.is_a?(Types::PArrayType)
+      # An array on a slurp parameter is how a size range is defined for a
+      # slurp (Array[Integer, 1, 3] *$param). However, the callable that is
+      # created can't have the array in that position or else type checking
+      # will require the parameters to be arrays, which isn't what is
+      # intended. The array type contains the intended information and needs
+      # to be unpacked.
+      param_range = type.size_range
+      type = type.element_type
+    elsif param.captures_rest && !type.is_a?(Types::PArrayType)
+      param_range = ANY_NUMBER_RANGE
+    elsif param.value
+      param_range = OPTIONAL_SINGLE_RANGE
+    else
+      param_range = REQUIRED_SINGLE_RANGE
+    end
+    [type, param_range]
   end
 
   # Produces information about parameters compatible with a 4x Function (which can have multiple signatures)
@@ -221,3 +266,5 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
   OPTIONAL_SINGLE_RANGE = [0, 1]
   REQUIRED_SINGLE_RANGE = [1, 1]
 end
+end
+end

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

@@ -1,16 +1,18 @@
-class Puppet::Pops::Evaluator::CollectorTransformer
+module Puppet::Pops
+module Evaluator
+class CollectorTransformer
 
   def initialize
-    @@query_visitor    ||= Puppet::Pops::Visitor.new(nil, "query", 1, 1)
-    @@match_visitor    ||= Puppet::Pops::Visitor.new(nil, "match", 1, 1)
-    @@evaluator        ||= Puppet::Pops::Evaluator::EvaluatorImpl.new
-    @@compare_operator ||= Puppet::Pops::Evaluator::CompareOperator.new()
+    @@query_visitor    ||= Visitor.new(nil, "query", 1, 1)
+    @@match_visitor    ||= Visitor.new(nil, "match", 1, 1)
+    @@evaluator        ||= EvaluatorImpl.new
+    @@compare_operator ||= CompareOperator.new()
   end
 
   def transform(o, scope)
-    raise ArgumentError, "Expected CollectExpression" unless o.is_a? Puppet::Pops::Model::CollectExpression
+    raise ArgumentError, "Expected CollectExpression" unless o.is_a? Model::CollectExpression
 
-    raise "LHS is not a type" unless o.type_expr.is_a? Puppet::Pops::Model::QualifiedReference
+    raise "LHS is not a type" unless o.type_expr.is_a? Model::QualifiedReference
     type = o.type_expr.value().downcase()
 
     if type == 'class'
@@ -20,14 +22,14 @@ class Puppet::Pops::Evaluator::CollectorTransformer
     resource_type = scope.find_resource_type(type)
     fail "Resource type #{type} doesn't exist" unless resource_type
 
-    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(o)
+    adapter = Adapters::SourcePosAdapter.adapt(o)
     line_num = adapter.line
     position = adapter.pos
     file_path = adapter.locator.file
 
     if !o.operations.empty?
       overrides = {
-        :parameters => o.operations.map{ |x| to_3x_param(x).evaluate(scope)},
+        :parameters => o.operations.map{ |x| @@evaluator.evaluate(x, scope)}.flatten,
         :file       => file_path,
         :line       => [line_num, position],
         :source     => scope.source,
@@ -38,11 +40,11 @@ class Puppet::Pops::Evaluator::CollectorTransformer
     code = query_unless_nop(o.query, scope)
 
     case o.query
-    when Puppet::Pops::Model::VirtualQuery
-      newcoll = Puppet::Pops::Evaluator::Collectors::CatalogCollector.new(scope, resource_type.name, code, overrides)
-    when Puppet::Pops::Model::ExportedQuery
+    when Model::VirtualQuery
+      newcoll = Collectors::CatalogCollector.new(scope, resource_type.name, code, overrides)
+    when Model::ExportedQuery
       match = match_unless_nop(o.query, scope)
-      newcoll = Puppet::Pops::Evaluator::Collectors::ExportedCollector.new(scope, resource_type.name, match, code, overrides)
+      newcoll = Collectors::ExportedCollector.new(scope, resource_type.name, match, code, overrides)
     end
 
     scope.compiler.add_collection(newcoll)
@@ -61,13 +63,13 @@ protected
   end
 
   def query_unless_nop(query, scope)
-    unless query.expr.nil? || query.expr.is_a?(Puppet::Pops::Model::Nop)
+    unless query.expr.nil? || query.expr.is_a?(Model::Nop)
       query(query.expr, scope)
     end
   end
 
   def match_unless_nop(query, scope)
-    unless query.expr.nil? || query.expr.is_a?(Puppet::Pops::Model::Nop)
+    unless query.expr.nil? || query.expr.is_a?(Model::Nop)
       match(query.expr, scope)
     end
   end
@@ -125,6 +127,14 @@ protected
     end
   end
 
+ def query_AccessExpression(o, scope)
+    pops_object = @@evaluator.evaluate(o, scope)
+
+    # Convert to Puppet 3 style objects since that is how they are represented
+    # in the catalog.
+    @@evaluator.convert(pops_object, scope, nil)
+  end
+
   def query_VariableExpression(o, scope)
     @@evaluator.evaluate(o, scope)
   end
@@ -157,6 +167,14 @@ protected
     raise ArgumentError, "Cannot transform object of class #{o.class}"
   end
 
+  def match_AccessExpression(o, scope)
+    pops_object = @@evaluator.evaluate(o, scope)
+
+    # Convert to Puppet 3 style objects since that is how they are represented
+    # in the catalog.
+    @@evaluator.convert(pops_object, scope, nil)
+  end
+
   def match_AndExpression(o, scope)
     left_match = match(o.left_expr, scope)
     right_match = match(o.right_expr, scope)
@@ -206,14 +224,6 @@ protected
   def match_Object(o, scope)
     raise ArgumentError, "Cannot transform object of class #{o.class}"
   end
-
-  # Produces (name => expr) or (name +> expr)
-  def to_3x_param(o)
-    bridge = Puppet::Parser::AST::PopsBridge::Expression.new(:value => o.value_expr)
-    args = { :value => bridge }
-    args[:add] = true if o.operator == :'+>'
-    args[:param] = o.attribute_name
-    args= Puppet::Pops::Model::AstTransformer.new().merge_location(args, o)
-    Puppet::Parser::AST::ResourceParam.new(args)
-  end
+end
+end
 end

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

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

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

@@ -22,4 +22,8 @@ class Puppet::Pops::Evaluator::Collectors::CatalogCollector < Puppet::Pops::Eval
       resource.type == t && (q ?  q.call(resource) : true)
     end
   end
+
+  def to_s
+    "Catalog-Collector[#{@type.to_s}]"
+  end
 end

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

@@ -19,7 +19,6 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
   # evaluate method
   def evaluate
     if Puppet[:storeconfigs] != true
-      Puppet.warning "Not collecting exported resources without storeconfigs"
       return false
     end
 
@@ -63,4 +62,8 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
 
     resources
   end
+
+  def to_s
+    "Exported-Collector[#{@type.to_s}]"
+  end
 end

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

@@ -1,3 +1,5 @@
+module Puppet::Pops
+module Evaluator
 # Compares the puppet DSL way
 #
 # ==Equality
@@ -6,19 +8,19 @@
 # Hashes  are equal to hashes if they have the same size and keys and values #equals.
 # All other objects are equal if they are ruby #== equal
 #
-class Puppet::Pops::Evaluator::CompareOperator
-  include Puppet::Pops::Utils
+class CompareOperator
+  include Utils
 
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
-  include Puppet::Pops::Evaluator::Runtime3Support
+  include Runtime3Support
 
   def initialize
-    @@equals_visitor  ||= Puppet::Pops::Visitor.new(self, "equals", 1, 1)
-    @@compare_visitor ||= Puppet::Pops::Visitor.new(self, "cmp", 1, 1)
-    @@include_visitor ||= Puppet::Pops::Visitor.new(self, "include", 2, 2)
-    @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
+    @@equals_visitor  ||= Visitor.new(self, "equals", 1, 1)
+    @@compare_visitor ||= Visitor.new(self, "cmp", 1, 1)
+    @@match_visitor ||= Visitor.new(self, "match", 2, 2)
+    @@include_visitor ||= Visitor.new(self, "include", 2, 2)
   end
 
   def equals (a, b)
@@ -31,6 +33,11 @@ class Puppet::Pops::Evaluator::CompareOperator
     @@compare_visitor.visit_this_1(self, a, b)
   end
 
+  # Performs a match of a and b, and returns true if b matches a
+  def match(a, b, scope)
+    @@match_visitor.visit_this_2(self, b, a, scope)
+  end
+
   # Answers is b included in a
   def include?(a, b, scope)
     @@include_visitor.visit_this_2(self, a, b, scope)
@@ -85,8 +92,13 @@ class Puppet::Pops::Evaluator::CompareOperator
     end
   end
 
+  def cmp_Version(a, b)
+    raise ArgumentError.new('Versions not comparable to non Versions') unless b.is_a?(Semantic::Version)
+    a <=> b
+  end
+
   def cmp_Object(a, b)
-    raise ArgumentError.new("Only Strings and Numbers are comparable")
+    raise ArgumentError.new('Only Strings, Numbers, and Versions are comparable')
   end
 
 
@@ -137,8 +149,10 @@ class Puppet::Pops::Evaluator::CompareOperator
       # Always set match data, a "not found" should not keep old match data visible
       set_match_data(matched, scope) # creates ephemeral
       return !!matched
-    when Puppet::Pops::Types::PAnyType
-      a.each {|element| return true if @type_calculator.instance?(b, element) }
+    when String, Semantic::Version
+      a.any? { |element| match(b, element, scope) }
+    when Types::PAnyType
+      a.each {|element| return true if b.instance?(element) }
       return false
     else
       a.each {|element| return true if equals(element, b) }
@@ -149,4 +163,67 @@ class Puppet::Pops::Evaluator::CompareOperator
   def include_Hash(a, b, scope)
     include?(a.keys, b, scope)
   end
+
+  def include_VersionRange(a, b, scope)
+    Types::PSemVerRangeType.include?(a, b)
+  end
+
+  # Matches in general by using == operator
+  def match_Object(pattern, a, scope)
+    equals(a, pattern)
+  end
+
+  # Matches only against strings
+  def match_Regexp(regexp, left, scope)
+    return false unless left.is_a? String
+    matched = regexp.match(left)
+    set_match_data(matched, scope) # creates or clears ephemeral
+    !!matched # convert to boolean
+  end
+
+  # Matches against semvers and strings
+  def match_Version(version, left, scope)
+    if left.is_a?(Semantic::Version)
+      version == left
+    elsif left.is_a? String
+      begin
+        version == Semantic::Version.parse(left)
+      rescue ArgumentError
+        false
+      end
+    else
+      false
+    end
+  end
+
+  # Matches against semvers and strings
+  def match_VersionRange(range, left, scope)
+    Types::PSemVerRangeType.include?(range, left)
+  end
+
+  def match_PAnyType(any_type, left, scope)
+    # right is a type and left is not - check if left is an instance of the given type
+    # (The reverse is not terribly meaningful - computing which of the case options that first produces
+    # an instance of a given type).
+    #
+    any_type.instance?(left)
+  end
+
+  def match_Array(array, left, scope)
+    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) }
+  end
+
+  def match_Hash(hash, left, scope)
+    return false unless left.is_a?(Hash)
+    hash.all? {|x,y| match(left[x], y, scope) }
+  end
+
+  def match_Symbol(symbol, left, scope)
+    return true if symbol == :default
+    equals(left, default, scope)
+  end
+end
+end
 end

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

@@ -24,10 +24,15 @@ class Puppet::Pops::Evaluator::EppEvaluator
       raise ArgumentError, "epp(): the first argument must be a String with the filename, got a #{file.class}"
     end
 
-    file = file + ".epp" unless file =~ /\.epp$/
+    unless Puppet::FileSystem.exist?(file)
+      unless file =~ /\.epp$/
+        file = file + ".epp"
+      end
+    end
+
     scope.debug "Retrieving epp template #{file}"
     template_file = Puppet::Parser::Files.find_template(file, env_name)
-    unless template_file
+    if template_file.nil? ||  !Puppet::FileSystem.exist?(template_file)
       raise Puppet::ParseError, "Could not find template '#{file}'"
     end
 
@@ -61,18 +66,19 @@ class Puppet::Pops::Evaluator::EppEvaluator
 
     parameters_specified = body.body.parameters_specified
     if parameters_specified || template_args_set
-      # no epp params or user provided arguments in a hash, epp() logic
-      # only sees global + what was given
-      closure_scope = scope.find_global_scope
       enforce_parameters = parameters_specified
     else
-      # no epp params and no arguments were given => inline_epp() logic
-      # sees all local variables, epp() all global
-      closure_scope =  use_global_scope_only ? scope.find_global_scope : scope
       enforce_parameters = true
     end
-    evaluated_result = parser.closure(body, closure_scope).call_by_name(template_args, enforce_parameters)
-    evaluated_result
+
+    # inline_epp() logic sees all local variables, epp() all global
+    if use_global_scope_only
+      scope.with_global_scope do |global_scope|
+        parser.closure(body, global_scope).call_by_name(template_args, enforce_parameters)
+      end
+    else
+      parser.closure(body, scope).call_by_name(template_args, enforce_parameters)
+    end
   end
 
   def self.handle_template_args(func_name, template_args)