puppet 4.3.1-x64-mingw32 → 4.3.2-x64-mingw32

data/lib/puppet/pops/adapters.rb

@@ -23,6 +23,7 @@ module Puppet::Pops::Adapters
   #
   class SourcePosAdapter < Puppet::Pops::Adaptable::Adapter
     attr_accessor :locator
+    attr_reader :adapted
 
     def self.create_adapter(o)
       new(o)
@@ -117,5 +118,47 @@ module Puppet::Pops::Adapters
   class LoaderAdapter < Puppet::Pops::Adaptable::Adapter
     # @return [Puppet::Pops::Loader::Loader] the loader
     attr_accessor :loader
+
+    # Attempts to find the module that `instance` originates from by looking at it's {SourcePosAdapter} and
+    # compare the `locator.file` found there with the module paths given in the environment found in the
+    # given `scope`. If the file is found to be relative to a path, then the first segment of the relative
+    # path is interpreted as the name of a module. The object that the {SourcePosAdapter} is adapted to
+    # will then be adapted to the private loader for that module and that adapter is returned.
+    #
+    # The method returns `nil` when no module could be found.
+    #
+    # @param scope
+    # @param instance
+    def self.adapt_by_source(scope, instance)
+      source_pos = Puppet::Pops::Utils.find_adapter(instance, SourcePosAdapter)
+      unless source_pos.nil?
+        mod = find_module_for_file(scope.environment, source_pos.locator.file)
+        unless mod.nil?
+          adapter = LoaderAdapter.adapt(source_pos.adapted)
+          adapter.loader = scope.compiler.loaders.private_loader_for_module(mod.name)
+          return adapter
+        end
+      end
+      nil
+    end
+
+    def self.find_module_for_file(environment, file)
+      return nil if file.nil?
+      file_path = Pathname.new(file)
+      environment.modulepath.each do |path|
+        begin
+          relative_path = file_path.relative_path_from(Pathname.new(path)).to_s.split(File::SEPARATOR)
+        rescue ArgumentError
+          # file_path was not relative to the module_path. That's OK.
+          next
+        end
+        if relative_path.length > 1
+          mod = environment.module(relative_path[0])
+          return mod unless mod.nil?
+        end
+      end
+      nil
+    end
+    private_class_method :find_module_for_file
   end
 end

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

@@ -39,7 +39,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       # Note that Ruby 1.8.7 requires a length of 1 to produce a String
-      k1 = coerce_numeric(keys[0], @semantic.keys, scope)
+      k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
       bad_access_key_type(o, 0, k1, Integer) unless k1.is_a?(Integer)
       k2 = 1
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos
@@ -50,8 +50,8 @@ class Puppet::Pops::Evaluator::AccessOperator
         o[ k1, k2 ]
       end
     when 2
-      k1 = coerce_numeric(keys[0], @semantic.keys, scope)
-      k2 = coerce_numeric(keys[1], @semantic.keys, scope)
+      k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
+      k2 = coerce_numeric(keys[1], @semantic.keys[1], scope)
       [k1, k2].each_with_index { |k,i| bad_access_key_type(o, i, k, Integer) unless k.is_a?(Integer) }
 
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)

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

@@ -54,40 +54,17 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
   # 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 = {}
+      args_hash = args_hash.dup
       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)
-          end
-        else
-          scope_hash[name] = arg_value
-        end
-      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.singleton
-      final_args = tc.infer_set(parameter_names.collect { |param| scope_hash[param] })
-      if !type.callable?(final_args)
-        raise ArgumentError, Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], final_args)
+        # only set result of default expr if it is defined (it is otherwise not possible to differentiate
+        # between explicit undef and no default expression
+        args_hash[name] = @evaluator.evaluate(p.value, @enclosing_scope) if args_hash[name].nil? && !p.value.nil?
       end
-    else
-      scope_hash = args_hash
+      Puppet::Pops::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
@@ -111,6 +88,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]
@@ -196,28 +178,7 @@ 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::PAnyType::DEFAULT
-             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
 
@@ -238,6 +199,45 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
     Puppet::Pops::Types::TypeFactory.callable(*(types + range))
   end
 
+  def create_params_struct
+    type_factory = Puppet::Pops::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
+             Puppet::Pops::Types::PAnyType::DEFAULT
+           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]
+  end
+
   # Produces information about parameters compatible with a 4x Function (which can have multiple signatures)
   def signatures
     [ self ]

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

@@ -125,6 +125,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 +165,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)

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

@@ -248,7 +248,9 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # this is done from the perspective of the environment.
     loader = loaders.private_environment_loader
     if loader && func = loader.load(:function, name)
