Relax composition detection

Previously, a module was only considered to be composed if it was used
in a member expression containing "propTypes". E.g.

var Foo = require('Foo');
var A = React.createClass({
  propTypes: {
    ...Foo.propTypes
  }
});

but not

var Foo = require('Foo');
var A = React.createClass({
  propTypes: {
    ...Foo
  }
});

The latter is now allowed as well, because react-docgen doesn't actually
care about the characteristics of the module (see #9).

This also fixes a bug where `propTypes: Foo.propTypes` wasn't treated
correctly.

Author: fkling

src/handlers/__tests__/propTypeCompositionHandler-test.js

@@ -0,0 +1,93 @@
+/*
+ *  Copyright (c) 2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ *
+ */
+
+/*global jest, describe, it, expect, beforeEach, afterEach*/
+
+"use strict";
+
+jest.autoMockOff();
+jest.mock('../../Documentation');
+
+describe('propTypeCompositionHandler', () => {
+  var utils;
+  var getPropTypeMock;
+  var documentation;
+  var propTypeCompositionHandler;
+
+  beforeEach(() => {
+    utils = require('../../../tests/utils');
+    getPropTypeMock = jest.genMockFunction().mockImplementation(() => ({}));
+    jest.setMock('../../utils/getPropType', getPropTypeMock);
+    jest.mock('../../utils/getPropType');
+
+    documentation = new (require('../../Documentation'))();
+    propTypeCompositionHandler = require('../propTypeCompositionHandler');
+  });
+
+  function parse(definition) {
+    var programPath = utils.parseWithTemplate(definition, utils.REACT_TEMPLATE);
+    return programPath.get(
+      'body',
+      programPath.node.body.length - 1,
+      'expression'
+    );
+  }
+
+  it('understands assignment from module', () => {
+    var definition = parse([
+      'var Foo = require("Foo.react");',
+      '({',
+      '  propTypes: Foo.propTypes',
+      '})',
+    ].join('\n'));
+
+    propTypeCompositionHandler(documentation, definition);
+    expect(documentation.composes).toEqual(['Foo.react']);
+
+    documentation.composes.length = 0;
+    definition = parse([
+      'var SharedProps = require("SharedProps");',
+      '({',
+      '  propTypes: SharedProps',
+      '})',
+    ].join('\n'));
+
+    propTypeCompositionHandler(documentation, definition);
+    expect(documentation.composes).toEqual(['SharedProps']);
+  });
+
+  it('understands the spread operator', () => {
+    var definition = parse([
+      'var Foo = require("Foo.react");',
+      'var SharedProps = require("SharedProps");',
+      '({',
+      '  propTypes: {',
+      '    ...Foo.propTypes,',
+      '    ...SharedProps',
+      '  }',
+      '})',
+    ].join('\n'));
+
+    propTypeCompositionHandler(documentation, definition);
+    expect(documentation.composes).toEqual(['Foo.react', 'SharedProps']);
+  });
+
+  it('does not error if propTypes cannot be found', () => {
+    var definition = parse([
+      '({',
+      '  fooBar: 42',
+      '})',
+    ].join('\n'));
+
+    expect(function() {
+      propTypeCompositionHandler(documentation, definition);
+    }).not.toThrow();
+  });
+});

src/handlers/__tests__/propTypeHandler-test.js

@@ -8,6 +8,8 @@
  *
  */
 
+/*global jest, describe, it, expect, beforeEach, afterEach*/
+
 "use strict";
 
 jest.autoMockOff();
@@ -145,6 +147,18 @@ describe('propTypeHandler', () => {
     });
   });
 
