puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

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

@@ -0,0 +1,101 @@
+# CallableSignature
+# ===
+# A CallableSignature describes how something callable expects to be called.
+# Different implementation of this class are used for different types of callables.
+#
+# @api public
+#
+class Puppet::Pops::Evaluator::CallableSignature
+
+  # Returns the names of the parameters as an array of strings. This does not include the name
+  # of an optional block parameter.
+  #
+  # All implementations are not required to supply names for parameters. They may be used if present,
+  # to provide user feedback in errors etc. but they are not authoritative about the number of
+  # required arguments, optional arguments, etc.
+  #
+  # A derived class must implement this method.
+  #
+  # @return [Array<String>] - an array of names (that may be empty if names are unavailable)
+  #
+  # @api public
+  #
+  def parameter_names
+    raise NotImplementedError.new
+  end
+
+  # Returns a PCallableType with the type information, required and optional count, and type information about
+  # an optional block.
+  #
+  # A derived class must implement this method.
+  #
+  # @return [Puppet::Pops::Types::PCallableType]
+  # @api public
+  #
+  def type
+    raise NotImplementedError.new
+  end
+
+  # Returns the expected type for an optional block. The type may be nil, which means that the callable does
+  # not accept a block. If a type is returned it is one of Callable, Optional[Callable], Variant[Callable,...],
+  # or Optional[Variant[Callable, ...]]. The Variant type is used when multiple signatures are acceptable.
+  # The Optional type is used when the block is optional.
+  #
+  # @return [Puppet::Pops::Types::PAbstractType, nil] the expected type of a block given as the last parameter in a call.
+  #
+  # @api public
+  #
+  def block_type
+    type.block_type
+  end
+
+  # Returns the name of the block parameter if the callable accepts a block.
+  # @return [String] the name of the block parameter
+  # A derived class must implement this method.
+  # @api public
+  #
+  def block_name
+    raise NotImplementedError.new
+  end
+
+  # Returns a range indicating the optionality of a block. One of [0,0] (does not accept block), [0,1] (optional
+  # block), and [1,1] (block required)
+  #
+  # @return [Array(Integer, Integer)] the range of the block parameter
+  #
+  def block_range
+    type.block_range
+  end
+
+  # Returns the range of required/optional argument values as an array of [min, max], where an infinite
+  # end is given as INFINITY. To test against infinity, use the infinity? method.
+  #
+  # @return [Array[Integer, Numeric]] - an Array with [min, max]
+  #
+  # @api public
+  #
+  def args_range
+    type.size_range
+  end
+
+  # Returns true if the last parameter captures the rest of the arguments, with a possible cap, as indicated
+  # by the `args_range` method.
+  # A derived class must implement this method.
+  #
+  # @return [Boolean] true if last parameter captures the rest of the given arguments (up to a possible cap)
+  # @api public
+  #
+  def last_captures_rest?
+    raise NotImplementedError.new
+  end
+
+  # Returns true if the given x is infinity
+  # @return [Boolean] true, if given value represents infinity
+  #
+  # @api public
+  #
+  def infinity?(x)
+    x == Puppet::Pops::Types::INFINITY
+  end
+
+end

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

@@ -2,11 +2,14 @@
 # A Closure represents logic bound to a particular scope.
 # As long as the runtime (basically the scope implementation) has the behaviour of Puppet 3x it is not
 # safe to use this closure when the scope given to it when initialized goes "out of scope".
-# 
+#
 # Note that the implementation is backwards compatible in that the call method accepts a scope, but this
 # scope is not used.
 #
-class Puppet::Pops::Evaluator::Closure
+# 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
   attr_reader :evaluator
   attr_reader :model
   attr_reader :enclosing_scope
@@ -18,11 +21,14 @@ class Puppet::Pops::Evaluator::Closure
   end
 
   # marker method checked with respond_to :puppet_lambda
+  # @api private
+  # @deprecated Use the type system to query if an object is of Callable type, then use its signatures method for info
   def puppet_lambda()
     true
   end
 
   # compatible with 3x AST::Lambda
+  # @api public
   def call(scope, *args)
     @evaluator.call(self, args, @enclosing_scope)
   end
