puppet 3.7.4 → 3.7.5

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

@@ -0,0 +1,175 @@
+module Puppet::Pops::Evaluator
+# Converts nested 4x supported values to 3x values. This is required because
+# resources and other objects do not know about the new type system, and does not support
+# regular expressions. Unfortunately this has to be done for array and hash as well.
+# A complication is that catalog types needs to be resolved against the scope.
+#
+# Users should not create instances of this class. Instead the class methods {Runtime3Converter.convert},
+# {Runtime3Converter.map_args}, or {Runtime3Converter.instance} should be used
+class Runtime3Converter
+  # Converts 4x supported values to a 3x values. Same as calling Runtime3Converter.instance.map_args(...)
+  #
+  # @param args [Array] Array of values to convert
+  # @param scope [Puppet::Parser::Scope] The scope to use when converting
+  # @param undef_value [Object] The value that nil is converted to
+  # @return [Array] The converted values
+  #
+  def self.map_args(args, scope, undef_value)
+    @@instance.map_args(args, scope, undef_value)
+  end
+
+  # Converts 4x supported values to a 3x values. Same as calling Runtime3Converter.instance.convert(...)
+  #
+  # @param o [Object]The value to convert
+  # @param scope [Puppet::Parser::Scope] The scope to use when converting
+  # @param undef_value [Object] The value that nil is converted to
+  # @return [Object] The converted value
+  #
+  def self.convert(o, scope, undef_value)
+    @@instance.convert(o, scope, undef_value)
+  end
+
+  # Returns the singleton instance of this class.
+  # @return [Runtime3Converter] The singleton instance
+  def self.instance
+    @@instance
+  end
+
+  # Converts 4x supported values to a 3x values.
+  #
+  # @param args [Array] Array of values to convert
+  # @param scope [Puppet::Parser::Scope] The scope to use when converting
+  # @param undef_value [Object] The value that nil is converted to
+  # @return [Array] The converted values
+  #
+  def map_args(args, scope, undef_value)
+    args.map {|a| convert(a, scope, undef_value) }
+  end
+
+  # Converts a 4x supported value to a 3x value.
+  #
+  # @param o [Object]The value to convert
+  # @param scope [Puppet::Parser::Scope] The scope to use when converting
+  # @param undef_value [Object] The value that nil is converted to
+  # @return [Object] The converted value
+  #
+  def convert(o, scope, undef_value)
+    @convert_visitor.visit_this_2(self, o, scope, undef_value)
+  end
+
+  def convert_NilClass(o, scope, undef_value)
+    undef_value
+  end
+
+  def convert2_NilClass(o, scope, undef_value)
+    :undef
+  end
+
+  def convert_String(o, scope, undef_value)
+    # although wasteful, needed because user code may mutate these strings in Resources
+    o.frozen? ? o.dup : o
+  end
+  alias convert2_String :convert_String
+
+  def convert_Object(o, scope, undef_value)
+    o
+  end
+  alias :convert2_Object :convert_Object
+
+  def convert_Array(o, scope, undef_value)
+    o.map {|x| convert2(x, scope, undef_value) }
+  end
+  alias :convert2_Array :convert_Array
+
+  def convert_Hash(o, scope, undef_value)
+    result = {}
+    o.each {|k,v| result[convert2(k, scope, undef_value)] = convert2(v, scope, undef_value) }
+    result
+  end
+  alias :convert2_Hash :convert_Hash
+
+  def convert_Regexp(o, scope, undef_value)
+    # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
+    # source form
+    o.inspect
+  end
+  alias :convert2_Regexp :convert_Regexp
+
+  def convert_Symbol(o, scope, undef_value)
+    case o
+      # Support :undef since it may come from a 3x structure
+      when :undef
+        undef_value  # 3x wants undef as either empty string or :undef
+      else
+        o   # :default, and all others are verbatim since they are new in future evaluator
+    end
+  end
+
+  # The :undef symbol should not be converted when nested in arrays or hashes
+  def convert2_Symbol(o, scope, undef_value)
+    o
+  end
+
+  def convert_PAnyType(o, scope, undef_value)
+    o
+  end
+  alias :convert2_PAnyType :convert_PAnyType
+
+  def convert_PCatalogEntryType(o, scope, undef_value)
+    # Since 4x does not support dynamic scoping, all names are absolute and can be
+    # used as is (with some check/transformation/mangling between absolute/relative form
+    # due to Puppet::Resource's idiosyncratic behavior where some references must be
+    # absolute and others cannot be.
+    # Thus there is no need to call scope.resolve_type_and_titles to do dynamic lookup.
+
+    Puppet::Resource.new(*catalog_type_to_split_type_title(o))
+  end
+  alias :convert2_PCatalogEntryType :convert_PCatalogEntryType
+
+  # Produces an array with [type, title] from a PCatalogEntryType
+  # This method is used to produce the arguments for creation of reference resource instances
+  # (used when 3x is operating on a resource).
+  # Ensures that resources are *not* absolute.
+  #
+  def catalog_type_to_split_type_title(catalog_type)
+    split_type = catalog_type.is_a?(Puppet::Pops::Types::PType) ? catalog_type.type : catalog_type
+    case split_type
+      when Puppet::Pops::Types::PHostClassType
+        class_name = split_type.class_name
+        ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
+      when Puppet::Pops::Types::PResourceType
+        type_name = split_type.type_name
+        title = split_type.title
+        if type_name =~ /^(::)?[Cc]lass/
+          ['class', title.nil? ? nil : title.sub(/^::/, '')]
+        else
+          # Ensure that title is '' if nil
+          # Resources with absolute name always results in error because tagging does not support leading ::
+          [type_name.nil? ? nil : type_name.sub(/^::/, ''), title.nil? ? '' : title]
+        end
+      else
+        raise ArgumentError, "Cannot split the type #{catalog_type.class}, it represents neither a PHostClassType, nor a PResourceType."
+    end
+  end
+
+  private
+
+  def initialize
+    @convert_visitor  = Puppet::Pops::Visitor.new(self, 'convert', 2, 2)
+    @convert2_visitor = Puppet::Pops::Visitor.new(self, 'convert2', 2, 2)
+  end
+
+  @@instance = self.new
+
+  # Converts a nested 4x supported value to a 3x value.
+  #
+  # @param o [Object]The value to convert
+  # @param scope [Puppet::Parser::Scope] The scope to use when converting
+  # @param undef_value [Object] The value that nil is converted to
+  # @return [Object] The converted value
+  #
+  def convert2(o, scope, undef_value)
+    @convert2_visitor.visit_this_2(self, o, scope, undef_value)
+  end
+end
+end

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

