Merge pull request #12 from bttmly/better_filters

Better filters

Makefile

@@ -25,6 +25,6 @@ dogfood-fork: compile
 	node ./lib/cli -s lib -u fork
 
 ci: compile
-	node ./lib/cli -s lib -k 85
+	node ./lib/cli -s lib -k 70
 
 .PHONY: test example

src/filters/filter.ts

@@ -0,0 +1,62 @@
+import * as R from "ramda";
+import * as escodegen from "escodegen";
+import S from "../mutators/_syntax";
+import { LocationFilter } from "../types";
+
+export const isStringRequire = R.allPass([
+  R.propEq("type", S.CallExpression),
+  R.pathEq(["callee", "name"], "require"),
+  R.pathEq(["arguments", "length"], 1),
+  R.pathEq(["arguments", "0", "type"], S.Literal),
+  n => typeof R.path(["arguments", "0", "value"], n) === "string",
+]);
+
+export const isUseStrict = R.allPass([
+  R.propEq("type", S.ExpressionStatement),
+  R.pathEq(["expression", "value"], "use strict"),
+]);
+
+export const isCallOfName = (name: string): LocationFilter => {
+  return ({ node }) => {
+    if (!R.propEq("type", S.CallExpression, node)) return false;
+    if (!R.pathEq(["callee", "type"], S.Identifier, node)) return false;
+    if (!R.pathEq(["callee", "name"], name, node)) return false;
+    return true;
+  };
+};
+
+export function nodeSourceIncludes(text: string): LocationFilter {
+  return ({ node }) => {
+    return escodegen.generate(node).includes(text);
+  };
+}
+
+export function sourceNodeIncludesAny(texts: string[]): LocationFilter {
+  return ({ node }) => {
+    const code = escodegen.generate(node);
+    return texts.some(t => code.includes(t));
+  };
+}
+
+export function nodeSourceMatches(re: RegExp): LocationFilter {
+  return ({ node }) => {
+    return re.test(escodegen.generate(node));
+  };
+}
+
+export function sourceNodeMatchesAny(res: RegExp[]): LocationFilter {
+  return ({ node }) => {
+    const code = escodegen.generate(node);
+    return res.some(re => re.test(code));
+  };
+}
+
+export function sourceNodeIs(text: string): LocationFilter {
+  return ({ node }) => {
+    return escodegen.generate(node).trim() === text;
+  };
+}
+
+export const isESModuleInterop = nodeSourceIncludes(
+  "Object.defineProperty(exports, '__esModule', { value: true });",
+);

src/filters/index.ts

@@ -1,26 +1,9 @@
 import * as R from "ramda";
-import S from "../mutators/_syntax";
 import { MutantLocation } from "../types";
 
 type LocationFilter = (m: MutantLocation) => boolean;
 
-const isStringRequire = R.allPass([
-  R.propEq("type", S.CallExpression),
-  R.pathEq(["callee", "name"], "require"),
-  R.pathEq(["arguments", "length"], 1),
-  R.pathEq(["arguments", "0", "type"], S.Literal),
-  n => typeof R.path(["arguments", "0", "value"], n) === "string",
-]);
-
-const isUseStrict = R.allPass([
-  R.propEq("type", S.ExpressionStatement),
-  R.pathEq(["expression", "value"], "use strict"),
-]);
-
-// const isCallOfName = (name: string) => R.allPass([
-//   R.pathEq(["expression", "callee", "type"], "Identifier"),
-//   R.pathEq(["expression", "callee", "name"], name),
-// ]);
+import { isUseStrict, isStringRequire } from "./filter";
 
 const filters: LocationFilter[] = [
   (m: MutantLocation) => !isUseStrict(m.node),

src/matchers/contains-comparative.ts

@@ -28,7 +28,7 @@ const plugin: ComparativeMatcherPlugin = {
       // TODO: lose the "!"s
       const sourceName = withoutExt(sourceFile.split(perturbSourceDir).pop()!);
       const testName = withoutExt(testFile.split(perturbTestDir).pop()!);
-      return testName.slice(0, sourceName.length) === sourceName;
+      return testName.startsWith(sourceName);
     };
   },
 };

src/mutators/_filters.ts

