Merge pull request #8475 from atom/ns-rebuild-packages

Add API for rebuilding native modules of packages

spec/package-spec.coffee

@@ -7,6 +7,10 @@ describe "Package", ->
   describe "when the package contains incompatible native modules", ->
     beforeEach ->
       spyOn(atom, 'inDevMode').andReturn(false)
+      items = {}
+      spyOn(global.localStorage, 'setItem').andCallFake (key, item) -> items[key] = item; undefined
+      spyOn(global.localStorage, 'getItem').andCallFake (key) -> items[key] ? null
+      spyOn(global.localStorage, 'removeItem').andCallFake (key) -> delete items[key]; undefined
 
     it "does not activate it", ->
       packagePath = atom.project.getDirectories()[0]?.resolve('packages/package-with-incompatible-native-module')
@@ -17,14 +21,6 @@ describe "Package", ->
 
     it "caches the incompatible native modules in local storage", ->
       packagePath = atom.project.getDirectories()[0]?.resolve('packages/package-with-incompatible-native-module')
-      cacheKey = null
-      cacheItem = null
-
-      spyOn(global.localStorage, 'setItem').andCallFake (key, item) ->
-        cacheKey = key
-        cacheItem = item
-      spyOn(global.localStorage, 'getItem').andCallFake (key) ->
-        return cacheItem if cacheKey is key
 
       expect(new Package(packagePath).isCompatible()).toBe false
       expect(global.localStorage.getItem.callCount).toBe 1
@@ -34,6 +30,71 @@ describe "Package", ->
       expect(global.localStorage.getItem.callCount).toBe 2
       expect(global.localStorage.setItem.callCount).toBe 1
 
+  describe "::rebuild()", ->
+    beforeEach ->
+      spyOn(atom, 'inDevMode').andReturn(false)
+      items = {}
+      spyOn(global.localStorage, 'setItem').andCallFake (key, item) -> items[key] = item; undefined
+      spyOn(global.localStorage, 'getItem').andCallFake (key) -> items[key] ? null
+      spyOn(global.localStorage, 'removeItem').andCallFake (key) -> delete items[key]; undefined
+
+    it "returns a promise resolving to the results of `apm rebuild`", ->
+      packagePath = atom.project.getDirectories()[0]?.resolve('packages/package-with-index')
+      pack = new Package(packagePath)
+      rebuildCallbacks = []
+      spyOn(pack, 'runRebuildProcess').andCallFake ((callback) -> rebuildCallbacks.push(callback))
+
+      promise = pack.rebuild()
+      rebuildCallbacks[0]({code: 0, stdout: 'stdout output', stderr: 'stderr output'})
+
+      waitsFor (done) ->
+        promise.then (result) ->
+          expect(result).toEqual {code: 0, stdout: 'stdout output', stderr: 'stderr output'}
+          done()
+
+    it "persists build failures in local storage", ->
+      packagePath = atom.project.getDirectories()[0]?.resolve('packages/package-with-index')
+      pack = new Package(packagePath)
+
+      expect(pack.isCompatible()).toBe true
+      expect(pack.getBuildFailureOutput()).toBeNull()
+
+      rebuildCallbacks = []
+      spyOn(pack, 'runRebuildProcess').andCallFake ((callback) -> rebuildCallbacks.push(callback))
+
+      pack.rebuild()
+      rebuildCallbacks[0]({code: 13, stderr: 'It is broken'})
+
+      expect(pack.getBuildFailureOutput()).toBe 'It is broken'
+      expect(pack.getIncompatibleNativeModules()).toEqual []
+      expect(pack.isCompatible()).toBe false
+
+      # A different package instance has the same failure output (simulates reload)
+      pack2 = new Package(packagePath)
+      expect(pack2.getBuildFailureOutput()).toBe 'It is broken'
+      expect(pack2.isCompatible()).toBe false
+
+      # Clears the build failure after a successful build
+      pack.rebuild()
+      rebuildCallbacks[1]({code: 0, stdout: 'It worked'})
+
+      expect(pack.getBuildFailureOutput()).toBeNull()
+      expect(pack2.getBuildFailureOutput()).toBeNull()
+
+    it "sets cached incompatible modules to an empty array when the rebuild completes (there may be a build error, but rebuilding *deletes* native modules)", ->
+      packagePath = atom.project.getDirectories()[0]?.resolve('packages/package-with-incompatible-native-module')
+      pack = new Package(packagePath)
+
+      expect(pack.getIncompatibleNativeModules().length).toBeGreaterThan(0)
+
+      rebuildCallbacks = []
+      spyOn(pack, 'runRebuildProcess').andCallFake ((callback) -> rebuildCallbacks.push(callback))
+
+      pack.rebuild()
+      expect(pack.getIncompatibleNativeModules().length).toBeGreaterThan(0)
+      rebuildCallbacks[0]({code: 0, stdout: 'It worked'})
+      expect(pack.getIncompatibleNativeModules().length).toBe(0)
+
   describe "theme", ->
     theme = null
 

src/package.coffee

