puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Loader
 # BaseLoader
@@ -9,12 +11,11 @@ module Loader
 # @api private
 #
 class BaseLoader < Loader
-
   # The parent loader
   attr_reader :parent
 
-  def initialize(parent_loader, loader_name)
-    super(loader_name)
+  def initialize(parent_loader, loader_name, environment)
+    super(loader_name, environment)
     @parent = parent_loader # the higher priority loader to consult
     @named_values = {}      # hash name => NamedEntry
     @last_result = nil      # the value of the last name (optimization)
@@ -38,22 +39,26 @@ class BaseLoader < 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 @last_result.nil? || typed_name != @last_result.typed_name
-      @last_result = internal_load(typed_name)
-    else
-      @last_result
+    synchronize do
+      if @last_result.nil? || typed_name != @last_result.typed_name
+        @last_result = internal_load(typed_name)
+      else
+        @last_result
+      end
     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
-      nil
+    synchronize do
+      if @named_values.has_key?(typed_name)
+        @named_values[typed_name]
+      elsif parent
+        parent.loaded_entry(typed_name, check_dependencies)
+      else
+        nil
+      end
     end
   end
 
@@ -68,22 +73,25 @@ class BaseLoader < Loader
   # @api private
   #
   def set_entry(typed_name, value, origin = nil)
-    # 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)
+    synchronize do
+      # It is never ok to redefine in the very same loader unless redefining a 'not found'
+      entry = @named_values[typed_name]
       if entry
-        fail_redefine(entry) unless entry.value.nil? #|| entry.value == value
+        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
-    end
 
-    @last_result = Loader::NamedEntry.new(typed_name, value, origin)
-    @named_values[typed_name] = @last_result
+      @last_result = Loader::NamedEntry.new(typed_name, value, origin)
+      @named_values[typed_name] = @last_result
+    end
   end
 
   # @api private
@@ -95,8 +103,10 @@ class BaseLoader < Loader
   # @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
+    synchronize do
+      unless @named_values.delete(typed_name).nil?
+        @last_result = nil unless @last_result.nil? || typed_name != @last_result.typed_name
+      end
     end
   end
 
@@ -105,9 +115,12 @@ class BaseLoader < Loader
   # @api private
   #
   def promote_entry(named_entry)
-    typed_name = named_entry.typed_name
-    if entry = @named_values[typed_name] then fail_redefine(entry); end
-    @named_values[typed_name] = named_entry
+    synchronize do
+      typed_name = named_entry.typed_name
+      entry = @named_values[typed_name]
+      if entry then fail_redefine(entry); end
+      @named_values[typed_name] = named_entry
+    end
   end
 
   protected
@@ -136,7 +149,7 @@ class BaseLoader < Loader
   end
 
   def format_uri(uri)
-    (uri.scheme == 'puppet' ? 'by ' : 'at ') + uri.to_s.sub(/^puppet:/,'')
+    (uri.scheme == 'puppet' ? 'by ' : 'at ') + uri.to_s.sub(/^puppet:/, '')
   end
 
   # loads in priority order:
@@ -163,4 +176,3 @@ class BaseLoader < Loader
 end
 end
 end
-

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # =DependencyLoader
 # This loader provides visibility into a set of other loaders. It is used as a child of a ModuleLoader (or other
 # loader) to make its direct dependencies visible for loading from contexts that have access to this dependency loader.
@@ -8,18 +10,14 @@
 # @api private
 #
 class Puppet::Pops::Loader::DependencyLoader < Puppet::Pops::Loader::BaseLoader
-
-  # An index of module_name to module loader used to speed up lookup of qualified names
-  attr_reader :index
-
   # Creates a DependencyLoader for one parent loader
   #
   # @param parent_loader [Puppet::Pops::Loader] typically a module loader for the root
   # @param name [String] the name of the dependency-loader (used for debugging and tracing only)
   # @param dependency_loaders [Array<Puppet::Pops::Loader>] array of loaders for modules this module depends on
   #
-  def initialize(parent_loader, name, dependency_loaders)
-    super parent_loader, name
+  def initialize(parent_loader, name, dependency_loaders, environment)
+    super(parent_loader, name, environment)
     @dependency_loaders = dependency_loaders
   end
 
