Fix flow errors. All tests pass.

Author: fkling

flow/react-docgen.js

@@ -8,10 +8,17 @@
  *
  */
 
+import type Documentation from '../src/Documentation';
+
 type PropTypeDescriptor = {
   name: string;
   value?: any;
   raw?: string;
+  computed?: boolean;
+  // These are only needed for shape types.
+  // Consider consolidating PropTypeDescriptor and PropDescriptor
+  description?: string;
+  required?: boolean;
 };
 
 type PropDescriptor = {
@@ -21,15 +28,6 @@ type PropDescriptor = {
   description?: string;
 };
 
-declare class Documentation {
-  addComposes(moduleName: string): void;
-  get(key: string): any;
-  set(key: string, value: any): void;
-  getPropDescriptor(propName: string): PropDescriptor;
-  toObject(): Object;
-}
-
-
 type Handler = (documentation: Documentation, path: NodePath) => void;
 type Resolver =
   (node: ASTNode, recast: Recast) => (?NodePath|?Array<NodePath>);

src/Documentation.js

@@ -12,7 +12,7 @@
 
 class Documentation {
   _props: Object;
-  _composes: Array<string>;
+  _composes: Set<string>;
   _data: Object;
 
   constructor() {
@@ -29,7 +29,7 @@ class Documentation {
     this._data.set(key, value);
   }
 
-  get(key: string) {
+  get(key: string): any {
     return this._data.get(key);
   }
 

src/parse.js

@@ -52,15 +52,17 @@ export default function parse(
 ): Array<Object>|Object {
   var ast = recast.parse(src, {esprima: babylon});
   var componentDefinitions = resolver(ast.program, recast);
-  var isArray = Array.isArray(componentDefinitions);
 
-  if (!componentDefinitions || (isArray && componentDefinitions.length === 0)) {
-    throw new Error(ERROR_MISSING_DEFINITION);
+  if (Array.isArray(componentDefinitions)) {
+    if (componentDefinitions.length === 0) {
+      throw new Error(ERROR_MISSING_DEFINITION);
+    }
+    return executeHandlers(handlers, componentDefinitions);
+  } else if (componentDefinitions) {
+    return executeHandlers(handlers, [(componentDefinitions: NodePath)])[0];
   }
 
-  return isArray ?
-    executeHandlers(handlers, componentDefinitions) :
-    executeHandlers(handlers, [componentDefinitions])[0];
+  throw new Error(ERROR_MISSING_DEFINITION);
 }
 
 export {ERROR_MISSING_DEFINITION};

src/utils/getPropType.js

@@ -33,7 +33,7 @@ function getEnumValues(path) {
 }
 
 function getPropTypeOneOf(argumentPath) {
-  var type = {name: 'enum'};
+  var type: PropTypeDescriptor = {name: 'enum'};
   if (!types.ArrayExpression.check(argumentPath.node)) {
     type.computed = true;
     type.value = printValue(argumentPath);
@@ -44,7 +44,7 @@ function getPropTypeOneOf(argumentPath) {
 }
 
 function getPropTypeOneOfType(argumentPath) {
-  var type = {name: 'union'};
+  var type: PropTypeDescriptor = {name: 'union'};
   if (!types.ArrayExpression.check(argumentPath.node)) {
     type.computed = true;
     type.value = printValue(argumentPath);
@@ -55,7 +55,7 @@ function getPropTypeOneOfType(argumentPath) {
 }
 
 function getPropTypeArrayOf(argumentPath) {
-  var type = {name: 'arrayOf'};
+  var type: PropTypeDescriptor = {name: 'arrayOf'};
   var subType = getPropType(argumentPath);
 
   if (subType.name === 'unknown') {
@@ -68,22 +68,24 @@ function getPropTypeArrayOf(argumentPath) {
 }
 
 function getPropTypeShape(argumentPath) {
-  var type: {name: string; value: any;} = {name: 'shape', value: 'unkown'};
+  var type: PropTypeDescriptor = {name: 'shape', value: 'unkown'};
   if (!types.ObjectExpression.check(argumentPath.node)) {
     argumentPath = resolveToValue(argumentPath);
   }
 
   if (types.ObjectExpression.check(argumentPath.node)) {
-    type.value = {};
+    var value = {};
     argumentPath.get('properties').each(function(propertyPath) {
-      var descriptor = getPropType(propertyPath.get('value'));
+      var descriptor: PropDescriptor | PropTypeDescriptor =
+        getPropType(propertyPath.get('value'));
       var docs = getDocblock(propertyPath);
       if (docs) {
         descriptor.description = docs;
       }
       descriptor.required = isRequiredPropType(propertyPath.get('value'));
-      type.value[getPropertyName(propertyPath)] = descriptor;
+      value[getPropertyName(propertyPath)] = descriptor;
     });
+    type.value = value;
   }
 
   return type;

src/utils/isStatelessComponent.js

@@ -101,12 +101,14 @@ function returnsJSXElementOrReactCreateElementCall(path) {
           }
         }
 
-        if (types.ObjectExpression.check(resolvedValue.node)) {
+        if (resolvedValue && types.ObjectExpression.check(resolvedValue.node)) {
           var resolvedMemberExpression = namesToResolve
             .reduce((result, path) => { // eslint-disable-line no-shadow
-              result = getPropertyValuePath(result, path.node.name);
-              if (types.Identifier.check(result.node)) {
-                return resolveToValue(result);
+              if (result) {
+                result = getPropertyValuePath(result, path.node.name);
+                if (result && types.Identifier.check(result.node)) {
+                  return resolveToValue(result);
+                }
               }
               return result;
             }, resolvedValue);