@@ -199,7 +199,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
       source_resource = source
     else
       # transform into the wonderful String representation in 3x
-      type, title = catalog_type_to_split_type_title(source)
+      type, title = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(source)
       source_resource = Puppet::Resource.new(type, title)
     end
     if target.is_a?(Puppet::Parser::Collector) || target.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
@@ -207,7 +207,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
       target_resource = target
     else
       # transform into the wonderful String representation in 3x
-      type, title = catalog_type_to_split_type_title(target)
+      type, title = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(target)
       target_resource = Puppet::Resource.new(type, title)
     end
     # Add the relationship to the compiler for later evaluation.
@@ -229,14 +229,14 @@ module Puppet::Pops::Evaluator::Runtime3Support
     n
   end
 
-  def call_function(name, args, o, scope)
+  def call_function(name, args, o, scope, &block)
     # Call via 4x API if the function exists there
     loaders = scope.compiler.loaders
     # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
     adapter = Puppet::Pops::Utils.find_adapter(o, Puppet::Pops::Adapters::LoaderAdapter)
     loader = adapter.nil? ? loaders.private_environment_loader : adapter.loader
     if loader && func = loader.load(:function, name)
-      return func.call(scope, *args)
+      return func.call(scope, *args, &block)
     end
 
     # Call via 3x API if function exists there
