Moving file-searching code out of Puppet::Module

The Module class had a bunch of code for finding
manifests and templates even when not in a module,
and it complicated the class unnecessarily.  This
moves that code to a new, hackish-but-sufficient
module for just that purpose.

Signed-off-by: Luke Kanies <luke@madstop.com>

3 files changed, 196 insertions, 181 deletions

diff --git a/spec/unit/module.rb b/spec/unit/module.rb
index 313de6761..17c2065eb 100755
--- a/spec/unit/module.rb
+++ b/spec/unit/module.rb
@@ -164,185 +164,6 @@ describe Puppet::Module, " when searching for modules" do
     end
 end
 
-describe Puppet::Module, " when searching for templates" do
-    it "should return fully-qualified templates directly" do
-        Puppet::Module.expects(:modulepath).never
-        Puppet::Module.find_template("/my/template").should == "/my/template"
-    end
-
-    it "should return the template from the first found module" do
-        mod = mock 'module'
-        Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
-
-        mod.expects(:template).returns("/one/mymod/templates/mytemplate")
-        Puppet::Module.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
-    end
-    
-    it "should return the file in the templatedir if it exists" do
-        Puppet.settings.expects(:value).with(:templatedir, nil).returns("/my/templates")
-        Puppet[:modulepath] = "/one:/two"
-        File.stubs(:directory?).returns(true)
-        FileTest.stubs(:exist?).returns(true)
-        Puppet::Module.find_template("mymod/mytemplate").should == "/my/templates/mymod/mytemplate"
-    end
-
-    it "should raise an error if no valid templatedir exists" do
-        Puppet::Module.stubs(:templatepath).with(nil).returns(nil)
-        lambda { Puppet::Module.find_template("mytemplate") }.should raise_error
-    end
-
-    it "should not raise an error if no valid templatedir exists and the template exists in a module" do
-        mod = mock 'module'
-        Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
-
-        mod.expects(:template).returns("/one/mymod/templates/mytemplate")
-        Puppet::Module.stubs(:templatepath).with(nil).returns(nil)
-
-        Puppet::Module.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
-    end
-
-    it "should use the main templatedir if no module is found" do
-        Puppet::Module.stubs(:templatepath).with(nil).returns(["/my/templates"])
-        Puppet::Module.expects(:find).with("mymod", nil).returns(nil)
-        Puppet::Module.find_template("mymod/mytemplate").should == "/my/templates/mymod/mytemplate"
-    end
-
-    it "should return unqualified templates directly in the template dir" do
-        Puppet::Module.stubs(:templatepath).with(nil).returns(["/my/templates"])
-        Puppet::Module.expects(:find).never
-        Puppet::Module.find_template("mytemplate").should == "/my/templates/mytemplate"
-    end
-
-    it "should accept relative templatedirs" do
-        Puppet[:templatedir] = "my/templates"
-        File.expects(:directory?).with(File.join(Dir.getwd,"my/templates")).returns(true)
-        Puppet::Module.find_template("mytemplate").should == File.join(Dir.getwd,"my/templates/mytemplate")
-    end
-
-    it "should use the environment templatedir if no module is found and an environment is specified" do
-        Puppet::Module.stubs(:templatepath).with("myenv").returns(["/myenv/templates"])
-        Puppet::Module.expects(:find).with("mymod", "myenv").returns(nil)
-        Puppet::Module.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
-    end
-
-    it "should use first dir from environment templatedir if no module is found and an environment is specified" do
-        Puppet::Module.stubs(:templatepath).with("myenv").returns(["/myenv/templates", "/two/templates"])
-        Puppet::Module.expects(:find).with("mymod", "myenv").returns(nil)
-        Puppet::Module.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
-    end
-
-    it "should use a valid dir when templatedir is a path for unqualified templates and the first dir contains template" do
-        Puppet::Module.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
-        FileTest.expects(:exist?).with("/one/templates/mytemplate").returns(true)
-        Puppet::Module.expects(:find).never
-        Puppet::Module.find_template("mytemplate").should == "/one/templates/mytemplate"
-    end
-
-    it "should use a valid dir when templatedir is a path for unqualified templates and only second dir contains template" do
-        Puppet::Module.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
-        FileTest.expects(:exist?).with("/one/templates/mytemplate").returns(false)
-        FileTest.expects(:exist?).with("/two/templates/mytemplate").returns(true)
-        Puppet::Module.expects(:find).never
-        Puppet::Module.find_template("mytemplate").should == "/two/templates/mytemplate"
-    end
-
-    it "should use the node environment if specified" do
-        mod = mock 'module'
-        Puppet::Node::Environment.new("myenv").expects(:module).with("mymod").returns mod
-
-        mod.expects(:template).returns("/my/modules/mymod/templates/envtemplate")
-
-        Puppet::Module.find_template("mymod/envtemplate", "myenv").should == "/my/modules/mymod/templates/envtemplate"
-    end
-
-    after { Puppet.settings.clear }
-end
-
-describe Puppet::Module, " 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 = "/fully/qualified/file.pp"
-        Dir.stubs(:glob).with(file).returns([file])
-        Puppet::Module.find_manifests(file)
-    end
-
-    it "should directly return fully qualified files" do
-        file = "/fully/qualified/file.pp"
-        Dir.stubs(:glob).with(file).returns([file])
-        Puppet::Module.find_manifests(file).should == [file]
-    end
-
-    it "should match against provided fully qualified patterns" do
-        pattern = "/fully/qualified/pattern/*"
-        Dir.expects(:glob).with(pattern).returns(%w{my file list})
-        Puppet::Module.find_manifests(pattern).should == %w{my file list}
-    end
-
-    it "should look for files relative to the current directory" do
-        cwd = Dir.getwd
-        Dir.expects(:glob).with("#{cwd}/foobar/init.pp").returns(["#{cwd}/foobar/init.pp"])
-        Puppet::Module.find_manifests("foobar/init.pp").should == ["#{cwd}/foobar/init.pp"]
-    end
-
-    it "should only return files, not directories" do
-        pattern = "/fully/qualified/pattern/*"
-        file = "/my/file"
-        dir = "/my/directory"
-        Dir.expects(:glob).with(pattern).returns([file, dir])
-        FileTest.expects(:directory?).with(file).returns(false)
-        FileTest.expects(:directory?).with(dir).returns(true)
-        Puppet::Module.find_manifests(pattern).should == [file]
-    end
-end
-
-describe Puppet::Module, " when searching for manifests in a found module" do
-    before do
-        @module = Puppet::Module.new("mymod", "/one")
-    end
-
-    it "should return the manifests from the first found module" do
-        mod = mock 'module'
-        Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
-        mod.expects(:match_manifests).with("init.pp").returns(%w{/one/mymod/manifests/init.pp})
-        Puppet::Module.find_manifests("mymod/init.pp").should == ["/one/mymod/manifests/init.pp"]
-    end
-
-    it "should use the node environment if specified" do
-        mod = mock 'module'
-        Puppet::Node::Environment.new("myenv").expects(:module).with("mymod").returns mod
-        mod.expects(:match_manifests).with("init.pp").returns(%w{/one/mymod/manifests/init.pp})
-        Puppet::Module.find_manifests("mymod/init.pp", :environment => "myenv").should == ["/one/mymod/manifests/init.pp"]
-    end
-
-    it "should return all manifests matching the glob pattern" do
-        File.stubs(:directory?).returns(true)
-        Dir.expects(:glob).with("/one/manifests/yay/*.pp").returns(%w{/one /two})
-
-        @module.match_manifests("yay/*.pp").should == %w{/one /two}
-    end
-
-    it "should not return directories" do
-        Dir.expects(:glob).with("/one/manifests/yay/*.pp").returns(%w{/one /two})
-
-        FileTest.expects(:directory?).with("/one").returns false
-        FileTest.expects(:directory?).with("/two").returns true
-
-        @module.match_manifests("yay/*.pp").should == %w{/one}
-    end
-
-    it "should default to the 'init.pp' file in the manifests directory" do
-        Dir.expects(:glob).with("/one/manifests/init.pp").returns(%w{/init.pp})
-
-        @module.match_manifests(nil).should == %w{/init.pp}
-    end
-
-    after { Puppet.settings.clear }
-end
-
 describe Puppet::Module, " when returning files" do
     it "should return the path to the module's 'files' directory" do
         mod = Puppet::Module.send(:new, "mymod", "/my/mod")
