puppet 4.0.0 → 4.10.0

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

@@ -1,25 +1,23 @@
+module Puppet::Pops
+module Loader
 # BaseLoader
 # ===
-# An abstract implementation of Puppet::Pops::Loader::Loader
+# An abstract implementation of Loader
 #
 # A derived class should implement `find(typed_name)` and set entries, and possible handle "miss caching".
 #
 # @api private
 #
-class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
+class BaseLoader < Loader
 
   # The parent loader
   attr_reader :parent
 
-  # An internal name used for debugging and error message purposes
-  attr_reader :loader_name
-
   def initialize(parent_loader, loader_name)
+    super(loader_name)
     @parent = parent_loader # the higher priority loader to consult
     @named_values = {}      # hash name => NamedEntry
-    @last_name = nil        # the last name asked for (optimization)
     @last_result = nil      # the value of the last name (optimization)
-    @loader_name = loader_name # the name of the loader (not the name-space it is a loader for)
   end
 
   # @api public
@@ -30,11 +28,22 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
     # These modules are typically parented by the same
     # loader as the one initiating the search. It is inefficient to again try to search the same loader for
     # the same name.
-    if typed_name == @last_name
+    if @last_result.nil? || typed_name != @last_result.typed_name
+      @last_result = internal_load(typed_name)
+    else
       @last_result
+    end
+  end
+
+  # @api public
+  #
+  def loaded_entry(typed_name, check_dependencies = false)
+    if @named_values.has_key?(typed_name)
+      @named_values[typed_name]
+    elsif parent
+      parent.loaded_entry(typed_name, check_dependencies)
     else
-      @last_name = typed_name
-      @last_result = internal_load(typed_name)
+      nil
     end
   end
 
@@ -49,14 +58,36 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
   # @api private
   #
   def set_entry(typed_name, value, origin = nil)
-    if entry = @named_values[typed_name] then fail_redefined(entry); end
-    @named_values[typed_name] = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, value, origin)
+    # It is never ok to redefine in the very same loader unless redefining a 'not found'
+    if entry = @named_values[typed_name]
+      fail_redefine(entry) unless entry.value.nil?
+    end
+
+    # Check if new entry shadows existing entry and fail
+    # (unless special loader allows shadowing)
+    if typed_name.type == :type && !allow_shadowing?
+      entry = loaded_entry(typed_name)
+      if entry
+        fail_redefine(entry) unless entry.value.nil? #|| entry.value == value
+      end
+    end
+
+    @last_result = Loader::NamedEntry.new(typed_name, value, origin)
+    @named_values[typed_name] = @last_result
   end
 
   # @api private
   #
   def add_entry(type, name, value, origin)
-    set_entry(Puppet::Pops::Loader::Loader::TypedName.new(type, name), value, origin)
+    set_entry(TypedName.new(type, name), value, origin)
+  end
+
+  # @api private
+  #
+  def remove_entry(typed_name)
+    unless @named_values.delete(typed_name).nil?
+      @last_result = nil unless @last_result.nil? || typed_name != @last_result.typed_name
+    end
   end
 
   # Promotes an already created entry (typically from another loader) to this loader
@@ -69,25 +100,35 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
     @named_values[typed_name] = named_entry
   end
 
+  protected
+
+  def allow_shadowing?
+    false
+  end
+
   private
 
   def fail_redefine(entry)
-    origin_info = entry.origin ? " Originally set at #{origin_label(entry.origin)}." : "unknown location"
-    raise ArgumentError, "Attempt to redefine entity '#{entry.typed_name}' originally set at #{origin_info}"
+    origin_info = entry.origin ? "Originally set #{origin_label(entry.origin)}." : "Set at unknown location"
+    raise ArgumentError, "Attempt to redefine entity '#{entry.typed_name}'. #{origin_info}"
   end
 
   # TODO: Should not really be here?? - TODO: A Label provider ? semantics for the URI?
   #
   def origin_label(origin)
     if origin && origin.is_a?(URI)
-      origin.to_s
+      format_uri(origin)
     elsif origin.respond_to?(:uri)
