Try to resolve static values inside PropType "oneOf"

A common pattern is to write:
```javascript
React.PropTypes.oneOf([TYPES.FOO, TYPES.BAR]);
// or:
var TYPES = ["FOO", "BAR"];
React.PropTypes.oneOf(TYPES);
// or:
var TYPES = ["A", "B"];
var MORE = [...TYPES, "C"];
React.PropTypes.oneOf(MORE);
```
etc.

This change tries to resolve all identifiers (be it the arguments
themselves or identifier inside an ArrayExpression) to their value
in order to be able to generate better documentation for "oneOf"
propTypes that reference static values.

This does not work for values that are imported from external files
and also does not work for values that are computed
(as in `Object.keys(TYPES)` or `_.values(TYPES)`).
In those cases it will just print the value with the `computed` flag set
to true.

Author: ZauberNerd

src/utils/__tests__/getPropType-test.js

@@ -134,20 +134,124 @@ describe('getPropType', () => {
     });
   });
 
-  it('resolves variables to their values', () => {
-    var propTypeExpression = statement(`
-      PropTypes.shape(shape);
-      var shape = {bar: PropTypes.string};
-    `).get('expression');
+  describe('resolve identifier to their values', () => {
+    it('resolves variables to their values', () => {
+      var propTypeExpression = statement(`
+        PropTypes.shape(shape);
+        var shape = {bar: PropTypes.string};
+      `).get('expression');
 
-    expect(getPropType(propTypeExpression)).toEqual({
-      name: 'shape',
-      value: {
-        bar: {
-          name: 'string',
-          required: false,
+      expect(getPropType(propTypeExpression)).toEqual({
+        name: 'shape',
+        value: {
+          bar: {
+            name: 'string',
+            required: false,
+          },
         },
-      },
+      });
+    });
+
+    it('resolves simple identifier to their initialization value', () => {
+      var propTypeIdentifier = statement(`
+        PropTypes.oneOf(TYPES);
+        var TYPES = ["foo", "bar"];
+      `).get('expression');
+
+      expect(getPropType(propTypeIdentifier)).toEqual({
+        name: 'enum',
+        value: [
+          {value: '"foo"', computed: false},
+          {value: '"bar"', computed: false},
+        ],
+      });
+
+      var identifierInsideArray = statement(`
+        PropTypes.oneOf([FOO, BAR]);
+        var FOO = "foo";
+        var BAR = "bar";
+      `).get('expression');
+
+      expect(getPropType(identifierInsideArray)).toEqual({
+        name: 'enum',
+        value: [
+          {value: '"foo"', computed: false},
+          {value: '"bar"', computed: false},
+        ],
+      });
+
+    });
+
+    it('resolves memberExpressions', () => {
+      var propTypeExpression = statement(`
+        PropTypes.oneOf([TYPES.FOO, TYPES.BAR]);
+        var TYPES = { FOO: "foo", BAR: "bar" };
+      `).get('expression');
+
+      expect(getPropType(propTypeExpression)).toEqual({
+        name: 'enum',
+        value: [
+          {value: '"foo"', computed: false},
+          {value: '"bar"', computed: false},
+        ],
+      });
+    });
+
+    it('correctly resolves SpreadElements in arrays', () => {
+      var propTypeExpression = statement(`
+        PropTypes.oneOf([...TYPES]);
+        var TYPES = ["foo", "bar"];
+      `).get('expression');
+
+      expect(getPropType(propTypeExpression)).toEqual({
+        name: 'enum',
+        value: [
+          {value: '"foo"', computed: false},
+          {value: '"bar"', computed: false},
+        ],
+      });
+    });
+
+    it('correctly resolves nested SpreadElements in arrays', () => {
+      var propTypeExpression = statement(`
+        PropTypes.oneOf([...TYPES]);
+        var TYPES = ["foo", ...TYPES2];
+        var TYPES2 = ["bar"];
+      `).get('expression');
+
+      expect(getPropType(propTypeExpression)).toEqual({
+        name: 'enum',
+        value: [
+          {value: '"foo"', computed: false},
+          {value: '"bar"', computed: false},
+        ],
+      });
+    });
+
+    it('does not resolve computed values', () => {
+      var propTypeExpression = statement(`
+        PropTypes.oneOf(Object.keys(TYPES));
+        var TYPES = { FOO: "foo", BAR: "bar" };
+      `).get('expression');
+
+      expect(getPropType(propTypeExpression)).toEqual({
+        name: 'enum',
+        value: 'Object.keys(TYPES)',
+        computed: true,
+      });
+    });
+
+    it('does not resolve external values', () => {
+      var propTypeExpression = statement(`
+        PropTypes.oneOf(TYPES);
+        import { TYPES } from './foo';
+      `).get('expression');
+
+      expect(getPropType(propTypeExpression)).toEqual({
+        name: 'enum',
+        value: 'TYPES',
+        computed: true,
+      });
     });
   });
 

src/utils/getPropType.js

@@ -24,21 +24,44 @@ import resolveToValue from './resolveToValue';
 var {types: {namedTypes: types}} = recast;
 
 function getEnumValues(path) {
-  return path.get('elements').map(function(elementPath) {
-    return {
-      value: printValue(elementPath),
-      computed: !types.Literal.check(elementPath.node),
-    };
+  const values = [];
+
+  path.get('elements').each(function(elementPath) {
+    if (types.SpreadElement.check(elementPath.node)) {
+      const value = resolveToValue(elementPath.get('argument'));
+
+      if (types.ArrayExpression.check(value.node)) {
+        // if the SpreadElement resolved to an Array, add all their elements too
+        return values.push(...getEnumValues(value));
+      } else {
+        // otherwise we'll just print the SpreadElement itself
+        return values.push({
+          value: printValue(elementPath),
+          computed: !types.Literal.check(elementPath.node),
+        });
+      }
+    }
+
+    // try to resolve the array element to it's value
+    const value = resolveToValue(elementPath);
+    return values.push({
+      value: printValue(value),
+      computed: !types.Literal.check(value.node),
+    });
   });
+
+  return values;
 }
 
 function getPropTypeOneOf(argumentPath) {
   var type: PropTypeDescriptor = {name: 'enum'};
-  if (!types.ArrayExpression.check(argumentPath.node)) {
+  const value = resolveToValue(argumentPath);
+  if (!types.ArrayExpression.check(value.node)) {
+    // could not easily resolve to an Array, let's print the original value
     type.computed = true;
     type.value = printValue(argumentPath);
   } else {
-    type.value = getEnumValues(argumentPath);
+    type.value = getEnumValues(value);
   }
   return type;
 }