puppet 3.2.3 → 3.2.4

data/Rakefile

@@ -10,8 +10,6 @@ $LOAD_PATH << File.join(RAKE_ROOT, 'tasks')
 begin
   require 'rubygems'
   require 'rubygems/package_task'
-  require 'rspec'
-  require 'rspec/core/rake_task'
 rescue LoadError
   # Users of older versions of Rake (0.8.7 for example) will not necessarily
   # have rubygems installed, or the newer rubygems package_task for that

data/ext/build_defaults.yaml

@@ -9,7 +9,7 @@ gpg_name: 'info@puppetlabs.com'
 gpg_key: '4BD6EC30'
 sign_tar: FALSE
 # a space separated list of mock configs
-final_mocks: 'pl-el-5-i386 pl-el-6-i386 pl-fedora-17-i386 pl-fedora-18-i386'
+final_mocks: 'pl-el-5-i386 pl-el-6-i386 pl-fedora-17-i386 pl-fedora-18-i386 pl-fedora-19-i386'
 yum_host: 'burji.puppetlabs.com'
 yum_repo_path: '/opt/repository/yum/'
 build_gem: TRUE

data/ext/redhat/puppet.spec.erb

@@ -37,9 +37,8 @@ BuildRoot:      %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
 BuildRequires:  facter < 1:2.0
 # Puppet 3.x drops ruby 1.8.5 support and adds ruby 1.9 support
 BuildRequires:  ruby >= 1.8.7
-
 BuildArch:      noarch
-Requires:       ruby(abi) >= 1.8
+Requires:       ruby >= 1.8
 Requires:       ruby-shadow
 
 # Pull in ruby selinux bindings where available
@@ -67,6 +66,11 @@ Requires:       shadow-utils
 %if 0%{?_with_systemd}
 # Required for %%post, %%preun, %%postun
 Requires:       systemd
+%if 0%{?fedora} >= 18
+BuildRequires:  systemd
+%else
+BuildRequires:  systemd-units
+%endif
 %else
 # Required for %%post and %%preun
 Requires:       chkconfig

data/lib/puppet.rb

@@ -27,6 +27,8 @@ require 'puppet/external/pson/pure'
 #
 # @api public
 module Puppet
+  require 'puppet/file_system'
+
   class << self
     include Puppet::Util
     attr_reader :features

data/lib/puppet/file_system.rb

@@ -0,0 +1,3 @@
+module Puppet::FileSystem
+  require 'puppet/file_system/path_pattern'
+end

data/lib/puppet/file_system/path_pattern.rb

@@ -0,0 +1,97 @@
+require 'pathname'
+
+module Puppet::FileSystem
+  class PathPattern
+    class InvalidPattern < Puppet::Error; end
+
+    TRAVERSAL = /^\.\.$/
+    ABSOLUTE_UNIX = /^\//
+    ABSOLUTE_WINDOWS = /^[a-z]:/i
+    #ABSOLUT_VODKA #notappearinginthisclass
+    CURRENT_DRIVE_RELATIVE_WINDOWS = /^\\/
+
+    def self.relative(pattern)
+      RelativePathPattern.new(pattern)
+    end
+
+    def self.absolute(pattern)
+      AbsolutePathPattern.new(pattern)
+    end
+
+    class << self
+      protected :new
+    end
+
+    # @param prefix [AbsolutePathPattern] An absolute path pattern instance
+    # @return [AbsolutePathPattern] A new AbsolutePathPattern prepended with
+    #   the passed prefix's pattern.
+    def prefix_with(prefix)
+      new_pathname = prefix.pathname + pathname
+      self.class.absolute(new_pathname.to_s)
+    end
+
+    def glob
+      Dir.glob(pathname.to_s)
+    end
+
+    def to_s
+      pathname.to_s
+    end
+
+    protected
+
+    attr_reader :pathname
+
+    private
+
+    def validate
+      @pathname.each_filename do |e|
+        if e =~ TRAVERSAL
+          raise(InvalidPattern, "PathPatterns cannot be created with directory traversals.")
+        end
+      end
+      case @pathname.to_s
+      when CURRENT_DRIVE_RELATIVE_WINDOWS
+        raise(InvalidPattern, "A PathPattern cannot be a Windows current drive relative path.")
+      end
+    end
+
+    def initialize(pattern)
+      begin
+        @pathname = Pathname.new(pattern.strip)
+      rescue ArgumentError => error
+        raise InvalidPattern.new("PathPatterns cannot be created with a zero byte.", error)
+      end
+      validate
+    end
+  end
+
+  class RelativePathPattern < PathPattern
+    def absolute?
+      false
+    end
+
+    def validate
+      super
+      case @pathname.to_s
+      when ABSOLUTE_WINDOWS
+        raise(InvalidPattern, "A relative PathPattern cannot be prefixed with a drive.")
+      when ABSOLUTE_UNIX
+        raise(InvalidPattern, "A relative PathPattern cannot be an absolute path.")
+      end
+    end
+  end
+
+  class AbsolutePathPattern < PathPattern
+    def absolute?
+      true
+    end
+
+    def validate
+      super
+      if @pathname.to_s !~ ABSOLUTE_UNIX and @pathname.to_s !~ ABSOLUTE_WINDOWS
+        raise(InvalidPattern, "An absolute PathPattern cannot be a relative path.")
+      end
+    end
+  end
+end

data/lib/puppet/module.rb

@@ -11,6 +11,7 @@ class Puppet::Module
   class IncompatiblePlatform < Error; end
   class MissingMetadata < Error; end
   class InvalidName < Error; end
+  class InvalidFilePattern < Error; end
 
   include Puppet::Util::Logging
 
@@ -45,6 +46,8 @@ class Puppet::Module
     load_metadata if has_metadata?
 
     validate_puppet_version
+
+    @absolute_path_to_manifests = Puppet::FileSystem::PathPattern.absolute(manifests)
   end
 
   def has_metadata?