@@ -244,8 +244,8 @@ module Puppet::Pops::Evaluator::Runtime3Support
 
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
-    mapped_args = args.map {|a| convert(a, scope, '') }
-    result = scope.send("function_#{name}", mapped_args)
+    mapped_args = Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, scope, '')
+    result = scope.send("function_#{name}", mapped_args, &block)
     # Prevent non r-value functions from leaking their result (they are not written to care about this)
     Puppet::Parser::Functions.rvalue?(name) ? result : nil
   end
@@ -261,6 +261,10 @@ module Puppet::Pops::Evaluator::Runtime3Support
     )
   end
 
+  def convert(value, scope, undef_value)
+    Puppet::Pops::Evaluator::Runtime3Converter.convert(value, scope, undef_value)
+  end
+
   CLASS_STRING = 'class'.freeze
 
   def create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
@@ -423,127 +427,6 @@ module Puppet::Pops::Evaluator::Runtime3Support
     x.is_a?(TrueClass) || x.is_a?(FalseClass)
   end
 
-  def initialize
-    @@convert_visitor   ||= Puppet::Pops::Visitor.new(self, "convert", 2, 2)
-    @@convert2_visitor   ||= Puppet::Pops::Visitor.new(self, "convert2", 2, 2)
-  end
-
-  # Converts 4x supported values to 3x values. This is required because
-  # resources and other objects do not know about the new type system, and does not support
-  # regular expressions. Unfortunately this has to be done for array and hash as well.
-  # A complication is that catalog types needs to be resolved against the scope.
-  #
-  def convert(o, scope, undef_value)
-    @@convert_visitor.visit_this_2(self, o, scope, undef_value)
-  end
-
-  # Converts nested 4x supported values to 3x values. This is required because
-  # resources and other objects do not know about the new type system, and does not support
-  # regular expressions. Unfortunately this has to be done for array and hash as well.
-  # A complication is that catalog types needs to be resolved against the scope.
-  #
-  def convert2(o, scope, undef_value)
-    @@convert2_visitor.visit_this_2(self, o, scope, undef_value)
-  end
-
-
-  def convert_NilClass(o, scope, undef_value)
-    undef_value
-  end
-
-  def convert2_NilClass(o, scope, undef_value)
-    :undef
-  end
-
-  def convert_String(o, scope, undef_value)
-    # although wasteful, needed because user code may mutate these strings in Resources
-    o.frozen? ? o.dup : o
-  end
-  alias convert2_String :convert_String
-
-  def convert_Object(o, scope, undef_value)
-    o
-  end
-  alias :convert2_Object :convert_Object
-
-  def convert_Array(o, scope, undef_value)
-    o.map {|x| convert2(x, scope, undef_value) }
-  end
-  alias :convert2_Array :convert_Array
-
-  def convert_Hash(o, scope, undef_value)
-    result = {}
-    o.each {|k,v| result[convert2(k, scope, undef_value)] = convert2(v, scope, undef_value) }
-    result
-  end
-  alias :convert2_Hash :convert_Hash
-
-  def convert_Regexp(o, scope, undef_value)
-    # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
-    # source form
-    o.inspect
-  end
-  alias :convert2_Regexp :convert_Regexp
-
-  def convert_Symbol(o, scope, undef_value)
-    case o
-    # Support :undef since it may come from a 3x structure
-    when :undef
-      undef_value  # 3x wants undef as either empty string or :undef
-    else
-      o   # :default, and all others are verbatim since they are new in future evaluator
-    end
-  end
-
-  # The :undef symbol should not be converted when nested in arrays or hashes
-  def convert2_Symbol(o, scope, undef_value)
-    o
-  end
-
-  def convert_PAnyType(o, scope, undef_value)
-    o
-  end
-  alias :convert2_PAnyType :convert_PAnyType
-
-  def convert_PCatalogEntryType(o, scope, undef_value)
-    # Since 4x does not support dynamic scoping, all names are absolute and can be
-    # used as is (with some check/transformation/mangling between absolute/relative form
-    # due to Puppet::Resource's idiosyncratic behavior where some references must be
-    # absolute and others cannot be.
-    # Thus there is no need to call scope.resolve_type_and_titles to do dynamic lookup.
-
-    Puppet::Resource.new(*catalog_type_to_split_type_title(o))
-  end
-  alias :convert2_PCatalogEntryType :convert_PCatalogEntryType
-
-  private
-
-  # Produces an array with [type, title] from a PCatalogEntryType
-  # This method is used to produce the arguments for creation of reference resource instances
-  # (used when 3x is operating on a resource).
-  # Ensures that resources are *not* absolute.
-  #
-  def catalog_type_to_split_type_title(catalog_type)
-    split_type = catalog_type.is_a?(Puppet::Pops::Types::PType) ? catalog_type.type : catalog_type
-    case split_type
-    when Puppet::Pops::Types::PHostClassType
-      class_name = split_type.class_name
-      ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
-    when Puppet::Pops::Types::PResourceType
-      type_name = split_type.type_name
-      title = split_type.title
-      if type_name =~ /^(::)?[Cc]lass/
-        ['class', title.nil? ? nil : title.sub(/^::/, '')]
-      else
-        # Ensure that title is '' if nil
-        # Resources with absolute name always results in error because tagging does not support leading ::
-        [type_name.nil? ? nil : type_name.sub(/^::/, ''), title.nil? ? '' : title]
-      end
-    else
-      raise ArgumentError, "Cannot split the type #{catalog_type.class}, it represents neither a PHostClassType, nor a PResourceType."
-    end
-  end
-
   def extract_file_line(o)
     source_pos = Puppet::Pops::Utils.find_closest_positioned(o)
     return [nil, -1] unless source_pos
