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

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -55,6 +55,13 @@ class Puppet::Parser::AST::PopsBridge
     end
   end
 
+  class NilAsUndefExpression < Expression
+    def evaluate(scope)
+      result = super
+      result.nil? ? :undef : result
+    end
+  end
+
   # Bridges the top level "Program" produced by the pops parser.
   # Its main purpose is to give one point where all definitions are instantiated (actually defined since the
   # Puppet 3x terminology is somewhat misleading - the definitions are instantiated, but instances of the created types
@@ -85,9 +92,10 @@ class Puppet::Parser::AST::PopsBridge
         when Puppet::Pops::Model::NodeDefinition
           instantiate_NodeDefinition(d, modname)
         else
-          raise Puppet::ParseError("Internal Error: Unknown type of definition - got '#{d.class}'")
+          raise Puppet::ParseError, "Internal Error: Unknown type of definition - got '#{d.class}'"
         end
-      end.flatten() # flatten since node definition may have returned an array
+      end.flatten().compact() # flatten since node definition may have returned an array
+                              # Compact since functions are not understood by compiler
     end
 
     def evaluate(scope)
@@ -109,7 +117,7 @@ class Puppet::Parser::AST::PopsBridge
       # can thus reference all sorts of information. Here the value expression is wrapped in an AST Bridge to a Pops
       # expression since the Pops side can not control the evaluation
       if o.value
-        [ o.name, Expression.new(:value => o.value) ]
+        [ o.name, NilAsUndefExpression.new(:value => o.value) ]
       else
         [ o.name ]
       end
@@ -155,6 +163,39 @@ class Puppet::Parser::AST::PopsBridge
       end
     end
 
+    # Propagates a found Function to the appropriate loader.
+    # This is for 4x future-evaluator/loader
+    #
+    def instantiate_FunctionDefinition(function_definition, modname)
+      loaders = (Puppet.lookup(:loaders) { nil })
+      unless loaders
+        raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing - cannot define any functions"
+      end
+      loader =
+      if modname.nil? || modname == ""
+        # TODO : Later when functions can be private, a decision is needed regarding what that means.
+        #        A private environment loader could be used for logic outside of modules, then only that logic
+        #        would see the function.
+        #
+        # Use the private loader, this function may see the environment's dependencies (currently, all modules)
+        loaders.private_environment_loader()
+      else
+        # TODO : Later check if function is private, and then add it to
+        #        private_loader_for_module
+        #
+        loaders.public_loader_for_module(modname)
+      end
+      unless loader
+        raise Puppet::ParseError, "Internal Error: did not find public loader for module: '#{modname}'"
+      end
+
+      # Instantiate Function, and store it in the environment loader
+      typed_name, f = Puppet::Pops::Loader::PuppetFunctionInstantiator.create_from_model(function_definition, loader)
+      loader.set_entry(typed_name, f, Puppet::Pops::Adapters::SourcePosAdapter.adapt(function_definition).to_uri)
+
+      nil # do not want the function to inadvertently leak into 3x
+    end
+
     def code()
       Expression.new(:value => @value)
     end

data/lib/puppet/parser/collector.rb

@@ -112,7 +112,7 @@ class Puppet::Parser::Collector
           unless existing.collector_id == item.collector_id
             # unless this is the one we've already collected
             raise Puppet::ParseError,
-              "Another local or imported resource exists with the type and title #{item.ref}"
+              "A duplicate resource was found while collecting exported resources, with the type and title #{item.ref}"
           end
         else
           item.exported = false

data/lib/puppet/parser/compiler.rb

@@ -37,6 +37,11 @@ class Puppet::Parser::Compiler
   #
   attr_accessor :injector
 
+  # Access to the configured loaders for 4x
+  # @return [Puppet::Pops::Loader::Loaders] the configured loaders
+  # @api private
+  attr_reader :loaders
+
   # The injector that provides lookup services during the creation of the {#injector}.
   # @return [Puppet::Pops::Binder::Injector, nil] The injector that provides lookup services during injector creation
   #   for this compiler/environment
@@ -98,14 +103,18 @@ class Puppet::Parser::Compiler
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
   def compile
-    Puppet.override({ :current_environment => environment }, "For compiling #{node.name}") do
+    Puppet.override( @context_overrides , "For compiling #{node.name}") do
+      @catalog.environment_instance = environment
+
       # Set the client's parameters into the top scope.
       Puppet::Util::Profiler.profile("Compile: Set node parameters") { set_node_parameters }
 
       Puppet::Util::Profiler.profile("Compile: Created settings scope") { create_settings_scope }
 
       if is_binder_active?
-        Puppet::Util::Profiler.profile("Compile: Created injector") { create_injector }
+        # create injector, if not already created - this is for 3x that does not trigger
+        # lazy loading of injector via context
+        Puppet::Util::Profiler.profile("Compile: Created injector") { injector }
       end
 
       Puppet::Util::Profiler.profile("Compile: Evaluated main") { evaluate_main }
