incubator-callback-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tim...@apache.org
Subject [6/6] webworks commit: made sample project work on bb10 with a custom config.xml and including webworks.js
Date Fri, 24 Aug 2012 00:36:15 GMT
made sample project work on bb10 with a custom config.xml and including webworks.js


Project: http://git-wip-us.apache.org/repos/asf/incubator-cordova-blackberry-webworks/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-cordova-blackberry-webworks/commit/98b4c9a2
Tree: http://git-wip-us.apache.org/repos/asf/incubator-cordova-blackberry-webworks/tree/98b4c9a2
Diff: http://git-wip-us.apache.org/repos/asf/incubator-cordova-blackberry-webworks/diff/98b4c9a2

Branch: refs/heads/master
Commit: 98b4c9a2d4660eb002574479d2c975139d26d5a3
Parents: ce8c37b
Author: Gord Tanner <gtanner@gmail.com>
Authored: Thu Aug 23 11:59:05 2012 -0400
Committer: Tim Kim <tim.kim@nitobi.com>
Committed: Thu Aug 23 11:48:37 2012 -0700

----------------------------------------------------------------------
 README.md                                        |    2 +-
 bin/templates/project/qnx.xml                    |    3 +-
 bin/templates/project/www/index.html             |    1 +
 bin/templates/project/www/js/webworks-1.0.1.8.js | 1240 +++++++++++++++++
 bin/templates/project/www/qnx/config.xml         |   73 +
 5 files changed, 1317 insertions(+), 2 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-cordova-blackberry-webworks/blob/98b4c9a2/README.md
----------------------------------------------------------------------
diff --git a/README.md b/README.md
index 7a1d612..c178ac6 100644
--- a/README.md
+++ b/README.md
@@ -179,4 +179,4 @@ __A:__ You probably need to update your plugins.xml file in the root of your app
 
 __Q: I am getting an error building for BlackBerry 10
 
