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