remove spaces after assignments to line them up and consolidate registry logic

Author: Sebastian McKenzie

src/PackageCompatibility.js

@@ -57,7 +57,7 @@ export default class PackageCompatibility {
   constructor(config: Config, resolver: PackageResolver) {
     this.reporter = config.reporter;
     this.resolver = resolver;
-    this.config   = config;
+    this.config = config;
   }
 
   resolver: PackageResolver;
@@ -74,12 +74,12 @@ export default class PackageCompatibility {
 
   check(info: Manifest) {
     let didIgnore = false;
-    let didError  = false;
-    const reporter  = this.reporter;
-    const human     = `${info.name}@${info.version}`;
+    let didError = false;
+    const reporter = this.reporter;
+    const human = `${info.name}@${info.version}`;
 
     const pushError = (msg) => {
-      const ref = info.reference;
+      const ref = info._reference;
       invariant(ref, 'expected package reference');
 
       if (ref.optional) {
@@ -134,7 +134,7 @@ export default class PackageCompatibility {
   }
 
   async init(): Promise<void> {
-    const infos  = this.resolver.getManifests();
+    const infos = this.resolver.getManifests();
     for (const info of infos) {
       this.check(info);
     }

src/PackageConstraintResolver.js

@@ -21,7 +21,7 @@ const semver = require('semver');
 export default class PackageConstraintResolver {
   constructor(config: Config, reporter: Reporter) {
     this.reporter = reporter;
-    this.config   = config;
+    this.config = config;
   }
 
   reporter: Reporter;

src/PackageFetcher.js

@@ -24,15 +24,15 @@ export default class PackageFetcher {
   constructor(config: Config, resolver: PackageResolver) {
     this.reporter = config.reporter;
     this.resolver = resolver;
-    this.config   = config;
+    this.config = config;
   }
 
   resolver: PackageResolver;
   reporter: Reporter;
   config: Config;
 
-  async fetch(reference: PackageReference, overwriteDestination: boolean): Promise<FetchedManifest> {
-    const dest = this.config.generateHardModulePath(reference);
+  async fetch(ref: PackageReference, overwriteDestination: boolean): Promise<FetchedManifest> {
+    const dest = this.config.generateHardModulePath(ref);
 
     if (!overwriteDestination && await this.config.isValidModuleDest(dest)) {
       let {hash, package: pkg} = await this.config.readPackageMetadata(dest);
@@ -46,7 +46,7 @@ export default class PackageFetcher {
     // remove as the module may be invalid
     await fs.unlink(dest);
 
-    const remote = reference.remote;
+    const remote = ref.remote;
     invariant(remote, 'Missing remote');
 
     const Fetcher = fetchers[remote.type];
@@ -57,7 +57,7 @@ export default class PackageFetcher {
     await fs.mkdirp(dest);
 
     try {
-      const fetcher = new Fetcher(remote, this.config, reference.saveForOffline);
+      const fetcher = new Fetcher(remote, this.config, ref.saveForOffline);
       return await fetcher.fetch(dest);
     } catch (err) {
       try {
@@ -69,10 +69,10 @@ export default class PackageFetcher {
     }
   }
 
-  async maybeFetch(reference: PackageReference): Promise<?FetchedManifest> {
-    let promise = this.fetch(reference, false);
+  async maybeFetch(ref: PackageReference): Promise<?FetchedManifest> {
+    let promise = this.fetch(ref, false);
 
-    if (reference.optional) {
+    if (ref.optional) {
       // swallow the error
       promise = promise.catch((err) => {
         this.reporter.error(err.message);
@@ -88,7 +88,7 @@ export default class PackageFetcher {
 
     await promise.queue(pkgs, async (ref) => {
       const res = await this.maybeFetch(ref);
-      
+
       if (res) {
         ref.remote.hash = res.hash;
 

src/PackageHoister.js

@@ -127,7 +127,7 @@ export default class PackageHoister {
 
     //
     const pkg = this.resolver.getStrictResolvedPattern(pattern);
-    const ref = pkg.reference;
+    const ref = pkg._reference;
     invariant(ref, 'expected reference');
     const loc = this.config.generateHardModulePath(ref);
 
@@ -189,7 +189,7 @@ export default class PackageHoister {
     //
     for (let i = parts.length - 1; i >= 0; i--) {
       const checkParts = parts.slice(0, i).concat(name);
-      const checkKey   = this.implodeKey(checkParts);
+      const checkKey = this.implodeKey(checkParts);
       info.addHistory(`Looked at ${checkKey} for a match`);
 
       const existing = this.tree.get(checkKey);
@@ -444,7 +444,7 @@ a   */
 
     // remove ignored modules from the tree
     for (let [key, info] of this.tree.entries()) {
-      const ref = info.pkg.reference;
+      const ref = info.pkg._reference;
       invariant(ref, 'expected reference');
       if (ref.ignore) {
         info.addHistory('Deleted as this module was ignored');

src/PackageInstallScripts.js

@@ -21,10 +21,10 @@ const _ = require('lodash');
 
 export default class PackageInstallScripts {
   constructor(config: Config, resolver: PackageResolver, force: boolean) {
-    this.resolver  = resolver;
-    this.reporter  = config.reporter;
-    this.config    = config;
-    this.force     = force;
+    this.resolver = resolver;
+    this.reporter = config.reporter;
+    this.config = config;
+    this.force = force;
   }
 
   needsPermission: boolean;
@@ -47,14 +47,14 @@ export default class PackageInstallScripts {
     command: string,
     stdout: string,
   }>> {
-    const loc = this.config.generateHardModulePath(pkg.reference);
+    const loc = this.config.generateHardModulePath(pkg._reference);
     try {
       this.reporter.info(`Running install scripts for ${pkg.name}`);
       return await executeLifecycleScript(this.config, loc, cmds, this.reporter);
     } catch (err) {
       err.message = `${loc}: ${err.message}`;
 
-      const ref = pkg.reference;
+      const ref = pkg._reference;
       invariant(ref, 'expected reference');
 
       if (ref.optional) {
@@ -78,7 +78,7 @@ export default class PackageInstallScripts {
         continue;
       }
 
-      const ref = pkg.reference;
+      const ref = pkg._reference;
       invariant(ref, 'Missing package reference');
       if (!ref.fresh && !this.force) {
         continue;

src/PackageLinker.js

@@ -21,7 +21,7 @@ import {entries} from './util/misc.js';
 import * as fs from './util/fs.js';
 
 const invariant = require('invariant');
-const cmdShim   = promise.promisify(require('cmd-shim'));
+const cmdShim = promise.promisify(require('cmd-shim'));
 const semver = require('semver');
 const path = require('path');
 const _ = require('lodash');
@@ -35,7 +35,7 @@ export default class PackageLinker {
   constructor(config: Config, resolver: PackageResolver) {
     this.resolver = resolver;
     this.reporter = config.reporter;
-    this.config   = config;
+    this.config = config;
   }
 
   reporter: Reporter;
@@ -47,7 +47,7 @@ export default class PackageLinker {
     pkgLoc = await fs.realpath(pkgLoc);
     for (let [scriptName, scriptCmd] of entries(pkg.bin)) {
       const dest = path.join(targetBinLoc, scriptName);
-      const src  = path.join(pkgLoc, scriptCmd);
+      const src = path.join(pkgLoc, scriptCmd);
 
       if (process.platform === 'win32') {
         await cmdShim(src, dest);
@@ -59,24 +59,28 @@ export default class PackageLinker {
   }
 
   async linkBinDependencies(deps: DependencyPairs, pkg: Manifest, dir: string): Promise<void> {
-    const ref = pkg.reference;
+    const ref = pkg._reference;
     invariant(ref, 'Package reference is missing');
 
-    const remote = pkg.remote;
+    const remote = pkg._remote;
     invariant(remote, 'Package remote is missing');
 
     // link up `bin scripts` in `dependencies`
     for (const pattern of ref.dependencies) {
       const dep = this.resolver.getStrictResolvedPattern(pattern);
       if (!_.isEmpty(dep.bin)) {
-        deps.push({dep, loc: this.config.generateHardModulePath(dep.reference)});
+        deps.push({dep, loc: this.config.generateHardModulePath(dep._reference)});
       }
     }
 
     // link up the `bin` scripts in bundled dependencies
     if (pkg.bundleDependencies) {
       for (const depName of pkg.bundleDependencies) {
-        const loc = path.join(this.config.generateHardModulePath(ref), 'node_modules', depName);
+        const loc = path.join(
+          this.config.generateHardModulePath(ref),
+          this.config.getFolder(pkg),
+          depName,
+        );
 
         const dep = await this.config.readManifest(loc, remote.registry);
 
@@ -118,7 +122,7 @@ export default class PackageLinker {
     //
     const queue = [];
     for (let [dest, {pkg, loc: src}] of flatTree) {
-      const ref = pkg.reference;
+      const ref = pkg._reference;
       invariant(ref, 'expected package reference');
 
       ref.setLocation(dest);
@@ -164,14 +168,14 @@ export default class PackageLinker {
     //
     const tickBin = this.reporter.progress(flatTree.length);
     await promise.queue(flatTree, async ([dest, {pkg}]) => {
-      const binLoc = path.join(dest, 'node_modules');
+      const binLoc = path.join(dest, this.config.getFolder(pkg));
       await this.linkBinDependencies([], pkg, binLoc);
       tickBin(dest);
     }, 4);
   }
 
   async resolvePeerModules(pkg: Manifest): Promise<DependencyPairs> {
-    const ref = pkg.reference;
+    const ref = pkg._reference;
     invariant(ref, 'Package reference is missing');
 
     const deps = [];
@@ -194,7 +198,7 @@ export default class PackageLinker {
           }
 
           //
-          const ref = dep.reference;
+          const ref = dep._reference;
           invariant(ref, 'expected reference');
           searchPatterns = searchPatterns.concat(ref.dependencies);
         } while (request = request.parentRequest);
@@ -219,7 +223,7 @@ export default class PackageLinker {
           deps.push({
             pattern: foundDep.pattern,
             dep: foundDep.package,
-            loc: this.config.generateHardModulePath(foundDep.package.reference),
+            loc: this.config.generateHardModulePath(foundDep.package._reference),
           });
         } else {
           this.reporter.warn('TODO not match');
@@ -241,7 +245,7 @@ export default class PackageLinker {
     const resolved = this.resolver.getResolvedPattern(pattern);
     invariant(resolved, `Couldn't find resolved name/version for ${pattern}`);
 
-    const ref = resolved.reference;
+    const ref = resolved._reference;
     invariant(ref, 'Missing reference');
 
     //

src/PackageReference.js

@@ -30,23 +30,23 @@ export default class PackageReference {
     this.resolver = request.resolver;
     this.lockfile = request.lockfile;
     this.requests = [request];
-    this.config   = request.config;
+    this.config = request.config;
 
     this.registry = remote.registry;
-    this.version  = info.version;
-    this.name     = info.name;
-    this.uid      = info.uid;
+    this.version = info.version;
+    this.name = info.name;
+    this.uid = info._uid;
 
     this.remote = remote;
 
     this.dependencies = [];
 
     this.permissions = {};
-    this.patterns    = [];
-    this.optional    = null;
-    this.ignore      = null;
-    this.fresh       = false;
-    this.location    = null;
+    this.patterns = [];
+    this.optional = null;
+    this.ignore = null;
+    this.fresh = false;
+    this.location = null;
     this.saveForOffline = !!saveForOffline;
   }
 
@@ -69,10 +69,6 @@ export default class PackageReference {
   location: ?string;
   resolver: PackageResolver;
 
-  async getFolder(): Promise<string> {
-    return this.config.registries[this.registry].folder;
-  }
-
   setFresh(fresh: boolean) {
     this.fresh = fresh;
   }
@@ -151,7 +147,7 @@ export default class PackageReference {
         continue;
       }
 
-      const ref = pkg.reference;
+      const ref = pkg._reference;
       invariant(ref, 'expected package reference');
       ref.addIgnore(ignore, ancestry);
     }