puppet 5.0.0 → 6.0.0

data/lib/puppet/pops/issue_reporter.rb

@@ -68,8 +68,13 @@ class IssueReporter
         emitted += 1
         break if emitted >= max_errors
       end
-      warnings_message = (emit_warnings && warnings.size > 0) ? ", and #{warnings.size} warnings" : ""
-      giving_up_message = "Language validation logged #{errors.size} errors#{warnings_message}. Giving up"
+      giving_up_message = if (emit_warnings && warnings.size > 0)
+                            _("Language validation logged %{error_count} errors, and %{warning_count} warnings. Giving up") %
+                                { error_count: errors.size, warning_count: warnings.size }
+                          else
+                            _("Language validation logged %{error_count} errors. Giving up") %
+                                { error_count: errors.size }
+                          end
       exception = emit_exception.new(giving_up_message)
       exception.file = errors[0].file
       raise exception
@@ -81,6 +86,22 @@ class IssueReporter
     [prefix, message].join(' ')
   end
 
+  def self.warning(semantic, issue, args)
+    Puppet::Util::Log.create({
+      :level => :warning,
+      :message => issue.format(args),
+      :arguments => args,
+      :issue_code => issue.issue_code,
+      :file => semantic.file,
+      :line => semantic.line,
+      :pos => semantic.pos,
+    })
+  end
+
+  def self.error(exception_class, semantic, issue, args)
+    raise exception_class.new(issue.format(args), semantic.file, semantic.line, semantic.pos, nil, issue.issue_code, args)
+  end
+
   def self.create_exception(exception_class, emit_message, formatter, diagnostic)
     file = diagnostic.file
     file = (file.is_a?(String) && file.empty?) ? nil : file
@@ -89,7 +110,7 @@ class IssueReporter
       line = diagnostic.source_pos.line
       pos = diagnostic.source_pos.pos
     end
-    exception_class.new(format_with_prefix(emit_message, formatter.format_message(diagnostic)), file, line, pos, nil, diagnostic.issue.issue_code)
+    exception_class.new(format_with_prefix(emit_message, formatter.format_message(diagnostic)), file, line, pos, nil, diagnostic.issue.issue_code, diagnostic.arguments)
   end
   private_class_method :create_exception
 
