fix: fix paths being incorrectly normalized on unix

This actually fixes another bug with `options.cwd` on Windows.
Closes#90.

Author: satazor

lib/parse.js

@@ -49,6 +49,10 @@ function parseNonShell(parsed) {
 // we need to double escape them
 constneedsDoubleEscapeMetaChars=isCmdShimRegExp.test(commandFile);
 
+// Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar)
+// This is necessary otherwise it will always fail with ENOENT in those cases
+parsed.command=path.normalize(parsed.command);
+
 // Escape command & arguments
 parsed.command=escape.command(parsed.command);
 parsed.args=parsed.args.map((arg)=>escape.argument(arg,needsDoubleEscapeMetaChars));
@@ -104,7 +108,7 @@ function parse(command, args, options) {
 
 // Build our parsed object
 constparsed={
-command: path.normalize(command),
+ command,
  args,
  options,
 file: undefined,

lib/util/resolveCommand.js

@@ -4,15 +4,40 @@ const path = require('path');
 constwhich=require('which');
 constpathKey=require('path-key')();
 
-functionresolveCommandAttempt(parsed,withPathExt){
-withPathExt=!!withPathExt;
+functionresolveCommandAttempt(parsed,withoutPathExt){
+constcwd=process.cwd();
+consthasCustomCwd=parsed.options.cwd!=null;
+
+// If a custom `cwd` was specified, we need to change the process cwd
+// because `which` will do stat calls but does not support a custom cwd
+if(hasCustomCwd){
+try{
+process.chdir(parsed.options.cwd);
+}catch(err){
+/* Empty */
+}
+}
+
+letresolved;
 
 try{
-returnwhich.sync(parsed.command,{
+resolved=which.sync(parsed.command,{
 path: (parsed.options.env||process.env)[pathKey],
-pathExt: withPathExt&&process.env.PATHEXT? path.delimiter+process.env.PATHEXT : undefined,
+pathExt: withoutPathExt? path.delimiter : undefined,
 });
-}catch(e){/* Empty */}
+}catch(e){
+/* Empty */
+}finally{
+process.chdir(cwd);
+}
+
+// If we successfully resolved, ensure that an absolute path is returned
+// Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
+if(resolved){
+resolved=path.resolve(hasCustomCwd ? parsed.options.cwd : '',resolved);
+}
+
+returnresolved;
 }
 
 functionresolveCommand(parsed){

test/index.test.js

@@ -32,7 +32,7 @@ run.methods.forEach((method) => {
 expect(stdout.trim()).toBe('foo');
 });
 
-it('should support shebang in executables with /usr/bin/env',async()=>{
+it('should support shebang in executables with `/usr/bin/env`',async()=>{
 const{stdout: stdout1}=awaitrun(method,`${__dirname}/fixtures/shebang`);
 
 expect(stdout1).toBe('shebang works!');
@@ -219,6 +219,26 @@ run.methods.forEach((method) => {
 expect(stdout3.trim()).toBe('foo');
 });
 
+it('should work with a relative posix path to a command with a custom `cwd`',async()=>{
+constrelativeTestPath=path.relative(process.cwd(),__dirname).replace(/\\/,'/');
+
+const{stdout: stdout1}=awaitrun(method,'fixtures/say-foo',{cwd: relativeTestPath});
+
+expect(stdout1.trim()).toBe('foo');
+
+const{stdout: stdout2}=awaitrun(method,'./fixtures/say-foo',{cwd: `./${relativeTestPath}`});
+
+expect(stdout2.trim()).toBe('foo');
+
+if(!isWin){
+return;
+}
+
+const{stdout: stdout3}=awaitrun(method,'./fixtures/say-foo.bat',{cwd: `./${relativeTestPath}`});
+
+expect(stdout3.trim()).toBe('foo');
+});
+
 {
 constassertError=(err)=>{
 constsyscall=run.isMethodSync(method) ? 'spawnSync' : 'spawn';
@@ -354,6 +374,45 @@ run.methods.forEach((method) => {
 });
 }
 
+if(run.isMethodSync(method)){
+it('should fail with ENOENT a non-existing `cwd` was specified',()=>{
+expect.assertions(1);
+
+try{
+run(method,'fixtures/say-foo',{cwd: 'somedirthatwillneverexist'});
+}catch(err){
+expect(err.code).toBe('ENOENT');
+}
+});
+}else{
+it('should emit `error` and `close` if a non-existing `cwd` was specified',async()=>{
+expect.assertions(3);
+
+awaitnewPromise((resolve,reject)=>{
+constpromise=run(method,'somecommandthatwillneverexist',['foo']);
+const{ cp }=promise;
+
+promise.catch(()=>{});
+
+lettimeout;
+
+cp
+.on('error',(err)=>expect(err.code).toBe('ENOENT'))
+.on('exit',()=>{
+cp.removeAllListeners();
+clearTimeout(timeout);
+reject(newError('Should not emit exit'));
+})
+.on('close',(code,signal)=>{
+expect(code).not.toBe(0);
+expect(signal).toBe(null);
+
+timeout=setTimeout(resolve,1000);
+});
+});
+});
+}
+
 if(isWin){
 it('should use nodejs\' spawn when options.shell is specified (windows)',async()=>{
 const{ stdout }=awaitrun(method,'echo',['%RANDOM%'],{shell: true});