diff --git a/lib/puppet/parser/functions/generate.rb b/lib/puppet/parser/functions/generate.rb
index cf9166f89..f53d8e5c3 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, :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.]+$/
+        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) }
       rescue Puppet::ExecutionFailure => detail
         raise Puppet::ParseError, "Failed to execute generator #{args[0]}: #{detail}"
       end
 end
diff --git a/spec/unit/parser/functions/generate_spec.rb b/spec/unit/parser/functions/generate_spec.rb
index fe779c832..71e2ff4c0 100755
--- a/spec/unit/parser/functions/generate_spec.rb
+++ b/spec/unit/parser/functions/generate_spec.rb
@@ -1,114 +1,120 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe "the generate function" do
   include PuppetSpec::Files
 
   before :all do
     Puppet::Parser::Functions.autoloader.loadall
   end
 
   let(:scope) { Puppet::Parser::Scope.new }
 
   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", :as_platform => :windows do
     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
 
   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