puppet 6.0.0 → 6.1.0

data/lib/puppet/pal/task_signature.rb

@@ -0,0 +1,58 @@
+module Puppet
+module Pal
+  # A TaskSignature is returned from `task_signature`. Its purpose is to answer questions about the task's parameters
+  # and if it can be run/called with a hash of named parameters.
+  #
+  class TaskSignature
+    def initialize(task)
+      @task = task
+    end
+
+    # Returns whether or not the given arguments are acceptable when running the task.
+    # In addition to returning the boolean outcome, if a block is given, it is called with a string of formatted
+    # error messages that describes the difference between what was given and what is expected. The error message may
+    # have multiple lines of text, and each line is indented one space.
+    #
+    # @param args_hash [Hash] a hash mapping parameter names to argument values
+    # @yieldparam [String] a formatted error message if a type mismatch occurs that explains the mismatch
+    # @return [Boolean] if the given arguments are acceptable when running the task
+    #
+    def runnable_with?(args_hash)
+      params = @task.parameters
+      params_type = if params.nil?
+        T_GENERIC_TASK_HASH
+      else
+        Puppet::Pops::Types::TypeFactory.struct(params)
+      end
+      return true if params_type.instance?(args_hash)
+
+      if block_given?
+        tm = Puppet::Pops::Types::TypeMismatchDescriber.singleton
+        error = if params.nil?
+          tm.describe_mismatch('', params_type, Puppet::Pops::Types::TypeCalculator.infer_set(args_hash))
+        else
+          tm.describe_struct_signature(params_type, args_hash).flatten.map {|e| e.format }.join("\n")
+        end
+        yield "Task #{@task.name}:\n#{error}"
+      end
+      false
+    end
+
+    # Returns the Task instance as a hash
+    #
+    # @return [Hash{String=>Object}] the hash representation of the task
+    def task_hash
+      @task._pcore_init_hash
+    end
+
+    # Returns the Task instance which can be further explored. It contains all meta-data defined for
+    # the task such as the description, parameters, output, etc.
+    #
+    # @return [Puppet::Pops::Types::PuppetObject] An instance of a dynamically created Task class
+    def task
+      @task
+    end
+  end
+
+end
+end

data/lib/puppet/parser/catalog_compiler.rb

@@ -29,4 +29,28 @@ class Puppet::Parser::CatalogCompiler < Puppet::Parser::Compiler
     raise Puppet::Error, message, detail.backtrace
   end
 
+  # Evaluates all added constructs, and validates the resulting catalog.
+  # This can be called whenever a series of evaluation of puppet code strings
+  # have reached a stable state (essentially that there are no relationships to
+  # non-existing resources).
+  #
+  # Raises an error if validation fails.
+  #
+  def compile_additions
+    evaluate_additions
+    validate
+  end
+
+  # Evaluates added constructs that are lazily evaluated until all of them have been evaluated.
+  # 
+  def evaluate_additions
+    evaluate_generators
+    finish
+  end
+
+  # Validates the current state of the catalog.
+  # Does not cause evaluation of lazy constructs.
+  def validate
+    validate_catalog(CatalogValidator::FINAL)
+  end
 end

data/lib/puppet/parser/compiler.rb

@@ -577,6 +577,7 @@ class Puppet::Parser::Compiler
       end
     end
   end
+  protected :evaluate_generators
 
   # Find and evaluate our main object, if possible.
   def evaluate_main
@@ -641,6 +642,7 @@ class Puppet::Parser::Compiler
 
     add_resource_metaparams
   end
+  protected :finish
 
   def add_resource_metaparams
     unless main = catalog.resource(:class, :main)
@@ -780,8 +782,8 @@ class Puppet::Parser::Compiler
     settings_resource = Puppet::Parser::Resource.new('class', SETTINGS, :scope => @topscope)
 
     @catalog.add_resource(settings_resource)
-
     settings_type.evaluate_code(settings_resource)
+    settings_resource.instance_variable_set(:@evaluated, true) # Prevents settings from being reevaluated
 
     scope = @topscope.class_scope(settings_type)
     scope.merge_settings(environment.name)

