# module Puppet::Parser::Files

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.

### Public Instance Methods

find_manifests(start, options = {}) click to toggle source

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`

    # File lib/puppet/parser/files.rb, line 16
    def find_manifests(start, options = {})
      cwd = options[:cwd] || Dir.getwd
      module_name, pattern = split_file_path(start)
      begin
        if mod = Puppet::Module.find(module_name, options[:environment])
          return [mod.name, mod.match_manifests(pattern)]
        end
      rescue Puppet::Module::InvalidName
        # Than that would be a "no."
      end
      abspat = File::expand_path(start, cwd)
      [nil, Dir.glob(abspat + (File.extname(abspat).empty? ? '{.pp,.rb}' : '' )).uniq.reject { |f| FileTest.directory?(f) }]
    end

find_template(template, environment = nil) click to toggle source

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

    # File lib/puppet/parser/files.rb, line 36
    def find_template(template, environment = nil)
      if template == File.expand_path(template)
        return template
      end

      if template_paths = templatepath(environment)
        # If we can find the template in :templatedir, we return that.
        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
      if td_file = find_template_in_module(template, environment)
        return td_file
      end

      nil
    end

find_template_in_module(template, environment = nil) click to toggle source

    # File lib/puppet/parser/files.rb, line 58
    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

split_file_path(path) click to toggle source

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.

    # File lib/puppet/parser/files.rb, line 84
    def split_file_path(path)
      path.split(File::SEPARATOR, 2) unless path == "" or Puppet::Util.absolute_path?(path)
    end

templatepath(environment = nil) click to toggle source

Return an array of paths by splitting the `templatedir` config parameter.

    # File lib/puppet/parser/files.rb, line 74
    def templatepath(environment = nil)
      dirs = Puppet.settings.value(:templatedir, environment).split(File::PATH_SEPARATOR)
      dirs.select do |p|
        File::directory?(p)
      end
    end