@@ -587,7 +470,11 @@ module Puppet::Pops::Evaluator::Runtime3Support
   class ExceptionRaisingAcceptor < Puppet::Pops::Validation::Acceptor
     def accept(diagnostic)
       super
-      Puppet::Pops::IssueReporter.assert_and_report(self, {:message => "Evaluation Error:", :emit_warnings => true })
+      Puppet::Pops::IssueReporter.assert_and_report(self, {
+        :message => "Evaluation Error:", 
+        :emit_warnings => true,  # log warnings
+        :exception_class => Puppet::PreformattedError
+      })
       if errors?
         raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
       end

data/lib/puppet/pops/functions/dispatch.rb

@@ -41,36 +41,40 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
   end
 
   # @api private
-  def invoke(instance, calling_scope, args)
-    instance.send(@method_name, *weave(calling_scope, args))
+  def invoke(instance, calling_scope, args, &block)
+    instance.send(@method_name, *weave(calling_scope, args), &block)
   end
 
   # @api private
   def weave(scope, args)
     # no need to weave if there are no injections
-    if injections.empty?
+    if @injections.empty?
       args
     else
       injector = nil # lazy lookup of injector Puppet.lookup(:injector)
-      weaving.map do |knit|
+      new_args = []
+      @weaving.each do |knit|
         if knit.is_a?(Array)
           injection_data = @injections[knit[0]]
-          case injection_data[3]
-          when :dispatcher_internal
-            # currently only supports :scope injection
-            scope
-          when :producer
-            injector ||= Puppet.lookup(:injector)
-            injector.lookup_producer(scope, injection_data[0], injection_data[2])
-          else
-            injector ||= Puppet.lookup(:injector)
-            injector.lookup(scope, injection_data[0], injection_data[2])
-          end
+          new_args <<
+            case injection_data[3]
+            when :dispatcher_internal
+              # currently only supports :scope injection
+              scope
+            when :producer
+              injector ||= Puppet.lookup(:injector)
+              injector.lookup_producer(scope, injection_data[0], injection_data[2])
+            else
+              injector ||= Puppet.lookup(:injector)
+              injector.lookup(scope, injection_data[0], injection_data[2])
+            end
         else
-          # pick that argument (injection of static value)
-          args[knit]
+          # Careful so no new nil arguments are added since they would override default
+          # parameter values in the received
+          new_args << args[knit] if knit < args.size
         end
       end
