.travis.yml

@@ -2,5 +2,6 @@ sudo: false
 language: node_js
 node_js:
   - 4
-  - 5
+  - 6
+  - 8
   - stable

CODE_OF_CONDUCT.md

@@ -0,0 +1,3 @@
+# Code of Conduct
+
+Facebook has adopted a Code of Conduct that we expect project participants to adhere to. Please [read the full text](https://code.facebook.com/codeofconduct) so that you can understand what actions will and will not be tolerated.

CONTRIBUTING.md

@@ -2,6 +2,9 @@
 We want to make contributing to this project as easy and transparent as
 possible.
 
+## Code of Conduct
+The code of conduct is described in [`CODE_OF_CONDUCT.md`](CODE_OF_CONDUCT.md)
+
 ## Our Development Process
 The majority of development on jscodeshift will occur through GitHub. Accordingly,
 the process for contributing will follow standard GitHub protocol.

README.md

@@ -100,7 +100,7 @@ module.exports = function(fileInfo, api) {
 }
 ```
 
-**Note:** This api is exposed for convenience, but you don't have to use it.
+**Note:** This API is exposed for convenience, but you don't have to use it.
 You can use any tool to modify the source.
 
 `stats` is a function that only works when the `--dry` options is set. It accepts
@@ -360,7 +360,7 @@ This will run two tests: One for `__testfixtures__/FirstFixture.input.js` and on
 #### `defineInlineTest`
 ```js
 const transform = require('../myTransform');
-defineInlineTest(transform, {}, 'input', 'expected output');
+defineInlineTest(transform, {}, 'input', 'expected output', 'test name (optional)');
 ```
 
 ### Example Codemods

package.json

@@ -1,6 +1,6 @@
 {
   "name": "jscodeshift",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "A toolkit for JavaScript codemods",
   "repository": {
     "type": "git",
@@ -26,19 +26,19 @@
   "author": "Felix Kling",
   "license": "BSD-3-Clause",
   "dependencies": {
-    "async": "^1.5.0",
     "babel-plugin-transform-flow-strip-types": "^6.8.0",
     "babel-preset-es2015": "^6.9.0",
     "babel-preset-stage-1": "^6.5.0",
     "babel-register": "^6.9.0",
-    "babylon": "^6.17.3",
+    "babylon": "^7.0.0-beta.30",
     "colors": "^1.1.2",
     "flow-parser": "^0.*",
     "lodash": "^4.13.1",
     "micromatch": "^2.3.7",
+    "neo-async": "^2.5.0",
     "node-dir": "0.1.8",
     "nomnom": "^1.8.1",
-    "recast": "^0.12.5",
+    "recast": "^0.14.1",
     "temp": "^0.8.1",
     "write-file-atomic": "^1.2.0"
   },

parser/babylon.js

@@ -31,6 +31,7 @@ const options = {
     'asyncGenerators',
     'functionBind',
     'functionSent',
+    'dynamicImport',
   ],
 };
 

sample/__tests__/reverse-identifiers-test.js

@@ -33,4 +33,9 @@ var droWtsrif = 'Hello ';
 var droWdnoces = 'world';
 var egassem = droWtsrif + droWdnoces;
   `);
+  defineInlineTest(transform, {},
+    'function aFunction() {};',
+    'function noitcnuFa() {};',
+    'Reverses function names'
+  );
 });

src/Collection.js

@@ -78,6 +78,30 @@ class Collection {
     return this;
   }
 
