puppet 5.3.7-universal-darwin → 5.4.0-universal-darwin

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

@@ -82,6 +82,19 @@ class Puppet::Pops::Evaluator::EppEvaluator
       enforce_parameters = true
     end
 
+    # filter out all qualified names and set them in qualified_variables
+    # only pass unqualified (filtered) variable names to the the template
+    filtered_args = {}
+    template_args.each_pair do |k, v|
+      if k =~ /::/
+        k = k[2..-1] if k.start_with?('::')
+        scope[k] = v
+      else
+        filtered_args[k] = v
+      end
+    end
+    template_args = filtered_args
+
     # inline_epp() logic sees all local variables, epp() all global
     if use_global_scope_only
       scope.with_global_scope do |global_scope|

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

@@ -178,6 +178,15 @@ class EvaluatorImpl
     end
   end
 
+  # Implementation of case option matching.
+  #
+  # This is the type of matching performed in a case option, using == for every type
+  # of value except regular expression where a match is performed.
+  #
+  def match?(left, right)
+    @@compare_operator.match(left, right, nil)
+  end
+
   protected
 
   def lvalue_VariableExpression(o, scope)
@@ -232,6 +241,9 @@ class EvaluatorImpl
           o, scope)
       end
     elsif values.is_a?(Puppet::Pops::Types::PClassType)
+      if Puppet[:tasks]
+        fail(Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING, o, {:operation => _('multi var assignment from class')})
+      end
       # assign variables from class variables
       # lookup class resource and return one or more parameter values
       # TODO: behavior when class_name is nil
@@ -392,7 +404,9 @@ class EvaluatorImpl
     end
 
     left_o = bin_expr.left_expr