+      new_args
     end
   end
 end

data/lib/puppet/pops/functions/dispatcher.rb

@@ -27,12 +27,12 @@ class Puppet::Pops::Functions::Dispatcher
   # @return [Object] - what the called function produced
   #
   # @api private
-  def dispatch(instance, calling_scope, args)
+  def dispatch(instance, calling_scope, args, &block)
     tc = Puppet::Pops::Types::TypeCalculator
-    actual = tc.infer_set(args)
+    actual = tc.infer_set(block_given? ? args + [block] : args)
     found = @dispatchers.find { |d| tc.callable?(d.type, actual) }
     if found
-      found.invoke(instance, calling_scope, args)
+      found.invoke(instance, calling_scope, args, &block)
     else
       raise ArgumentError, "function '#{instance.class.name}' called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string(instance.class.name, actual, @dispatchers)}"
     end

data/lib/puppet/pops/functions/function.rb

@@ -40,25 +40,21 @@ class Puppet::Pops::Functions::Function
   # is defined) is available via the method `closure_scope`).
   #
   # @api public
-  def call(scope, *args)
-    self.class.dispatcher.dispatch(self, scope, args)
+  def call(scope, *args, &block)
+    self.class.dispatcher.dispatch(self, scope, args, &block)
   end
 
   # Allows the implementation of a function to call other functions by name. The callable functions
-  # are those visible to the same loader that loaded this function (the calling function).
+  # are those visible to the same loader that loaded this function (the calling function). The
+  # referenced function is called with the calling functions closure scope as the caller's scope.
+  #
+  # @param function_name [String] The name of the function
+  # @param *args [Object] splat of arguments
+  # @return [Object] The result returned by the called function
   #
   # @api public
-  def call_function(function_name, *args)
-    if the_loader = loader
-      func = the_loader.load(:function, function_name)
-      if func
-        return func.call(closure_scope, *args)
-      end
-    end
-    # Raise a generic error to allow upper layers to fill in the details about where in a puppet manifest this
-    # error originates. (Such information is not available here).
-    #
-    raise ArgumentError, "Function #{self.class.name}(): cannot call function '#{function_name}' - not found"
+  def call_function(function_name, *args, &block)
+    internal_call_function(closure_scope, function_name, args, &block)
   end
 
   # The dispatcher for the function
@@ -74,4 +70,40 @@ class Puppet::Pops::Functions::Function
   def self.signatures
     @dispatcher.signatures
   end
+
+  protected
+
+  # Allows the implementation of a function to call other functions by name and pass the caller
+  # scope. The callable functions are those visible to the same loader that loaded this function
+  # (the calling function).
+  #
+  # @param scope [Puppet::Parser::Scope] The caller scope
+  # @param function_name [String] The name of the function
+  # @param args [Array] array of arguments
+  # @return [Object] The result returned by the called function
+  #
+  # @api public
+  def internal_call_function(scope, function_name, args, &block)
+
+    the_loader = loader
+    raise ArgumentError, "Function #{self.class.name}(): cannot call function '#{function_name}' - no loader specified" unless the_loader
+
+    func = the_loader.load(:function, function_name)
+    return func.call(scope, *args, &block) if func
+
+    # Check if a 3x function is present. Raise a generic error if it's not to allow upper layers to fill in the details
+    # about where in a puppet manifest this error originates. (Such information is not available here).
+    loader_scope = closure_scope
+    func_3x = Puppet::Parser::Functions.function(function_name, loader_scope.environment) if loader_scope.is_a?(Puppet::Parser::Scope)
+    raise ArgumentError, "Function #{self.class.name}(): cannot call function '#{function_name}' - not found" unless func_3x
+
+    # Call via 3x API
+    # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
+    # NOTE: Passing an empty string last converts nil/:undef to empty string
+    result = scope.send(func_3x, Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, loader_scope, ''), &block)
+
+    # Prevent non r-value functions from leaking their result (they are not written to care about this)
+    Puppet::Parser::Functions.rvalue?(function_name) ? result : nil
+  end
+
 end