@@ -132,10 +135,16 @@ class Puppet::Module
   # Return the list of manifests matching the given glob pattern,
   # defaulting to 'init.{pp,rb}' for empty modules.
   def match_manifests(rest)
-    pat = File.join(path, "manifests", rest || 'init')
-    [manifest("init.pp"),manifest("init.rb")].compact + Dir.
-      glob(pat + (File.extname(pat).empty? ? '.{pp,rb}' : '')).
-      reject { |f| FileTest.directory?(f) }
+    if rest
+      wanted_manifests = wanted_manifests_from(rest)
+      searched_manifests = wanted_manifests.glob.reject { |f| FileTest.directory?(f) }
+    else
+      searched_manifests = []
+    end
+
+    # (#4220) Always ensure init.pp in case class is defined there.
+    init_manifests = [manifest("init.pp"), manifest("init.rb")].compact
+    init_manifests + searched_manifests
   end
 
   def metadata_file
@@ -275,6 +284,19 @@ class Puppet::Module
 
   private
 
+  def wanted_manifests_from(pattern)
+    begin
+      extended = File.extname(pattern).empty? ? "#{pattern}.{pp,rb}" : pattern
+      relative_pattern = Puppet::FileSystem::PathPattern.relative(extended)
+    rescue Puppet::FileSystem::PathPattern::InvalidPattern => error
+      raise Puppet::Module::InvalidFilePattern.new(
+        "The pattern \"#{pattern}\" to find manifests in the module \"#{name}\" " +
+        "is invalid and potentially unsafe.", error)
+    end
+
+    relative_pattern.prefix_with(@absolute_path_to_manifests)
+  end
+
   def subpath(type)
     File.join(path, type)
   end

data/lib/puppet/module_tool/applications/unpacker.rb

@@ -10,7 +10,8 @@ module Puppet::ModuleTool
         parsed = parse_filename(filename)
         @module_name = parsed[:module_name]
         super(options)
-        @module_dir = Pathname.new(options[:target_dir]) + parsed[:dir_name]
+        @module_path = Pathname(options[:target_dir])
+        @module_dir = @module_path + parsed[:dir_name]
       end
 
       def run
@@ -37,7 +38,7 @@ module Puppet::ModuleTool
         build_dir.mkpath
         begin
           begin
-            Puppet::ModuleTool::Tar.instance(@module_name).unpack(@filename.to_s, build_dir.to_s)
+            Puppet::ModuleTool::Tar.instance(@module_name).unpack(@filename.to_s, build_dir.to_s, [@module_path.stat.uid, @module_path.stat.gid].join(':'))
           rescue Puppet::ExecutionFailure => e
             raise RuntimeError, "Could not extract contents of module archive: #{e.message}"
           end

data/lib/puppet/module_tool/tar/gnu.rb

@@ -1,6 +1,9 @@
 class Puppet::ModuleTool::Tar::Gnu
-  def unpack(sourcefile, destdir)
-    Puppet::Util::Execution.execute("tar xzf #{sourcefile} -C #{destdir}")
+  def unpack(sourcefile, destdir, owner)
+    Puppet::Util::Execution.execute("tar xzf #{sourcefile} --no-same-permissions --no-same-owner -C #{destdir}")
+    Puppet::Util::Execution.execute("find #{destdir} -type d -exec chmod 755 {} +")
+    Puppet::Util::Execution.execute("find #{destdir} -type f -exec chmod 644 {} +")
+    Puppet::Util::Execution.execute("chown -R #{owner} #{destdir}")
   end
 
   def pack(sourcedir, destfile)

data/lib/puppet/module_tool/tar/mini.rb

@@ -3,7 +3,7 @@ class Puppet::ModuleTool::Tar::Mini
     @module_name = module_name
   end
 
-  def unpack(sourcefile, destdir)
+  def unpack(sourcefile, destdir, _)
     Zlib::GzipReader.open(sourcefile) do |reader|
       Archive::Tar::Minitar.unpack(reader, destdir) do |action, name, stats|
         case action

data/lib/puppet/module_tool/tar/solaris.rb

@@ -1,5 +1,8 @@
 class Puppet::ModuleTool::Tar::Solaris < Puppet::ModuleTool::Tar::Gnu
-  def unpack(sourcefile, destdir)
-    Puppet::Util::Execution.execute("gtar xzf #{sourcefile} -C #{destdir}")
+  def unpack(sourcefile, destdir, owner)
+    Puppet::Util::Execution.execute("gtar xzf #{sourcefile} --no-same-permissions --no-same-owner -C #{destdir}")
+    Puppet::Util::Execution.execute("find #{destdir} -type d -exec chmod 755 {} +")
+    Puppet::Util::Execution.execute("find #{destdir} -type f -exec chmod 644 {} +")
+    Puppet::Util::Execution.execute("chown -R #{owner} #{destdir}")
   end
 end

data/lib/puppet/parser/files.rb

@@ -6,26 +6,28 @@ require 'puppet/module'
 # doesn't really belong in the Puppet::Module class,
 # but it doesn't really belong anywhere else, either.
 module Puppet; module Parser; module Files
-  
+
   module_function
 
-  # Return a list of manifests (as absolute filenames) that match +pat+
-  # with the current directory set to +cwd+. If the first component of
-  # +pat+ does not contain any wildcards and is an existing module, return
-  # a list of manifests in that module matching the rest of +pat+
-  # Otherwise, try to find manifests matching +pat+ relative to +cwd+
-  def find_manifests(start, options = {})
-    cwd = options[:cwd] || Dir.getwd
-    module_name, pattern = split_file_path(start)
+  # Return a list of manifests as absolute filenames matching the given 
+  # pattern.
+  #
+  # @param pattern [String] A reference for a file in a module. It is the format "<modulename>/<file glob>"
+  # @param environment [Puppet::Node::Environment] the environment of modules
+  #
+  # @return [Array(String, Array<String>)] the module name and the list of files found
+  # @api private
+  def find_manifests_in_modules(pattern, environment)
+    module_name, file_pattern = split_file_path(pattern)
     begin