data/lib/puppet/parser/functions/generate.rb

@@ -1,15 +1,16 @@
 # Runs an external command and returns the results
 Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue,
     :doc => "Calls an external command on the Puppet master and returns
-    the results of the command.  Any arguments are passed to the external command as
-    arguments.  If the generator does not exit with return code of 0,
+    the results of the command. Any arguments are passed to the external command as
+    arguments. If the generator does not exit with return code of 0,
     the generator is considered to have failed and a parse error is
-    thrown.  Generators can only have file separators, alphanumerics, dashes,
-    and periods in them.  This function will attempt to protect you from
+    thrown. Generators can only have file separators, alphanumerics, dashes,
+    and periods in them. This function will attempt to protect you from
     malicious generator calls (e.g., those with '..' in them), but it can
-    never be entirely safe.  No subshell is used to execute
+    never be entirely safe. No subshell is used to execute
     generators, so all shell metacharacters are passed directly to
-    the generator.") do |args|
+    the generator, and all metacharacters are returned by the function.
+    Consider cleaning white space from any string generated.") do |args|
 
       #TRANSLATORS "fully qualified" refers to a fully qualified file system path
       raise Puppet::ParseError, _("Generators must be fully qualified") unless Puppet::Util.absolute_path?(args[0])

data/lib/puppet/plugins/configuration.rb

@@ -10,6 +10,8 @@ module Puppet::Plugins
     require 'puppet/plugins/syntax_checkers'
     require 'puppet/syntax_checkers/base64'
     require 'puppet/syntax_checkers/json'
+    require 'puppet/syntax_checkers/pp'
+    require 'puppet/syntax_checkers/epp'
 
     def self.load_plugins
       # Register extensions
@@ -17,7 +19,9 @@ module Puppet::Plugins
       {
         SyntaxCheckers::SYNTAX_CHECKERS_KEY => {
           'json' => Puppet::SyntaxCheckers::Json.new,
-          'base64' => Puppet::SyntaxCheckers::Base64.new
+          'base64' => Puppet::SyntaxCheckers::Base64.new,
+          'pp' => Puppet::SyntaxCheckers::PP.new,
+          'epp' => Puppet::SyntaxCheckers::EPP.new
         }
       }
     end

data/lib/puppet/pops/evaluator/collectors/abstract_collector.rb

@@ -51,7 +51,9 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
 
       objects.each do |res|
         unless @collected.include?(res.ref)
-          newres = Puppet::Parser::Resource.new(res.type, res.title, @overrides)
+          t = res.type
+          t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t)
+          newres = Puppet::Parser::Resource.new(t, res.title, @overrides)
           scope.compiler.add_override(newres)
         end
       end

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

@@ -96,6 +96,9 @@ class DeferredResolver
     elsif x.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
       # rewrap in a new Sensitive after resolving any nested deferred values
       Puppet::Pops::Types::PSensitiveType::Sensitive.new(resolve(x.unwrap))
+    elsif x.is_a?(Puppet::Pops::Types::PBinaryType::Binary)
+      # use the ASCII-8BIT string that it wraps
+      x.binary_buffer
     else
       x
     end

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

@@ -1028,8 +1028,12 @@ class EvaluatorImpl
 
   # Evaluates Puppet DSL Heredoc
   def eval_HeredocExpression o, scope
+    expr = o.text_expr.expr # Always a SublocatedExpression with an expression
     result = evaluate(o.text_expr, scope)
-    assert_external_syntax(scope, result, o.syntax, o.text_expr)
+    unless expr.is_a?(Model::LiteralString)
+      # When expr is a LiteralString, validation has already validated this
+      assert_external_syntax(scope, result, o.syntax, o.text_expr)
+    end
     result
   end
 

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

@@ -3,11 +3,11 @@
 #
 require 'puppet/plugins/syntax_checkers'
 module Puppet::Pops::Evaluator::ExternalSyntaxSupport
-  def assert_external_syntax(scope, result, syntax, reference_expr)
+  def assert_external_syntax(_, result, syntax, reference_expr)
     # ignore 'unspecified syntax'
     return if syntax.nil? || syntax == ''
 
