# File lib/automateit/template_manager/base.rb, line 10
  def setup(opts={})
    super(opts)
    if opts[:default_check]
      @default_check = opts[:default_check]
    else
      @default_check ||= :compare
    end
  end

# File lib/automateit/template_manager/base.rb, line 60
  def _backup(filename)
    interpreter.backup(filename)
  end

# File lib/automateit/template_manager/base.rb, line 35
  def _exists?(filename)
    return File.exists?(filename)
  end

# File lib/automateit/template_manager/base.rb, line 65
  def _mtime(filename)
    return _exists? ? File.mtime(filename) : nil
  end

# File lib/automateit/template_manager/base.rb, line 25
  def _newer(filename, *dependencies)
    updated = []
    timestamp = _mtime(filename)
    for dependency in dependencies
      updated << dependency if _mtime(dependency) > timestamp
    end
    return updated
  end

# File lib/automateit/template_manager/base.rb, line 40
  def _read(filename)
    begin
      result = File.read(filename)
      return result
    rescue Errno::ENOENT => e
      if writing?
        raise e
      else
        return ""
      end
    end
  end

# File lib/automateit/template_manager/base.rb, line 86
  def _render_helper(*options, &block) # :yields: block_opts
    args, opts = args_and_opts(*options)
    source_filename = args[0] || opts[:file]
    target_filename = args[1] || opts[:to]
    source_text = opts[:text]
    opts[:backup] = true if opts[:backup].nil?

    raise ArgumentError.new("No source specified with :file or :text") if not source_filename and not source_text
    raise Errno::ENOENT.new(source_filename) if writing? and source_filename and not _exists?(source_filename)

    begin
      # source_filename, target_filename, opts={}
      opts[:check] ||= @default_check
      target_exists = target_filename && _exists?(target_filename)
      updates = []

      if target_filename
        unless opts[:force]
          case opts[:check]
          when :exists
            if target_exists
              log.debug(PNOTE+"Rendering for '#{target_filename}' skipped because it already exists")
              return false
            else
              log.info(PNOTE+"Rendering '#{target_filename}' because of it doesn't exist")
            end
          when :timestamp
            if target_exists
              updates = _newer(target_filename, \
                  *[source_filename, opts[:dependencies]].reject{|t| t.nil?}.flatten)
              if updates.empty?
                log.debug(PNOTE+"Rendering for '#{target_filename}' skipped because dependencies haven't been updated")
                return false
              end
            end
          end
        end
      end

      target_contents = target_exists ? _read(target_filename) : ""
      source_text ||= _read(source_filename)

      if source_text.blank? and preview?
        return true
      end

      binder = nil
      if opts[:locals]
        # Create a binding that the template can get variables from without
        # polluting the Driver's namespace.
        callback = lambda{
          code = ""
          for key in opts[:locals].keys
            code << "#{key} = opts[:locals][:#{key}]\n"
          end
          eval code
          binding
        }
        binder = callback.call
      end

      block_opts = {
        :binder => binder,
        :filename => source_filename,
        :text => source_text,
        :locals => opts[:locals],
        :opts => opts,
      }
      output = block.call(block_opts)

      if target_filename
        case opts[:check]
        when :compare
          if not target_exists
            log.info(PNOTE+"Rendering '#{target_filename}' because of it doesn't exist")
          elsif output == target_contents
            log.debug(PNOTE+"Rendering for '#{target_filename}' skipped because contents are the same")
            return false
          else
            log.info(PNOTE+"Rendering '#{target_filename}' because its contents changed")
          end
        when :timestamp
          log.info(PNOTE+"Rendering '#{target_filename}' because of updated: #{updates.join(' ')}")
        end
      end

      _backup(target_filename) if target_exists and opts[:backup]

      return(target_filename ? _write(target_filename, output) : output)
    ensure
      if opts[:mode] or opts[:user] or opts[:group]
        interpreter.chperm(target_filename, :mode => opts[:mode], :user => opts[:user], :group => opts[:group])
      end
    end
  end

# File lib/automateit/template_manager/base.rb, line 54
  def _write(filename, contents)
    File.open(filename, "w+"){|writer| writer.write(contents)} if writing?
    return true
  end