puppet 4.5.3-x86-mingw32 → 4.6.1-x86-mingw32

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

@@ -19,10 +19,18 @@
 #
 # @api public
 #
-class Puppet::Pops::Loader::Loader
+module Puppet::Pops
+module Loader
+class Loader
+  attr_reader :loader_name
 
   # Describes the kinds of things that loaders can load
-  LOADABLE_KINDS = [:func_4x, :func_4xpp, :type_pp].freeze
+  LOADABLE_KINDS = [:func_4x, :func_4xpp, :type_pp, :resource_type_pp].freeze
+
+  # @param [String] name the name of the loader. Must be unique among all loaders maintained by a {Loader} instance
+  def initialize(loader_name)
+    @loader_name = loader_name.freeze
+  end
 
   # Produces the value associated with the given name if already loaded, or available for loading
   # by this loader, one of its parents, or other loaders visible to this loader.
@@ -52,7 +60,7 @@ class Puppet::Pops::Loader::Loader
   # @api public
   #
   def load_typed(typed_name)
-    raise NotImplementedError.new
+    raise NotImplementedError, "Class #{self.class.name} must implement method #load_typed"
   end
 
   # Returns an already loaded entry if one exists, or nil. This does not trigger loading
@@ -64,7 +72,7 @@ class Puppet::Pops::Loader::Loader
   # @api public
   #
   def loaded_entry(typed_name, check_dependencies = false)
-    raise NotImplementedError.new(self.class)
+    raise NotImplementedError, "Class #{self.class.name} must implement method #loaded_entry"
   end
 
   # Produces the value associated with the given name if defined **in this loader**, or nil if not defined.
@@ -94,7 +102,7 @@ class Puppet::Pops::Loader::Loader
   # @api private
   #
   def find(typed_name)
-    raise NotImplementedError.new
+    raise NotImplementedError, "Class #{self.class.name} must implement method #find"
   end
 
   # Returns the parent of the loader, or nil, if this is the top most loader. This implementation returns nil.
@@ -156,49 +164,6 @@ class Puppet::Pops::Loader::Loader
       freeze()
     end
   end
-
-  # A name/type combination that can be used as a compound hash key
-  #
-  class TypedName
-    DOUBLE_COLON = '::'
-
-    attr_reader :hash
-    attr_reader :type
-    attr_reader :name
-    attr_reader :name_parts
-    attr_reader :compound_name
-
-    def initialize(type, name)
-      @type = type
-      # relativize the name (get rid of leading ::), and make the split string available
-      parts = name.to_s.split(DOUBLE_COLON)
-      if parts[0].empty?
-        parts.shift
-        @name = name[2..-1]
-      else
-        @name = name
-      end
-      @name_parts = parts
-
-      # Use a frozen compound key for the hash and comparison
-      @compound_name = "#{type}/#{name}".freeze
-      @hash = @compound_name.hash
-      freeze
-    end
-
-    def ==(o)
-      o.class == self.class && o.compound_name == @compound_name
-    end
-
-    alias eql? ==
-
-    def qualified?
-      @name_parts.size > 1
-    end
-
-    def to_s
-      @compound_name
-    end
-  end
 end
-
+end
+end

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

@@ -25,6 +25,8 @@ module Puppet::Pops::Loader::LoaderPaths
         # When wanted also add FunctionPath3x to load 3x functions
     when :type
       result << TypePathPP.new(loader) if loader.loadables.include?(:type_pp)
+    when :resource_type_pp
+      result << ResourceTypeImplPP.new(loader) if loader.loadables.include?(:resource_type_pp)
     else
       # unknown types, simply produce an empty result; no paths to check, nothing to find... move along...
       []
@@ -100,7 +102,6 @@ module Puppet::Pops::Loader::LoaderPaths
     end
 
     def root_path
-      # Drop the lib part (it may not exist and cannot be navigated to in a relative way)
       Puppet::FileSystem.dir_string(@loader.path)
     end
 
@@ -150,7 +151,6 @@ module Puppet::Pops::Loader::LoaderPaths
   end
 
   class TypePathPP < PuppetSmartPath
-    # Navigate to directory where 'lib' is, then down again
     TYPE_PATH_PP = File.join('types')
 
     def relative_path
@@ -162,6 +162,32 @@ module Puppet::Pops::Loader::LoaderPaths
     end
   end
 