-      if mod = Puppet::Module.find(module_name, options[:environment])
-        return [mod.name, mod.match_manifests(pattern)]
+      if mod = Puppet::Module.find(module_name, environment)
+        return [mod.name, mod.match_manifests(file_pattern)]
       end
     rescue Puppet::Module::InvalidName
-      # Than that would be a "no."
+      # one of the modules being loaded might have an invalid name and so
+      # looking for one might blow up since we load them lazily.
     end
-    abspat = File::expand_path(start, cwd)
-    [nil, Dir.glob(abspat + (File.extname(abspat).empty? ? '{.pp,.rb}' : '' )).uniq.reject { |f| FileTest.directory?(f) }]
+    [nil, []]
   end
 
   # Find the concrete file denoted by +file+. If +file+ is absolute,
@@ -81,9 +83,12 @@ module Puppet; module Parser; module Files
 
   # Split the path into the module and the rest of the path, or return
   # nil if the path is empty or absolute (starts with a /).
-  # This method can return nil & anyone calling it needs to handle that.
   def split_file_path(path)
-    path.split(File::SEPARATOR, 2) unless path == "" or Puppet::Util.absolute_path?(path)
+    if path == "" or Puppet::Util.absolute_path?(path)
+      nil
+    else
+      path.split(File::SEPARATOR, 2)
+    end
   end
 
 end; end; end

data/lib/puppet/parser/parser_support.rb

@@ -98,7 +98,16 @@ class Puppet::Parser::Parser
   def_delegators :known_resource_types, :watch_file, :version
 
   def import(file)
-    known_resource_types.loader.import(file, @lexer.file)
+    if @lexer.file
+      # use a path relative to the file doing the importing
+      dir = File.dirname(@lexer.file)
+    else
+      # otherwise assume that everything needs to be from where the user is
+      # executing this command. Normally, this would be in a "puppet apply -e"
+      dir = Dir.pwd
+    end
+
+    known_resource_types.loader.import(file, dir)
   end
 
   def initialize(env)

data/lib/puppet/parser/type_loader.rb

@@ -62,50 +62,48 @@ class Puppet::Parser::TypeLoader
     end
   end
 
-  # Import our files.
-  def import(file, current_file = nil)
+  # Import manifest files that match a given file glob pattern.
+  #
+  # @param pattern [String] the file glob to apply when determining which files
+  #   to load
+  # @param dir [String] base directory to use when the file is not
+  #   found in a module
+  # @api private
+  def import(pattern, dir)
     return if Puppet[:ignoreimport]
 
-    # use a path relative to the file doing the importing
-    if current_file
-      dir = current_file.sub(%r{[^/]+$},'').sub(/\/$/, '')
-    else
-      dir = "."
-    end
-    if dir == ""
-      dir = "."
-    end
+    modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
+    if files.empty?
+      abspat = File.expand_path(pattern, dir)
+      file_pattern = abspat + (File.extname(abspat).empty? ? '{.pp,.rb}' : '' )
 
-    pat = file
-    modname, files = Puppet::Parser::Files.find_manifests(pat, :cwd => dir, :environment => environment)
-    if files.size == 0
-      raise Puppet::ImportError.new("No file(s) found for import of '#{pat}'")
-    end
+      files = Dir.glob(file_pattern).uniq.reject { |f| FileTest.directory?(f) }
+      modname = nil
 
-    loaded_asts = []
-    files.each do |file|
-      unless Puppet::Util.absolute_path?(file)
-        file = File.join(dir, file)
+      if files.empty?
+        raise_no_files_found(pattern)
       end
-      @loading_helper.do_once(file) do
-        loaded_asts << parse_file(file)
-      end
-    end
-    loaded_asts.inject([]) do |loaded_types, ast|
-      loaded_types + known_resource_types.import_ast(ast, modname)
     end
+
+    load_files(modname, files)
   end
 
+  # Load all of the manifest files in all known modules.
+  # @api private
   def import_all
     # And then load all files from each module, but (relying on system
     # behavior) only load files from the first module of a given name.  E.g.,
     # given first/foo and second/foo, only files from first/foo will be loaded.
     environment.modules.each do |mod|
-      Find.find(mod.manifests) do |path|
-        if path =~ /\.pp$/ or path =~ /\.rb$/
-          import(path)
+      manifest_files = []
+      if File.exists?(mod.manifests)
+        Find.find(mod.manifests) do |path|
+          if path.end_with?(".pp") || path.end_with?(".rb")
+            manifest_files << path
+          end
         end
       end
+      load_files(mod.name, manifest_files)
     end
   end
 
@@ -121,7 +119,7 @@ class Puppet::Parser::TypeLoader
     return nil if fqname == "" # special-case main.
     name2files(fqname).each do |filename|
       begin
-        imported_types = import(filename)
+        imported_types = import_from_modules(filename)
         if result = imported_types.find { |t| t.type == type and t.name == fqname }
           Puppet.debug "Automatically imported #{fqname} from #{filename} into #{environment}"
           return result
@@ -138,7 +136,6 @@ class Puppet::Parser::TypeLoader
 
   def parse_file(file)
     Puppet.debug("importing '#{file}' in environment #{environment}")
-#    parser = Puppet::Parser::Parser.new(environment)
     parser = Puppet::Parser::ParserFactory.parser(environment)
     parser.file = file
     return parser.parse
@@ -146,6 +143,32 @@ class Puppet::Parser::TypeLoader
 
   private
 