@@ -104,6 +125,7 @@ class IssueReporter
     Puppet::Util::Log.create({
         :level => severity,
         :message => formatter.format_message(diagnostic),
+        :arguments => diagnostic.arguments,
         :issue_code => diagnostic.issue.issue_code,
         :file => file,
         :line => line,

data/lib/puppet/pops/issues.rb

@@ -49,7 +49,6 @@ module Issues
         # Evaluate the message block in the msg data's binding
         msgdata.format(hash, &message_block)
       rescue StandardError => e
-        MessageData
         raise RuntimeError, _("Error while reporting issue: %{code}. %{message}") % { code: issue_code, message: e.message }, caller
       end
     end
@@ -71,7 +70,7 @@ module Issues
 
     def format(hash, &block)
       @data = hash
-      instance_eval &block
+      instance_eval(&block)
     end
 
     # Obtains the label provider given as a key `:label` in the hash passed to #format. The label provider is
@@ -119,7 +118,7 @@ module Issues
   # @see MessageData
   # @api public
   #
-  def self.issue (issue_code, *args, &block)
+  def self.issue(issue_code, *args, &block)
     Issue.new(issue_code, *args, &block)
   end
 
@@ -287,7 +286,7 @@ module Issues
   end
 
   ILLEGAL_NAME = hard_issue :ILLEGAL_NAME, :name do
-    _("Illegal name. The given name '%{name}' does not conform to the naming rule /^((::)?[a-z_]\w*)(::[a-z]\\w*)*$/") % { name: name }
+    _("Illegal name. The given name '%{name}' does not conform to the naming rule /^((::)?[a-z_]\\w*)(::[a-z]\\w*)*$/") % { name: name }
   end
 
   ILLEGAL_SINGLE_TYPE_MAPPING = hard_issue :ILLEGAL_TYPE_MAPPING, :expression do
@@ -354,7 +353,7 @@ module Issues
   # Issues when a variable is not a NAME
   #
   ILLEGAL_VARIABLE_EXPRESSION = hard_issue :ILLEGAL_VARIABLE_EXPRESSION do
-    _("Illegal variable expression. %{expresion} did not produce a variable name (String or Numeric).") % { expression: label.a_an_uc(semantic) }
+    _("Illegal variable expression. %{expression} did not produce a variable name (String or Numeric).") % { expression: label.a_an_uc(semantic) }
   end
 
   # Issues when an expression is used illegally in a query.
@@ -441,8 +440,7 @@ module Issues
   end
 
   BAD_STRING_SLICE_KEY_TYPE = issue :BAD_STRING_SLICE_KEY_TYPE, :left_value, :actual_type do
-    actual_type_text = _("#{label.article(actual_type)} #{actual_type}")
-    _("A substring operation does not accept %{actual_type_text} as a character index. Expected an Integer") % { actual_type_text: actual_type_text }
+    _("A substring operation does not accept %{label_article} %{actual_type} as a character index. Expected an Integer") % { label_article: label.article(actual_type), actual_type: actual_type }
   end
 
   BAD_NOT_UNDEF_SLICE_TYPE = issue :BAD_NOT_UNDEF_SLICE_TYPE, :base_type, :actual do
@@ -488,6 +486,18 @@ module Issues
     _("Unacceptable name. The name '%{name}' is unacceptable as the name of %{value}") % { name: name, value: label.a_an(semantic) }
   end
 
+  ILLEGAL_DEFINITION_LOCATION = issue :ILLEGAL_DEFINITION_LOCATION, :name, :file do
+    _("Unacceptable location. The name '%{name}' is unacceptable in file '%{file}'") % { name: name, file: file }
+  end
+
+  ILLEGAL_TOP_CONSTRUCT_LOCATION = issue :ILLEGAL_TOP_CONSTRUCT_LOCATION do
+    if semantic.is_a?(Puppet::Pops::Model::NamedDefinition)
+      _("The %{value} '%{name}' is unacceptable as a top level construct in this location") % { name: semantic.name, value: label(semantic) }
+    else
+      _("This %{value} is unacceptable as a top level construct in this location") % { value: label(semantic) }
+    end
+  end
+
   CAPTURES_REST_NOT_LAST = hard_issue :CAPTURES_REST_NOT_LAST, :param_name do
     _("Parameter $%{param} is not last, and has 'captures rest'") % { param: param_name }
   end
@@ -509,7 +519,7 @@ module Issues
   end
 
   NUMERIC_COERCION = issue :NUMERIC_COERCION, :before, :after do
-    "The string '#{before}' was automatically coerced to the numerical value #{after}"
+    _("The string '%{before}' was automatically coerced to the numerical value %{after}") % { before: before, after: after }
   end
 
   UNKNOWN_FUNCTION = issue :UNKNOWN_FUNCTION, :name do
@@ -618,7 +628,7 @@ module Issues
     _("Node inheritance is not supported in Puppet >= 4.0.0. See http://links.puppet.com/puppet-node-inheritance-deprecation")
   end
 
-  ILLEGAL_OVERRIDEN_TYPE = issue :ILLEGAL_OVERRIDEN_TYPE, :actual do
+  ILLEGAL_OVERRIDDEN_TYPE = issue :ILLEGAL_OVERRIDDEN_TYPE, :actual do
     _("Resource Override can only operate on resources, got: %{actual}") % { actual: label.label(actual) }
   end
 
@@ -742,6 +752,10 @@ module Issues
     _('Heredoc without any following lines of text')
   end
 
+  HEREDOC_EMPTY_ENDTAG = hard_issue :HEREDOC_EMPTY_ENDTAG do
+    _('Heredoc with an empty endtag')
+  end
+
   HEREDOC_MULTIPLE_AT_ESCAPES = hard_issue :HEREDOC_MULTIPLE_AT_ESCAPES, :escapes do
     _("An escape char for @() may only appear once. Got '%{escapes}'") % { escapes: escapes.join(', ') }
   end
@@ -750,9 +764,20 @@ module Issues
     _("Illegal %{format} Byte Order mark at beginning of input: %{bom} - remove these from the puppet source") % { format: format_name, bom: bytes }
   end
 
+  NO_SUCH_FILE_OR_DIRECTORY = hard_issue :NO_SUCH_FILE_OR_DIRECTORY, :file do
+    _('No such file or directory: %{file}') % { file: file }
+  end
+
+  NOT_A_FILE = hard_issue :NOT_A_FILE, :file do
+    _('%{file} is not a file') % { file: file }
+  end
+
   NUMERIC_OVERFLOW = hard_issue :NUMERIC_OVERFLOW, :value do
-    range_end = value > 0 ? _('max') : _('min')
-    _("#{label.a_an_uc(semantic)} resulted in a value outside of Puppet Integer #{range_end} range, got '#{"%#+x" % value}'")
+    if value > 0
+      _("%{expression} resulted in a value outside of Puppet Integer max range, got '%{value}'") % { expression: label.a_an_uc(semantic), value: ("%#+x" % value) }
+    else
+      _("%{expression} resulted in a value outside of Puppet Integer min range, got '%{value}'") % { expression: label.a_an_uc(semantic), value: ("%#+x" % value) }
+    end
   end
 
   HIERA_UNSUPPORTED_VERSION = hard_issue :HIERA_UNSUPPORTED_VERSION, :version do
@@ -772,9 +797,12 @@ module Issues
   end
 
   HIERA_BACKEND_MULTIPLY_DEFINED = hard_issue :HIERA_BACKEND_MULTIPLY_DEFINED, :name, :first_line do
-    msg = _("Backend '%{name}' is defined more than once") % { name: name }
+    msg = _("Backend '%{name}' is defined more than once.") % { name: name }
     fl = first_line
-    fl ? _("%{msg}. First defined at line %{line}") % { msg: msg, line: fl } : msg
+    if fl
+      msg += ' ' + _("First defined at %{error_location}") % { error_location: Puppet::Util::Errors.error_location(nil, fl) }
+    end
+    msg
   end
 
   HIERA_NO_PROVIDER_FOR_BACKEND = hard_issue :HIERA_NO_PROVIDER_FOR_BACKEND, :name do
@@ -782,9 +810,12 @@ module Issues
   end
 
   HIERA_HIERARCHY_NAME_MULTIPLY_DEFINED = hard_issue :HIERA_HIERARCHY_NAME_MULTIPLY_DEFINED, :name, :first_line do
-    msg = _("Hierarchy name '%{name}' defined more than once") % { name: name }
+    msg = _("Hierarchy name '%{name}' defined more than once.") % { name: name }
     fl = first_line
-    fl ? _("%{msg}. First defined at line %{line}") % { msg: msg, line: fl } : msg
+    if fl
+      msg += ' ' + _("First defined at %{error_location}") % { error_location: Puppet::Util::Errors.error_location(nil, fl) }
+    end
+    msg
   end
 
   HIERA_V3_BACKEND_NOT_GLOBAL = hard_issue :HIERA_V3_BACKEND_NOT_GLOBAL do
@@ -843,6 +874,10 @@ module Issues
     _('Endless recursion detected when attempting to serialize value of class %{type_name}') % { :type_name => type_name }
   end
 
+  SERIALIZATION_DEFAULT_CONVERTED_TO_STRING = issue :SERIALIZATION_DEFAULT_CONVERTED_TO_STRING, :path, :klass, :value do
+    _("%{path} contains the special value default. It will be converted to the String 'default'") % { path: path }
+  end
+
   SERIALIZATION_UNKNOWN_CONVERTED_TO_STRING = issue :SERIALIZATION_UNKNOWN_CONVERTED_TO_STRING, :path, :klass, :value do
     _("%{path} contains %{klass} value. It will be converted to the String '%{value}'") % { path: path, klass: label.a_an(klass), value: value }
   end
@@ -850,5 +885,37 @@ module Issues
   SERIALIZATION_UNKNOWN_KEY_CONVERTED_TO_STRING = issue :SERIALIZATION_UNKNOWN_KEY_CONVERTED_TO_STRING, :path, :klass, :value do
     _("%{path} contains a hash with %{klass} key. It will be converted to the String '%{value}'") % { path: path, klass: label.a_an(klass), value: value }
   end
+
+  FEATURE_NOT_SUPPORTED_WHEN_SCRIPTING = issue :NOT_SUPPORTED_WHEN_SCRIPTING, :feature do
+    _("The feature '%{feature}' is only available when compiling a catalog") % { feature: feature }
+  end
+
+  CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING = issue :CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING, :operation do
+    _("The catalog operation '%{operation}' is only available when compiling a catalog") % { operation: operation }
+  end
+
+  EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING = issue :EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING, :klass do
+    _("%{expr} is only available when compiling a catalog") % { expr: label.a_an_uc(klass) }
+  end
+
+  TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING = issue :TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, :operation do
+    _("The task operation '%{operation}' is not available when compiling a catalog") % { operation: operation }
+  end
+
+  EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING = issue :EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING, :klass do
+    _("%{expr} is not available when compiling a catalog") % { expr: label.a_an_uc(klass) }
+  end
+
+  TASK_MISSING_BOLT = issue :TASK_MISSING_BOLT, :action do
+    _("The 'bolt' library is required to %{action}") % { action: action }
+  end
+
+  UNKNOWN_TASK = issue :UNKNOWN_TASK, :type_name do
+    _('Task not found: %{type_name}') % { type_name: type_name }
+  end
+
+  LOADER_FAILURE = issue :LOADER_FAILURE, :type do
+    _('Failed to load: %{type_name}') % { type: type }
+  end
 end
 end

data/lib/puppet/pops/label_provider.rb

@@ -73,7 +73,7 @@ module Puppet::Pops::LabelProvider
     end
 
     if char == ""
-      raise Puppet::DevError, "<#{string}> does not appear to contain a word"
+      raise Puppet::DevError, _("<%{string}> does not appear to contain a word") % { string: string }
     end
 
     char

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

@@ -20,6 +20,16 @@ class BaseLoader < Loader
     @last_result = nil      # the value of the last name (optimization)
   end
 
+  def discover(type, error_collector = nil, name_authority = Pcore::RUNTIME_NAME_AUTHORITY, &block)
+    result = []
+    @named_values.each_pair do |key, entry|
+      result << key unless entry.nil? || entry.value.nil? || key.type != type || (block_given? && !yield(key))
+    end
+    result.concat(parent.discover(type, error_collector, name_authority, &block))
+    result.uniq!
+    result
+  end
+
   # @api public
   #
   def load_typed(typed_name)

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

@@ -23,6 +23,13 @@ class Puppet::Pops::Loader::DependencyLoader < Puppet::Pops::Loader::BaseLoader
     @dependency_loaders = dependency_loaders
   end
 
+  def discover(type, error_collector = nil, name_authority = Puppet::Pops::Pcore::RUNTIME_NAME_AUTHORITY, &block)
+    result = []
+    @dependency_loaders.each { |loader| result.concat(loader.discover(type, error_collector, name_authority, &block)) }
+    result.concat(super)
+    result
+  end
+
   # Finds name in a loader this loader depends on / can see
   #
   def find(typed_name)

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

@@ -29,13 +29,32 @@ 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
+  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)
     @loader_name = loader_name.freeze
   end
 
+  # Search all places where this loader would find values of a given type and return a list the
+  # found values for which the given block returns true. All found entries will be returned if no
+  # block is given.
+  #
+  # Errors that occur function discovery will either be logged as warnings or collected by the optional
+  # `error_collector` array. When provided, it will receive {Puppet::DataTypes::Error} instances describing
+  # each error in detail and no warnings will be logged.
+  #
+  # @param type [Symbol] the type of values to search for
+  # @param error_collector [Array<Puppet::DataTypes::Error>] an optional array that will receive errors during load
+  # @param name_authority [String] the name authority, defaults to the pcore runtime
+  # @yield [typed_name] optional block to filter the results
+  # @yieldparam [TypedName] typed_name the typed name of a found entry
+  # @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
+  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.
   # This is the method an external party should use to "get" the named element.
@@ -71,7 +90,7 @@ class Loader
   # 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
+  # @param check_dependencies [Boolean] - if dependencies should be checked in addition to here and parent
   # @return [NamedEntry, nil] the entry containing the loaded value, or nil if not found
   # @api public
   #
@@ -88,7 +107,7 @@ class Loader
   #
   # @api private
   #
-  def [] (typed_name)
+  def [](typed_name)
     if found = get_entry(typed_name)
       found.value
     else

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

@@ -6,7 +6,10 @@
 #
 # TODO: Currently only supports loading of functions (2 kinds)
 #
-module Puppet::Pops::Loader::LoaderPaths
+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.
@@ -22,8 +25,15 @@ module Puppet::Pops::Loader::LoaderPaths
         if loader.loadables.include?(:func_4xpp)
           result << FunctionPathPP.new(loader)
         end
-        # When wanted also add FunctionPath3x to load 3x functions
+        if loader.loadables.include?(:func_3x)
+          result << FunctionPath3x.new(loader)
+        end
+    when :plan
+      result << PlanPathPP.new(loader)
+    when :task
+      result << TaskPath.new(loader) if Puppet[:tasks] && loader.loadables.include?(:task)
     when :type
+      result << DataTypePath.new(loader) if loader.loadables.include?(:datatype)
       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)
@@ -52,28 +62,58 @@ module Puppet::Pops::Loader::LoaderPaths
       @loader = loader
     end
 
-    def generic_path()
+    def generic_path
       return @generic_path unless @generic_path.nil?
 
-      the_root_path = root_path() # @loader.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 fuzzy_matching?
+      false
+    end
+
     def root_path
       @loader.path
     end
 
+    def lib_root?
+      @loader.lib_root?
+    end
+
     # Effective path is the generic path + the name part(s) + extension.
     #
     def effective_path(typed_name, start_index_in_name)
       "#{File.join(generic_path, typed_name.name_parts)}#{extension}"
     end
 
-    def relative_path()
+    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 = ''
+      unless extension.empty?
+        # Remove extension
+        relative_path = relative_path[0..-(extension.length+1)]
+      end
+      relative_path.split('/').each do |segment|
+        n << '::' if n.size > 0
+        n << segment
+      end
+      TypedName.new(type, n, name_authority)
+    end
+
+    def valid_path?(path)
+      path.end_with?(extension) && path.start_with?(generic_path)
+    end
+
+    def valid_name?(typed_name)
+      true
+    end
+
+    def relative_path
       raise NotImplementedError.new
     end
 
-    def instantiator()
+    def instantiator
       raise NotImplementedError.new
     end
   end
@@ -101,10 +141,6 @@ module Puppet::Pops::Loader::LoaderPaths
       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
@@ -114,61 +150,144 @@ module Puppet::Pops::Loader::LoaderPaths
         return nil if start_index_in_name >= parts.size
         parts = parts[start_index_in_name..-1]
       end
-      "#{File.join(generic_path, parts)}.pp"
+      "#{File.join(generic_path, parts)}#{extension}"
+    end
+
+    def typed_name(type, name_authority, relative_path, module_name)
+      n = ''
+      n << module_name unless module_name.nil?
+      unless extension.empty?
+        # Remove extension
+        relative_path = relative_path[0..-(extension.length+1)]
+      end
+      relative_path.split('/').each do |segment|
+        n << '::' if n.size > 0
+        n << segment
+      end
+      TypedName.new(type, n, name_authority)
     end
   end
 
   class FunctionPath4x < RubySmartPath
-    FUNCTION_PATH_4X = File.join('puppet', 'functions')
+    SYSTEM_FUNCTION_PATH_4X = File.join('puppet', 'functions').freeze
+    FUNCTION_PATH_4X = File.join('lib', SYSTEM_FUNCTION_PATH_4X).freeze
 
     def relative_path
-      FUNCTION_PATH_4X
+      lib_root? ? SYSTEM_FUNCTION_PATH_4X : FUNCTION_PATH_4X
     end
 
-    def instantiator()
-      Puppet::Pops::Loader::RubyFunctionInstantiator
+    def instantiator
+      RubyFunctionInstantiator
     end
   end
 
   class FunctionPath3x < RubySmartPath
-    FUNCTION_PATH_3X = File.join('puppet', 'parser', 'functions')
+    SYSTEM_FUNCTION_PATH_3X = File.join('puppet', 'parser', 'functions').freeze
+    FUNCTION_PATH_3X = File.join('lib', SYSTEM_FUNCTION_PATH_3X).freeze
 
     def relative_path
-      FUNCTION_PATH_3X
+      lib_root? ? SYSTEM_FUNCTION_PATH_3X : FUNCTION_PATH_3X
     end
 
-    def instantiator()
-      Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
+    def instantiator
+      RubyLegacyFunctionInstantiator
     end
   end
 
   class FunctionPathPP < PuppetSmartPath
-    # Navigate to directory where 'lib' is, then down again
-    FUNCTION_PATH_PP = File.join('functions')
+    FUNCTION_PATH_PP = 'functions'.freeze
 
     def relative_path
       FUNCTION_PATH_PP
     end
 
-    def instantiator()
-      Puppet::Pops::Loader::PuppetFunctionInstantiator
+    def instantiator
+      PuppetFunctionInstantiator
+    end
+  end
+
+  class DataTypePath < RubySmartPath
+    SYSTEM_TYPE_PATH = File.join('puppet', 'datatypes').freeze
+    TYPE_PATH = File.join('lib', SYSTEM_TYPE_PATH).freeze
+
+    def relative_path
+      lib_root? ? SYSTEM_TYPE_PATH : TYPE_PATH
+    end
+
+    def instantiator
+      RubyDataTypeInstantiator
     end
   end
 
   class TypePathPP < PuppetSmartPath
-    TYPE_PATH_PP = File.join('types')
+    TYPE_PATH_PP = 'types'.freeze
 
     def relative_path
       TYPE_PATH_PP
     end
 
-    def instantiator()
-      Puppet::Pops::Loader::TypeDefinitionInstantiator
+    def instantiator
+      TypeDefinitionInstantiator
+    end
+  end
+
+  # 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
+
+    def extension
+      EMPTY_STRING
+    end
+
+    def fuzzy_matching?
+      true
+    end
+
+    def relative_path
+      TASKS_PATH
+    end
+
+    def typed_name(type, name_authority, relative_path, module_name)
+      n = ''
+      n << module_name unless module_name.nil?
+
+      # Remove the file extension, defined as everything after the *last* dot.
+      relative_path = relative_path.sub(%r{\.[^/.]*\z}, '')
+
+      if relative_path == 'init' && !(module_name.nil? || module_name.empty?)
+        TypedName.new(type, module_name, name_authority)
+      else
+        relative_path.split('/').each do |segment|
+          n << '::' if n.size > 0
+          n << segment
+        end
+        TypedName.new(type, n, name_authority)
+      end
+    end
+
+    def instantiator
+      require_relative 'task_instantiator'
+      TaskInstantiator
+    end
+
+    def valid_name?(typed_name)
+      # TODO: Remove when PE has proper namespace handling
+      typed_name.name_parts.size <= 2
+    end
+
+    def valid_path?(path)
+      path.start_with?(generic_path) && is_task_name?(File.basename(path, '.*')) && !FORBIDDEN_EXTENSIONS.any? { |ext| path.end_with?(ext) }
+    end
+
+    def is_task_name?(name)
+      !!(name =~ /^[a-z][a-z0-9_]*$/)
     end
   end
 
   class ResourceTypeImplPP < PuppetSmartPath
-    RESOURCE_TYPES_PATH_PP = File.join('.resource_types')
+    RESOURCE_TYPES_PATH_PP = '.resource_types'.freeze
 
     def relative_path
       RESOURCE_TYPES_PATH_PP
@@ -178,8 +297,8 @@ module Puppet::Pops::Loader::LoaderPaths
       @loader.path
     end
 
-    def instantiator()
-      Puppet::Pops::Loader::PuppetResourceTypeImplInstantiator
+    def instantiator
+      PuppetResourceTypeImplInstantiator
     end
 
     # The effect paths for resource type impl is the full name
@@ -188,11 +307,41 @@ module Puppet::Pops::Loader::LoaderPaths
     #
     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
+      # i.e. <module>/mymodule/resource_types/foo.pp is the resource type foo
       "#{File.join(generic_path, typed_name.name_parts)}.pp"
     end
   end
 
+  class PlanPathPP < PuppetSmartPath
+    PLAN_PATH_PP = File.join('plans')
+
+    def relative_path
+      PLAN_PATH_PP
+    end
+
+    def instantiator()
+      Puppet::Pops::Loader::PuppetPlanInstantiator
+    end
+
+    def typed_name(type, name_authority, relative_path, module_name)
+      if relative_path == 'init.pp' && !(module_name.nil? || module_name.empty?)
+        TypedName.new(type, module_name, name_authority)
+      else
+        n = ''
+        n << module_name unless module_name.nil?
+        unless extension.empty?
+          # Remove extension
+          relative_path = relative_path[0..-(extension.length+1)]
+        end
+        relative_path.split('/').each do |segment|
+          n << '::' if n.size > 0
+          n << segment
+        end
+        TypedName.new(type, n, name_authority)
+      end
+    end
+  end
+
   # SmartPaths
   # ===
   # Holds effective SmartPath instances per type
@@ -215,7 +364,7 @@ module Puppet::Pops::Loader::LoaderPaths
       unless effective_paths = smart_paths[type]
         # type not yet processed, does the various directories for the type exist ?
         # Get the relative dirs for the type
-        paths_for_type = Puppet::Pops::Loader::LoaderPaths.relative_paths_for_type(type, loader)
+        paths_for_type = LoaderPaths.relative_paths_for_type(type, loader)
         # Check which directories exist in the loader's content/index
         effective_paths = smart_paths[type] = paths_for_type.select { |sp| loader.meaningful_to_search?(sp) }
       end
@@ -223,3 +372,6 @@ module Puppet::Pops::Loader::LoaderPaths
     end
   end
 end
+end
+end
+