Add cwd flag (#4174)

* Add cwd flag

* Handle --cwd flag in .yarnrc

* add test fixtures

* Update rc.js

* Update en.js

Author: Sebastian McKenzie

__tests__/fixtures/rc/empty/.yarnrc

@@ -0,0 +1 @@
+--foo true

__tests__/fixtures/rc/inside/.yarnrc

@@ -0,0 +1 @@
+--cwd foo

__tests__/fixtures/rc/inside/foo/.yarnrc

@@ -0,0 +1 @@
+--foo true

__tests__/fixtures/rc/prefixed/.yarnrc

@@ -0,0 +1,2 @@
+--add.foo true
+--install.bar true

__tests__/fixtures/rc/recursive/.yarnrc

@@ -0,0 +1 @@
+--cwd pointer

__tests__/fixtures/rc/recursive/pointer/.yarnrc

@@ -0,0 +1,2 @@
+--bar true
+--cwd ".."

__tests__/rc.js

@@ -0,0 +1,40 @@
+/* @flow */
+
+import {getRcArgs} from '../src/rc.js';
+import * as path from 'path';
+
+const fixturesLoc = path.join(__dirname, 'fixtures', 'rc');
+
+test('resolve .yarnrc args and use --cwd if present', () => {
+  const args = getRcArgs('install', ['--cwd', path.join(fixturesLoc, 'empty')]);
+  expect(args.indexOf('--foo') !== -1).toBe(true);
+});
+
+test('resolve .yarnrc args and use process.cwd() if no --cwd present', () => {
+  const cwd = process.cwd();
+  process.chdir(path.join(fixturesLoc, 'empty'));
+
+  try {
+    const args = getRcArgs('install', []);
+    expect(args.indexOf('--foo') !== -1).toBe(true);
+  } finally {
+    process.chdir(cwd);
+  }
+});
+
+test('resolve .yarnrc args and handle --cwd arg inside .yarnrc', () => {
+  const args = getRcArgs('install', ['--cwd', path.join(fixturesLoc, 'inside')]);
+  expect(args.indexOf('--foo') !== -1).toBe(true);
+});
+
+test('resolve .yarnrc args and bail out of recursive --cwd args inside of .yarnrc', () => {
+  expect(() => {
+    getRcArgs('install', ['--cwd', path.join(fixturesLoc, 'recursive')]);
+  }).toThrowError();
+});
+
+test('resolve .yarnrc args and adds command name prefixed arguments', () => {
+  const args = getRcArgs('add', ['--cwd', path.join(fixturesLoc, 'prefixed')]);
+  expect(args.indexOf('--foo') !== -1).toBe(true);
+  expect(args.indexOf('--bar') !== -1).toBe(false);
+});

src/cli/index.js

@@ -64,6 +64,7 @@ export function main({
   commander.option('--mutex <type>[:specifier]', 'use a mutex to ensure only one yarn instance is executing');
   commander.option('--emoji [bool]', 'enable emoji in output', process.platform === 'darwin');
   commander.option('-s, --silent', 'skip Yarn console logs, other types of logs (script output) will be printed');
+  commander.option('--cwd <cwd>', 'working directory to use', process.cwd());
   commander.option('--proxy <host>', '');
   commander.option('--https-proxy <host>', '');
   commander.option('--no-progress', 'disable progress bar');
@@ -114,7 +115,7 @@ export function main({
     // we use this for https://github.com/tj/commander.js/issues/346, otherwise
     // it will strip some args that match with any options
     'this-arg-will-get-stripped-later',
-    ...getRcArgs(commandName),
+    ...getRcArgs(commandName, args),
     ...args,
   ]);
   commander.args = commander.args.concat(endArgs);
@@ -339,6 +340,7 @@ export function main({
       networkTimeout: commander.networkTimeout,
       nonInteractive: commander.nonInteractive,
       scriptsPrependNodePath: commander.scriptsPrependNodePath,
+      cwd: commander.cwd,
 
       commandName: commandName === 'run' ? commander.args[0] : commandName,
     })

src/rc.js

@@ -5,17 +5,15 @@ import parse from './lockfile/parse.js';
 import * as rcUtil from './util/rc.js';
 
 // Keys that will get resolved relative to the path of the rc file they belong to
-const PATH_KEYS = ['cache-folder', 'global-folder', 'modules-folder'];
+const PATH_KEYS = ['cache-folder', 'global-folder', 'modules-folder', 'cwd'];
 
-let rcConfCache;
-let rcArgsCache;
-
-const buildRcConf = () =>
-  rcUtil.findRc('yarn', (fileText, filePath) => {
+// given a cwd, load all .yarnrc files relative to it
+function getRcConfigForCwd(cwd: string): {[key: string]: string} {
+  return rcUtil.findRc('yarn', cwd, (fileText, filePath) => {
     const {object: values} = parse(fileText, 'yarnrc');
-    const keys = Object.keys(values);
 
-    for (const key of keys) {
+    // some keys reference directories so keep their relativity
+    for (const key in values) {
       for (const pathKey of PATH_KEYS) {
         if (key.replace(/^(--)?([^.]+\.)*/, '') === pathKey) {
           values[key] = resolve(dirname(filePath), values[key]);
@@ -25,57 +23,78 @@ const buildRcConf = () =>
 
     return values;
   });
-
-export function getRcConf(): {[string]: Array<string>} {
-  if (!rcConfCache) {
-    rcConfCache = buildRcConf();
-  }
-
-  return rcConfCache;
 }
 
-const buildRcArgs = () =>
-  Object.keys(getRcConf()).reduce((argLists, key) => {
-    const miniparse = key.match(/^--(?:([^.]+)\.)?(.*)$/);
+// get the built of arguments of a .yarnrc chain of the passed cwd
+function buildRcArgs(cwd: string): Map<string, Array<string>> {
+  const config = getRcConfigForCwd(cwd);
 
-    if (!miniparse) {
-      return argLists;
+  const argsForCommands: Map<string, Array<string>> = new Map();
+
+  for (const key in config) {
+    // args can be prefixed with the command name they're meant for, eg.
+    // `--install.check-files true`
+    const keyMatch = key.match(/^--(?:([^.]+)\.)?(.*)$/);
+    if (!keyMatch) {
+      continue;
     }
 
-    const namespace = miniparse[1] || '*';
-    const arg = miniparse[2];
-    const value = getRcConf()[key];
+    const commandName = keyMatch[1] || '*';
+    const arg = keyMatch[2];
+    const value = config[key];
 
-    if (!argLists[namespace]) {
-      argLists[namespace] = [];
-    }
+    // create args for this command name if we didn't previously have them
+    const args = argsForCommands.get(commandName) || [];
+    argsForCommands.set(commandName, args);
 
+    // turn config value into appropriate cli flag
     if (typeof value === 'string') {
-      argLists[namespace] = argLists[namespace].concat([`--${arg}`, value]);
+      args.push(`--${arg}`, value);
     } else if (value === true) {
-      argLists[namespace] = argLists[namespace].concat([`--${arg}`]);
+      args.push(`--${arg}`);
     } else if (value === false) {
-      argLists[namespace] = argLists[namespace].concat([`--no-${arg}`]);
+      args.push(`--no-${arg}`);
     }
+  }
 
-    return argLists;
-  }, {});
+  return argsForCommands;
+}
 
-export function getRcArgs(command: string): Array<string> {
-  if (!rcArgsCache) {
-    rcArgsCache = buildRcArgs();
+// extract the value of a --cwd arg if present
+function extractCwdArg(args: Array<string>): ?string {
+  for (let i = 0, I = args.length; i < I; ++i) {
+    const arg = args[i];
+    if (arg === '--') {
+      return null;
+    } else if (arg === '--cwd') {
+      return args[i + 1];
+    }
   }
+  return null;
+}
 
-  let result = rcArgsCache['*'] || [];
+// get a list of arguments from .yarnrc that apply to this commandName
+export function getRcArgs(commandName: string, args: Array<string>, previousCwds?: Array<string> = []): Array<string> {
+  // for the cwd, use the --cwd arg if it was passed or else use process.cwd()
+  const origCwd = extractCwdArg(args) || process.cwd();
 
-  if (command !== '*' && Object.prototype.hasOwnProperty.call(rcArgsCache, command)) {
-    result = result.concat(rcArgsCache[command] || []);
-  }
+  // get a map of command names and their arguments
+  const argMap = buildRcArgs(origCwd);
 
-  return result;
-}
+  // concat wildcard arguments and arguments meant for this specific command
+  const newArgs = [].concat(argMap.get('*') || [], argMap.get(commandName) || []);
+
+  // check if the .yarnrc args specified a cwd
+  const newCwd = extractCwdArg(newArgs);
+  if (newCwd && newCwd !== origCwd) {
+    // ensure that we don't enter into a loop
+    if (previousCwds.indexOf(newCwd) !== -1) {
+      throw new Error(`Recursive .yarnrc files specifying --cwd flags. Bailing out.`);
+    }
+
+    //  if we have a new cwd then let's refetch the .yarnrc args relative to it
+    return getRcArgs(commandName, newArgs, previousCwds.concat(origCwd));
+  }
 
-export function clearRcCache() {
-  rcConfCache = null;
-  rcArgsCache = null;
+  return newArgs;
 }

src/util/rc.js

@@ -1,46 +1,17 @@
 /* @flow */
 
 import {readFileSync} from 'fs';
-import {basename, dirname, join} from 'path';
+import * as path from 'path';
 
 const etc = '/etc';
 const isWin = process.platform === 'win32';
 const home = isWin ? process.env.USERPROFILE : process.env.HOME;
 
-export function findRc(name: string, parser: Function): Object {
-  let configPaths = [];
+function getRcPaths(name: string, cwd: string): Array<string> {
+  const configPaths = [];
 
   function addConfigPath(...segments) {
-    configPaths.push(join(...segments));
-  }
-
-  function addRecursiveConfigPath(...segments) {
-    const queue = [];
-
-    let oldPath;
-    let path = join(...segments);
-
-    do {
-      queue.unshift(path);
-
-      oldPath = path;
-      path = join(dirname(dirname(path)), basename(path));
-    } while (path !== oldPath);
-
-    configPaths = configPaths.concat(queue);
-  }
-
-  function fetchConfigs(): Object {
-    return Object.assign(
-      {},
-      ...configPaths.map(path => {
-        try {
-          return parser(readFileSync(path).toString(), path);
-        } catch (error) {
-          return {};
-        }
-      }),
-    );
+    configPaths.push(path.join(...segments));
   }
 
   if (!isWin) {
@@ -55,13 +26,42 @@ export function findRc(name: string, parser: Function): Object {
     addConfigPath(home, `.${name}rc`);
   }
 
-  addRecursiveConfigPath(process.cwd(), `.${name}rc`);
+  // add .yarnrc locations relative to the cwd
+  while (true) {
+    configPaths.unshift(path.join(cwd, `.${name}rc`));
+
+    const upperCwd = path.dirname(cwd);
+    if (upperCwd === cwd) {
+      // we've reached the root
+      break;
+    } else {
+      // continue since there's still more directories to search
+      cwd = upperCwd;
+    }
+  }
 
   const envVariable = `${name}_config`.toUpperCase();
 
   if (process.env[envVariable]) {
     addConfigPath(process.env[envVariable]);
   }
 
-  return fetchConfigs();
+  return configPaths;
+}
+
+function parseRcPaths(paths: Array<string>, parser: Function): Object {
+  return Object.assign(
+    {},
+    ...paths.map(path => {
+      try {
+        return parser(readFileSync(path).toString(), path);
+      } catch (error) {
+        return {};
+      }
+    }),
+  );
+}
+
+export function findRc(name: string, cwd: string, parser: Function): Object {
+  return parseRcPaths(getRcPaths(name, cwd), parser);
 }