@@ -50,8 +56,57 @@ class Puppet::Pops::Evaluator::Closure
     @model.parameters.count { |p| !p.value.nil? }
   end
 
+  # @api public
   def parameter_names
     @model.parameters.collect {|p| p.name }
   end
 
+  # @api public
+  def type
+    @callable || create_callable_type
+  end
+
+  # @api public
+  def last_captures_rest?
+    # TODO: No support for this yet
+    false
+  end
+
+  # @api public
+  def block_name
+    # TODO: Lambda's does not support blocks yet. This is a placeholder
+    'unsupported_block'
+  end
+
+  private
+
+  def create_callable_type()
+    t = Puppet::Pops::Types::PCallableType.new()
+    tuple_t = Puppet::Pops::Types::PTupleType.new()
+    # since closure lambdas are currently untyped, each parameter becomes Optional[Object]
+    parameter_names.each do |name|
+      # TODO: Change when Closure supports typed parameters
+      tuple_t.addTypes(Puppet::Pops::Types::TypeFactory.optional_object())
+    end
+
+    # TODO: A Lambda can not currently declare varargs
+    to = parameter_count
+    from = to - optional_parameter_count
+    if from != to
+      size_t = Puppet::Pops::Types::PIntegerType.new()
+      size_t.from = size
+      size_t.to = size
+      tuple_t.size_type = size_t
+    end
+    t.param_types = tuple_t
+    # TODO: A Lambda can not currently declare that it accepts a lambda, except as an explicit parameter
+    # being a Callable
+    t
+  end
+
+  # Produces information about parameters compatible with a 4x Function (which can have multiple signatures)
+  def signatures
+    [ self ]
+  end
+
 end

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

@@ -64,7 +64,7 @@ class Puppet::Pops::Evaluator::CompareOperator
   def cmp_Numeric(a, b)
     if n2 = Puppet::Pops::Utils.to_n(b)
       a <=> n2
-    elsif b.kind_of(String)
+    elsif b.kind_of?(String)
       # Numeric is always lexiographically smaller than a string, even if the string is empty.
       -1
     else

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

@@ -82,8 +82,14 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   def evaluate(target, scope)
     begin
       @@eval_visitor.visit_this_1(self, target, scope)
+
+    rescue Puppet::Pops::SemanticError => e
+      # a raised issue may not know the semantic target
+      fail(e.issue, e.semantic || target, e.options, e)
+
     rescue StandardError => e
       if e.is_a? Puppet::ParseError
+        # ParseError's are supposed to be fully configured with location information
         raise e
       end
       fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
@@ -205,7 +211,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       #
       # "given" is always an optional entry. If a parameter was provided then
       # the entry will be in the array, otherwise the m array will be a
-      # single element.a = []
+      # single element.
       given_argument = m[1]
       argument_name = m[0].name
       default_expression = m[0].value
@@ -756,14 +762,10 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
     name = o.functor_expr.value
-    assert_function_available(name, o, scope)
     evaluated_arguments = o.arguments.collect {|arg| evaluate(arg, scope) }
     # wrap lambda in a callable block if it is present
     evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
-    call_function(name, evaluated_arguments, o, scope) do |result|
-      # prevent functions that are not r-value from leaking its return value
-      rvalue_function?(name, o, scope) ? result : nil
-    end
+    call_function(name, evaluated_arguments, o, scope)
   end
 
   # Evaluation of CallMethodExpression handles a NamedAccessExpression functor (receiver.function_name)
@@ -778,13 +780,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end 
     name = name.value # the string function name
-    assert_function_available(name, o, scope)
     evaluated_arguments = [receiver] + (o.arguments || []).collect {|arg| evaluate(arg, scope) }
     evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
-    call_function(name, evaluated_arguments, o, scope) do |result|
-      # prevent functions that are not r-value from leaking its return value
-      rvalue_function?(name, o, scope) ? result : nil
-    end
+    call_function(name, evaluated_arguments, o, scope)
   end
 
   # @example

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

@@ -4,6 +4,7 @@
 #
 # @api private
 module Puppet::Pops::Evaluator::Runtime3Support