@@ -124,6 +133,23 @@ class Puppet::Parser::Compiler
     end
   end
 
+  # Constructs the overrides for the context
+  def context_overrides()
+    if Puppet[:parser] == 'future'
+      require 'puppet/loaders'
+      {
+        :current_environment => environment,
+        :global_scope => @topscope,             # 4x placeholder for new global scope
+        :loaders  => lambda {|| loaders() },    # 4x loaders
+        :injector => lambda {|| injector() }    # 4x API - via context instead of via compiler
+      }
+    else
+      {
+        :current_environment => environment,
+      }
+    end
+  end
+
   def_delegator :@collections, :delete, :delete_collection
 
   # Return the node's environment.
@@ -232,6 +258,10 @@ class Puppet::Parser::Compiler
     @injector
   end
 
+  def loaders
+    @loaders ||= Puppet::Pops::Loaders.new(environment)
+  end
+
   def boot_injector
     create_boot_injector(nil) if @boot_injector.nil?
     @boot_injector
@@ -471,14 +501,27 @@ class Puppet::Parser::Compiler
     @relationships = []
 
     # For maintaining the relationship between scopes and their resources.
-    @catalog = Puppet::Resource::Catalog.new(@node.name)
-    @catalog.version = known_resource_types.version
+    @catalog = Puppet::Resource::Catalog.new(@node.name, @node.environment)
 
-    @catalog.environment = @node.environment.to_s
-
-    # Create our initial scope and a resource that will evaluate main.
+    # MOVED HERE - SCOPE IS NEEDED (MOVE-SCOPE)
+    # Create the initial scope, it is needed early
     @topscope = Puppet::Parser::Scope.new(self)
 
+    # Need to compute overrides here, and remember them, because we are about to
+    # enter the magic zone of known_resource_types and intial import.
+    # Expensive entries in the context are bound lazily.
+    @context_overrides = context_overrides()
+
+    # This construct ensures that initial import (triggered by instantiating
+    # the structure 'known_resource_types') has a configured context
+    # It cannot survive the initvars method, and is later reinstated
+    # as part of compiling...
+    #
+    Puppet.override( @context_overrides , "For initializing compiler") do
+      # THE MAGIC STARTS HERE ! This triggers parsing, loading etc.
+      @catalog.version = known_resource_types.version
+    end
+
     @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @topscope))
 
     # local resource array to maintain resource ordering

data/lib/puppet/parser/functions.rb

@@ -120,6 +120,12 @@ module Puppet::Parser::Functions
   #
   # @api public
   def self.newfunction(name, options = {}, &block)
+    # Short circuit this call when 4x "biff" is in effect to allow the new loader system to load
+    # and define the function a different way.
+    #
+    if Puppet[:biff]
+      return Puppet::Pops::Loader::RubyLegacyFunctionInstantiator.legacy_newfunction(name, options, &block)
+    end
     name = name.intern
     environment = options[:environment] || Puppet.lookup(:current_environment)
 

data/lib/puppet/parser/functions/generate.rb

@@ -30,7 +30,7 @@ Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue
       end
 
       begin
-        Dir.chdir(File.dirname(args[0])) { Puppet::Util::Execution.execute(args) }
+        Dir.chdir(File.dirname(args[0])) { Puppet::Util::Execution.execute(args).to_str }
       rescue Puppet::ExecutionFailure => detail
         raise Puppet::ParseError, "Failed to execute generator #{args[0]}: #{detail}", detail.backtrace
       end

data/lib/puppet/parser/resource.rb

@@ -253,7 +253,7 @@ class Puppet::Parser::Resource < Puppet::Resource
       validate_parameter(name)
     end
   rescue => detail
-    self.fail Puppet::ParseError, detail.to_s, detail
+    self.fail Puppet::ParseError, detail.to_s + " on #{self}", detail
   end
 
   def extract_parameters(params)

data/lib/puppet/pops.rb

@@ -1,5 +1,14 @@
 module Puppet
-
+  # The Pops language system. This includes the parser, evaluator, AST model, and
+  # Binder.
+  #
+  # @todo Explain how a user should use this to parse and evaluate the puppet
+  #   language.
+  #
+  # @note Warning: Pops is still considered experimental, as such the API may
+  #   change at any time.
+  #
+  # @api public
   module Pops
     require 'puppet/pops/patterns'
     require 'puppet/pops/utils'
@@ -13,6 +22,7 @@ module Puppet
     require 'puppet/pops/containment'
 
     require 'puppet/pops/issues'
+    require 'puppet/pops/semantic_error'
     require 'puppet/pops/label_provider'
     require 'puppet/pops/validation'
     require 'puppet/pops/issue_reporter'