@@ -34,7 +32,8 @@ class Puppet::Pops::Loader::DependencyLoader < Puppet::Pops::Loader::BaseLoader
   #
   def find(typed_name)
     if typed_name.qualified?
-      if l = index()[typed_name.name_parts[0]]
+      l = index()[typed_name.name_parts[0]]
+      if l
         l.load_typed(typed_name)
       else
         # no module entered as dependency with name matching first segment of wanted name
@@ -45,7 +44,8 @@ class Puppet::Pops::Loader::DependencyLoader < Puppet::Pops::Loader::BaseLoader
       # (Note: superclass caches the result in this loader as it would have to repeat this search for every
       # lookup otherwise).
       loaded = @dependency_loaders.reduce(nil) do |previous, loader|
-        break previous if !previous.nil?
+        break previous unless previous.nil?
+
         loader.load_typed(typed_name)
       end
       if loaded
@@ -62,14 +62,15 @@ class Puppet::Pops::Loader::DependencyLoader < Puppet::Pops::Loader::BaseLoader
   end
 
   def to_s
-    "(DependencyLoader '#{@loader_name}' [" + @dependency_loaders.map {|loader| loader.to_s }.join(' ,') + "])"
+    "(DependencyLoader '#{@loader_name}' [" + @dependency_loaders.map(&:to_s).join(' ,') + "])"
   end
 
   private
 
   def loaded_entry_in_dependency(typed_name, check_dependencies)
     if typed_name.qualified?
-      if l = index[typed_name.name_parts[0]]
+      l = index[typed_name.name_parts[0]]
+      if l
         l.loaded_entry(typed_name)
       else
         # no module entered as dependency with name matching first segment of wanted name
@@ -80,13 +81,15 @@ class Puppet::Pops::Loader::DependencyLoader < Puppet::Pops::Loader::BaseLoader
       # (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?
+        break previous unless previous.nil?
+
         loader.loaded_entry(typed_name, check_dependencies)
       end
     end
   end
 
+  # An index of module_name to module loader used to speed up lookup of qualified names
   def index
-    @index ||= @dependency_loaders.reduce({}) { |index, loader| index[loader.module_name] = loader; index }
+    @index ||= @dependency_loaders.each_with_object({}) { |loader, index| index[loader.module_name] = loader; }
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # GemSupport offers methods to find a gem's location by name or gem://gemname URI.
 #
 # TODO: The Puppet 3x, uses Puppet::Util::RubyGems to do this, and obtain paths, and avoids using ::Gems
@@ -8,7 +10,6 @@
 # and then trying to access those.
 #
 module Puppet::Pops::Loader::GemSupport
-
   # Produces the root directory of a gem given as an URI (gem://gemname/optional/path), or just the
   # gemname as a string.
   #
@@ -26,9 +27,11 @@ module Puppet::Pops::Loader::GemSupport
   # TODO: FIND by name raises exception Gem::LoadError with list of all gems on the path
   #
   def gem_dir_from_uri(uri)
-    unless spec = Gem::Specification.find_by_name(uri.hostname)
+    spec = Gem::Specification.find_by_name(uri.hostname)
+    unless spec
       raise ArgumentError, _("Gem not found %{uri}") % { uri: uri }
     end
+
     # if path given append that, else append given subdir
     if uri.path.empty?
       spec.gem_dir
@@ -41,9 +44,11 @@ module Puppet::Pops::Loader::GemSupport
   # TODO: FIND by name raises exception Gem::LoadError with list of all gems on the path
   #
   def gem_dir_from_name(gem_name)
-    unless spec = Gem::Specification.find_by_name(gem_name)
+    spec = Gem::Specification.find_by_name(gem_name)
+    unless spec
       raise ArgumentError, _("Gem not found '%{gem_name}'") % { gem_name: gem_name }
     end
+
     spec.full_gem_path
   end