@@ -1,3 +1,49 @@
-export function hasProp(prop: string) {
-  return (node: any) => node.hasOwnProperty(prop) && node[prop] !== null;
+import * as R from "ramda";
+import { NodeFilter } from "../types";
+import * as escodegen from "escodegen";
+import S from "../mutators/_syntax";
+
+export function hasProp(prop: string): NodeFilter {
+  return node => {
+    return R.prop(prop, node as any) != null;
+  };
 }
+
+export const isCallOfName = (name: string): NodeFilter => {
+  return node => {
+    if (!R.propEq("type", S.CallExpression, node)) return false;
+    if (!R.pathEq(["callee", "type"], S.Identifier, node)) return false;
+    if (!R.pathEq(["callee", "name"], name, node)) return false;
+    return true;
+  };
+};
+
+export function nodeSourceIncludes(text: string): NodeFilter {
+  return node => escodegen.generate(node).includes(text);
+}
+
+export function sourceNodeIncludesAny(texts: string[]): NodeFilter {
+  return node => {
+    const code = escodegen.generate(node);
+    return texts.some(t => code.includes(t));
+  };
+}
+
+export function nodeSourceMatches(re: RegExp): NodeFilter {
+  return node => re.test(escodegen.generate(node));
+}
+
+export function sourceNodeMatchesAny(res: RegExp[]): NodeFilter {
+  return node => {
+    const code = escodegen.generate(node);
+    return res.some(re => re.test(code));
+  };
+}
+
+export function sourceNodeIs(text: string): NodeFilter {
+  return node => escodegen.generate(node).trim() === text;
+}
+
+export const isESModuleInterop = nodeSourceIncludes(
+  "Object.defineProperty(exports, '__esModule', { value: true });",
+);

src/mutators/_syntax.ts

@@ -4,4 +4,10 @@ S.LOOP_NODES = [S.WhileStatement, S.DoWhileStatement, S.ForStatement];
 
 S.TEST_NODES = [S.IfStatement, S.ConditionalExpression, S.SwitchCase];
 
+S.FUNC_NODES = [
+  S.FunctionDeclaration,
+  S.FunctionExpression,
+  S.ArrowFunctionExpression,
+];
+
 export default S;

src/mutators/drop-parameter-default.ts

@@ -0,0 +1,24 @@
+import * as R from "ramda";
+import S from "./_syntax";
+import { VOID_NODE } from "./_constant-nodes";
+import { MutatorPlugin } from "../types";
+
+// a default parameter
+// input: `function fn (x = 1) {}`
+// output: `function fn (x) {}`
+
+const plugin: MutatorPlugin = {
+  type: "mutator",
+  name: "drop-return",
+  nodeTypes: S.FUNC_NODES,
+  mutator: R.ifElse(
+    node => node.argument == null,
+    R.always(VOID_NODE),
+    node => ({
+      type: S.ExpressionStatement,
+      expression: node.argument,
+    }),
+  ),
+};
+
+export default plugin;

src/mutators/index.ts

@@ -85,8 +85,11 @@ function makeMutatorIndex(names: string[]): MutatorIndex {
   return index;
 }
 
-function locateMutatorPlugins(names: string[]): MutatorPlugin[] {
-  return names.map((name: string): MutatorPlugin => {
+function locateMutatorPlugins(
+  names: string[],
+  strict = false,
+): MutatorPlugin[] {
+  const plugins = names.map((name: string) => {
     try {
       const plugin: MutatorPlugin = require(`perturb-plugin-mutator-${name}`);
       return plugin;
@@ -95,9 +98,20 @@ function locateMutatorPlugins(names: string[]): MutatorPlugin[] {
       console.log(
         `unable to locate -MUTATOR- plugin "${name}" -- fatal error, exiting`,
       );
-      throw err;
+      if (strict) throw err;
     }
+    return;
   });
+
+  return removeNils<MutatorPlugin>(plugins);
+}
+
+function removeNils<T>(arr: Array<T | null | void>): T[] {
+  const xs: T[] = [];
+  for (const item of arr) {
+    if (item != null) xs.push(item);
+  }
+  return xs;
 }
 
 // exports.injectPlugins = function (names: string[]) {

src/mutators/reverse-function-parameters.ts

@@ -2,18 +2,12 @@ import S from "./_syntax";
 import * as util from "./util";
 import { MutatorPlugin } from "../types";
 
-const FUNC_NODES = [
-  S.FunctionDeclaration,
-  S.FunctionExpression,
-  S.ArrowFunctionExpression,
-];
-
 // reverse the perameter order for a function expression or declaration
 // `function fn (a, b) {}` => `function fn (b, a) {}`
 const plugin: MutatorPlugin = {
   type: "mutator",
   name: "reverse-function-parameters",
-  nodeTypes: FUNC_NODES,
+  nodeTypes: S.FUNC_NODES,
   filter: util.lengthAtPropGreaterThan("params", 1),
   mutator: util.update("params", (ps: any[]) => ps.slice().reverse()),
 };

src/mutators/util.ts

@@ -13,15 +13,35 @@ export const update = R.curry(
 //   return updater(R.prop, obj).map(updated => R.assoc(prop, updated, obj));
 // });
 
-export const lengthAtPropGreaterThan = R.curry(
-  (prop: string, count: number, obj: object): boolean => {
-    return (R.path([prop, "length"], obj) as number) > count;
-  },
-);
+export const lengthAtPropGreaterThan = (prop: string, count: number) => {
+  return (obj: any) => (R.path([prop, "length"], obj) as number) > count;
+};
+
+// given an object with an array property, return an array of
+// copies of that object, each copy having one of the array's
+// elements removed
+
+// dropEachOfProp("key", {key: [1, 2, 3]})
+// => [ {key: [2, 3]}, {key: [1, 3]}, {key: [1, 2]} ]
 
 export const dropEachOfProp = R.curry((prop: string, obj: any): any[] => {
-  const target: any[] = R.prop(prop, obj);
-  return target.map((_: any, i: number) => {
-    return R.assoc(prop, R.remove(i, 1, target), obj);
+  const arr: any[] = R.prop(prop, obj);
+  // TODO: runtime verify Array.isArray(arr)
+  return arr.map((_: any, i: number) => {
+    return R.assoc(prop, R.remove(i, 1, arr), obj);
   });
 });
+
+export const dropEachOfPropPred = (prop: string, pred: (x: any) => boolean) => {
+  return (obj: any) => {
+    const results: any[] = [];
+    const arr: any[] = R.prop(prop, obj);
+    // TODO: runtime verify Array.isArray(target)
+    for (let i = 0; i < arr.length; i++) {
+      const item = arr[i];
+      if (pred(item)) {
+        results.push(R.assoc(prop, R.remove(i, 1, arr), obj));
+      }
+    }
+  };
+};