@@ -88,12 +98,23 @@ module Puppet
     end
 
     module Evaluator
+      require 'puppet/pops/evaluator/callable_signature'
       require 'puppet/pops/evaluator/runtime3_support'
       require 'puppet/pops/evaluator/evaluator_impl'
       require 'puppet/pops/evaluator/epp_evaluator'
     end
+
+    # Subsystem for puppet functions defined in ruby.
+    #
+    # @api public
+    module Functions
+      require 'puppet/pops/functions/function'
+      require 'puppet/pops/functions/dispatch'
+      require 'puppet/pops/functions/dispatcher'
+    end
   end
 
   require 'puppet/parser/ast/pops_bridge'
   require 'puppet/bindings'
+  require 'puppet/functions'
 end

data/lib/puppet/pops/adapters.rb

@@ -83,6 +83,13 @@ module Puppet::Pops::Adapters
     def extract_text
       locator.string.slice(offset, length)
     end
+
+    # Produces an URI with path?line=n&pos=n. If origin is unknown the URI is string:?line=n&pos=n
+    def to_uri
+      f = locator.file
+      f = 'string:' if f.nil? || f.empty?
+      URI("#{f}?line=#{line.to_s}&pos=#{pos.to_s}")
+    end
   end
 
   # A LoaderAdapter adapts an object with a {Puppet::Pops::Loader}. This is used to make further loading from the
@@ -95,7 +102,7 @@ module Puppet::Pops::Adapters
   # @see Puppet::Pops::Utils#find_adapter
   #
   class LoaderAdapter < Puppet::Pops::Adaptable::Adapter
-    # @return [Puppet::Pops::Loader] the loader
+    # @return [Puppet::Pops::Loader::Loader] the loader
     attr_accessor :loader
   end
 end

data/lib/puppet/pops/binder/bindings_composer.rb

@@ -20,7 +20,7 @@ class Puppet::Pops::Binder::BindingsComposer
   # @api private
   attr_reader :scheme_handlers
 
-  # @return Hash<String, Puppet::Module> map of module name to module instance
+  # @return [Hash{String => Puppet::Module}] map of module name to module instance
   # @api private
   attr_reader :name_to_module
 

data/lib/puppet/pops/binder/bindings_factory.rb

@@ -213,7 +213,7 @@ module Puppet::Pops::Binder::BindingsFactory
     # @note
     #   This is only needed if something other than the default type `Data` is wanted, or if the wanted type is
     #   not provided by one of the convenience methods {#array_of_data}, {#boolean}, {#float}, {#hash_of_data},
-    #   {#integer}, {#literal}, {#pattern}, {#string}, or one of the collection methods {#array_of}, or {#hash_of}.
+    #   {#integer}, {#scalar}, {#pattern}, {#string}, or one of the collection methods {#array_of}, or {#hash_of}.
     #
     # To create a type, use the method {#type_factory}, to obtain the type.
     # @example creating a Hash with Integer key and Array[Integer] element type

data/lib/puppet/pops/binder/config/binder_config_checker.rb

@@ -2,7 +2,7 @@ module Puppet::Pops::Binder::Config
   # Validates the consistency of a Binder::BinderConfig
   class BinderConfigChecker
     # Create an instance with a diagnostic producer that will receive the result during validation
-    # @param diangostics [DiagnosticProducer] The producer that will receive the diagnostic
+    # @param diagnostics [DiagnosticProducer] The producer that will receive the diagnostic
     # @api public
     #
     def initialize(diagnostics)

data/lib/puppet/pops/binder/producers.rb

@@ -320,7 +320,7 @@ module Puppet::Pops::Binder::Producers
     attr_reader :name
 
     # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param binder [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
     # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
     # @option options [Puppet::Pops::Types::PObjectType] :type The type to lookup
@@ -349,7 +349,7 @@ module Puppet::Pops::Binder::Producers
     attr_reader :key
 
     # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param binder [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
     # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
     # @option options [Puppet::Pops::Types::PObjectType] :type The type to lookup

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

@@ -183,6 +183,10 @@ class Puppet::Pops::Evaluator::AccessOperator
     t
   end
 
+  def access_PCallableType(o, scope, keys)
+    TYPEFACTORY.callable(*keys)
+  end
+
   def access_PStructType(o, scope, keys)
     assert_keys(keys, o, 1, 1, Hash)
     TYPEFACTORY.struct(keys[0])
@@ -439,18 +443,51 @@ class Puppet::Pops::Evaluator::AccessOperator
   #
   def access_PResourceType(o, scope, keys)
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
-    keys.flatten!
+
     if keys.size == 0
