[New] forEachDescriptor: provide variationProvider info to callback

Author: ljharb

src/traversal/forEachDescriptor.js

@@ -1,10 +1,16 @@
 import entries from 'object.entries';
+import path from 'path';
+import has from 'has';
 
 import validateProject from '../helpers/validateProject';
 import getComponents from '../helpers/getComponents';
 import getVariationProviders from '../helpers/getVariationProviders';
 import getDescriptorFromProvider from '../helpers/getDescriptorFromProvider';
 
+function stripExtension(actualPath) {
+  return path.join(path.dirname(actualPath), path.basename(actualPath, path.extname(actualPath)));
+}
+
 export default function forEachDescriptor(
   projectConfig,
   {
@@ -20,7 +26,7 @@ export default function forEachDescriptor(
   }
 
   const Components = getComponents(projectConfig, projectRoot);
-  const variations = getVariationProviders(projectConfig, projectRoot);
+  const variations = getVariationProviders(projectConfig, projectRoot, { fileMapOnly: true });
 
   if (Object.keys(Components).length === 0) {
     throw new RangeError('Zero components found');
@@ -29,22 +35,37 @@ export default function forEachDescriptor(
     throw new RangeError('Zero variations found');
   }
 
+  const {
+    variationsRoot,
+  } = projectConfig;
+  const actualRoot = variationsRoot ? path.join(projectRoot, variationsRoot) : projectRoot;
+
   return function traverseVariationDescriptors(callback) {
     if (typeof callback !== 'function' || callback.length < 1 || callback.length > 2) {
       throw new TypeError('a callback that accepts exactly 1 or 2 arguments is required');
     }
-    entries(variations).forEach(([path, provider]) => {
+    entries(variations).forEach(([filePath, { actualPath, Module }]) => {
+      const provider = has(Module, 'default') ? Module.default : Module;
       if (typeof provider !== 'function') {
-        throw new TypeError(`“${path}” does not export default a function; got ${typeof provider}`);
+        throw new TypeError(`“${filePath}” does not export default a function; got ${typeof provider}`);
       }
+      const hierarchy = path.relative(actualRoot, stripExtension(actualPath));
       const descriptor = getDescriptor(provider, {
         Components,
         variations,
         getExtras,
         projectConfig,
       });
       callback(descriptor, {
-        variationPath: path,
+        variationProvider: {
+          path: filePath,
+          resolvedPath: actualPath,
+          hierarchy,
+        },
+        get variationPath() {
+          console.warn('this property is deprecated in favor of the `variationProvider` object’s `path` property');
+          return filePath;
+        },
       });
     });
   };

test/traversal/forEachDescriptor.js

@@ -1,3 +1,4 @@
+import interopRequireDefault from 'babel-runtime/helpers/interopRequireDefault';
 import forEachDescriptor from '../../src/traversal/forEachDescriptor';
 
 let mockComponents, mockVariations;
@@ -7,19 +8,16 @@ jest.mock('../../src/helpers/getVariationProviders', () => jest.fn(() => mockVar
 
 describe('forEachDescriptor', () => {
   beforeEach(() => {
-    mockComponents = {
-      'path/to/component': { actualPath: 'path/to/component.js', Module: {} },
-    };
-    mockVariations = {
-      'path/to/VariationProvider': jest.fn(),
-    };
     require('../../src/helpers/getComponents').mockClear();
     require('../../src/helpers/getVariationProviders').mockClear();
     mockComponents = {
       'path/to/component': { actualPath: 'path/to/component.js', Module: {} },
     };
     mockVariations = {
-      'path/to/VariationProvider': jest.fn(),
+      'path/to/VariationProvider': {
+        Module: interopRequireDefault(jest.fn()),
+        actualPath: '/full/path/to/VariationProvider.jsx',
+      },
     };
   });
 
@@ -56,7 +54,13 @@ describe('forEachDescriptor', () => {
     expect(getComponents).toHaveBeenCalledWith(mockProjectConfig, expect.any(String));
 
     expect(getVariationProviders).toHaveBeenCalledTimes(1);
-    expect(getVariationProviders).toHaveBeenCalledWith(mockProjectConfig, expect.any(String));
+    expect(getVariationProviders).toHaveBeenCalledWith(
+      mockProjectConfig,
+      expect.any(String),
+      expect.objectContaining({
+        fileMapOnly: true,
+      }),
+    );
   });
 
   describe('traversal function', () => {
@@ -106,11 +110,17 @@ describe('forEachDescriptor', () => {
     it('iterates variations', () => {
       const a = jest.fn();
       const b = jest.fn();
-      const variationPathA = 'path/to/a';
-      const variationPathB = 'path/to/b';
+      const variationPathA = `${projectRoot}/path/to/a`;
+      const variationPathB = `${projectRoot}/path/to/b`;
       mockVariations = {
-        [variationPathA]: a,
-        [variationPathB]: b,
+        [variationPathA]: {
+          Module: interopRequireDefault(a),
+          actualPath: `${variationPathA}.extA`,
+        },
+        [variationPathB]: {
+          Module: interopRequireDefault(b),
+          actualPath: `${variationPathB}.extB`,
+        },
       };
       const traverse = forEachDescriptor(mockProjectConfig, {
         getExtras,
@@ -147,12 +157,30 @@ describe('forEachDescriptor', () => {
 
       expect(callback).toHaveBeenCalledTimes(2);
       const [first, second] = callback.mock.calls;
-      expect(first).toEqual([descriptor, { variationPath: variationPathA }]);
-      expect(second).toEqual([descriptor, { variationPath: variationPathB }]);
+      expect(first).toEqual([descriptor, {
+        variationProvider: {
+          hierarchy: 'path/to/a',
+          path: variationPathA,
+          resolvedPath: mockVariations[variationPathA].actualPath
+        },
+        variationPath: variationPathA,
+      }]);
+      expect(second).toEqual([descriptor, {
+        variationProvider: {
+          hierarchy: 'path/to/b',
+          path: variationPathB,
+          resolvedPath: mockVariations[variationPathB].actualPath
+        },
+        variationPath: variationPathB,
+      }]);
     });
 
     it('throws when the provider is not a function', () => {
-      mockVariations = { 'path/to/a': true };
+      mockVariations = {
+        'path/to/a': {
+          Module: interopRequireDefault(true),
+        },
+      };
       const traverse = forEachDescriptor(mockProjectConfig, {
         getExtras,
         getDescriptor,
@@ -165,7 +193,12 @@ describe('forEachDescriptor', () => {
 
     it('provides a default `getExtras`', () => {
       const a = jest.fn();
-      mockVariations = { 'path/to/a': a };
+      mockVariations = {
+        'path/to/a': {
+          Module: interopRequireDefault(a),
+          actualPath: 'path/to/a.extension',
+        },
+      };
       const traverse = forEachDescriptor(mockProjectConfig, {
         getDescriptor,
         projectRoot,

test/traversal/forEachProjectVariation.js

@@ -1,8 +1,13 @@
+import interopRequireDefault from 'babel-runtime/helpers/interopRequireDefault';
+global.interopRequireDefault = interopRequireDefault;
+
 import forEachProjectVariation from '../../src/traversal/forEachProjectVariation';
 
 const mockProjectConfig = {
-  components: 'glob/path/to/components',
-  variations: 'glob/path/to/variations',
+  componentsRoot: 'glob/',
+  components: './path/to/components/**',
+  variationsRoot: 'glob/',
+  variations: './path/to/variations/**',
 };
 
 const mockProjectName = 'some awesome project';
@@ -16,7 +21,10 @@ jest.mock('../../src/helpers/getComponents', () => jest.fn(() => ({
   'path/to/component': { actualPath: 'path/to/component.js', Module: {} },
 })));
 jest.mock('../../src/helpers/getVariationProviders', () => jest.fn(() => ({
-  'path/to/VariationProvider': jest.fn(() => mockDescriptor),
+  'path/to/VariationProvider': {
+    actualPath: 'path/to/RealVariationProvider.js',
+    Module: global.interopRequireDefault(jest.fn(() => mockDescriptor)),
+  },
 })));
 
 const mockProjectNames = [mockProjectName, mockProjectName2];