[new] - Add API to not infer values and just get literal values.

This is for cases where we do not want to assume anything about dynamic
properties (such as variables, functions, etc.). We cannot know their
types until runtime, so we should just skip over them when enforcing a
rule.

Author: beefancohen

.eslintrc.js

@@ -64,7 +64,6 @@ module.exports = {
       "ignorePattern": "((^import[^;]+;$)|(^\\s*it\\())",
       "ignoreUrls": true
     } ],
-    "new-cap": 2,
     "no-alert": 2,
     "no-confusing-arrow": 2,
     "no-caller": 2,

src/util/getAttributeValue.js

@@ -1,18 +1,8 @@
 'use strict';
 
-import getValue from './values';
+import { getValue, getLiteralValue } from './values';
 
-/**
- * Returns the value of a given attribute.
- * Different types of attributes have their associated
- * values in different properties on the object.
- *
- * This function should return the most *closely* associated
- * value with the intention of the JSX.
- *
- * @param attribute - The JSXAttribute collected by AST parser.
- */
-const getAttributeValue = attribute => {
+const extract = (attribute, extractor) => {
   if (attribute.type === 'JSXAttribute') {
     if (attribute.value === null) {
       // Null valued attributes imply truthiness.
@@ -21,10 +11,24 @@ const getAttributeValue = attribute => {
       return true;
     }
 
-    return getValue(attribute.value);
+    return extractor(attribute.value);
   }
 
   return undefined;
 };
 
+/**
+ * Returns the value of a given attribute.
+ * Different types of attributes have their associated
+ * values in different properties on the object.
+ *
+ * This function should return the most *closely* associated
+ * value with the intention of the JSX.
+ *
+ * @param attribute - The JSXAttribute collected by AST parser.
+ */
+const getAttributeValue = attribute => extract(attribute, getValue);
+
+export const getLiteralAttributeValue = attribute => extract(attribute, getLiteralValue);
+
 export default getAttributeValue;

src/util/values/Literal.js

@@ -1,3 +1,13 @@
-const extract = value => value.value;
+const extract = value => {
+  const { value: extractedValue } = value;
+
+  if (extractedValue === "true") {
+    return true;
+  } else if (extractedValue === "false") {
+    return false;
+  }
+
+  return extractedValue;
+};
 
 export default extract;

src/util/values/Identifier.js renamed to src/util/values/expressions/Identifier.js

@@ -1,5 +1,5 @@
 import Literal from '../Literal';
-import Identifier from '../Identifier';
+import Identifier from './Identifier';
 import TemplateLiteral from './TemplateLiteral';
 import ArrowFunctionExpression from './FunctionExpression';
 import FunctionExpression from './FunctionExpression';
@@ -20,11 +20,35 @@ const TYPES = {
   UnaryExpression
 };
 
-const extract = value => {
+const noop = () => null;
+
+const LITERAL_TYPES = Object.assign({}, TYPES, {
+  Identifier: value => {
+    const isUndefined = TYPES.Identifier(value) === undefined;
+    return isUndefined ? undefined : null;
+  },
+  ArrowFunctionExpression: noop,
+  FunctionExpression: noop,
+  LogicalExpression: noop,
+  MemberExpression: noop,
+  CallExpression: noop,
+  UnaryExpression: value => {
+    const extractedVal = TYPES.UnaryExpression(value);
+    return extractedVal === undefined ? null : extractedVal;
+  }
+});
+
+export const extract = value => {
   // Value will not have the expression property when we recurse.
   const expression = value.expression || value;
 
   return TYPES[expression.type](expression);
 };
 
+export const extractLiteral = value => {
+  const expression = value.expression || value;
+
+  return LITERAL_TYPES[expression.type](expression);
+};
+
 export default extract;

src/util/values/expressions/index.js

@@ -1,15 +1,21 @@
 import Literal from './Literal';
-import Identifier from './Identifier';
 import JSXElement from './JSXElement';
 import JSXExpressionContainer from './expressions';
+import { extractLiteral } from './expressions';
 
 const TYPES = {
   Literal,
-  Identifier,
   JSXElement,
   JSXExpressionContainer
 };
 
-const getValue = value => TYPES[value.type](value);
+const LITERAL_TYPES = Object.assign({}, TYPES, {
+  JSXElement: () => null,
+  JSXExpressionContainer: extractLiteral
+});
+
+export const getValue = value => TYPES[value.type](value);
+
+export const getLiteralValue = value => LITERAL_TYPES[value.type](value);
 
 export default getValue;