-      return func.call(scope, *args, &block)
+      Puppet::Util::Profiler.profile(name, [:functions, name]) do
+        return func.call(scope, *args, &block)
+      end
     end
 
     # Call via 3x API if function exists there
@@ -267,9 +269,16 @@ module Puppet::Pops::Evaluator::Runtime3Support
     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)
+
+    # Use source location to determine calling module, or use the private_environment_loader (sees env + all modules)
+    # This is necessary since not all .pp files are loaded by a Puppet::Pops::Loader (see PUP-1833)
+    adapter ||= Puppet::Pops::Adapters::LoaderAdapter.adapt_by_source(scope, o)
+
     loader = adapter.nil? ? loaders.private_environment_loader : adapter.loader
     if loader && func = loader.load(:function, name)
-      return func.call(scope, *args, &block)
+      Puppet::Util::Profiler.profile(name, [:functions, name]) do
+        return func.call(scope, *args, &block)
+      end
     end
 
     # Call via 3x API if function exists there

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

@@ -89,13 +89,17 @@ class Puppet::Pops::Functions::Function
     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
+    if func
+      Puppet::Util::Profiler.profile(function_name, [:functions, function_name]) do
+        return func.call(scope, *args, &block)
+      end
+    end
 
     # 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
+    raise ArgumentError, "Function #{self.class.name}(): Unknown function: '#{function_name}'" unless func_3x
 
     # Call via 3x API
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.

data/lib/puppet/pops/issues.rb

@@ -151,6 +151,10 @@ module Puppet::Pops::Issues
     "Classes, definitions, and nodes may only appear at toplevel or inside other classes"
   end
 
+  NOT_ABSOLUTE_TOP_LEVEL = hard_issue :NOT_ABSOLUTE_TOP_LEVEL do
+    "#{label.a_an_uc(semantic)} may only appear at toplevel"
+  end
+
   CROSS_SCOPE_ASSIGNMENT = hard_issue :CROSS_SCOPE_ASSIGNMENT, :name do
     "Illegal attempt to assign to '#{name}'. Cannot assign to variables in other namespaces"
   end
@@ -536,6 +540,10 @@ module Puppet::Pops::Issues
     "This #{label.label(semantic)} has no effect. A value was produced and then forgotten (one or more preceding expressions may have the wrong form)"
   end
 
+  RESOURCE_WITHOUT_TITLE = issue :RESOURCE_WITHOUT_TITLE, :name do
+    "This expression is invalid. Did you try declaring a '#{name}' resource without a title?"
+  end
+
   IDEM_NOT_ALLOWED_LAST = hard_issue :IDEM_NOT_ALLOWED_LAST, :container do
     "This #{label.label(semantic)} has no effect. #{label.a_an_uc(container)} can not end with a value-producing expression without other effect"
   end
@@ -564,6 +572,10 @@ module Puppet::Pops::Issues
     "Resource Override can only operate on resources, got: #{label.label(actual)}"
   end
 
+  DUPLICATE_PARAMETER = hard_issue :DUPLICATE_PARAMETER, :param_name do
+    "The parameter '#{param_name}' is declared more than once in the parameter list"
+  end
+
   RESERVED_PARAMETER = hard_issue :RESERVED_PARAMETER, :container, :param_name do
     "The parameter $#{param_name} redefines a built in parameter in #{label.the(container)}"
   end
@@ -632,6 +644,10 @@ module Puppet::Pops::Issues
     "Unclosed quote after #{after} followed by '#{followed_by}'"
   end
 
+  UNCLOSED_MLCOMMENT = hard_issue :UNCLOSED_MLCOMMENT do
+    'Unclosed multiline comment'
+  end
+
   EPP_INTERNAL_ERROR = hard_issue :EPP_INTERNAL_ERROR, :error do
     "Internal error: #{error}"
   end

data/lib/puppet/pops/loader/puppet_function_instantiator.rb

@@ -43,7 +43,8 @@ class Puppet::Pops::Loader::PuppetFunctionInstantiator
     # Adapt the function definition with loader - this is used from logic contained in it body to find the
     # loader to use when making calls to the new function API. Such logic have a hard time finding the closure (where
     # the loader is known - hence this mechanism
-    Puppet::Pops::Adapters::LoaderAdapter.adapt(the_function_definition).loader = loader
+    private_loader = loader.private_loader
+    Puppet::Pops::Adapters::LoaderAdapter.adapt(the_function_definition).loader = private_loader
 
     # TODO: Cheating wrt. scope - assuming it is found in the context
     closure_scope = Puppet.lookup(:global_scope) { {} }