-end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Puppet::Pops
+module Loader
+# The GenericPlanInstantiator dispatches to either PuppetPlanInstantiator or a
+# yaml_plan_instantiator injected through the Puppet context, depending on
+# the type of the plan.
+#
+class GenericPlanInstantiator
+  def self.create(loader, typed_name, source_refs)
+    if source_refs.length > 1
+      raise ArgumentError, _("Found multiple files for plan '%{plan_name}' but only one is allowed") % { plan_name: typed_name.name }
+    end
+
+    source_ref = source_refs[0]
+    code_string = Puppet::FileSystem.read(source_ref, :encoding => 'utf-8')
+
+    instantiator = if source_ref.end_with?('.pp')
+                     Puppet::Pops::Loader::PuppetPlanInstantiator
+                   else
+                     Puppet.lookup(:yaml_plan_instantiator) do
+                       raise Puppet::DevError, _("No instantiator is available to load plan from %{source_ref}") % { source_ref: source_ref }
+                     end
+                   end
+
+    instantiator.create(loader, typed_name, source_ref, code_string)
+  end
+end
+end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Loader
 # ===
 # A Loader is responsible for loading "entities" ("instantiable and executable objects in the puppet language" which
@@ -21,19 +23,19 @@
 #
 module Puppet::Pops
 module Loader
-
-ENVIRONMENT = 'environment'.freeze
-ENVIRONMENT_PRIVATE = 'environment private'.freeze
+ENVIRONMENT = 'environment'
+ENVIRONMENT_PRIVATE = 'environment private'
 
 class Loader
-  attr_reader :loader_name
+  attr_reader :environment, :loader_name
 
   # Describes the kinds of things that loaders can load
   LOADABLE_KINDS = [:func_4x, :func_4xpp, :func_3x, :datatype, :type_pp, :resource_type_pp, :plan, :task].freeze
 
   # @param [String] name the name of the loader. Must be unique among all loaders maintained by a {Loader} instance
-  def initialize(loader_name)
+  def initialize(loader_name, environment)
     @loader_name = loader_name.freeze
+    @environment = environment
   end
 
   # Search all places where this loader would find values of a given type and return a list the
@@ -52,7 +54,7 @@ class Loader
   # @yieldreturn [Boolean] `true` to keep the entry, `false` to discard it.
   # @return [Array<TypedName>] the list of names of discovered values
   def discover(type, error_collector = nil, name_authority = Pcore::RUNTIME_NAME_AUTHORITY, &block)
-    return EMPTY_ARRAY
+    EMPTY_ARRAY
   end
 
   # Produces the value associated with the given name if already loaded, or available for loading
@@ -69,8 +71,11 @@ class Loader
   # @api public
   #
   def load(type, name)
-    if result = load_typed(TypedName.new(type, name.to_s))
-      result.value
+    synchronize do
+      result = load_typed(TypedName.new(type, name.to_s))
+      if result
+        result.value
+      end
     end
   end
 
@@ -108,7 +113,8 @@ class Loader
   # @api private
   #
   def [](typed_name)
-    if found = get_entry(typed_name)
+    found = get_entry(typed_name)
+    if found
       found.value
     else
       nil
@@ -141,6 +147,13 @@ class Loader
     self
   end
 
+  # Lock around a block
+  # This exists so some subclasses that are set up statically and don't actually
+  # load can override it
+  def synchronize(&block)
+    @environment.lock.synchronize(&block)
+  end
+
   # Binds a value to a name. The name should not start with '::', but may contain multiple segments.
   #
   # @param type [:Symbol] the type of the entity being set
@@ -151,7 +164,7 @@ class Loader
   # @api private
   #
   def set_entry(type, name, value, origin = nil)
-    raise NotImplementedError.new
+    raise NotImplementedError
   end
 
   # Produces a NamedEntry if a value is bound to the given name, or nil if nothing is bound.
@@ -162,7 +175,7 @@ class Loader
   # @api private
   #
   def get_entry(typed_name)
-    raise NotImplementedError.new
+    raise NotImplementedError
   end
 
   # A loader is by default a loader for all kinds of loadables. An implementation may override
@@ -186,10 +199,9 @@ class Loader
   # 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
+    to_s
   end
 
-
   # An entry for one entity loaded by the loader.
   #
   class NamedEntry

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 # LoaderPaths
 # ===
@@ -9,7 +10,6 @@
 module Puppet::Pops
 module Loader
 module LoaderPaths
