Add helper methods to get members from objects or classes

With `getMemberValuePath`, handlers don't have to care whether the
component definition comes from an ObjectExpression (via
`React.createClass`) or a class definition.

This helper function also "normalizes" member names between
ObjectExpressions and class definitions. E.g. "defaultProps" will both
look for "defaultProps" and "getDefaultProps".

Author: fkling

src/utils/__tests__/getClassMemberValuePath-test.js

@@ -0,0 +1,70 @@
+/*
+ *  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, beforeEach, it, expect*/
+
+jest.autoMockOff();
+
+describe('getClassMemberValuePath', () => {
+  var getClassMemberValuePath;
+  var statement;
+
+  beforeEach(() => {
+    getClassMemberValuePath = require('../getClassMemberValuePath');
+    ({statement} = require('../../../tests/utils'));
+  });
+
+  describe('MethodDefinitions', () => {
+    it('finds "normal" method definitions', () => {
+      var def = statement(`
+        class Foo {
+          render() {}
+        }
+      `);
+
+      expect(getClassMemberValuePath(def, 'render'))
+        .toBe(def.get('body', 'body', 0, 'value'));
+    });
+
+    it('finds computed method definitions with literal keys', () => {
+      var def = statement(`
+        class Foo {
+          ['render']() {}
+        }
+      `);
+
+      expect(getClassMemberValuePath(def, 'render'))
+        .toBe(def.get('body', 'body', 0, 'value'));
+    });
+
+    it('ignores computed method definitions with expression', () => {
+      var def = statement(`
+        class Foo {
+          [render]() {}
+        }
+      `);
+
+      expect(getClassMemberValuePath(def, 'render')).not.toBeDefined();
+    });
+  });
+
+  xdescribe('ClassProperty', () => {
+    it('finds "normal" class properties', () => {
+      var def = statement(`
+        class Foo {
+          foo = 42;
+        }
+      `);
+
+      expect(getClassMemberValuePath(def, 'foo'))
+        .toBe(def.get('body', 'body', 0, 'value'));
+    });
+  });
+});

src/utils/__tests__/getMemberValuePath-test.js

@@ -0,0 +1,78 @@
+/*
+ *  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, xdescribe, beforeEach, it, expect*/
+
+jest
+  .dontMock('../getMemberValuePath.js');
+
+describe('getMemberValuePath', () => {
+  var getMemberValuePath;
+  var expression, statement;
+
+  beforeEach(() => {
+    ({expression, statement} = require('../../../tests/utils'));
+    getMemberValuePath = require('../getMemberValuePath');
+  });
+
+  it('handles ObjectExpresisons', () => {
+    var getPropertyValuePath = require('../getPropertyValuePath');
+    var path = expression('{}');
+
+    getMemberValuePath(path, 'foo');
+    expect(getPropertyValuePath).toBeCalledWith(path, 'foo');
+  });
+
+  it('handles ClassDeclarations', () => {
+    var getClassMemberValuePath = require('../getClassMemberValuePath');
+    var path = statement('class Foo {}');
+
+    getMemberValuePath(path, 'foo');
+    expect(getClassMemberValuePath).toBeCalledWith(path, 'foo');
+  });
+
+  it('handles ClassExpressions', () => {
+    var getClassMemberValuePath = require('../getClassMemberValuePath');
+    var path = expression('class {}');
+
+    getMemberValuePath(path, 'foo');
+    expect(getClassMemberValuePath).toBeCalledWith(path, 'foo');
+  });
+
+  it('tries synonyms', () => {
+    var getPropertyValuePath = require('../getPropertyValuePath');
+    var getClassMemberValuePath = require('../getClassMemberValuePath');
+    var path = expression('{}');
+
+    getMemberValuePath(path, 'defaultProps');
+    expect(getPropertyValuePath).toBeCalledWith(path, 'defaultProps');
+    expect(getPropertyValuePath).toBeCalledWith(path, 'getDefaultProps');
+
+    path = statement('class Foo {}');
+
+    getMemberValuePath(path, 'defaultProps');
+    expect(getClassMemberValuePath).toBeCalledWith(path, 'defaultProps');
+    expect(getClassMemberValuePath).toBeCalledWith(path, 'getDefaultProps');
+  });
+
+  it('returns the result of getPropertyValuePath and getClassMemberValuePath', () => {
+    var getPropertyValuePath = require('../getPropertyValuePath');
+    var getClassMemberValuePath = require('../getClassMemberValuePath');
+    getPropertyValuePath.mockReturnValue(42);
+    getClassMemberValuePath.mockReturnValue(21);
+    var path = expression('{}');
+
+    expect(getMemberValuePath(path, 'defaultProps')).toBe(42);
+
+    path = statement('class Foo {}');
+
+    expect(getMemberValuePath(path, 'defaultProps')).toBe(21);
+  });
+});