@@ -53,7 +54,7 @@ class Puppet::Pops::Loader::PuppetFunctionInstantiator
     # when calling functions etc.
     # It should be bound to global scope
 
-    created.new(closure_scope, loader)
+    created.new(closure_scope, private_loader)
   end
 
   # Creates Function class and instantiates it based on a FunctionDefinition model

data/lib/puppet/pops/lookup.rb

@@ -2,6 +2,9 @@
 # See puppet/functions/lookup.rb for documentation.
 #
 module Puppet::Pops::Lookup
+  LOOKUP_OPTIONS = 'lookup_options'.freeze
+  GLOBAL = '__global__'.freeze
+
   # Performs a lookup in the configured scopes and optionally merges the default.
   #
   # This is a backing function and all parameters are assumed to have been type checked.

data/lib/puppet/pops/lookup/explainer.rb

@@ -28,7 +28,8 @@ module Puppet::Pops::Lookup
   end
 
   class ExplainTreeNode < ExplainNode
-    attr_reader :parent, :event, :key, :value
+    attr_reader :parent, :event, :value
+    attr_accessor :key
 
     def initialize(parent)
       @parent = parent
@@ -133,6 +134,55 @@ module Puppet::Pops::Lookup
     end
   end
 
+  class ExplainTop < ExplainTreeNode
+    def initialize(parent, type, key)
+      super(parent)
+      @type = type
+      self.key = key
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << 'Searching for "' << key << "\"\n"
+      indent = increase_indent(indent)
+      branches.each {|b| b.dump_on(io, indent, indent)}
+    end
+  end
+
+  class ExplainInvalidKey < ExplainTreeNode
+    def initialize(parent, key)
+      super(parent)
+      @key = key
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << "Invalid key \"" << @key << "\"\n"
+    end
+
+    def type
+      :invalid_key
+    end
+  end
+
+  class ExplainMergeSource < ExplainNode
+    attr_reader :merge_source
+
+    def initialize(merge_source)
+      @merge_source = merge_source
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << 'Using merge options from "' << merge_source << "\" hash\n"
+    end
+
+    def to_hash
+      { :type => type, :merge_source => merge_source }
+    end
+
+    def type
+      :merge_source
+    end
+  end
+
   class ExplainInterpolate < ExplainTreeNode
     def initialize(parent, expression)
       super(parent)
@@ -163,6 +213,8 @@ module Puppet::Pops::Lookup
     end
 
     def dump_on(io, indent, first_indent)
+      return if branches.size == 0
+
       # It's pointless to report a merge where there's only one branch
       return branches[0].dump_on(io, indent, first_indent) if branches.size == 1
 
@@ -297,7 +349,7 @@ module Puppet::Pops::Lookup
     def dump_on(io, indent, first_indent)
       io << indent << 'Path "' << @path.path << "\"\n"
       indent = increase_indent(indent)
-      io << indent << 'Original path: ' << @path.original_path << "\n"
+      io << indent << 'Original path: "' << @path.original_path << "\"\n"
       branches.each {|b| b.dump_on(io, indent, indent)}
       io << indent << "Path not found\n" if @event == :path_not_found
       dump_outcome(io, indent)
@@ -332,8 +384,10 @@ module Puppet::Pops::Lookup
   end
 
   class Explainer < ExplainNode
-    def initialize
+    def initialize(explain_options = false, only_explain_options = false)
       @current = self
+      @explain_options = explain_options
+      @only_explain_options = only_explain_options
     end
 
     def push(qualifier_type, qualifier)
@@ -352,6 +406,10 @@ module Puppet::Pops::Lookup
           ExplainMerge.new(@current, qualifier)
         when :scope
           ExplainScope.new(@current)
+        when :meta, :data
+          ExplainTop.new(@current, qualifier_type, qualifier)
+        when :invalid_key
+          ExplainInvalidKey.new(@current, qualifier)
         else
           raise ArgumentError, "Unknown Explain type #{qualifier_type}"
         end
@@ -359,6 +417,14 @@ module Puppet::Pops::Lookup
       @current = node
     end
 
+    def only_explain_options?
+      @only_explain_options
+    end
+
+    def explain_options?
+      @explain_options
+    end
+
     def pop
       @current = @current.parent unless @current.parent.nil?
     end
@@ -375,6 +441,10 @@ module Puppet::Pops::Lookup
       @current.found(key, value)
     end
 
+    def accept_merge_source(merge_source)
+      @current.branches << ExplainMergeSource.new(merge_source)
+    end
+
     def accept_not_found(key)
       @current.not_found(key)
     end