-
   # Returns an array of SmartPath, each instantiated with a reference to the given loader (for root path resolution
   # and existence checks). The smart paths in the array appear in precedence order. The returned array may be
   # mutated.
@@ -18,18 +18,18 @@ module LoaderPaths
     result = []
     case type
     when :function
-        # 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
-        if loader.loadables.include?(:func_3x)
-          result << FunctionPath3x.new(loader)
-        end
+      # 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
+      if loader.loadables.include?(:func_3x)
+        result << FunctionPath3x.new(loader)
+      end
     when :plan
-      result << PlanPathPP.new(loader)
+      result << PlanPath.new(loader)
     when :task
       result << TaskPath.new(loader) if Puppet[:tasks] && loader.loadables.include?(:task)
     when :type
@@ -44,24 +44,22 @@ module LoaderPaths
     result
   end
 
-#  # DO NOT REMOVE YET. needed later? when there is the need to decamel a classname
-#  def de_camel(fq_name)
-#    fq_name.to_s.gsub(/::/, '/').
-#    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-#    gsub(/([a-z\d])([A-Z])/,'\1_\2').
-#    tr("-", "_").
-#    downcase
-#  end
+  #  # DO NOT REMOVE YET. needed later? when there is the need to decamel a classname
+  #  def de_camel(fq_name)
+  #    fq_name.to_s.gsub(/::/, '/').
+  #    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+  #    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+  #    tr("-", "_").
+  #    downcase
+  #  end
 
   class SmartPath
-    # Generic path, in the sense of "if there are any entities of this kind to load, where are they?"
-    attr_reader :generic_path
-
     # Creates SmartPath for the given loader (loader knows how to check for existence etc.)
     def initialize(loader)
       @loader = loader
     end
 
+    # Generic path, in the sense of "if there are any entities of this kind to load, where are they?"
     def generic_path
       return @generic_path unless @generic_path.nil?
 
@@ -89,10 +87,10 @@ module LoaderPaths
 
     def typed_name(type, name_authority, relative_path, module_name)
       # Module name is assumed to be included in the path and therefore not added here
-      n = ''
+      n = ''.dup
       unless extension.empty?
         # Remove extension
-        relative_path = relative_path[0..-(extension.length+1)]
+        relative_path = relative_path[0..-(extension.length + 1)]
       end
       relative_path.split('/').each do |segment|
         n << '::' if n.size > 0
@@ -110,16 +108,16 @@ module LoaderPaths
     end
 
     def relative_path
-      raise NotImplementedError.new
+      raise NotImplementedError
     end
 
     def instantiator
-      raise NotImplementedError.new
+      raise NotImplementedError
     end
   end
 
   class RubySmartPath < SmartPath
-    EXTENSION = '.rb'.freeze
+    EXTENSION = '.rb'
 
     def extension
       EXTENSION
@@ -135,7 +133,7 @@ module LoaderPaths
   # path (which is a reference to its 'lib' directory.
   #
   class PuppetSmartPath < SmartPath
-    EXTENSION = '.pp'.freeze
+    EXTENSION = '.pp'
 
     def extension
       EXTENSION
@@ -148,17 +146,18 @@ module LoaderPaths
       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]
+
+        parts = parts[start_index_in_name..]
       end
       "#{File.join(generic_path, parts)}#{extension}"
     end
 
     def typed_name(type, name_authority, relative_path, module_name)
-      n = ''
+      n = ''.dup
       n << module_name unless module_name.nil?
       unless extension.empty?
         # Remove extension
-        relative_path = relative_path[0..-(extension.length+1)]
+        relative_path = relative_path[0..-(extension.length + 1)]
       end
       relative_path.split('/').each do |segment|
         n << '::' if n.size > 0
@@ -195,7 +194,7 @@ module LoaderPaths
   end
 
   class FunctionPathPP < PuppetSmartPath
-    FUNCTION_PATH_PP = 'functions'.freeze
+    FUNCTION_PATH_PP = 'functions'
 
     def relative_path
       FUNCTION_PATH_PP
@@ -220,7 +219,7 @@ module LoaderPaths
   end
 
   class TypePathPP < PuppetSmartPath