+  def import_from_modules(pattern)
+    modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
+    if files.empty?
+      raise_no_files_found(pattern)
+    end
+
+    load_files(modname, files)
+  end
+
+  def raise_no_files_found(pattern)
+    raise Puppet::ImportError, "No file(s) found for import of '#{pattern}'"
+  end
+
+  def load_files(modname, files)
+    loaded_asts = []
+    files.each do |file|
+      @loading_helper.do_once(file) do
+        loaded_asts << parse_file(file)
+      end
+    end
+
+    loaded_asts.collect do |ast|
+      known_resource_types.import_ast(ast, modname)
+    end.flatten
+  end
+
   # Return a list of all file basenames that should be tried in order
   # to load the object with the given fully qualified name.
   def name2files(fqname)

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '3.2.3'
+  PUPPETVERSION = '3.2.4'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/unit/file_system/path_pattern_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet/file_system'
+
+describe Puppet::FileSystem::PathPattern do
+  include PuppetSpec::Files
+  InvalidPattern = Puppet::FileSystem::PathPattern::InvalidPattern
+
+  describe 'relative' do
+    it "can not be created with a traversal up the directory tree" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("my/../other")
+      end.to raise_error(InvalidPattern, "PathPatterns cannot be created with directory traversals.")
+    end
+
+    it "can be created with a '..' prefixing a filename" do
+      expect(Puppet::FileSystem::PathPattern.relative("my/..other").to_s).to eq("my/..other")
+    end
+
+    it "can be created with a '..' suffixing a filename" do
+      expect(Puppet::FileSystem::PathPattern.relative("my/other..").to_s).to eq("my/other..")
+    end
+
+    it "can be created with a '..' embedded in a filename" do
+      expect(Puppet::FileSystem::PathPattern.relative("my/ot..her").to_s).to eq("my/ot..her")
+    end
+
+    it "can not be created with a \\0 byte embedded" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("my/\0/other")
+      end.to raise_error(InvalidPattern, "PathPatterns cannot be created with a zero byte.")
+    end
+
+    it "can not be created with a windows drive" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("c:\\relative\\path")
+      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be prefixed with a drive.")
+    end
+
+    it "can not be created with a windows drive (with space)" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative(" c:\\relative\\path")
+      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be prefixed with a drive.")
+    end
+
+    it "can not create an absolute relative path" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("/no/absolutes")
+      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be an absolute path.")
+    end
+
+    it "can not create an absolute relative path (with space)" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("\t/no/absolutes")
+      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be an absolute path.")
+    end
+
+    it "can not create a relative path that is a windows path relative to the current drive" do
+      expect do
+        Puppet::FileSystem::PathPattern.relative("\\no\relatives")
+      end.to raise_error(InvalidPattern, "A PathPattern cannot be a Windows current drive relative path.")
+    end
+
+    it "creates a relative PathPattern from a valid relative path" do
+      expect(Puppet::FileSystem::PathPattern.relative("a/relative/path").to_s).to eq("a/relative/path")
+    end
+
+    it "is not absolute" do
+      expect(Puppet::FileSystem::PathPattern.relative("a/relative/path")).to_not be_absolute
+    end
+  end
+
+  describe 'absolute' do
+    it "can not create a relative absolute path" do
+      expect do
+        Puppet::FileSystem::PathPattern.absolute("no/relatives")
+      end.to raise_error(InvalidPattern, "An absolute PathPattern cannot be a relative path.")
+    end
+
+    it "can not create an absolute path that is a windows path relative to the current drive" do
+      expect do
+        Puppet::FileSystem::PathPattern.absolute("\\no\\relatives")
+      end.to raise_error(InvalidPattern, "A PathPattern cannot be a Windows current drive relative path.")
+    end
+
+    it "creates an absolute PathPattern from a valid absolute path" do
+      expect(Puppet::FileSystem::PathPattern.absolute("/an/absolute/path").to_s).to eq("/an/absolute/path")
+    end
+
+    it "creates an absolute PathPattern from a valid Windows absolute path" do
+      expect(Puppet::FileSystem::PathPattern.absolute("c:/absolute/windows/path").to_s).to eq("c:/absolute/windows/path")
+    end
+
+    it "can be created with a '..' embedded in a filename on windows", :if => Puppet.features.microsoft_windows? do
+      expect(Puppet::FileSystem::PathPattern.absolute(%q{c:\..my\ot..her\one..}).to_s).to eq(%q{c:\..my\ot..her\one..})
+    end
+
+    it "is absolute" do
+      expect(Puppet::FileSystem::PathPattern.absolute("c:/absolute/windows/path")).to be_absolute
+    end
+  end
+
+  it "prefixes the relative path pattern with another path" do
+    pattern = Puppet::FileSystem::PathPattern.relative("docs/*_thoughts.txt")
+    prefix = Puppet::FileSystem::PathPattern.absolute("/prefix")
+
+    absolute_pattern = pattern.prefix_with(prefix)
+
+    expect(absolute_pattern).to be_absolute
+    expect(absolute_pattern.to_s).to eq(File.join("/prefix", "docs/*_thoughts.txt"))
+  end
+
+  it "refuses to prefix with a relative pattern" do
+    pattern = Puppet::FileSystem::PathPattern.relative("docs/*_thoughts.txt")
+    prefix = Puppet::FileSystem::PathPattern.relative("prefix")
+
+    expect do
+      pattern.prefix_with(prefix)
+    end.to raise_error(InvalidPattern, "An absolute PathPattern cannot be a relative path.")
+  end
+
+  it "applies the pattern to the filesystem as a glob" do
+    dir = tmpdir('globtest')
+    create_file_in(dir, "found_one")
+    create_file_in(dir, "found_two")
+    create_file_in(dir, "third_not_found")
+
+    pattern = Puppet::FileSystem::PathPattern.relative("found_*").prefix_with(
+      Puppet::FileSystem::PathPattern.absolute(dir))
+
+    expect(pattern.glob).to match_array([File.join(dir, "found_one"),
+                                         File.join(dir, "found_two")])
+  end
+
+  def create_file_in(dir, name)
+    File.open(File.join(dir, name), "w") { |f| f.puts "data" }
+  end
+end

data/spec/unit/module_spec.rb

@@ -8,7 +8,7 @@ describe Puppet::Module do
   include PuppetSpec::Files
 
   let(:env) { mock("environment") }
-  let(:path) { "path" }
+  let(:path) { "/path" }
   let(:name) { "mymod" }
   let(:mod) { Puppet::Module.new(name, path, env) }
 