-    checker = checker_for_syntax(scope, syntax)
+    checker = checker_for_syntax(nil, syntax)
     # ignore syntax with no matching checker
     return unless checker
 
@@ -26,7 +26,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
   # Finds the most significant checker for the given syntax (most significant is to the right).
   # Returns nil if there is no registered checker.
   #
-  def checker_for_syntax(scope, syntax)
+  def checker_for_syntax(_, syntax)
     checkers_hash = Puppet.lookup(:plugins)[Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_KEY]
     checkers_hash[lookup_keys_for_syntax(syntax).find {|x| checkers_hash[x] }]
   end

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

@@ -105,8 +105,8 @@ class Runtime3Converter
   end
 
   def convert_Symbol(o, scope, undef_value)
-    o == :undef ? undef_value : o
-    #o == :undef && !@inner ? undef_value : o
+    return o unless o == :undef
+    !@inner ? undef_value : nil
   end
 
   def convert_PAnyType(o, scope, undef_value)

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

@@ -20,17 +20,26 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
     loader_for_function = loader.private_loader
     here = get_binding(loader_for_function)
 
-    # This will to do the 3x loading and define the "function_<name>" and "real_function_<name>" methods
-    # in the anonymous module used to hold function definitions.
-    #
-    func_info = eval(ruby_code_string, here, source_ref, 1)
+    # Avoid reloading the function if already loaded via one of the APIs that trigger 3x function loading
+    # Check if function is already loaded the 3x way (and obviously not the 4x way since we would not be here in the
+    # first place.
+    environment = Puppet.lookup(:current_environment)
+    func_info = Puppet::Parser::Functions.environment_module(environment).get_function_info(typed_name.name.to_sym)
+    if func_info.nil?
+      # This will to do the 3x loading and define the "function_<name>" and "real_function_<name>" methods
+      # in the anonymous module used to hold function definitions.
+      #
+      func_info = eval(ruby_code_string, here, source_ref, 1)
 
-    unless func_info.is_a?(Hash)
-      raise ArgumentError, _("The code loaded from %{source_ref} did not produce the expected 3x function info Hash when evaluated. Got '%{klass}'") % { source_ref: source_ref, klass: created.class }
-    end
-    unless func_info[:name] == "function_#{typed_name.name()}"
-      raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected 'function_%{type_name}', got %{created_name}") % { 
-        source_ref: source_ref, type_name: typed_name.name, created_name: func_info[:name] }
+      # Validate what was loaded
+      unless func_info.is_a?(Hash)
+        # TRANSLATORS - the word 'newfunction' shoud not be translated as it is a method name.
+        raise ArgumentError, _("Illegal legacy function definition! The code loaded from %{source_ref} did not return the result of calling 'newfunction'. Got '%{klass}'") % { source_ref: source_ref, klass: func_info.class }
+      end
+      unless func_info[:name] == "function_#{typed_name.name()}"
+        raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected 'function_%{type_name}', got '%{created_name}'") % { 
+          source_ref: source_ref, type_name: typed_name.name, created_name: func_info[:name] }
+      end
     end
 
     created = Puppet::Functions::Function3x.create_function(typed_name.name(), func_info, loader_for_function)

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

@@ -1,58 +1,9 @@
 # The TypeDefinitionInstantiator instantiates a type alias or a type definition
 #
+require 'puppet/module/task'
 module Puppet::Pops
 module Loader
 class TaskInstantiator
