cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ste...@apache.org
Subject [2/3] git commit: CB-7190: Add browserify support in cordova-lib/cordova-cli
Date Mon, 04 Aug 2014 22:53:15 GMT
CB-7190: Add browserify support in cordova-lib/cordova-cli


Project: http://git-wip-us.apache.org/repos/asf/cordova-lib/repo
Commit: http://git-wip-us.apache.org/repos/asf/cordova-lib/commit/c2dd20cd
Tree: http://git-wip-us.apache.org/repos/asf/cordova-lib/tree/c2dd20cd
Diff: http://git-wip-us.apache.org/repos/asf/cordova-lib/diff/c2dd20cd

Branch: refs/heads/master
Commit: c2dd20cd2781500b5f2136b4b58f1a17c8d1da18
Parents: a6d23ed
Author: Suraj Pindoria <suraj.pindoria@yahoo.com>
Authored: Tue Jul 29 11:51:31 2014 -0700
Committer: Steven Gill <stevengill97@gmail.com>
Committed: Mon Aug 4 15:52:12 2014 -0700

----------------------------------------------------------------------
 .../spec-plugman/install-browserify.spec.js     | 505 +++++++++++++++++++
 .../spec-plugman/uninstall-browserify.spec.js   | 309 ++++++++++++
 cordova-lib/src/cordova/plugin.js               |   1 +
 cordova-lib/src/plugman/install.js              |   6 +-
 cordova-lib/src/plugman/plugman.js              |   1 +
 cordova-lib/src/plugman/prepare-browserify.js   |   2 +-
 cordova-lib/src/plugman/uninstall.js            |  10 +-
 7 files changed, 829 insertions(+), 5 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cordova-lib/blob/c2dd20cd/cordova-lib/spec-plugman/install-browserify.spec.js