-    TYPE_PATH_PP = 'types'.freeze
+    TYPE_PATH_PP = 'types'
 
     def relative_path
       TYPE_PATH_PP
@@ -234,8 +233,8 @@ module LoaderPaths
   # TaskPath is like PuppetSmartPath but it does not use an extension and may
   # match more than one path with one name
   class TaskPath < PuppetSmartPath
-    TASKS_PATH = 'tasks'.freeze
-    FORBIDDEN_EXTENSIONS = %w{.conf .md}.freeze
+    TASKS_PATH = 'tasks'
+    FORBIDDEN_EXTENSIONS = %w[.conf .md].freeze
 
     def extension
       EMPTY_STRING
@@ -250,7 +249,7 @@ module LoaderPaths
     end
 
     def typed_name(type, name_authority, relative_path, module_name)
-      n = ''
+      n = ''.dup
       n << module_name unless module_name.nil?
 
       # Remove the file extension, defined as everything after the *last* dot.
@@ -287,7 +286,7 @@ module LoaderPaths
   end
 
   class ResourceTypeImplPP < PuppetSmartPath
-    RESOURCE_TYPES_PATH_PP = '.resource_types'.freeze
+    RESOURCE_TYPES_PATH_PP = '.resource_types'
 
     def relative_path
       RESOURCE_TYPES_PATH_PP
@@ -312,27 +311,51 @@ module LoaderPaths
     end
   end
 
-  class PlanPathPP < PuppetSmartPath
-    PLAN_PATH_PP = File.join('plans')
+  class PlanPath < PuppetSmartPath
+    PLAN_PATH = File.join('plans')
+    PP_EXT = '.pp'
+    YAML_EXT = '.yaml'
+
+    def initialize(loader)
+      super
+
+      if Puppet.lookup(:yaml_plan_instantiator) { nil }
+        @extensions = [PP_EXT, YAML_EXT]
+      else
+        @extensions = [PP_EXT]
+      end
+      @init_filenames = @extensions.map { |ext| "init#{ext}" }
+    end
+
+    def extension
+      EMPTY_STRING
+    end
 
     def relative_path
-      PLAN_PATH_PP
+      PLAN_PATH
     end
 
-    def instantiator()
-      Puppet::Pops::Loader::PuppetPlanInstantiator
+    def instantiator
+      Puppet::Pops::Loader::GenericPlanInstantiator
+    end
+
+    def fuzzy_matching?
+      true
+    end
+
+    def valid_path?(path)
+      @extensions.any? { |ext| path.end_with?(ext) } && path.start_with?(generic_path)
     end
 
     def typed_name(type, name_authority, relative_path, module_name)
-      if relative_path == 'init.pp' && !(module_name.nil? || module_name.empty?)
+      if @init_filenames.include?(relative_path) && !(module_name.nil? || module_name.empty?)
         TypedName.new(type, module_name, name_authority)
       else
-        n = ''
+        n = ''.dup
         n << module_name unless module_name.nil?
-        unless extension.empty?
-          # Remove extension
-          relative_path = relative_path[0..-(extension.length+1)]
-        end
+        ext = @extensions.find { |extension| relative_path.end_with?(extension) }
+        relative_path = relative_path[0..-(ext.length + 1)]
+
         relative_path.split('/').each do |segment|
           n << '::' if n.size > 0
           n << segment
@@ -340,6 +363,19 @@ module LoaderPaths
         TypedName.new(type, n, name_authority)
       end
     end
+
+    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..]
+      end
+      basename = File.join(generic_path, parts)
+      @extensions.map { |ext| "#{basename}#{ext}" }
+    end
   end
 
   # SmartPaths
@@ -361,7 +397,8 @@ module LoaderPaths
     def effective_paths(type)
       smart_paths = @smart_paths
       loader = @loader
-      unless effective_paths = smart_paths[type]
+      effective_paths = smart_paths[type]
+      unless effective_paths
         # type not yet processed, does the various directories for the type exist ?
         # Get the relative dirs for the type
         paths_for_type = LoaderPaths.relative_paths_for_type(type, loader)
@@ -374,4 +411,3 @@ module LoaderPaths
 end
 end
 end
-