diff --git a/spec/unit/parser/files.rb b/spec/unit/parser/files.rb
new file mode 100644
index 000000000..f401a902c
--- /dev/null
+++ b/spec/unit/parser/files.rb
@@ -0,0 +1,194 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/parser/files'
+
+describe Puppet::Parser::Files do
+    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
+            Puppet::Parser::Files.find_template("/my/template").should == "/my/template"
+        end
+
+        it "should return the template from the first found module" do
+            mod = mock 'module'
+            Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
+
+            mod.expects(:template).returns("/one/mymod/templates/mytemplate")
+            Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
+        end
+        
+        it "should return the file in the templatedir if it exists" do
+            Puppet.settings.expects(:value).with(:templatedir, nil).returns("/my/templates")
+            Puppet[:modulepath] = "/one:/two"
+            File.stubs(:directory?).returns(true)
+            FileTest.stubs(:exist?).returns(true)
+            Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/my/templates/mymod/mytemplate"
+        end
+
+        it "should raise an error if no valid templatedir exists" do
+            Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(nil)
+            lambda { Puppet::Parser::Files.find_template("mytemplate") }.should raise_error
+        end
+
+        it "should not raise an error if no valid templatedir exists and the template exists in a module" do
+            mod = mock 'module'
+            Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
+
+            mod.expects(:template).returns("/one/mymod/templates/mytemplate")
+            Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(nil)
+
+            Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
+        end
+
+        it "should use the main templatedir if no module is found" do
+            Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
+            Puppet::Module.expects(:find).with("mymod", nil).returns(nil)
+            Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/my/templates/mymod/mytemplate"
+        end
+
+        it "should return unqualified templates directly in the template dir" do
+            Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
+            Puppet::Module.expects(:find).never
+            Puppet::Parser::Files.find_template("mytemplate").should == "/my/templates/mytemplate"
+        end
+
+        it "should accept relative templatedirs" do
+            Puppet[:templatedir] = "my/templates"
+            File.expects(:directory?).with(File.join(Dir.getwd,"my/templates")).returns(true)
+            Puppet::Parser::Files.find_template("mytemplate").should == File.join(Dir.getwd,"my/templates/mytemplate")
+        end
+
+        it "should use the environment templatedir if no module is found and an environment is specified" do
+            Puppet::Parser::Files.stubs(:templatepath).with("myenv").returns(["/myenv/templates"])
+            Puppet::Module.expects(:find).with("mymod", "myenv").returns(nil)
+            Puppet::Parser::Files.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
+        end
+
+        it "should use first dir from environment templatedir if no module is found and an environment is specified" do
+            Puppet::Parser::Files.stubs(:templatepath).with("myenv").returns(["/myenv/templates", "/two/templates"])
+            Puppet::Module.expects(:find).with("mymod", "myenv").returns(nil)
+            Puppet::Parser::Files.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
+        end
+
+        it "should use a valid dir when templatedir is a path for unqualified templates and the first dir contains template" do
+            Puppet::Parser::Files.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
+            FileTest.expects(:exist?).with("/one/templates/mytemplate").returns(true)
+            Puppet::Module.expects(:find).never
+            Puppet::Parser::Files.find_template("mytemplate").should == "/one/templates/mytemplate"
+        end
+
+        it "should use a valid dir when templatedir is a path for unqualified templates and only second dir contains template" do
+            Puppet::Parser::Files.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
+            FileTest.expects(:exist?).with("/one/templates/mytemplate").returns(false)
+            FileTest.expects(:exist?).with("/two/templates/mytemplate").returns(true)
+            Puppet::Module.expects(:find).never
+            Puppet::Parser::Files.find_template("mytemplate").should == "/two/templates/mytemplate"
+        end
+
+        it "should use the node environment if specified" do
+            mod = mock 'module'
+            Puppet::Node::Environment.new("myenv").expects(:module).with("mymod").returns mod
+
+            mod.expects(:template).returns("/my/modules/mymod/templates/envtemplate")
+
+            Puppet::Parser::Files.find_template("mymod/envtemplate", "myenv").should == "/my/modules/mymod/templates/envtemplate"
+        end
+
+        after { Puppet.settings.clear }
+    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 = "/fully/qualified/file.pp"
+            Dir.stubs(:glob).with(file).returns([file])
+            Puppet::Parser::Files.find_manifests(file)
+        end
+
+        it "should directly return fully qualified files" do
+            file = "/fully/qualified/file.pp"
+            Dir.stubs(:glob).with(file).returns([file])
+            Puppet::Parser::Files.find_manifests(file).should == [file]
+        end
+
+        it "should match against provided fully qualified patterns" do
+            pattern = "/fully/qualified/pattern/*"
+            Dir.expects(:glob).with(pattern).returns(%w{my file list})
+            Puppet::Parser::Files.find_manifests(pattern).should == %w{my file list}
+        end
+
+        it "should look for files relative to the current directory" do
+            cwd = Dir.getwd
+            Dir.expects(:glob).with("#{cwd}/foobar/init.pp").returns(["#{cwd}/foobar/init.pp"])
+            Puppet::Parser::Files.find_manifests("foobar/init.pp").should == ["#{cwd}/foobar/init.pp"]
+        end
+
+        it "should only return files, not directories" do
+            pattern = "/fully/qualified/pattern/*"
+            file = "/my/file"
+            dir = "/my/directory"
+            Dir.expects(:glob).with(pattern).returns([file, dir])
+            FileTest.expects(:directory?).with(file).returns(false)
+            FileTest.expects(:directory?).with(dir).returns(true)
+            Puppet::Parser::Files.find_manifests(pattern).should == [file]
+        end
+    end
+
+    describe "when searching for manifests in a found module" do
+        before do
+            @module = Puppet::Module.new("mymod", "/one")
+        end
+
+        it "should return the manifests from the first found module" do
+            mod = mock 'module'
+            Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
+            mod.expects(:match_manifests).with("init.pp").returns(%w{/one/mymod/manifests/init.pp})
+            Puppet::Parser::Files.find_manifests("mymod/init.pp").should == ["/one/mymod/manifests/init.pp"]
+        end
+
+        it "should use the node environment if specified" do
+            mod = mock 'module'
+            Puppet::Node::Environment.new("myenv").expects(:module).with("mymod").returns mod
+            mod.expects(:match_manifests).with("init.pp").returns(%w{/one/mymod/manifests/init.pp})
+            Puppet::Parser::Files.find_manifests("mymod/init.pp", :environment => "myenv").should == ["/one/mymod/manifests/init.pp"]
+        end
+
+        it "should return all manifests matching the glob pattern" do
+            File.stubs(:directory?).returns(true)
+            Dir.expects(:glob).with("/one/manifests/yay/*.pp").returns(%w{/one /two})
+
+            @module.match_manifests("yay/*.pp").should == %w{/one /two}
+        end
+
+        it "should not return directories" do
+            Dir.expects(:glob).with("/one/manifests/yay/*.pp").returns(%w{/one /two})
+
+            FileTest.expects(:directory?).with("/one").returns false
+            FileTest.expects(:directory?).with("/two").returns true
+
+            @module.match_manifests("yay/*.pp").should == %w{/one}
+        end
+
+        it "should default to the 'init.pp' file in the manifests directory" do
+            Dir.expects(:glob).with("/one/manifests/init.pp").returns(%w{/init.pp})
+
+            @module.match_manifests(nil).should == %w{/init.pp}
+        end
+
+        after { Puppet.settings.clear }
+    end
+end
diff --git a/spec/unit/parser/templatewrapper.rb b/spec/unit/parser/templatewrapper.rb
index fd9efa8af..ce458af75 100755
--- a/spec/unit/parser/templatewrapper.rb
+++ b/spec/unit/parser/templatewrapper.rb
@@ -8,7 +8,7 @@ describe Puppet::Parser::TemplateWrapper do
         parser = stub('parser', :watch_file => true)
         @scope = stub('scope', :compiler => compiler, :parser => parser, :to_hash => {})
         @file = "fake_template"
-        Puppet::Module.stubs(:find_template).returns("/tmp/fake_template")
+        Puppet::Parser::Files.stubs(:find_template).returns("/tmp/fake_template")
         FileTest.stubs(:exists?).returns("true")
         File.stubs(:read).with("/tmp/fake_template").returns("template content")
         @tw = Puppet::Parser::TemplateWrapper.new(@scope)
@@ -21,7 +21,7 @@ describe Puppet::Parser::TemplateWrapper do
     end
 
     it "should check template file existance and read its content" do
-        Puppet::Module.expects(:find_template).with("fake_template", "foo").returns("/tmp/fake_template")
+        Puppet::Parser::Files.expects(:find_template).with("fake_template", "foo").returns("/tmp/fake_template")
         FileTest.expects(:exists?).with("/tmp/fake_template").returns(true)
         File.expects(:read).with("/tmp/fake_template").returns("template content")