----------------------------------------------------------------------
diff --git a/cordova-lib/spec-plugman/install-browserify.spec.js b/cordova-lib/spec-plugman/install-browserify.spec.js
new file mode 100644
index 0000000..1731707
--- /dev/null
+++ b/cordova-lib/spec-plugman/install-browserify.spec.js
@@ -0,0 +1,505 @@
+// /**
+//     Licensed to the Apache Software Foundation (ASF) under one
+//     or more contributor license agreements.  See the NOTICE file
+//     distributed with this work for additional information
+//     regarding copyright ownership.  The ASF licenses this file
+//     to you under the Apache License, Version 2.0 (the
+//     "License"); you may not use this file except in compliance
+//     with the License.  You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+//     Unless required by applicable law or agreed to in writing,
+//     software distributed under the License is distributed on an
+//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+//     KIND, either express or implied.  See the License for the
+//     specific language governing permissions and limitations
+//     under the License.
+// */
+var install = require('../src/plugman/install'),
+    actions = require('../src/plugman/util/action-stack'),
+    config_changes = require('../src/plugman/util/config-changes'),
+    xml_helpers = require('../src/util/xml-helpers'),
+    events  = require('../src/events'),
+    plugman = require('../src/plugman/plugman'),
+    browserify = require('../src/plugman/prepare-browserify'),
+    platforms = require('../src/plugman/platforms/common'),
+    common  = require('./common'),
+    fs      = require('fs'),
+    os      = require('os'),
+    path    = require('path'),
+    shell   = require('shelljs'),
+    child_process = require('child_process'),
+    semver  = require('semver'),
+    Q = require('q'),
+    spec    = __dirname,
+    done    = false,
+    srcProject = path.join(spec, 'projects', 'android_install'),
+    temp_dir = path.join(os.tmpdir(), 'plugman-test'),
+    project = path.join(temp_dir, 'android_install'),
+    plugins_dir = path.join(spec, 'plugins'),
+    plugins_install_dir = path.join(project, 'cordova', 'plugins'),
+    plugins = {
+        'DummyPlugin' : path.join(plugins_dir, 'DummyPlugin'),
+        'EnginePlugin' : path.join(plugins_dir, 'EnginePlugin'),
+        'EnginePluginAndroid' : path.join(plugins_dir, 'EnginePluginAndroid'),
+        'ChildBrowser' : path.join(plugins_dir, 'ChildBrowser'),
+        'VariablePlugin' : path.join(plugins_dir, 'VariablePlugin'),
+        'A' : path.join(plugins_dir, 'dependencies', 'A'),
+        'B' : path.join(plugins_dir, 'dependencies', 'B'),
+        'C' : path.join(plugins_dir, 'dependencies', 'C'),
+        'F' : path.join(plugins_dir, 'dependencies', 'F'),
+        'G' : path.join(plugins_dir, 'dependencies', 'G')
+    },
+    promise,
+    results = {},
+    dummy_id = 'com.phonegap.plugins.dummyplugin';
+
+
+// Pre-crete the temp dir, without it the test fails.
+shell.mkdir('-p', temp_dir);
+
+function installPromise(f) {
+  f.then(function(res) { done = true; }, function(err) { done = err; });
+}
+
+var existsSync = fs.existsSync;
+
+// Mocked functions for tests
+var fake = {
+    'existsSync' : {
+        'noPlugins' : function(path){
+            // fake installed plugin directories as 'not found'
+            if( path.slice(-5) !== '.json' && path.indexOf(plugins_install_dir) >=
0) {
+                return false;
+            }
+
+            return existsSync(path);
+        }
+    },
+    'fetch' : {
+        'dependencies' : function(id, dir) {
+            if(id == plugins['A'])
+                return Q(id); // full path to plugin
+
+            return Q( path.join(plugins_dir, 'dependencies', id) );
+        }
+    }
+}
+
+describe('start', function() {
+    var prepare, prepareBrowserify, config_queue_add, proc, actions_push, ca, emit, write;
+
+    beforeEach(function() {
+        prepare = spyOn(plugman, 'prepare');
+        prepareBrowserify = spyOn(plugman, 'prepareBrowserify');
+        config_queue_add = spyOn(config_changes, 'add_installed_plugin_to_prepare_queue');
+        proc = spyOn(actions.prototype, 'process').andReturn( Q(true) );
+        actions_push = spyOn(actions.prototype, 'push');
+        ca = spyOn(actions.prototype, 'createAction');
+    });
+    it('start', function() {
+        shell.rm('-rf', project);
+        shell.cp('-R', path.join(srcProject, '*'), project);
+
+        done = false;
+        promise = Q()
+         .then(
+            function(){ return install('android', project, plugins['DummyPlugin'], plugins_install_dir,
{ browserify: true }) }
+        ).then(
+            function(){
+                results['actions_callCount'] = actions_push.callCount;
+                results['actions_create'] = ca.argsForCall[0];
+                results['config_add'] = config_queue_add.argsForCall[0];
+
+                return Q();
+            }
+        ).then(
+            function(){ 
+                return install('android', project, plugins['EnginePlugin'], plugins_install_dir,
{ browserify: true }) }
+        ).then(
+            function(){
+                emit = spyOn(events, 'emit');
+                return install('android', project, plugins['ChildBrowser'], plugins_install_dir,
{ browserify: true })
+            }
+        ).then(
+            function(){
+                return install('android', project, plugins['VariablePlugin'], plugins_install_dir,
{ browserify: true, cli_variables:{API_KEY:'batman'} })
+            }
+        ).then(
+            function(){
+                done = true;
+                results['prepareCount'] = prepareBrowserify.callCount;
+                results['emit_results'] = [];
+
+                for(var i in emit.calls) {
+                    if(emit.calls[i].args[0] === 'results')
+                        results['emit_results'].push(emit.calls[i].args[1]);
+                }
+
+                events.emit("verbose", "***** DONE START *****");
+            }
+        ).fail(
+            function(error) {
+                expect(error).toBeUndefined();
+            }
+        );
+        waitsFor(function() { return done; }, 'promise never resolved', 500);
+    });
+});
+
+describe('install', function() {
+    var chmod, exec, proc, add_to_queue, prepare, actions_push, c_a, mkdir, cp, rm, fetchSpy,
emit;
+
+    beforeEach(function() {
+        prepare = spyOn(plugman, 'prepare').andReturn( Q(true) );
+        prepareBrowserify = spyOn(plugman, 'prepareBrowserify');
+        exec = spyOn(child_process, 'exec').andCallFake(function(cmd, cb) {
+
+            cb(false, '', '');
+        });
+        spyOn(fs, 'mkdirSync').andReturn(true);
+        spyOn(shell, 'mkdir').andReturn(true);
+        spyOn(platforms, 'copyFile').andReturn(true);
+
+        fetchSpy = spyOn(plugman.raw, 'fetch').andReturn( Q( plugins['EnginePlugin'] ) );
+        chmod = spyOn(fs, 'chmodSync').andReturn(true);
+        fsWrite = spyOn(fs, 'writeFileSync').andReturn(true);
+        cp = spyOn(shell, 'cp').andReturn(true);
+        rm = spyOn(shell, 'rm').andReturn(true);
+        add_to_queue = spyOn(config_changes, 'add_installed_plugin_to_prepare_queue');
+        done = false;
+    });
+
+    describe('success', function() {
+        it('should call prepare after a successful install', function() {
+           expect(results['prepareCount']).toBe(4);
+        });
+
+        it('should emit a results event with platform-agnostic <info>', function()
{
+            // ChildBrowser
+            expect(results['emit_results'][0]).toBe('No matter what platform you are installing
to, this notice is very important.');
+        });
+        it('should emit a results event with platform-specific <info>', function()
{
+            // ChildBrowser
+            expect(results['emit_results'][1]).toBe('Please make sure you read this because
it is very important to complete the installation of your plugin.');
+        });
+        it('should interpolate variables into <info> tags', function() {
+            // VariableBrowser
+            expect(results['emit_results'][2]).toBe('Remember that your api key is batman!');
+        });
+
+        it('should call fetch if provided plugin cannot be resolved locally', function()
{
+            fetchSpy.andReturn( Q( plugins['DummyPlugin'] ) );
+            spyOn(fs, 'existsSync').andCallFake( fake['existsSync']['noPlugins'] );
+
+            runs(function() {
+                installPromise(install('android', project, 'CLEANYOURSHORTS', plugins_dir,
{ browserify: true } ));
+            });
+            waitsFor(function() { return done; }, 'install promise never resolved', 200);
+            runs(function() {
+                expect(done).toBe(true);
+                expect(fetchSpy).toHaveBeenCalled();
+            });
+        });
+
+        it('should call the config-changes module\'s add_installed_plugin_to_prepare_queue
method after processing an install', function() {
+           expect(results['config_add']).toEqual([plugins_install_dir, dummy_id, 'android',
{}, true]);
+        });
+        it('should queue up actions as appropriate for that plugin and call process on the
action stack',
+           function() {
+                expect(results['actions_callCount']).toEqual(3);
+                expect(results['actions_create']).toEqual([jasmine.any(Function), [jasmine.any(Object),
path.join(plugins_install_dir, dummy_id), project, dummy_id], jasmine.any(Function), [jasmine.any(Object),
project, dummy_id]]);
+        });
+
+        it('should check version if plugin has engine tag', function(){
+            var satisfies = spyOn(semver, 'satisfies').andReturn(true);
+            exec.andCallFake(function(cmd, cb) {
+                cb(null, '2.5.0\n');
+            });
+
+            runs(function() {
+                installPromise( install('android', project, plugins['EnginePlugin'], plugins_install_dir,
{ browserify: true }) );
+            });
+            waitsFor(function() { return done; }, 'install promise never resolved', 200);
+            runs(function() {
+                expect(satisfies).toHaveBeenCalledWith('2.5.0','>=2.3.0');
+            });
+        });
+        it('should check version and munge it a little if it has "rc" in it so it plays nice
with semver (introduce a dash in it)', function() {
+            var satisfies = spyOn(semver, 'satisfies').andReturn(true);
+            exec.andCallFake(function(cmd, cb) {
+                cb(null, '3.0.0rc1\n');
+            });
+
+            runs(function() {
+                installPromise( install('android', project, plugins['EnginePlugin'], plugins_install_dir,
{ browserify: true }) );
+            });
+            waitsFor(function() { return done; }, 'install promise never resolved', 200);
+            runs(function() {
+                expect(satisfies).toHaveBeenCalledWith('3.0.0-rc1','>=2.3.0');
+            });
+        });
+        it('should check specific platform version over cordova version if specified', function()
{
+            var spy = spyOn(semver, 'satisfies').andReturn(true);
+            exec.andCallFake(function(cmd, cb) {
+                cb(null, '3.1.0\n');
+            });
+            fetchSpy.andReturn( Q( plugins['EnginePluginAndroid'] ) );
+
+            runs(function() {
+                installPromise( install('android', project, plugins['EnginePluginAndroid'],
plugins_install_dir, { browserify: true }) );
+            });
+            waitsFor(function() { return done; }, 'install promise never resolved', 200);
+            runs(function() {
+                expect(spy).toHaveBeenCalledWith('3.1.0','>=3.1.0');
+            });
+        });
+        it('should check platform sdk version if specified', function() {
+            var spy = spyOn(semver, 'satisfies').andReturn(true);
+            fetchSpy.andReturn( Q( plugins['EnginePluginAndroid'] ) );
+            exec.andCallFake(function(cmd, cb) {
+                cb(null, '18\n');
+            });
+
+            runs(function() {
+                installPromise( install('android', project, 'EnginePluginAndroid', plugins_install_dir,
{ browserify: true }) );
+            });
+            waitsFor(function() { return done; }, 'install promise never resolved', 200);
+            runs(function() {
+                // <engine name="cordova" VERSION=">=3.0.0"/>
+                // <engine name="cordova-android" VERSION=">=3.1.0"/>
+                // <engine name="android-sdk" VERSION=">=18"/>
+
+                expect(spy.calls.length).toBe(3);
+                expect(spy.calls[0].args).toEqual([ '18.0.0', '>=3.0.0' ]);
+                expect(spy.calls[1].args).toEqual([ '18.0.0', '>=3.1.0' ]);
+                expect(spy.calls[2].args).toEqual([ '18.0.0','>=18' ]);
+            });
+        });
+        it('should check engine versions', function() {
+            var spy = spyOn(semver, 'satisfies').andReturn(true);
+            fetchSpy.andReturn( Q( plugins['EnginePlugin'] ) );
+
+            runs(function() {
+                installPromise( install('android', project, plugins['EnginePlugin'], plugins_install_dir,
{ browserify: true }) );
+            });
+            waitsFor(function() { return done; }, 'install promise never resolved', 200);
+            runs(function() {
+                // <engine name="cordova" version=">=2.3.0"/>
+                // <engine name="cordova-plugman" version=">=0.10.0" />
+                // <engine name="mega-fun-plugin" version=">=1.0.0" scriptSrc="megaFunVersion"
platform="*" />
+                // <engine name="mega-boring-plugin" version=">=3.0.0" scriptSrc="megaBoringVersion"
platform="ios|android" />
+
+                var plugmanVersion = require('../package.json').version;
+
+                expect(spy.calls.length).toBe(4);
+                expect(spy.calls[0].args).toEqual([ null, '>=2.3.0' ]);
+                expect(spy.calls[1].args).toEqual([ plugmanVersion, '>=0.10.0' ]);
+                expect(spy.calls[2].args).toEqual([ null, '>=1.0.0' ]);
+                expect(spy.calls[3].args).toEqual([ null, '>=3.0.0' ]);
+            });
+        });
+        it('should not check custom engine version that is not supported for platform', function()
{
+            var spy = spyOn(semver, 'satisfies').andReturn(true);
+            runs(function() {
+                installPromise( install('blackberry10', project, plugins['EnginePlugin'],
plugins_install_dir, { browserify: true }) );
+            });
+            waitsFor(function() { return done; }, 'install promise never resolved', 200);
+            runs(function() {
+                expect(spy).not.toHaveBeenCalledWith('','>=3.0.0');
+            });
+        });
+
+        describe('with dependencies', function() {
+            var emit;
+            beforeEach(function() {
+                spyOn(fs, 'existsSync').andCallFake( fake['existsSync']['noPlugins'] );
+                fetchSpy.andCallFake( fake['fetch']['dependencies'] );
+                emit = spyOn(events, 'emit');
+                exec.andCallFake(function(cmd, cb) {
+                    cb(null, '9.0.0\n');
+                });
+            });
+
+            it('should install any dependent plugins if missing', function() {
+                runs(function() {
+                    installPromise( install('android', project, plugins['A'], plugins_install_dir,
{ browserify: true }) );
+                });
+                waitsFor(function() { return done; }, 'install promise never resolved', 200);
+                runs(function() {
+                    // Look for 'Installing plugin ...' in events
+                    var install = common.spy.getInstall(emit);
+
+                    expect(install).toEqual([
+                        'Install start for "C" on android.',
+                        'Install start for "D" on android.',
+                        'Install start for "A" on android.'
+                    ]);
+                });
+            });
+
+            it('should install any dependent plugins from registry when url is not defined',
function() {
+                // Plugin A depends on C & D
+                runs(function() {
+                    installPromise( install('android', project, plugins['A'], plugins_install_dir,
{ browserify: true }) );
+                });
+                waitsFor(function() { return done; }, 'promise never resolved', 200);
+                runs(function() {
+                    // TODO: this is same test as above? Need test other dependency with
url=?
+                    var install = common.spy.getInstall(emit);
+
+                    expect(install).toEqual([
+                        'Install start for "C" on android.',
+                        'Install start for "D" on android.',
+                        'Install start for "A" on android.'
+                    ]);;
+                });
+            });
+
+            it('should process all dependent plugins with alternate routes to the same plugin',
function() {
+                // Plugin F depends on A, C, D and E
+                runs(function () {
+                    installPromise(install('android', project, plugins['F'], plugins_install_dir,
{ browserify: true }));
+                });
+                waitsFor(function () { return done; }, 'install promise never resolved',
200);
+                runs(function () {
+                    var install = common.spy.getInstall(emit);
+
+                    expect(install).toEqual([
+                        'Install start for "C" on android.',
+                        'Install start for "D" on android.',
+                        'Install start for "A" on android.',
+                        'Install start for "D" on android.',
+                        'Install start for "F" on android.'
+                    ]);
+                });
+            });
+
+            it('should throw if there is a cyclic dependency', function() {
+                runs(function () {
+                    installPromise( install('android', project, plugins['G'], plugins_install_dir,
{ browserify: true }) );
+                });
+                waitsFor(function () { return done; }, 'install promise never resolved',
200);
+                runs(function () {
+                    var install = common.spy.getInstall(emit);
+
+                    expect(done.message).toEqual('Cyclic dependency from G to H');
+                });
+            });
+
+            it('install subdir relative to top level plugin if no fetch meta', function()
{
+                runs(function () {
+                    installPromise(install('android', project, plugins['B'], plugins_install_dir,
{ browserify: true }));
+                });
+                waitsFor(function () { return done; }, 'install promise never resolved',
200);
+                runs(function () {
+                    var install = common.spy.getInstall(emit);
+
+                    expect(install).toEqual([
+                        'Install start for "D" on android.',
+                        'Install start for "E" on android.',
+                        'Install start for "B" on android.'
+                    ]);
+                });
+            });
+
+            it('install uses meta data (if available) of top level plugin source', function()
{
+                // Fake metadata so plugin 'B' appears from 'meta/B'
+                var meta = require('../src/plugman/util/metadata');
+                spyOn(meta, 'get_fetch_metadata').andCallFake(function(){
+                    return {
+                        source: {type: 'dir', url: path.join(plugins['B'], '..', 'meta')}
+                    };
+                });
+
+                runs(function () {
+                    installPromise(install('android', project, plugins['B'], plugins_install_dir,
{ browserify: true }));
+                });
+                waitsFor(function () { return done; }, 'install promise never resolved',
200);
+                runs(function () {
+                    var install = common.spy.getInstall(emit);
+
+                    expect(install).toEqual([
+                        'Install start for "D" on android.',
+                        'Install start for "E" on android.',
+                        'Install start for "B" on android.'
+                    ]);
+
+                    var copy = common.spy.startsWith(emit, "Copying from");
+                    expect(copy.length).toBe(3);
+                    expect(copy[0].indexOf(path.normalize('meta/D')) > 0).toBe(true);
+                    expect(copy[1].indexOf(path.normalize('meta/subdir/E')) > 0).toBe(true);
+                });
+            });
+        });
+
+    });
+
+    describe('failure', function() {
+        it('should throw if platform is unrecognized', function() {
+            runs(function() {
+                installPromise( install('atari', project, 'SomePlugin', plugins_install_dir,
{ browserify: true }) );
+            });
+            waitsFor(function() { return done; }, 'install promise never resolved', 200);
+            runs(function() {
+                expect(''+done).toContain('atari not supported.');
+            });
+        });
+        it('should throw if variables are missing', function() {
+            runs(function() {
+                installPromise( install('android', project, plugins['VariablePlugin'], plugins_install_dir,
{ browserify: true }) );
+            });
+            waitsFor(function(){ return done; }, 'install promise never resolved', 200);
+            runs(function() {
+                expect(''+done).toContain('Variable(s) missing: API_KEY');
+            });
+        });
+        it('should throw if git is not found on the path and a remote url is requested',
function() {
+            spyOn(fs, 'existsSync').andCallFake( fake['existsSync']['noPlugins'] );
+            fetchSpy.andCallThrough();
+            var which_spy = spyOn(shell, 'which').andReturn(null);
+            runs(function() {
+                installPromise( install('android', project, 'https://git-wip-us.apache.org/repos/asf/cordova-plugin-camera.git',
plugins_install_dir, { browserify: true }) );
+            });
+            waitsFor(function(){ return done; }, 'install promise never resolved', 200);
+            runs(function() {
+                expect(''+done).toContain('"git" command line tool is not installed: make
sure it is accessible on your PATH.');
+            });
+        });
+        it('should throw if plugin version is less than the minimum requirement', function(){
+            var spy = spyOn(semver, 'satisfies').andReturn(false);
+            exec.andCallFake(function(cmd, cb) {
+                cb(null, '0.0.1\n');
+            });
+            runs(function() {
+                installPromise( install('android', project, plugins['EnginePlugin'], plugins_install_dir,
{ browserify: true }) );
+            });
+            waitsFor(function(){ return done; }, 'install promise never resolved', 200);
+            runs(function() {
+                expect(''+done).toContain('Plugin doesn\'t support this project\'s cordova
version. cordova: 0.0.1, failed version requirement: >=2.3.0');
+            });
+        });
+    });
+
+});
+
+// When run using 'npm test', the removal of temp_dir is causing
+// tests in 'install.spec.js' to fail.
+
+// describe('end', function() {
+
+//     it('end', function() {
+//         done = false;
+
+//         promise.fin(function(err){
+//             if(err)
+//                 events.emit('error', err);
+
+//             shell.rm('-rf', temp_dir);
+//             done = true;
+//         });
+
+//         waitsFor(function() { return done; }, 'promise never resolved', 500);
+//     });
+// });

http://git-wip-us.apache.org/repos/asf/cordova-lib/blob/c2dd20cd/cordova-lib/spec-plugman/uninstall-browserify.spec.js
----------------------------------------------------------------------
diff --git a/cordova-lib/spec-plugman/uninstall-browserify.spec.js b/cordova-lib/spec-plugman/uninstall-browserify.spec.js
new file mode 100644
index 0000000..4960dc8
--- /dev/null
+++ b/cordova-lib/spec-plugman/uninstall-browserify.spec.js
@@ -0,0 +1,309 @@
+/**
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+*/
+var uninstall = require('../src/plugman/uninstall'),
+    install = require('../src/plugman/install'),
+    actions = require('../src/plugman/util/action-stack'),
+    config_changes = require('../src/plugman/util/config-changes'),
+    events  = require('../src/events'),
+    plugman = require('../src/plugman/plugman'),
+    common  = require('./common'),
+    fs      = require('fs'),
+    path    = require('path'),
+    shell   = require('shelljs'),
+    Q       = require('q'),
+    spec    = __dirname,
+    done    = false,
+    srcProject = path.join(spec, 'projects', 'android_uninstall'),
+    project = path.join(spec, 'projects', 'android_uninstall.test'),
+    project2 = path.join(spec, 'projects', 'android_uninstall.test2'),
+
+    plugins_dir = path.join(spec, 'plugins'),
+    plugins_install_dir = path.join(project, 'cordova', 'plugins'),
+    plugins_install_dir2 = path.join(project2, 'cordova', 'plugins'),
+
+    plugins = {
+        'DummyPlugin' : path.join(plugins_dir, 'DummyPlugin'),
+        'A' : path.join(plugins_dir, 'dependencies', 'A'),
+        'C' : path.join(plugins_dir, 'dependencies', 'C')
+    },
+    promise,
+    dummy_id = 'com.phonegap.plugins.dummyplugin';
+
+function uninstallPromise(f) {
+    return f.then(function() { done = true; }, function(err) { done = err; });
+}
+
+describe('start', function() {
+
+    it('start', function() {
+        shell.rm('-rf', project);
+        shell.rm('-rf', project2);
+        shell.cp('-R', path.join(srcProject, '*'), project);
+        shell.cp('-R', path.join(srcProject, '*'), project2);
+
+        done = false;
+        promise = Q()
+        .then(
+            function(){ return install('android', project, plugins['DummyPlugin'], plugins_install_dir,
{ browserify: true }) }
+        ).then(
+            function(){ return install('android', project, plugins['A'], plugins_install_dir,
{ browserify: true }) }
+        ).then(
+            function(){ return install('android', project2, plugins['C'], plugins_install_dir2,
{ browserify: true }) }
+        ).then(
+            function(){ return install('android', project2, plugins['A'], plugins_install_dir2,
{ browserify: true }) }
+        ).then(
+            function(){ done = true; }
+        );
+        waitsFor(function() { return done; }, 'promise never resolved', 500);
+    });
+});
+
+describe('uninstallPlatform', function() {
+    var proc, prepare, prepareBrowserify, actions_push, add_to_queue, c_a, rm;
+    var fsWrite;
+
+    var plat_common = require('../src/plugman/platforms/common');
+
+    beforeEach(function() {
+        proc = spyOn(actions.prototype, 'process').andReturn(Q());
+        actions_push = spyOn(actions.prototype, 'push');
+        c_a = spyOn(actions.prototype, 'createAction');
+        prepare = spyOn(plugman, 'prepare');
+        prepareBrowserify = spyOn(plugman, 'prepareBrowserify');
+        fsWrite = spyOn(fs, 'writeFileSync').andReturn(true);
+        rm = spyOn(shell, 'rm').andReturn(true);
+        spyOn(shell, 'cp').andReturn(true);
+        add_to_queue = spyOn(config_changes, 'add_uninstalled_plugin_to_prepare_queue');
+        done = false;
+    });
+    describe('success', function() {
+        it('should call prepare after a successful uninstall', function() {
+            runs(function() {
+                uninstallPromise(uninstall.uninstallPlatform('android', project, dummy_id,
plugins_install_dir, { browserify: true }));
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                expect(prepareBrowserify).toHaveBeenCalled();
+            });
+        });
+        it('should call the config-changes module\'s add_uninstalled_plugin_to_prepare_queue
method after processing an install', function() {
+            runs(function() {
+                uninstallPromise(uninstall.uninstallPlatform('android', project, dummy_id,
plugins_install_dir, { browserify: true }));
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                expect(add_to_queue).toHaveBeenCalledWith(plugins_install_dir, dummy_id,
'android', true);
+            });
+        });
+        it('should queue up actions as appropriate for that plugin and call process on the
action stack', function() {
+            runs(function() {
+                uninstallPromise(uninstall.uninstallPlatform('android', project, dummy_id,
plugins_install_dir, { browserify: true }));
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                expect(actions_push.calls.length).toEqual(5);
+                expect(proc).toHaveBeenCalled();
+            });
+        });
+
+        describe('with dependencies', function() {
+            var emit;
+            beforeEach(function() {
+                emit = spyOn(events, 'emit');
+            });
+            it('should uninstall "dangling" dependencies', function() {
+                runs(function() {
+                    uninstallPromise(uninstall.uninstallPlatform('android', project, 'A',
plugins_install_dir, { browserify: true }));
+                });
+                waitsFor(function() { return done; }, 'promise never resolved', 200);
+                runs(function() {
+                    expect(emit).toHaveBeenCalledWith('log', 'Uninstalling 2 dependent plugins.');
+                });
+            });
+        });
+    });
+
+    describe('failure', function() {
+        it('should throw if platform is unrecognized', function() {
+            runs(function() {
+                uninstallPromise( uninstall.uninstallPlatform('atari', project, 'SomePlugin',
plugins_install_dir, { browserify: true }) );
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                expect(''+done).toContain('atari not supported.');
+            });
+        });
+        it('should throw if plugin is missing', function() {
+            runs(function() {
+                uninstallPromise( uninstall.uninstallPlatform('android', project, 'SomePluginThatDoesntExist',
plugins_install_dir, { browserify: true }) );
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                expect(''+done).toContain('Plugin "SomePluginThatDoesntExist" not found.
Already uninstalled?');
+            });
+        });
+    });
+});
+
+describe('uninstallPlugin', function() {
+    var rm, fsWrite, rmstack = [], emit, prepareBrowserify;
+
+    beforeEach(function() {
+        fsWrite = spyOn(fs, 'writeFileSync').andReturn(true);
+        rm = spyOn(shell, 'rm').andCallFake(function(f,p) { rmstack.push(p); return true});
+        rmstack = [];
+        emit = spyOn(events, 'emit');
+        done = false;
+    });
+    describe('with dependencies', function() {
+
+        it('should delete all dependent plugins', function() {
+            runs(function() {
+                uninstallPromise( uninstall.uninstallPlugin('A', plugins_install_dir, {browserify:
true}) );
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                var del = common.spy.getDeleted(emit);
+
+                expect(del).toEqual([
+                    'Deleted "C"',
+                    'Deleted "D"',
+                    'Deleted "A"'
+                ]);
+            });
+        });
+
+        it("should fail if plugin is a required dependency", function() {
+            runs(function() {
+                uninstallPromise( uninstall.uninstallPlugin('C', plugins_install_dir, {browserify:
true}) );
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                expect(done.message).toBe('"C" is required by (A) and cannot be removed (hint:
use -f or --force)');
+            });
+        });
+
+        it("allow forcefully removing a plugin", function() {
+            runs(function() {
+                uninstallPromise( uninstall.uninstallPlugin('C', plugins_install_dir, {browserify:
true, force: true}) );
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                expect(done).toBe(true);
+                var del = common.spy.getDeleted(emit);
+                expect(del).toEqual(['Deleted "C"']);
+            });
+        });
+
+        it("never remove top level plugins if they are a dependency", function() {
+            runs(function() {
+                uninstallPromise( uninstall.uninstallPlugin('A', plugins_install_dir2, {browserify:
true}) );
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                var del = common.spy.getDeleted(emit);
+
+                expect(del).toEqual([
+                    'Deleted "D"',
+                    'Deleted "A"'
+                ]);
+            });
+        });
+    });
+});
+
+describe('uninstall', function() {
+    var fsWrite, rm, add_to_queue;
+
+    beforeEach(function() {
+        fsWrite = spyOn(fs, 'writeFileSync').andReturn(true);
+        rm = spyOn(shell, 'rm').andReturn(true);
+        add_to_queue = spyOn(config_changes, 'add_uninstalled_plugin_to_prepare_queue');
+        done = false;
+    });
+    describe('success', function() {
+        it('should call the config-changes module\'s add_uninstalled_plugin_to_prepare_queue
method after processing an install', function() {
+            runs(function() {
+                uninstallPromise( uninstall('android', project, plugins['DummyPlugin'], plugins_install_dir,
{ browserify: true }) );
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                expect(add_to_queue).toHaveBeenCalledWith(plugins_install_dir, dummy_id,
'android', true);
+            });
+        });
+    });
+
+    describe('failure', function() {
+        it('should throw if platform is unrecognized', function() {
+            runs(function() {
+                uninstallPromise(uninstall('atari', project, 'SomePlugin', plugins_install_dir,
{ browserify: true }));
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                expect(''+done).toContain('atari not supported.');
+            });
+        });
+        it('should throw if plugin is missing', function() {
+            runs(function() {
+                uninstallPromise(uninstall('android', project, 'SomePluginThatDoesntExist',
plugins_install_dir, { browserify: true }));
+            });
+            waitsFor(function() { return done; }, 'promise never resolved', 200);
+            runs(function() {
+                expect(''+done).toContain('Plugin "SomePluginThatDoesntExist" not found.
Already uninstalled?');
+            });
+        });
+    });
+});
+
+describe('end', function() {
+
+    it('end', function() {
+        done = false;
+
+        promise.then(
+            function(){
+                return uninstall('android', project, plugins['DummyPlugin'], plugins_install_dir,
{ browserify: true })
+            }
+        ).then(
+            function(){
+                // Fails... A depends on
+                return uninstall('android', project, plugins['C'], plugins_install_dir, {
browserify: true })
+            }
+        ).fail(
+            function(err) {
+                expect(err.message).toBe("The plugin 'C' is required by (A), skipping uninstallation.");
+            }
+        ).then(
+            function(){
+                // dependencies on C,D ... should this only work with --recursive? prompt
user..?
+                return uninstall('android', project, plugins['A'], plugins_install_dir, {
browserify: true })
+            }
+        ).fin(function(err){
+            if(err)
+                plugman.emit('error', err);
+
+            shell.rm('-rf', project);
+            shell.rm('-rf', project2);
+            done = true;
+        });
+
+        waitsFor(function() { return done; }, 'promise never resolved', 500);
+    });
+});
+

http://git-wip-us.apache.org/repos/asf/cordova-lib/blob/c2dd20cd/cordova-lib/src/cordova/plugin.js
----------------------------------------------------------------------
diff --git a/cordova-lib/src/cordova/plugin.js b/cordova-lib/src/cordova/plugin.js
index 8a792b9..5d4562f 100644
--- a/cordova-lib/src/cordova/plugin.js
+++ b/cordova-lib/src/cordova/plugin.js
@@ -124,6 +124,7 @@ module.exports = function plugin(command, targets, opts) {
                                 var platformRoot = path.join(projectRoot, 'platforms', platform),
                                     options = {
                                         cli_variables: opts.cli_variables || {},
+                                        browserify: opts.browserify || false,
                                         searchpath: searchPath,
                                         noregistry: opts.noregistry,
                                     },

http://git-wip-us.apache.org/repos/asf/cordova-lib/blob/c2dd20cd/cordova-lib/src/plugman/install.js
----------------------------------------------------------------------
diff --git a/cordova-lib/src/plugman/install.js b/cordova-lib/src/plugman/install.js
index a13c1e2..83834b4 100644
--- a/cordova-lib/src/plugman/install.js
+++ b/cordova-lib/src/plugman/install.js
@@ -569,7 +569,11 @@ function handleInstall(actions, pluginInfo, platform, project_dir, plugins_dir,
         // queue up the plugin so prepare knows what to do.
         config_changes.add_installed_plugin_to_prepare_queue(plugins_dir, pluginInfo.id,
platform, filtered_variables, options.is_top_level);
         // call prepare after a successful install
-        plugman.prepare(project_dir, platform, plugins_dir, options.www_dir, options.is_top_level);
+        if (options.browserify) {
+            plugman.prepareBrowserify(project_dir, platform, plugins_dir, options.www_dir,
options.is_top_level);
+        } else {
+            plugman.prepare(project_dir, platform, plugins_dir, options.www_dir, options.is_top_level);
+        }
 
         events.emit('verbose', 'Install complete for ' + pluginInfo.id + ' on ' + platform
+ '.');
         // WIN!

http://git-wip-us.apache.org/repos/asf/cordova-lib/blob/c2dd20cd/cordova-lib/src/plugman/plugman.js
----------------------------------------------------------------------
diff --git a/cordova-lib/src/plugman/plugman.js b/cordova-lib/src/plugman/plugman.js
index 6184503..5598628 100644
--- a/cordova-lib/src/plugman/plugman.js
+++ b/cordova-lib/src/plugman/plugman.js
@@ -70,6 +70,7 @@ addProperty(plugman, 'install', './install', true);
 addProperty(plugman, 'uninstall', './uninstall', true);
 addProperty(plugman, 'fetch', './fetch', true);
 addProperty(plugman, 'prepare', './prepare');
+addProperty(plugman, 'prepareBrowserify', './prepare-browserify');
 addProperty(plugman, 'config', './config', true);
 addProperty(plugman, 'owner', './owner', true);
 addProperty(plugman, 'adduser', './adduser', true);

http://git-wip-us.apache.org/repos/asf/cordova-lib/blob/c2dd20cd/cordova-lib/src/plugman/prepare-browserify.js
----------------------------------------------------------------------
diff --git a/cordova-lib/src/plugman/prepare-browserify.js b/cordova-lib/src/plugman/prepare-browserify.js
index 1a1cdf9..ed2bdf9 100644
--- a/cordova-lib/src/plugman/prepare-browserify.js
+++ b/cordova-lib/src/plugman/prepare-browserify.js
@@ -27,7 +27,7 @@ var platform_modules   = require('./platforms'),
     config_changes     = require('./util/config-changes'),
     xml_helpers        = require('../util/xml-helpers'),
     wp8                = require('./platforms/wp8'),
-    windows8           = require('./platforms/windows8'),
+    windows            = require('./platforms/windows'),
     common             = require('./platforms/common'),
     fs                 = require('fs'),
     shell              = require('shelljs'),

http://git-wip-us.apache.org/repos/asf/cordova-lib/blob/c2dd20cd/cordova-lib/src/plugman/uninstall.js
----------------------------------------------------------------------
diff --git a/cordova-lib/src/plugman/uninstall.js b/cordova-lib/src/plugman/uninstall.js
index c145da2..06bcb85 100644
--- a/cordova-lib/src/plugman/uninstall.js
+++ b/cordova-lib/src/plugman/uninstall.js
@@ -238,12 +238,12 @@ function runUninstallPlatform(actions, platform, project_dir, plugin_dir,
plugin
     }
 
     return promise.then(function() {
-        return handleUninstall(actions, platform, plugin_id, plugin_et, project_dir, options.www_dir,
plugins_dir, plugin_dir, options.is_top_level);
+        return handleUninstall(actions, platform, plugin_id, plugin_et, project_dir, options.www_dir,
plugins_dir, plugin_dir, options.is_top_level, options);
     });
 }
 
 // Returns a promise.
-function handleUninstall(actions, platform, plugin_id, plugin_et, project_dir, www_dir, plugins_dir,
plugin_dir, is_top_level) {
+function handleUninstall(actions, platform, plugin_id, plugin_et, project_dir, www_dir, plugins_dir,
plugin_dir, is_top_level, options) {
     var platform_modules = require('./platforms');
     var handler = platform_modules[platform];
     var platformTag = plugin_et.find('./platform[@name="'+platform+'"]');
@@ -316,6 +316,10 @@ function handleUninstall(actions, platform, plugin_id, plugin_et, project_dir,
w
         // queue up the plugin so prepare can remove the config changes
         config_changes.add_uninstalled_plugin_to_prepare_queue(plugins_dir, plugin_id, platform,
is_top_level);
         // call prepare after a successful uninstall
-        plugman.prepare(project_dir, platform, plugins_dir, www_dir, is_top_level);
+        if (options.browserify) {
+            plugman.prepareBrowserify(project_dir, platform, plugins_dir, www_dir, is_top_level);
+        } else {
+            plugman.prepare(project_dir, platform, plugins_dir, www_dir, is_top_level);
+        }
     });
 }


Mime
View raw message