+  class ResourceTypeImplPP < PuppetSmartPath
+    RESOURCE_TYPES_PATH_PP = File.join('.resource_types')
+
+    def relative_path
+      RESOURCE_TYPES_PATH_PP
+    end
+
+    def root_path
+      @loader.path
+    end
+
+    def instantiator()
+      Puppet::Pops::Loader::PuppetResourceTypeImplInstantiator
+    end
+
+    # The effect paths for resource type impl is the full name
+    # since resource types are not name spaced.
+    # This overrides the default PuppetSmartPath.
+    #
+    def effective_path(typed_name, start_index_in_name)
+      # Resource type to name does not skip the name-space
+      # i.e. <module>/mymodule/resource_types/foo.pp is the reource type foo
+      "#{File.join(generic_path, typed_name.name_parts)}.pp"
+    end
+  end
+
   # SmartPaths
   # ===
   # Holds effective SmartPath instances per type

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

@@ -46,6 +46,15 @@ module ModuleLoaders
                                                        )
   end
 
+  def self.pcore_resource_type_loader_from(parent_loader, loaders, environment_path)
+    ModuleLoaders::FileBased.new(parent_loader,
+      loaders,
+      nil,
+      environment_path,
+      'pcore_resource_types'
+    )
+  end
+
   class AbstractPathBasedModuleLoader < BaseLoader
 
     # The name of the module, or nil, if this is a global "component"
@@ -66,6 +75,7 @@ module ModuleLoaders
 
     # Initialize a kind of ModuleLoader for one module
     # @param parent_loader [Loader] loader with higher priority
+    # @param loaders [Loaders] the container for this loader
     # @param module_name [String] the name of the module (non qualified name), may be nil for a global "component"
     # @param path [String] the path to the root of the module (semantics defined by subclass)
     # @param loader_name [String] a name that is used for human identification (useful when module_name is nil)
@@ -81,6 +91,7 @@ module ModuleLoaders
       unless (loadables - LOADABLE_KINDS).empty?
         raise ArgumentError, 'given loadables are not of supported loadable kind'
       end
+      loaders.add_loader_by_name(self)
     end
 
     def loadables
@@ -92,6 +103,9 @@ module ModuleLoaders
     # @return [Loader::NamedEntry, nil found/created entry, or nil if not found
     #
     def find(typed_name)
+      # This loader is tailored to only find entries in the current runtime
+      return nil unless typed_name.name_authority == Pcore::RUNTIME_NAME_AUTHORITY
+
       # Assume it is a global name, and that all parts of the name should be used when looking up
       name_part_index = 0
       name_parts = typed_name.name_parts
@@ -116,6 +130,7 @@ module ModuleLoaders
         case typed_name.type
         when :function
         when :resource_type
+        when :resource_type_pp
         when :type
         else
           # anything else cannot possibly be in this module
@@ -190,7 +205,7 @@ module ModuleLoaders
     def private_loader
       # The system loader has a nil module_name and it does not have a private_loader as there are no functions
       # that can only by called by puppet runtime - if so, it acts as the private loader directly.
-      @private_loader ||= ((module_name.nil? && self) || @loaders.private_loader_for_module(module_name))
+      @private_loader ||= (module_name.nil? || module_name == 'environment' ? self : @loaders.private_loader_for_module(module_name))
     end
   end
 

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

@@ -6,7 +6,7 @@ class Puppet::Pops::Loader::NullLoader < Puppet::Pops::Loader::Loader
   # Construct a NullLoader, optionally with a parent loader
   #
   def initialize(parent_loader=nil, loader_name = "null-loader")
-    @loader_name = loader_name
+    super(loader_name)
     @parent = parent_loader
   end
 
@@ -15,6 +15,14 @@ class Puppet::Pops::Loader::NullLoader < Puppet::Pops::Loader::Loader
     @parent
   end
 
+  def find(typed_name)
+    if @parent.nil?
+      nil
+    else
+      @parent.find(typed_name)
+    end
+  end
+
   def load_typed(typed_name)
     if @parent.nil?
       nil
@@ -23,6 +31,14 @@ class Puppet::Pops::Loader::NullLoader < Puppet::Pops::Loader::Loader
     end
   end
 
+  def loaded_entry(typed_name, check_dependencies = false)
+    if @parent.nil?
+      nil
+    else
+      @parent.loaded_entry(typed_name, check_dependencies)
+    end
+  end
+
   # Has no entries on its own - always nil
   def get_entry(typed_name)
     nil

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

@@ -46,12 +46,13 @@ class PuppetFunctionInstantiator
     # 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
     private_loader = loader.private_loader
-    Adapters::LoaderAdapter.adapt(the_function_definition).loader = private_loader
+    Adapters::LoaderAdapter.adapt(the_function_definition).loader_name = private_loader.loader_name
 
-    # TODO: Cheating wrt. scope - assuming it is found in the context
-    closure_scope = Puppet.lookup(:global_scope) { {} }
+    # Cannot bind loaded functions to global scope, that must be done without binding that scope as
+    # loaders survive a compilation.
+    closure_scope = nil # Puppet.lookup(:global_scope) { {} }
 