+
   # Fails the evaluation of _semantic_ with a given issue.
   #
   # @param issue [Puppet::Pops::Issue] the issue to report
@@ -13,6 +14,21 @@ module Puppet::Pops::Evaluator::Runtime3Support
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
   def fail(issue, semantic, options={}, except=nil)
+    optionally_fail(issue, semantic, options, except)
+    # an error should have been raised since fail always fails
+    raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
+  end
+
+  # Optionally (based on severity) Fails the evaluation of _semantic_ with a given issue
+  # If the given issue is configured to be of severity < :error it is only reported, and the function returns.
+  #
+  # @param issue [Puppet::Pops::Issue] the issue to report
+  # @param semantic [Puppet::Pops::ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
+  # @param options [Hash] hash of optional named data elements for the given issue
+  # @return [!] this method does not return
+  # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
+  #
+  def optionally_fail(issue, semantic, options={}, except=nil)
     if except.nil?
       # Want a stacktrace, and it must be passed as an exception
       begin
@@ -212,23 +228,27 @@ module Puppet::Pops::Evaluator::Runtime3Support
     n
   end
 
-  # Asserts that the given function name resolves to an available function. The function is loaded
-  # as a side effect. Fails if the function does not exist.
-  #
-  def assert_function_available(name, o, scope)
+  def call_function(name, args, o, scope)
+    # Call via 4x API if it is available, and the function exists
+    #
+    if loaders = Puppet.lookup(:loaders) {nil}
+      # 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)
+      end
+    end
+
     fail(Puppet::Pops::Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)
-  end
 
-  def call_function(name, args, o, scope)
+    # TODO: if Puppet[:biff] == true, then 3x functions should be called via loaders above
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts :undef to empty string
     mapped_args = args.map {|a| convert(a, scope, '') }
-    scope.send("function_#{name}", mapped_args)
-  end
-
-  # Returns true if the function produces a value
-  def rvalue_function?(name, o, scope)
-    Puppet::Parser::Functions.rvalue?(name)
+    result = scope.send("function_#{name}", mapped_args)
+    # 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
 
   # The o is used for source reference
@@ -257,7 +277,6 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
-
     # Build a resource for each title
     resource_titles.map do |resource_title|
         resource = Puppet::Parser::Resource.new(
@@ -292,7 +311,13 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # for the type of the name.
     # Note, locations are available per parameter.
     #
-    scope.define_settings(type_name.capitalize, evaluated_parameters)
+    scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters)
+  end
+
+  # Capitalizes each segment of a qualified name
+  #
+  def capitalize_qualified_name(name)
+    name.split(/::/).map(&:capitalize).join('::')
   end
 
   # Creates resource overrides for all resource type objects in evaluated_resources. The same set of
@@ -330,15 +355,20 @@ module Puppet::Pops::Evaluator::Runtime3Support
   # Returns the value of a resource's parameter by first looking up the parameter in the resource
   # and then in the defaults for the resource. Since the resource exists (it must in order to look up its
   # parameters, any overrides have already been applied). Defaults are not applied to a resource until it
-  # has been finished (which typically has not taked place when this is evaluated; hence the dual lookup).
+  # has been finished (which typically has not taken place when this is evaluated; hence the dual lookup).
   #
   def get_resource_parameter_value(scope, resource, parameter_name)
+    # This gets the parameter value, or nil (for both valid parameters and parameters that do not exist).
     val = resource[parameter_name]
     if val.nil? && defaults = scope.lookupdefaults(resource.type)
       # NOTE: 3x resource keeps defaults as hash using symbol for name as key to Parameter which (again) holds
       # name and value.
+      # NOTE: meta parameters that are unset ends up here, and there are no defaults for those encoded
+      # in the defaults, they may receive hardcoded defaults later (e.g. 'tag').
       param = defaults[parameter_name.to_sym]
-      val = param.value
+      # Some parameters (meta parameters like 'tag') does not return a param from which the value can be obtained
+      # at all times. Instead, they return a nil param until a value has been set.
+      val = param.nil? ? nil : param.value
     end
     val
   end
@@ -430,14 +460,16 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # Needs conversion by calling scope to resolve the name and possibly return a different name
     # Resolution can only be called with an array, and returns an array. Here there is only one name
     type, titles = scope.resolve_type_and_titles(o.type_name, [o.title])