-  def self.load_metadata(loader, metadata)
-    if metadata.nil?
-      EMPTY_HASH
-    else
-      json_text = loader.get_contents(metadata)
-      begin
-        Puppet::Util::Json.load(json_text).freeze || EMPTY_HASH
-      rescue Puppet::Util::Json::ParseError => ex
-        raise Puppet::ParseError.new(ex.message, metadata)
-      end
-    end
-  end
-
-  def self.validate_implementations(typed_name, directory, metadata, executables)
-    name = typed_name.name
-    basename = typed_name.name_parts[1] || 'init'
-    # If 'implementations' is defined, it needs to mention at least one
-    # implementation, and everything it mentions must exist.
-    if metadata.key?('implementations')
-      if metadata['implementations'].is_a?(Array)
-        metadata['implementations'].map do |impl|
-          path = executables.find { |real_impl| File.basename(real_impl) == impl['name'] }
-          if path
-            { "name" => impl['name'], "requirements" => impl.fetch('requirements', []), "path" => path }
-          else
-            raise ArgumentError, _("Task metadata for task %{name} specifies missing implementation %{implementation}") %
-              { name: name, implementation: impl['name'] }
-          end
-        end
-      else
-        # If 'implementations' is the wrong type, we just pass it through and
-        # let the task type definition reject it.
-        metadata['implementations']
-      end
-    # If implementations isn't defined, then we use executables matching the
-    # task name, and only one may exist.
-    else
-      implementations = executables.select { |impl| File.basename(impl, '.*') == basename }
-      if implementations.empty?
-        raise ArgumentError, _('No source besides task metadata was found in directory %{directory} for task %{name}') %
-          { name: name, directory: directory }
-      elsif implementations.length > 1
-        raise ArgumentError, _("Multiple executables were found in directory %{directory} for task %{name}; define 'implementations' in metadata to differentiate between them") %
-          { name: name, directory: implementations[0] }
-      end
-
-      [{ "name" => File.basename(implementations.first), "path" => implementations.first, "requirements" => [] }]
-    end
-  end
-
   def self.create(loader, typed_name, source_refs)
     name = typed_name.name
     basename = typed_name.name_parts[1] || 'init'
@@ -60,31 +11,16 @@ class TaskInstantiator
     metadata_files, executables = source_refs.partition { |source_ref| source_ref.end_with?('.json') }
     metadata_file = metadata_files.find { |source_ref| File.basename(source_ref, '.json') == basename }
 
-    metadata = load_metadata(loader, metadata_file)
+    metadata = Puppet::Module::Task.read_metadata(metadata_file) || {}
 
-    implementation_metadata = validate_implementations(typed_name, dirname, metadata, executables)
+    files = Puppet::Module::Task.find_files(name, dirname, metadata, executables)
 
-    arguments = {
-      'name' => name,
-      'implementations' => implementation_metadata
-    }
+    task = { 'name' => name, 'metadata' => metadata, 'files' => files }
 
     begin
-      metadata.each_pair do |key, value|
-        if %w[parameters output].include?(key)
-          ps = {}
-          value.each_pair do |k, v|
-            pd = v.dup
-            t = v['type']
-            pd['type'] = t.nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(t)
-            ps[k] = pd
-          end
-          value = ps
-        end
-        arguments[key] = value unless arguments.key?(key)
-      end
+      task['parameters'] = convert_types(metadata['parameters'])
 
-      Types::TypeFactory.task.from_hash(arguments)
+      Types::TypeFactory.task.from_hash(task)
     rescue Types::TypeAssertionError => ex
       # Not strictly a parser error but from the users perspective, the file content didn't parse properly. The
       # ParserError also conveys file info (even though line is unknown)
@@ -92,6 +28,13 @@ class TaskInstantiator
       raise Puppet::ParseError.new(msg, metadata_file)
     end
   end
+
+  def self.convert_types(args)
+    args.each_with_object({}) do |(k, v), hsh|
+      hsh[k] = v['type'].nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(v['type'])
+    end if args
+  end
+  private_class_method :convert_types
 end
 end
 end

data/lib/puppet/pops/parser/heredoc_support.rb

@@ -98,8 +98,7 @@ module HeredocSupport
 
         # Use a new lexer instance configured with a sub-locator to enable correct positioning
         sublexer = self.class.new()
-        locator = Locator::SubLocator.sub_locator(str,
-          locator.file, heredoc_line, heredoc_offset, leading.length())
+        locator = Locator::SubLocator.new(locator, heredoc_line, heredoc_offset, leading.length())
 
         # Emit a token that provides the grammar with location information about the lines on which the heredoc
         # content is based.