@@ -339,7 +339,7 @@ describe Puppet::Module do
   end
 
   it "should fail if its name is not alphanumeric" do
-    lambda { Puppet::Module.new(".something", "path", env) }.should raise_error(Puppet::Module::InvalidName)
+    lambda { Puppet::Module.new(".something", "/path", env) }.should raise_error(Puppet::Module::InvalidName)
   end
 
   it "should require a name at initialization" do
@@ -347,7 +347,7 @@ describe Puppet::Module do
   end
 
   it "should accept an environment at initialization" do
-    Puppet::Module.new("foo", "path", env).environment.should == env
+    Puppet::Module.new("foo", "/path", env).environment.should == env
   end
 
   describe '#modulepath' do
@@ -418,7 +418,8 @@ describe Puppet::Module, "when finding matching manifests" do
   end
 
   it "should default to the 'init' file if no glob pattern is specified" do
-    Dir.expects(:glob).with("/a/manifests/init.{pp,rb}").returns(%w{/a/manifests/init.pp})
+    FileTest.expects(:exist?).with("/a/manifests/init.pp").returns(true)
+    FileTest.expects(:exist?).with("/a/manifests/init.rb").returns(false)
 
     @mod.match_manifests(nil).should == %w{/a/manifests/init.pp}
   end
@@ -440,6 +441,12 @@ describe Puppet::Module, "when finding matching manifests" do
 
     @mod.match_manifests(@pq_glob_with_extension).should == []
   end
+
+  it "should raise an error if the pattern tries to leave the manifest directory" do
+    expect do
+      @mod.match_manifests("something/../../*")
+    end.to raise_error(Puppet::Module::InvalidFilePattern, 'The pattern "something/../../*" to find manifests in the module "mymod" is invalid and potentially unsafe.')
+  end
 end
 
 describe Puppet::Module do
@@ -509,13 +516,13 @@ describe Puppet::Module do
     Puppet::Module.any_instance.expects(:has_metadata?).returns true
     Puppet::Module.any_instance.expects(:load_metadata)
 
-    Puppet::Module.new("yay", "path", mock("env"))
+    Puppet::Module.new("yay", "/path", mock("env"))
   end
 
   def a_module_with_metadata(data)
     text = data.to_pson
 
-    mod = Puppet::Module.new("foo", "path", mock("env"))
+    mod = Puppet::Module.new("foo", "/path", mock("env"))
     mod.stubs(:metadata_file).returns "/my/file"
     File.stubs(:read).with("/my/file").returns text
     mod

data/spec/unit/module_tool/tar/gnu_spec.rb

@@ -8,8 +8,11 @@ describe Puppet::ModuleTool::Tar::Gnu do
   let(:destfile)   { '/the/dest/file.tar.gz' }
 
   it "unpacks a tar file" do
-    Puppet::Util::Execution.expects(:execute).with("tar xzf #{sourcefile} -C #{destdir}")
-    subject.unpack(sourcefile, destdir)
+    Puppet::Util::Execution.expects(:execute).with("tar xzf #{sourcefile} --no-same-permissions --no-same-owner -C #{destdir}")
+    Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type d -exec chmod 755 {} +")
+    Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type f -exec chmod 644 {} +")
+    Puppet::Util::Execution.expects(:execute).with("chown -R <owner:group> #{destdir}")
+    subject.unpack(sourcefile, destdir, '<owner:group>')
   end
 
   it "packs a tar file" do

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -11,14 +11,14 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
   it "unpacks a tar file" do
     unpacks_the_entry(:file_start, 'thefile')
 
-    minitar.unpack(sourcefile, destdir)
+    minitar.unpack(sourcefile, destdir, 'uid')
   end
 
   it "does not allow an absolute path" do
     unpacks_the_entry(:file_start, '/thefile')
 
     expect {
-      minitar.unpack(sourcefile, destdir)
+      minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
                      "Attempt to install file into \"/thefile\" under \"#{destdir}\"")
   end
@@ -27,7 +27,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     unpacks_the_entry(:file_start, '../../thefile')
 
     expect {
-      minitar.unpack(sourcefile, destdir)
+      minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
                      "Attempt to install file into \"#{File.expand_path('/the/thefile')}\" under \"#{destdir}\"")
   end