-    Puppet::Resource.new(type, titles[0])
+    # Note: a title of nil makes Resource class throw error with information that is wrong
+    Puppet::Resource.new(type, titles[0].nil? ? '' : titles[0] )
   end
 
   def convert_PHostClassType(o, scope, undef_value)
     # Needs conversion by calling scope to resolve the name and possibly return a different name
     # Resolution can only be called with an array, and returns an array. Here there is only one name
     type, titles = scope.resolve_type_and_titles('class', [o.class_name])
-    Puppet::Resource.new(type, titles[0])
+    # Note: a title of nil makes Resource class throw error with information that is wrong
+    Puppet::Resource.new(type, titles[0].nil? ? '' : titles[0] )
   end
 
   private
@@ -471,16 +503,35 @@ module Puppet::Pops::Evaluator::Runtime3Support
   def diagnostic_producer
     Puppet::Pops::Validation::DiagnosticProducer.new(
       ExceptionRaisingAcceptor.new(),                   # Raises exception on all issues
-      Puppet::Pops::Validation::SeverityProducer.new(), # All issues are errors
+      SeverityProducer.new(), # All issues are errors
+#      Puppet::Pops::Validation::SeverityProducer.new(), # All issues are errors
       Puppet::Pops::Model::ModelLabelProvider.new())
   end
 
+  # Configure the severity of failures
+  class SeverityProducer < Puppet::Pops::Validation::SeverityProducer
+    Issues = Puppet::Pops::Issues
+
+    def initialize
+      super
+      p = self
+      # Issues triggering warning only if --debug is on
+      if Puppet[:debug]
+        p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :warning
+      else
+        p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
+      end
+    end
+  end
+
   # An acceptor of diagnostics that immediately raises an exception.
   class ExceptionRaisingAcceptor < Puppet::Pops::Validation::Acceptor
     def accept(diagnostic)
       super
-      Puppet::Pops::IssueReporter.assert_and_report(self, {:message => "Evaluation Error:" })
-      raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
+      Puppet::Pops::IssueReporter.assert_and_report(self, {:message => "Evaluation Error:", :emit_warnings => true })
+      if errors?
+        raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
+      end
     end
   end
 

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

@@ -0,0 +1,71 @@
+# Defines a connection between a implementation method and the signature that
+# the method will handle.
+#
+# This interface should not be used directly. Instead dispatches should be
+# constructed using the DSL defined in {Puppet::Functions}.
+#
+# @api private
+class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSignature
+  # @api public
+  attr_reader :type
+  # TODO: refactor to parameter_names since that makes it API
+  attr_reader :param_names
+  attr_reader :injections
+
+  # Describes how arguments are woven if there are injections, a regular argument is a given arg index, an array
+  # an injection description.
+  #
+  attr_reader :weaving
+  # @api public
+  attr_reader :block_name
+
+  # @api private
+  def initialize(type, method_name, param_names, block_name, injections, weaving, last_captures)
+    @type = type
+    @method_name = method_name
+    @param_names = param_names || []
+    @block_name = block_name
+    @injections = injections || []
+    @weaving = weaving
+    @last_captures = last_captures
+  end
+
+  # @api private
+  def parameter_names
+    @param_names
+  end
+
+  # @api private
+  def last_captures_rest?
+    !! @last_captures
+  end
+
+  # @api private
+  def invoke(instance, calling_scope, args)
+    instance.send(@method_name, *weave(calling_scope, args))
+  end
+
+  # @api private
+  def weave(scope, args)
+    # no need to weave if there are no injections
+    if injections.empty?
+      args
+    else
+      injector = Puppet.lookup(:injector)
+      weaving.map do |knit|
+        if knit.is_a?(Array)
+          injection_data = @injections[knit[0]]
+          # inject
+          if injection_data[3] == :producer
+            injector.lookup_producer(scope, injection_data[0], injection_data[2])
+          else
+            injector.lookup(scope, injection_data[0], injection_data[2])
+          end
+        else
+          # pick that argument
+          args[knit]
+        end
+      end
+    end
+  end
+end