Add option to export library as webgmex

src/client/gmeServerRequests.js

@@ -323,13 +323,14 @@ define(['common/Constants', 'common/regexp'], function (CONSTANTS, REGEXP) {
         }
 
         //package save
-        function exportProjectToFile(projectId, branchName, commitHash, withAssets, callback) {
+        function _exportProjectOrLibToFile(projectId, branchName, commitHash, withAssets, libraryName, callback) {
             var parameters = {
                 command: CONSTANTS.SERVER_WORKER_REQUESTS.EXPORT_PROJECT_TO_FILE,
-                projectId: projectId,
-                branchName: branchName,
-                commitHash: commitHash,
-                withAssets: withAssets
+                projectId,
+                branchName,
+                commitHash,
+                withAssets,
+                libraryName,
             };
 
             logger.debug('exportProjectToFile, parameters', parameters);
@@ -347,6 +348,10 @@ define(['common/Constants', 'common/regexp'], function (CONSTANTS, REGEXP) {
             }
         }
 
+        function exportProjectToFile(projectId, branchName, commitHash, withAssets, callback) {
+            _exportProjectOrLibToFile(projectId, branchName, commitHash, withAssets, undefined, callback);
+        }
+
         function exportSelectionToFile(projectId, commitHash, selectedIds, withAssets, callback) {
             var parameters = {
                 command: CONSTANTS.SERVER_WORKER_REQUESTS.EXPORT_SELECTION_TO_FILE,
@@ -407,6 +412,7 @@ define(['common/Constants', 'common/regexp'], function (CONSTANTS, REGEXP) {
                 autoMerge: autoMerge,
                 resolve: resolve,
                 exportProjectToFile: exportProjectToFile,
+                exportLibraryToFile: _exportProjectOrLibToFile,
                 exportSelectionToFile: exportSelectionToFile,
                 importSelectionFromFile: importSelectionFromFile
             },

src/common/util/serialization.js

@@ -36,6 +36,7 @@ define([
      * @param {boolean} [parameters.withAssets=false] - Bundle the encountered assets linked from attributes.
      * @param {string} [parameters.kind] - If not given will use the one defined in project (if any).
      * @param {string} [parameters.outName] - Name of the output blob (.webgmex will be appended).
+     * @param {string} [parameters.libraryName] - If provided - will export library as webgmex file.
      * @param {function} [callback]
      * @param {Error|null} callback.err - If there was an error
      * @param {object} callback.result - Data about the exported project
@@ -45,16 +46,47 @@ define([
      * @returns {Promise}
      */
     exports.exportProjectToFile = function exportProjectToFile(project, blobClient, parameters, callback) {
-        var fileName;
-
-        return storageUtils.getProjectJson(project, {
-            branchName: parameters.branchName,
-            commitHash: parameters.commitHash,
-            rootHash: parameters.rootHash,
-            tagName: parameters.tagName,
-            kind: parameters.kind
-        })
+        let fileName;
+        let libInfo;
+
+        return storageUtils.getRootHash(project, parameters)
+            .then(function (rootHash) {
+                if (!parameters.libraryName) {
+                    return {
+                        branchName: parameters.branchName,
+                        commitHash: parameters.commitHash,
+                        rootHash: parameters.rootHash,
+                        tagName: parameters.tagName,
+                        kind: parameters.kind
+                    };
+                }
+
+                const core = new Core(project, { globConf: project.gmeConfig, logger: project.logger });
+
+                return core.loadRoot(rootHash)
+                    .then(function (rootNode) {
+                        const libNode = core.getLibraryRoot(rootNode, parameters.libraryName);
+                        libInfo = core.getLibraryInfo(rootNode, parameters.libraryName);
+                        return { rootHash: core.getHash(libNode) };
+                    });
+            })
+            .then(function (exportContext) {
+                return storageUtils.getProjectJson(project, {
+                    branchName: exportContext.branchName,
+                    commitHash: exportContext.commitHash,
+                    rootHash: exportContext.rootHash,
+                    tagName: exportContext.tagName,
+                    kind: exportContext.kind
+                });
+            })
             .then(function (rawJson) {
+                if (parameters.libraryName) {
+                    // We need to adjust this when the exportee was a library.
+                    delete rawJson.kind; // This is lost at this point.
+                    rawJson.projectId = libInfo.projectId;
+                    rawJson.commitHash = libInfo.commitHash;
+                }
+
                 fileName = typeof parameters.outName === 'string' ?
                     parameters.outName :
                     rawJson.projectId + '_' + (rawJson.commitHash || '').substr(1, 6);
@@ -132,19 +164,19 @@ define([
                 closureInfo = core.getClosureInformation(nodes);
 
                 return Q.all(nodes.map(function (node) {
-                    return storageUtils.getProjectJson(project, {rootHash: core.getHash(node)});
+                    return storageUtils.getProjectJson(project, { rootHash: core.getHash(node) });
                 }));
             })
             .then(function (rawJsons) {
-                var output = {
-                        projectId: project.projectId,
-                        commitHash: parameters.commitHash,
-                        selectionInfo: closureInfo,
-                        kind: rawJsons[0].kind,
-                        objects: [],
-                        hashes: {objects: [], assets: []}
-                    },
-                    i;
+                const output = {
+                    projectId: project.projectId,
+                    commitHash: parameters.commitHash,
+                    selectionInfo: closureInfo,
+                    kind: rawJsons[0].kind,
+                    objects: [],
+                    hashes: { objects: [], assets: [] }
+                };
+                let i;
 
                 fileName = typeof parameters.outName === 'string' ?
                     parameters.outName :

src/server/worker/workerrequests.js

@@ -797,6 +797,7 @@ function WorkerRequests(mainLogger, gmeConfig, webgmeUrl) {
      * @param {string} [parameters.tagName] - The tree at the given tag.
      * @param {boolean} [parameters.withAssets=false] - Bundle the encountered assets linked from attributes.
      * @param {string} [parameters.kind] - If not given will use the one defined in project (if any).
+     * @param {string} [parameters.libraryName] - If provided - will export library as webgmex file.
      * @param {function} callback
      */
     function exportProjectToFile(webgmeToken, parameters, callback) {

test/server/worker/simpleworker.spec.js

@@ -69,6 +69,7 @@ describe('Simple worker', function () {
         constraintProjectImportResult,
         constraintProjectImportResult2,
         renameProjectImportResult,
+        libProjectImportResult,
 
         oldSend = process.send,
         oldOn = process.on,
@@ -207,12 +208,20 @@ describe('Simple worker', function () {
                         branchName: 'master',
                         logger: logger,
                         gmeConfig: gmeConfig
+                    }),
+                    testFixture.importProject(storage, {
+                        projectSeed: './test/plugin/PluginManagerBase/Lib.A.B.webgmex',
+                        projectName: 'LibraryProject',
+                        branchName: 'master',
+                        logger: logger,
+                        gmeConfig: gmeConfig
                     })
                 ]);
             })
             .then(function (result) {
                 constraintProjectImportResult = result[0];
                 constraintProjectImportResult2 = result[1];
+                libProjectImportResult = result[2];
 
                 return testFixture.importProject(storage, {
                     projectSeed: './test/common/core/users/rename/propagate.webgmex',
@@ -1742,6 +1751,64 @@ describe('Simple worker', function () {
             .nodeify(done);
     });
 
+    it('exportProjectToFile should export library when name provided', function (done) {
+        var worker = getSimpleWorker();
+
+        worker.send({command: CONSTANTS.workerCommands.initialize, gmeConfig: gmeConfig})
+            .then(function (msg) {
+                expect(msg.pid).equal(process.pid);
+                expect(msg.type).equal(CONSTANTS.msgTypes.initialized);
+
+                return worker.send({
+                    command: CONSTANTS.workerCommands.exportProjectToFile,
+                    projectId: libProjectImportResult.project.projectId,
+                    commitHash: libProjectImportResult.commitHash,
+                    libraryName: 'A'
+                });
+            })
+            .then(function (msg) {
+                expect(msg.pid).equal(process.pid);
+                expect(msg.type).equal(CONSTANTS.msgTypes.result);
+                expect(msg.error).equal(null);
+
+                expect(msg.result).not.equal(null);
+                expect(typeof msg.result).to.equal('object');
+                expect(msg.result.downloadUrl).to.include('/rest/blob/download/');
+                expect(msg.result.fileName).to.include('guest+A_');
+            })
+            .finally(restoreProcessFunctions)
+            .nodeify(done);
+    });
+
+    it('exportProjectToFile should export nested library when name provided', function (done) {
+        var worker = getSimpleWorker();
+
+        worker.send({command: CONSTANTS.workerCommands.initialize, gmeConfig: gmeConfig})
+            .then(function (msg) {
+                expect(msg.pid).equal(process.pid);
+                expect(msg.type).equal(CONSTANTS.msgTypes.initialized);
+
+                return worker.send({
+                    command: CONSTANTS.workerCommands.exportProjectToFile,
+                    projectId: libProjectImportResult.project.projectId,
+                    commitHash: libProjectImportResult.commitHash,
+                    libraryName: 'A.B'
+                });
+            })
+            .then(function (msg) {
+                expect(msg.pid).equal(process.pid);
+                expect(msg.type).equal(CONSTANTS.msgTypes.result);
+                expect(msg.error).equal(null);
+
+                expect(msg.result).not.equal(null);
+                expect(typeof msg.result).to.equal('object');
+                expect(msg.result.downloadUrl).to.include('/rest/blob/download/');
+                expect(msg.result.fileName).to.include('guest+B_');
+            })
+            .finally(restoreProcessFunctions)
+            .nodeify(done);
+    });
+
     it('should fail to exportProjectToFile when branchName does not exist.', function (done) {
         var worker = getSimpleWorker();