data/lib/puppet/pops/parser/lexer2.rb

@@ -189,7 +189,7 @@ class Lexer2
       ',' => lambda {  emit(TOKEN_COMMA, @scanner.pos) },
       '[' => lambda do
         before = @scanner.pos
-        if (before == 0 || @scanner.string[locator.char_offset(before)-1,1] =~ /[[:blank:]\r\n]+/)
+        if (before == 0 || locator.string[locator.char_offset(before)-1,1] =~ /[[:blank:]\r\n]+/)
           emit(TOKEN_LISTSTART, before)
         else
           emit(TOKEN_LBRACK, before)

data/lib/puppet/pops/pcore.rb

@@ -39,39 +39,16 @@ module Pcore
             # Fully qualified name of the task
             name => { type => Pattern[/\\A[a-z][a-z0-9_]*(?:::[a-z][a-z0-9_]*)*\\z/] },
 
-            # List of implementations with requirements
-            implementations => { type => Array[Struct[name => String, path => String, Optional[requirements] => Array[String]], 1] },
-
-            # Task description
-            description => { type => Optional[String], value => undef },
-
-            # Puppet Task version
-            puppet_task_version => { type => Integer, value => 1 },
-
-            # Type, description, and sensitive property of each parameter
-            parameters => {
-              type => Optional[Hash[
-                Pattern[/\\A[a-z][a-z0-9_]*\\z/],
-                Struct[
-                  Optional[description] => String,
-                  Optional[sensitive] => Boolean,
-                  type => Type]]],
-              value => undef
-            },
-
-             # Type, description, and sensitive property of each output
-            output => {
-              type => Optional[Hash[
-                Pattern[/\\A[a-z][a-z0-9_]*\\z/],
-                Struct[
-                  Optional[description] => String,
-                  Optional[sensitive] => Boolean,
-                  type => Type]]],
-              value => undef
-            },
-
-            supports_noop => { type => Boolean, value => false },
-            input_method => { type => Optional[String] },
+            # List of file references referenced by metadata and their paths on disk.
+            # If there are no implementations listed in metadata, the first file is always
+            # the task executable.
+            files => { type => Array[Struct[name => String, path => String]] },
+
+            # Task metadata
+            metadata => { type => Hash[String, Any] },
+
+            # Map parameter names to their parsed data type
+            parameters => { type => Optional[Hash[Pattern[/\\A[a-z][a-z0-9_]*\\z/], Type]], value => undef },
           }
         }
       PUPPET

data/lib/puppet/pops/serialization/to_data_converter.rb

@@ -70,7 +70,15 @@ module Serialization
 
     def to_data(value)
       if value.nil? || Types::PScalarDataType::DEFAULT.instance?(value)
-        value
+        if @rich_data && value.is_a?(String) && value.encoding == Encoding::ASCII_8BIT
+          # Transform the binary string to rich Binary
+          {
+            PCORE_TYPE_KEY => PCORE_TYPE_BINARY,
+            PCORE_VALUE_KEY => Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(value).to_s
+          }
+        else
+          value
+        end
       elsif :default == value
         if @rich_data
           { PCORE_TYPE_KEY => PCORE_TYPE_DEFAULT }

data/lib/puppet/pops/serialization.rb

@@ -19,6 +19,7 @@ module Serialization
 
   # Type key used for symbols
   PCORE_TYPE_SENSITIVE = 'Sensitive'.freeze
+  PCORE_TYPE_BINARY = 'Binary'.freeze
 
   # Type key used for symbols
   PCORE_TYPE_SYMBOL = 'Symbol'.freeze

data/lib/puppet/pops/types/p_timespan_type.rb

@@ -65,9 +65,9 @@ module Types
       when String
         impl_class.parse(arg)
       when Integer
-        arg == impl_class.new(arg * Time::NSECS_PER_SEC)
+        impl_class.new(arg * Time::NSECS_PER_SEC)
       when Float