+  /**
+   * Tests whether at-least one path passes the test implemented by the provided callback.
+   *
+   * @param {function} callback
+   * @return {boolean}
+   */
+  some(callback) {
+    return this.__paths.some(
+      (path, i, paths) => callback.call(path, path, i, paths)
+    );
+  }
+
+  /**
+   * Tests whether all paths pass the test implemented by the provided callback.
+   *
+   * @param {function} callback
+   * @return {boolean}
+   */
+  every(callback) {
+    return this.__paths.every(
+      (path, i, paths) => callback.call(path, path, i, paths)
+    );
+  }
+
   /**
    * Executes the callback for every path in the collection and returns a new
    * collection from the return values (which must be paths).

src/Runner.js

@@ -157,17 +157,19 @@ function run(transformFile, paths, options) {
           })
           .on('end', () => {
             temp.open('jscodeshift', (err, info) => {
-              reject(err);
-              fs.write(info.fd, contents);
-              fs.close(info.fd, function(err) {
-                reject(err);
-                transform(info.path).then(resolve, reject);
+              if (err) return reject(err);
+              fs.write(info.fd, contents, function (err) {
+                if (err) return reject(err);
+                fs.close(info.fd, function(err) {
+                  if (err) return reject(err);
+                  transform(info.path).then(resolve, reject);
+                });
               });
             });
         })
       })
       .on('error', (e) => {
-        reject(e.message);
+        reject(e);
       });
     });
   } else if (!fs.existsSync(transformFile)) {

src/Worker.js

@@ -12,7 +12,7 @@
 
 const EventEmitter = require('events').EventEmitter;
 
-const async = require('async');
+const async = require('neo-async');
 const fs = require('fs');
 const writeFileAtomic = require('write-file-atomic');
 const getParser = require('./getParser');

src/__tests__/Collection-test.js

@@ -234,6 +234,46 @@ describe('Collection API', function() {
       });
     });
 
+    describe('some', function() {
+      it('lets you test each element of a collection and stops when one passes the test', function() {
+        const each = jest.genMockFunction().mockImplementation(() => true);
+        Collection.fromNodes(nodes).some(each);
+
+        expect(each.mock.calls.length).toBe(1);
+        expect(each.mock.calls[0][0].value).toBe(nodes[0]);
+      });
+
+      it('returns true if at least one element passes the test', function() {
+        const result = Collection.fromNodes(nodes).some((_, i) => i === 1);
+        expect(result).toBe(true);
+      });
+
+      it('returns false if no elements pass the test', function() {
+        const result = Collection.fromNodes(nodes).some(() => false);
+        expect(result).toBe(false);
+      });
+    });
+
+    describe('every', function() {
+      it('lets you test each element of a collection and stops when one fails the test', function() {
+        const each = jest.genMockFunction().mockImplementation(() => false);
+        Collection.fromNodes(nodes).every(each);
+
+        expect(each.mock.calls.length).toBe(1);
+        expect(each.mock.calls[0][0].value).toBe(nodes[0]);
+      });
+
+      it('returns true if all elements pass the test', function() {
+        const result = Collection.fromNodes(nodes).every(() => true);
+        expect(result).toBe(true);
+      });
+
+      it('returns false if at least one element does not pass the test', function() {
+        const result = Collection.fromNodes(nodes).every((_, i) => i === 1);
+        expect(result).toBe(false);
+      });
+    });
+
     describe('map', function() {
       it('returns a new collection with mapped values', function() {
         const root = Collection.fromNodes(nodes);

src/collections/VariableDeclarator.js

@@ -114,6 +114,15 @@ const transformMethods = {
             return false;
           }
 
+          if (
+            types.JSXAttribute.check(parent) &&
+            parent.name === path.node &&
+            !parent.computed
+          ) {
+            // <Foo oldName={oldName} />
+            return false;
+          }
+
           return true;
         })
         .forEach(function(path) {
@@ -125,6 +134,21 @@ const transformMethods = {
             scope = scope.parent;
           }
           if (scope) { // identifier must refer to declared variable
+
+            // It may look like we filtered out properties, 
+            // but the filter only ignored property "keys", not "value"s
+            // In shorthand properties, "key" and "value" both have an
+            // Identifier with the same structure.
+            const parent = path.parent.node;
+            if (
+              types.Property.check(parent) &&
+              parent.shorthand &&
+              !parent.method
+            )  {
+
+              path.parent.get('shorthand').replace(false);
+            }
+
             path.get('name').replace(newName);
           }
         });

src/collections/__tests__/VariableDeclarator-test.js

@@ -53,6 +53,7 @@ describe('VariableDeclarators', function() {
       '    blah() {}',
       '  }',
       '}',
+      '<Component foo={foo} />',
     ].join('\n'), {parser: getParser()}).program];
   });
 
@@ -127,6 +128,48 @@ describe('VariableDeclarators', function() {
 
       expect(identifiers.length).toBe(1);
     });
+
+    it('properly renames a shorthand property that was using the old variable name', function() {
+      nodes = [recast.parse([
+        'var foo = 42;',
+        'var obj2 = {',
+        '  foo,',
+        '};',
+      ].join('\n'), {parser: getParser()}).program];
+
+      // Outputs:
+      // var newFoo = 42;
+      // var obj2 = {
+      //   foo: newFoo,
+      // };
+      Collection.fromNodes(nodes)
+        .findVariableDeclarators('foo').renameTo('newFoo');
+
+      expect(
+        Collection.fromNodes(nodes).find(types.Identifier, { name: 'newFoo' }).length
+      ).toBe(2);
+      expect(
+        Collection.fromNodes(nodes).find(types.Identifier, { name: 'foo' }).length
+      ).toBe(1);
+
+      expect(
+        Collection.fromNodes(nodes).find(types.Property).filter(prop => !prop.value.shorthand).length
+      ).toBe(1);
+      expect(
+        Collection.fromNodes(nodes).find(types.Property).filter(prop => prop.value.shorthand).length
+      ).toBe(0);
+    });
+
+    it('does not rename React component prop name', function () {
+      const declarators = Collection.fromNodes(nodes)
+        .findVariableDeclarators('foo')
+        .renameTo('xyz');
+
+      const identifiers = Collection.fromNodes(nodes)
+        .find(types.JSXIdentifier, { name: 'foo' });
+
+      expect(identifiers.length).toBe(1);
+    });
   });
 
 });

src/testUtils.js

@@ -93,8 +93,8 @@ function defineTest(dirName, transformName, options, testFilePrefix) {
 }
 exports.defineTest = defineTest;
 
-function defineInlineTest(module, options, input, expectedOutput) {
-  it('transforms correctly', () => {
+function defineInlineTest(module, options, input, expectedOutput, testName) {
+  it(testName || 'transforms correctly', () => {
     runInlineTest(module, options, {
       source: input
     }, expectedOutput);