Fix for ticket #2844 (file recursion generated vs. explicit prefix)

The routine which was determining if one path was a prefix of another
in arbitrating between explicit and generated resources was using the
raw string for the test without regard to path segments and thus could
be fooled by pairs such as "/tmp/foo" vs. "/tmp/foo2"

Fix was to be path delimiter aware and add a test.

Signed-off-by: Markus Roberts <Markus@reality.com>

1 files changed, 9 insertions, 17 deletions

diff --git a/lib/puppet/type/file.rb b/lib/puppet/type/file.rb
index f9205255a..a4666a95f 100644
--- a/lib/puppet/type/file.rb
+++ b/lib/puppet/type/file.rb
@@ -496,26 +496,18 @@ module Puppet
         # not likely to have many actual conflicts, which is good, because
         # this is a pretty inefficient implementation.
         def remove_less_specific_files(files)
-            # We sort the paths so we can short-circuit some tests.
-            mypath = self[:path]
-            other_paths = catalog.vertices.find_all do |r|
-                r.is_a?(self.class) and r[:path][0..(mypath.length - 1)] == mypath
-            end.collect { |r| r[:path] }.sort { |a, b| a.length <=> b.length } - [self[:path]]
+            mypath = self[:path].split(File::Separator)
+            other_paths = catalog.vertices.
+              select  { |r| r.is_a?(self.class) and r[:path] != self[:path] }.
+              collect { |r| r[:path].split(File::Separator) }.
+              select  { |p| p[0,mypath.length]  == mypath }
 
             return files if other_paths.empty?
 
-            remove = []
-            files.each do |file|
-                path = file[:path]
-                other_paths.each do |p|
-                    if path[0..(p.length - 1)] == p
-                        remove << file
-                        break
-                    end
-                end
-            end
-
-            files - remove
+            files.reject { |file|
+                path = file[:path].split(File::Separator)
+                other_paths.any? { |p| path[0,p.length] == p }
+                }
         end
 
         # A simple method for determining whether we should be recursing.