@@ -36,7 +36,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     unpacks_the_entry(:dir, '../../thedir')
 
     expect {
-      minitar.unpack(sourcefile, destdir)
+      minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
                      "Attempt to install file into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
   end

data/spec/unit/module_tool/tar/solaris_spec.rb

@@ -8,8 +8,11 @@ describe Puppet::ModuleTool::Tar::Solaris do
   let(:destfile)   { '/the/dest/file.tar.gz' }
 
   it "unpacks a tar file" do
-    Puppet::Util::Execution.expects(:execute).with("gtar xzf #{sourcefile} -C #{destdir}")
-    subject.unpack(sourcefile, destdir)
+    Puppet::Util::Execution.expects(:execute).with("gtar xzf #{sourcefile} --no-same-permissions --no-same-owner -C #{destdir}")
+    Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type d -exec chmod 755 {} +")
+    Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type f -exec chmod 644 {} +")
+    Puppet::Util::Execution.expects(:execute).with("chown -R <owner:group> #{destdir}")
+    subject.unpack(sourcefile, destdir, '<owner:group>')
   end
 
   it "packs a tar file" do

data/spec/unit/parser/files_spec.rb

@@ -10,14 +10,6 @@ describe Puppet::Parser::Files do
     @basepath = make_absolute("/somepath")
   end
 
-  it "should have a method for finding a template" do
-    Puppet::Parser::Files.should respond_to(:find_template)
-  end
-
-  it "should have a method for finding manifests" do
-    Puppet::Parser::Files.should respond_to(:find_manifests)
-  end
-
   describe "when searching for templates" do
     it "should return fully-qualified templates directly" do
       Puppet::Parser::Files.expects(:modulepath).never
@@ -127,90 +119,42 @@ describe Puppet::Parser::Files do
   describe "when searching for manifests" do
     it "should ignore invalid modules" do
       mod = mock 'module'
-      Puppet::Node::Environment.new.expects(:module).with("mymod").raises(Puppet::Module::InvalidName, "name is invalid")
+      env = Puppet::Node::Environment.new
+      env.expects(:module).with("mymod").raises(Puppet::Module::InvalidName, "name is invalid")
       Puppet.expects(:value).with(:modulepath).never
       Dir.stubs(:glob).returns %w{foo}
 
-      Puppet::Parser::Files.find_manifests("mymod/init.pp")
+      Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", env)
     end
   end
 
-  describe "when searching for manifests when no module is found" do
-    before do
-      File.stubs(:find).returns(nil)
-    end
-
-    it "should not look for modules when paths are fully qualified" do
-      Puppet.expects(:value).with(:modulepath).never
-      file = @basepath + "/fully/qualified/file.pp"
-      Dir.stubs(:glob).with(file).returns([file])
-      Puppet::Parser::Files.find_manifests(file)
-    end
-
-    it "should return nil and an array of fully qualified files" do
-      file = @basepath + "/fully/qualified/file.pp"
-      Dir.stubs(:glob).with(file).returns([file])
-      Puppet::Parser::Files.find_manifests(file).should == [nil, [file]]
-    end
-
-    it "should match against provided fully qualified patterns" do
-      pattern = @basepath + "/fully/qualified/pattern/*"
-      Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns(%w{my file list})
-      ['my', 'file','list'].each do |w|
-        FileTest.expects(:'directory?').with(w).returns false
-      end
-      Puppet::Parser::Files.find_manifests(pattern)[1].should == %w{my file list}
-    end
-
-    it "should look for files relative to the current directory" do
-      # We expand_path to normalize backslashes and slashes on Windows
-      cwd = File.expand_path(Dir.getwd)
-      Dir.expects(:glob).with("#{cwd}/foobar/init.pp").returns(["#{cwd}/foobar/init.pp"])
-      Puppet::Parser::Files.find_manifests("foobar/init.pp")[1].should == ["#{cwd}/foobar/init.pp"]
-    end
-
-    it "should only return files, not directories" do
-      pattern = @basepath + "/fully/qualified/pattern/*"
-      file = @basepath + "/my/file"
-      dir = @basepath + "/my/directory"
-      Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns([file, dir])
-      FileTest.expects(:directory?).with(file).returns(false)
-      FileTest.expects(:directory?).with(dir).returns(true)
-      Puppet::Parser::Files.find_manifests(pattern)[1].should == [file]
-    end
-
-    it "should return files once only" do
-      pattern = @basepath + "/fully/qualified/pattern/*"
-      Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns(%w{one two one})
-      Puppet::Parser::Files.find_manifests(pattern)[1].should == %w{one two}
-    end
-  end
-
-  describe "when searching for manifests in a found module" do
+  describe "when searching for manifests in a module" do
     def a_module_in_environment(env, name)
       mod = Puppet::Module.new(name, "/one/#{name}", env)
       env.stubs(:module).with(name).returns mod
       mod.stubs(:match_manifests).with("init.pp").returns(["/one/#{name}/manifests/init.pp"])
     end
 
-    it "should return the name of the module and the manifests from the first found module" do
-      a_module_in_environment(Puppet::Node::Environment.new, "mymod")
+    let(:environment) { Puppet::Node::Environment.new }
 
-      Puppet::Parser::Files.find_manifests("mymod/init.pp").should ==
-        ["mymod", ["/one/mymod/manifests/init.pp"]]
+    it "returns no files when no module is found" do
+      module_name, files = Puppet::Parser::Files.find_manifests_in_modules("not_here_module/foo", environment)
+      expect(files).to be_empty
+      expect(module_name).to be_nil
     end
 
-    it "should use the node environment if specified" do
-      a_module_in_environment(Puppet::Node::Environment.new("myenv"), "mymod")
+    it "should return the name of the module and the manifests from the first found module" do
+      a_module_in_environment(environment, "mymod")
 
-      Puppet::Parser::Files.find_manifests("mymod/init.pp", :environment => "myenv").should ==
+      Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", environment).should ==
         ["mymod", ["/one/mymod/manifests/init.pp"]]
     end
 
     it "does not find the module when it is a different environment" do
-      a_module_in_environment(Puppet::Node::Environment.new("myenv"), "mymod")
+      different_env = Puppet::Node::Environment.new("different")
+      a_module_in_environment(environment, "mymod")
 
-      Puppet::Parser::Files.find_manifests("mymod/init.pp", :environment => "different").should_not include("mymod")
+      Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", different_env).should_not include("mymod")
     end
   end
 end

data/spec/unit/parser/parser_spec.rb

@@ -35,16 +35,18 @@ describe Puppet::Parser do
   end
 
   context "when importing" do
-    it "should delegate importing to the known resource type loader" do
-      parser = Puppet::Parser::Parser.new "development"
-      parser.known_resource_types.loader.expects(:import).with("newfile", "current_file")
-      parser.lexer.expects(:file).returns "current_file"
-      parser.import("newfile")
+    it "uses the directory of the currently parsed file" do
+      @parser.lexer.stubs(:file).returns "/tmp/current_file"
+
+      @parser.known_resource_types.loader.expects(:import).with("newfile", "/tmp")
+
+      @parser.import("newfile")
     end
 
-    it "should import multiple files on one line" do
-      @parser.known_resource_types.loader.expects(:import).with('one', nil)
-      @parser.known_resource_types.loader.expects(:import).with('two', nil)
+    it "uses the current working directory, when there is no file being parsed" do
+      @parser.known_resource_types.loader.expects(:import).with('one', Dir.pwd)
+      @parser.known_resource_types.loader.expects(:import).with('two', Dir.pwd)
+
       @parser.parse("import 'one', 'two'")
     end
   end

data/spec/unit/parser/type_loader_spec.rb

@@ -37,67 +37,56 @@ describe Puppet::Parser::TypeLoader do
       end
 
       it "should attempt to import each generated name" do
-        @loader.expects(:import).with("foo/bar",nil).returns([])
-        @loader.expects(:import).with("foo",nil).returns([])
+        @loader.expects(:import_from_modules).with("foo/bar").returns([])
+        @loader.expects(:import_from_modules).with("foo").returns([])
         @loader.try_load_fqname(:hostclass, "foo::bar") { |f| false }
       end
     end
 
     describe "when importing" do
       before do
-        Puppet::Parser::Files.stubs(:find_manifests).returns ["modname", %w{file}]
+        Puppet::Parser::Files.stubs(:find_manifests_in_modules).returns ["modname", %w{file}]
         parser_class.any_instance.stubs(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
         parser_class.any_instance.stubs(:file=)
       end
 
       it "should return immediately when imports are being ignored" do
-        Puppet::Parser::Files.expects(:find_manifests).never
+        Puppet::Parser::Files.expects(:find_manifests_in_modules).never
         Puppet[:ignoreimport] = true
-        @loader.import("foo").should be_nil
+        @loader.import("foo", "/path").should be_nil
       end
 
       it "should find all manifests matching the file or pattern" do
-        Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| pat == "myfile" }.returns ["modname", %w{one}]
-        @loader.import("myfile")
-      end
-
-      it "should use the directory of the current file if one is set" do
-        Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| opts[:cwd] == make_absolute("/current") }.returns ["modname", %w{one}]
-        @loader.import("myfile", make_absolute("/current/file"))
+        Puppet::Parser::Files.expects(:find_manifests_in_modules).with("myfile", anything).returns ["modname", %w{one}]
+        @loader.import("myfile", "/path")
       end
 
       it "should pass the environment when looking for files" do