-    created = create_function_class(the_function_definition, closure_scope)
+    created = create_function_class(the_function_definition)
     # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
     # when calling functions etc.
     # It should be bound to global scope
@@ -60,22 +61,22 @@ class PuppetFunctionInstantiator
   end
 
   # Creates Function class and instantiates it based on a FunctionDefinition model
-  # @return [Array<Loader::TypedName, Functions.Function>] - array of 
+  # @return [Array<TypedName, Functions.Function>] - array of
   #   typed name, and an instantiated function with global scope closure associated with the given loader
   #
   def self.create_from_model(function_definition, loader)
-    closure_scope = Puppet.lookup(:global_scope) { {} }
-    created = create_function_class(function_definition, closure_scope)
-    typed_name = Loader::TypedName.new(:function, function_definition.name)
-    [typed_name, created.new(closure_scope, loader)]
+    created = create_function_class(function_definition)
+    typed_name = TypedName.new(:function, function_definition.name)
+    [typed_name, created.new(nil, loader)]
   end
 
-  def self.create_function_class(function_definition, closure_scope)
+  def self.create_function_class(function_definition)
     # Create a 4x function wrapper around a named closure
     Puppet::Functions.create_function(function_definition.name, Puppet::Functions::PuppetFunction) do
+      # TODO: should not create a new evaluator per function
       init_dispatch(Evaluator::Closure::Named.new(
         function_definition.name,
-        Evaluator::EvaluatorImpl.new(), function_definition, closure_scope))
+        Evaluator::EvaluatorImpl.new(), function_definition))
     end
   end
 end

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

@@ -0,0 +1,80 @@
+module Puppet::Pops
+module Loader
+# The PuppetResourceTypeImplInstantiator instantiates a Puppet::Pops::ResourceTypeImpl object.
+# given a Puppet Programming language source that when called evaluates the Puppet logic it contains.
+#
+class PuppetResourceTypeImplInstantiator
+  # Produces an instance of Puppet::Pops::ResourceTypeImpl, or fails with an error if the
+  # given puppet source does not produce such an instance when evaluated.
+  #
+  # @param loader [Loader] The loader the function is associated with
+  # @param typed_name [TypedName] the type / name of the resoure type impl to load
+  # @param source_ref [URI, String] a reference to the source / origin of the puppet code to evaluate
+  # @param pp_code_string [String] puppet code in a string
+  #
+  # @return [Puppet::Pops::ResourceTypeImpl] - an instantiated ResourceTypeImpl
+  #
+  def self.create(loader, typed_name, source_ref, pp_code_string)
+    parser = Parser::EvaluatingParser.new()
+
+    # parse and validate
+    result = parser.parse_string(pp_code_string, source_ref)
+    model = result.model
+    statements = if model.is_a?(Model::Program)
+      if model.body.is_a?(Model::BlockExpression)
+        statements = model.body.statements
+      else
+        statements = [model.body]
+      end
+    else
+      statements = EMPTY_ARRAY
+    end
+    statements = statements.reject { |s| s.is_a?(Model::Nop) }
+    if statements.empty?
+      raise ArgumentError, "The code loaded from #{source_ref} does not create the resource type '#{typed_name.name}' - it is empty"
+    end
+
+    rname = Resource::ResourceTypeImpl._ptype.name
+    unless statements.find do |s|
+      if s.is_a?(Model::CallMethodExpression)
+        functor_expr = s.functor_expr
+        functor_expr.is_a?(Model::NamedAccessExpression) &&
+          functor_expr.left_expr.is_a?(Model::QualifiedReference) &&
+          functor_expr.left_expr.cased_value == rname &&
+          functor_expr.right_expr.is_a?(Model::QualifiedName) &&
+          functor_expr.right_expr.value == 'new'
+      else
+        false
+      end
+    end
+      raise ArgumentError, "The code loaded from #{source_ref} does not create the resource type '#{typed_name.name}' - no call to #{rname}.new found."
+    end
+
+    unless statements.size == 1
+      raise ArgumentError, "The code loaded from #{source_ref} must contain only the creation of resource type '#{typed_name.name}' - it has additional logic."
+    end
+
+    closure_scope = Puppet.lookup(:global_scope) { {} }
+    resource_type_impl = parser.evaluate(closure_scope, result)
+
+    unless resource_type_impl.is_a?(Puppet::Pops::Resource::ResourceTypeImpl)
+      got = resource_type.class
+      raise ArgumentError, "The code loaded from #{source_ref} does not define the resource type '#{typed_name.name}' - got '#{got}'."
+    end
+
+    unless resource_type_impl.name == typed_name.name
+      expected = typed_name.name
+      actual = resource_type_impl.name
+      raise ArgumentError, "The code loaded from #{source_ref} produced resource type with the wrong name, expected '#{expected}', actual '#{actual}'"
+    end
+
+    # Adapt the resource type 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
+    Adapters::LoaderAdapter.adapt(resource_type_impl).loader_name = loader.loader_name
+    resource_type_impl
+  end
+
+end
+end
+end

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