-      origin.uri.to_s
+      format_uri(origin.uri)
     else
       origin
     end
   end
 
+  def format_uri(uri)
+    (uri.scheme == 'puppet' ? 'by ' : 'at ') + uri.to_s.sub(/^puppet:/,'')
+  end
+
   # loads in priority order:
   # 1. already loaded here
   # 2. load from parent
@@ -95,8 +136,21 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
   # 4. give up
   #
   def internal_load(typed_name)
-    # avoid calling get_entry, by looking it up
-    @named_values[typed_name] || parent.load_typed(typed_name) || find(typed_name)
-  end
+    # avoid calling get_entry by looking it up
+    te = @named_values[typed_name]
+    return te unless te.nil? || te.value.nil?
 
+    te = parent.load_typed(typed_name)
+    return te unless te.nil? || te.value.nil?
+
+    # Under some circumstances, the call to the parent loader will have resulted in files being
+    # parsed that in turn contained references to the requested entity and hence, caused a
+    # recursive call into this loader. This means that the entry might be present now, so a new
+    # check must be made.
+    te = @named_values[typed_name]
+    te.nil? || te.value.nil? ? find(typed_name) : te
+  end
 end
+end
+end
+

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

@@ -48,13 +48,38 @@ class Puppet::Pops::Loader::DependencyLoader < Puppet::Pops::Loader::BaseLoader
     end
   end
 
-  def to_s()
+  # @api public
+  #
+  def loaded_entry(typed_name, check_dependencies = false)
+    super || (check_dependencies ? loaded_entry_in_dependency(typed_name, check_dependencies) : nil)
+  end
+
+  def to_s
     "(DependencyLoader '#{@loader_name}' [" + @dependency_loaders.map {|loader| loader.to_s }.join(' ,') + "])"
   end
 
   private
 
-  def index()
+  def loaded_entry_in_dependency(typed_name, check_dependencies)
+    if typed_name.qualified?
+      if l = index[typed_name.name_parts[0]]
+        l.loaded_entry(typed_name)
+      else
+        # no module entered as dependency with name matching first segment of wanted name
+        nil
+      end
+    else
+      # a non name-spaced name, have to search since it can be anywhere.
+      # (Note: superclass caches the result in this loader as it would have to repeat this search for every
+      # lookup otherwise).
+      @dependency_loaders.reduce(nil) do |previous, loader|
+        break previous if !previous.nil?
+        loader.loaded_entry(typed_name, check_dependencies)
+      end
+    end
+  end
+
+  def index
     @index ||= @dependency_loaders.reduce({}) { |index, loader| index[loader.module_name] = loader; index }
   end
 end

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

@@ -19,7 +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, :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.
@@ -49,7 +60,19 @@ 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
+  # of the given type/name.
+  #
+  # @param typed_name [TypedName] - the type, name combination to lookup
+  # @param check_dependencies [Boolean] - if dependencies should be checked in additiona to here and parent
+  # @return [NamedEntry, nil] the entry containing the loaded value, or nil if not found
+  # @api public
+  #
+  def loaded_entry(typed_name, check_dependencies = false)
+    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.
@@ -79,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.
@@ -119,6 +142,31 @@ class Puppet::Pops::Loader::Loader
     raise NotImplementedError.new
   end
 
+  # A loader is by default a loader for all kinds of loadables. An implementation may override
+  # if it cannot load all kinds.
+  #
+  # @api private
+  def loadables
+    LOADABLE_KINDS
+  end
+
+  # A loader may want to implement its own version with more detailed information.
+  def to_s
+    loader_name
+  end
+
+  # Loaders may contain references to the environment they load items within.
+  # Consequently, calling Kernel#inspect may return strings that are large
+  # enough to cause OutOfMemoryErrors on some platforms.
+  #
+  # We do not call alias_method here as that would copy the content of to_s
+  # at this point to inspect (ie children would print out `loader_name`
+  # rather than their version of to_s if they chose to implement it).
+  def inspect
+    self.to_s
+  end
+
+
   # An entry for one entity loaded by the loader.
   #
   class NamedEntry
@@ -133,49 +181,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