-        Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| opts[:environment] == @loader.environment }.returns ["modname", %w{one}]
-        @loader.import("myfile")
+        Puppet::Parser::Files.expects(:find_manifests_in_modules).with(anything, @loader.environment).returns ["modname", %w{one}]
+        @loader.import("myfile", "/path")
       end
 
       it "should fail if no files are found" do
-        Puppet::Parser::Files.expects(:find_manifests).returns [nil, []]
-        lambda { @loader.import("myfile") }.should raise_error(Puppet::ImportError)
+        Puppet::Parser::Files.expects(:find_manifests_in_modules).returns [nil, []]
+        lambda { @loader.import("myfile", "/path") }.should raise_error(Puppet::ImportError)
       end
 
       it "should parse each found file" do
-        Puppet::Parser::Files.expects(:find_manifests).returns ["modname", [make_absolute("/one")]]
+        Puppet::Parser::Files.expects(:find_manifests_in_modules).returns ["modname", [make_absolute("/one")]]
         @loader.expects(:parse_file).with(make_absolute("/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
-        @loader.import("myfile")
-      end
-
-      it "should make each file qualified before attempting to parse it" do
-        Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{one}]
-        @loader.expects(:parse_file).with(make_absolute("/current/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
-        @loader.import("myfile", make_absolute("/current/file"))
+        @loader.import("myfile", "/path")
       end
 
       it "should not attempt to import files that have already been imported" do
         @loader = Puppet::Parser::TypeLoader.new(:myenv)
 
-        Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{/one}]
+        Puppet::Parser::Files.expects(:find_manifests_in_modules).returns ["modname", %w{/one}]
         parser_class.any_instance.expects(:parse).once.returns(Puppet::Parser::AST::Hostclass.new(''))
         other_parser_class.any_instance.expects(:parse).never.returns(Puppet::Parser::AST::Hostclass.new(''))
-        @loader.import("myfile")
+        @loader.import("myfile", "/path")
 
         # This will fail if it tries to reimport the file.
-        @loader.import("myfile")
+        @loader.import("myfile", "/path")
       end
     end
 
@@ -219,7 +208,7 @@ describe Puppet::Parser::TypeLoader do
     it "should be able to add classes to the current resource type collection" do
       file = tmpfile("simple_file.pp")
       File.open(file, "w") { |f| f.puts "class foo {}" }
-      @loader.import(file)
+      @loader.import(File.basename(file), File.dirname(file))
 
       @loader.known_resource_types.hostclass("foo").should be_instance_of(Puppet::Resource::Type)
     end

data/spec/unit/resource/type_collection_spec.rb

@@ -55,6 +55,14 @@ describe Puppet::Resource::TypeCollection do
     @code.node("foo").should equal(node)
   end
 
+  it "should fail if a duplicate node is added" do
+    @code.add(Puppet::Resource::Type.new(:node, "foo"))
+
+    expect do
+      @code.add(Puppet::Resource::Type.new(:node, "foo"))
+    end.to raise_error(Puppet::ParseError, /cannot redefine/)
+  end
+
   it "should store hostclasses as hostclasses" do
     klass = Puppet::Resource::Type.new(:hostclass, "foo")
 
@@ -62,6 +70,16 @@ describe Puppet::Resource::TypeCollection do
     @code.hostclass("foo").should equal(klass)
   end
 
+  it "merge together hostclasses of the same name" do
+    klass1 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "first")
+    klass2 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "second")
+
+    @code.add(klass1)
+    @code.add(klass2)
+
+    @code.hostclass("foo").doc.should == "firstsecond"
+  end
+
   it "should store definitions as definitions" do
     define = Puppet::Resource::Type.new(:definition, "foo")
 
@@ -69,13 +87,12 @@ describe Puppet::Resource::TypeCollection do
     @code.definition("foo").should equal(define)
   end
 