@@ -30,10 +30,9 @@ class Puppet::Pops::Loader::RubyFunctionInstantiator
     # when calling functions etc.
     # It should be bound to global scope
 
-    # Cheating wrt. scope - assuming it is found in the context (else an empty hash is used).
-    closure_scope = Puppet.lookup(:global_scope) { {} }
+    # Sets closure scope to nil, to let it be picked up at runtime from Puppet.lookup(:global_scope)
     # If function definition used the loader from the binding to create a new loader, that loader wins
-    created.new(closure_scope, loader_for_function)
+    created.new(nil, loader_for_function)
   end
 
   private

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

@@ -7,9 +7,10 @@ module Loader
 #
 # @api private
 class Runtime3TypeLoader < BaseLoader
-  def initialize(parent_loader, environment)
+  def initialize(parent_loader, loaders, environment, env_path)
     super(parent_loader, environment.name)
     @environment = environment
+    @resource_3x_loader = env_path.nil? ? nil : ModuleLoaders.pcore_resource_type_loader_from(parent_loader, loaders, env_path)
   end
 
   def to_s()
@@ -21,28 +22,66 @@ class Runtime3TypeLoader < BaseLoader
   # @return [Loader::NamedEntry, nil found/created entry, or nil if not found
   #
   def find(typed_name)
-    return nil unless typed_name.type == :type
+    return nil unless typed_name.name_authority == Pcore::RUNTIME_NAME_AUTHORITY
+    case typed_name.type
+    when :type
+      value = nil
+      name = typed_name.name
+      if @resource_3x_loader.nil?
+        value = Puppet::Type.type(name) unless typed_name.qualified?
+        if value.nil?
+          # Look for a user defined type
+          value = @environment.known_resource_types.find_definition(name)
+        end
+      else
+        impl_te = find_impl(TypedName.new(:resource_type_pp, name, typed_name.name_authority))
+        value = impl_te.value unless impl_te.nil?
+      end
 
-    name = typed_name.name
-    value = @environment.known_resource_types.find_definition(name)
-    if value.nil?
-      # Look for Puppet::Type
-      value = Puppet::Type.type(name)
       if value.nil?
         # Cache the fact that it wasn't found
         set_entry(typed_name, nil)
         return nil
       end
+
+      # Loaded types doesn't have the same life cycle as this loader, so we must start by
+      # checking if the type was created. If it was, an entry will already be stored in
+      # this loader. If not, then it was created before this loader was instantiated and
+      # we must therefore add it.
+      te = get_entry(typed_name)
+      te = set_entry(typed_name, Types::TypeFactory.resource(value.name.to_s)) if te.nil? || te.value.nil?
+      te
+    when :resource_type_pp
+      @resource_3x_loader.nil? ? nil : find_impl(typed_name)
+    else
+      nil
     end
+  end
 
-    # Loaded types doesn't have the same life cycle as this loader, so we must start by
-    # checking if the type was created. If it was, an entry will already be stored in
-    # this loader. If not, then it was created before this loader was instantiated and
-    # we must therefore add it.
-    te = get_entry(typed_name)
-    te = set_entry(typed_name, Types::TypeFactory.resource(value.name.to_s)) if te.nil? || te.value.nil?
+  # Find the implementation for the resource type by first consulting the internal loader for pp defined 'Puppet::Resource::ResourceType3'
+  # instances, then check for a Puppet::Type and lastly check for a defined type.
+  #
+  def find_impl(typed_name)
+    name = typed_name.name
+    te = StaticLoader::BUILTIN_TYPE_NAMES_LC.include?(name) ? nil : @resource_3x_loader.find(typed_name)
+    if te.nil? || te.value.nil?
+      # Look for Puppet::Type
+      value = Puppet::Type.type(name) unless typed_name.qualified?
+      if value.nil?
+        # Look for a user defined type
+        value = @environment.known_resource_types.find_definition(name)
+        if value.nil?
+          # Cache the fact that it wasn't found
+          @resource_3x_loader.set_entry(typed_name, nil)
+          return nil
+        end
+      end
+      te = @resource_3x_loader.get_entry(typed_name)
+      te = @resource_3x_loader.set_entry(typed_name, value) if te.nil? || te.value.nil?
+    end
     te
   end
+  private :find_impl
 
   # Allows shadowing since this loader is populalted with all loaded resource types at time
   # of loading. This loading will, for built in types override the aliases configured in the static