src/utils/getClassMemberValuePath.js

@@ -0,0 +1,31 @@
+/*
+ * 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
+ *
+ */
+
+import getNameOrValue from './getNameOrValue';
+import recast from 'recast';
+
+var {types: {namedTypes: types}} = recast;
+
+export default function getClassMemberValuePath(
+  classDefinition: NodePath,
+  memberName: string
+) {
+  // Fortunately it seems like that all members of a class body, be it
+  // ClassProperty or MethodDefinition, have the same structure: They have a
+  // "key" and a "value"
+  return classDefinition.get('body', 'body')
+    .filter(memberPath => (
+      (!memberPath.node.computed || types.Literal.check(memberPath.node.key)) &&
+      getNameOrValue(memberPath.get('key')) === memberName
+    ))
+    .map(memberPath => memberPath.get('value'))[0];
+}

src/utils/getMemberValuePath.js

@@ -0,0 +1,67 @@
+/*
+ * 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
+ *
+ */
+
+import getClassMemberValuePath from './getClassMemberValuePath';
+import getPropertyValuePath from './getPropertyValuePath';
+import recast from 'recast';
+
+var {types: {namedTypes: types}} = recast;
+
+const SYNONYMS = {
+  getDefaultProps: 'defaultProps',
+  defaultProps: 'getDefaultProps',
+};
+
+const LOOKUP_METHOD = {
+  [types.ObjectExpression.name]: getPropertyValuePath,
+  [types.ClassDeclaration.name]: getClassMemberValuePath,
+  [types.ClassExpression.name]: getClassMemberValuePath,
+};
+
+function isSupportedDefinitionType({node}) {
+  return types.ObjectExpression.check(node) ||
+    types.ClassDeclaration.check(node) ||
+    types.ClassExpression.check(node);
+}
+
+/**
+ * This is a helper method for handlers to make it easier to work either with
+ * an ObjectExpression from `React.createClass` class or with a class
+ * definition.
+ *
+ * Given a path and a name, this function will either return the path of the
+ * property value if the path is an ObjectExpression, or the value of the
+ * ClassProperty/MethodDefinition if it is a class definition (declaration or
+ * expression).
+ *
+ * It also normalizes the names so that e.g. `defaultProps` and
+ * `getDefaultProps` can be used interchangeably.
+ */
+export default function getMemberValuePath(
+  componentDefinition: NodePath,
+  memberName: string
+): ?NodePath {
+  if (!isSupportedDefinitionType(componentDefinition)) {
+    throw new TypeError(
+      'Got unsupported definition type. Definition must either be an ' +
+      'ObjectExpression, ClassDeclaration or ClassExpression. Got "' +
+      componentDefinition.node.type + '" instead.'
+    );
+  }
+
+  var lookupMethod = LOOKUP_METHOD[componentDefinition.node.type];
+  var result = lookupMethod(componentDefinition, memberName);
+  if (!result && SYNONYMS[memberName]) {
+    return lookupMethod(componentDefinition, SYNONYMS[memberName]);
+  }
+  return result;
+}