@@ -4,7 +4,7 @@
 # The central loader knowledge about paths, what they represent and how to instantiate from them.
 # Contains helpers (*smart paths*) to deal with lazy resolution of paths.
 #
-# TODO: Currently only supports loading of functions (3 kinds)
+# TODO: Currently only supports loading of functions (2 kinds)
 #
 module Puppet::Pops::Loader::LoaderPaths
   # Returns an array of SmartPath, each instantiated with a reference to the given loader (for root path resolution
@@ -12,10 +12,21 @@ module Puppet::Pops::Loader::LoaderPaths
   # mutated.
   #
   def self.relative_paths_for_type(type, loader)
-    result =
+    result = []
     case type
     when :function
-        [FunctionPath4x.new(loader)]
+        # Only include support for the loadable items the loader states it can contain
+        if loader.loadables.include?(:func_4x)
+          result << FunctionPath4x.new(loader)
+        end
+        if loader.loadables.include?(:func_4xpp)
+          result << FunctionPathPP.new(loader)
+        end
+        # 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...
       []
@@ -44,8 +55,12 @@ module Puppet::Pops::Loader::LoaderPaths
     def generic_path()
       return @generic_path unless @generic_path.nil?
 
-      root_path = @loader.path
-      @generic_path = (root_path.nil? ? relative_path : File.join(root_path, relative_path))
+      the_root_path = root_path() # @loader.path
+      @generic_path = (the_root_path.nil? ? relative_path : File.join(the_root_path, relative_path))
+    end
+
+    def root_path
+      @loader.path
     end
 
     # Effective path is the generic path + the name part(s) + extension.
@@ -64,8 +79,10 @@ module Puppet::Pops::Loader::LoaderPaths
   end
 
   class RubySmartPath < SmartPath
+    EXTENSION = '.rb'.freeze
+
     def extension
-      ".rb"
+      EXTENSION
     end
 
     # Duplication of extension information, but avoids one call
@@ -74,6 +91,33 @@ module Puppet::Pops::Loader::LoaderPaths
     end
   end
 
+  # A PuppetSmartPath is rooted at the loader's directory one level up from what the loader specifies as it
+  # path (which is a reference to its 'lib' directory.
+  #
+  class PuppetSmartPath < SmartPath
+    EXTENSION = '.pp'.freeze
+
+    def extension
+      EXTENSION
+    end
+
+    def root_path
+      Puppet::FileSystem.dir_string(@loader.path)
+    end
+
+    # Duplication of extension information, but avoids one call
+    def effective_path(typed_name, start_index_in_name)
+      # Puppet name to path always skips the name-space as that is part of the generic path
+      # i.e. <module>/mymodule/functions/foo.pp is the function mymodule::foo
+      parts = typed_name.name_parts
+      if start_index_in_name > 0
+        return nil if start_index_in_name >= parts.size
+        parts = parts[start_index_in_name..-1]
+      end
+      "#{File.join(generic_path, parts)}.pp"
+    end
+  end
+
   class FunctionPath4x < RubySmartPath
     FUNCTION_PATH_4X = File.join('puppet', 'functions')
 
@@ -86,6 +130,69 @@ module Puppet::Pops::Loader::LoaderPaths
     end
   end
 
+  class FunctionPath3x < RubySmartPath
+    FUNCTION_PATH_3X = File.join('puppet', 'parser', 'functions')
+
+    def relative_path
+      FUNCTION_PATH_3X
+    end
+
+    def instantiator()
+      Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
+    end
+  end
+
+  class FunctionPathPP < PuppetSmartPath
+    # Navigate to directory where 'lib' is, then down again
+    FUNCTION_PATH_PP = File.join('functions')
+
+    def relative_path
+      FUNCTION_PATH_PP
+    end
+
+    def instantiator()
+      Puppet::Pops::Loader::PuppetFunctionInstantiator
+    end
+  end
+
+  class TypePathPP < PuppetSmartPath
+    TYPE_PATH_PP = File.join('types')
+
+    def relative_path
+      TYPE_PATH_PP
+    end
+
+    def instantiator()
+      Puppet::Pops::Loader::TypeDefinitionInstantiator
+    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