-        arg == (min ? -Float::INFINITY : Float::INFINITY) ? arg : impl_class.new(arg * Time::NSECS_PER_SEC)
+        impl_class.new(arg * Time::NSECS_PER_SEC)
       else
         raise ArgumentError, "Unable to create a #{impl_class.name} from a #{arg.class.name}" unless arg.nil? || arg == :default
         nil

data/lib/puppet/pops/types/string_converter.rb

@@ -484,8 +484,17 @@ class StringConverter
 
     value_type = TypeCalculator.infer_set(value)
     if string_formats.is_a?(String)
-      # add the format given for the exact type
-      string_formats = { value_type => string_formats }
+      # For Array and Hash, the format is given as a Hash where 'format' key is the format for the collection itself
+      if Puppet::Pops::Types::PArrayType::DEFAULT.assignable?(value_type)
+        # add the format given for the exact type
+        string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => {'format' => string_formats }}
+      elsif Puppet::Pops::Types::PHashType::DEFAULT.assignable?(value_type)
+          # add the format given for the exact type
+          string_formats = { Puppet::Pops::Types::PHashType::DEFAULT => {'format' => string_formats }}
+      else
+        # add the format given for the exact type
+        string_formats = { value_type => string_formats }
+      end
     end
 
     case string_formats
@@ -804,7 +813,7 @@ class StringConverter
       Kernel.format(f.orig_fmt, val)
 
     when :p
-      apply_string_flags(f, puppet_quote(val))
+      apply_string_flags(f, puppet_quote(val, f.alt?))
 
     when :c
       c_val = val.capitalize
@@ -836,10 +845,15 @@ class StringConverter
   # strings will be quoted using double quotes.
   #
   # @param [String] str the string that should be formatted
+  # @param [Boolean] enforce_double_quotes if true the result will be double quoted (even if single quotes would be possible)
   # @return [String] the formatted string
   #
   # @api public
-  def puppet_quote(str)
+  def puppet_quote(str, enforce_double_quotes = false)
+    if enforce_double_quotes
+      return puppet_double_quote(str)
+    end
+
     # Assume that the string can be single quoted
     bld = '\''
     bld.force_encoding(str.encoding)

data/lib/puppet/pops/validation/checker4_0.rb

@@ -1,5 +1,8 @@
+require 'puppet/pops/evaluator/external_syntax_support'
+
 module Puppet::Pops
 module Validation
+
 # A Validator validates a model.
 #
 # Validation is performed on each model element in isolation. Each method should validate the model element's state
@@ -12,6 +15,8 @@ module Validation
 #       This is however mostly valuable when validating model to model transformations, and is therefore T.B.D
 #
 class Checker4_0 < Evaluator::LiteralEvaluator
+  include Puppet::Pops::Evaluator::ExternalSyntaxSupport
+
   attr_reader :acceptor
   attr_reader :migration_checker
 
@@ -324,6 +329,14 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     end
   end
 
+  def check_HeredocExpression(o)
+    # Only check static text in heredoc
+    expr = o.text_expr.expr # Always a SublocatedExpression with an expression
+    if expr.is_a?(Model::LiteralString)
+      assert_external_syntax(nil, expr.value, o.syntax, o.text_expr)
+    end
+  end
+
   def check_MethodCallExpression(o)
     unless o.functor_expr.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, :feature => 'function name', :container => o)
@@ -559,6 +572,8 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     return if namespace_for_file(file) == NO_NAMESPACE
 
     body = prog.body
+    return if prog.body.is_a?(Model::Nop) #Ignore empty or comment-only files
+
     if(body.is_a?(Model::BlockExpression))
       body.statements.each { |s| acceptor.accept(Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION, s) unless valid_top_construct?(s) }
     else
@@ -623,9 +638,9 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   def is_parent_dir_of(parent_dir, child_dir)
     parent_dir_path = Pathname.new(parent_dir)
-    clean_parent = parent_dir_path.cleanpath
+    clean_parent = parent_dir_path.cleanpath.to_s + File::SEPARATOR
 
-    return child_dir.to_s.start_with?(clean_parent.to_s)
+    return child_dir.to_s.start_with?(clean_parent)
   end
 
   def dir_to_names(relative_path)