Support disabling extensions via .disabled file.

Extension can also be disabled using `"disable": true` in the package.json.

Details:
    - Rename getPackageJson to getMetadata.
    - Check for presence of .disabled file in the extension directory and add
      it to the metadata.
    - Do not load extension if it is disabled instead, reject with disabled
      status.
    - Add DISABLED extension state.
    - Extension is still gets on record and is enumerated with all its
      metadata, but it's not started.

Author: busykai

src/extensibility/ExtensionManager.js

@@ -67,6 +67,7 @@ define(function (require, exports, module) {
      * Extension status constants.
      */
     var ENABLED      = "enabled",
+        DISABLED     = "disabled",
         START_FAILED = "startFailed";
 
     /**
@@ -240,8 +241,9 @@ define(function (require, exports, module) {
      * @param {string} path The local path of the loaded extension's folder.
      */
     function _handleExtensionLoad(e, path) {
-        function setData(id, metadata) {
+        function setData(metadata) {
             var locationType,
+                id = metadata.name,
                 userExtensionPath = ExtensionLoader.getUserExtensionPath();
             if (path.indexOf(userExtensionPath) === 0) {
                 locationType = LOCATION_USER;
@@ -265,27 +267,33 @@ define(function (require, exports, module) {
                 metadata: metadata,
                 path: path,
                 locationType: locationType,
-                status: (e.type === "loadFailed" ? START_FAILED : ENABLED)
+                status: (e.type === "loadFailed" ? START_FAILED : (metadata.disabled ? DISABLED : ENABLED))
             };
 
             synchronizeEntry(id);
             loadTheme(id);
             exports.trigger("statusChange", id);
         }
+        
+        function deduceMetadata() {
+            var match = path.match(/\/([^\/]+)$/),
+                name = (match && match[1]) || path,
+                metadata = { name: name, title: name };
+            return metadata;
+        }
 
-        ExtensionUtils.loadPackageJson(path)
+        ExtensionUtils.loadMetadata(path)
             .done(function (metadata) {
-                setData(metadata.name, metadata);
+                setData(metadata);
             })
-            .fail(function () {
+            .fail(function (disabled) {
                 // If there's no package.json, this is a legacy extension. It was successfully loaded,
                 // but we don't have an official ID or metadata for it, so we just create an id and
                 // "title" for it (which is the last segment of its pathname)
                 // and record that it's enabled.
-                var match = path.match(/\/([^\/]+)$/),
-                    name = (match && match[1]) || path,
-                    metadata = { name: name, title: name };
-                setData(name, metadata);
+                var metadata = deduceMetadata();
+                metadata.disabled = disabled;
+                setData(metadata);
             });
     }
 
@@ -764,7 +772,8 @@ define(function (require, exports, module) {
     // Listen to extension load and loadFailed events
     ExtensionLoader
         .on("load", _handleExtensionLoad)
-        .on("loadFailed", _handleExtensionLoad);
+        .on("loadFailed", _handleExtensionLoad)
+        .on("disabled", _handleExtensionLoad);
 
 
     EventDispatcher.makeEventDispatcher(exports);

src/utils/ExtensionLoader.js

@@ -242,7 +242,7 @@ define(function (require, exports, module) {
         var promise = new $.Deferred();
 
         // Try to load the package.json to figure out if we are loading a theme.
-        ExtensionUtils.loadPackageJson(config.baseUrl).always(promise.resolve);
+        ExtensionUtils.loadMetadata(config.baseUrl).always(promise.resolve);
 
         return promise
             .then(function (metadata) {
@@ -251,12 +251,20 @@ define(function (require, exports, module) {
                     return;
                 }
 
-                return loadExtensionModule(name, config, entryPoint);
+                if (!metadata.disabled) {
+                    return loadExtensionModule(name, config, entryPoint);
+                } else {
+                    return new $.Deferred().resolve().reject("disabled");
+                }
             })
             .then(function () {
                 exports.trigger("load", config.baseUrl);
             }, function (err) {
-                exports.trigger("loadFailed", config.baseUrl);
+                if (err === "disabled") {
+                    exports.trigger("disabled", config.baseUrl);
+                } else {
+                    exports.trigger("loadFailed", config.baseUrl);
+                }
             });
     }
 

src/utils/ExtensionUtils.js

@@ -31,7 +31,8 @@
 define(function (require, exports, module) {
     "use strict";
 
-    var FileSystem = require("filesystem/FileSystem"),
+    var Async      = require("utils/Async"),
+        FileSystem = require("filesystem/FileSystem"),
         FileUtils  = require("file/FileUtils");
 
     /**
@@ -233,26 +234,51 @@ define(function (require, exports, module) {
     }
 
     /**
-     * Loads the package.json file in the given extension folder.
+     * Loads the package.json file in the given extension folder as well as any additional
+     * metadata.
+     * 
+     * If there's a .disabled file in the extension directory, then the content of package.json
+     * will be augmented with disabled property set to true. It will override whatever value of
+     * disabled might be set.
      *
      * @param {string} folder The extension folder.
      * @return {$.Promise} A promise object that is resolved with the parsed contents of the package.json file,
-     *     or rejected if there is no package.json or the contents are not valid JSON.
+     *     or rejected if there is no package.json with the boolean indicating whether .disabled file exists.
      */
-    function loadPackageJson(folder) {
-        var file = FileSystem.getFileForPath(folder + "/package.json"),
-            result = new $.Deferred();
-        FileUtils.readAsText(file)
-            .done(function (text) {
+    function loadMetadata(folder) {
+        var packageJSONFile = FileSystem.getFileForPath(folder + "/package.json"),
+            disabledFile = FileSystem.getFileForPath(folder + "/.disabled"),
+            result = new $.Deferred(),
+            jsonPromise = new $.Deferred(),
+            disabledPromise = new $.Deferred(),
+            json,
+            disabled;
+        FileUtils.readAsText(packageJSONFile)
+            .then(function (text) {
                 try {
-                    var json = JSON.parse(text);
-                    result.resolve(json);
+                    json = JSON.parse(text);
+                    jsonPromise.resolve();
                 } catch (e) {
-                    result.reject();
+                    jsonPromise.reject();
                 }
             })
-            .fail(function () {
-                result.reject();
+            .fail(jsonPromise.reject);
+        disabledFile.exists(function (err, exists) {
+            if (err) {
+                disabled = false;
+            } else {
+                disabled = exists;
+            }
+            disabledPromise.resolve();
+        });
+        Async.waitForAll([jsonPromise, disabledPromise])
+            .always(function () {
+                if (!json) {
+                    result.reject(disabled);
+                } else {
+                    json.disabled = disabled;
+                    result.resolve(json);
+                }
             });
         return result.promise();
     }
@@ -264,5 +290,5 @@ define(function (require, exports, module) {
     exports.getModuleUrl          = getModuleUrl;
     exports.loadFile              = loadFile;
     exports.loadStyleSheet        = loadStyleSheet;
-    exports.loadPackageJson       = loadPackageJson;
+    exports.loadMetadata          = loadMetadata;
 });