-__A:__ The current SDK for BlackBerry 10 has a couple bugs that will get in the way when developing for cross platform BlackBerry Apps. [Issue 177] (https://github.com/blackberry/BB10-Webworks-Packager/issues/177) and [Issue 175] (https://github.com/blackberry/BB10-Webworks-Packager/issues/175). Adding the BlackBerry 10 SDK folder to your path on OSX and updating the features in config.xml to not have any unknown features will allow you to build and deploy to BlackBerry 10 for now.
+__A:__ The current SDK for BlackBerry 10 has a bug that will get in the way when developing for cross platform BlackBerry Apps. [Issue 177] (https://github.com/blackberry/BB10-Webworks-Packager/issues/177) 

http://git-wip-us.apache.org/repos/asf/incubator-cordova-blackberry-webworks/blob/98b4c9a2/bin/templates/project/qnx.xml
----------------------------------------------------------------------
diff --git a/bin/templates/project/qnx.xml b/bin/templates/project/qnx.xml
index a67f54a..a125cca 100644
--- a/bin/templates/project/qnx.xml
+++ b/bin/templates/project/qnx.xml
@@ -112,8 +112,9 @@
         
         <!-- Overwrite the cordova js with the qnx specific cordova js -->
         <copy todir="${widget.dir}" overwrite="true">
-            <fileset dir="www/playbook">
+            <fileset dir="www/qnx">
                 <include name="*.js" />
+                <include name="config.xml" />
             </fileset>
         </copy>
         

http://git-wip-us.apache.org/repos/asf/incubator-cordova-blackberry-webworks/blob/98b4c9a2/bin/templates/project/www/index.html
----------------------------------------------------------------------
diff --git a/bin/templates/project/www/index.html b/bin/templates/project/www/index.html
index cfa6fb9..d538be6 100644
--- a/bin/templates/project/www/index.html
+++ b/bin/templates/project/www/index.html
@@ -33,6 +33,7 @@
                 <p class="status complete blink hide">Device is Ready</p>
             </div>
         </div>
+        <script type="text/javascript" src="js/webworks-1.0.1.8.js"></script>
         <script type="text/javascript" src="cordova-2.0.0.js"></script>
         <script type="text/javascript" src="js/index.js"></script>
         <script type="text/javascript">

http://git-wip-us.apache.org/repos/asf/incubator-cordova-blackberry-webworks/blob/98b4c9a2/bin/templates/project/www/js/webworks-1.0.1.8.js
----------------------------------------------------------------------
diff --git a/bin/templates/project/www/js/webworks-1.0.1.8.js b/bin/templates/project/www/js/webworks-1.0.1.8.js
new file mode 100755
index 0000000..52d5da8
--- /dev/null
+++ b/bin/templates/project/www/js/webworks-1.0.1.8.js
@@ -0,0 +1,1240 @@
+/*
+ *  Copyright 2012 Research In Motion Limited.
+ *
+ * Licensed 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.
+ */
+
+(function () { 
+/*
+ *  Copyright 2012 Research In Motion Limited.
+ *
+ * Licensed 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 define,
+    require;
+
+(function () {
+    var unpreparedModules = {},
+        readyModules = {},
+        ACCEPTABLE_EXTENSIONS = [".js", ".json"],
+        DEFAULT_EXTENSION = ".js";
+
+    function hasValidExtension(moduleName) {
+        return ACCEPTABLE_EXTENSIONS.some(function (element, index, array) {
+            return moduleName.match("\\" + element + "$");
+        });
+    }
+
+
+    function normalizeName(originalName, baseName) {
+        var nameParts,
+            name = originalName.slice(0);
+        //remove ^local:// (if it exists) and .js$
+        //This will not work for local:// without a trailing js
+        name = name.replace(/(?:^local:\/\/)/, "");
+        if (name.charAt(0) === '.' && baseName) {
+            //Split the baseName and remove the final part (the module name)
+            nameParts = baseName.split('/');
+            nameParts.pop();
+            nameParts = nameParts.concat(name.split('/'));
+            
+            name = nameParts.reduce(function (previous, current,  index, array) {
+                var returnValue,
+                    slashIndex;
+
+                //If previous is a dot, ignore it
+                //If previous is ever just .. we're screwed anyway
+                if (previous !== '.') {
+                    returnValue = previous;
+                }
+                
+                //If we have a .. then remove a chunk of previous
+                if (current === "..") {
+                    slashIndex = previous.lastIndexOf('/');
+                    //If there's no slash we're either screwed or we remove the final token
+                    if (slashIndex !== -1) {
+                        returnValue = previous.slice(0, previous.lastIndexOf('/'));
+                    } else {
+                        returnValue = "";
+                    }
+                } else if (current !== '.') {
+                    //Otherwise simply append anything not a .
+                    //Only append a slash if we're not empty
+                    if (returnValue.length) {
+                        returnValue += "/";
+                    }
+                    returnValue += current;
+                }
+
+                return returnValue;
+            });
+
+        }
+        
+        //If there is no acceptable extension tack on a .js
+        if (!hasValidExtension(name)) {
+            name = name + DEFAULT_EXTENSION;
+        }
+
+        return name;
+    }
+
+    function buildModule(name, dependencies, factory) {
+        var module = {exports: {}},
+            localRequire = function (moduleName) {
+                return require(moduleName, name);
+            },
+            args = [];
+        localRequire.toUrl = function (moduleName, baseName) {
+            return require.toUrl(moduleName, baseName || name);
+        };
+        dependencies.forEach(function (dependency) {
+            if (dependency === 'require') {
+                args.push(localRequire);
+            } else if (dependency === 'exports') {
+                args.push(module.exports);
+            } else if (dependency === 'module') {
+                args.push(module);
+            } else {
+                //This is because jshint cannot handle out of order functions
+                /*global loadModule:false */
+                args.push(loadModule(dependency));
+                /*global loadModule:true */
+            }
+        });
+
+        //No need to process dependencies, webworks only has require, exports, module
+        factory.apply(this, args);
+
+        //For full AMD we would need logic to also check the return value
+        return module.exports;
+
+    }
+
+    function getDefineString(moduleName, body) {
+        var evalString = 'define("' + moduleName + '", function (require, exports, module) {',
+            isJson = /\.json$/.test(moduleName);
+
+        evalString += isJson ? ' module.exports = ' : '';
+        evalString += body.replace(/^\s+|\s+$/g, '');
+        evalString += isJson ? ' ;' : '';
+        evalString += '});';
+
+        return evalString;
+    }
+
+    function loadModule(name, baseName) {
+        var normalizedName = normalizeName(name, baseName),
+            url,
+            xhr,
+            loadResult;
+        //Always check undefined first, this allows the user to redefine modules
+        //(Not used in WebWorks, although it is used in our unit tests)
+        if (unpreparedModules[normalizedName]) {
+            readyModules[normalizedName] = buildModule(normalizedName, unpreparedModules[normalizedName].dependencies, unpreparedModules[normalizedName].factory);
+            delete unpreparedModules[normalizedName];
+        }
+
+        //If the module does not exist, load the module from external source
+        //Webworks currently only loads APIs from across bridge
+        if (!readyModules[normalizedName]) {
+            //If the module to be loaded ends in .js then we will define it
+            //Also if baseName exists than we have a local require situation
+            if (hasValidExtension(name) || baseName) {
+                xhr = new XMLHttpRequest();
+                url = name;
+                //If the module to be loaded starts with local:// go over the bridge
+                //Else If the module to be loaded is a relative load it may not have .js extension which is needed
+                if (/^local:\/\//.test(name)) {
+                    url = "http://localhost:8472/extensions/load/" + normalizedName.replace(/(?:^ext\/)(.+)(?:\/client.js$)/, "$1");
+
+                    xhr.open("GET", url, false);
+                    xhr.send(null);
+                    try {
+                        loadResult = JSON.parse(xhr.responseText);
+
+                        loadResult.dependencies.forEach(function (dep) {
+                            /*jshint evil:true */
+                            eval(getDefineString(dep.moduleName, dep.body));
+                            /*jshint evil:false */
+                        });
+
+                        //Trimming responseText to remove EOF chars
+                        /*jshint evil:true */
+                        eval(getDefineString(normalizedName, loadResult.client));
+                        /*jshint evil:false */
+                    } catch (err1) {
+                        err1.message += ' in ' + url;
+                        throw err1;
+                    }
+                } else {
+                    if (baseName) {
+                        url = normalizedName;
+                    }
+
+                    xhr.open("GET", url, false);
+                    xhr.send(null);
+                    try {
+                        //Trimming responseText to remove EOF chars
+                        /*jshint evil:true */
+                        eval(getDefineString(normalizedName, xhr.responseText));
+                        /*jshint evil:false */
+                    } catch (err) {
+                        err.message += ' in ' + url;
+                        throw err;
+                    }
+                }
+
+                if (unpreparedModules[normalizedName]) {
+                    readyModules[normalizedName] = buildModule(normalizedName, unpreparedModules[normalizedName].dependencies, unpreparedModules[normalizedName].factory);
+                    delete unpreparedModules[normalizedName];
+                }
+            } else {
+                throw "module " + name + " cannot be found";
+            }
+
+        }
+
+        return readyModules[normalizedName];
+
+    }
+
+    //Use the AMD signature incase we ever want to change.
+    //For now we will only be using (name, baseName)
+    require = function (dependencies, callback) {
+        if (typeof dependencies === "string") {
+            //dependencies is the module name and callback is the relName
+            //relName is not part of the AMDJS spec, but we use it from localRequire
+            return loadModule(dependencies, callback);
+        } else if (Array.isArray(dependencies) && typeof callback === 'function') {
+            //Call it Asynchronously
+            setTimeout(function () {
+                buildModule(undefined, dependencies, callback);
+            }, 0);
+        }
+    }; 
+
+    require.toUrl = function (originalName, baseName) {
+        return normalizeName(originalName, baseName);
+    };
+
+    //Use the AMD signature incase we ever want to change.
+    //For now webworks will only be using (name, factory) signature.
+    define = function (name, dependencies, factory) {
+        if (typeof name === "string" && typeof dependencies === 'function') {
+            factory = dependencies;
+            dependencies = ['require', 'exports', 'module'];
+        }
+
+        //According to the AMDJS spec we should parse out the require statments 
+        //from factory.toString and add those to the list of dependencies
+
+        //Normalize the name. Remove local:// and .js
+        name = normalizeName(name);
+        unpreparedModules[name] = {
+            dependencies: dependencies,
+            factory: factory
+        }; 
+    };
+}());
+
+//Export for use in node for unit tests
+if (typeof module === "object" && typeof require === "function") {
+    module.exports = {
+        require: require,
+        define: define
+    };
+}
+
+define('builder', function (require, exports, module) {
+/*
+ * Copyright 2010-2011 Research In Motion Limited.
+ *
+ * Licensed 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 utils = require(!!require.resolve ? "../utils" : "lib/utils");
+
+function buildNamespace(currentNamespace, namespaceParts, featureProperties) {
+    var featureId,
+        nextPart;
+
+    if (namespaceParts.length === 1) {
+        //base case, feature properties go here
+        featureId = namespaceParts[0];
+        if (currentNamespace[featureId] === undefined) {
+            currentNamespace[featureId] = {};
+        }
+
+        currentNamespace = utils.mixin(featureProperties, currentNamespace[featureId]);
+        return currentNamespace;
+    }
+    else {
+        nextPart = namespaceParts.shift();
+        if (currentNamespace[nextPart] === undefined) {
+            currentNamespace[nextPart] = {};
+        }
+
+        return buildNamespace(currentNamespace[nextPart], namespaceParts, featureProperties);
+    }
+}
+
+function include(parent, featureIdList) {
+    var featureId,
+        featureProperties,
+        localUrl,
+        i;
+
+    for (i = 0; i < featureIdList.length; i++) {
+        featureId = featureIdList[i];
+
+        localUrl = "local://ext/" + featureId + "/client.js";
+        featureProperties = utils.loadModule(localUrl);
+
+        buildNamespace(parent, featureId.split("."), featureProperties);
+    }
+}
+
+var _self = {
+    build: function (featureIdList) {
+        return {
+            into: function (target) {
+                include(target, featureIdList);
+            }
+        };
+    }
+};
+
+module.exports = _self;
+
+});
+
+define('window', function (require, exports, module) {
+/*
+ * Copyright 2010-2011 Research In Motion Limited.
+ *
+ * Licensed 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.
+ */
+
+// HACK have to live with differentiating node from browser for now
+module.exports = {
+    "window": function () {
+        return !!require.resolve ? null : window;
+    }
+};
+});
+
+define('event', function (require, exports, module) {
+/*
+* Copyright 2010-2011 Research In Motion Limited.
+*
+* Licensed 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 _handlers = {};
+
+function _add(featureId, name, cb, success, fail, once) {
+    var handler;
+    if (featureId && name && typeof cb === "function") {
+        handler = {
+            func: cb,
+            once: !!once
+        };
+        //If this is the first time we are adding a cb
+        if (!_handlers.hasOwnProperty(name)) {
+            _handlers[name] = [handler];
+            //Do not call exec for once because its not necessary
+            if (!once) {
+                window.webworks.exec(success, fail, featureId, "add", {"eventName": name});
+            }
+        } else if (_handlers[name].some(function (element, index, array) { 
+            return element.func !== cb;
+        })) {
+            //Only add unique callbacks
+            _handlers[name].push(handler);
+        }
+    }
+}
+
+module.exports = {
+    add: function (featureId, name, cb, success, fail) {
+        _add(featureId, name, cb, success, fail, false);
+    },
+    
+    once: function (featureId, name, cb, success, fail) {
+        _add(featureId, name, cb, success, fail, true);
+    },
+    
+    isOn: function (name) {
+        return !!_handlers[name];
+    },
+
+    remove: function (featureId, name, cb, success, fail) {
+        if (featureId && name && typeof cb === "function") {
+            if (_handlers.hasOwnProperty(name)) {
+                _handlers[name] = _handlers[name].filter(function (element, index, array) {
+                    return element.func !== cb || element.once;
+                });
+                
+                if (_handlers[name].length === 0) {
+                    delete _handlers[name];
+                    window.webworks.exec(success, fail, featureId, "remove", {"eventName": name});
+                }
+            }
+        }
+    },
+
+    trigger: function (name, args) {
+        var parsedArgs;
+        if (_handlers.hasOwnProperty(name)) {
+            if (args && args !== "undefined") {
+                parsedArgs = JSON.parse(args);
+            }
+            //Call the handlers
+            _handlers[name].forEach(function (handler) {
+                if (handler) {
+                    //args should be an array of arguments
+                    handler.func.apply(undefined, parsedArgs);
+                }
+            });
+            //Remove the once listeners
+            _handlers[name] = _handlers[name].filter(function (handler) {
+                return !handler.once;
+            });
+            //Clean up the array if it is empty
+            if (_handlers[name].length === 0) {
+                delete _handlers[name];
+                //No need to call remove since this would only be for callbacks
+            }
+        }
+    }
+};
+
+});
+
+define('lib/utils', function (require, exports, module) {
+/*
+ *  Copyright 2012 Research In Motion Limited.
+ *
+ * Licensed 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 self,
+    exception = require('./exception');
+
+self = module.exports = {
+    validateNumberOfArguments: function (lowerBound, upperBound, numberOfArguments, customExceptionType, customExceptionMessage, customExceptionObject) {
+
+        customExceptionMessage = customExceptionMessage || "";
+
+        if (arguments.length < 3 || arguments.length > 6) {
+            exception.raise(exception.types.Argument, "Wrong number of arguments when calling: validateNumberOfArguments()");
+        }
+
+        if (isNaN(lowerBound) && isNaN(upperBound) && isNaN(numberOfArguments)) {
+            exception.raise(exception.types.ArgumentType, "(validateNumberOfArguments) Arguments are not numbers");
+        }
+
+        lowerBound = parseInt(lowerBound, 10);
+        upperBound = parseInt(upperBound, 10);
+        numberOfArguments = parseInt(numberOfArguments, 10);
+
+        if (numberOfArguments < lowerBound || numberOfArguments > upperBound) {
+            exception.raise((customExceptionType || exception.types.ArgumentLength), (customExceptionMessage + "\n\nWrong number of arguments"), customExceptionObject);
+        }
+
+    },
+
+    validateArgumentType: function (arg, argType, customExceptionType, customExceptionMessage, customExceptionObject) {
+        var invalidArg = false,
+            msg;
+
+        switch (argType) {
+        case "array":
+            if (!arg instanceof Array) {
+                invalidArg = true;
+            }
+            break;
+        case "date":
+            if (!arg instanceof Date) {
+                invalidArg = true;
+            }
+            break;
+        case "integer":
+            if (typeof arg === "number") {
+                if (arg !== Math.floor(arg)) {
+                    invalidArg = true;
+                }
+            }
+            else {
+                invalidArg = true;
+            }
+            break;
+        default:
+            if (typeof arg !== argType) {
+                invalidArg = true;
+            }
+            break;
+        }
+
+        if (invalidArg) {
+            msg = customExceptionMessage +  ("\n\nInvalid Argument type. argument: " + arg + " ==> was expected to be of type: " + argType);
+            exception.raise((customExceptionType || exception.types.ArgumentType), msg, customExceptionObject);
+        }
+    },
+
+    validateMultipleArgumentTypes: function (argArray, argTypeArray, customExceptionType, customExceptionMessage, customExceptionObject) {
+        for (var i = 0; i < argArray.length; i++) {
+            this.validateArgumentType(argArray[i], argTypeArray[i], customExceptionType, customExceptionMessage, customExceptionObject);
+        }
+    },
+
+    arrayContains: function (array, obj) {
+        var i = array.length;
+        while (i--) {
+            if (array[i] === obj) {
+                return true;
+            }
+        }
+        return false;
+    },
+
+    some: function (obj, predicate, scope) {
+        if (obj instanceof Array) {
+            return obj.some(predicate, scope);
+        }
+        else {
+            var values = self.map(obj, predicate, scope);
+
+            return self.reduce(values, function (some, value) {
+                return value ? value : some;
+            }, false);
+        }
+    },
+
+    count: function (obj) {
+        return self.sum(obj, function (total) {
+            return 1;
+        });
+    },
+
+    sum: function (obj, selector, scope) {
+        var values = self.map(obj, selector, scope);
+        return self.reduce(values, function (total, value) {
+            return total + value;
+        });
+    },
+
+    max: function (obj, selector, scope) {
+        var values = self.map(obj, selector, scope);
+        return self.reduce(values, function (max, value) {
+            return max < value ? value : max;
+        }, Number.MIN_VALUE);
+    },
+
+    min: function (obj, selector, scope) {
+        var values = self.map(obj, selector, scope);
+        return self.reduce(values, function (min, value) {
+            return min > value ? value : min;
+        }, Number.MAX_VALUE);
+    },
+
+    forEach: function (obj, action, scope) {
+        if (obj instanceof Array) {
+            return obj.forEach(action, scope);
+        }
+        else {
+            self.map(obj, action, scope);
+        }
+    },
+
+    filter: function (obj, predicate, scope) {
+        if (obj instanceof Array) {
+            return obj.filter(predicate, scope);
+        }
+        else {
+            var result = [];
+            self.forEach(obj, function (value, index) {
+                if (predicate.apply(scope, [value, index])) {
+                    result.push(value);
+                }
+
+            }, scope);
+
+            return result;
+        }
+    },
+
+    reduce: function (obj, func, init, scope) {
+        var i,
+            initial = init === undefined ? 0 : init,
+            result = initial;
+
+
+        if (obj instanceof Array) {
+            return obj.reduce(func, initial);
+        }
+        else if (obj instanceof NamedNodeMap) {
+            for (i = 0; i < obj.length; i++) {
+                result = func.apply(scope, [result, obj[i], i]);
+            }
+        }
+        else {
+            for (i in obj) {
+                if (obj.hasOwnProperty(i)) {
+                    result = func.apply(scope, [result, obj[i], i]);
+                }
+            }
+        }
+
+        return result;
+
+    },
+
+    map: function (obj, func, scope) {
+        var i,
+            returnVal = null,
+            result = [];
+
+        if (obj instanceof Array) {
+            return obj.map(func, scope);
+        }
+        else if (obj instanceof NamedNodeMap) {
+            for (i = 0; i < obj.length; i++) {
+                returnVal = func.apply(scope, [obj[i], i]);
+                result.push(returnVal);
+            }
+        }
+        else {
+            for (i in obj) {
+                if (obj.hasOwnProperty(i)) {
+                    returnVal = func.apply(scope, [obj[i], i]);
+                    result.push(returnVal);
+                }
+            }
+        }
+
+        return result;
+    },
+
+    regexSanitize: function (regexString) {
+        return regexString.replace("^", "\\^")
+                    .replace("$", "\\$")
+                    .replace("(", "\\(")
+                    .replace(")", "\\)")
+                    .replace("<", "\\<")
+                    .replace("[", "\\[")
+                    .replace("{", "\\{")
+                    .replace(/\\/, "\\\\")
+                    .replace("|", "\\|")
+                    .replace(">", "\\>")
+                    .replace(".", "\\.")
+                    .replace("*", "\\*")
+                    .replace("+", "\\+")
+                    .replace("?", "\\?");
+    },
+
+    find: function (comparison, collection, startInx, endInx, callback) {
+        var results = [],
+            compare = function (s, pattern) {
+
+                if (typeof(s) !== "string" || pattern === null) {
+                    return s === pattern;
+                }
+
+                var regex = pattern.replace(/\./g, "\\.")
+                                   .replace(/\^/g, "\\^")
+                                   .replace(/\*/g, ".*")
+                                   .replace(/\\\.\*/g, "\\*");
+
+                regex = "^".concat(regex, "$");
+
+                return !!s.match(new RegExp(regex, "i"));
+            };
+
+        self.forEach(collection, function (c) {
+            var match,
+                fail = false;
+
+            self.forEach(comparison, function (value, key) {
+                if (!fail && value !== undefined) {
+
+                    if (compare(c[key], value)) {
+                        match = c;
+                    }
+                    else {
+                        fail = true;
+                        match = null;
+                    }
+                }
+            });
+
+            if (match) {
+                results.push(match);
+            }
+        });
+
+        if (callback) {
+            if (startInx === undefined) {
+                startInx = 0;
+            }
+            if (endInx === undefined) {
+                endInx = results.length;
+            }
+            if (startInx === endInx) {
+                endInx = startInx + 1;
+            }
+
+            callback.apply(null, [results.slice(startInx, endInx)]);
+        }
+    },
+
+    mixin: function (mixin, to) {
+        Object.getOwnPropertyNames(mixin).forEach(function (prop) {
+            if (Object.hasOwnProperty.call(mixin, prop)) {
+                Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(mixin, prop));
+            }
+        });
+        return to;
+    },
+
+    copy: function (obj) {
+        var i,
+            newObj = (obj === null ? false : global.toString.call(obj) === "[object Array]") ? [] : {};
+
+        if (typeof obj === 'number' ||
+            typeof obj === 'string' ||
+            typeof obj === 'boolean' ||
+            obj === null ||
+            obj === undefined) {
+            return obj;
+        }
+
+        if (obj instanceof Date) {
+            return new Date(obj);
+        }
+
+        if (obj instanceof RegExp) {
+            return new RegExp(obj);
+        }
+
+        for (i in obj) {
+            if (obj.hasOwnProperty(i)) {
+                if (obj[i] && typeof obj[i] === "object") {
+                    if (obj[i] instanceof Date) {
+                        newObj[i] = obj[i];
+                    }
+                    else {
+                        newObj[i] = self.copy(obj[i]);
+                    }
+                }
+                else {
+                    newObj[i] = obj[i];
+                }
+            }
+        }
+
+        return newObj;
+    },
+
+    startsWith : function (str, substr) {
+        return str.indexOf(substr) === 0;
+    },
+
+    endsWith : function (str, substr) {
+        return str.indexOf(substr, str.length - substr.length) !== -1;
+    },
+
+    parseUri : function (str) {
+        var i, uri = {},
+            key = [ "source", "scheme", "authority", "userInfo", "user", "password", "host", "port", "relative", "path", "directory", "file", "query", "anchor" ],
+            matcher = /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/.exec(str);
+
+        for (i = key.length - 1; i >= 0; i--) {
+            uri[key[i]] = matcher[i] || "";
+        }
+
+        return uri;
+    },
+
+    // uri - output from parseUri
+    isAbsoluteURI : function (uri) {
+        if (uri && uri.source) {
+            return uri.relative !== uri.source;
+        }
+
+        return false;
+    },
+
+    fileNameToImageMIME : function (fileName) {
+
+        var extensionsToMIME = {},
+            ext;
+
+        extensionsToMIME.png = 'image/png';
+        extensionsToMIME.jpg = 'image/jpeg';
+        extensionsToMIME.jpe = 'image/jpeg';
+        extensionsToMIME.jpeg = 'image/jpeg';
+        extensionsToMIME.gif = 'image/gif';
+        extensionsToMIME.bmp = 'image/bmp';
+        extensionsToMIME.bm = 'image/bmp';
+        extensionsToMIME.svg = 'image/svg+xml';
+        extensionsToMIME.tif = 'image/tiff';
+        extensionsToMIME.tiff = 'image/tiff';
+
+        ext = fileName.split('.').pop();
+        return extensionsToMIME[ext];
+    },
+
+    isLocalURI : function (uri) {
+        return uri && uri.scheme && "local:///".indexOf(uri.scheme.toLowerCase()) !== -1;
+    },
+
+    isFileURI : function (uri) {
+        return uri && uri.scheme && "file://".indexOf(uri.scheme.toLowerCase()) !== -1;
+    },
+
+    isHttpURI : function (uri) {
+        return uri && uri.scheme && "http://".indexOf(uri.scheme.toLowerCase()) !== -1;
+    },
+
+    isHttpsURI : function (uri) {
+        return uri && uri.scheme && "https://".indexOf(uri.scheme.toLowerCase()) !== -1;
+    },
+
+    // Checks if the specified uri starts with 'data:'
+    isDataURI : function (uri) {
+        return uri && uri.scheme && "data:".indexOf(uri.scheme.toLowerCase()) !== -1;
+    },
+
+    performExec : function (featureId, property, args) {
+        var result;
+
+        window.webworks.exec(function (data, response) {
+            result = data;
+        }, function (data, response) {
+            throw data;
+        }, featureId, property, args, true);
+
+        return result;
+    },
+
+    inNode : function () {
+        return !!require.resolve;
+    },
+
+    requireWebview : function () {
+        return require("./webview");
+    },
+    convertDataToBinary : function (data, dataEncoding) {
+        var rawData,
+            uint8Array,
+            i;
+
+        if (data) {
+            if (dataEncoding.toLowerCase() === "base64") {
+                rawData = window.atob(data);
+            }
+            else {
+                rawData = data;
+            }
+
+            uint8Array = new Uint8Array(new ArrayBuffer(rawData.length));
+
+            for (i = 0; i < uint8Array.length; i++) {
+                uint8Array[i] = rawData.charCodeAt(i);
+            }
+
+            return uint8Array.buffer;
+        }
+    },
+    getBlobWithArrayBufferAsData : function (data, dataEncoding) {
+        var rawData,
+            blobBuilderObj = new window.WebKitBlobBuilder();
+        rawData = this.convertDataToBinary(data, dataEncoding);
+        blobBuilderObj.append(rawData);
+
+        return blobBuilderObj.getBlob("arraybuffer");
+    },
+    loadModule: function (module) {
+        return require(module);
+    },
+    loadExtensionModule: function (extBasename, path) {
+        var ext = require("./manifest")[extBasename];
+
+        if (ext) {
+            return require("../ext/" + ext.namespace + "/" + path);
+        } else {
+            return null;
+        }
+    }
+};
+
+});
+
+define('lib/exception', function (require, exports, module) {
+/*
+ *  Copyright 2012 Research In Motion Limited.
+ *
+ * Licensed 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.
+ */
+
+module.exports = {
+
+    types: {
+        Application: "Application",
+        ArgumentLength: "ArgumentLength",
+        ArgumentType: "ArgumentType",
+        Argument: "Argument",
+        NotificationType: "NotificationType",
+        NotificationStateType: "NotificationStateType",
+        DomObjectNotFound: "DomObjectNotFound",
+        MethodNotImplemented: "MethodNotImplemented",
+        InvalidState: "InvalidState",
+        ApplicationState: "ApplicationState"
+    },
+
+    handle: function handle(exception, reThrow) {
+        reThrow = reThrow || false;
+
+        var eMsg = exception.message || "exception caught!",
+        msg = eMsg + "\n\n" + (exception.stack || "*no stack provided*") + "\n\n";
+
+        console.error(msg);
+
+        if (reThrow) {
+            throw exception;
+        }
+    },
+
+    raise: function raise(exceptionType, message, customExceptionObject) {
+        var obj = customExceptionObject || {
+                type: "",
+                message: "",
+
+                toString: function () {
+                    var result = this.name + ': "' + this.message + '"';
+
+                    if (this.stack) {
+                        result += "\n" + this.stack;
+                    }
+                    return result;
+                }
+            };
+
+        message = message || "";
+
+        obj.name = exceptionType;
+        obj.type = exceptionType;
+        // TODO: include the exception objects original message if exists
+        obj.message = message;
+
+        throw obj;
+    }
+};
+
+});
+define('lib/webworks-info', function (require, exports, module) {
+module.exports = {
+	hash: "f1d993c3aa16da2ba0def7a42b11b75b",
+	version: "1.0.1.8"
+};
+});
+/*
+* Copyright 2010-2012 Research In Motion Limited.
+*
+* Licensed 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.
+*/
+(function () {
+    var _d = document.addEventListener,
+        _webworksReady = false,
+        _alreadyFired = false,
+        _listenerRegistered = false;
+
+    //Only fire the webworks event when both webworks is ready and a listener is registered
+    function fireWebworksReadyEvent() {
+        if (_listenerRegistered && _webworksReady && !_alreadyFired) {
+            _alreadyFired = true;
+            var evt = document.createEvent("Events");
+            evt.initEvent("webworksready", true, true);
+            document.dispatchEvent(evt);
+        }
+    }
+
+    //Trapping when users add listeners to the webworks ready event
+    //This way we can make sure not to fire the event before there is a listener
+    document.addEventListener = function (event, callback, capture) {
+        _d.call(document, event, callback, capture);
+        if (event.toLowerCase() === "webworksready") {
+            _listenerRegistered = true;
+            fireWebworksReadyEvent();
+        }
+    };
+
+
+    function createWebworksReady() {
+        function RemoteFunctionCall(functionUri) {
+            var paramString = "",
+                params = {},
+                isPost = false;
+
+            function composeUri() {
+                return "http://localhost:8472/" + functionUri;
+            }
+
+            function createXhrRequest(uri, isAsync) {
+                var request = new XMLHttpRequest(),
+                    paramCount = 1,
+                    param;
+
+                for (param in params) {
+                    if (params.hasOwnProperty(param)) {
+                        paramString += param + "=" + params[param] + "&";
+                        paramCount++;
+                    }
+                }
+
+                paramString = paramString.replace(/\&$/, "");
+
+                if (!isPost && paramString) {
+                    uri += "?" + paramString;
+                }
+
+                // TODO: make get/post
+                request.open("GET", uri, isAsync);
+                request.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
+
+                return request;
+            }
+
+            this.addParam = function (name, value) {
+                params[name] = encodeURIComponent(JSON.stringify(value));
+            };
+
+            this.makeSyncCall = function (success, error) {
+                var requestUri = composeUri(),
+                    request = createXhrRequest(requestUri, false),
+                    response, 
+                    errored, 
+                    cb, 
+                    data;
+
+                request.send(isPost ? paramString : null);
+
+                response = JSON.parse(decodeURIComponent(request.responseText) || "null");
+                errored = response.code < 0;
+                cb = errored ? error : success;
+                data = errored ? response.msg : response.data;
+
+                if (cb) {
+                    cb(data, response);
+                }
+                else if (errored) {
+                    throw data;
+                }
+
+                return data;
+            };
+
+            this.makeAsyncCall = function (success, error) {
+                var requestUri = composeUri(),
+                    request = createXhrRequest(requestUri, true);
+
+                request.onreadystatechange = function () {
+                    if (request.readyState === 4 && request.status === 200) {
+                        var response = JSON.parse(decodeURIComponent(request.responseText) || "null"),
+                        cb = response.code < 0 ? error : success,
+                        data = response.code < 0 ? response.msg : response.data;
+
+                        return cb && cb(data, response);
+                    }
+                };
+
+                request.send(isPost ? paramString : null);
+            };
+        }
+
+        var builder,
+            request,
+            resp,
+            execFunc,
+            wwInfo = require('lib/webworks-info');
+        
+        //For users who wish to have a single source project across BB7 -> PB -> BB10 they will need to use webworks.js
+        //To aid in this, we will fire the webworksready event on these platforms as well
+        //If blackberry object already exists then we are in an older version of webworks
+        if (window.blackberry) {
+            _webworksReady = true;
+            fireWebworksReadyEvent();
+            return;
+        }
+
+        // Build out the blackberry namespace based on the APIs desired in the config.xml
+        builder = require('builder');
+        
+        request = new XMLHttpRequest();
+        request.open("GET", "http://localhost:8472/extensions/get/?hash=" + wwInfo.hash + "&version=" + wwInfo.version, true);
+
+        request.onreadystatechange = function () {
+            if (request.readyState === 4) {
+                if (request.status === 412) {
+                    //Application Webworks.js does not match framework, display error to user.
+                    resp = JSON.parse(request.responseText);
+                    alert(resp.msg);
+                } else if (request.status === 200) {
+                    resp = JSON.parse(decodeURIComponent(request.responseText));
+                    builder.build(resp.data).into(window);
+                    //At this point all of the APIs should be built into the window object
+                    //Fire the webworks ready event
+                    _webworksReady = true;
+                    fireWebworksReadyEvent();
+                }
+            }
+        };
+        request.send(null);
+
+        execFunc = function (success, fail, service, action, args, sync) {
+            var uri = service + "/" + action,
+                request = new RemoteFunctionCall(uri),
+                name;
+
+            for (name in args) {
+                if (Object.hasOwnProperty.call(args, name)) {
+                    request.addParam(name, args[name]);
+                }
+            }
+
+            request[sync ? "makeSyncCall" : "makeAsyncCall"](success, fail);
+        };
+
+        window.webworks = {
+            exec: execFunc,
+            execSync: function (service, action, args) {
+                var result;
+
+                execFunc(function (data, response) {
+                    result = data;
+                }, function (data, response) {
+                    throw data;
+                }, service, action, args, true);
+
+                return result;
+            },
+            execAsync: function (service, action, args) {
+                var result;
+
+                execFunc(function (data, response) {
+                    result = data;
+                }, function (data, response) {
+                    throw data;
+                }, service, action, args, false);
+
+                return result;
+            },
+            successCallback: function (id, args) {
+                //HACK: this will live later
+                throw "not implemented";
+            },
+            errorCallback: function (id, args) {
+                //HACK: this will live later
+                throw "not implemented";
+            },
+            defineReadOnlyField: function (obj, field, value) {
+                Object.defineProperty(obj, field, {
+                    "value": value,
+                    "writable": false
+                });
+            },
+            event: require("event")
+        };
+    }
+    //Only start building window.webworks once the DOMContent is loaded
+    document.addEventListener('DOMContentLoaded', createWebworksReady, false);
+    //If the DOM Content has already been loaded then create window.webworks immediately
+    if (document.readyState === 'complete') {
+        createWebworksReady();
+    } 
+}());
+
+
+}());
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-cordova-blackberry-webworks/blob/98b4c9a2/bin/templates/project/www/qnx/config.xml
----------------------------------------------------------------------
diff --git a/bin/templates/project/www/qnx/config.xml b/bin/templates/project/www/qnx/config.xml
new file mode 100644
index 0000000..971dfd3
--- /dev/null
+++ b/bin/templates/project/www/qnx/config.xml
@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+       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.
+-->
+<!--
+  Widget Configuration Reference:
+    http://docs.blackberry.com/en/developers/deliverables/15274/
+-->
+
+<widget xmlns="http://www.w3.org/ns/widgets"
+        xmlns:rim="http://www.blackberry.com/ns/widgets"
+	version="1.0.0.0" id="__NAME__">
+
+  <name>__NAME__</name>
+
+  <author>Your Name Here</author>
+
+  <description>
+       A sample Apache Cordova application that responds to the deviceready event.
+  </description>
+    
+  <license href="http://opensource.org/licenses/alphabetical">
+  </license>
+
+  <!-- Cordova API -->
+  <feature id="blackberry.system" required="true" version="1.0.0.0" />
+  <feature id="blackberry.identity" required="true" version="1.0.0.0" />
+  <feature id="blackberry.app" required="true" version="1.0.0.0" />
+  <feature id="blackberry.ui.dialog" />
+  <feature id="blackberry.connection" />
+  
+  <!-- Cordova API -->
+  <access subdomains="true" uri="file:///store/home" />
+  <access subdomains="true" uri="file:///SDCard" />
+
+  <!-- Expose access to all URIs, including the file and http protocols -->
+  <access subdomains="true" uri="*" />
+
+  <icon rim:hover="false" src="res/icon/cordova_bb_80.png" />
+  <icon rim:hover="true" src="res/icon/cordova_bb_80.png" />
+
+  <rim:loadingScreen backgroundColor="#CFCFCF"
+                     foregroundImage="res/screen/blackberry_transparent_300.png"
+		     onFirstLaunch="true">
+    <rim:transitionEffect type="fadeOut" />
+  </rim:loadingScreen>
+
+  <content src="index.html" />
+
+  <rim:permissions>
+    <rim:permit>use_camera</rim:permit>
+    <rim:permit>read_device_identifying_information</rim:permit>
+    <rim:permit>access_shared</rim:permit>
+    <rim:permit>read_geolocation</rim:permit>
+    <rim:permit>record_audio</rim:permit> 
+  </rim:permissions>
+
+</widget>


Mime
View raw message