-  it "should merge new classes with existing classes of the same name" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-    first = Puppet::Resource::Type.new(:hostclass, "foo")
-    second = Puppet::Resource::Type.new(:hostclass, "foo")
-    loader.add first
-    first.expects(:merge).with(second)
-    loader.add(second)
+  it "should fail if a duplicate definition is added" do
+    @code.add(Puppet::Resource::Type.new(:definition, "foo"))
+
+    expect do
+      @code.add(Puppet::Resource::Type.new(:definition, "foo"))
+    end.to raise_error(Puppet::ParseError, /cannot be redefined/)
   end
 
   it "should remove all nodes, classes, and definitions when cleared" do
@@ -180,58 +197,27 @@ describe Puppet::Resource::TypeCollection do
   end
 
   %w{hostclass node definition}.each do |data|
-    before do
-      @instance = Puppet::Resource::Type.new(data, "foo")
-    end
+    describe "behavior of add for #{data}" do
 
-    it "should have a method for adding a #{data}" do
-      Puppet::Resource::TypeCollection.new("env").should respond_to("add_#{data}")
-    end
-
-    it "should use the name of the instance to add it" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      loader.send("add_#{data}", @instance)
-      loader.send(data, @instance.name).should equal(@instance)
-    end
-
-    unless data == "hostclass"
-      it "should fail to add a #{data} when one already exists" do
+      it "should return the added #{data}" do
         loader = Puppet::Resource::TypeCollection.new("env")
-        loader.add @instance
-        lambda { loader.add(@instance) }.should raise_error(Puppet::ParseError)
-      end
-    end
-
-    it "should return the added #{data}" do
-      loader = Puppet::Resource::TypeCollection.new("env")
+        instance = Puppet::Resource::Type.new(data, "foo")
 
-      loader.add(@instance).should equal(@instance)
-    end
+        loader.add(instance).should equal(instance)
+      end
 
-    it "should be able to retrieve #{data} by name" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(data, "bar")
-      loader.add instance
-      loader.send(data, "bar").should equal(instance)
-    end
+      it "should retrieve #{data} insensitive to case" do
+        loader = Puppet::Resource::TypeCollection.new("env")
+        instance = Puppet::Resource::Type.new(data, "Bar")
 
-    it "should retrieve #{data} insensitive to case" do
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(data, "Bar")
-      loader.add instance
-      loader.send(data, "bAr").should equal(instance)
-    end
+        loader.add instance
 
-    it "should return nil when asked for a #{data} that has not been added" do
-      Puppet::Resource::TypeCollection.new("env").send(data, "foo").should be_nil
-    end
+        loader.send(data, "bAr").should equal(instance)
+      end
 
-    it "should be able to retrieve all #{data}s" do
-      plurals = { "hostclass" => "hostclasses", "node" => "nodes", "definition" => "definitions" }
-      loader = Puppet::Resource::TypeCollection.new("env")
-      instance = Puppet::Resource::Type.new(data, "foo")
-      loader.add instance
-      loader.send(plurals[data]).should == { "foo" => instance }
+      it "should return nil when asked for a #{data} that has not been added" do
+        Puppet::Resource::TypeCollection.new("env").send(data, "foo").should be_nil
+      end
     end
   end
 
@@ -319,12 +305,12 @@ describe Puppet::Resource::TypeCollection do
       it "should only look in the topclass, if the name is qualified" do
         @loader.find_hostclass("foo", "::bar").name.should == 'bar'
       end
-      
+
       it "should only look in the topclass, if we assume the name is fully qualified" do
         @loader.find_hostclass("foo", "bar", :assume_fqname => true).name.should == 'bar'
       end
     end
-    
+
     it "should not look in the local scope for classes when the name is qualified" do
         @loader = Puppet::Resource::TypeCollection.new("env")
         @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
@@ -341,18 +327,6 @@ describe Puppet::Resource::TypeCollection do
     loader.find_node(stub("ignored"), "bar").should == node
   end
 
-  it "should use the 'find_or_load' method to find hostclasses" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-    loader.expects(:find_or_load).with("foo", "bar", :hostclass, {})
-    loader.find_hostclass("foo", "bar")
-  end
-
-  it "should use the 'find_or_load' method to find definitions" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-    loader.expects(:find_or_load).with("foo", "bar", :definition)
-    loader.find_definition("foo", "bar")
-  end
-
   it "should indicate whether any nodes are defined" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.add_node(Puppet::Resource::Type.new(:node, "foo"))
@@ -458,7 +432,5 @@ describe Puppet::Resource::TypeCollection do
 
       lambda { @code.version }.should raise_error(Puppet::ParseError)
     end
-
   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: puppet
 version: !ruby/object:Gem::Version
-  version: 3.2.3
+  version: 3.2.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-12 00:00:00.000000000 Z
+date: 2013-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facter
@@ -878,6 +878,7 @@ files:
 - lib/puppet/forge/repository.rb
 - lib/puppet/forge/cache.rb
 - lib/puppet/file_serving.rb
+- lib/puppet/file_system/path_pattern.rb
 - lib/puppet/network/authentication.rb
 - lib/puppet/network/rights.rb
 - lib/puppet/network/rest_controller.rb
@@ -919,6 +920,7 @@ files:
 - lib/puppet/forge.rb
 - lib/puppet/data_binding.rb
 - lib/puppet/simple_graph.rb
+- lib/puppet/file_system.rb
 - lib/puppet/daemon.rb
 - lib/puppet/network.rb
 - lib/puppet/parameter/value.rb
@@ -1969,6 +1971,7 @@ files:
 - spec/unit/forge/repository_spec.rb
 - spec/unit/forge/errors_spec.rb
 - spec/unit/daemon_spec.rb
+- spec/unit/file_system/path_pattern_spec.rb
 - spec/unit/status_spec.rb
 - spec/unit/network/authentication_spec.rb
 - spec/unit/network/rights_spec.rb
@@ -2878,6 +2881,7 @@ test_files:
 - spec/unit/forge/repository_spec.rb
 - spec/unit/forge/errors_spec.rb
 - spec/unit/daemon_spec.rb
+- spec/unit/file_system/path_pattern_spec.rb
 - spec/unit/status_spec.rb
 - spec/unit/network/authentication_spec.rb
 - spec/unit/network/rights_spec.rb