Make resolveToValue consider assignments to identifiers (fixes #58)

In the following example, resolveToValue wouldn't resolve to the value
assigned to "React" because it only looks at the variable
definition, not at assignments to the variable:

```
var React;
React = require('react');
module.exports = React.createClass(...);
```

This diff fixes that. It will make a shallow traversal over the scope
where the variable is defined and look for the last assignment to the
variable.

---

I'm also trying to improve tests by storing component definitions that
are known to have been broken in `src/__tests__/fixtures/`. Adding more
components over time will strengthen the test suit and help catch
regressions.

Author: fkling

package.json

@@ -58,8 +58,6 @@
       "bin",
       "src"
     ],
-    "testPathIgnorePatterns": [
-      "/bin/__tests__/example/"
-    ]
+    "testRegex": "/__tests__/.*-test\\.js$"
   }
 }

src/__tests__/__snapshots__/main-test.js.snap

@@ -0,0 +1,7 @@
+exports[`main fixtures processes component "component_1.js" without errors 1`] = `
+Object {
+  "description": "The is a component to test the document generation",
+  "displayName": "Component",
+  "methods": Array []
+}
+`;

src/__tests__/fixtures/component_1.js

@@ -0,0 +1,12 @@
+var Component, React;
+
+React = require('react');
+
+/**
+ * The is a component to test the document generation
+ */
+Component = React.createClass({
+    displayName: 'Component',
+});
+
+module.exports = Component;

src/__tests__/main-test.js

@@ -8,17 +8,15 @@
  *
  */
 
-/*global jest, describe, beforeEach, it, expect*/
+/*global describe, it, expect*/
 
-jest.disableAutomock();
+import fs from 'fs';
+import path from 'path';
 
-describe('main', () => {
-  var docgen, ERROR_MISSING_DEFINITION;
+import * as docgen from '../main';
+import {ERROR_MISSING_DEFINITION} from '../parse';
 
-  beforeEach(() => {
-    docgen = require('../main');
-    ({ERROR_MISSING_DEFINITION} = require('../parse'));
-  });
+describe('main', () => {
 
   function test(source) {
     it('parses with default resolver/handlers', () => {
@@ -225,4 +223,17 @@ describe('main', () => {
       expect(() => docgen.parse(source)).toThrowError(ERROR_MISSING_DEFINITION);
     });
   });
+
+  describe('fixtures', () => {
+    const fixturePath = path.join(__dirname, 'fixtures');
+    const fileNames = fs.readdirSync(fixturePath);
+    for (let i = 0; i < fileNames.length; i++) {
+      const fileContent = fs.readFileSync(path.join(fixturePath, fileNames[i]));
+
+      it(`processes component "${fileNames[i]}" without errors`, () => {
+        expect(() => docgen.parse(fileContent)).not.toThrowError();
+        expect(docgen.parse(fileContent)).toMatchSnapshot();
+      });
+    }
+  });
 });

src/utils/__tests__/resolveToValue-test.js

@@ -91,6 +91,18 @@ describe('resolveToValue', () => {
       .toBe('FunctionDeclaration');
   });
 
+  describe('assignments', () => {
+    it('resolves to assigned values', () => {
+      var path = parse([
+        'var foo;',
+        'foo = 42;',
+        'foo;',
+      ].join('\n'));
+
+      expect(resolveToValue(path).node).toEqualASTNode(builders.literal(42));
+    });
+  });
+
   describe('ImportDeclaration', () => {
 
     it('resolves default import references to the import declaration', () => {

src/utils/resolveToValue.js

@@ -11,6 +11,7 @@
  */
 
 import recast from 'recast';
+import {traverseShallow} from './traverse';
 
 var {
   types: {
@@ -71,6 +72,36 @@ function findScopePath(paths: Array<NodePath>, path: NodePath): ?NodePath {
   }
 }
 
+/**
+ * Tries to find the last value assigned to `name` in the scope created by
+ * `scope`. We are not descending into any statements (blocks).
+ */
+function findLastAssignedValue(scope, name) {
+  let results = [];
+
+  traverseShallow(scope.path.node, {
+    visitAssignmentExpression: function(path) {
+      const node = path.node;
+      // Skip anything that is not an assignment to a variable with the
+      // passed name.
+      if (
+        !types.Identifier.check(node.left) ||
+        node.left.name !== name ||
+        node.operator !== '='
+      ) {
+        return this.traverse(path);
+      }
+      results.push(path.get('right'));
+      return false;
+    },
+  });
+
+  if (results.length === 0) {
+    return null;
+  }
+  return resolveToValue(results.pop());
+}
+
 /**
  * If the path is an identifier, it is resolved in the scope chain.
  * If it is an assignment expression, it resolves to the right hand side.
@@ -91,7 +122,7 @@ export default function resolveToValue(path: NodePath): NodePath {
     return path.parentPath;
   } else if (types.AssignmentExpression.check(node)) {
     if (node.operator === '=') {
-      return resolveToValue(node.get('right'));
+      return resolveToValue(path.get('right'));
     }
   } else if (types.Identifier.check(node)) {
     if ((types.ClassDeclaration.check(path.parentPath.node) ||
@@ -104,8 +135,14 @@ export default function resolveToValue(path: NodePath): NodePath {
     let scope = path.scope.lookup(node.name);
     let resolvedPath: ?NodePath;
     if (scope) {
-      const bindings = scope.getBindings()[node.name];
-      resolvedPath = findScopePath(bindings, path);
+      // The variable may be assigned a different value after initialization.
+      // We are first trying to find all assignments to the variable in the
+      // block where it is defined (i.e. we are not traversing into statements)
+      resolvedPath = findLastAssignedValue(scope, node.name);
+      if (!resolvedPath) {
+        const bindings = scope.getBindings()[node.name];
+        resolvedPath = findScopePath(bindings, path);
+      }
     } else {
       scope = path.scope.lookupType(node.name);
       if (scope) {