diff --git a/lib/puppet/parser/functions/generate.rb b/lib/puppet/parser/functions/generate.rb
index 35c752c0b..8a71cfb6c 100644
--- a/lib/puppet/parser/functions/generate.rb
+++ b/lib/puppet/parser/functions/generate.rb
@@ -1,37 +1,37 @@
 # Runs an external command and returns the results
 Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue,
     :doc => "Calls an external command on the Puppet master and returns
     the results of the command.  Any arguments are passed to the external command as
     arguments.  If the generator does not exit with return code of 0,
     the generator is considered to have failed and a parse error is
     thrown.  Generators can only have file separators, alphanumerics, dashes,
     and periods in them.  This function will attempt to protect you from
     malicious generator calls (e.g., those with '..' in them), but it can
     never be entirely safe.  No subshell is used to execute
     generators, so all shell metacharacters are passed directly to
     the generator.") do |args|
 
       raise Puppet::ParseError, "Generators must be fully qualified" unless Puppet::Util.absolute_path?(args[0])
 
       if Puppet.features.microsoft_windows?
         valid = args[0] =~ /^[a-z]:(?:[\/\\][-.~\w]+)+$/i
       else
         valid = args[0] =~ /^[-\/\w.+]+$/
       end
 
       unless valid
         raise Puppet::ParseError,
           "Generators can only contain alphanumerics, file separators, and dashes"
       end
 
       if args[0] =~ /\.\./
         raise Puppet::ParseError,
           "Can not use generators with '..' in them."
       end
 
       begin
-        Dir.chdir(File.dirname(args[0])) { Puppet::Util::Execution.execute(args) }
+        Dir.chdir(File.dirname(args[0])) { Puppet::Util::Execution.execute(args).to_str }
       rescue Puppet::ExecutionFailure => detail
         raise Puppet::ParseError, "Failed to execute generator #{args[0]}: #{detail}", detail.backtrace
       end
 end
diff --git a/spec/unit/parser/functions/generate_spec.rb b/spec/unit/parser/functions/generate_spec.rb
index 832ac13ae..f955d7128 100755
--- a/spec/unit/parser/functions/generate_spec.rb
+++ b/spec/unit/parser/functions/generate_spec.rb
@@ -1,132 +1,136 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "the generate function" do
   include PuppetSpec::Files
 
   before :all do
     Puppet::Parser::Functions.autoloader.loadall
   end
 
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
   let :scope    do Puppet::Parser::Scope.new(compiler) end
 
   it "should exist" do
     Puppet::Parser::Functions.function("generate").should == "function_generate"
   end
 
   it "accept a fully-qualified path as a command" do
     command = File.expand_path('/command/foo')
     Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
     scope.function_generate([command]).should == "yay"
   end
 
   it "should not accept a relative path as a command" do
     lambda { scope.function_generate(["command"]) }.should raise_error(Puppet::ParseError)
   end
 
   it "should not accept a command containing illegal characters" do
     lambda { scope.function_generate([File.expand_path('/##/command')]) }.should raise_error(Puppet::ParseError)
   end
 
   it "should not accept a command containing spaces" do
     lambda { scope.function_generate([File.expand_path('/com mand')]) }.should raise_error(Puppet::ParseError)
   end
 
   it "should not accept a command containing '..'" do
     command = File.expand_path("/command/../")
     lambda { scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
   end
 
   it "should execute the generate script with the correct working directory" do
     command = File.expand_path("/command")
     Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
     scope.function_generate([command]).should == 'yay'
   end
 
   describe "on Windows", :if => Puppet.features.microsoft_windows? do
     it "should accept the tilde in the path" do
       command = "C:/DOCUME~1/ADMINI~1/foo.bat"
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
       scope.function_generate([command]).should == 'yay'
     end
 
     it "should accept lower-case drive letters" do
       command = 'd:/command/foo'
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
       scope.function_generate([command]).should == 'yay'
     end
 
     it "should accept upper-case drive letters" do
       command = 'D:/command/foo'
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
       scope.function_generate([command]).should == 'yay'
     end
 
     it "should accept forward and backslashes in the path" do
       command = 'D:\command/foo\bar'
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
       scope.function_generate([command]).should == 'yay'
     end
 
     it "should reject colons when not part of the drive letter" do
       lambda { scope.function_generate(['C:/com:mand']) }.should raise_error(Puppet::ParseError)
     end
 
     it "should reject root drives" do
       lambda { scope.function_generate(['C:/']) }.should raise_error(Puppet::ParseError)
     end
   end
 
   describe "on non-Windows", :as_platform => :posix do
     it "should reject backslashes" do
       lambda { scope.function_generate(['/com\\mand']) }.should raise_error(Puppet::ParseError)
     end
 
     it "should accept plus and dash" do
       command = "/var/folders/9z/9zXImgchH8CZJh6SgiqS2U+++TM/-Tmp-/foo"
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
       scope.function_generate([command]).should == 'yay'
     end
   end
 
   let :command do
     cmd = tmpfile('function_generate')
 
     if Puppet.features.microsoft_windows?
       cmd += '.bat'
       text = '@echo off' + "\n" + 'echo a-%1 b-%2'
     else
       text = '#!/bin/sh' + "\n" + 'echo a-$1 b-$2'
     end
 
     File.open(cmd, 'w') {|fh| fh.puts text }
     File.chmod 0700, cmd
     cmd
   end
 
   after :each do
     File.delete(command) if Puppet::FileSystem.exist?(command)
   end
 
+  it "returns the output as a String" do
+    scope.function_generate([command]).class.should == String
+  end
+
   it "should call generator with no arguments" do
     scope.function_generate([command]).should == "a- b-\n"
   end
 
   it "should call generator with one argument" do
     scope.function_generate([command, 'one']).should == "a-one b-\n"
   end
 
   it "should call generator with wo arguments" do
     scope.function_generate([command, 'one', 'two']).should == "a-one b-two\n"
   end
 
   it "should fail if generator is not absolute" do
     expect { scope.function_generate(['boo']) }.to raise_error(Puppet::ParseError)
   end
 
   it "should fail if generator fails" do
     expect { scope.function_generate(['/boo']) }.to raise_error(Puppet::ParseError)
   end
 end