-      max = o.type_name.nil? ? 2 : 1
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
-        :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => max, :actual => 0)
+        :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => -1, :actual => 0)
+    end
+
+    # Must know which concrete resource type to operate on in all cases.
+    # It is not allowed to specify the type in an array arg - e.g. Resource[[File, 'foo']]
+    # type_name is LHS type_name if set, else the first given arg
+    type_name = o.type_name || keys.shift
+    type_name = case type_name
+    when Puppet::Pops::Types::PResourceType
+      type_name.type_name
+    when String
+      type_name.downcase
+    else
+      # blame given left expression if it defined the type, else the first given key expression
+      blame = o.type_name.nil? ? @semantic.keys[0] : @semantic.left_expr
+      fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => type_name.class})
+    end
+
+    # The result is an array if multiple titles are given, or if titles are specified with an array
+    # (possibly multiple arrays, and nested arrays).
+    result_type_array = keys.size > 1 || keys[0].is_a?(Array)
+    keys_orig_size = keys.size
+
+    keys.flatten!
+    keys.compact!
+
+    # If given keys  that were just a mix of empty/nil with empty array as a result.
+    # As opposed to calling the function the wrong way (without any arguments), (configurable issue),
+    # Return an empty array
+    #
+    if keys.empty? && keys_orig_size > 0
+      optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
+      return result_type_array ? [] : nil
     end
+
     if !o.title.nil?
       # lookup resource and return one or more parameter values
       resource = find_resource(scope, o.type_name, o.title)
       unless resource
         fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => o.type_name, :title => o.title})
       end
+
       result = keys.map do |k|
         unless is_parameter_of_resource?(scope, resource, k)
           fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
@@ -458,21 +495,9 @@ class Puppet::Pops::Evaluator::AccessOperator
         end
         get_resource_parameter_value(scope, resource, k)
       end
-      return result.size <= 1 ? result.pop : result
+      return result_type_array ? result : result.pop
     end
 
-    # type_name is LHS type_name if set, else the first given arg
-    keys_orig_size = keys.size
-    type_name = o.type_name || keys.shift
-    type_name = case type_name
-    when Puppet::Pops::Types::PResourceType
-      type_name.type_name
-    when String
-      type_name.downcase
-    else
-      blame = keys_orig_size != keys.size ? @semantic.keys[0] : @semantic.left_expr
-      fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => type_name.class})
-    end
 
     keys = [:no_title] if keys.size < 1 # if there was only a type_name and it was consumed
     result = keys.each_with_index.map do |t, i|
@@ -497,18 +522,35 @@ class Puppet::Pops::Evaluator::AccessOperator
       rtype.title = (t == :no_title ? nil : t)
       rtype
     end
-    # returns single type as type, else an array of types
-    result.size == 1 ? result.pop : result
+    # returns single type if request was for a single entity, else an array of types (possibly empty)
+    return result_type_array ? result : result.pop
   end
 
   def access_PHostClassType(o, scope, keys)
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
+    keys_orig_size = keys.size
+
+    # The result is an array if multiple classnames are given, or if classnames are specified with an array
+    # (possibly multiple arrays, and nested arrays).
+    result_type_array = keys.size > 1 || keys[0].is_a?(Array)
 
     keys.flatten!
-    if keys.size == 0
+    keys.compact!
+
+    if keys_orig_size == 0
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
         :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => -1, :actual => 0)
     end
+
+    # If given keys  that were just a mix of empty/nil with empty array as a result.
+    # As opposed to calling the function the wrong way (without any arguments), (configurable issue),
+    # Return an empty array
+    #
+    if keys.empty? && keys_orig_size > 0
+      optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
+      return result_type_array ? [] : nil
+    end
+
     if ! o.class_name.nil?
       # lookup class resource and return one or more parameter values
       resource = find_resource(scope, 'class', o.class_name)
@@ -522,12 +564,9 @@ class Puppet::Pops::Evaluator::AccessOperator
         end
         get_resource_parameter_value(scope, resource, k)
       end
-      return result.size <= 1 ? result.pop : result
-      # TODO: if [] is applied to specific class, it should be treated the same as getting
-      # a resource parameter. Now it fails the operation
-      #
-      fail(Puppet::Pops::Issues::ILLEGAL_TYPE_SPECIALIZATION, semantic.left_expr, {:kind => 'Class'})
+      return result_type_array ? result : result.pop
     end
+
     # The type argument may be a Resource Type - the Puppet Language allows a reference such as
     # Class[Foo], and this is interpreted as Class[Resource[Foo]] - which is ok as long as the resource
     # does not have a title. This should probably be deprecated.
@@ -547,7 +586,8 @@ class Puppet::Pops::Evaluator::AccessOperator
       ctype.class_name = c.downcase.sub(/^::/,'')
       ctype
     end
+
     # returns single type as type, else an array of types
-    result.size == 1 ? result.pop : result
+    return result_type_array ? result : result.pop
   end
 end