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, 99 insertions, 3 deletions

diff --git a/lib/puppet/parser/files.rb b/lib/puppet/parser/files.rb
new file mode 100644
index 000000000..2cd163f97
--- /dev/null
+++ b/lib/puppet/parser/files.rb
@@ -0,0 +1,94 @@
+require 'puppet/module'
+require 'puppet/parser/parser'
+
+# This is a silly central module for finding
+# different kinds of files while parsing.  This code
+# doesn't really belong in the Puppet::Module class,
+# but it doesn't really belong anywhere else, either.
+module Puppet::Parser::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)
+        if module_name and mod = Puppet::Module.find(module_name, options[:environment])
+            return mod.match_manifests(pattern)
+        else
+            abspat = File::expand_path(start, cwd)
+            files = Dir.glob(abspat).reject { |f| FileTest.directory?(f) }
+            if files.size == 0
+                files = Dir.glob(abspat + ".pp").reject { |f| FileTest.directory?(f) }
+            end
+            return files
+        end
+    end
+
+    # Find the concrete file denoted by +file+. If +file+ is absolute,
+    # return it directly. Otherwise try to find it as a template in a
+    # module. If that fails, return it relative to the +templatedir+ config
+    # param.
+    # In all cases, an absolute path is returned, which does not
+    # necessarily refer to an existing file
+    def find_template(template, environment = nil)
+        if template =~ /^#{File::SEPARATOR}/
+            return template
+        end
+
+        if template_paths = templatepath(environment)
+            # If we can find the template in :templatedir, we return that.
+            td_file = template_paths.collect { |path|
+                File::join(path, template)
+            }.each do |f|
+                return f if FileTest.exist?(f)
+            end
+        end
+
+        # check in the default template dir, if there is one
+        unless td_file = find_template_in_module(template, environment)
+            raise Puppet::Error, "No valid template directory found, please check templatedir settings" if template_paths.nil?
+            td_file = File::join(template_paths.first, template)
+        end
+        td_file
+    end
+
+    def find_template_in_module(template, environment = nil)
+        path, file = split_file_path(template)
+
+        # Because templates don't have an assumed template name, like manifests do,
+        # we treat templates with no name as being templates in the main template
+        # directory.
+        return nil unless file
+
+        if mod = Puppet::Module.find(path, environment) and t = mod.template(file)
+            return t
+        end
+        nil
+    end
+
+    # Return an array of paths by splitting the +templatedir+ config
+    # parameter.
+    def templatepath(environment = nil)
+        dirs = Puppet.settings.value(:templatedir, environment).split(":")
+        dirs.select do |p|
+            File::directory?(p)
+        end
+    end
+
+    # Split the path into the module and the rest of the path.
+    # This method can and often does return nil, so anyone calling
+    # it needs to handle that.
+    def split_file_path(path)
+        if path =~ %r/^#{File::SEPARATOR}/
+            return nil
+        end
+
+        modname, rest = path.split(File::SEPARATOR, 2)
+        return nil if modname.nil? || modname.empty?
+        return modname, rest
+    end
+end
diff --git a/lib/puppet/parser/parser_support.rb b/lib/puppet/parser/parser_support.rb
index d59093799..3a6853f27 100644
--- a/lib/puppet/parser/parser_support.rb
+++ b/lib/puppet/parser/parser_support.rb
@@ -2,6 +2,7 @@
 # tired of rebuilding the parser.rb file all the time.
 class Puppet::Parser::Parser
     require 'puppet/parser/functions'
+    require 'puppet/parser/files'
 
     ASTSet = Struct.new(:classes, :definitions, :nodes)
 
@@ -183,7 +184,7 @@ class Puppet::Parser::Parser
                "in file #{@lexer.file} at line #{@lexer.line}"
             )
         end
-        files = Puppet::Module::find_manifests(pat, :cwd => dir, :environment => @environment)
+        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}'")
diff --git a/lib/puppet/parser/templatewrapper.rb b/lib/puppet/parser/templatewrapper.rb
index 55c7745ba..8b333a0b6 100644
--- a/lib/puppet/parser/templatewrapper.rb
+++ b/lib/puppet/parser/templatewrapper.rb
@@ -1,5 +1,7 @@
 # A simple wrapper for templates, so they don't have full access to
 # the scope objects.
+require 'puppet/parser/files'
+
 class Puppet::Parser::TemplateWrapper
     attr_accessor :scope, :file, :string
     include Puppet::Util
@@ -63,7 +65,7 @@ class Puppet::Parser::TemplateWrapper
     end
 
     def file=(filename)
-        @file = Puppet::Module::find_template(filename, scope.compiler.environment)
+        @file = Puppet::Parser::Files.find_template(filename, scope.compiler.environment)
 
         unless FileTest.exists?(file)
             raise Puppet::ParseError,
@@ -113,4 +115,3 @@ class Puppet::Parser::TemplateWrapper
         "template[%s]" % (file ? file : "inline")
     end
 end
-