+  it('understands assignment from module', () => {
+    var definition = parse([
+      'var Foo = require("Foo.react");',
+      '({',
+      '  propTypes: Foo.propTypes',
+      '})',
+    ].join('\n'));
+
+    propTypeHandler(documentation, definition);
+    expect(documentation.composes).toEqual(['Foo.react']);
+  });
+
   it('understands the spread operator', () => {
     var definition = parse([
       'var Foo = require("Foo.react");',

src/handlers/index.js

@@ -13,4 +13,5 @@
 exports.componentDocblockHandler = require('./componentDocblockHandler');
 exports.defaultPropsHandler = require('./defaultPropsHandler');
 exports.propTypeHandler = require('./propTypeHandler');
+exports.propTypeCompositionHandler = require('./propTypeCompositionHandler');
 exports.propDocBlockHandler = require('./propDocBlockHandler');

src/handlers/propTypeCompositionHandler.js

@@ -0,0 +1,69 @@
+/*
+ *  Copyright (c) 2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ *
+ */
+
+/**
+ * @flow
+ */
+"use strict";
+
+var Documentation = require('../Documentation');
+
+var getPropertyValuePath = require('../utils/getPropertyValuePath');
+var recast = require('recast');
+var resolveToModule = require('../utils/resolveToModule');
+var resolveToValue = require('../utils/resolveToValue');
+var types = recast.types.namedTypes;
+
+/**
+ * It resolves the path to its module name and adds it to the "composes" entry
+ * in the documentation.
+ */
+function amendComposes(documentation, path) {
+  var moduleName = resolveToModule(path);
+  if (moduleName) {
+    documentation.addComposes(moduleName);
+  }
+}
+
+function processObjectExpression(documentation, path) {
+  path.get('properties').each(function(propertyPath) {
+    switch (propertyPath.node.type) {
+      case types.SpreadProperty.name:
+        var resolvedValuePath = resolveToValue(propertyPath.get('argument'));
+        amendComposes(documentation, resolvedValuePath);
+        break;
+    }
+  });
+}
+
+function propTypeCompositionHandler(
+  documentation: Documentation,
+  path: NodePath
+) {
+  var propTypesPath = getPropertyValuePath(path, 'propTypes');
+  if (!propTypesPath) {
+    return;
+  }
+  propTypesPath = resolveToValue(propTypesPath);
+  if (!propTypesPath) {
+    return;
+  }
+
+  switch (propTypesPath.node.type) {
+    case types.ObjectExpression.name:
+      processObjectExpression(documentation, propTypesPath);
+      break;
+    default:
+      amendComposes(documentation, propTypesPath);
+      break;
+  }
+}
+
+module.exports = propTypeCompositionHandler;

src/handlers/propTypeHandler.js

@@ -22,6 +22,7 @@ var getPropertyName = require('../utils/getPropertyName');
 var getPropertyValuePath = require('../utils/getPropertyValuePath');
 var isReactModuleName = require('../utils/isReactModuleName');
 var printValue = require('../utils/printValue');
+var propTypeCompositionHandler = require('./propTypeCompositionHandler');
 var recast = require('recast');
 var resolveToModule = require('../utils/resolveToModule');
 var resolveToValue = require('../utils/resolveToValue');
@@ -67,7 +68,7 @@ function amendComposes(documentation, path) {
   }
 }
 
-function amendPropTypes(documentation, path) {
+function amendPropTypes(documentation, path, componentPath) {
   path.get('properties').each(function(propertyPath) {
     switch (propertyPath.node.type) {
       case types.Property.name:
@@ -91,8 +92,9 @@ function amendPropTypes(documentation, path) {
           case types.ObjectExpression.name: // normal object literal
             amendPropTypes(documentation, resolvedValuePath);
             break;
-          case types.MemberExpression.name:
-            amendComposes(documentation, resolvedValuePath);
+          default:
+            // for backwards compatibility
+            propTypeCompositionHandler(documentation, componentPath);
           break;
         }
         break;
@@ -106,17 +108,17 @@ function propTypeHandler(documentation: Documentation, path: NodePath) {
     return;
   }
   propTypesPath = resolveToValue(propTypesPath);
-  if (!propTypesPath || !types.ObjectExpression.check(propTypesPath.node)) {
+  if (!propTypesPath) {
     return;
   }
-
-  switch (propTypesPath.node.type) {
-    case types.ObjectExpression.name:
-      amendPropTypes(documentation, propTypesPath);
-      break;
-    case types.MemberExpression.name:
-      amendComposes(documentation, propTypesPath);
+  if (!types.ObjectExpression.check(propTypesPath.node)) {
+    // maybe composition
+    // for backwards compatibility
+    propTypeCompositionHandler(documentation, path);
+    return;
   }
+
+  amendPropTypes(documentation, propTypesPath, path);
 }
 
 module.exports = propTypeHandler;