-    if (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
+    if left.is_a?(URI) && operator == '+'
+      concatenate(left, right)
+    elsif (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
       # Handle operation on collections
       case operator
       when '+'
@@ -428,9 +442,9 @@ class EvaluatorImpl
           end
         end
         result = left.send(operator, right)
-      rescue NoMethodError => e
+      rescue NoMethodError
         fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
-      rescue ZeroDivisionError => e
+      rescue ZeroDivisionError
         fail(Issues::DIV_BY_ZERO, bin_expr.right_expr)
       end
       case result
@@ -689,7 +703,7 @@ class EvaluatorImpl
   end
 
   # Evaluates a CollectExpression by creating a collector transformer. The transformer
-  # will evaulate the collection, create the appropriate collector, and hand it off
+  # will evaluate the collection, create the appropriate collector, and hand it off
   # to the compiler to collect the resources specified by the query.
   #
   def eval_CollectExpression o, scope
@@ -934,7 +948,7 @@ class EvaluatorImpl
 
     obj = receiver[0]
     receiver_type = Types::TypeCalculator.infer(obj)
-    if receiver_type.is_a?(Types::PObjectType)
+    if receiver_type.is_a?(Types::TypeWithMembers)
       member = receiver_type[name]
       unless member.nil?
         args = unfold([], o.arguments || [], scope)
@@ -1117,7 +1131,11 @@ class EvaluatorImpl
   # * Hash => a merge, where entries in `y` overrides
   # * any other => error
   #
-  # When x is something else, wrap it in an array first.
+  # When x is a URI, y of type produces:
+  #
+  # * String => merge of URI interpreted x + URI(y) using URI merge semantics
+  # * URI => merge of URI interpreted x + y using URI merge semantics
+  # * any other => error
   #
   # When x is nil, an empty array is used instead.
   #
@@ -1147,11 +1165,18 @@ class EvaluatorImpl
   #   @param hsh_x [Hash] the hash to merge to
   #   @param hsh_y [Hash] hash merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `hsh_y`
+  # @overload concatenate(uri_x, uri_y)
+  #   @param uri_x [URI] the uri to merge to
+  #   @param uri_y [URI] uri to merged with `uri_x`
+  #   @return [URI] new uri with `uri_x` merged with `uri_y`
+  # @overload concatenate(uri_x, string_y)
+  #   @param uri_x [URI] the uri to merge to
+  #   @param string_y [String] string to merge with `uri_x`
+  #   @return [URI] new uri with `uri_x` merged with `string_y`
   # @raise [ArgumentError] when `xxx_x` is neither an Array nor a Hash
   # @raise [ArgumentError] when `xxx_x` is a Hash, and `xxx_y` is neither Array nor Hash.
   #
   def concatenate(x, y)
-    x = [x] unless x.is_a?(Array) || x.is_a?(Hash)
     case x
     when Array
       y = case y
@@ -1169,7 +1194,7 @@ class EvaluatorImpl
         # Hash[a,1,b,2] => {a => 1, b => 2}
         # Hash[[a,1], [b,2]] => {[a,1] => [b,2]}
         # Hash[[[a,1], [b,2]]] => {a => 1, b => 2}
-        # Use type calcultor to determine if array is Array[Array[?]], and if so use second form
+        # Use type calculator to determine if array is Array[Array[?]], and if so use second form
         # of call
         t = @@type_calculator.infer(y)
         if t.element_type.is_a? Types::PArrayType
@@ -1178,11 +1203,14 @@ class EvaluatorImpl
           Hash[*y]
         end
       else
-        raise ArgumentError.new(_("Can only append Array or Hash to a Hash"))
+        raise ArgumentError.new(_('Can only append Array or Hash to a Hash'))
       end
       x.merge y # new hash with overwrite
+    when URI
+      raise ArgumentError.new(_('An URI can only be merged with an URI or String')) unless y.is_a?(String) || y.is_a?(URI)
+      x + y
     else
-      raise ArgumentError.new(_("Can only append to an Array or a Hash."))
+      concatenate([x], y)
     end
   end
 

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

@@ -9,7 +9,7 @@ module Evaluator
 # Hash
 # QualifiedName
 # Default (produced :default)
-# Regular Expression (produces ruby reqular expression)
+# Regular Expression (produces ruby regular expression)
 #
 # Not considered literal
 # QualifiedReference  # i.e. File, FooBar

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

@@ -166,7 +166,7 @@ end
 class Runtime3FunctionArgumentConverter < Runtime3Converter
 
   def convert_Regexp(o, scope, undef_value)
-    # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
+    # Puppet 3x cannot handle parameter values that are regular expressions. Turn into regexp string in
     # source form
     o.inspect
   end

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

@@ -330,8 +330,7 @@ module Runtime3Support
   end
 
   def convert(value, scope, undef_value)
-    converter = scope.environment.rich_data? ? Runtime3Converter.instance : Runtime3FunctionArgumentConverter.instance
-    converter.convert(value, scope, undef_value)
+    Runtime3Converter.instance.convert(value, scope, undef_value)
   end
 
   def create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
@@ -375,7 +374,7 @@ module Runtime3Support
     evaluated_parameters = evaluated_parameters.flatten
     evaluated_resources.each do |r|
       unless r.is_a?(Types::PResourceType) && r.type_name != 'class'
-        fail(Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
+        fail(Issues::ILLEGAL_OVERRIDDEN_TYPE, o, {:actual => r} )
       end
       t = Runtime3ResourceSupport.find_resource_type(scope, r.type_name)
       resource = Puppet::Parser::Resource.new(

data/lib/puppet/pops/functions/dispatch.rb

@@ -72,14 +72,15 @@ class Dispatch < Evaluator::CallableSignature
       new_args = []
       @weaving.each do |knit|
         if knit.is_a?(Array)
-          injection_data = @injections[knit[0]]
+          injection_name = @injections[knit[0]]
           new_args <<
-            case injection_data[3]
-            when :dispatcher_internal
-              # currently only supports :scope injection
+            case injection_name
+            when :scope
               scope
+            when :pal_script_compiler
+              Puppet.lookup(:pal_script_compiler)
             else
-              raise_error ArgumentError, _("Unknown injection %{detail}") % { detail: injection_data[3] }
+              raise ArgumentError, _("Unknown injection %{injection_name}") % { injection_name: injection_name }
             end
         else
           # Careful so no new nil arguments are added since they would override default

data/lib/puppet/pops/functions/function.rb

@@ -49,13 +49,13 @@ class Puppet::Pops::Functions::Function
     rescue Puppet::Pops::Evaluator::Next => jumper
       begin
         throw :next, jumper.value
-      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION => uncaught
+      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
         raise Puppet::ParseError.new("next() from context where this is illegal", jumper.file, jumper.line)
       end
     rescue Puppet::Pops::Evaluator::Return => jumper
       begin
         throw :return, jumper
-      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION => uncaught
+      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
         raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
       end
     end

data/lib/puppet/pops/issues.rb

@@ -354,7 +354,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.
@@ -617,7 +617,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
 
@@ -749,6 +749,14 @@ 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
     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) }
@@ -862,5 +870,29 @@ 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
+
+  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
+
+  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/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, :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
   #

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.
@@ -23,7 +26,12 @@ module Puppet::Pops::Loader::LoaderPaths
           result << FunctionPathPP.new(loader)
         end
         # When wanted also add FunctionPath3x to load 3x functions
+    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 +60,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 match_many?
+      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 +139,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 +148,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 match_many?
+      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 +295,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 +305,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 +362,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 +370,6 @@ module Puppet::Pops::Loader::LoaderPaths
     end
   end
 end
+end
+end
+