cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dblot...@apache.org
Subject [09/15] docs commit: Snapshotting dev to 6.x.
Date Sat, 19 Mar 2016 09:36:25 GMT
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/e3751865/www/docs/en/6.x/gen/cordova-plugin-whitelist.md
----------------------------------------------------------------------
diff --git a/www/docs/en/6.x/gen/cordova-plugin-whitelist.md b/www/docs/en/6.x/gen/cordova-plugin-whitelist.md
deleted file mode 100644
index 9bf6b39..0000000
--- a/www/docs/en/6.x/gen/cordova-plugin-whitelist.md
+++ /dev/null
@@ -1,158 +0,0 @@
----
-edit_link: 'https://github.com/apache/cordova-plugin-whitelist/blob/master/README.md'
-permalink: /docs/en/6.x/cordova-plugin-whitelist/index.html
-plugin_name: cordova-plugin-whitelist
-plugin_version: master
----
-
-<!--
-# license: 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.
--->
-
-# cordova-plugin-whitelist
-
-This plugin implements a whitelist policy for navigating the application webview on Cordova 4.0
-
-:warning: Report issues on the [Apache Cordova issue tracker](https://issues.apache.org/jira/issues/?jql=project%20%3D%20CB%20AND%20status%20in%20%28Open%2C%20%22In%20Progress%22%2C%20Reopened%29%20AND%20resolution%20%3D%20Unresolved%20AND%20component%20%3D%20%22Plugin%20Whitelist%22%20ORDER%20BY%20priority%20DESC%2C%20summary%20ASC%2C%20updatedDate%20DESC)
-
-
-## Supported Cordova Platforms
-
-* Android 4.0.0 or above
-
-## Navigation Whitelist
-Controls which URLs the WebView itself can be navigated to. Applies to
-top-level navigations only.
-
-Quirks: on Android it also applies to iframes for non-http(s) schemes.
-
-By default, navigations only to `file://` URLs, are allowed. To allow others URLs, you must add `<allow-navigation>` tags to your `config.xml`:
-
-    <!-- Allow links to example.com -->
-    <allow-navigation href="http://example.com/*" />
-
-    <!-- Wildcards are allowed for the protocol, as a prefix
-         to the host, or as a suffix to the path -->
-    <allow-navigation href="*://*.example.com/*" />
-
-    <!-- A wildcard can be used to whitelist the entire network,
-         over HTTP and HTTPS.
-         *NOT RECOMMENDED* -->
-    <allow-navigation href="*" />
-
-    <!-- The above is equivalent to these three declarations -->
-    <allow-navigation href="http://*/*" />
-    <allow-navigation href="https://*/*" />
-    <allow-navigation href="data:*" />
-
-## Intent Whitelist
-Controls which URLs the app is allowed to ask the system to open.
-By default, no external URLs are allowed.
-
-On Android, this equates to sending an intent of type BROWSEABLE.
-
-This whitelist does not apply to plugins, only hyperlinks and calls to `window.open()`.
-
-In `config.xml`, add `<allow-intent>` tags, like this:
-
-    <!-- Allow links to web pages to open in a browser -->
-    <allow-intent href="http://*/*" />
-    <allow-intent href="https://*/*" />
-
-    <!-- Allow links to example.com to open in a browser -->
-    <allow-intent href="http://example.com/*" />
-
-    <!-- Wildcards are allowed for the protocol, as a prefix
-         to the host, or as a suffix to the path -->
-    <allow-intent href="*://*.example.com/*" />
-
-    <!-- Allow SMS links to open messaging app -->
-    <allow-intent href="sms:*" />
-
-    <!-- Allow tel: links to open the dialer -->
-    <allow-intent href="tel:*" />
-
-    <!-- Allow geo: links to open maps -->
-    <allow-intent href="geo:*" />
-
-    <!-- Allow all unrecognized URLs to open installed apps
-         *NOT RECOMMENDED* -->
-    <allow-intent href="*" />
-
-## Network Request Whitelist
-Controls which network requests (images, XHRs, etc) are allowed to be made (via cordova native hooks).
-
-Note: We suggest you use a Content Security Policy (see below), which is more secure.  This whitelist is mostly historical for webviews which do not support CSP.
-
-In `config.xml`, add `<access>` tags, like this:
-
-    <!-- Allow images, xhrs, etc. to google.com -->
-    <access origin="http://google.com" />
-    <access origin="https://google.com" />
-
-    <!-- Access to the subdomain maps.google.com -->
-    <access origin="http://maps.google.com" />
-
-    <!-- Access to all the subdomains on google.com -->
-    <access origin="http://*.google.com" />
-
-    <!-- Enable requests to content: URLs -->
-    <access origin="content:///*" />
-
-    <!-- Don't block any requests -->
-    <access origin="*" />
-
-Without any `<access>` tags, only requests to `file://` URLs are allowed. However, the default Cordova application includes `<access origin="*">` by default.
-
-
-Note: Whitelist cannot block network redirects from a whitelisted remote website (i.e. http or https) to a non-whitelisted website. Use CSP rules to mitigate redirects to non-whitelisted websites for webviews that support CSP.
-
-Quirk: Android also allows requests to https://ssl.gstatic.com/accessibility/javascript/android/ by default, since this is required for TalkBack to function properly.
-
-### Content Security Policy
-Controls which network requests (images, XHRs, etc) are allowed to be made (via webview directly).
-
-On Android and iOS, the network request whitelist (see above) is not able to filter all types of requests (e.g. `<video>` & WebSockets are not blocked). So, in addition to the whitelist, you should use a [Content Security Policy](http://content-security-policy.com/) `<meta>` tag on all of your pages.
-
-On Android, support for CSP within the system webview starts with KitKat (but is available on all versions using Crosswalk WebView).
-
-Here are some example CSP declarations for your `.html` pages:
-
-    <!-- Good default declaration:
-        * gap: is required only on iOS (when using UIWebView) and is needed for JS->native communication
-        * https://ssl.gstatic.com is required only on Android and is needed for TalkBack to function properly
-        * Disables use of eval() and inline scripts in order to mitigate risk of XSS vulnerabilities. To change this:
-            * Enable inline JS: add 'unsafe-inline' to default-src
-            * Enable eval(): add 'unsafe-eval' to default-src
-    -->
-    <meta http-equiv="Content-Security-Policy" content="default-src 'self' data: gap: https://ssl.gstatic.com; style-src 'self' 'unsafe-inline'; media-src *">
-
-    <!-- Allow everything but only from the same origin and foo.com -->
-    <meta http-equiv="Content-Security-Policy" content="default-src 'self' foo.com">
-
-    <!-- This policy allows everything (eg CSS, AJAX, object, frame, media, etc) except that 
-        * CSS only from the same origin and inline styles,
-        * scripts only from the same origin and inline styles, and eval()
-    -->
-    <meta http-equiv="Content-Security-Policy" content="default-src *; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline' 'unsafe-eval'">
-
-    <!-- Allows XHRs only over HTTPS on the same domain. -->
-    <meta http-equiv="Content-Security-Policy" content="default-src 'self' https:">
-
-    <!-- Allow iframe to https://cordova.apache.org/ -->
-    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; frame-src 'self' https://cordova.apache.org">

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/e3751865/www/docs/en/6.x/gen/cordova.md
----------------------------------------------------------------------
diff --git a/www/docs/en/6.x/gen/cordova.md b/www/docs/en/6.x/gen/cordova.md
deleted file mode 100644
index d78f22e..0000000
--- a/www/docs/en/6.x/gen/cordova.md
+++ /dev/null
@@ -1,586 +0,0 @@
----
-edit_link: 'https://github.com/apache/cordova-cli/blob/master/doc/readme.md'
-permalink: /docs/en/6.x/cordova-cli/index.html
-title: CLI Reference
-description: Learn how to use Cordova CLI commands and their options.
----
-
-<!--
-#
-# 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.
-#
--->
-
-# Cordova Command-line-interface (CLI) Reference
-
-## Syntax
-
-```bash
-cordova <command> [options] -- [platformOpts]
-```
-
-## Global Command List
-
-These commands are available at all times.
-
-| Command  | Description
-|----------|--------------
-| create | Create a project
-| help <command> | Get help for a command
-
-## Project Command List
-
-These commands are supported when the current working directory is a valid Cordova project.
-
-| Command      | Description
-|--------------|--------------
-| info         | Generate project information
-| requirements | Checks and print out all the installation requirements for platforms specified
-| platform     | Manage project platforms
-| plugin       | Manage project plugins
-| prepare      | Copy files into platform(s) for building
-| compile      | Build platform(s)
-| clean        | Cleanup project from build artifacts
-| run          | Run project (including prepare && compile)
-| serve        | Run project with a local webserver (including prepare)
-
-## Common options
-
-These options apply to all cordova-cli commands.
-
-| Option               | Description
-|----------------------|------------------------
-| -d or --verbose      | Pipe out more verbose output to your shell. You can also subscribe to `log` and `warn` events if you are consuming `cordova-cli` as a node module by calling `cordova.on('log', function() {})` or `cordova.on('warn', function() {})`.
-| -v or --version      | Print out the version of your `cordova-cli` install.
-| --no-update-notifier | Will disable updates check. Alternatively set `"optOut": true` in `~/.config/configstore/update-notifier-cordova.json` or set `NO_UPDATE_NOTIFIER` environment variable with any value (see details in [update-notifier docs](https://www.npmjs.com/package/update-notifier#user-settings)).
-|--nohooks             | Suppress executing hooks (taking RegExp hook patterns as parameters)
-
-## Platform-specific options
-
-Certain commands have options (`platformOpts`) that are specific to a particular platform. They can be provided to the cordova-cli with a '--' separator that stops the command parsing within the cordova-lib module and passes through rest of the options for platforms to parse.   
-
-## Examples
--  This example demonstrates how cordova-cli can be used to create a project with the `camera` plugin and run it for `android` platform. In particular, platform specific options like `--keystore` can be provided:
-          
-        # Create a cordova project
-        cordova create myApp com.myCompany.myApp myApp
-        cd myApp
-        # Add camera plugin to the project and remember that in config.xml
-        cordova plugin add cordova-plugin-camera --save
-        # Add android platform to the project and remember that in config.xml
-        cordova platform add android --save
-        # Check to see if your system is configured for building android platform.
-        cordova requirements android
-        # Build the android and emit verbose logs.
-        cordova build android --verbose
-        # Run the project on the android platform.
-        cordova run android
-        # Build for android platform in release mode with specified signing parameters.
-        cordova build android --release -- --keystore="..\android.keystore" --storePassword=android --alias=mykey
-
-## cordova create command
-
-### Synopsis
-
-Create the directory structure for the Cordova project in the specified path.
-
-### Syntax
-
-```
-cordova create path [id [name [config]]] [options]
-```
-
-| Value | Description   |
-|-------|---------------|
-| path  |  Directory which should not already exist. Cordova will create this directory. For more details on the directory structure, see below. |
-| id    | _Default_: `io.cordova.hellocordova` <br/>  Reverse domain-style identifier that maps to `id` attirbute of `widget` element in `config.xml`. This can be changed but there may be code generated using this value, such as Java package names. It is recommended that you select an appropriate value.  |
-| name  | _Default_: `HelloCordova` <br/> Application's display title that maps `name` element in `config.xml` file. This can be changed but there may be code generated using this value, such as Java class names. The default value is `HelloCordova`, but it is recommended that you select an appropriate value. |
-| config | JSON string whose key/values will be included in `<path>`/.cordova/config.json |
-
-### Options
-
-| Option | Description |
-|--------|-------------|
-| --template |  Use a custom template located locally, in NPM, or GitHub. |
-| --copy-from\|--src | _Deprecated_ <br/> Use --template instead. Specifies a directory from which to copy the current Cordova project. |
-|--link-to | Symlink to specified `www` directory without creating a copy. |
-
-### Directory structure
-
-A Cordova application created with `cordova-cli` will have the following directory structure:
-
-```
-myapp/
-|-- config.xml
-|-- hooks/
-|-- merges/
-| | |-- android/
-| | |-- windows/
-| | |-- ios/
-|-- www/
-|-- platforms/
-| |-- android/
-| |-- windows/
-| |-- ios/
--- plugins/
-```
-
-#### config.xml
-
-Configures your application and allows you to customize the behavior of your project. See also [config.xml reference documentation][config.xml ref]
-
-#### www/
-
-Contains the project's web artifacts, such as .html, .css and .js files. As a cordova application developer, most of your code and assets will go here. They will be copied on a `cordova prepare` to each platform's www directory. The www source directory is reproduced within each platform's subdirectory, appearing for example in `platforms/ios/www` or `platforms/android/assets/www`. Because the CLI constantly copies over files from the source www folder, you should only edit these files and not the ones located under the platforms subdirectories. If you use version control software, you should add this source www folder, along with the merges folder, to your version control system.
-
-#### platforms/
-
-Contains all the source code and build scripts for the platforms that you add to your project.
-
-> **WARNING:** When using the CLI to build your application, you should not edit any files in the /platforms/ directory unless you know what you are doing, or if documentation specifies otherwise. The files in this directory are routinely overwritten when preparing applications for building, or when plugins are re-installed.
-
-#### plugins/
-
-Any added plugins will be extracted or copied into this directory.
-
-#### hooks/
-
-This directory may contains scripts used to customize cordova-cli commands. Any scripts you add to these directories will be executed before and after the commands corresponding to the directory name. Useful for integrating your own build systems or integrating with version control systems.
-
-Refer to [Hooks Guide] for more information.
-
-#### merges/
-
-Platform-specific web assets (HTML, CSS and JavaScript files) are contained within appropriate subfolders in this directory. These are deployed during a `prepare` to the appropriate native directory.  Files placed under `merges/` will override matching files in the `www/` folder for the relevant platform. A quick example, assuming a project structure of:
-
-```
-merges/
-|-- ios/
-| -- app.js
-|-- android/
-| -- android.js
-www/
--- app.js
-```
-
-After building the Android and iOS projects, the Android application will contain both `app.js` and `android.js`. However, the iOS application will only contain an `app.js`, and it will be the one from `merges/ios/app.js`, overriding the "common" `app.js` located inside `www/`.
-
-#### Version control
-
-It is recommended not to check in `platforms/` and `plugins/` directories into version control as they are considered a build artifact. Instead, you should save the platform/plugin spec in the `config.xml` and they will be downloaded when on the machine when `cordova prepare` is invoked.
-
-### Examples
-
-- Create a Cordova project in `myapp` directory using the specified ID and display name:
-
-        cordova create myapp com.mycompany.myteam.myapp MyApp
-
-- Create a Cordova project with a symlink to an existing `www` directory. This can be useful if you have a custom build process or existing web assets that you want to use in your Cordova app:
-
-        cordova create myapp --link-to=../www
-
-
-## cordova platform command
-
-### Synopsis
-
-Manage cordova platforms - allowing you to add, remove, update, list and check for updates. Running commands to add or remove platforms affects the contents of the project's platforms directory.
-
-### Syntax
-
-```bash
-cordova {platform | platforms} [
-    add <platform-spec> [...] {--save | link=<path> } |
-    {remove | rm}  platform [...] |
-    {list | ls}  |
-    check |
-    save ]
-```
-
-| Sub-command           | Option | Description |
-------------------------|-------------|------|
-| add `<platform-spec>` [...] |  | Add specified platforms |
-|     | --save                   | Save `<platform-spec>` into `config.xml` after installing them using `<engine>` tag |
-|     | --link=`<path>`          | When `<platform-spec>` is a local path, links the platform library directly instead of making a copy of it (support varies by platform; useful for platform development)
-| remove `<platform>` [...] |    | Remove specified platforms |
-|     | --save                   | Delete specified platforms from `config.xml` after removing them |
-| update `platform` [...] |      | Update specified platforms |
-|     | --save                   | Updates the version specified in `config.xml` |
-| list |                         | List all installed and available platforms |
-| check |                        | List platforms which can be updated by `cordova-cli platform update` |
-| save  |                        | Save `<platform-spec>` of all platforms added to config.xml |
-
-### Platform-spec
-
-There are a number of ways to specify a platform:
-
-```
-<platform-spec> : platform[@version] | path | url[#commit-ish]
-```
-
-| Value | Description |
-|-----------|-------------|
-| platform  | Platform name e.g. android, ios, windows etc. to be added to the project. Every release of cordova CLI pins a version for each platform. When no version is specified this version is used to add the platform. |
-| version   | Major.minor.patch version specifier using semver |
-| path      | Path to a directory or tarball containing a platform |
-| url       | URL to a git repository or tarball containing a platform |
-| commit-ish | Commit/tag/branch reference. If none is specified, 'master' is used |
-
-### Supported Platforms
-
-- Android
-- iOS
-- Windows (8.1, Phone 8.1, UWP - Windows 10)
-- Blackberry10
-- Ubuntu
-- Browser
-
-### Deprecated Platforms
-
-- Amazon-fireos (use Android platform instead)
-- WP8 (use Windows platform instead)
-- Windows 8.0 (use older versions of cordova)
-- Firefox OS (use older versions of cordova)
-
-### Examples
-
-- Add pinned version of the `android` and `ios` platform and save the downloaded version to `config.xml`:
-
-        cordova platform add android ios --save
-
-- Add `android` platform with [semver](http://semver.org/) version ^5.0.0 and save it to `config.xml`:
-
-        cordova platform add android@^5.0.0 --save
-
-- Add platform by cloning the specified git repo and checkout to the `4.0.0` tag:
-
-        cordova platform add https://github.com/myfork/cordova-android.git#4.0.0
-
-- Add platform using a local directory named `android`:
-
-        cordova platform add ../android
-
-- Add platform using the specified tarball:
-
-        cordova platform add ../cordova-android.tgz
-
-- Remove `android` platform from the project and from `config.xml`:
-
-        cordova platform rm android --save
-
-- List available and installed platforms with version numbers. This is useful to find version numbers when reporting issues:
-
-        cordova platform ls
-
-- Save versions of all platforms currently added to the project to `config.xml`.
-
-        cordova platform save
-
-## cordova plugin command
-
-### Synopsis
-
-Manage project plugins
-
-### Syntax
-
-```bash
-cordova {plugin | plugins} [
-    add <plugin-spec> [..] {--searchpath=<directory> | --noregistry | --link | --save | --browserify} |
-    {remove | rm} {<pluginid> | <name>} --save |
-    {list | ls} |
-    search [<keyword>] |
-    save |
-]
-```
-
-| Sub-command | Option | Description
-|------------------------|-------------|------
-| add `<plugin-spec>` [...] |     | Add specified plugins
-|       |--searchpath `<directory>` | When looking up plugins by ID, look in this directory and each of its subdirectories before hitting the registry. Multiple search paths can be specified. Use ':' as a separator in *nix based systems and ';' for Windows.
-|       |--noregistry             | Don't search the registry for plugins.
-|       |--link                   | When installing from a local path, creates a symbolic link instead of copying files. The extent to which files are linked varies by platform. Useful for plugin development.
-|       |--save                   | Save the `<plugin-spec>` as part of the `plugin` element  into `config.xml`.
-|       |--browserify             | Compile plugin JS at build time using browserify instead of runtime.
-| remove `<pluginid>|<name>` [...]| | Remove plugins with the given IDs/name.
-|       |--save                    | Remove the specified plugin from config.xml
-|list                           |  | List currently installed plugins
-|search `[<keyword>]` [...]     |  | Search http://plugins.cordova.io for plugins matching the keywords
-|save                           |  | Save `<plugin-spec>` of all plugins currently added to the project
-
-### Plugin-spec
-
-There are a number of ways to specify a plugin:
-
-    <plugin-spec> : pluginID[@version]|directory|url[#commit-ish][:subdir]
-
-| Value       | Description
-|-------------|--------------------
-| plugin      | Plugin id (id of plugin in npm registry or in --searchPath)
-| version     | Major.minor.patch version specifier using semver
-| directory   | Directory containing plugin.xml
-| url         | Url to a git repository containing a plugin.xml
-| commit-ish  | Commit/tag/branch reference. If none is specified, 'master' is used
-| subdir      | Sub-directory to find plugin.xml for the specified plugin.
-
-### Examples
-
-- Add `cordova-plugin-camera` and `cordova-plugin-file` to the project and save it to `config.xml`. Use `../plugins` directory to search for the plugins.
-
-        cordova plugin add cordova-plugin-camera cordova-plugin-file --save --searchpath ../plugins
-
-- Add `cordova-plugin-camera` with [semver](http://semver.org/) version ^2.0.0 and save it to `config.xml`:
-
-        cordova plugin add cordova-plugin-camera@^2.0.0 --save
-
-- Clone the specified git repo, checkout to tag `2.1.0`, look for plugin.xml in the `plugin` directory, and add it to the project. Save the `plugin-spec` to `config.xml`:
-
-        cordova plugin add https://github.com/apache/cordova-plugin-camera.git#2.1.0:plugin --save
-
-- Add the plugin from the specified local directory:
-
-        cordova plugin add ../cordova-plugin-camera
-
-- Add the plugin from the specified tarball file:
-
-        cordova plugin add ../cordova-plugin-camera.tgz --save
-
-- Remove the plugin from the project and the `config.xml`:
-
-        cordova plugin rm camera --save
-
-- List all plugins installed in the project:
-
-        cordova plugin ls
-
-## cordova prepare command
-
-### Synopsis
-
-Transforms config.xml metadata to platform-specific manifest files, copies icons & splashscreens,
-copies plugin files for specified platforms so that the project is ready to build with each native SDK.
-
-### Syntax
-
-```
-cordova prepare [<platform> [..]]
-     [--browserify]
-```
-
-###Options
-
-| Option     | Description
-|------------|------------------
-| `<platform> [..]` | Platform name(s) to prepare. If not specified, all platforms are built.
-|--browserify | Compile plugin JS at build time using browserify instead of runtime.
-
-## cordova compile command
-
-### Synopsis
-
-`cordova compile` is a subset of the [cordova build command](#cordova-build-command).
-It only performs the compilation step without doing prepare. It's common to invoke `cordova build` instead of this command - however, this stage is useful to allow extending using [hooks][Hooks guide].
-
-###Syntax
-
-```bash
-cordova build [<platform> [...]]
-    [--debug|--release]
-    [--device|--emulator|--target=<targetName>]
-    [--buildConfig=<configfile>]
-    [--browserify]
-    [-- <platformOpts>]
-```
-For detailed documentation see [cordova build command](#cordova-build-command) docs below.
-
-## cordova build command
-
-### Synopsis
-
-Shortcut for `cordova prepare` + `cordova compile` for all/the specified platforms. Allows you to build the app for the specified platform.
-
-### Syntax
-
-```bash
-cordova build [<platform> [...]]
-    [--debug|--release]
-    [--device|--emulator]
-    [--buildConfig=<configfile>]
-    [--browserify]
-    [-- <platformOpts>]
-```
-
-| Option     | Description
-|------------|------------------
-| `<platform> [..]` | Platform name(s) to build. If not specified, all platforms are built.
-| --debug    | Perform a debug build. This typically translates to debug mode for the underlying platform being built.
-| --release  | Perform a release build. This typically translates to release mode for the underlying platform being built.
-| --device   | Build it for a device
-| --emulator | Build it for an emulator. In particular, the platform architecture might be different for a device Vs emulator.
-| --buildConfig=`<configFile>` | Default: build.json in cordova root directory. <br/> Use the specified build configuration file. `build.json` file is used to specify paramaters to customize the app build process esecially related to signing the package.
-| --browserify | Compile plugin JS at build time using browserify instead of runtime
-| `<platformOpts>` | To provide platform specific options, you must include them after `--` separator. Review platform guide docs for more details.
-
-### Examples
-
-- Build for `android` and `windows` platform in `debug` mode for deployment to device:
-
-        cordova build android windows --debug --device
-
-- Build for `android` platform in `release` mode and use the specified build configuration:
-
-        cordova build android --release --buildConfig=..\myBuildConfig.json
-
-- Build for `android` platform in release mode and pass custom platform options to android build process:
-
-        cordova build android --release -- --keystore="..\android.keystore" --storePassword=android --alias=mykey
-
-## cordova run command
-
-### Synopsis
-
-Prepares, builds (unless `--nobuild` is specified) and deploys app on specified platform devices/emulators. If a device is connected it will be used, unless an eligible emulator is already running.
-
-###Syntax
-
-```bash
-cordova run [<platform> [...]]
-    [--list | --nobuild ]
-    [--device|--emulator|--target=<targetName>]
-    [--buildConfig=<configfile>]
-    [--browserify]
-    [-- <platformOpts>]
-```
-
-| Option     | Description
-|------------|------------------
-| `<platform> [..]` | Platform name(s) to run. If not specified, all platforms are run.
-|--nobuild   | Skip building
-|--debug     | Deploy a debug build. This is the default behavior unless `--release` is specified.
-|--release   | Deploy a release build
-|--device    | Deploy to a device
-|--emulator  | Deploy to an emulator
-|--target    | Deploy to a specific target emulator/device. Use `--list` to display target options
-| --list     | Lists available targets. Displays both device and emulator deployment targets unless specified
-| --buildConfig=`<configFile>` | Default: build.json in cordova root directory. <br/> Use the specified build configuration file. `build.json` file is used to specify paramaters to customize the app build process esecially related to signing the package.
-| --browserify | Compile plugin JS at build time using browserify instead of runtime
-| `<platformOpts>` | To provide platform specific options, you must include them after `--` separator. Review platform guide docs for more details.
-
-###Examples
-
-- Run a release build of current cordova project on `android` platform emulator named `Nexus_5_API_23_x86`. Use the spcified build configuration when running:
-
-        cordova run android --release --buildConfig=..\myBuildConfig.json --target=Nexus_5_API_23_x86
-
-- Run a debug build of current cordova project on `android` platform using a device or emulator (if no device is connected). Skip doing the build:
-
-        cordova run android --nobuild
-
-- Run a debug build of current cordova project on an `ios` device:
-
-        cordova run ios --device
-
-- Enumerate names of all the connected devices and available emulators that can be used to run this app:
-
-        cordova run ios --list
-
-
-## cordova emulate command
-
-### Synopsis
-
-Alias for `cordova run --emulator`. Launches the emulator instead of device.
-See [cordova run command docs](#cordova-run-command) for more details.
-
-## cordova clean command
-
-### Synopsis
-
-Cleans the build artifacts for the specified platform, or all platforms by running platform-specific build cleanup.
-
-### Syntax
-
-```
-cordova clean [<platform> [...]]
-```
-
-### Example
-
-- Clean `android` platform build artifiacts:
-
-        cordova clean android
-
-
-## cordova requirements command
-
-### Synopsis
-
-Checks and print out all the requirements for platforms specified (or all platforms added
-to project if none specified). If all requirements for each platform are met, exits with code 0
-otherwise exits with non-zero code.
-
-This can be useful when setting up a machine for building a particular platform.
-
-### Syntax
-
-```
-cordova requirements android
-```
-
-## cordova info command
-
-### Synopsis
-
-Print out useful information helpful for submitting bug
-reports and getting help.  Creates an info.txt file at the
-base of your project.
-
-### Syntax
-
-```
-cordova info
-```
-
-## cordova serve command
-
-### Synopsis
-
-Run a local web server for www/ assets using specified `port` or default of 8000. Access projects at: `http://HOST_IP:PORT/PLATFORM/www`
-
-### Syntax
-
-```
-cordova serve [port]
-```
-
-## cordova help command
-
-### Synopsis
-
-Show syntax summary, or the help for a specific command.
-
-### Syntax
-
-```
-cordova help [command]
-cordova [command] -h
-cordova -h [command]
-```
-
-[Hooks guide]: http://cordova.apache.org/docs/en/latest/guide_appdev_hooks_index.md.html
-[config.xml ref]: http://cordova.apache.org/docs/en/latest/config_ref/index.html

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/e3751865/www/docs/en/6.x/guide/appdev/hooks/index.md
----------------------------------------------------------------------
diff --git a/www/docs/en/6.x/guide/appdev/hooks/index.md b/www/docs/en/6.x/guide/appdev/hooks/index.md
index 454f2e5..8fb4818 100644
--- a/www/docs/en/6.x/guide/appdev/hooks/index.md
+++ b/www/docs/en/6.x/guide/appdev/hooks/index.md
@@ -44,6 +44,9 @@ Cordova supports the following hook types:
 <!-- START HTML -->
 
 <table class="hooks" width="100%">
+    <col width="20%">
+    <col width="30%">
+    <col width="50%">
     <thead>
         <tr>
             <th>Hook Type</th>
@@ -54,7 +57,7 @@ Cordova supports the following hook types:
     <tbody>
         <tr>
             <th data-col="beforeplatformadd">before_platform_add</th>
-            <td data-col="code" rowspan="2"><code>cordova platform add</code></td>
+            <td data-col="code" rowspan="2" ><code>cordova platform add</code></td>
             <td rowspan="2" class="description" data-col="description">To be executed before and after adding a platform.</td>
         </tr>
         <tr>
@@ -78,7 +81,7 @@ Cordova supports the following hook types:
         </tr>
         <tr>
             <th data-col="beforeprepare">before_prepare</th>
-            <td data-col="code" rowspan="2"><code>cordova prepare</code><br/><code>cordova platform add</code><br/><code>cordova run</code></td>
+            <td data-col="code" rowspan="2"><code>cordova prepare</code><br/><code>cordova platform add</code><br/><code>cordova build</code><br/><code>cordova run</code></td>
             <td rowspan="2" data-col="description">To be executed before and after preparing your application.</td>
         </tr>
         <tr>
@@ -86,7 +89,7 @@ Cordova supports the following hook types:
         </tr>
         <tr>
             <th data-col="beforecompile">before_compile</th>
-            <td data-col="code" rowspan="2"><code>cordova compile</code><br/><code>cordova run</code></td>
+            <td data-col="code" rowspan="2"><code>cordova compile</code><br/><code>cordova build</code></td>
             <td rowspan="2" data-col="description">To be executed before and after compiling your application.</td>
         </tr>
         <tr>
@@ -94,7 +97,7 @@ Cordova supports the following hook types:
         </tr>
         <tr>
             <th data-col="beforebuild">before_build</th>
-            <td data-col="code" rowspan="2"><code>cordova build</code><br/><code>cordova run</code></td>
+            <td data-col="code" rowspan="2"><code>cordova build</code></td>
             <td rowspan="2" data-col="description">To be executed before and after building your application.</td>
         </tr>
         <tr>
@@ -193,36 +196,40 @@ Cordova supports the following hook types:
 
 Hooks could be defined in project's `config.xml` using `<hook>` elements, for example:
 
-    <hook type="before_build" src="scripts/appBeforeBuild.bat" />
-    <hook type="before_build" src="scripts/appBeforeBuild.js" />
-    <hook type="before_plugin_install" src="scripts/appBeforePluginInstall.js" />
+```xml
+<hook type="before_build" src="scripts/appBeforeBuild.bat" />
+<hook type="before_build" src="scripts/appBeforeBuild.js" />
+<hook type="before_plugin_install" src="scripts/appBeforePluginInstall.js" />
 
-    <platform name="android">
-        <hook type="before_build" src="scripts/wp8/appAndroidBeforeBuild.bat" />
-        <hook type="before_build" src="scripts/wp8/appAndroidBeforeBuild.js" />
-        <hook type="before_plugin_install" src="scripts/wp8/appWP8BeforePluginInstall.js" />
-        ...
-    </platform>
+<platform name="android">
+    <hook type="before_build" src="scripts/wp8/appAndroidBeforeBuild.bat" />
+    <hook type="before_build" src="scripts/wp8/appAndroidBeforeBuild.js" />
+    <hook type="before_plugin_install" src="scripts/wp8/appWP8BeforePluginInstall.js" />
+    ...
+</platform>
 
-    <platform name="windows">
-        <hook type="before_build" src="scripts/windows/appWinBeforeBuild.bat" />
-        <hook type="before_build" src="scripts/windows/appWinBeforeBuild.js" />
-        <hook type="before_plugin_install" src="scripts/windows/appWinBeforePluginInstall.js" />
-        ...
-    </platform>
+<platform name="windows">
+    <hook type="before_build" src="scripts/windows/appWinBeforeBuild.bat" />
+    <hook type="before_build" src="scripts/windows/appWinBeforeBuild.js" />
+    <hook type="before_plugin_install" src="scripts/windows/appWinBeforePluginInstall.js" />
+    ...
+</platform>
+```
 
 ### Plugin hooks (plugin.xml)
 
 As a plugin developer you can define hook scripts using `<hook>` elements in a `plugin.xml` like that:
 
-    <hook type="before_plugin_install" src="scripts/beforeInstall.js" />
-    <hook type="after_build" src="scripts/afterBuild.js" />
+```xml
+<hook type="before_plugin_install" src="scripts/beforeInstall.js" />
+<hook type="after_build" src="scripts/afterBuild.js" />
 
-    <platform name="android">
-        <hook type="before_plugin_install" src="scripts/androidBeforeInstall.js" />
-        <hook type="before_build" src="scripts/androidBeforeBuild.js" />
-        ...
-    </platform>
+<platform name="android">
+    <hook type="before_plugin_install" src="scripts/androidBeforeInstall.js" />
+    <hook type="before_build" src="scripts/androidBeforeBuild.js" />
+    ...
+</platform>
+```
 
 `before_plugin_install`, `after_plugin_install`, `before_plugin_uninstall` plugin hooks will be fired
 exclusively for the plugin being installed/uninstalled.
@@ -231,8 +238,10 @@ exclusively for the plugin being installed/uninstalled.
 
 To execute custom action when corresponding hook type is fired, use hook type as a name for a subfolder inside 'hooks' directory and place you script file here, for example:
 
-    # script file will be automatically executed after each build
-    hooks/after_build/after_build_custom_action.js
+```
+# script file will be automatically executed after each build
+hooks/after_build/after_build_custom_action.js
+```
 
 When using these hooks, they will always be run as executable files, not as loadable JavaScript modules.
 
@@ -261,30 +270,36 @@ If there are hooks associated with `before_platform_add`, `after_platform_add`,
 `before_plugin_install` and `after_plugin_install` (and assuming you have one plugin installed on your project),
 adding a new platform will execute the hooks in the following order:
 
-    before_platform_add
-        before_prepare
-        after_prepare
-        before_plugin_install
-        after_plugin_install
-    after_platform_add
+```
+before_platform_add
+    before_prepare
+    after_prepare
+    before_plugin_install
+    after_plugin_install
+after_platform_add
+```
 
 ##### Example 2 (cordova build)
 If there are hooks associated with `before_prepare`, `after_prepare`, `before_compile`, `after_compile`, `before_build`
 and `after_build` - running a build command will execute the hooks in the following order:
 
-    before_build
-        before_prepare
-        after_prepare
-        before_compile
-        after_compile
-    after_build
+```
+before_build
+    before_prepare
+    after_prepare
+    before_compile
+    after_compile
+after_build
+```
 
 ## Script Interface
 ### Windows Quirks
 
 If you are working on Windows, and in case your hook (Javascript/Non-Javascript)scripts aren't bat files (which is recommended, if you want your scripts to work in non-Windows operating systems) Cordova CLI will expect a shebang line as the first line for it to know the interpreter it needs to use to launch the script. The shebang line should match the following example:
 
-    #!/usr/bin/env [name_of_interpreter_executable]
+```
+#!/usr/bin/env [name_of_interpreter_executable]
+```
 
 ### Javascript
 
@@ -373,35 +388,39 @@ size of generated .apk file for Android platform.
 Create blank Cordova app and add the following definition to `config.xml` to
 tell Cordova to run `afterBuild.js` script after each platform build.
 
-    <hook type="after_build" src="scripts/afterBuild.js" />
+```xml
+<hook type="after_build" src="scripts/afterBuild.js" />
+```
 
 Create `scripts/afterBuild.js` file and add the following implementation.
 We use async version of `fs.stat` method to demonstrate how async functionality
 could be done via hooks.
 
-    module.exports = function(ctx) {
-        // make sure android platform is part of build
-        if (ctx.opts.platforms.indexOf('android') < 0) {
-            return;
+```javascript
+module.exports = function(ctx) {
+    // make sure android platform is part of build
+    if (ctx.opts.platforms.indexOf('android') < 0) {
+        return;
+    }
+    var fs = ctx.requireCordovaModule('fs'),
+        path = ctx.requireCordovaModule('path'),
+        deferral = ctx.requireCordovaModule('q').defer();
+
+    var platformRoot = path.join(ctx.opts.projectRoot, 'platforms/android');
+    var apkFileLocation = path.join(platformRoot, 'build/outputs/apk/android-debug.apk');
+
+    fs.stat(apkFileLocation, function(err,stats) {
+        if (err) {
+                deferral.reject('Operation failed');
+        } else {
+            console.log('Size of ' + apkFileLocation + ' is ' + stats.size +' bytes');
+            deferral.resolve();
         }
-        var fs = ctx.requireCordovaModule('fs'),
-            path = ctx.requireCordovaModule('path'),
-            deferral = ctx.requireCordovaModule('q').defer();
+    });
 
-        var platformRoot = path.join(ctx.opts.projectRoot, 'platforms/android');
-        var apkFileLocation = path.join(platformRoot, 'build/outputs/apk/android-debug.apk');
-
-        fs.stat(apkFileLocation, function(err,stats) {
-            if (err) {
-                 deferral.reject('Operation failed');
-            } else {
-                console.log('Size of ' + apkFileLocation + ' is ' + stats.size +' bytes');
-                deferral.resolve();
-            }
-        });
-
-        return deferral.promise;
-    };
+    return deferral.promise;
+};
+```
 
 Parameter `ctx` in example above is passed by Cordova and represents execution
 context such as script full path, target platform, command-line arguments, etc and
@@ -410,11 +429,13 @@ for more details.
 
 You can now add android platform and execute build.
 
-    cordova platform add android
-    ..
-    cordova build
-    ..
-    Size of path\to\app\platforms\android\build\outputs\apk\android-debug.apk is 1821193 bytes
+```
+cordova platform add android
+..
+cordova build
+..
+Size of path\to\app\platforms\android\build\outputs\apk\android-debug.apk is 1821193 bytes
+```
 
 More good usage examples could be found in [Three Hooks Your Cordova Phone Gap Project needs][Devgirl_Hooks_Link]
 

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/e3751865/www/docs/en/6.x/guide/appdev/whitelist/index.md
----------------------------------------------------------------------
diff --git a/www/docs/en/6.x/guide/appdev/whitelist/index.md b/www/docs/en/6.x/guide/appdev/whitelist/index.md
index 1b4b4b4..674cd16 100644
--- a/www/docs/en/6.x/guide/appdev/whitelist/index.md
+++ b/www/docs/en/6.x/guide/appdev/whitelist/index.md
@@ -42,31 +42,41 @@ enable network access to specific domains. For projects that rely on
 the CLI workflow described in [The Command-Line Interface](../../cli/index.html), this file is
 located in the project's top-level directory. Otherwise for
 platform-specific development paths, locations are listed in the
-sections below. 
+sections below.
 
 The following examples demonstrate `<access>` whitelist syntax:
 
 * Access to [google.com][2]:
 
-        <access origin="http://google.com" />
+    ```xml
+    <access origin="http://google.com" />
+    ```
 
 * Access to the secure [google.com][3] (`https://`):
 
-        <access origin="https://google.com" />
+    ```xml
+    <access origin="https://google.com" />
+    ```
 
 * Access to the subdomain [maps.google.com][4]:
 
-        <access origin="http://maps.google.com" />
+    ```xml
+    <access origin="http://maps.google.com" />
+    ```
 
 * Access to all the subdomains on [google.com][2], for example
   [mail.google.com][5] and [docs.google.com][6]:
 
-        <access origin="http://*.google.com" />
+    ```xml
+    <access origin="http://*.google.com" />
+    ```
 
 * Access to _all_ domains, for example, [google.com][2] and
   [developer.mozilla.org][7]:
 
-        <access origin="*" />
+    ```xml
+    <access origin="*" />
+    ```
 
   This is the default value for newly created CLI projects.
 
@@ -88,7 +98,7 @@ prior to 4.0.0, see older versions of this documentation.
 
 ## iOS Whitelisting
 
-`Cordova-ios` version 4.0 and greater does **not** require the [cordova-plugin-whitelist][wlp] plugin to be installed, however it's configuration details apply to iOS too. The `<allow-intent>` and `<allow-navigation>` tags are _new_ for cordova-ios 4.x and greater, see the [cordova-plugin-whitelist][wlp] documentation for details on the usage of these tags. 
+`Cordova-ios` version 4.0 and greater does **not** require the [cordova-plugin-whitelist][wlp] plugin to be installed, however it's configuration details apply to iOS too. The `<allow-intent>` and `<allow-navigation>` tags are _new_ for cordova-ios 4.x and greater, see the [cordova-plugin-whitelist][wlp] documentation for details on the usage of these tags.
 
 For cordova-ios versions prior to 4.0.0, see the older versions of this documentation.
 
@@ -96,8 +106,8 @@ For cordova-ios versions prior to 4.0.0, see the older versions of this document
 
 The `<access>` and `<allow-navigation>` tags support these two new attributes below, which have their equivalents in ATS:
 
-    1. minimum-tls-version (String, defaults to 'TLSv1.2')
-    2. requires-forward-secrecy (Boolean, defaults to 'true')
+1. minimum-tls-version (String, defaults to 'TLSv1.2')
+2. requires-forward-secrecy (Boolean, defaults to 'true')
 
 See the [ATS Technote](https://developer.apple.com/library/prerelease/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CocoaKeys.html#//apple_ref/doc/uid/TP40009251-SW33) for details.
 
@@ -113,33 +123,34 @@ ways:
   Alternatively, all web security may be disabled using the
   `WebSecurity` preference described in BlackBerry Configuration:
 
-        <preference name="websecurity" value="disable" />
+    ```xml
+    <preference name="websecurity" value="disable" />
+    ```
 
 * As an alternative to setting `*.domain`, set an additional
   `subdomains` attribute to `true`. It should be set to `false` by
-  default. For example, the following allows access to `google.com`,
-  `maps.google.com`, and `docs.google.com`:
+  default.
 
-        <access origin="http://google.com" subdomains="true" />
+    ```xml
+    <!-- Narrows access to google.com -->
+    <access origin="http://google.com" subdomains="false" />
 
-  The following narrows access to `google.com`:
+    <!-- Allows access to maps.google.com and docs.google.com -->
+    <access origin="http://google.com" subdomains="true" />
 
-        <access origin="http://google.com" subdomains="false" />
+    <!-- Allows access to all domains, including the local `file://` protocol -->
+    <access origin="*" subdomains="true" />
+    ```
 
-  Specify access to all domains, including the local `file://`
-  protocol:
-
-        <access origin="*" subdomains="true" />
-
-(For more information on support, see BlackBerry's documentation on the
-[access element][8].)
+For more information on support, see BlackBerry's documentation on the
+[access element][8].
 
 ## Windows Phone Whitelisting
 
 The whitelisting rules for Windows Phone 8 are found in the
 app's `config.xml` file.
 
-[wlp]: ../../../cordova-plugin-whitelist/
+[wlp]: ../../../reference/cordova-plugin-whitelist/
 [1]: http://www.w3.org/TR/widgets-access/
 [2]: http://google.com
 [3]: https://google.com

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/e3751865/www/docs/en/6.x/guide/cli/index.md
----------------------------------------------------------------------
diff --git a/www/docs/en/6.x/guide/cli/index.md b/www/docs/en/6.x/guide/cli/index.md
index 1b9e432..022a497 100644
--- a/www/docs/en/6.x/guide/cli/index.md
+++ b/www/docs/en/6.x/guide/cli/index.md
@@ -29,24 +29,25 @@ interface (CLI). For detailed reference on Cordova command-line, review the [CLI
 
 ## Installing the Cordova CLI
 
-The Cordova command-line tool is distributed as an npm package. 
+The Cordova command-line tool is distributed as an npm package.
 
 To install the `cordova` command-line tool, follow these steps:
 
 1. Download and install [Node.js](https://nodejs.org/en/download/). On
    installation you should be able to invoke `node` and `npm` on your
-   command line. 
+   command line.
 
 1. (Optional) Download and install a [git client](http://git-scm.com/downloads), if you don't
    already have one. Following installation, you should be able to invoke `git`
-   on your command line. The CLI uses it to download assets when they are referenced using a url to a git repo. 
+   on your command line. The CLI uses it to download assets when they are referenced using a url to a git repo.
 
 1. Install the `cordova` module using `npm` utility of Node.js. The `cordova`
    module will automatically be downloaded by the `npm` utility.
 
    * on OS X and Linux:
-
-            $ sudo npm install -g cordova
+       ```bash
+       $ sudo npm install -g cordova
+       ```
 
        On OS X and Linux, prefixing the `npm` command with
        `sudo` may be necessary to install this development utility in
@@ -58,8 +59,9 @@ To install the `cordova` command-line tool, follow these steps:
        available on using `npm` without `sudo`, if you desire to do that.
 
    * on Windows:
-
-            C:\>npm install -g cordova
+       ```
+       C:\>npm install -g cordova
+       ```
 
    The `-g` flag above tells `npm` to install `cordova` globally. Otherwise
    it will be installed in the `node_modules` subdirectory of the current
@@ -73,33 +75,41 @@ To install the `cordova` command-line tool, follow these steps:
 
 Go to the directory where you maintain your source code, and create a cordova project:
 
-        $ cordova create hello com.example.hello HelloWorld
+```bash
+$ cordova create hello com.example.hello HelloWorld
+```
 
-This creates the required directory structure for your cordova app. By default, the `cordova create` script generates a skeletal web-based application whose home page is the project's `www/index.html` file. 
+This creates the required directory structure for your cordova app. By default, the `cordova create` script generates a skeletal web-based application whose home page is the project's `www/index.html` file.
 
 ###See Also
-- [Cordova create command reference documentation](../../cordova-cli/index.html#cordova-create-command)
-- [Cordova project directory structure](../../cordova-cli/index.html#directory-structure)
+- [Cordova create command reference documentation][cdv_create]
+- [Cordova project directory structure][cdv_dir]
 
 ## Add Platforms
 
 All subsequent commands need to be run within the project's directory,
 or any subdirectories:
 
-        $ cd hello
+```bash
+$ cd hello
+```
 
 Add the platforms that you want to target your app. We will add the 'ios' and 'android' platform and ensure they get saved to `config.xml`:
 
-        $ cordova platform add ios --save
-        $ cordova platform add android --save
+```bash
+$ cordova platform add ios --save
+$ cordova platform add android --save
+```
 
 To check your current set of platforms:
 
-        $ cordova platform ls
+```bash
+$ cordova platform ls
+```
 
 Running commands to add or remove platforms affects the contents of
 the project's _platforms_ directory, where each specified platform
-appears as a subdirectory. 
+appears as a subdirectory.
 
 > Note: When using the CLI to build your application, you should
 _not_ edit any files in the `/platforms/` directory. The files
@@ -107,7 +117,7 @@ in this directory are routinely overwritten when preparing
 applications for building, or when plugins are re-installed.
 
 ###See Also
-- [Cordova platform command reference documentation](../../cordova-cli/index.html#cordova-platform-command)
+- [Cordova platform command reference documentation][cdv_platform]
 
 ##Install pre-requrisites for building
 To build and run apps, you need to install SDKs for each platform you wish to target. Alternatively, if you are using browser for development you can use `browser` platform which does not require any platform SDKs.
@@ -115,17 +125,17 @@ To build and run apps, you need to install SDKs for each platform you wish to ta
 To check if you satisfy requirements for building the platform:
 
 ```
-    $ cordova requirements
-    Requirements check results for android:
-    Java JDK: installed .
-    Android SDK: installed
-    Android target: installed android-19,android-21,android-22,android-23,Google Inc.:Google APIs:19,Google Inc.:Google APIs (x86 System Image):19,Google Inc.:Google APIs:23
-    Gradle: installed
-
-    Requirements check results for ios:
-    Apple OS X: not installed
-    Cordova tooling for iOS requires Apple OS X
-    Error: Some of requirements check failed
+$ cordova requirements
+Requirements check results for android:
+Java JDK: installed .
+Android SDK: installed
+Android target: installed android-19,android-21,android-22,android-23,Google Inc.:Google APIs:19,Google Inc.:Google APIs (x86 System Image):19,Google Inc.:Google APIs:23
+Gradle: installed
+
+Requirements check results for ios:
+Apple OS X: not installed
+Cordova tooling for iOS requires Apple OS X
+Error: Some of requirements check failed
 ```
 
 ###See Also
@@ -135,19 +145,23 @@ To check if you satisfy requirements for building the platform:
 
 ## Build the App
 
-By default, `cordova create` script generates a skeletal web-based application whose start page is the project's `www/index.html` file. Any 
-initialization should be specified as part of the [deviceready][DeviceReadyEvent] event handler defined in `www/js/index.js`.  
+By default, `cordova create` script generates a skeletal web-based application whose start page is the project's `www/index.html` file. Any
+initialization should be specified as part of the [deviceready][DeviceReadyEvent] event handler defined in `www/js/index.js`.
 
 Run the following command to build the project for _all_ platforms:
 
-        $ cordova build
+```bash
+$ cordova build
+```
 
 You can optionally limit the scope of each build to specific platforms - 'ios' in this case:
 
-        $ cordova build ios
+```bash
+$ cordova build ios
+```
 
 ###See Also
-- [Cordova build command reference documentation](../../dev/cordova-cli/index.html#cordova-build-command)
+- [Cordova build command reference documentation][cdv_build]
 
 ##Test the App
 
@@ -157,8 +171,9 @@ screen and see how it interacts with many platform features.  Run a
 command such as the following to rebuild the app and view it within a
 specific platform's emulator:
 
-        $ cordova emulate android
-
+```bash
+$ cordova emulate android
+```
 
 ![]({{ site.baseurl }}/static/img/guide/cli/android_emulate_init.png)
 
@@ -171,32 +186,38 @@ launch from the home screen:
 Alternately, you can plug the handset into your computer and test the
 app directly:
 
-        $ cordova run android
+```bash
+$ cordova run android
+```
 
 Before running this command, you need to set up the device for
-testing, following procedures that vary for each platform. 
+testing, following procedures that vary for each platform.
 
 ###See Also
 - [Setting up Android emulator](../../guide/platforms/android/index.html#setting-up-an-emulator)
-- [Cordova run command reference documentation](../../cordova-cli/index.html#cordova-run-command)
-- [Cordova emulate command reference documentation](../../cordova-cli/index.html#cordova-emulate-command)
+- [Cordova run command reference documentation][cdv_run]
+- [Cordova emulate command reference documentation][cdv_emulate]
 
 ## Add Plugins
 
-You can modify the default generated app to take advantage of standard web technologies, 
+You can modify the default generated app to take advantage of standard web technologies,
 but for the app to access device-level features, you need to add plugins.
 
-A _plugin_ exposes a Javascript API for native SDK functionality. Plugins are typically hosted on 
+A _plugin_ exposes a Javascript API for native SDK functionality. Plugins are typically hosted on
 npm and you can search for them on the [plugin search page](/plugins/). Some key APIs are provided by the Apache Cordova open source project and these are referred to as [Core Plugin APIs]. You can also use the CLI to launch the search page:
 
-        $ cordova plugin search camera
-        
+```bash
+$ cordova plugin search camera
+```
+
 To add the camera plugin, we will specify the npm package name for the camera plugin:
 
-      $ cordova plugin add cordova-plugin-camera
-      Fetching plugin "cordova-plugin-camera@~2.1.0" via npm
-      Installing "cordova-plugin-camera" for android
-      Installing "cordova-plugin-camera" for ios
+```
+$ cordova plugin add cordova-plugin-camera
+Fetching plugin "cordova-plugin-camera@~2.1.0" via npm
+Installing "cordova-plugin-camera" for android
+Installing "cordova-plugin-camera" for ios
+```
 
 Plugins can also be added using a directory or a git repo.
 
@@ -209,12 +230,14 @@ add plugins separately for each platform. (For more information, see
 Use `plugin ls` (or `plugin list`, or `plugin` by itself) to view
 currently installed plugins. Each displays by its identifier:
 
-        $ cordova plugin ls 
-        cordova-plugin-camera 2.1.0 "Camera"
-        cordova-plugin-whitelist 1.2.1 "Whitelist"
+```
+$ cordova plugin ls
+cordova-plugin-camera 2.1.0 "Camera"
+cordova-plugin-whitelist 1.2.1 "Whitelist"
+```
 
 ###See Also
-- [Cordova plugin command reference documentation](../../cordova-cli/index.html#cordova-plugin-command)
+- [Cordova plugin command reference documentation][cdv_plugin]
 - [Cordova plugin search page](/plugins/)
 - [Core Plugin APIs]
 
@@ -236,9 +259,9 @@ font size for Android devices:
 * Edit the `www/index.html` file, adding a link to an additional CSS
   file, `overrides.css` in this case:
 
-```html
+    ```html
     <link rel="stylesheet" type="text/css" href="css/overrides.css" />
-```
+    ```
 
 * Optionally create an empty `www/css/overrides.css` file, which would
   apply for all non-Android builds, preventing a missing-file error.
@@ -248,9 +271,9 @@ font size for Android devices:
   12-point default font size specified within `www/css/index.css`, for
   example:
 
-```css
+    ```css
     body { font-size:14px; }
-```
+    ```
 
 When you rebuild the project, the Android version features the custom
 font size, while others remain unchanged.
@@ -268,23 +291,39 @@ button.
 After installing the `cordova` utility, you can always update it to
 the latest version by running the following command:
 
-        $ sudo npm update -g cordova
+```bash
+$ sudo npm update -g cordova
+```
 
 Use this syntax to install a specific version:
 
-        $ sudo npm install -g cordova@3.1.0-0.2.0
+```bash
+$ sudo npm install -g cordova@3.1.0-0.2.0
+```
 
 Run `cordova -v` to see which version is currently running. To find the latest released cordova version, you can run:
 
-        $ npm info cordova version
+```bash
+$ npm info cordova version
+```
 
 To update platform that you're targeting:
 
-        $ cordova platform update android --save
-        $ cordova platform update ios --save
-        ...etc.
+```bash
+$ cordova platform update android --save
+$ cordova platform update ios --save
+...etc.
+```
 
 [DeviceReadyEvent]: ../../cordova/events/events.html#deviceready
-[BackButtonEvent]: ../../cordova/events/events.html#backbutton
-[CLI reference]: ../../cordova-cli/index.html
+[BackButtonEvent]:  ../../cordova/events/events.html#backbutton
 [Core Plugin APIs]: ../../guide/support/index.html#core-plugin-apis
+
+[CLI reference]: ../../reference/cordova-cli/index.html
+[cdv_create]:    ../../reference/cordova-cli/index.html#cordova-create-command
+[cdv_dir]:       ../../reference/cordova-cli/index.html#directory-structure
+[cdv_platform]:  ../../reference/cordova-cli/index.html#cordova-platform-command
+[cdv_run]:       ../../reference/cordova-cli/index.html#cordova-run-command
+[cdv_emulate]:   ../../reference/cordova-cli/index.html#cordova-emulate-command
+[cdv_plugin]:    ../../reference/cordova-cli/index.html#cordova-plugin-command
+[cdv_build]:     ../../reference/cordova-cli/index.html#cordova-build-command

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/e3751865/www/docs/en/6.x/guide/hybrid/plugins/index.md
----------------------------------------------------------------------
diff --git a/www/docs/en/6.x/guide/hybrid/plugins/index.md b/www/docs/en/6.x/guide/hybrid/plugins/index.md
index c0d1a7f..e1f3cd8 100644
--- a/www/docs/en/6.x/guide/hybrid/plugins/index.md
+++ b/www/docs/en/6.x/guide/hybrid/plugins/index.md
@@ -44,13 +44,12 @@ For each corresponding native interface, see the list at the end of
 this section.
 
 In addition to these instructions, when preparing to write a plugin it
-is best to look over
-[existing plugins](http://cordova.apache.org/contribute)
+is best to look over [existing plugins](http://cordova.apache.org/contribute)
 for guidance.
 
 ## Building a Plugin
 
-Application developers use the CLI's [plugin add command](../../../cordova-cli/index.html#cordova-plugin-add-command) to add a plugin to a project. The
+Application developers use the CLI's [plugin add command][cdv_plugin] to add a plugin to a project. The
 argument to that command is the URL for a _git_ repository containing
 the plugin code.  This example implements Cordova's Device API:
 
@@ -107,7 +106,7 @@ correctly for each platform.  Install `plugman` with the following
 
 You need an valid app source directory, such as the top-level `www`
 directory included in a default CLI-generated project as described in
-[Create your first app](../../cli/index.html) guide.  
+[Create your first app](../../cli/index.html) guide.
 
 Then run a command such as the following to test whether iOS
 dependencies load properly:
@@ -126,7 +125,7 @@ plugin's JavaScript however you like, but you need to call
 `cordova.exec` to communicate with the native platform, using the
 following syntax:
 
-```js
+```javascript
     cordova.exec(function(winParam) {},
                  function(error) {},
                  "service",
@@ -160,18 +159,22 @@ Here is how each parameter works:
 This example shows one way to implement the plugin's JavaScript
 interface:
 
-        window.echo = function(str, callback) {
-            cordova.exec(callback, function(err) {
-                callback('Nothing to echo.');
-            }, "Echo", "echo", [str]);
-        };
+```javascript
+    window.echo = function(str, callback) {
+        cordova.exec(callback, function(err) {
+            callback('Nothing to echo.');
+        }, "Echo", "echo", [str]);
+    };
+```
 
 In this example, the plugin attaches itself to the `window` object as
 the `echo` function, which plugin users would call as follows:
 
-        window.echo("echome", function(echoValue) {
-            alert(echoValue == "echome"); // should alert true.
-        });
+```javascript
+    window.echo("echome", function(echoValue) {
+        alert(echoValue == "echome"); // should alert true.
+    });
+```
 
 Look at the last three arguments to the `cordova.exec` function. The
 first calls the `Echo` _service_, a class name. The second requests
@@ -198,33 +201,48 @@ listed below, and each builds on the simple Echo Plugin example above:
 
 ## Publishing Plugins
 
-Once you develop your plugin, you may want to publish and share it
-with the community. You can publish your plugin to any `npmjs`-based
-registry, but the recommended one is the [NPM registry](https://www.npmjs.com).
-Please read our [publishing plugins to npm guide](http://plugins.cordova.io/npm/developers.html).
-
-
-__NOTE__: [Cordova plugin registry](https://plugins.cordova.io) is
-moving to a read-only state. `publish`/
-`unpublish` commands have been removed from `plugman`, so you'll need to
-use corresponding `npm` commands.
-
-Other developers can install your plugin automatically using either `plugman`
- or the Cordova CLI.  (For details on each development path, see
- [Using Plugman to Manage Plugins](../../../plugin_ref/plugman.html) and [The Command-Line Interface reference](../../../cordova-cli/index.html).)
+You can publish your plugin to any `npmjs`-based registry, but the recommended one is the [NPM registry](https://www.npmjs.com). Other developers can install your plugin automatically using either `plugman` or the Cordova CLI.
 
 To publish a plugin to NPM registry you need to follow steps below:
+  * install the `plugman` CLI:
+
+    ```bash
+    $ npm install -g plugman
+    ```
 
   * create `package.json` file for your plugin:
 
-        $ plugman createpackagejson /path/to/your/plugin
+    ```bash
+    $ plugman createpackagejson /path/to/your/plugin
+    ```
 
   * publish it:
 
-        $ npm adduser # that is if you don't have an account yet
-        $ npm publish /path/to/your/plugin
+    ```bash
+    $ npm adduser # that is if you don't have an account yet
+    $ npm publish /path/to/your/plugin
+    ```
+
+For more details on npm usage refer to [publishing a npm package](https://docs.npmjs.com/getting-started/publishing-npm-packages) on the NPM documentation site.
+
+## Integrating with Plugin Search
+
+To surface the plugin in [Cordova Plugin Search](/plugins/), add the `ecosystem:cordova` keyword to the `package.json` file of your plugin before publishing.
+
+To indicate support for a particular platform add a keyword with the `<platformName>` as `**cordova-<platformName>**` to the list of keywords in package.json.
+Plugman's `createpackagejson` command does this for you, but if you did not use it to generate your `package.json`, you should manually edit it as shown below.
+
+For example, for a plugin that supports android, iOS & Windows, the keywords in package.json should include:
+
+```json
+    "keywords": [
+      "ecosystem:cordova",
+      "cordova-android",
+      "cordova-ios",
+      "cordova-windows"
+    ]
+```
 
-That is it!
+For more detailed example of a package.json, review the [package.json file of cordova-plugin-device](https://github.com/apache/cordova-plugin-device/blob/master/package.json).
 
-Running `plugman --help` lists other available registry-based
-commands.
+[cdv_plugin]: ../../../reference/cordova-cli/index.html#cordova-plugin-command

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/e3751865/www/docs/en/6.x/guide/overview/index.md
----------------------------------------------------------------------
diff --git a/www/docs/en/6.x/guide/overview/index.md b/www/docs/en/6.x/guide/overview/index.md
index 6dc9ede..33fcb74 100644
--- a/www/docs/en/6.x/guide/overview/index.md
+++ b/www/docs/en/6.x/guide/overview/index.md
@@ -77,7 +77,7 @@ other and bindings to standard device APIs. This enables you to invoke native
 code from JavaScript. 
 
 Apache Cordova project maintains a set of plugins called the 
-[Core Plugins](../guide/support/index.html#core-plugin-apis). These core 
+[Core Plugins](../support/index.html#core-plugin-apis). These core 
 plugins provide your application to access device capabilities such as 
 battery, camera, contacts, etc.
 

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/e3751865/www/docs/en/6.x/guide/platforms/android/index.md
----------------------------------------------------------------------
diff --git a/www/docs/en/6.x/guide/platforms/android/index.md b/www/docs/en/6.x/guide/platforms/android/index.md
index af54741..5edd3cc 100644
--- a/www/docs/en/6.x/guide/platforms/android/index.md
+++ b/www/docs/en/6.x/guide/platforms/android/index.md
@@ -28,8 +28,8 @@ command-line tools in your development workflow.  You need to install
 the Android SDK regardless of whether you want to use these
 platform-centered shell tools or cross-platform Cordova CLI for
 development. For a comparison of the two development paths, see the
-[Overview](../../overview/index.html#development-paths).  For details on the CLI, see [Cordova CLI Reference].
-
+[Overview](../../overview/index.html#development-paths). For details on
+the CLI, see [Cordova CLI Reference][cli_reference].
 
 ## Requirements and Support
 
@@ -112,16 +112,22 @@ On a Mac or Linux, you can use a text editor to create or modify the
 `~/.bash_profile` file. To set an environment variable, add a line that
 uses `export` like so (substitute the path with your local installation):
 
-        export ANDROID_HOME=/Development/android-sdk/
+```bash
+export ANDROID_HOME=/Development/android-sdk/
+```
 
 To update your `PATH`, add a line resembling the following
 (substitute the paths with your local Android SDK installation's location):
 
-        export PATH=${PATH}:/Development/android-sdk/platform-tools:/Development/android-sdk/tools
+```bash
+export PATH=${PATH}:/Development/android-sdk/platform-tools:/Development/android-sdk/tools
+```
 
 Reload your terminal to see this change reflected or run the following command:
 
-        $ source ~/.bash_profile
+```bash
+$ source ~/.bash_profile
+```
 
 #### Windows
 
@@ -150,7 +156,6 @@ reopen any command prompt windows after making changes to see them reflected
     C:\Development\android-sdk\tools
     ```
 
-
 ## Project Configuration
 
 ### Setting up an Emulator
@@ -164,7 +169,9 @@ for configuring the emulator and setting up hardware acceleration.
 Once your AVD is configured correctly, you should be able to see it by running
 this command from within a Cordova project:
 
-    $ cordova run --list
+```bash
+$ cordova run --list
+```
 
 ### Configuring Gradle
 
@@ -192,14 +199,14 @@ You can set these properties in one of four ways:
 
   1. By setting environment variables like so:
 
-      ```
+      ```bash
       $ export ORG_GRADLE_PROJECT_cdvMinSdkVersion=20
       $ cordova build android
-  ```
+      ```
 
   2. By using the `--gradleArg` flag in your Cordova `build` or `run` commands:
 
-      ```
+      ```bash
       $ cordova run android -- --gradleArg=-PcdvMinSdkVersion=20
       ```
 
@@ -215,8 +222,8 @@ You can set these properties in one of four ways:
   4. By extending `build.gradle` via a [`build-extras.gradle` file](#extending-build-gradle)
     and setting the property like so:
 
-      ```
-      # In <your-project>/platforms/android/build-extras.gradle
+      ```groovy
+      // In <your-project>/platforms/android/build-extras.gradle
       ext.cdvMinSdkVersion = 20
       ```
 
@@ -238,19 +245,50 @@ recommended that you copy it over via a script attached to the `before_build`
 
 Here's an example:
 
-    # Example build-extras.gradle
-    # This file is included at the beginning of `build.gradle`
-    ext.cdvDebugSigningPropertiesFile = '../../android-debug-keys.properties'
+```groovy
+// Example build-extras.gradle
+// This file is included at the beginning of `build.gradle`
+ext.cdvDebugSigningPropertiesFile = '../../android-debug-keys.properties'
 
-    # When set, this function allows code to run at the end of `build.gradle`
-    ext.postBuildExtras = {
-        android.buildTypes.debug.applicationIdSuffix = '.debug'
-    }
+// When set, this function allows code to run at the end of `build.gradle`
+ext.postBuildExtras = {
+    android.buildTypes.debug.applicationIdSuffix = '.debug'
+}
+```
 
 Note that plugins can also include `build-extras.gradle` files via:
 
-    <framework src="some.gradle" custom="true" type="gradleReference" />
+```xml
+<framework src="some.gradle" custom="true" type="gradleReference" />
+```
+
+### Setting the Version Code
+
+To change the [version code](http://developer.android.com/tools/publishing/versioning.html) for your app's generated apk,
+set the `android-versionCode` attribute in the widget element of your application's
+[config.xml file](../../../config_ref/index.html). If the `android-versionCode` is not set, the
+version code will be determined using the `version` attribute. For example,
+if the version is `MAJOR.MINOR.PATCH`:
 
+```
+versionCode = MAJOR * 10000 + MINOR * 100 + PATCH
+```
+
+If your application has enabled the `cdvBuildMultipleApks` Gradle property (see
+[Setting Gradle Properties](#setting-gradle-properties)), the version code of your app
+will also be multiplied by 10 so that the last digit of the code can be used
+to indicate the architecture the apk was built for. This multiplication will happen
+regardless of whether the version code is taken from the `android-versionCode`
+attribute or generated using the `version`. Be aware that some plugins added to your
+project (including cordova-plugin-crosswalk-webview) may set this Gradle property
+automatically.
+
+**Please Note:** When updating the `android-versionCode` property, it is unwise to
+increment the version code taken from built apks. Instead, you should increment
+the code based off the value in your `config.xml` file's `android-versionCode`
+attribute. This is because the `cdvBuildMultipleApks` property causes the version code
+to be multiplied by 10 in the built apks and thus using that value will cause your next
+version code to be 100 times the original, etc.
 
 ## Signing an App
 
@@ -269,7 +307,11 @@ To sign an app, you need the following parameters:
 | Type of the Keystore  | `--keystoreType`  | *Default: auto-detect based on file extension*<br>Either pkcs12 or jks
 
 These parameters can be specified using the command line arguments above to
-the [Cordova CLI](../../../cordova-cli/index.html) `build` or `run` commands.
+the [Cordova CLI][cli_reference] `build` or `run` commands.
+
+__Note__: You should use double `--` to indicate that these are platform-specific arguments, for example:
+
+`cordova run android --release -- --keystore=../my-release-key.keystore --storePassword=password --alias=alias_name --password=password`.
 
 ### Using build.json
 
@@ -277,24 +319,26 @@ Alternatively, you could specify them in a build configuration file (`build.json
 using the `--buildConfig` argument to the same commands. Here's a sample of a
 build configuration file:
 
-    {
-         "android": {
-             "debug": {
-                 "keystore": "..\android.keystore",
-                 "storePassword": "android",
-                 "alias": "mykey1",
-                 "password" : "password",
-                 "keystoreType": ""
-             },
-             "release": {
-                 "keystore": "..\android.keystore",
-                 "storePassword": "",
-                 "alias": "mykey2",
-                 "password" : "password",
-                 "keystoreType": ""
-             }
-         }
-     }
+```json
+{
+    "android": {
+        "debug": {
+            "keystore": "../android.keystore",
+            "storePassword": "android",
+            "alias": "mykey1",
+            "password" : "password",
+            "keystoreType": ""
+        },
+        "release": {
+            "keystore": "../android.keystore",
+            "storePassword": "",
+            "alias": "mykey2",
+            "password" : "password",
+            "keystoreType": ""
+        }
+    }
+}
+```
 
 For release signing, passwords can be excluded and the build system will issue a
 prompt asking for the password.
@@ -320,7 +364,6 @@ keyPassword=SECRET2
 
 `storePassword` and `keyPassword` are optional, and will be prompted for if omitted.
 
-
 ## Debugging
 
 For details on the debugging tools that come packaged with the Android SDK, see
@@ -329,7 +372,6 @@ Additionally, Android's developer documentation for [debugging web apps](http://
 provides an introduction for debugging the portion of your app running in the
 Webview.
 
-
 ### Opening a Project in Android Studio
 
 Cordova for Android projects can be opened in the Android IDE, [Android Studio](http://developer.android.com/sdk/installing/index.html?pkg=studio).
@@ -366,7 +408,6 @@ for more details.
 
 ![]({{ site.baseurl }}/static/img/guide/platforms/android/asdk_import_done.png)
 
-
 ## Platform Centered Workflow
 
 cordova-android includes a number of scripts that allow the platform to be used
@@ -378,7 +419,7 @@ development path, you must still configure the Android SDK environment
 as described in [Requirements and Support](#requirements-and-support)
 above.
 
-For each of the scripts discussed below, refer to [Cordova CLI Reference] for more information on their
+For each of the scripts discussed below, refer to [Cordova CLI Reference][cli_reference] for more information on their
 arguments and usage. Each script has a name that matches the corresponding CLI
 command. For example, `cordova-android/bin/create` is equivalent to
 `cordova create`.
@@ -390,7 +431,9 @@ To get started, either download the cordova-android package from
 To create a project using this package, run the `create` script in the `bin`
 folder:
 
-    $ cordova-android/bin/create ...
+```bash
+$ cordova-android/bin/create ...
+```
 
 The created project will have a folder named `cordova` inside that contains
 scripts for the project-specific Cordova commands (e.g. `run`, `build`, etc.).
@@ -405,7 +448,6 @@ To install plugins in this project, use the [Cordova Plugman Utility](../../../p
 Refer to [this](./upgrade.html) article for instructions to upgrade your
 `cordova-android` version.
 
-
 ## Lifecycle Guide
 
 ### Cordova and Android
@@ -532,7 +574,7 @@ external activity made prior to the activity being destroyed.
 
 The payload for the `resume` event adheres to the following format:
 
-```
+```text
 {
     action: "resume",
     pendingResult: {
@@ -708,4 +750,4 @@ on your device or emulator to simulate low memory scenarios. You should always
 do some amount of testing with this setting enabled to make sure that your
 application is properly maintaining state.
 
-[Cordova CLI Reference]: ../../../cordova-cli/index.html
+[cli_reference]: ../../../reference/cordova-cli/index.html


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org


Mime
View raw message