@@ -11,6 +11,7 @@ Q = require 'q'
 
 ModuleCache = require './module-cache'
 ScopedProperties = require './scoped-properties'
+BufferedProcess = require './buffered-process'
 
 packagesCache = require('../package.json')?._atomPackages ? {}
 
@@ -603,6 +604,70 @@ class Package
     traversePath(path.join(@path, 'node_modules'))
     nativeModulePaths
 
+  ###
+  Section: Native Module Compatibility
+  ###
+
+  # Extended: Are all native modules depended on by this package correctly
+  # compiled against the current version of Atom?
+  #
+  # Incompatible packages cannot be activated.
+  #
+  # Returns a {Boolean}, true if compatible, false if incompatible.
+  isCompatible: ->
+    return @compatible if @compatible?
+
+    if @path.indexOf(path.join(atom.packages.resourcePath, 'node_modules') + path.sep) is 0
+      # Bundled packages are always considered compatible
+      @compatible = true
+    else if @getMainModulePath()
+      @incompatibleModules = @getIncompatibleNativeModules()
+      @compatible = @incompatibleModules.length is 0 and not @getBuildFailureOutput()?
+    else
+      @compatible = true
+
+  # Extended: Rebuild native modules in this package's dependencies for the
+  # current version of Atom.
+  #
+  # Returns a {Promise} that resolves with an object containing `code`,
+  # `stdout`, and `stderr` properties based on the results of running
+  # `apm rebuild` on the package.
+  rebuild: ->
+    new Promise (resolve) =>
+      @runRebuildProcess (result) =>
+        if result.code is 0
+          global.localStorage.removeItem(@getBuildFailureOutputStorageKey())
+        else
+          @compatible = false
+          global.localStorage.setItem(@getBuildFailureOutputStorageKey(), result.stderr)
+        global.localStorage.setItem(@getIncompatibleNativeModulesStorageKey(), '[]')
+        resolve(result)
+
+  # Extended: If a previous rebuild failed, get the contents of stderr.
+  #
+  # Returns a {String} or null if no previous build failure occurred.
+  getBuildFailureOutput: ->
+    global.localStorage.getItem(@getBuildFailureOutputStorageKey())
+
+  runRebuildProcess: (callback) ->
+    stderr = ''
+    stdout = ''
+    new BufferedProcess({
+      command: atom.packages.getApmPath()
+      args: ['rebuild', '--no-color']
+      options: {cwd: @path}
+      stderr: (output) -> stderr += output
+      stdout: (output) -> stdout += output
+      exit: (code) -> callback({code, stdout, stderr})
+    })
+
+  getBuildFailureOutputStorageKey: ->
+    "installed-packages:#{@name}:#{@metadata.version}:build-error"
+
+  getIncompatibleNativeModulesStorageKey: ->
+    electronVersion = process.versions['electron'] ? process.versions['atom-shell']
+    "installed-packages:#{@name}:#{@metadata.version}:electron-#{electronVersion}:incompatible-native-modules"
+
   # Get the incompatible native modules that this package depends on.
   # This recurses through all dependencies and requires all modules that
   # contain a `.node` file.
@@ -610,11 +675,10 @@ class Package
   # This information is cached in local storage on a per package/version basis
   # to minimize the impact on startup time.
   getIncompatibleNativeModules: ->
-    localStorageKey = "installed-packages:#{@name}:#{@metadata.version}"
     unless atom.inDevMode()
       try
-        {incompatibleNativeModules} = JSON.parse(global.localStorage.getItem(localStorageKey)) ? {}
-      return incompatibleNativeModules if incompatibleNativeModules?
+        if arrayAsString = global.localStorage.getItem(@getIncompatibleNativeModulesStorageKey())
+          return JSON.parse(arrayAsString)
 
     incompatibleNativeModules = []
     for nativeModulePath in @getNativeModuleDependencyPaths()
@@ -629,28 +693,9 @@ class Package
           version: version
           error: error.message
 
-    global.localStorage.setItem(localStorageKey, JSON.stringify({incompatibleNativeModules}))
+    global.localStorage.setItem(@getIncompatibleNativeModulesStorageKey(), JSON.stringify(incompatibleNativeModules))
     incompatibleNativeModules
 
-  # Public: Is this package compatible with this version of Atom?
-  #
-  # Incompatible packages cannot be activated. This will include packages
-  # installed to ~/.atom/packages that were built against node 0.11.10 but
-  # now need to be upgrade to node 0.11.13.
-  #
-  # Returns a {Boolean}, true if compatible, false if incompatible.
-  isCompatible: ->
-    return @compatible if @compatible?
-
-    if @path.indexOf(path.join(atom.packages.resourcePath, 'node_modules') + path.sep) is 0
-      # Bundled packages are always considered compatible
-      @compatible = true
-    else if @getMainModulePath()
-      @incompatibleModules = @getIncompatibleNativeModules()
-      @compatible = @incompatibleModules.length is 0
-    else
-      @compatible = true
-
   handleError: (message, error) ->
     if error.filename and error.location and (error instanceof SyntaxError)
       location = "#{error.filename}:#{error.location.first_line + 1}:#{error.location.first_column + 1}"