Update request

This reverts commit 3f01228db4.

.editorconfig

@@ -13,3 +13,6 @@ trim_trailing_whitespace = false
 
 [**.std]
 insert_final_newline = false
+
+[{package,bower}.json]
+indent_size = 2

.eslintignore

@@ -0,0 +1,6 @@
+node_modules
+test/assets
+test/reports
+test/sample
+test/tmp
+packages/bower-logger/test

.eslintrc

@@ -0,0 +1,51 @@
+{
+  "env": {
+    "node": true,
+    "mocha": true
+  },
+  "rules": {
+    "no-bitwise": 0,
+    "curly": 0,
+    "eqeqeq": 0,
+    "guard-for-in": 0,
+    "no-use-before-define": 0,
+    "no-caller": 2,
+    "no-new": 2,
+    "no-plusplus": 0,
+    "no-undef": 2,
+    "no-unused-vars": 0,
+    "strict": 0,
+    "semi": 0,
+    "comma-spacing": 2,
+    "quote-props": [2, "as-needed"],
+    "quotes": [2, "single", "avoid-escape"],
+    "no-cond-assign": [ 2, "except-parens" ],
+    "no-debugger": 2,
+    "no-dupe-args": 2,
+    "no-dupe-keys": 2,
+    "no-duplicate-case": 2,
+    "no-unreachable": 2,
+    "valid-typeof": 2,
+    "no-fallthrough": 2,
+    "no-ex-assign": 2,
+    "no-eq-null": 0,
+    "no-eval": 0,
+    "no-unused-expressions": 0,
+    "block-scoped-var": 0,
+    "no-iterator": 0,
+    "no-loop-func": 2,
+    "no-script-url": 0,
+    "no-shadow": 0,
+    "no-new-func": 2,
+    "no-new-wrappers": 2,
+    "no-invalid-this": 0,
+    "space-before-blocks": [2, "always"],
+    "space-before-function-paren": [2, "never"],
+    "space-infix-ops": 2,
+    "keyword-spacing": 2,
+    "new-parens": 2,
+    "no-multiple-empty-lines": [2, { max: 2}],
+    "eol-last": 2,
+    "no-trailing-spaces": 2
+  }
+}

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+open_collective: bower

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,44 @@
+<!--
+
+If you are reporting a new issue, make sure that we do not have any duplicates.
+You can ensure this by searching the issue list for this repository.
+
+You are welcome to open issues to discuss important general topics concerning Bower.
+However for support questions, please consider using http://stackoverflow.com or
+asking for help in our Discord channel: https://discordapp.com/invite/0fFM7QF0KpZaDeN9
+
+# BUG REPORT
+
+Use the commands below to provide key information to reproduce:
+You do NOT have to include this information if this is a FEATURE REQUEST OR DISCUSSION
+
+For more information about reporting bugs, see:
+https://github.com/bower/bower/wiki/Report-a-Bug
+
+-->
+
+**Output of `bower -v && npm -v && node -v`:**
+
+```
+(paste your output here)
+```
+
+**Additional environment details (proxy, private registry, etc.):**
+
+
+
+**Steps to reproduce the issue:**
+
+1.
+2.
+3.
+
+**Describe the results you received:**
+
+
+
+**Describe the results you expected:**
+
+
+
+**Additional information:**

.github/workflows/nodejs.yml

@@ -0,0 +1,62 @@
+name: build
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - '**'
+
+jobs:
+  test:
+    name: Node v${{ matrix.node-version }} on ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # https://github.com/actions/setup-node/issues/27
+        node-version: [0.10.x, 0.12.x, 4.x, 6.x, 8.x, 10.x, 12.x, 14.x]
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Set git config
+        shell: bash
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.symlinks true
+        if: runner.os == 'Windows'
+
+      - uses: actions/checkout@v2
+      - name: install
+        run: yarn && (cd packages/bower-json && yarn link) && yarn link bower-json
+      - name: lint
+        run: npm run lint
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: bower tests
+        run: npm test
+        env:
+          CI: true
+      - name: bower-logger tests
+        run: (cd packages/bower-logger && npm install && npm test)
+        env:
+          CI: true
+      - name: bower-config tests
+        run: (cd packages/bower-config && npm install && npm test)
+        env:
+          CI: true
+      - name: bower-endpoint-parser tests
+        run: (cd packages/bower-endpoint-parser && npm install && npm test)
+        env:
+          CI: true
+      - name: bower-json tests
+        run: (cd packages/bower-json && npm install && npm test)
+        env:
+          CI: true
+      - name: bower-registry-client tests
+        run: (cd packages/bower-registry-client && npm install && npm test)
+        env:
+          CI: true

.gitignore

@@ -1,12 +1,15 @@
+!lib/bin
 /node_modules
 /npm-debug.log
 
-/test/assets/temp
-/test/assets/temp2
-/test/assets/temp-resolve-cache
 /test/assets/package-*/
+/test/assets/temp-*/
 /test/reports
+/test/tmp/
 
 /bower.json
 /component.json
 /bower_components
+/test/sample
+!/test/sample/bower.json
+/npm-shrinkwrap.json

.jshintrc

@@ -1,62 +0,0 @@
-{
-    "predef": [
-        "console",
-        "describe",
-        "it",
-        "after",
-        "afterEach",
-        "before",
-        "beforeEach"
-    ],
-
-    "indent": 4,
-    "node": true,
-    "devel": true,
-
-    "bitwise": false,
-    "curly": false,
-    "eqeqeq": true,
-    "forin": false,
-    "immed": true,
-    "latedef": false,
-    "newcap": true,
-    "noarg": true,
-    "noempty": false,
-    "nonew": true,
-    "plusplus": false,
-    "regexp": false,
-    "undef": true,
-    "unused": "vars",
-    "quotmark": "single",
-    "strict": false,
-    "trailing": true,
-    "camelcase": true,
-
-    "asi": false,
-    "boss": true,
-    "debug": false,
-    "eqnull": true,
-    "es5": false,
-    "esnext": false,
-    "evil": false,
-    "expr": false,
-    "funcscope": false,
-    "globalstrict": false,
-    "iterator": false,
-    "lastsemic": false,
-    "laxbreak": true,
-    "laxcomma": false,
-    "loopfunc": true,
-    "multistr": false,
-    "onecase": true,
-    "regexdash": false,
-    "scripturl": false,
-    "smarttabs": false,
-    "shadow": false,
-    "sub": false,
-    "supernew": true,
-    "validthis": false,
-
-    "nomen": false,
-    "white": true
-}

.prettierignore

@@ -0,0 +1,4 @@
+**/node_modules/**
+**/test/assets/**
+**/bower_components/**
+test/sample

.travis.yml

@@ -1,9 +0,0 @@
-language: node_js
-node_js:
-  - "0.10"
-  - "0.11"
-matrix:
-  allow_failures:
-    - node_js: "0.11"
-before_script:
-  - npm install grunt-cli -g

CHANGELOG.md

@@ -1,13 +1,310 @@
 # Changelog
 
+## Newer releases
+
+Please see: https://github.com/bower/bower/releases
+
+## 1.8.0 - 2016-11-07
+
+- Download tar archives from GitHub when possible (#2263)
+  - Change default shorthand resolver for github from `git://` to `https://`
+- Fix ssl handling by not setting GIT_SSL_NO_VERIFY=false (#2361)
+- Allow for removing components with url instead of name (#2368)
+- Show in warning message location of malformed bower.json (#2357)
+- Improve handling of non-semver versions in git resolver (#2316)
+- Fix handling of cached releases pluginResolverFactory (#2356)
+- Allow to type the entire version when conflict occured (#2243)
+- Allow `owner/reponame` shorthand for registering components (#2248)
+- Allow single-char repo names and package names (#2249)
+- Make `bower version` no longer honor `version` in bower.json (#2232)
+- Add `postinstall` hook (#2252)
+- Allow for `@` instead of `#` for `install` and `info` commands (#2322)
+- Upgrade all bundled modules
+
+## 1.7.9 - 2016-04-05
+
+- Show warnings for invalid bower.json fields
+- Update bower-json
+  - Less strict validation on package name (allow spaces, slashes, and "@")
+
+## 1.7.8 - 2016-04-04
+
+- Don't ask for git credentials in non-interactive session, fixes #956 #1009
+- Prevent swallowing exceptions with programmatic api, fixes #2187
+- Update graceful-fs to 4.x in all dependences, fixes nodejs/node#5213
+- Resolve pluggable resolvers using cwd and fallback to global modules, fixes #1919
+- Upgrade handlebars to 4.0.5, closes #2195
+- Replace all % chatacters in defined scripts, instead of only first one, fixes #2174
+- Update opn package to fix issues with "bower open" command on Windows
+- Update bower-config
+  - Do not interpolate environment variables in script hooks, fixes bower/config#47
+- Update bower-json
+  - Validate package name more strictly and allow only latin letters, dots, dashes and underscores
+- Add support for "save" and "save-exact" in .bowerrc, #2161
+
+## 1.7.7 - 2016-01-27
+
+Revert locations of all files while still packaging `node_modules`.
+
+It's because people are depending on internals of bower, like
+`bower/lib/renderers/StandardRenderer`. We want to preserve this
+implicit contract, but we discourage it. The only official way
+to use bower programmatically is through `require('bower')`.
+
+## 1.7.6 - 2016-01-27
+
+- Revert location of "bin/bower" as developers are using it directly ([#2157](https://github.com/bower/bower/issues/2157))
+  Note: Correctly, you should use an alias created in `npm bin --global`.
+
+## 1.7.5 - 2016-01-26
+
+- Remove analytics from Bower, fixes ([#2150](https://github.com/bower/bower/pull/2150))
+- Default to ^ operator on `bower install --save` ([#2145](https://github.com/bower/bower/pull/2145))
+- Support absolute path in .bowerrc directory option ([#2130](https://github.com/bower/bower/pull/2130))
+- Display user's name upon `bower login` command ([#2133](https://github.com/bower/bower/pull/2133))
+- Decompress gzip files ([#2092](https://github.com/bower/bower/pull/2092))
+- Prevent name clashes in package extraction ([#2102](https://github.com/bower/bower/pull/2102))
+- When strictSsl is false, set GIT_SSL_NO_VERIFY=true ([#2129](https://github.com/bower/bower/issues/2129))
+- Distribute bower with npm@3 for better Windows support ([#2146](https://github.com/bower/bower/issues/2146))
+- Update request to 2.67.0 and fs-write-stream-atomic to 1.0.8
+- Documentation improvements
+
+## 1.7.4 - 2016-01-21
+
+Unpublished because of issue with npm distribution:
+https://github.com/npm/npm/issues/11227
+
+## 1.7.3 - 2016-01-20
+
+Unpublished because of issue with npm distribution:
+https://github.com/npm/npm/issues/11227
+
+## 1.7.2 - 2015-12-31
+
+- Lock "fs-write-stream-atomic" to 1.0.5
+
+## 1.7.1 - 2015-12-11
+
+- Rollback "Add `bower update --save` functionality", it causes issues and needs more testing
+- Fix backward-compatibility of `bower search --json` ([#2066](https://github.com/bower/bower/issues/2066))
+- Ignore prerelease versions from `bower info` output
+- Update update-notifier to 0.6.0
+- Better formatting of help messages (https://github.com/bower/bower/commit/de3e1089da80f47ea3667c5ab80d301cddfd8c3e)
+- Add help menu for update `--save` and `update --save-dev` (https://github.com/bower/bower/commit/612aaa88eb4d4b268b2d8665c338ac086af3a5b0)
+
+## 1.7.0 - 2015-12-07
+
+- Add `bower update --save` functionality ([#2035](https://github.com/bower/bower/issues/2035))
+- `bower search` shows help message when no package name is specified ([#2066](https://github.com/bower/bower/issues/2066))
+- Update only those packages that are explicitly requested by the user. Related Issues
+  - [#256](https://github.com/bower/bower/issues/256)
+  - [#924](https://github.com/bower/bower/issues/924)
+  - [#1770](https://github.com/bower/bower/issues/1770)
+- Allow for @ in username for SVN on windows ([#1650](https://github.com/bower/bower/issues/1650))
+- Update bower config
+  - Loads the .bowerrc file from the cwd specified on the command line
+  - Allow the use of environment variables in .bowerrc ([#41](https://github.com/bower/config/issues/41))
+  - Allow for array notation in ENV variables ([#44](https://github.com/bower/config/issues/44))
+
+## 1.6.9 - 2015-12-04
+
+- Change git version of fs-write-stream-atomic back to npm version ([#2079](https://github.com/bower/bower/issues/2079))
+
+## 1.6.8 - 2015-11-27
+
+- Use fs-write-stream-atomic for downloads
+- Improved downloader that properly cleans after itself
+- Fix shallow host detection ([#2040](https://github.com/bower/bower/pull/2040))
+- Upgrade to ([bower-config#1.2.3](https://github.com/bower/config/releases/tag/1.2.3))
+  - Properly restore env variables if they are undefined at the beginning
+  - Properly handle `default` setting for config.ca
+  - Display proper error if .bowerrc is a directory instead of file
+
+## 1.6.7 - 2015-11-26
+
+- Bundless all the dependencies again
+
+## 1.6.6 - 2015-11-25
+
+- Fixes regression with the published npm version
+
+## 1.6.5 - 2015-10-24
+
+- Updates to tests and documentation
+- Fixes passing options when requesting downloads
+
+## 1.6.4 - 2015-10-24
+
+- Fix ignoring dependencies on multiple install run ([#1970](https://github.com/bower/bower/pull/1970))
+- Use --non-interactive when running svn client ([#1969](https://github.com/bower/bower/pull/1969))
+- Fix downloading of URLs ending with slash ([#1956](https://github.com/bower/bower/pull/1956))
+- Add user-agent field for downloads by Bower ([#1960](https://github.com/bower/bower/pull/1960))
+
+## 1.6.3 - 2015-10-16
+
+Fixes regression issues introduced with 1.6.2, specifically:
+
+- Allow for bower_components to be a symlink
+- Allow setting custom registry in .bowerrc
+
+## 1.6.2 - 2015-10-15
+
+Fix dependency issues of 1.6.1. First published release of 1.6.x.
+
+## 1.6.1 - 2015-10-15
+
+Fix dependency issues of 1.6.0. Reverted release.
+
+## 1.6.0 - 2015-10-15
+
+- Shrinkwrap all dependencies and add them to bundledDependencies ([#1948](https://github.com/bower/bower/pull/1948))
+- Allow for ignoring of child dependencies ([#1394](https://github.com/bower/bower/pull/1394))
+- Allow passing `--config.resolvers` through CLI ([#1922](https://github.com/bower/bower/pull/1922))
+- Use defaults values from package.json if it exists (bower init) ([#1731](https://github.com/bower/bower/issues/1731))
+- Properly use cerificates set in .bowerrc ([#1869](https://github.com/bower/bower/pull/1869))
+- Include package name when version conflict occurs ([#1917](https://github.com/bower/bower/pull/1917))
+- Add timeout for permission check ([yeoman/insight#35](https://github.com/yeoman/insight/pull/35))
+- Close file-handles when possible. Prevents all sorts of permission issues on Windows ([0bb1536](https://github.com/bower/bower/commit/0bb1536c9972e13f3be06bea9a8619632966c664))
+- Prevent ENOENT error on Windows when in VM environment ([isaacs/chmodr#8](https://github.com/isaacs/chmodr/pull/8))
+
+Reverted release.
+
+## 1.5.4 - 2015-11-24
+
+- [fix] Lock lru-cache dependency to 2.7.0
+
+## 1.5.3 - 2015-09-24
+
+- Revert auto sorting of bower dependencies, fixes ([#1897](https://github.com/bower/bower/issues/1897))
+- Fix --save-exact feature for github endpoints, fixes ([#1925](https://github.com/bower/bower/issues/1925))
+- Fix `bower init` to support private flag again ([#1819](https://github.com/bower/bower/pull/1819))
+- Bump insight dependency to support prompt timeout ([#1102](https://github.com/bower/bower/issues/1102))
+
+## 1.5.2 - 2015-08-25
+
+- Revert update semver version from 2.x to 5.x, fixes ([#1896](https://github.com/bower/bower/issues/1896))
+- Make bower commands work from subdirectories, fixes ([#1893](https://github.com/bower/bower/issues/1893))
+- Put auto shallow cloning for git behind a flag, fixes ([#1764](https://github.com/bower/bower/issues/1764))
+
+## 1.5.1 - 2015-08-24
+
+- If cwd provided explicitly, force using it, fixes #1866
+
+## 1.5.0 - 2015-08-24
+
+- Pluggable Resolvers! http://bower.io/docs/pluggable-resolvers/
+- Update semver version from 2.x to 5.x ([#1852](https://github.com/bower/bower/issues/1852))
+- Auto-sort dependencies alphabetically ([#1381](https://github.com/bower/bower/issues/1381))
+- Make bower commands work from subdirectories ([#1866](https://github.com/bower/bower/issues/1866))
+- No longer prefer installing bower as global module ([#1865](https://github.com/bower/bower/issues/1865))
+
+## 1.4.2 - 2015-11-24
+
+- [fix] Lock lru-cache dependency to 2.7.0
+
+## 1.4.1 - 2015-04-01
+
+- [fix] Reading .bowerrc upwards directory tree ([#1763](https://github.com/bower/bower/issues/1763))
+- [fix] Update bower-registry-client so it uses the same bower-config as bower
+
+## 1.4.0 - 2015-03-30
+
+- Add login and unregister commands ([#1719](https://github.com/bower/bower/issues/1719))
+- Automatically detecting smart Git hosts ([#1628](https://github.com/bower/bower/issues/1628))
+- [bower/config#23] Allow npm config variables ([#1711](https://github.com/bower/bower/issues/1711))
+- [bower/config#24] Merge .bowerrc files upwards directory tree ([#1689](https://github.com/bower/bower/issues/1689))
+- Better homedir detection (514eb8f)
+- Add --save-exact flag ([#1654](https://github.com/bower/bower/issues/1654))
+- Ensure extracted files are readable (tar-fs) ([#1548](https://github.com/bower/bower/issues/1548))
+- The version command in the programmatic API now returns the new version ([#1755](https://github.com/bower/bower/issues/1755))
+- Some minor fixes: #1639, #1620, #1576, #1557, 962a565, a464f5a
+- Improved Windows support (AppVeyor CI, tests actually passing on Windows)
+- OSX testing enabled on TravisCI
+
+It also includes improved test coverage (~60% -> ~85%) and many refactors.
+
+## 1.3.12 - 2014-09-28
+
+- [stability] Fix versions for unstable dependencies ([#1532](https://github.com/bower/bower/pull/1532))
+- [fix] Update tar-fs to support old tar format ([#1537](https://github.com/bower/bower/issues/1537))
+- [fix] Make analytics work again ([#1529](https://github.com/bower/bower/pull/1529))
+- [fix] Always disable analytics for non-interactive mode ([#1529](https://github.com/bower/bower/pull/1529))
+- [fix] Bower init can create private packages again ([#1522](https://github.com/bower/bower/issues/1522))
+- [fix] Show again missing newline for bower search output ([#1538](https://github.com/bower/bower/issues/1538))
+
+## 1.3.11 - 2014-09-17
+
+- [fix] Restore install missing dependencies on update ([1519](https://github.com/bower/bower/pull/1519))
+
+## 1.3.10 - 2014-09-13
+
+- [fix] Back down concurrency from 50 to 5 ([#1483](https://github.com/bower/bower/pull/1483))
+- [fix] Read .bowerrc from specified cwd ([#1301](https://github.com/bower/bower/pull/1301))
+- [fix] Disable shallow clones except those from GitHub ([#1393](https://github.com/bower/bower/pull/1393))
+- [fix] Expose bower version ([#1478](https://github.com/bower/bower/pull/1478))
+- [fix] Bump dependencies, including "request" ([#1467](https://github.com/bower/bower/pull/1467))
+- [fix] Prevent an error when piping bower output to head ([#1508](https://github.com/bower/bower/pull/1508))
+- [fix] Disable removing unnecessary resolutions ([#1061](https://github.com/bower/bower/pull/1061))
+- [fix] Display the output of hooks again ([#1484](https://github.com/bower/bower/issues/1484))
+- [fix] analytics: true in .bowerrc prevents user prompt ([#1470](https://github.com/bower/bower/pull/1470))
+- [perf] Use `tar-fs` instead of `tar` for faster TAR extraction ([#1490](https://github.com/bower/bower/pull/1490))
+
+## 1.3.9 - 2014-08-06
+
+- [fix] Handle `tmp` sometimes returning an array ([#1434](https://github.com/bower/bower/pull/1434))
+
+## 1.3.8 - 2014-7-11
+
+- [fix] Lock down `tmp` package dep ([#1403](https://github.com/bower/bower/pull/1403), [#1407](https://github.com/bower/bower/pull/1407))
+
+## 1.3.7 - 2014-07-04
+
+- [fix] callstack error when processing installed packages with circular dependencies ([#1349](https://github.com/bower/bower/issues/1349))
+- [fix] Prevent bower list --paths` failing with TypeError ([#1383](https://github.com/bower/bower/issues/1383))
+- "bower install" fails if there's no bower.json in current directory ([#922](https://github.com/bower/bower/issues/922))
+
+## 1.3.6 - 2014-07-02
+
+- [fix] Make --force always re-run installation ([#931](https://github.com/bower/bower/issues/931))
+- [fix] Disable caching for local resources ([#1356](https://github.com/bower/bower/issues/1356))
+- [fix] Emit errors instead throwing them when using bower.commands API ([#1297](https://github.com/bower/bower/issues/1297))
+- [fix] Main files and bower.json are never ignored ([#547](https://github.com/bower/bower/issues/547))
+- [fix] Check if pkgMeta is undefined during uninstall command ([#1329](https://github.com/bower/bower/issues/1329))
+- [fix] Make custom tmp dir and ignores play well with each other ([#1299](https://github.com/bower/bower/issues/1299))
+- Warn users when installing package with missing properties ([#694](https://github.com/bower/bower/issues/694))
+
+
+## 1.3.5 - 2014-06-06
+- Search compatible versions in fetching packages ([#1147](https://github.com/bower/bower/issues/1147))
+
+## 1.3.4 - 2014-06-02
+
+- Resolve a situation in which the install process gets into an infinite loop ([#1169](https://github.com/bower/bower/issues/1169))
+- Improved CLI output for conflicts ([#1284](https://github.com/bower/bower/issues/1284))
+- Changed `bower version` to mirror the tag format of `npm version` ([#1278](https://github.com/bower/bower/issues/1278))
+- Allow short commit SHAs to be used ([#990](https://github.com/bower/bower/issues/990))
+
+## 1.3.3 - 2014-04-24
+
+- Do not cache moving targets like branches ([#1242](https://github.com/bower/bower/issues/1242))
+- Suppress output if --quiet option is specified ([#1124](https://github.com/bower/bower/pull/1124))
+- Use "svn export" for efficiency ([#1224](https://github.com/bower/bower/pull/1224))
+- Prevent loading insights and analytics on CI ([#1221](https://github.com/bower/bower/issues/1221))
+- Make "bower list" respect custom components directory ([#1237](https://github.com/bower/bower/issues/1237))
+- Improve non-interactive loading performance 2x ([#1238](https://github.com/bower/bower/issues/1238))
+- Load commands only on demand, improving performance ([#1232](https://github.com/bower/bower/pull/1232))
+
 ## 1.3.2 - 2014-04-05
+
 - Added yui moduleType [PR #1129](https://github.com/bower/bower/pull/1129)
 - Fixes for concurrency issues [PR #1211](https://github.com/bower/bower/pull/1211)
 - `link` now installs package dependencies [PR #891](https://github.com/bower/bower/pull/891)
 - Improved conflict installation message [Commit](https://github.com/bower/bower/commit/bea533acf87903d4b411bfbaa7df93f852ef46a3)
 - Add --production switch to "prune" command [PR #1168](https://github.com/bower/bower/pull/1168)
 
+
 ## 1.3.1 - 2014-03-10
+
 - No longer ask for permission to gather analytics when running on in a CI environment.
 
 

CONTRIBUTING.md

@@ -1,96 +1,43 @@
 # Contributing to Bower
 
-Bower is a large community project with many different developers contributing at all levels to the project. We're **actively** looking for more contributors right now.  (Jan 2014)
+Bower is a large community project with many different developers contributing at all levels to the project. We're **actively** looking for more contributors right now. If you're interested in becoming a Bower maintainer or supporting in any way, please fill the following form: http://goo.gl/forms/P1ndzCNoiG. There is more information about [contributing](https://github.com/bower/bower/wiki/Contributor-Guidelines) in the Wiki.
+
+<a name="bugs"></a>
+## 🐛 [Bug reports](https://github.com/bower/bower/wiki/Report-a-Bug)
 
 ## Casual Involvement
+
 * Improve the bower.io site ([tickets](https://github.com/bower/bower.github.io/issues))
-* Move forward [bower.io redesign](https://github.com/bower/bower.github.io/issues/7)
-* Attend team meetings
 * Comment on issues and drive to resolution
 
 ## High-impact Involvement
 
-* Maintaining the bower client. 
-  * [Authoring client tests](https://github.com/bower/bower/issues/801)
+* Maintaining the bower client.
   * Read [Architecture doc](https://github.com/bower/bower/wiki/Rewrite-architecture)
   * Triage, close, fix and resolve [issues](https://github.com/bower/bower/issues)
-* Developing the [new registry server](https://github.com/bower/registry/tree/node_rewrite)
-  * Hooking in to Elastic Search rather than the in-memory search
-  * Getting bower/registry-client to talk to the new server without breaking backwards compatibility
-  * DevOps for the server
 
 ## Team Meetings
 
-We meet on Monday at 1:00pm PST, 9:00pm UTC in #bower on Freenode. [The meeting notes](http://goo.gl/NJZ1o2).
-
-<hr>
-
-Following these guidelines helps to communicate that you respect the time of
-the developers managing and developing this open source project. In return,
-they should reciprocate that respect in addressing your issue, assessing
-changes, and helping you finalize your pull requests.
+We communicate through a channel on Discord https://discord.gg/0fFM7QF0KpZRh2cY 
 
+If you'd like to attend the meetings, please fill the [support form](http://goo.gl/forms/P1ndzCNoiG), and you'll get an invite.
 
 ## Using the issue tracker
 
-* 
-
 The issue tracker is the preferred channel for [bug reports](#bugs),
 [features requests](#features) and [submitting pull
 requests](#pull-requests), but please respect the following restrictions:
 
 * Please **do not** use the issue tracker for personal support requests. Use
-  [Stack Overflow](http://stackoverflow.com/questions/tagged/bower), our
-  [Mailing List](http://groups.google.com/group/twitter-bower)
+  [Stack Overflow](http://stackoverflow.com/questions/tagged/bower),
+  [Discord Channel](https://discordapp.com/channels/119103197720739842/123728452816732160),
+  [Mailing List](http://groups.google.com/group/twitter-bower),
   (twitter-bower@googlegroups.com), or
   [#bower](http://webchat.freenode.net/?channels=bower) on Freenode.
 
 * Please **do not** derail or troll issues. Keep the discussion on topic and
   respect the opinions of others.
 
-
-<a name="bugs"></a>
-## Bug reports
-
-A bug is a _demonstrable problem_ that is caused by the code in the repository.
-Good bug reports are extremely helpful - thank you!
-
-Guidelines for bug reports:
-
-1. **Use the GitHub issue search** &mdash; check if the issue has already been
-   reported.
-
-2. **Check if the issue has been fixed** &mdash; try to reproduce it using the
-   latest `master` or development branch in the repository.
-
-3. **Isolate the problem** &mdash; ideally create a [reduced test
-   case](http://css-tricks.com/6263-reduced-test-cases/).
-
-A good bug report shouldn't leave others needing to chase you up for more
-information. Please try to be as detailed as possible in your report. What is
-your environment? What steps will reproduce the issue? What OS experiences the
-problem? What would you expect to be the outcome? All these details will help
-people to fix any potential bugs.
-
-Example:
-
-> Short and descriptive example bug report title
->
-> A summary of the issue and the browser/OS environment in which it occurs. If
-> suitable, include the steps required to reproduce the bug.
->
-> 1. This is the first step
-> 2. This is the second step
-> 3. Further steps, etc.
->
-> `<url>` - a link to the reduced test case
->
-> Any other information you want to share that is relevant to the issue being
-> reported. This might include the lines of code that you have identified as
-> causing the bug, and potential solutions (and your opinions on their
-> merits).
-
-
 <a name="features"></a>
 ## Feature requests
 
@@ -174,6 +121,8 @@ included in the project:
    force push to your remote feature branch. You may also be asked to squash
    commits.
 
+10. If you are asked to squash your commits, then please use `git rebase -i master`. It will ask you to pick your commits - pick the major commits and squash the rest.
+
 **IMPORTANT**: By submitting a patch, you agree to license your work under the
 same license as that used by the project.
 

Gruntfile.js

@@ -1,47 +0,0 @@
-module.exports = function (grunt) {
-
-    require('load-grunt-tasks')(grunt);
-
-    grunt.initConfig({
-        jshint: {
-            options: {
-                jshintrc: '.jshintrc'
-            },
-            files: ['Gruntfile.js', 'bin/*', 'lib/**/*.js', 'test/**/*.js', '!test/assets/**/*', '!test/reports/**/*']
-        },
-        simplemocha: {
-            options: {
-                reporter: 'spec',
-                timeout: '5000'
-            },
-            full: { src: ['test/test.js'] },
-            short: {
-                options: {
-                    reporter: 'dot'
-                },
-                src: ['test/test.js']
-            }
-        },
-        exec: {
-            assets: {
-                command: 'node test/packages.js && node test/packages-svn.js'
-            },
-            'assets-force': {
-                command: 'node test/packages.js --force && node test/packages-svn.js --force'
-            },
-            cover: {
-                command: 'node node_modules/istanbul/lib/cli.js cover --dir ./test/reports node_modules/mocha/bin/_mocha -- -R dot test/test.js'
-            }
-        },
-        watch: {
-            files: ['<%= jshint.files %>'],
-            tasks: ['jshint', 'simplemocha:short']
-        }
-    });
-
-
-    grunt.registerTask('assets', ['exec:assets-force']);
-    grunt.registerTask('test', ['jshint', 'exec:assets', 'simplemocha:full']);
-    grunt.registerTask('cover', 'exec:cover');
-    grunt.registerTask('default', 'test');
-};

HOOKS.md

@@ -1,21 +0,0 @@
-# Install and Uninstall Hooks
-
-Bower provides 3 separate hooks that can be used to trigger other automated tools during Bower usage.  Importantly, these hooks are intended to allow external tools to help wire up the newly installed components into the parent project and other similar tasks.  These hooks are not intended to provide a post-installation build step for component authors.  As such, the configuration for these hooks is provided in the `.bowerrc` file in the parent project's directory.
-
-## Configuring
-
-In `.bowerrc` do:
-
-```js
-{
-	"scripts": {
-		"preinstall": "<your command here>",
-		"postinstall": "<your command here>",
-		"preuninstall": "<your command here>"
-	}
-}
-```
-
-The value of each script hook may contain a % character.  When your script is called, the % will be replaced with a space-separated list of components being installed or uninstalled.
-
-Your script will also include an environment variable `BOWER_PID` containing the PID of the parent Bower process that triggered the script.  This can be used to verify that a `preinstall` and `postinstall` steps are part of the same Bower process.

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Twitter and other contributors
+Copyright (c) 2013-present Twitter and other contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

README.md

@@ -1,424 +1,249 @@
-# Bower
+# Bower - A package manager for the web
 
-[![Build Status](https://secure.travis-ci.org/bower/bower.svg?branch=master)](http://travis-ci.org/bower/bower)
+[![Build](https://github.com/bower/bower/workflows/build/badge.svg)](https://github.com/bower/bower/actions?query=branch%3Amaster)
+[![Backers on Open Collective](https://opencollective.com/bower/backers/badge.svg)](#backers)
+[![Sponsors on Open Collective](https://opencollective.com/bower/sponsors/badge.svg)](#sponsors)
+
+> ..psst! While Bower is maintained, we recommend [yarn](https://yarnpkg.com/) and [webpack](https://webpack.js.org/) or [parcel](https://parceljs.org/) for new front-end projects!
 
 <img align="right" height="300" src="http://bower.io/img/bower-logo.png">
 
-Bower is a package manager for the web. It offers a generic, unopinionated
-solution to the problem of **front-end package management**, while exposing the
-package dependency model via an API that can be consumed by a more opinionated
-build stack. There are no system wide dependencies, no dependencies are shared
-between different apps, and the dependency tree is flat.
+---
 
-Bower runs over Git, and is package-agnostic. A packaged component can be made
-up of any type of asset, and use any type of transport (e.g., AMD, CommonJS,
-etc.).
+Bower offers a generic, unopinionated solution to the problem of **front-end package management**, while exposing the package dependency model via an API that can be consumed by a more opinionated build stack. There are no system wide dependencies, no dependencies are shared between different apps, and the dependency tree is flat.
+
+Bower runs over Git, and is package-agnostic. A packaged component can be made up of any type of asset, and use any type of transport (e.g., AMD, CommonJS, etc.).
+
+**View complete docs on [bower.io](http://bower.io)**
 
 [View all packages available through Bower's registry](http://bower.io/search/).
 
+## Install
 
-## Installing Bower
-
-Bower depends on [Node](http://nodejs.org/) and [npm](http://npmjs.org/). It's
-installed globally using npm:
-
-```
-npm install -g bower
+```sh
+$ npm install -g bower
 ```
 
-Also make sure that [git](http://git-scm.com/) is installed as some bower
+Bower depends on [Node.js](http://nodejs.org/) and [npm](http://npmjs.org/). Also make sure that [git](http://git-scm.com/) is installed as some bower
 packages require it to be fetched and installed.
 
 
 ## Usage
 
-Much more information is available via `bower help` once it's installed. This
-is just enough to get you started.
+See complete command line reference at [bower.io/docs/api/](http://bower.io/docs/api/)
 
 ### Installing packages and dependencies
 
-Bower offers several ways to install packages:
+```sh
+# install dependencies listed in bower.json
+$ bower install
 
-#####Using the dependencies listed in the current directory's bower.json
+# install a package and add it to bower.json
+$ bower install <package> --save
+
+# install specific version of a package and add it to bower.json
+$ bower install <package>#<version> --save
 ```
-bower install
-```
-##### Using a local or remote package
-```
-bower install <package>
-```
-##### Using a specific version of a package
-```
-bower install <package>#<version>
-```
-##### Using a different name and a specific version of a package
-```
-bower install <name>=<package>#<version>
-```
-
-Where `<package>` can be any one of the following:
-
-* A name that maps to a package registered with Bower, e.g, `jquery`. ‡
-* A public remote Git endpoint, e.g., ```git://github.com/someone/some-package.git```. ‡
-* A private Git repository, e.g., ```https://github.com/someone/some-package.git```. If the protocol is https, a prompt will ask for the credentials. ssh can also be used, e.g., ```git@github.com:someone/some-package.git``` and can authenticate with the user's ssh public/private keys. ‡
-* A local endpoint, i.e., a folder that's a Git repository. ‡
-* A public remote Subversion endpoint, e.g., ```svn+http://package.googlecode.com/svn/```. ‡
-* A private Subversion repository, e.g., ```svn+ssh://package.googlecode.com/svn/``` or ```svn+https://package.googlecode.com/svn/```. ‡
-* A local endpoint, i.e., a folder that's an Subversion repository, e.g., ```svn+file:///path/to/svn/```. ‡
-* A shorthand endpoint, e.g., `someone/some-package` (defaults to GitHub). ‡
-* A URL to a file, including `zip` and `tar` files. Its contents will be
-  extracted.
-
-‡ These types of `<package>` might have versions available. You can specify a
-[semver](http://semver.org/) compatible version to fetch a specific release, and lock the
-package to that version. You can also specify a [range](https://github.com/isaacs/node-semver#ranges) of versions.
-
-If you are using a package that is a git endpoint, you may use any tag, commit SHA,
-or branch name as a version. For example: `<package>#<sha>`. Using branches is not
-recommended because the HEAD does not reference a fixed commit SHA.
-
-If you are using a package that is a subversion endpoint, you may use any tag, revision number,
-or branch name as a version. For example: `<package>#<revision>`.
-
-All package contents are installed in the `bower_components` directory by default.
-You should **never** directly modify the contents of this directory.
-
-Using `bower list` will show all the packages that are installed locally.
-
-**N.B.** If you aren't authoring a package that is intended to be consumed by
-others (e.g., you're building a web app), you should always [check installed
-packages into source control](http://addyosmani.com/blog/checking-in-front-end-dependencies/).
-
-
-### Custom install directory
-
-A custom install location can be set in a `.bowerrc` file using the `directory` property. The .bowerrc file should be a sibling of your project's bower.json.
-
-```json
-{
-  "directory": "public/bower_components"
-}
-```
-
-
-### Finding packages
-
-To search for packages registered with Bower:
-
-```
-bower search [<name>]
-```
-
-Using just `bower search` will list all packages in the registry.
 
 ### Using packages
 
-The easiest approach is to use Bower statically, just reference the package's
-installed components manually using a `script` tag:
+We discourage using bower components statically for performance and security reasons (if component has an `upload.php` file that is not ignored, that can be easily exploited to do malicious stuff).
 
-```html
-<script src="/bower_components/jquery/jquery.js"></script>
-```
-
-For more complex projects, you'll probably want to concatenate your scripts or
-use a module loader. Bower is just a package manager, but there are plenty of
-other tools -- such as [Sprockets](https://github.com/sstephenson/sprockets)
-and [RequireJS](http://requirejs.org/) -- that will help you do this.
+The best approach is to process components installed by bower with build tool (like [Grunt](http://gruntjs.com/) or [gulp](http://gulpjs.com/)), and serve them concatenated or using a module loader (like [RequireJS](http://requirejs.org/)).
 
 ### Uninstalling packages
 
 To uninstall a locally installed package:
 
-```
-bower uninstall <package-name>
+```sh
+$ bower uninstall <package-name>
 ```
 
-
-#### Warning
+### prezto and oh-my-zsh users
 
 On `prezto` or `oh-my-zsh`, do not forget to `alias bower='noglob bower'` or `bower install jquery\#1.9.1`
 
-#### Running commands with sudo
+### Never run Bower with sudo
 
-Bower is a user command, there is no need to execute it with superuser permissions.
-However, if you still want to run commands with sudo, use `--allow-root` option.
+Bower is a user command; there is no need to execute it with superuser permissions.
 
-#### A note for Windows users
+### Windows users
 
 To use Bower on Windows, you must install
-[msysgit](http://msysgit.github.io/) correctly. Be sure to check the
-option shown below:
+[Git for Windows](http://git-for-windows.github.io/) correctly. Be sure to check the
+options shown below:
 
-![msysgit](http://f.cl.ly/items/2V2O3i1p3R2F1r2v0a12/mysgit.png)
+<img src="https://cloud.githubusercontent.com/assets/10702007/10532690/d2e8991a-7386-11e5-9a57-613c7f92e84e.png" width="534" height="418" alt="Git for Windows" />
+
+<img src="https://cloud.githubusercontent.com/assets/10702007/10532694/dbe8857a-7386-11e5-9bd0-367e97644403.png" width="534" height="418" alt="Git for Windows" />
 
 Note that if you use TortoiseGit and if Bower keeps asking for your SSH
 password, you should add the following environment variable: `GIT_SSH -
 C:\Program Files\TortoiseGit\bin\TortoisePlink.exe`. Adjust the `TortoisePlink`
 path if needed.
 
-### Using bower's cache
+### Ubuntu users
+
+To use Bower on Ubuntu, you might need to link `nodejs` executable to `node`:
 
-Bower supports installing packages from its local cache (without internet connection), if the packages were installed before.
 ```
-bower install <package-name> --offline
-```
-The content of the cache can be listed with:
-```
-bower cache list
-```
-The cache can be cleaned with:
-```
-bower cache clean
+sudo ln -s /usr/bin/nodejs /usr/bin/node
 ```
 
 ## Configuration
 
-Bower can be configured using JSON in a `.bowerrc` file.
-
-The current spec can be read
-[here](https://docs.google.com/document/d/1APq7oA9tNao1UYWyOm8dKqlRP2blVkROYLZ2fLIjtWc/edit#heading=h.4pzytc1f9j8k)
-in the `Configuration` section.
-
-## Running on a continuous integration server
-
-Bower will skip some interactive and analytics operations if it finds a `CI` environmental variable set to `true`. You will find that the `CI` variable is already set for you on many continuous integration servers, e.g., [CircleCI](https://circleci.com/docs/environment-variables#basics) and [Travis-CI](http://docs.travis-ci.com/user/ci-environment/#Environment-variables).
-
-You may try to set manually set `CI` variable manually before running your Bower commands. On Mac or Linux, `export CI=true` and on Windows `set CI=true`
-
-### Interactive configuration
-
-If for some reason you are unable to set the `CI` environment variable, you can alternately use the `--config.interactive=false` flag. (`bower install --config.interactive=false`)
-
-## Defining a package
-
-You must create a `bower.json` in your project's root, and specify all of its
-dependencies. This is similar to Node's `package.json`, or Ruby's `Gemfile`,
-and is useful for locking down a project's dependencies.
-
-*NOTE:* In versions of Bower before 0.9.0 the package metadata file was called
-`component.json` rather than `bower.json`. This has changed to avoid a name
-clash with another tool. You can still use `component.json` for now but it is
-deprecated and the automatic fallback is likely to be removed in an upcoming
-release.
-
-You can interactively create a `bower.json` with the following command:
-
-```
-bower init
-```
-
-The `bower.json` ([spec](https://github.com/bower/bower.json-spec)) defines several options, including:
-
-* `name` (required): The name of your package.
-* `version`: A semantic version number (see [semver](http://semver.org/)).
-* `main` [string|array]: The primary endpoints of your package.
-* `ignore` [array]: An array of paths not needed in production that you want
-  Bower to ignore when installing your package.
-* `dependencies` [hash]: Packages your package depends upon in production.
-  Note that you can specify [ranges](https://github.com/isaacs/node-semver#ranges)
-  of versions for your dependencies.
-* `devDependencies` [hash]: Development dependencies.
-* `private` [boolean]: Set to true if you want to keep the package private and
-  do not want to register the package in future.
-
-```json
-{
-  "name": "my-project",
-  "description": "My project does XYZ...",
-  "version": "1.0.0",
-  "main": "path/to/main.css",
-  "ignore": [
-    ".jshintrc",
-    "**/*.txt"
-  ],
-  "dependencies": {
-    "<name>": "<version>",
-    "<name>": "<folder>",
-    "<name>": "<package>"
-  },
-  "devDependencies": {
-    "<test-framework-name>": "<version>"
-  }
-}
-```
-
-### Registering packages
-
-To register a new package:
-
-* There **must** be a valid manifest JSON in the current working directory.
-* Your package should use [semver](http://semver.org/) Git tags.
-* Your package **must** be available at a Git endpoint (e.g., GitHub); remember
-  to push your Git tags!
-
-Then use the following command:
-
-```
-bower register <my-package-name> <git-endpoint>
-```
-
-The Bower registry does not have authentication or user management at this point
-in time. It's on a first come, first served basis. Think of it like a URL
-shortener. Now anyone can run `bower install <my-package-name>`, and get your
-library installed.
-
-There is no direct way to unregister a package yet. For now, you can [request a
-package be unregistered](https://github.com/bower/bower/issues/120).
+Bower can be configured using JSON in a `.bowerrc` file. Read over available options at [bower.io/docs/config](http://bower.io/docs/config).
 
 
-## Consuming a package
+## Support
 
-Bower also makes available a source mapping. This can be used by build tools to
-easily consume Bower packages.
-
-If you pass the `--paths` option to Bower's `list` command, you will get a
-simple name-to-path mapping:
-
-```json
-{
-  "backbone": "bower_components/backbone/index.js",
-  "jquery": "bower_components/jquery/index.js",
-  "underscore": "bower_components/underscore/index.js"
-}
-```
-
-Alternatively, every command supports the `--json` option that makes bower
-output JSON. Command result is outputted to `stdout` and error/logs to
-`stderr`.
-
-
-## Programmatic API
-
-Bower provides a powerful, programmatic API. All commands can be accessed
-through the `bower.commands` object.
-
-```js
-var bower = require('bower');
-
-bower.commands
-.install(['jquery'], { save: true }, { /* custom config */ })
-.on('end', function (installed) {
-    console.log(installed);
-});
-
-bower.commands
-.search('jquery', {})
-.on('end', function (results) {
-    console.log(results);
-});
-```
-
-Commands emit four types of events: `log`, `prompt`, `end`, `error`.
-
-* `log` is emitted to report the state/progress of the command.
-* `prompt` is emitted whenever the user needs to be prompted.
-* `error` will only be emitted if something goes wrong.
-* `end` is emitted when the command successfully ends.
-
-For a better of idea how this works, you may want to check out [our bin
-file](https://github.com/bower/bower/blob/master/bin/bower).
-
-When using bower programmatically, prompting is disabled by default. Though you can enable it when calling commands with `interactive: true` in the config.
-This requires you to listen for the `prompt` event and handle the prompting yourself. The easiest way is to use the [inquirer](https://npmjs.org/package/inquirer) npm module like so:
-
-```js
-var inquirer =  require('inquirer');
-
-bower.commands
-.install(['jquery'], { save: true }, { interactive: true })
-// ..
-.on('prompt', function (prompts, callback) {
-    inquirer.prompt(prompts, callback);
-});
-```
-
-
-## Completion (experimental)
-
-_NOTE_: Completion is still not implemented for the 1.0.0 release
-
-Bower now has an experimental `completion` command that is based on, and works
-similarly to the [npm completion](https://npmjs.org/doc/completion.html). It is
-not available for Windows users.
-
-This command will output a Bash / ZSH script to put into your `~/.bashrc`,
-`~/.bash_profile`, or `~/.zshrc` file.
-
-```
-bower completion >> ~/.bash_profile
-```
-
-
-## Contact
-
-Have a question?
+You can ask questions on following channels in order:
 
 * [StackOverflow](http://stackoverflow.com/questions/tagged/bower)
-* [Mailinglist](http://groups.google.com/group/twitter-bower) - twitter-bower@googlegroups.com
-* [\#bower](http://webchat.freenode.net/?channels=bower) on Freenode
+* [Issue Tracker](https://github.com/bower/bower/issues)
+* team@bower.io
 
+## Contributing
 
-## Contributing to this project
+We welcome [contributions](https://github.com/bower/bower/graphs/contributors) of all kinds from anyone. Please take a moment to review the [guidelines for contributing](CONTRIBUTING.md).
 
-Anyone and everyone is welcome to contribute. Please take a moment to
-review the [guidelines for contributing](CONTRIBUTING.md).
-
-* [Bug reports](CONTRIBUTING.md#bugs)
+* [Bug reports](https://github.com/bower/bower/wiki/Report-a-Bug)
 * [Feature requests](CONTRIBUTING.md#features)
 * [Pull requests](CONTRIBUTING.md#pull-requests)
 
 
-## Bower Team
+Note that on Windows for tests to pass you need to configure Git before cloning:
 
-### Core team
+```
+git config --global core.autocrlf input
+```
 
-* [@satazor](https://github.com/satazor)
-* [@wibblymat](https://github.com/wibblymat)
-* [@paulirish](https://github.com/paulirish)
-* [@benschwarz](https://github.com/benschwarz)
-* [@sindresorhus](https://github.com/sindresorhus)
-* [@svnlto](https://github.com/svnlto)
 
-Thanks for assistance and contributions:
+## Backers
 
-[@addyosmani](https://github.com/addyosmani),
-[@ahmadnassri](https://github.com/ahmadnassri),
-[@angus-c](https://github.com/angus-c),
-[@borismus](https://github.com/borismus),
-[@carsonmcdonald](https://github.com/carsonmcdonald),
-[@chriseppstein](https://github.com/chriseppstein),
-[@danwrong](https://github.com/danwrong),
-[@davidmaxwaterman](https://github.com/davidmaxwaterman),
-[@desandro](https://github.com/desandro),
-[@hemanth](https://github.com/hemanth),
-[@isaacs](https://github.com/isaacs),
-[@josh](https://github.com/josh),
-[@jrburke](https://github.com/jrburke),
-[@kennethklee](https://github.com/kennethklee),
-[@marcelombc](https://github.com/marcelombc),
-[@marcooliveira](https://github.com/marcooliveira),
-[@mklabs](https://github.com/mklabs),
-[@MrDHat](https://github.com/MrDHat),
-[@necolas](https://github.com/necolas),
-[@richo](https://github.com/richo),
-[@rvagg](https://github.com/rvagg),
-[@ryanflorence](https://github.com/ryanflorence),
-[@SlexAxton](https://github.com/SlexAxton),
-[@sstephenson](https://github.com/sstephenson),
-[@tomdale](https://github.com/tomdale),
-[@uzquiano](https://github.com/uzquiano),
-[@visionmedia](https://github.com/visionmedia),
-[@wagenet](https://github.com/wagenet),
-[@wycats](https://github.com/wycats)
+Support us with a monthly donation and help us continue our activities. [[Become a backer](https://opencollective.com/bower#backer)]
 
-### Bower Alumni
+<a href="https://opencollective.com/bower/backer/0/website" target="_blank"><img src="https://opencollective.com/bower/backer/0/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/1/website" target="_blank"><img src="https://opencollective.com/bower/backer/1/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/2/website" target="_blank"><img src="https://opencollective.com/bower/backer/2/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/3/website" target="_blank"><img src="https://opencollective.com/bower/backer/3/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/4/website" target="_blank"><img src="https://opencollective.com/bower/backer/4/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/5/website" target="_blank"><img src="https://opencollective.com/bower/backer/5/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/6/website" target="_blank"><img src="https://opencollective.com/bower/backer/6/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/7/website" target="_blank"><img src="https://opencollective.com/bower/backer/7/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/8/website" target="_blank"><img src="https://opencollective.com/bower/backer/8/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/9/website" target="_blank"><img src="https://opencollective.com/bower/backer/9/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/10/website" target="_blank"><img src="https://opencollective.com/bower/backer/10/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/11/website" target="_blank"><img src="https://opencollective.com/bower/backer/11/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/12/website" target="_blank"><img src="https://opencollective.com/bower/backer/12/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/13/website" target="_blank"><img src="https://opencollective.com/bower/backer/13/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/14/website" target="_blank"><img src="https://opencollective.com/bower/backer/14/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/15/website" target="_blank"><img src="https://opencollective.com/bower/backer/15/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/16/website" target="_blank"><img src="https://opencollective.com/bower/backer/16/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/17/website" target="_blank"><img src="https://opencollective.com/bower/backer/17/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/18/website" target="_blank"><img src="https://opencollective.com/bower/backer/18/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/19/website" target="_blank"><img src="https://opencollective.com/bower/backer/19/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/20/website" target="_blank"><img src="https://opencollective.com/bower/backer/20/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/21/website" target="_blank"><img src="https://opencollective.com/bower/backer/21/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/22/website" target="_blank"><img src="https://opencollective.com/bower/backer/22/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/23/website" target="_blank"><img src="https://opencollective.com/bower/backer/23/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/24/website" target="_blank"><img src="https://opencollective.com/bower/backer/24/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/25/website" target="_blank"><img src="https://opencollective.com/bower/backer/25/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/26/website" target="_blank"><img src="https://opencollective.com/bower/backer/26/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/27/website" target="_blank"><img src="https://opencollective.com/bower/backer/27/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/28/website" target="_blank"><img src="https://opencollective.com/bower/backer/28/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/29/website" target="_blank"><img src="https://opencollective.com/bower/backer/29/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/30/website" target="_blank"><img src="https://opencollective.com/bower/backer/30/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/31/website" target="_blank"><img src="https://opencollective.com/bower/backer/31/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/32/website" target="_blank"><img src="https://opencollective.com/bower/backer/32/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/33/website" target="_blank"><img src="https://opencollective.com/bower/backer/33/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/34/website" target="_blank"><img src="https://opencollective.com/bower/backer/34/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/35/website" target="_blank"><img src="https://opencollective.com/bower/backer/35/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/36/website" target="_blank"><img src="https://opencollective.com/bower/backer/36/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/37/website" target="_blank"><img src="https://opencollective.com/bower/backer/37/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/38/website" target="_blank"><img src="https://opencollective.com/bower/backer/38/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/39/website" target="_blank"><img src="https://opencollective.com/bower/backer/39/avatar.svg"></a>
+<a href="https://opencollective.com/bower/backer/40/website" target="_blank"><img src="https://opencollective.com/bower/backer/40/avatar.svg"></a>
 
-* [@fat](https://github.com/fat)
-* [@maccman](https://github.com/maccman)
+## Sponsors
+
+Become a sponsor and get your logo on our README on Github with a link to your site. [[Become a sponsor](https://opencollective.com/bower#sponsor)]
+
+<a href="https://opencollective.com/bower/tiers/sponsors/0/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/0/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/1/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/1/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/2/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/2/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/3/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/3/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/4/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/4/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/5/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/5/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/6/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/6/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/7/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/7/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/8/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/8/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/9/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/9/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/10/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/10/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/11/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/11/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/12/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/12/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/13/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/13/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/14/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/14/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/15/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/15/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/16/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/16/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/17/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/17/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/18/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/18/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/19/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/19/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/20/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/20/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/21/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/21/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/22/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/22/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/23/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/23/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/24/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/24/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/25/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/25/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/26/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/26/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/27/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/27/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/28/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/28/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/29/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/29/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/30/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/30/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/31/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/31/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/32/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/32/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/33/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/33/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/34/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/34/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/35/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/35/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/36/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/36/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/37/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/37/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/38/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/38/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/39/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/39/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/40/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/40/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/41/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/41/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/42/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/42/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/43/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/43/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/44/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/44/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/45/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/45/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/46/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/46/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/47/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/47/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/48/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/48/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/49/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/49/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/50/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/50/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/51/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/51/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/52/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/52/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/53/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/53/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/54/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/54/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/55/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/55/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/56/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/56/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/57/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/57/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/58/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/58/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/59/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/59/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/60/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/60/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/61/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/61/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/62/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/62/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/63/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/63/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/64/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/64/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/65/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/65/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/66/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/66/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/67/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/67/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/68/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/68/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/69/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/69/avatar.svg"></a>
+<a href="https://opencollective.com/bower/tiers/sponsors/70/website" target="_blank"><img src="https://opencollective.com/bower/tiers/sponsors/70/avatar.svg"></a>
 
 
 ## License
 
-Copyright (c) 2014 Twitter and other contributors
+Copyright (c) 2012-present Twitter and [other contributors](https://github.com/bower/bower/graphs/contributors)
 
 Licensed under the MIT License

SECURITY.md

@@ -0,0 +1,3 @@
+# Security Policy
+
+For critical security issues, please send an e-mail to team@bower.io instead of filing issue here.

bin/bower

@@ -1,145 +1,3 @@
 #!/usr/bin/env node
 
-process.bin = process.title = 'bower';
-
-var Q = require('q');
-var path = require('path');
-var mout = require('mout');
-var updateNotifier = require('update-notifier');
-var Logger = require('bower-logger');
-var osenv = require('osenv');
-var bower = require('../lib');
-var pkg = require(path.join(__dirname, '..', 'package.json'));
-var cli = require('../lib/util/cli');
-var rootCheck = require('../lib/util/rootCheck');
-var analytics = require('../lib/util/analytics');
-
-// --------
-
-var options;
-var renderer;
-var loglevel;
-var command;
-var commandFunc;
-var logger;
-var notifier;
-var levels = Logger.LEVELS;
-
-options = cli.readOptions({
-    version: { type: Boolean, shorthand: 'v' },
-    help: { type: Boolean, shorthand: 'h' },
-    'allow-root': { type: Boolean }
-});
-
-// Handle print of version
-if (options.version) {
-    process.stdout.write(pkg.version + '\n');
-    process.exit();
-}
-
-// Root check
-rootCheck(options, bower.config);
-
-// Set loglevel
-if (bower.config.silent) {
-    loglevel = levels.error;
-} else if (bower.config.verbose) {
-    loglevel = -Infinity;
-    Q.longStackSupport = true;
-} else if (bower.config.quiet) {
-    loglevel = levels.warn;
-} else {
-    loglevel = levels[bower.config.loglevel] || levels.info;
-}
-
-// Get the command to execute
-while (options.argv.remain.length) {
-    command = options.argv.remain.join(' ');
-
-    // Alias lookup
-    if (bower.abbreviations[command]) {
-        command = bower.abbreviations[command].replace(/\s/g, '.');
-        break;
-    }
-
-    command = command.replace(/\s/g, '.');
-
-    // Direct lookup
-    if (mout.object.has(bower.commands, command)) {
-        break;
-    }
-
-    options.argv.remain.pop();
-}
-
-// Ask for Insights on first run.
-analytics.setup().then(function () {
-    // Execute the command
-    commandFunc = command && mout.object.get(bower.commands, command);
-    command = command && command.replace(/\./g, ' ');
-
-    // If no command was specified, show bower help
-    // Do the same if the command is unknown
-    if (!commandFunc) {
-        logger = bower.commands.help();
-        command = 'help';
-    // If the user requested help, show the command's help
-    // Do the same if the actual command is a group of other commands (e.g.: cache)
-    } else if (options.help || !commandFunc.line) {
-        logger = bower.commands.help(command);
-        command = 'help';
-    // Call the line method
-    } else {
-        logger = commandFunc.line(process.argv);
-
-        // If the method failed to interpret the process arguments
-        // show the command help
-        if (!logger) {
-            logger = bower.commands.help(command);
-            command = 'help';
-        }
-    }
-
-    // Get the renderer and configure it with the executed command
-    renderer = cli.getRenderer(command, logger.json, bower.config);
-
-    logger
-    .on('end', function (data) {
-        if (!bower.config.silent && !bower.config.quiet) {
-            renderer.end(data);
-        }
-    })
-    .on('error', function (err)  {
-        if (levels.error >= loglevel) {
-            renderer.error(err);
-        }
-
-        process.exit(1);
-    })
-    .on('log', function (log) {
-        if (levels[log.level] >= loglevel) {
-            renderer.log(log);
-        }
-    })
-    .on('prompt', function (prompt, callback) {
-        renderer.prompt(prompt)
-        .then(function (answer) {
-            callback(answer);
-        });
-    });
-
-    // Warn if HOME is not SET
-    if (!osenv.home()) {
-        logger.warn('no-home', 'HOME not set, user configuration will not be loaded');
-    }
-
-    // Check for newer version of Bower
-    notifier = updateNotifier({
-        packageName: pkg.name,
-        packageVersion: pkg.version
-    });
-
-    if (notifier.update && levels.info >= loglevel) {
-        renderer.updateNotice(notifier.update);
-    }
-});
+require('../lib/bin/bower');

lib/bin/bower.js

@@ -0,0 +1,150 @@
+process.bin = process.title = 'bower';
+
+var Q = require('q');
+var mout = require('mout');
+var Logger = require('bower-logger');
+var userHome = require('user-home');
+var bower = require('../');
+var version = require('../version');
+var cli = require('../util/cli');
+var rootCheck = require('../util/rootCheck');
+
+var options;
+var renderer;
+var loglevel;
+var command;
+var commandFunc;
+var logger;
+var levels = Logger.LEVELS;
+
+options = cli.readOptions({
+    version: { type: Boolean, shorthand: 'v' },
+    help: { type: Boolean, shorthand: 'h' },
+    'allow-root': { type: Boolean }
+});
+
+// Handle print of version
+if (options.version) {
+    process.stdout.write(version + '\n');
+    process.exit();
+}
+
+// Root check
+rootCheck(options, bower.config);
+
+// Set loglevel
+if (bower.config.silent) {
+    loglevel = levels.error;
+} else if (bower.config.verbose) {
+    loglevel = -Infinity;
+    Q.longStackSupport = true;
+} else if (bower.config.quiet) {
+    loglevel = levels.warn;
+} else {
+    loglevel = levels[bower.config.loglevel] || levels.info;
+}
+
+// Get the command to execute
+while (options.argv.remain.length) {
+    command = options.argv.remain.join(' ');
+
+    // Alias lookup
+    if (bower.abbreviations[command]) {
+        command = bower.abbreviations[command].replace(/\s/g, '.');
+        break;
+    }
+
+    command = command.replace(/\s/g, '.');
+
+    // Direct lookup
+    if (mout.object.has(bower.commands, command)) {
+        break;
+    }
+
+    options.argv.remain.pop();
+}
+
+// Execute the command
+commandFunc = command && mout.object.get(bower.commands, command);
+command = command && command.replace(/\./g, ' ');
+
+// If no command was specified, show bower help
+// Do the same if the command is unknown
+if (!commandFunc) {
+    logger = bower.commands.help();
+    command = 'help';
+    // If the user requested help, show the command's help
+    // Do the same if the actual command is a group of other commands (e.g.: cache)
+} else if (options.help || !commandFunc.line) {
+    logger = bower.commands.help(command);
+    command = 'help';
+    // Call the line method
+} else {
+    logger = commandFunc.line(process.argv);
+
+    // If the method failed to interpret the process arguments
+    // show the command help
+    if (!logger) {
+        logger = bower.commands.help(command);
+        command = 'help';
+    }
+}
+
+// Get the renderer and configure it with the executed command
+renderer = cli.getRenderer(command, logger.json, bower.config);
+
+function handleLogger(logger, renderer) {
+    logger
+        .on('end', function(data) {
+            if (!bower.config.silent && !bower.config.quiet) {
+                renderer.end(data);
+            }
+        })
+        .on('error', function(err) {
+            if (
+                command !== 'help' &&
+                (err.code === 'EREADOPTIONS' || err.code === 'EINVFORMAT')
+            ) {
+                logger = bower.commands.help(command);
+                renderer = cli.getRenderer('help', logger.json, bower.config);
+                handleLogger(logger, renderer);
+            } else {
+                if (levels.error >= loglevel) {
+                    renderer.error(err);
+                }
+
+                process.exit(1);
+            }
+        })
+        .on('log', function(log) {
+            if (levels[log.level] >= loglevel) {
+                renderer.log(log);
+            }
+        })
+        .on('prompt', function(prompt, callback) {
+            renderer.prompt(prompt).then(function(answer) {
+                callback(answer);
+            });
+        });
+}
+
+handleLogger(logger, renderer);
+
+// Warn if HOME is not SET
+if (!userHome) {
+    logger.warn(
+        'no-home',
+        'HOME environment variable not set. User config will not be loaded.'
+    );
+}
+
+if (bower.config.interactive) {
+    var updateNotifier = require('update-notifier');
+
+    // Check for newer version of Bower
+    var notifier = updateNotifier({ pkg: { name: 'bower', version: version } });
+
+    if (notifier.update && levels.info >= loglevel) {
+        notifier.notify();
+    }
+}

lib/commands/cache/clean.js

@@ -1,22 +1,19 @@
-var fs = require('graceful-fs');
+var fs = require('../../util/fs');
 var path = require('path');
 var mout = require('mout');
 var Q = require('q');
-var rimraf = require('rimraf');
-var Logger = require('bower-logger');
+var rimraf = require('../../util/rimraf');
 var endpointParser = require('bower-endpoint-parser');
 var PackageRepository = require('../../core/PackageRepository');
 var semver = require('../../util/semver');
-var cli = require('../../util/cli');
 var defaultConfig = require('../../config');
 
-function clean(endpoints, options, config) {
-    var logger = new Logger();
+function clean(logger, endpoints, options, config) {
     var decEndpoints;
     var names;
 
     options = options || {};
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
 
     // If endpoints is an empty array, null them
     if (endpoints && !endpoints.length) {
@@ -25,46 +22,37 @@ function clean(endpoints, options, config) {
 
     // Generate decomposed endpoints and names based on the endpoints
     if (endpoints) {
-        decEndpoints = endpoints.map(function (endpoint) {
+        decEndpoints = endpoints.map(function(endpoint) {
             return endpointParser.decompose(endpoint);
         });
-        names = decEndpoints.map(function (decEndpoint) {
+        names = decEndpoints.map(function(decEndpoint) {
             return decEndpoint.name || decEndpoint.source;
         });
     }
 
-    Q.all([
+    return Q.all([
         clearPackages(decEndpoints, config, logger),
-        clearLinks(names, config, logger),
-        !names ? clearCompletion(config, logger) : null
-    ])
-    .spread(function (entries) {
+        clearLinks(names, config, logger)
+    ]).spread(function(entries) {
         return entries;
-    })
-    .done(function (entries) {
-        logger.emit('end', entries);
-    }, function (error) {
-        logger.emit('error', error);
     });
-
-    return logger;
 }
 
 function clearPackages(decEndpoints, config, logger) {
-    var repository =  new PackageRepository(config, logger);
+    var repository = new PackageRepository(config, logger);
 
-    return repository.list()
-    .then(function (entries) {
+    return repository.list().then(function(entries) {
         var promises;
 
         // Filter entries according to the specified packages
         if (decEndpoints) {
-            entries = entries.filter(function (entry) {
-                return !!mout.array.find(decEndpoints, function (decEndpoint) {
+            entries = entries.filter(function(entry) {
+                return !!mout.array.find(decEndpoints, function(decEndpoint) {
                     var entryPkgMeta = entry.pkgMeta;
 
                     // Check if name or source match the entry
-                    if  (decEndpoint.name !== entryPkgMeta.name &&
+                    if (
+                        decEndpoint.name !== entryPkgMeta.name &&
                         decEndpoint.source !== entryPkgMeta.name &&
                         decEndpoint.source !== entryPkgMeta._source
                     ) {
@@ -78,36 +66,47 @@ function clearPackages(decEndpoints, config, logger) {
 
                     // If it's a semver target, compare using semver spec
                     if (semver.validRange(decEndpoint.target)) {
-                        return semver.satisfies(entryPkgMeta.version, decEndpoint.target);
+                        return semver.satisfies(
+                            entryPkgMeta.version,
+                            decEndpoint.target
+                        );
                     }
 
                     // Otherwise, compare against target/release
-                    return decEndpoint.target === entryPkgMeta._target ||
-                           decEndpoint.target === entryPkgMeta._release;
+                    return (
+                        decEndpoint.target === entryPkgMeta._target ||
+                        decEndpoint.target === entryPkgMeta._release
+                    );
                 });
             });
         }
 
-        promises = entries.map(function (entry) {
-            return repository.eliminate(entry.pkgMeta)
-            .then(function () {
-                logger.info('deleted', 'Cached package ' + entry.pkgMeta.name + ': ' + entry.canonicalDir, {
-                    file: entry.canonicalDir
-                });
+        promises = entries.map(function(entry) {
+            return repository.eliminate(entry.pkgMeta).then(function() {
+                logger.info(
+                    'deleted',
+                    'Cached package ' +
+                        entry.pkgMeta.name +
+                        ': ' +
+                        entry.canonicalDir,
+                    {
+                        file: entry.canonicalDir
+                    }
+                );
             });
         });
 
         return Q.all(promises)
-        .then(function () {
-            if (!decEndpoints) {
-                // Ensure that everything is cleaned,
-                // even invalid packages in the cache
-                return repository.clear();
-            }
-        })
-        .then(function () {
-            return entries;
-        });
+            .then(function() {
+                if (!decEndpoints) {
+                    // Ensure that everything is cleaned,
+                    // even invalid packages in the cache
+                    return repository.clear();
+                }
+            })
+            .then(function() {
+                return entries;
+            });
     });
 }
 
@@ -117,59 +116,59 @@ function clearLinks(names, config, logger) {
 
     // If no names are passed, grab all links
     if (!names) {
-        promise = Q.nfcall(fs.readdir, dir)
-        .fail(function (err) {
+        promise = Q.nfcall(fs.readdir, dir).fail(function(err) {
             if (err.code === 'ENOENT') {
                 return [];
             }
 
             throw err;
         });
-    // Otherwise use passed ones
+        // Otherwise use passed ones
     } else {
         promise = Q.resolve(names);
     }
 
-    return promise
-    .then(function (names) {
+    return promise.then(function(names) {
         var promises;
         var linksToRemove = [];
 
         // Decide which links to delete
-        promises = names.map(function (name) {
+        promises = names.map(function(name) {
             var link = path.join(config.storage.links, name);
 
-            return Q.nfcall(fs.readlink, link)
-            .then(function (linkTarget) {
-                // Link exists, check if it points to a folder
-                // that still exists
-                return Q.nfcall(fs.stat, linkTarget)
-                .then(function (stat) {
-                    // Target is not a folder..
-                    if (!stat.isDirectory()) {
+            return Q.nfcall(fs.readlink, link).then(
+                function(linkTarget) {
+                    // Link exists, check if it points to a folder
+                    // that still exists
+                    return (
+                        Q.nfcall(fs.stat, linkTarget)
+                            .then(function(stat) {
+                                // Target is not a folder..
+                                if (!stat.isDirectory()) {
+                                    linksToRemove.push(link);
+                                }
+                            })
+                            // Error occurred reading the link
+                            .fail(function() {
+                                linksToRemove.push(link);
+                            })
+                    );
+                    // Ignore if link does not exist
+                },
+                function(err) {
+                    if (err.code !== 'ENOENT') {
                         linksToRemove.push(link);
                     }
-                })
-                // Error occurred reading the link
-                .fail(function () {
-                    linksToRemove.push(link);
-                });
-            // Ignore if link does not exist
-            }, function (err) {
-                if (err.code !== 'ENOENT') {
-                    linksToRemove.push(link);
                 }
-            });
+            );
         });
 
-        return Q.all(promises)
-        .then(function () {
+        return Q.all(promises).then(function() {
             var promises;
 
             // Remove each link that was declared as invalid
-            promises = linksToRemove.map(function (link) {
-                return Q.nfcall(rimraf, link)
-                .then(function () {
+            promises = linksToRemove.map(function(link) {
+                return Q.nfcall(rimraf, link).then(function() {
                     logger.info('deleted', 'Invalid link: ' + link, {
                         file: link
                     });
@@ -181,37 +180,16 @@ function clearLinks(names, config, logger) {
     });
 }
 
-function clearCompletion(config, logger) {
-    var dir = config.storage.completion;
-
-    return Q.nfcall(fs.stat, dir)
-    .then(function () {
-        return Q.nfcall(rimraf, dir)
-        .then(function () {
-            logger.info('deleted', 'Completion cache', {
-                file: dir
-            });
-        });
-    }, function (error) {
-        if (error.code !== 'ENOENT') {
-            throw error;
-        }
-    });
-}
-
 // -------------------
 
-clean.line = function (argv) {
-    var options = clean.options(argv);
-    return clean(options.argv.remain.slice(2), options);
-};
+clean.readOptions = function(argv) {
+    var cli = require('../../util/cli');
+    var options = cli.readOptions(argv);
+    var endpoints = options.argv.remain.slice(2);
 
-clean.options = function (argv) {
-    return cli.readOptions(argv);
-};
+    delete options.argv;
 
-clean.completion = function () {
-    // TODO:
+    return [endpoints, options];
 };
 
 module.exports = clean;

lib/commands/cache/index.js

@@ -1,4 +0,0 @@
-module.exports = {
-    clean: require('./clean'),
-    list: require('./list')
-};

lib/commands/cache/list.js

@@ -1,14 +1,11 @@
 var mout = require('mout');
-var Logger = require('bower-logger');
 var PackageRepository = require('../../core/PackageRepository');
-var cli = require('../../util/cli');
 var defaultConfig = require('../../config');
 
-function list(packages, options, config) {
+function list(logger, packages, options, config) {
     var repository;
-    var logger = new Logger();
 
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
     repository = new PackageRepository(config, logger);
 
     // If packages is an empty array, null them
@@ -16,41 +13,30 @@ function list(packages, options, config) {
         packages = null;
     }
 
-    repository.list()
-    .then(function (entries) {
+    return repository.list().then(function(entries) {
         if (packages) {
             // Filter entries according to the specified packages
-            entries = entries.filter(function (entry) {
-                return !!mout.array.find(packages, function (pkg) {
+            entries = entries.filter(function(entry) {
+                return !!mout.array.find(packages, function(pkg) {
                     return pkg === entry.pkgMeta.name;
                 });
             });
         }
 
         return entries;
-    })
-    .done(function (entries) {
-        logger.emit('end', entries);
-    }, function (error) {
-        logger.emit('error', error);
     });
-
-    return logger;
 }
 
 // -------------------
 
-list.line = function (argv) {
-    var options = list.options(argv);
-    return list(options.argv.remain.slice(2), options);
-};
+list.readOptions = function(argv) {
+    var cli = require('../../util/cli');
+    var options = cli.readOptions(argv);
+    var packages = options.argv.remain.slice(2);
 
-list.options = function (argv) {
-    return cli.readOptions(argv);
-};
+    delete options.argv;
 
-list.completion = function () {
-    // TODO:
+    return [packages, options];
 };
 
 module.exports = list;

lib/commands/completion.js

@@ -1,31 +0,0 @@
-var Logger = require('bower-logger');
-var cli = require('../util/cli');
-
-function completion(config) {
-    var logger = new Logger();
-
-    process.nextTick(function () {
-        logger.emit('end');
-    });
-
-    return logger;
-}
-
-// -------------------
-
-completion.line = function (argv) {
-    var options = completion.options(argv);
-    var name = options.argv.remain[1];
-
-    return completion(name);
-};
-
-completion.options = function (argv) {
-    return cli.readOptions(argv);
-};
-
-completion.completion = function () {
-    // TODO:
-};
-
-module.exports = completion;

lib/commands/help.js

@@ -1,52 +1,41 @@
+var Q = require('q');
 var path = require('path');
-var fs = require('graceful-fs');
-var Logger = require('bower-logger');
-var cli = require('../util/cli');
+var fs = require('../util/fs');
 var createError = require('../util/createError');
 
-function help(name) {
+function help(logger, name, config) {
     var json;
-    var logger = new Logger();
 
     if (name) {
-        json = path.resolve(__dirname, '../../templates/json/help-' + name.replace(/\s+/g, '/') + '.json');
+        json = path.resolve(
+            __dirname,
+            '../templates/json/help-' + name.replace(/\s+/g, '/') + '.json'
+        );
     } else {
-        json = path.resolve(__dirname, '../../templates/json/help.json');
+        json = path.resolve(__dirname, '../templates/json/help.json');
     }
 
-    fs.exists(json, function (exists) {
+    return Q.promise(function(resolve) {
+        fs.exists(json, resolve);
+    }).then(function(exists) {
         if (!exists) {
-            return logger.emit('error', createError('Unknown command: ' + name, 'EUNKOWNCMD', {
+            throw createError('Unknown command: ' + name, 'EUNKNOWNCMD', {
                 command: name
-            }));
+            });
         }
 
-        try {
-            json = require(json);
-        } catch (error) {
-            return logger.emit('error', error);
-        }
-
-        logger.emit('end', json);
+        return require(json);
     });
-
-    return logger;
 }
 
 // -------------------
 
-help.line = function (argv) {
-    var options = help.options(argv);
+help.readOptions = function(argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
+    var name = options.argv.remain.slice(1).join(' ');
 
-    return help(options.argv.remain.slice(1).join(' '));
-};
-
-help.options = function (argv) {
-    return cli.readOptions(argv);
-};
-
-help.completion = function () {
-    // TODO
+    return [name];
 };
 
 module.exports = help;

lib/commands/home.js

@@ -1,27 +1,22 @@
-var mout = require('mout');
-var Logger = require('bower-logger');
 var Project = require('../core/Project');
-var open = require('open');
+var open = require('opn');
 var endpointParser = require('bower-endpoint-parser');
-var cli = require('../util/cli');
 var createError = require('../util/createError');
 var defaultConfig = require('../config');
 
-function home(name, config) {
+function home(logger, name, config) {
     var project;
     var promise;
     var decEndpoint;
-    var logger = new Logger();
 
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
     project = new Project(config, logger);
 
     // Get the package meta
     // If no name is specified, read the project json
     // If a name is specified, fetch from the package repository
     if (!name) {
-        promise = project.hasJson()
-        .then(function (json) {
+        promise = project.hasJson().then(function(json) {
             if (!json) {
                 throw createError('You are not inside a package', 'ENOENT');
             }
@@ -30,47 +25,35 @@ function home(name, config) {
         });
     } else {
         decEndpoint = endpointParser.decompose(name);
-        promise = project.getPackageRepository().fetch(decEndpoint)
-        .spread(function (canonicalDir, pkgMeta) {
-            return pkgMeta;
-        });
+        promise = project
+            .getPackageRepository()
+            .fetch(decEndpoint)
+            .spread(function(canonicalDir, pkgMeta) {
+                return pkgMeta;
+            });
     }
 
     // Get homepage and open it
-    promise.then(function (pkgMeta) {
+    return promise.then(function(pkgMeta) {
         var homepage = pkgMeta.homepage;
 
         if (!homepage) {
             throw createError('No homepage set for ' + pkgMeta.name, 'ENOHOME');
         }
 
-        open(homepage);
+        open(homepage, { wait: false });
         return homepage;
-    })
-    .done(function (homepage) {
-        logger.emit('end', homepage);
-    }, function (error) {
-        logger.emit('error', error);
     });
-
-    return logger;
 }
 
 // -------------------
 
-home.line = function (argv) {
-    var options = home.options(argv);
+home.readOptions = function(argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
     var name = options.argv.remain[1];
 
-    return home(name);
-};
-
-home.options = function (argv) {
-    return cli.readOptions(argv);
-};
-
-home.completion = function () {
-    // TODO:
+    return [name];
 };
 
 module.exports = home;

lib/commands/index.js

@@ -1,5 +1,6 @@
 var Q = require('q');
 var Logger = require('bower-logger');
+var config = require('../config');
 
 /**
  * Require commands only when called.
@@ -8,50 +9,74 @@ var Logger = require('bower-logger');
  * a command function. The difference is that `cmd = commandFactory()` and `cmd()`
  * return as soon as possible and load and execute the command asynchronously.
  */
-function lazyRequire(id) {
-    function command() {
-        var logger = new Logger();
-        var commandArgs = arguments;
+function commandFactory(id) {
+    function runApi() {
+        var command = require(id);
+        var commandArgs = [].slice.call(arguments);
 
-        Q.try(function () {
-            // call require asynchronously
-            return require(id).apply(undefined, commandArgs);
-        })
-        .done(function (commandLogger) {
-            // forward to exposed logger
-            commandLogger.on('end', logger.emit.bind(logger, 'end'));
-            commandLogger.on('error', logger.emit.bind(logger, 'error'));
-        }, function (error) {
-            logger.emit('error', error);
+        return withLogger(function(logger) {
+            commandArgs.unshift(logger);
+
+            return command.apply(undefined, commandArgs);
         });
+    }
+
+    function runFromArgv(argv) {
+        var commandArgs;
+        var command = require(id);
+
+        commandArgs = command.readOptions(argv);
+
+        return withLogger(function(logger) {
+            commandArgs.unshift(logger);
+
+            return command.apply(undefined, commandArgs);
+        });
+    }
+
+    function withLogger(func) {
+        var logger = new Logger();
+
+        Q.try(func, logger).done(
+            function() {
+                config.restore();
+                var args = [].slice.call(arguments);
+                args.unshift('end');
+                logger.emit.apply(logger, args);
+            },
+            function(error) {
+                config.restore();
+                logger.emit('error', error);
+            }
+        );
 
         return logger;
     }
 
-    function runFromArgv() {
-        return require(id).line.apply(undefined, arguments);
-    }
+    runApi.line = runFromArgv;
 
-    command.line = runFromArgv;
-    return command;
+    return runApi;
 }
 
-
 module.exports = {
-    cache: lazyRequire('./cache'),
-    completion: lazyRequire('./completion'),
-    help: lazyRequire('./help'),
-    home: lazyRequire('./home'),
-    info: lazyRequire('./info'),
-    init: lazyRequire('./init'),
-    install: lazyRequire('./install'),
-    link: lazyRequire('./link'),
-    list: lazyRequire('./list'),
-    lookup: lazyRequire('./lookup'),
-    prune: lazyRequire('./prune'),
-    register: lazyRequire('./register'),
-    search: lazyRequire('./search'),
-    update: lazyRequire('./update'),
-    uninstall: lazyRequire('./uninstall'),
-    version: lazyRequire('./version')
+    cache: {
+        clean: commandFactory('./cache/clean'),
+        list: commandFactory('./cache/list')
+    },
+    help: commandFactory('./help'),
+    home: commandFactory('./home'),
+    info: commandFactory('./info'),
+    init: commandFactory('./init'),
+    install: commandFactory('./install'),
+    link: commandFactory('./link'),
+    list: commandFactory('./list'),
+    login: commandFactory('./login'),
+    lookup: commandFactory('./lookup'),
+    prune: commandFactory('./prune'),
+    register: commandFactory('./register'),
+    search: commandFactory('./search'),
+    update: commandFactory('./update'),
+    uninstall: commandFactory('./uninstall'),
+    unregister: commandFactory('./unregister'),
+    version: commandFactory('./version')
 };

lib/commands/info.js

@@ -1,30 +1,35 @@
 var mout = require('mout');
 var Q = require('q');
-var Logger = require('bower-logger');
 var endpointParser = require('bower-endpoint-parser');
 var PackageRepository = require('../core/PackageRepository');
-var cli = require('../util/cli');
-var Tracker = require('../util/analytics').Tracker;
 var defaultConfig = require('../config');
 
-function info(endpoint, property, config) {
+function info(logger, endpoint, property, config) {
+    if (!endpoint) {
+        return;
+    }
+
+    // handle @ as version divider
+    var splitParts = endpoint.split('/');
+    splitParts[splitParts.length - 1] = splitParts[
+        splitParts.length - 1
+    ].replace('@', '#');
+    endpoint = splitParts.join('/');
+
     var repository;
     var decEndpoint;
-    var tracker;
-    var logger = new Logger();
 
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
     repository = new PackageRepository(config, logger);
-    tracker = new Tracker(config);
 
     decEndpoint = endpointParser.decompose(endpoint);
-    tracker.trackDecomposedEndpoints('info', [decEndpoint]);
 
-    Q.all([
+    return Q.all([
         getPkgMeta(repository, decEndpoint, property),
-        decEndpoint.target === '*' && !property ? repository.versions(decEndpoint.source) : null
-    ])
-    .spread(function (pkgMeta, versions) {
+        decEndpoint.target === '*' && !property
+            ? repository.versions(decEndpoint.source)
+            : null
+    ]).spread(function(pkgMeta, versions) {
         if (versions) {
             return {
                 name: decEndpoint.source,
@@ -34,52 +39,35 @@ function info(endpoint, property, config) {
         }
 
         return pkgMeta;
-    })
-    .done(function (result) {
-        logger.emit('end', result);
-    }, function (error) {
-        logger.emit('error', error);
     });
-
-    return logger;
 }
 
 function getPkgMeta(repository, decEndpoint, property) {
-    return repository.fetch(decEndpoint)
-    .spread(function (canonicalDir, pkgMeta) {
-        pkgMeta = mout.object.filter(pkgMeta, function (value, key) {
-            return key.charAt(0) !== '_';
+    return repository
+        .fetch(decEndpoint)
+        .spread(function(canonicalDir, pkgMeta) {
+            pkgMeta = mout.object.filter(pkgMeta, function(value, key) {
+                return key.charAt(0) !== '_';
+            });
+
+            // Retrieve specific property
+            if (property) {
+                pkgMeta = mout.object.get(pkgMeta, property);
+            }
+
+            return pkgMeta;
         });
-
-        // Retrieve specific property
-        if (property) {
-            pkgMeta = mout.object.get(pkgMeta, property);
-        }
-
-        return pkgMeta;
-    });
 }
 
 // -------------------
 
-info.line = function (argv) {
-    var options = info.options(argv);
+info.readOptions = function(argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
     var pkg = options.argv.remain[1];
     var property = options.argv.remain[2];
 
-    if (!pkg) {
-        return null;
-    }
-
-    return info(pkg, property);
-};
-
-info.options = function (argv) {
-    return cli.readOptions(argv);
-};
-
-info.completion = function () {
-    // TODO:
+    return [pkg, property];
 };
 
 module.exports = info;

lib/commands/init.js

@@ -1,61 +1,60 @@
 var mout = require('mout');
-var fs = require('graceful-fs');
+var fs = require('../util/fs');
 var path = require('path');
 var Q = require('q');
-var Logger = require('bower-logger');
 var endpointParser = require('bower-endpoint-parser');
 var Project = require('../core/Project');
 var defaultConfig = require('../config');
 var GitHubResolver = require('../core/resolvers/GitHubResolver');
-var GitFsResolver = require('../core/resolvers/GitFsResolver');
-var cli = require('../util/cli');
 var cmd = require('../util/cmd');
 var createError = require('../util/createError');
 
-function init(config) {
+function init(logger, config) {
     var project;
-    var logger = new Logger();
 
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = config || {};
+
+    if (!config.cwd) {
+        config.cwd = process.cwd();
+    }
+
+    config = defaultConfig(config);
 
     // This command requires interactive to be enabled
     if (!config.interactive) {
-        process.nextTick(function () {
-            logger.emit('error', createError('Register requires an interactive shell', 'ENOINT', {
-                details: 'Note that you can manually force an interactive shell with --config.interactive'
-            }));
+        throw createError('Register requires an interactive shell', 'ENOINT', {
+            details:
+                'Note that you can manually force an interactive shell with --config.interactive'
         });
-        return logger;
     }
 
     project = new Project(config, logger);
 
     // Start with existing JSON details
-    readJson(project, logger)
-    // Fill in defaults
-    .then(setDefaults.bind(null, config))
-    // Now prompt user to make changes
-    .then(promptUser.bind(null, logger))
-    // Set ignore based on the response
-    .spread(setIgnore.bind(null, config))
-    // Set dependencies based on the response
-    .spread(setDependencies.bind(null, project))
-    // All done!
-    .spread(saveJson.bind(null, project, logger))
-    .done(function (json) {
-        logger.emit('end', json);
-    }, function (error) {
-        logger.emit('error', error);
-    });
-
-    return logger;
+    return (
+        readJson(project, logger)
+            // Fill in defaults
+            .then(setDefaults.bind(null, config))
+            // Now prompt user to make changes
+            .then(promptUser.bind(null, logger))
+            // Set ignore based on the response
+            .spread(setIgnore.bind(null, config))
+            // Set dependencies based on the response
+            .spread(setDependencies.bind(null, project))
+            // All done!
+            .spread(saveJson.bind(null, project, logger))
+    );
 }
 
 function readJson(project, logger) {
-    return project.hasJson()
-    .then(function (json) {
+    return project.hasJson().then(function(json) {
         if (json) {
-            logger.warn('existing', 'The existing ' + path.basename(json) + ' file will be used and filled in');
+            logger.warn(
+                'existing',
+                'The existing ' +
+                    path.basename(json) +
+                    ' file will be used and filled in'
+            );
         }
 
         return project.getJson();
@@ -64,8 +63,8 @@ function readJson(project, logger) {
 
 function saveJson(project, logger, json) {
     // Cleanup empty props (null values, empty strings, objects and arrays)
-    mout.object.forOwn(json, function (value, key) {
-        if (value == null || mout.lang.isEmpty(value)) {
+    mout.object.forOwn(json, function(value, key) {
+        if (!validConfigValue(value)) {
             delete json[key];
         }
     });
@@ -77,8 +76,7 @@ function saveJson(project, logger, json) {
         type: 'confirm',
         message: 'Looks good?',
         default: true
-    })
-    .then(function (good) {
+    }).then(function(good) {
         if (!good) {
             return null;
         }
@@ -88,6 +86,18 @@ function saveJson(project, logger, json) {
     });
 }
 
+// Test if value is of a type supported by bower.json[0] - Object, Array, String, Boolean - or a Number
+// [0]: https://github.com/bower/bower.json-spec
+function validConfigValue(val) {
+    return (
+        mout.lang.isObject(val) ||
+        mout.lang.isArray(val) ||
+        mout.lang.isString(val) ||
+        mout.lang.isBoolean(val) ||
+        mout.lang.isNumber(val)
+    );
+}
+
 function setDefaults(config, json) {
     var name;
     var promise = Q.resolve();
@@ -97,19 +107,6 @@ function setDefaults(config, json) {
         json.name = path.basename(config.cwd);
     }
 
-    // Version
-    if (!json.version) {
-        // Assume latest semver tag if it's a git repo
-        promise = promise.then(function () {
-            return GitFsResolver.versions(config.cwd)
-            .then(function (versions) {
-                json.version = versions[0] || '0.0.0';
-            }, function () {
-                json.version = '0.0.0';
-            });
-        });
-    }
-
     // Main
     if (!json.main) {
         // Remove '.js' from the end of the package name if it is there
@@ -125,52 +122,70 @@ function setDefaults(config, json) {
     // Homepage
     if (!json.homepage) {
         // Set as GitHub homepage if it's a GitHub repository
-        promise = promise.then(function () {
+        promise = promise.then(function() {
             return cmd('git', ['config', '--get', 'remote.origin.url'])
-            .spread(function (stdout) {
-                var pair;
+                .spread(function(stdout) {
+                    var pair;
 
-                stdout = stdout.trim();
-                if (!stdout) {
-                    return;
-                }
+                    stdout = stdout.trim();
+                    if (!stdout) {
+                        return;
+                    }
 
-                pair = GitHubResolver.getOrgRepoPair(stdout);
-                if (pair) {
-                    json.homepage = 'https://github.com/' + pair.org + '/' + pair.repo;
-                }
-            })
-            .fail(function () { });
+                    pair = GitHubResolver.getOrgRepoPair(stdout);
+                    if (pair) {
+                        json.homepage =
+                            'https://github.com/' + pair.org + '/' + pair.repo;
+                    }
+                })
+                .fail(function() {});
         });
     }
 
     if (!json.authors) {
-        promise = promise.then(function () {
+        promise = promise.then(function() {
             // Get the user name configured in git
-            return cmd('git', ['config', '--get', '--global', 'user.name'])
-            .spread(function (stdout) {
-                var gitEmail;
-                var gitName = stdout.trim();
+            return cmd('git', [
+                'config',
+                '--get',
+                '--global',
+                'user.name'
+            ]).spread(
+                function(stdout) {
+                    var gitEmail;
+                    var gitName = stdout.trim();
 
-                // Abort if no name specified
-                if (!gitName) {
-                    return;
-                }
+                    // Abort if no name specified
+                    if (!gitName) {
+                        return;
+                    }
 
-                // Get the user email configured in git
-                return cmd('git', ['config', '--get', '--global', 'user.email'])
-                .spread(function (stdout) {
-                    gitEmail = stdout.trim();
-                }, function () {})
-                .then(function () {
-                    json.authors = gitName;
-                    json.authors += gitEmail ? ' <' + gitEmail + '>' : '';
-                });
-            }, function () {});
+                    // Get the user email configured in git
+                    return cmd('git', [
+                        'config',
+                        '--get',
+                        '--global',
+                        'user.email'
+                    ])
+                        .spread(
+                            function(stdout) {
+                                gitEmail = stdout.trim();
+                            },
+                            function() {}
+                        )
+                        .then(function() {
+                            json.authors = gitName;
+                            json.authors += gitEmail
+                                ? ' <' + gitEmail + '>'
+                                : '';
+                        });
+                },
+                function() {}
+            );
         });
     }
 
-    return promise.then(function () {
+    return promise.then(function() {
         return json;
     });
 }
@@ -178,86 +193,76 @@ function setDefaults(config, json) {
 function promptUser(logger, json) {
     var questions = [
         {
-            'name': 'name',
-            'message': 'name',
-            'default': json.name,
-            'type': 'input'
+            name: 'name',
+            message: 'name',
+            default: json.name,
+            type: 'input'
         },
         {
-            'name': 'version',
-            'message': 'version',
-            'default': json.version,
-            'type': 'input'
+            name: 'description',
+            message: 'description',
+            default: json.description,
+            type: 'input'
         },
         {
-            'name': 'description',
-            'message': 'description',
-            'default': json.description,
-            'type': 'input'
+            name: 'main',
+            message: 'main file',
+            default: json.main,
+            type: 'input'
         },
         {
-            'name': 'main',
-            'message': 'main file',
-            'default': json.main,
-            'type': 'input'
+            name: 'keywords',
+            message: 'keywords',
+            default: json.keywords ? json.keywords.toString() : null,
+            type: 'input'
         },
         {
-            'name': 'moduleType',
-            'message': 'what types of modules does this package expose?',
-            'type': 'checkbox',
-            'choices': ['amd', 'es6', 'globals', 'node', 'yui']
+            name: 'authors',
+            message: 'authors',
+            default: json.authors ? json.authors.toString() : null,
+            type: 'input'
         },
         {
-            'name': 'keywords',
-            'message': 'keywords',
-            'default': json.keywords ? json.keywords.toString() : null,
-            'type': 'input'
+            name: 'license',
+            message: 'license',
+            default: json.license || 'MIT',
+            type: 'input'
         },
         {
-            'name': 'authors',
-            'message': 'authors',
-            'default': json.authors ? json.authors.toString() : null,
-            'type': 'input'
+            name: 'homepage',
+            message: 'homepage',
+            default: json.homepage,
+            type: 'input'
         },
         {
-            'name': 'license',
-            'message': 'license',
-            'default': json.license || 'MIT',
-            'type': 'input'
+            name: 'dependencies',
+            message: 'set currently installed components as dependencies?',
+            default:
+                !mout.object.size(json.dependencies) &&
+                !mout.object.size(json.devDependencies),
+            type: 'confirm'
         },
         {
-            'name': 'homepage',
-            'message': 'homepage',
-            'default': json.homepage,
-            'type': 'input'
+            name: 'ignore',
+            message: 'add commonly ignored files to ignore list?',
+            default: true,
+            type: 'confirm'
         },
         {
-            'name': 'dependencies',
-            'message': 'set currently installed components as dependencies?',
-            'default': !mout.object.size(json.dependencies) && !mout.object.size(json.devDependencies),
-            'type': 'confirm'
-        },
-        {
-            'name': 'ignore',
-            'message': 'add commonly ignored files to ignore list?',
-            'default': true,
-            'type': 'confirm'
-        },
-        {
-            'name': 'private',
-            'message': 'would you like to mark this package as private which prevents it from being accidentally published to the registry?',
-            'default': !!json.private,
-            'type': 'confirm'
+            name: 'private',
+            message:
+                'would you like to mark this package as private which prevents it from being accidentally published to the registry?',
+            default: !!json.private,
+            type: 'confirm'
         }
     ];
 
-    return Q.nfcall(logger.prompt.bind(logger), questions)
-    .then(function (answers) {
+    return Q.nfcall(logger.prompt.bind(logger), questions).then(function(
+        answers
+    ) {
         json.name = answers.name;
-        json.version = answers.version;
         json.description = answers.description;
         json.main = answers.main;
-        json.moduleType = answers.moduleType;
         json.keywords = toArray(answers.keywords);
         json.authors = toArray(answers.authors, ',');
         json.license = answers.license;
@@ -272,12 +277,12 @@ function toArray(value, splitter) {
     var arr = value.split(splitter || /[\s,]/);
 
     // Trim values
-    arr = arr.map(function (item) {
+    arr = arr.map(function(item) {
         return item.trim();
     });
 
     // Filter empty values
-    arr = arr.filter(function (item) {
+    arr = arr.filter(function(item) {
         return !!item;
     });
 
@@ -301,13 +306,12 @@ function setIgnore(config, json, answers) {
 
 function setDependencies(project, json, answers) {
     if (answers.dependencies) {
-        return project.getTree()
-        .spread(function (tree, flattened, extraneous) {
+        return project.getTree().spread(function(tree, flattened, extraneous) {
             if (extraneous.length) {
                 json.dependencies = {};
 
                 // Add extraneous as dependencies
-                extraneous.forEach(function (extra) {
+                extraneous.forEach(function(extra) {
                     var jsonEndpoint;
 
                     // Skip linked packages
@@ -315,7 +319,9 @@ function setDependencies(project, json, answers) {
                         return;
                     }
 
-                    jsonEndpoint = endpointParser.decomposed2json(extra.endpoint);
+                    jsonEndpoint = endpointParser.decomposed2json(
+                        extra.endpoint
+                    );
                     mout.object.mixIn(json.dependencies, jsonEndpoint);
                 });
             }
@@ -329,16 +335,8 @@ function setDependencies(project, json, answers) {
 
 // -------------------
 
-init.line = function () {
-    return init();
-};
-
-init.options = function (argv) {
-    return cli.readOptions(argv);
-};
-
-init.completion = function () {
-    // TODO:
+init.readOptions = function(argv) {
+    return [];
 };
 
 module.exports = init;

lib/commands/install.js

@@ -1,61 +1,55 @@
-var mout = require('mout');
-var Logger = require('bower-logger');
 var endpointParser = require('bower-endpoint-parser');
 var Project = require('../core/Project');
-var cli = require('../util/cli');
-var Tracker = require('../util/analytics').Tracker;
 var defaultConfig = require('../config');
 
-function install(endpoints, options, config) {
+function install(logger, endpoints, options, config) {
     var project;
     var decEndpoints;
-    var tracker;
-    var logger = new Logger();
 
     options = options || {};
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
     if (options.save === undefined) {
         options.save = config.defaultSave;
     }
     project = new Project(config, logger);
-    tracker = new Tracker(config);
 
     // Convert endpoints to decomposed endpoints
     endpoints = endpoints || [];
-    decEndpoints = endpoints.map(function (endpoint) {
+    decEndpoints = endpoints.map(function(endpoint) {
+        // handle @ as version divider
+        var splitParts = endpoint.split('/');
+        splitParts[splitParts.length - 1] = splitParts[
+            splitParts.length - 1
+        ].replace('@', '#');
+        endpoint = splitParts.join('/');
+
         return endpointParser.decompose(endpoint);
     });
-    tracker.trackDecomposedEndpoints('install', decEndpoints);
 
-    project.install(decEndpoints, options)
-    .done(function (installed) {
-        tracker.trackPackages('installed', installed);
-        logger.emit('end', installed);
-    }, function (error) {
-        logger.emit('error', error);
-    });
-
-    return logger;
+    return project.install(decEndpoints, options, config);
 }
 
 // -------------------
 
-install.line = function (argv) {
-    var options = install.options(argv);
-    return install(options.argv.remain.slice(1), options);
-};
+install.readOptions = function(argv) {
+    var cli = require('../util/cli');
 
-install.options = function (argv) {
-    return cli.readOptions({
-        'force-latest': { type: Boolean, shorthand: 'F'},
-        'production': { type: Boolean, shorthand: 'p' },
-        'save': { type: Boolean, shorthand: 'S' },
-        'save-dev': { type: Boolean, shorthand: 'D' }
-    }, argv);
-};
+    var options = cli.readOptions(
+        {
+            'force-latest': { type: Boolean, shorthand: 'F' },
+            production: { type: Boolean, shorthand: 'p' },
+            save: { type: Boolean, shorthand: 'S' },
+            'save-dev': { type: Boolean, shorthand: 'D' },
+            'save-exact': { type: Boolean, shorthand: 'E' }
+        },
+        argv
+    );
 
-install.completion = function () {
-    // TODO:
+    var packages = options.argv.remain.slice(1);
+
+    delete options.argv;
+
+    return [packages, options];
 };
 
 module.exports = install;

lib/commands/link.js

@@ -1,110 +1,88 @@
 var path = require('path');
-var rimraf = require('rimraf');
-var mout = require('mout');
+var rimraf = require('../util/rimraf');
 var Q = require('q');
-var Logger = require('bower-logger');
 var Project = require('../core/Project');
 var createLink = require('../util/createLink');
-var cli = require('../util/cli');
 var defaultConfig = require('../config');
+var relativeToBaseDir = require('../util/relativeToBaseDir');
 
-function linkSelf(config) {
+function link(logger, name, localName, config) {
+    if (name) {
+        return linkTo(logger, name, localName, config);
+    } else {
+        return linkSelf(logger, config);
+    }
+}
+
+function linkSelf(logger, config) {
     var project;
-    var logger = new Logger();
 
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
     project = new Project(config, logger);
 
-    project.getJson()
-    .then(function (json) {
+    return project.getJson().then(function(json) {
         var src = config.cwd;
         var dst = path.join(config.storage.links, json.name);
 
         // Delete previous link if any
-        return Q.nfcall(rimraf, dst)
-        // Link globally
-        .then(function () {
-            return createLink(src, dst);
-        })
-        .then(function () {
-            return {
-                src: src,
-                dst: dst
-            };
-        });
-    })
-    .done(function (result) {
-        logger.emit('end', result);
-    }, function (error) {
-        logger.emit('error', error);
+        return (
+            Q.nfcall(rimraf, dst)
+                // Link globally
+                .then(function() {
+                    return createLink(src, dst);
+                })
+                .then(function() {
+                    return {
+                        src: src,
+                        dst: dst
+                    };
+                })
+        );
     });
-
-    return logger;
 }
 
-function linkTo(name, localName, config) {
+function linkTo(logger, name, localName, config) {
     var src;
     var dst;
-    var logger = new Logger();
-    var project = new Project(config, logger);
+    var project;
 
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
+    project = new Project(config, logger);
 
     localName = localName || name;
     src = path.join(config.storage.links, name);
-    dst = path.join(process.cwd(), config.directory, localName);
+    dst = path.join(relativeToBaseDir(config.cwd)(config.directory), localName);
 
     // Delete destination folder if any
-    Q.nfcall(rimraf, dst)
-    // Link locally
-    .then(function () {
-        return createLink(src, dst);
-    })
-    // Install linked package deps
-    .then(function () {
-        return project.update([localName]);
-    })
-    .then(function (installed) {
-        return {
-            src: src,
-            dst: dst,
-            installed: installed
-        };
-    })
-    .done(function (result) {
-        logger.emit('end', result);
-    }, function (error) {
-        logger.emit('error', error);
-    });
-
-    return logger;
+    return (
+        Q.nfcall(rimraf, dst)
+            // Link locally
+            .then(function() {
+                return createLink(src, dst);
+            })
+            // Install linked package deps
+            .then(function() {
+                return project.update([localName]);
+            })
+            .then(function(installed) {
+                return {
+                    src: src,
+                    dst: dst,
+                    installed: installed
+                };
+            })
+    );
 }
 
 // -------------------
 
-var link = {
-    linkTo: linkTo,
-    linkSelf: linkSelf
-};
-
-link.line = function (argv) {
-    var options = link.options(argv);
+link.readOptions = function(argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
     var name = options.argv.remain[1];
     var localName = options.argv.remain[2];
 
-    if (name) {
-        return linkTo(name, localName);
-    }
-
-    return linkSelf();
-};
-
-link.options = function (argv) {
-    return cli.readOptions(argv);
-};
-
-link.completion = function () {
-    // TODO:
+    return [name, localName];
 };
 
 module.exports = link;

lib/commands/list.js

@@ -1,54 +1,58 @@
 var path = require('path');
 var mout = require('mout');
 var Q = require('q');
-var Logger = require('bower-logger');
 var Project = require('../core/Project');
 var semver = require('../util/semver');
-var cli = require('../util/cli');
 var defaultConfig = require('../config');
 
-function list(options, config) {
+function list(logger, options, config) {
     var project;
-    var logger = new Logger();
 
     options = options || {};
 
     // Make relative option true by default when used with paths
-    if (options.paths && options.relative == null)  {
+    if (options.paths && options.relative == null) {
         options.relative = true;
     }
 
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
     project = new Project(config, logger);
 
-    project.getTree(options)
-    .spread(function (tree, flattened) {
-        var baseDir = path.dirname(path.join(config.cwd, config.directory));
-
+    return project.getTree(options).spread(function(tree, flattened) {
         // Relativize paths
         // Also normalize paths on windows
-        project.walkTree(tree, function (node) {
-            if (node.missing) {
-                return;
-            }
+        project.walkTree(
+            tree,
+            function(node) {
+                if (node.missing) {
+                    return;
+                }
 
-            if (options.relative) {
-                node.canonicalDir = path.relative(baseDir, node.canonicalDir);
-            }
-            if (options.paths) {
-                node.canonicalDir = normalize(node.canonicalDir);
-            }
-        }, true);
+                if (options.relative) {
+                    node.canonicalDir = path.relative(
+                        config.cwd,
+                        node.canonicalDir
+                    );
+                }
+                if (options.paths) {
+                    node.canonicalDir = normalize(node.canonicalDir);
+                }
+            },
+            true
+        );
 
         // Note that we need to to parse the flattened tree because it might
         // contain additional packages
-        mout.object.forOwn(flattened, function (node) {
+        mout.object.forOwn(flattened, function(node) {
             if (node.missing) {
                 return;
             }
 
             if (options.relative) {
-                node.canonicalDir = path.relative(baseDir, node.canonicalDir);
+                node.canonicalDir = path.relative(
+                    config.cwd,
+                    node.canonicalDir
+                );
             }
             if (options.paths) {
                 node.canonicalDir = normalize(node.canonicalDir);
@@ -66,20 +70,10 @@ function list(options, config) {
         }
 
         // Check for new versions
-        return checkVersions(project, tree, logger)
-        .then(function () {
+        return checkVersions(project, tree, logger).then(function() {
             return tree;
         });
-    })
-    .done(function (value) {
-        logger.emit('end', value);
-    }, function (error) {
-        logger.emit('error', error);
     });
-
-    logger.json = !!options.paths;
-
-    return logger;
 }
 
 function checkVersions(project, tree, logger) {
@@ -88,32 +82,40 @@ function checkVersions(project, tree, logger) {
     var repository = project.getPackageRepository();
 
     // Gather all nodes, ignoring linked nodes
-    project.walkTree(tree, function (node) {
-        if (!node.linked) {
-            nodes.push(node);
-        }
-    }, true);
+    project.walkTree(
+        tree,
+        function(node) {
+            if (!node.linked) {
+                nodes.push(node);
+            }
+        },
+        true
+    );
 
     if (nodes.length) {
-        logger.info('check-new', 'Checking for new versions of the project dependencies..');
+        logger.info(
+            'check-new',
+            'Checking for new versions of the project dependencies...'
+        );
     }
 
     // Check for new versions for each node
-    promises = nodes.map(function (node) {
+    promises = nodes.map(function(node) {
         var target = node.endpoint.target;
 
-        return repository.versions(node.endpoint.source)
-        .then(function (versions) {
-            node.versions = versions;
+        return repository
+            .versions(node.endpoint.source)
+            .then(function(versions) {
+                node.versions = versions;
 
-            // Do not check if node's target is not a valid semver one
-            if (versions.length && semver.validRange(target)) {
-                node.update = {
-                    target: semver.maxSatisfying(versions, target),
-                    latest: semver.maxSatisfying(versions, '*')
-                };
-            }
-        });
+                // Do not check if node's target is not a valid semver one
+                if (versions.length && semver.validRange(target)) {
+                    node.update = {
+                        target: semver.maxSatisfying(versions, target),
+                        latest: semver.maxSatisfying(versions, '*')
+                    };
+                }
+            });
     });
 
     // Set the versions also for the root node
@@ -125,7 +127,7 @@ function checkVersions(project, tree, logger) {
 function paths(flattened) {
     var ret = {};
 
-    mout.object.forOwn(flattened, function (pkg, name) {
+    mout.object.forOwn(flattened, function(pkg, name) {
         var main;
 
         if (pkg.missing) {
@@ -146,7 +148,7 @@ function paths(flattened) {
         }
 
         // Concatenate each main entry with the canonical dir
-        main = main.map(function (part) {
+        main = main.map(function(part) {
             return normalize(path.join(pkg.canonicalDir, part).trim());
         });
 
@@ -164,20 +166,20 @@ function normalize(src) {
 
 // -------------------
 
-list.line = function (argv) {
-    var options = list.options(argv);
-    return list(options);
-};
+list.readOptions = function(argv) {
+    var cli = require('../util/cli');
 
-list.options = function (argv) {
-    return cli.readOptions({
-        'paths': { type: Boolean, shorthand: 'p' },
-        'relative': { type: Boolean, shorthand: 'r' }
-    }, argv);
-};
+    var options = cli.readOptions(
+        {
+            paths: { type: Boolean, shorthand: 'p' },
+            relative: { type: Boolean, shorthand: 'r' }
+        },
+        argv
+    );
 
-list.completion = function () {
-    // TODO:
+    delete options.argv;
+
+    return [options];
 };
 
 module.exports = list;

lib/commands/login.js

@@ -0,0 +1,155 @@
+var Configstore = require('configstore');
+var GitHub = require('github');
+var Q = require('q');
+
+var createError = require('../util/createError');
+var defaultConfig = require('../config');
+
+function login(logger, options, config) {
+    var configstore = new Configstore('bower-github');
+
+    config = defaultConfig(config);
+
+    var promise;
+
+    options = options || {};
+
+    if (options.token) {
+        promise = Q.resolve({ token: options.token });
+    } else {
+        // This command requires interactive to be enabled
+        if (!config.interactive) {
+            logger.emit(
+                'error',
+                createError('Login requires an interactive shell', 'ENOINT', {
+                    details:
+                        'Note that you can manually force an interactive shell with --config.interactive'
+                })
+            );
+
+            return;
+        }
+
+        var questions = [
+            {
+                name: 'username',
+                message: 'Username',
+                type: 'input',
+                default: configstore.get('username')
+            },
+            {
+                name: 'password',
+                message: 'Password',
+                type: 'password'
+            }
+        ];
+
+        var github = new GitHub({
+            version: '3.0.0'
+        });
+
+        promise = Q.nfcall(logger.prompt.bind(logger), questions).then(function(
+            answers
+        ) {
+            configstore.set('username', answers.username);
+
+            github.authenticate({
+                type: 'basic',
+                username: answers.username,
+                password: answers.password
+            });
+
+            return Q.ninvoke(github.authorization, 'create', {
+                scopes: ['user', 'repo'],
+                note:
+                    'Bower command line client (' +
+                    new Date().toISOString() +
+                    ')'
+            });
+        });
+    }
+
+    return promise.then(
+        function(result) {
+            configstore.set('accessToken', result.token);
+            logger.info(
+                'EAUTH',
+                'Logged in as ' + configstore.get('username'),
+                {}
+            );
+
+            return result;
+        },
+        function(error) {
+            var message;
+
+            try {
+                message = JSON.parse(error.message).message;
+            } catch (e) {
+                message = 'Authorization failed';
+            }
+
+            var questions = [
+                {
+                    name: 'otpcode',
+                    message: 'Two-Factor Auth Code',
+                    type: 'input'
+                }
+            ];
+
+            if (
+                message === 'Must specify two-factor authentication OTP code.'
+            ) {
+                return Q.nfcall(logger.prompt.bind(logger), questions)
+                    .then(function(answers) {
+                        return Q.ninvoke(github.authorization, 'create', {
+                            scopes: ['user', 'repo'],
+                            note:
+                                'Bower command line client (' +
+                                new Date().toISOString() +
+                                ')',
+                            headers: {
+                                'X-GitHub-OTP': answers.otpcode
+                            }
+                        });
+                    })
+                    .then(
+                        function(result) {
+                            configstore.set('accessToken', result.token);
+                            logger.info(
+                                'EAUTH',
+                                'Logged in as ' + configstore.get('username'),
+                                {}
+                            );
+
+                            return result;
+                        },
+                        function() {
+                            logger.emit('error', createError(message, 'EAUTH'));
+                        }
+                    );
+            } else {
+                logger.emit('error', createError(message, 'EAUTH'));
+            }
+        }
+    );
+}
+
+// -------------------
+
+login.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(
+        {
+            token: { type: String, shorthand: 't' }
+        },
+        argv
+    );
+
+    delete options.argv;
+
+    return [options];
+};
+
+module.exports = login;

lib/commands/lookup.js

@@ -1,56 +1,37 @@
-var mout = require('mout');
 var Q = require('q');
-var Logger = require('bower-logger');
-var RegistryClient = require('bower-registry-client');
-var cli = require('../util/cli');
+var PackageRepository = require('../core/PackageRepository');
 var defaultConfig = require('../config');
 
-function lookup(name, config) {
-    var registryClient;
-    var logger = new Logger();
+function lookup(logger, name, config) {
+    if (!name) {
+        return new Q(null);
+    }
 
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
-    config.cache = config.storage.registry;
+    config = defaultConfig(config);
 
-    registryClient = new RegistryClient(config, logger);
+    var repository = new PackageRepository(config, logger);
+    var registryClient = repository.getRegistryClient();
 
-    Q.nfcall(registryClient.lookup.bind(registryClient), name)
-    .then(function (entry) {
-        // TODO: Handle entry.type.. for now it's only 'alias'
-        //       When we got published packages, this needs to be adjusted
-        return !entry ? null : {
-            name: name,
-            url: entry && entry.url
-        };
-    })
-    .done(function (result) {
-        logger.emit('end', result);
-    }, function (error) {
-        logger.emit('error', error);
-    });
-
-    return logger;
+    return Q.nfcall(registryClient.lookup.bind(registryClient), name).then(
+        function(entry) {
+            return !entry
+                ? null
+                : {
+                      name: name,
+                      url: entry.url
+                  };
+        }
+    );
 }
 
 // -------------------
 
-lookup.line = function (argv) {
-    var options = lookup.options(argv);
+lookup.readOptions = function(argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
     var name = options.argv.remain[1];
 
-    if (!name) {
-        return null;
-    }
-
-    return lookup(name);
-};
-
-lookup.options = function (argv) {
-    return cli.readOptions(argv);
-};
-
-lookup.completion = function () {
-    // TODO:
+    return [name];
 };
 
 module.exports = lookup;

lib/commands/prune.js

@@ -1,25 +1,15 @@
 var mout = require('mout');
-var Logger = require('bower-logger');
 var Project = require('../core/Project');
-var cli = require('../util/cli');
 var defaultConfig = require('../config');
 
-function prune(options, config) {
+function prune(logger, options, config) {
     var project;
-    var logger = new Logger();
 
     options = options || {};
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
     project = new Project(config, logger);
 
-    clean(project, options)
-    .done(function (removed) {
-        logger.emit('end', removed);
-    }, function (error) {
-        logger.emit('error', error);
-    });
-
-    return logger;
+    return clean(project, options);
 }
 
 function clean(project, options, removed) {
@@ -27,42 +17,44 @@ function clean(project, options, removed) {
 
     // Continually call clean until there is no more extraneous
     // dependencies to remove
-    return project.getTree(options)
-    .spread(function (tree, flattened, extraneous) {
-        var names = extraneous.map(function (extra) {
-            return extra.endpoint.name;
-        });
+    return project
+        .getTree(options)
+        .spread(function(tree, flattened, extraneous) {
+            var names = extraneous.map(function(extra) {
+                return extra.endpoint.name;
+            });
 
-        // Uninstall extraneous
-        return project.uninstall(names, options)
-        .then(function (uninstalled) {
-            // Are we done?
-            if (!mout.object.size(uninstalled)) {
-                return removed;
-            }
+            // Uninstall extraneous
+            return project
+                .uninstall(names, options)
+                .then(function(uninstalled) {
+                    // Are we done?
+                    if (!mout.object.size(uninstalled)) {
+                        return removed;
+                    }
 
-            // Not yet, recurse!
-            mout.object.mixIn(removed, uninstalled);
-            return clean(project, options, removed);
+                    // Not yet, recurse!
+                    mout.object.mixIn(removed, uninstalled);
+                    return clean(project, options, removed);
+                });
         });
-    });
 }
 
 // -------------------
 
-prune.line = function (argv) {
-    var options = prune.options(argv);
-    return prune(options);
-};
+prune.readOptions = function(argv) {
+    var cli = require('../util/cli');
 
-prune.options = function (argv) {
-    return cli.readOptions({
-        'production': { type: Boolean, shorthand: 'p' },
-    }, argv);
-};
+    var options = cli.readOptions(
+        {
+            production: { type: Boolean, shorthand: 'p' }
+        },
+        argv
+    );
 
-prune.completion = function () {
-    // TODO:
+    delete options.argv;
+
+    return [options];
 };
 
 module.exports = prune;

lib/commands/register.js

@@ -1,59 +1,51 @@
-var mout = require('mout');
 var Q = require('q');
 var chalk = require('chalk');
 var PackageRepository = require('../core/PackageRepository');
-var Logger = require('bower-logger');
-var Config = require('bower-config');
-var Tracker = require('../util/analytics').Tracker;
-var cli = require('../util/cli');
 var createError = require('../util/createError');
 var defaultConfig = require('../config');
-var GitHubResolver = require('../core/resolvers/GitHubResolver');
 
-function register(name, url, config) {
+function register(logger, name, source, config) {
     var repository;
     var registryClient;
-    var tracker;
-    var logger = new Logger();
     var force;
+    var url;
+    var githubSourceRegex = /^\w[\w-]*\/\w[\w-]*$/;
+    var getGithubUrl = function(source) {
+        return 'git@github.com:' + source + '.git';
+    };
 
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
     force = config.force;
-    tracker = new Tracker(config);
+
+    name = (name || '').trim();
+    source = (source || '').trim();
+
+    url = source.match(githubSourceRegex) ? getGithubUrl(source) : source;
 
     // Bypass any cache
     config.offline = false;
     config.force = true;
 
-    // Trim name
-    name = name.trim();
-
-    process.nextTick(function () {
-        // Verify name
-        // TODO: Verify with the new spec regexp?
-        if (!name) {
-            return logger.emit('error', createError('Please type a name', 'EINVNAME'));
+    return Q.try(function() {
+        // Verify name and url
+        if (!name || !url) {
+            throw createError(
+                'Usage: bower register <name> <url>',
+                'EINVFORMAT'
+            );
         }
 
-        // The public registry only allows git:// endpoints
-        // As such, we attempt to convert URLs as necessary
-        if (config.registry.register === Config.DEFAULT_REGISTRY) {
-            url = convertUrl(url, logger);
-
-            if (!mout.string.startsWith(url, 'git://')) {
-                return logger.emit('error', createError('The registry only accepts URLs starting with git://', 'EINVFORMAT'));
-            }
-        }
-
-        tracker.track('register');
-
         // Attempt to resolve the package referenced by the URL to ensure
         // everything is ok before registering
         repository = new PackageRepository(config, logger);
-        repository.fetch({ name: name, source: url, target: '*' })
-        .spread(function (canonicalDir, pkgMeta) {
+        return repository.fetch({ name: name, source: url, target: '*' });
+    })
+        .spread(function(canonicalDir, pkgMeta) {
             if (pkgMeta.private) {
-                throw createError('The package you are trying to register is marked as private', 'EPRIV');
+                throw createError(
+                    'The package you are trying to register is marked as private',
+                    'EPRIV'
+                );
             }
 
             // If non interactive or user forced, bypass confirmation
@@ -64,12 +56,14 @@ function register(name, url, config) {
             // Confirm if the user really wants to register
             return Q.nfcall(logger.prompt.bind(logger), {
                 type: 'confirm',
-                message: 'Registering a package will make it installable via the registry (' +
-                    chalk.cyan.underline(config.registry.register) + '), continue?',
+                message:
+                    'Registering a package will make it installable via the registry (' +
+                    chalk.cyan.underline(config.registry.register) +
+                    '), continue?',
                 default: true
             });
         })
-        .then(function (result) {
+        .then(function(result) {
             // If user response was negative, abort
             if (!result) {
                 return;
@@ -83,55 +77,24 @@ function register(name, url, config) {
                 url: url
             });
 
-            return Q.nfcall(registryClient.register.bind(registryClient), name, url);
-        })
-        .done(function (result) {
-            tracker.track('registered');
-            logger.emit('end', result);
-        }, function (error) {
-            logger.emit('error', error);
+            return Q.nfcall(
+                registryClient.register.bind(registryClient),
+                name,
+                url
+            );
         });
-    });
-
-    return logger;
-}
-
-function convertUrl(url, logger) {
-    var pair;
-    var newUrl;
-
-    if (!mout.string.startsWith(url, 'git://')) {
-        // Convert GitHub ssh & https to git://
-        pair = GitHubResolver.getOrgRepoPair(url);
-        if (pair) {
-            newUrl = 'git://github.com/' + pair.org + '/' + pair.repo + '.git';
-            logger.warn('convert', 'Converted ' + url + ' to ' + newUrl);
-        }
-    }
-
-    return newUrl || url;
 }
 
 // -------------------
 
-register.line = function (argv) {
-    var options = register.options(argv);
+register.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(argv);
     var name = options.argv.remain[1];
     var url = options.argv.remain[2];
 
-    if (!name || !url) {
-        return null;
-    }
-
-    return register(name, url);
-};
-
-register.options = function (argv) {
-    return cli.readOptions(argv);
-};
-
-register.completion = function () {
-    // TODO:
+    return [name, url];
 };
 
 module.exports = register;

lib/commands/search.js

@@ -1,55 +1,39 @@
-var mout = require('mout');
 var Q = require('q');
-var Logger = require('bower-logger');
-var RegistryClient = require('bower-registry-client');
-var cli = require('../util/cli');
-var Tracker = require('../util/analytics').Tracker;
+var PackageRepository = require('../core/PackageRepository');
 var defaultConfig = require('../config');
+var cli = require('../util/cli');
+var createError = require('../util/createError');
 
-function search(name, config) {
+function search(logger, name, config) {
     var registryClient;
-    var promise;
-    var tracker;
-    var logger = new Logger();
 
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
-    config.cache = config.storage.registry;
+    config = defaultConfig(config);
 
-    registryClient = new RegistryClient(config, logger);
-    tracker = new Tracker(config);
-    tracker.track('search', name);
+    var repository = new PackageRepository(config, logger);
+    var registryClient = repository.getRegistryClient();
 
-    // If no name was specified, list all packages
-    if (!name) {
-        promise = Q.nfcall(registryClient.list.bind(registryClient));
-    // Otherwise search it
+    if (name) {
+        return Q.nfcall(registryClient.search.bind(registryClient), name);
     } else {
-        promise = Q.nfcall(registryClient.search.bind(registryClient), name);
+        // List all packages when in interactive mode + json enabled, and
+        // always when in non-interactive mode
+        if (config.interactive && !config.json) {
+            throw createError('no parameter to bower search', 'EREADOPTIONS');
+        }
+
+        return Q.nfcall(registryClient.list.bind(registryClient));
     }
-
-    promise
-    .done(function (results) {
-        logger.emit('end', results);
-    }, function (error) {
-        logger.emit('error', error);
-    });
-
-    return logger;
 }
 
 // -------------------
 
-search.line = function (argv) {
-    var options = search.options(argv);
-    return search(options.argv.remain.slice(1).join(' '), options);
-};
+search.readOptions = function(argv) {
+    var options = cli.readOptions(argv);
+    var terms = options.argv.remain.slice(1);
 
-search.options = function (argv) {
-    return cli.readOptions(argv);
-};
+    var name = terms.join(' ');
 
-search.completion = function () {
-    // TODO:
+    return [name];
 };
 
 module.exports = search;

lib/commands/uninstall.js

@@ -1,79 +1,75 @@
 var mout = require('mout');
-var Logger = require('bower-logger');
 var Q = require('q');
 var Project = require('../core/Project');
-var cli = require('../util/cli');
-var Tracker = require('../util/analytics').Tracker;
 var defaultConfig = require('../config');
 
-function uninstall(names, options, config) {
+function uninstall(logger, names, options, config) {
+    if (!names.length) {
+        return new Q();
+    }
+
     var project;
-    var tracker;
-    var logger = new Logger();
 
     options = options || {};
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
     project = new Project(config, logger);
-    tracker = new Tracker(config);
 
-    tracker.trackNames('uninstall', names);
-
-    project.getTree(options)
-    .spread(function (tree, flattened) {
+    return project.getTree(options).spread(function(tree, flattened) {
         // Uninstall nodes
-        return project.uninstall(names, options)
-        // Clean out non-shared uninstalled dependencies
-        .then(function (uninstalled) {
-            var names = Object.keys(uninstalled);
-            var children = [];
+        return (
+            project
+                .uninstall(names, options)
+                // Clean out non-shared uninstalled dependencies
+                .then(function(uninstalled) {
+                    var names = Object.keys(uninstalled);
+                    var children = [];
 
-            // Grab the dependencies of packages that were uninstalled
-            mout.object.forOwn(flattened, function (node) {
-                if (names.indexOf(node.endpoint.name) !== -1) {
-                    children.push.apply(children, mout.object.keys(node.dependencies));
-                }
-            });
+                    // Grab the dependencies of packages that were uninstalled
+                    mout.object.forOwn(flattened, function(node) {
+                        if (names.indexOf(node.endpoint.name) !== -1) {
+                            children.push.apply(
+                                children,
+                                mout.object.keys(node.dependencies)
+                            );
+                        }
+                    });
 
-            // Clean them!
-            return clean(project, children, uninstalled);
-        });
-    })
-    .done(function (uninstalled) {
-        logger.emit('end', uninstalled);
-        tracker.trackNames('uninstalled', Object.keys(uninstalled));
-    }, function (error) {
-        logger.emit('error', error);
+                    // Clean them!
+                    return clean(project, children, uninstalled);
+                })
+        );
     });
-
-    return logger;
 }
 
 function clean(project, names, removed) {
     removed = removed || {};
 
-    return project.getTree()
-    .spread(function (tree, flattened) {
+    return project.getTree().spread(function(tree, flattened) {
         var nodes = [];
         var dependantsCounter = {};
 
         // Grab the nodes of each specified name
-        mout.object.forOwn(flattened, function (node) {
+        mout.object.forOwn(flattened, function(node) {
             if (names.indexOf(node.endpoint.name) !== -1) {
                 nodes.push(node);
             }
         });
 
         // Walk the down the tree, gathering dependants of the packages
-        project.walkTree(tree, function (node, nodeName) {
-            if (names.indexOf(nodeName) !== -1) {
-                dependantsCounter[nodeName] = dependantsCounter[nodeName] || 0;
-                dependantsCounter[nodeName] += node.nrDependants;
-            }
-        }, true);
-
+        project.walkTree(
+            tree,
+            function(node, nodeName) {
+                if (names.indexOf(nodeName) !== -1) {
+                    dependantsCounter[nodeName] =
+                        dependantsCounter[nodeName] || 0;
+                    dependantsCounter[nodeName] += node.nrDependants;
+                }
+            },
+            true
+        );
 
         // Filter out those that have no dependants
-        nodes = nodes.filter(function (node) {
+        nodes = nodes.filter(function(node) {
             return !dependantsCounter[node.endpoint.name];
         });
 
@@ -83,52 +79,54 @@ function clean(project, names, removed) {
         }
 
         // Grab the nodes after filtering
-        names = nodes.map(function (node) {
+        names = nodes.map(function(node) {
             return node.endpoint.name;
         });
 
         // Uninstall them
-        return project.uninstall(names)
-        // Clean out non-shared uninstalled dependencies
-        .then(function (uninstalled) {
-            var children;
+        return (
+            project
+                .uninstall(names)
+                // Clean out non-shared uninstalled dependencies
+                .then(function(uninstalled) {
+                    var children;
 
-            mout.object.mixIn(removed, uninstalled);
+                    mout.object.mixIn(removed, uninstalled);
 
-            // Grab the dependencies of packages that were uninstalled
-            children = [];
-            nodes.forEach(function (node) {
-                children.push.apply(children, mout.object.keys(node.dependencies));
-            });
+                    // Grab the dependencies of packages that were uninstalled
+                    children = [];
+                    nodes.forEach(function(node) {
+                        children.push.apply(
+                            children,
+                            mout.object.keys(node.dependencies)
+                        );
+                    });
 
-            // Recurse!
-            return clean(project, children, removed);
-        });
+                    // Recurse!
+                    return clean(project, children, removed);
+                })
+        );
     });
 }
 
 // -------------------
 
-uninstall.line = function (argv) {
-    var options = uninstall.options(argv);
+uninstall.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(
+        {
+            save: { type: Boolean, shorthand: 'S' },
+            'save-dev': { type: Boolean, shorthand: 'D' }
+        },
+        argv
+    );
+
     var names = options.argv.remain.slice(1);
 
-    if (!names.length) {
-        return null;
-    }
+    delete options.argv;
 
-    return uninstall(names, options);
-};
-
-uninstall.options = function (argv) {
-    return cli.readOptions({
-        'save': { type: Boolean, shorthand: 'S' },
-        'save-dev': { type: Boolean, shorthand: 'D' }
-    }, argv);
-};
-
-uninstall.completion = function () {
-    // TODO:
+    return [names, options];
 };
 
 module.exports = uninstall;

lib/commands/unregister.js

@@ -0,0 +1,90 @@
+var chalk = require('chalk');
+var Q = require('q');
+
+var defaultConfig = require('../config');
+var PackageRepository = require('../core/PackageRepository');
+var createError = require('../util/createError');
+
+function unregister(logger, name, config) {
+    if (!name) {
+        return;
+    }
+
+    var repository;
+    var registryClient;
+    var force;
+
+    config = defaultConfig(config);
+    force = config.force;
+
+    // Bypass any cache
+    config.offline = false;
+    config.force = true;
+
+    // Trim name
+    name = name.trim();
+
+    repository = new PackageRepository(config, logger);
+
+    if (!config.accessToken) {
+        return logger.emit(
+            'error',
+            createError(
+                'Use "bower login" with collaborator credentials',
+                'EFORBIDDEN'
+            )
+        );
+    }
+
+    return Q.resolve()
+        .then(function() {
+            // If non interactive or user forced, bypass confirmation
+            if (!config.interactive || force) {
+                return true;
+            }
+
+            return Q.nfcall(logger.prompt.bind(logger), {
+                type: 'confirm',
+                message:
+                    'You are about to remove component "' +
+                    chalk.cyan.underline(name) +
+                    '" from the bower registry (' +
+                    chalk.cyan.underline(config.registry.register) +
+                    '). It is generally considered bad behavior to remove versions of a library that others are depending on. Are you really sure?',
+                default: false
+            });
+        })
+        .then(function(result) {
+            // If user response was negative, abort
+            if (!result) {
+                return;
+            }
+
+            registryClient = repository.getRegistryClient();
+
+            logger.action('unregister', name, { name: name });
+
+            return Q.nfcall(
+                registryClient.unregister.bind(registryClient),
+                name
+            );
+        })
+        .then(function(result) {
+            logger.info('Package unregistered', name);
+
+            return result;
+        });
+}
+
+// -------------------
+
+unregister.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(argv);
+    var name = options.argv.remain[1];
+
+    return [name];
+};
+
+module.exports = unregister;

lib/commands/update.js

@@ -1,15 +1,11 @@
-var mout = require('mout');
-var Logger = require('bower-logger');
 var Project = require('../core/Project');
-var cli = require('../util/cli');
 var defaultConfig = require('../config');
 
-function update(names, options, config) {
+function update(logger, names, options, config) {
     var project;
-    var logger = new Logger();
 
     options = options || {};
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
+    config = defaultConfig(config);
     project = new Project(config, logger);
 
     // If names is an empty array, null them
@@ -17,32 +13,27 @@ function update(names, options, config) {
         names = null;
     }
 
-    project.update(names, options)
-    .done(function (installed) {
-        logger.emit('end', installed);
-    }, function (error) {
-        logger.emit('error', error);
-    });
-
-    return logger;
+    return project.update(names, options);
 }
 
 // -------------------
 
-update.line = function (argv) {
-    var options = update.options(argv);
-    return update(options.argv.remain.slice(1), options);
-};
+update.readOptions = function(argv) {
+    var cli = require('../util/cli');
 
-update.options = function (argv) {
-    return cli.readOptions({
-        'force-latest': { type: Boolean, shorthand: 'F' },
-        'production': { type: Boolean, shorthand: 'p' }
-    }, argv);
-};
+    var options = cli.readOptions(
+        {
+            'force-latest': { type: Boolean, shorthand: 'F' },
+            production: { type: Boolean, shorthand: 'p' }
+        },
+        argv
+    );
 
-update.completion = function () {
-    // TODO:
+    var names = options.argv.remain.slice(1);
+
+    delete options.argv;
+
+    return [names, options];
 };
 
 module.exports = update;

lib/commands/version.js

@@ -1,140 +1,210 @@
-var mout = require('mout');
 var semver = require('semver');
-var Logger = require('bower-logger');
 var which = require('which');
-var fs = require('fs');
+var fs = require('../util/fs');
 var path = require('path');
 var Q = require('q');
 var execFile = require('child_process').execFile;
-var Project = require('../core/Project');
-var cli = require('../util/cli');
 var defaultConfig = require('../config');
 var createError = require('../util/createError');
 
-function version(versionArg, options, config) {
-    var project;
-    var logger = new Logger();
+function version(logger, versionArg, options, config) {
+    options = options || {};
 
-    config = mout.object.deepFillIn(config || {}, defaultConfig);
-    project = new Project(config, logger);
+    config = defaultConfig(config);
 
-    bump(project, versionArg, options.message)
-    .done(function () {
-        logger.emit('end');
-    }, function (error) {
-        logger.emit('error', error);
-    });
-
-    return logger;
+    return bump(logger, config, versionArg, options.message);
 }
 
-function bump(project, versionArg, message) {
+function bump(logger, config, versionArg, message) {
+    var cwd = config.cwd || process.cwd();
     var newVersion;
-    var doGitCommit = false;
 
-    return checkGit()
-    .then(function (hasGit) {
-        doGitCommit = hasGit;
-    })
-    .then(project.getJson.bind(project))
-    .then(function (json) {
-        newVersion = getNewVersion(json.version, versionArg);
-        json.version = newVersion;
-    })
-    .then(project.saveJson.bind(project))
-    .then(function () {
-        if (doGitCommit) {
-            return gitCommitAndTag(newVersion, message);
-        }
-    })
-    .then(function () {
-        console.log('v' + newVersion);
-    });
-}
-
-function getNewVersion(currentVersion, versionArg) {
-    var newVersion = semver.valid(versionArg);
-    if (!newVersion) {
-        newVersion = semver.inc(currentVersion, versionArg);
+    if (!versionArg) {
+        throw createError('No <version> agrument provided', 'EREADOPTIONS');
     }
-    if (!newVersion) {
-        throw createError('Invalid version argument: `' + versionArg + '`. Usage: `bower version [<newversion> | major | minor | patch]`', 'EINVALIDVERSION');
-    }
-    if (currentVersion === newVersion) {
-        throw createError('Version not changed', 'EVERSIONNOTCHANGED');
-    }
-    return newVersion;
+
+    return driver
+        .check(cwd)
+        .then(function() {
+            return Q.all([driver.versions(cwd), driver.currentVersion(cwd)]);
+        })
+        .spread(function(versions, currentVersion) {
+            currentVersion = currentVersion || '0.0.0';
+
+            if (semver.valid(versionArg)) {
+                newVersion = semver.valid(versionArg);
+            } else {
+                newVersion = semver.inc(currentVersion, versionArg);
+
+                if (!newVersion) {
+                    throw createError(
+                        'Invalid <version> argument: ' + versionArg,
+                        'EINVALIDVERSION',
+                        { version: versionArg }
+                    );
+                }
+            }
+
+            newVersion =
+                currentVersion[0] === 'v' ? 'v' + newVersion : newVersion;
+
+            if (versions) {
+                versions.forEach(function(version) {
+                    if (semver.eq(version, newVersion)) {
+                        throw createError(
+                            'Version exists: ' + newVersion,
+                            'EVERSIONEXISTS',
+                            { versions: versions, newVersion: newVersion }
+                        );
+                    }
+                });
+            }
+
+            return driver.bump(cwd, newVersion, message).then(function() {
+                return {
+                    oldVersion: currentVersion,
+                    newVersion: newVersion
+                };
+            });
+        })
+        .then(function(result) {
+            logger.info(
+                'version',
+                'Bumped package version from ' +
+                    result.oldVersion +
+                    ' to ' +
+                    result.newVersion,
+                result
+            );
+
+            return result.newVersion;
+        });
 }
 
-function checkGit() {
-    var gitDir = path.join(process.cwd(), '.git');
-    return Q.nfcall(fs.stat, gitDir)
-    .then(function (stat) {
-        if (stat.isDirectory()) {
-            return checkGitStatus();
+var driver = {
+    check: function(cwd) {
+        function checkGit(cwd) {
+            var gitDir = path.join(cwd, '.git');
+            return Q.nfcall(fs.stat, gitDir).then(
+                function(stat) {
+                    if (stat.isDirectory()) {
+                        return checkGitStatus(cwd);
+                    }
+                    return false;
+                },
+                function() {
+                    //Ignore not found .git directory
+                    return false;
+                }
+            );
         }
-        return false;
-    }, function () {
-        //Ignore not found .git directory
-        return false;
-    });
-}
 
-function checkGitStatus() {
-    return Q.nfcall(which, 'git')
-    .fail(function (err) {
-        err.code = 'ENOGIT';
-        throw err;
-    })
-    .then(function () {
-        return Q.nfcall(execFile, 'git', ['status', '--porcelain'], {env: process.env});
-    })
-    .then(function (value) {
-        var stdout = value[0];
-        var lines = filterModifiedStatusLines(stdout);
-        if (lines.length) {
-            throw createError('Git working directory not clean.\n' + lines.join('\n'), 'EWORKINGDIRECTORYDIRTY');
+        function checkGitStatus(cwd) {
+            return Q.nfcall(which, 'git')
+                .fail(function(err) {
+                    err.code = 'ENOGIT';
+                    throw err;
+                })
+                .then(function() {
+                    return Q.nfcall(
+                        execFile,
+                        'git',
+                        ['status', '--porcelain'],
+                        { env: process.env, cwd: cwd }
+                    );
+                })
+                .then(function(value) {
+                    var stdout = value[0];
+                    var lines = filterModifiedStatusLines(stdout);
+                    if (lines.length) {
+                        throw createError(
+                            'Version bump requires clean working directory',
+                            'EWORKINGDIRECTORYDIRTY'
+                        );
+                    }
+                    return true;
+                });
         }
-        return true;
-    });
-}
 
-function filterModifiedStatusLines(stdout) {
-    return stdout.trim().split('\n')
-    .filter(function (line) {
-        return line.trim() && !line.match(/^\?\? /);
-    }).map(function (line) {
-        return line.trim();
-    });
-}
+        function filterModifiedStatusLines(stdout) {
+            return stdout
+                .trim()
+                .split('\n')
+                .filter(function(line) {
+                    return line.trim() && !line.match(/^\?\? /);
+                })
+                .map(function(line) {
+                    return line.trim();
+                });
+        }
 
-function gitCommitAndTag(newVersion, message) {
-    message = message || 'v' + newVersion;
-    message = message.replace(/%s/g, newVersion);
-    return Q.nfcall(execFile, 'git', ['add', 'bower.json'], {env: process.env})
-    .then(function () {
-        return Q.nfcall(execFile, 'git', ['commit', '-m', message], {env: process.env});
-    })
-    .then(function () {
-        return Q.nfcall(execFile, 'git', ['tag', newVersion, '-am', message], {env: process.env});
-    });
-}
+        return checkGit(cwd).then(function(hasGit) {
+            if (!hasGit) {
+                throw createError(
+                    'Version bump currently supports only git repositories',
+                    'ENOTGITREPOSITORY'
+                );
+            }
+        });
+    },
+    versions: function(cwd) {
+        return Q.nfcall(execFile, 'git', ['tag'], {
+            env: process.env,
+            cwd: cwd
+        }).then(
+            function(res) {
+                var versions = res[0].split(/\r?\n/).filter(semver.valid);
 
-// -------------------
+                return versions;
+            },
+            function() {
+                return [];
+            }
+        );
+    },
+    currentVersion: function(cwd) {
+        return Q.nfcall(execFile, 'git', ['describe', '--abbrev=0', '--tags'], {
+            env: process.env,
+            cwd: cwd
+        }).then(
+            function(res) {
+                var version = res[0].split(/\r?\n/).filter(semver.valid)[0];
 
-version.line = function (argv) {
-    var options = version.options(argv);
-    return version(options.argv.remain[1], options);
+                return version;
+            },
+            function() {
+                return undefined;
+            }
+        );
+    },
+    bump: function(cwd, tag, message) {
+        message = message || tag;
+        message = message.replace(/%s/g, tag);
+        return Q.nfcall(
+            execFile,
+            'git',
+            ['commit', '-m', message, '--allow-empty'],
+            { env: process.env, cwd: cwd }
+        ).then(function() {
+            return Q.nfcall(execFile, 'git', ['tag', tag, '-am', message], {
+                env: process.env,
+                cwd: cwd
+            });
+        });
+    }
 };
 
-version.options = function (argv) {
-    return cli.readOptions({
-        'message': { type: String, shorthand: 'm'}
-    }, argv);
+version.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(
+        {
+            message: { type: String, shorthand: 'm' }
+        },
+        argv
+    );
+
+    return [options.argv.remain[1], options];
 };
 
-version.completion = function () {
-    // TODO:
-};
-
-module.exports = version;
+module.exports = version;

lib/config.js

@@ -1,33 +1,63 @@
 var tty = require('tty');
-var mout = require('mout');
-var config = require('bower-config').read();
-var cli = require('./util/cli');
+var object = require('mout').object;
+var bowerConfig = require('bower-config');
+var Configstore = require('configstore');
 
-// Delete the json attribute because it is no longer supported
-// and conflicts with --json
-delete config.json;
+var current;
 
-// If interactive is auto (null), guess its value
-if (config.interactive == null) {
-    config.interactive = process.bin === 'bower' && tty.isatty(1);
+function defaultConfig(config) {
+    config = config || {};
+
+    return readCachedConfig(config.cwd || process.cwd(), config);
 }
 
-// If `analytics` hasn't been explicitly set, we disable
-// it when ran programatically.
-if (config.analytics == null) {
-    // Don't enable analytics on CI server unless explicitly configured.
-    config.analytics = config.interactive && !process.env.CI;
+function readCachedConfig(cwd, overwrites) {
+    current = bowerConfig.create(cwd).load(overwrites);
+
+    var config = current.toObject();
+
+    var configstore = new Configstore('bower-github').all;
+
+    object.mixIn(config, configstore);
+
+    // If interactive is auto (null), guess its value
+    if (config.interactive == null) {
+        config.interactive =
+            process.bin === 'bower' && tty.isatty(1) && !process.env.CI;
+    }
+
+    // Merge common CLI options into the config
+    if (process.bin === 'bower') {
+        var cli = require('./util/cli');
+
+        object.mixIn(
+            config,
+            cli.readOptions({
+                force: { type: Boolean, shorthand: 'f' },
+                offline: { type: Boolean, shorthand: 'o' },
+                verbose: { type: Boolean, shorthand: 'V' },
+                quiet: { type: Boolean, shorthand: 'q' },
+                loglevel: { type: String, shorthand: 'l' },
+                json: { type: Boolean, shorthand: 'j' },
+                silent: { type: Boolean, shorthand: 's' }
+            })
+        );
+    }
+
+    return config;
 }
 
-// Merge common CLI options into the config
-mout.object.mixIn(config, cli.readOptions({
-    force: { type: Boolean, shorthand: 'f' },
-    offline: { type: Boolean, shorthand: 'o' },
-    verbose: { type: Boolean, shorthand: 'V' },
-    quiet: { type: Boolean, shorthand: 'q' },
-    loglevel: { type: String, shorthand: 'l' },
-    json: { type: Boolean, shorthand: 'j' },
-    silent: { type: Boolean, shorthand: 's' }
-}));
+function restoreConfig() {
+    if (current) {
+        current.restore();
+    }
+}
 
-module.exports = config;
+function resetCache() {
+    restoreConfig();
+    current = undefined;
+}
+
+module.exports = defaultConfig;
+module.exports.restore = restoreConfig;
+module.exports.reset = resetCache;

lib/core/PackageRepository.js

@@ -1,9 +1,9 @@
 var mout = require('mout');
 var Q = require('q');
-var RegistryClient = require('bower-registry-client');
 var ResolveCache = require('./ResolveCache');
 var resolverFactory = require('./resolverFactory');
 var createError = require('../util/createError');
+var RegistryClient = require('bower-registry-client');
 
 function PackageRepository(config, logger) {
     var registryOptions;
@@ -14,6 +14,7 @@ function PackageRepository(config, logger) {
     // Instantiate the registry
     registryOptions = mout.object.deepMixIn({}, this._config);
     registryOptions.cache = this._config.storage.registry;
+
     this._registryClient = new RegistryClient(registryOptions, logger);
 
     // Instantiate the resolve cache
@@ -22,7 +23,7 @@ function PackageRepository(config, logger) {
 
 // -----------------
 
-PackageRepository.prototype.fetch = function (decEndpoint) {
+PackageRepository.prototype.fetch = function(decEndpoint) {
     var logger;
     var that = this;
     var isTargetable;
@@ -34,129 +35,192 @@ PackageRepository.prototype.fetch = function (decEndpoint) {
     // used to fetch
     logger = this._logger.geminate();
     // Intercept all logs, adding additional information
-    logger.intercept(function (log) {
+    logger.intercept(function(log) {
         that._extendLog(log, info);
     });
 
-    // Get the appropriate resolver
-    return resolverFactory(decEndpoint, this._config, logger, this._registryClient)
-    // Decide if we retrieve from the cache or not
-    // Also decide if we validate the cached entry or not
-    .then(function (resolver) {
-        info.resolver = resolver;
-        isTargetable = resolver.constructor.isTargetable;
+    return (
+        this._getResolver(decEndpoint, logger)
+            // Decide if we retrieve from the cache or not
+            // Also decide if we validate the cached entry or not
+            .then(function(resolver) {
+                info.resolver = resolver;
+                isTargetable = resolver.constructor.isTargetable;
 
-        // If force flag is used, bypass cache
-        if (that._config.force) {
-            logger.action('resolve', resolver.getSource() + '#' + resolver.getTarget());
-            return that._resolve(resolver, logger);
-        }
-
-        // Note that we use the resolver methods to query the
-        // cache because transformations/normalisations can occur
-        return that._resolveCache.retrieve(resolver.getSource(), resolver.getTarget())
-        // Decide if we can use the one from the resolve cache
-        .spread(function (canonicalDir, pkgMeta) {
-            // If there's no package in the cache
-            if (!canonicalDir) {
-                // And the offline flag is passed, error out
-                if (that._config.offline) {
-                    throw createError('No cached version for ' + resolver.getSource() + '#' + resolver.getTarget(), 'ENOCACHE', {
-                        resolver: resolver
-                    });
+                if (!resolver.isCacheable()) {
+                    return that._resolve(resolver, logger);
                 }
 
-                // Otherwise, we have to resolve it
-                logger.info('not-cached', resolver.getSource() + (resolver.getTarget() ? '#' + resolver.getTarget() : ''));
-                logger.action('resolve', resolver.getSource() + '#' + resolver.getTarget());
-
-                return that._resolve(resolver, logger);
-            }
-
-            info.canonicalDir = canonicalDir;
-            info.pkgMeta = pkgMeta;
-
-            logger.info('cached', resolver.getSource() + (pkgMeta._release ? '#' + pkgMeta._release : ''));
-
-            // If offline flag is used, use directly the cached one
-            if (that._config.offline) {
-                return [canonicalDir, pkgMeta, isTargetable];
-            }
-
-            // Otherwise check for new contents
-            logger.action('validate', (pkgMeta._release ? pkgMeta._release + ' against ': '') +
-                                      resolver.getSource() + (resolver.getTarget() ? '#' + resolver.getTarget() : ''));
-
-            return resolver.hasNew(canonicalDir, pkgMeta)
-            .then(function (hasNew) {
-                // If there are no new contents, resolve to
-                // the cached one
-                if (!hasNew) {
-                    return [canonicalDir, pkgMeta, isTargetable];
+                // If force flag is used, bypass cache, but write to cache anyway
+                if (that._config.force) {
+                    logger.action(
+                        'resolve',
+                        resolver.getSource() + '#' + resolver.getTarget()
+                    );
+                    return that._resolve(resolver, logger);
                 }
 
-                // Otherwise resolve to the newest one
-                logger.info('new', 'version for ' + resolver.getSource() + '#' + resolver.getTarget());
-                logger.action('resolve', resolver.getSource() + '#' + resolver.getTarget());
+                // Note that we use the resolver methods to query the
+                // cache because transformations/normalisations can occur
+                return (
+                    that._resolveCache
+                        .retrieve(resolver.getSource(), resolver.getTarget())
+                        // Decide if we can use the one from the resolve cache
+                        .spread(function(canonicalDir, pkgMeta) {
+                            // If there's no package in the cache
+                            if (!canonicalDir) {
+                                // And the offline flag is passed, error out
+                                if (that._config.offline) {
+                                    throw createError(
+                                        'No cached version for ' +
+                                            resolver.getSource() +
+                                            '#' +
+                                            resolver.getTarget(),
+                                        'ENOCACHE',
+                                        {
+                                            resolver: resolver
+                                        }
+                                    );
+                                }
 
-                return that._resolve(resolver, logger);
-            });
-        });
-    })
-    // If something went wrong, also extend the error
-    .fail(function (err) {
-        that._extendLog(err, info);
-        throw err;
-    });
+                                // Otherwise, we have to resolve it
+                                logger.info(
+                                    'not-cached',
+                                    resolver.getSource() +
+                                        (resolver.getTarget()
+                                            ? '#' + resolver.getTarget()
+                                            : '')
+                                );
+                                logger.action(
+                                    'resolve',
+                                    resolver.getSource() +
+                                        '#' +
+                                        resolver.getTarget()
+                                );
+
+                                return that._resolve(resolver, logger);
+                            }
+
+                            info.canonicalDir = canonicalDir;
+                            info.pkgMeta = pkgMeta;
+
+                            logger.info(
+                                'cached',
+                                resolver.getSource() +
+                                    (pkgMeta._release
+                                        ? '#' + pkgMeta._release
+                                        : '')
+                            );
+
+                            // If offline flag is used, use directly the cached one
+                            if (that._config.offline) {
+                                return [canonicalDir, pkgMeta, isTargetable];
+                            }
+
+                            // Otherwise check for new contents
+                            logger.action(
+                                'validate',
+                                (pkgMeta._release
+                                    ? pkgMeta._release + ' against '
+                                    : '') +
+                                    resolver.getSource() +
+                                    (resolver.getTarget()
+                                        ? '#' + resolver.getTarget()
+                                        : '')
+                            );
+
+                            return resolver
+                                .hasNew(pkgMeta)
+                                .then(function(hasNew) {
+                                    // If there are no new contents, resolve to
+                                    // the cached one
+                                    if (!hasNew) {
+                                        return [
+                                            canonicalDir,
+                                            pkgMeta,
+                                            isTargetable
+                                        ];
+                                    }
+
+                                    // Otherwise resolve to the newest one
+                                    logger.info(
+                                        'new',
+                                        'version for ' +
+                                            resolver.getSource() +
+                                            '#' +
+                                            resolver.getTarget()
+                                    );
+                                    logger.action(
+                                        'resolve',
+                                        resolver.getSource() +
+                                            '#' +
+                                            resolver.getTarget()
+                                    );
+
+                                    return that._resolve(resolver, logger);
+                                });
+                        })
+                );
+            })
+            // If something went wrong, also extend the error
+            .fail(function(err) {
+                that._extendLog(err, info);
+                throw err;
+            })
+    );
 };
 
-PackageRepository.prototype.versions = function (source) {
+PackageRepository.prototype.versions = function(source) {
     // Resolve the source using the factory because the
     // source can actually be a registry name
-    return resolverFactory.getConstructor(source, this._config, this._registryClient)
-    .spread(function (ConcreteResolver, source) {
-        // If offline, resolve using the cached versions
-        if (this._config.offline) {
-            return this._resolveCache.versions(source);
-        }
+    return this._getResolver({ source: source }).then(
+        function(resolver) {
+            // If offline, resolve using the cached versions
+            if (this._config.offline) {
+                return this._resolveCache.versions(resolver.getSource());
+            }
 
-        // Otherwise, fetch remotely
-        return ConcreteResolver.versions(source);
-    }.bind(this));
+            // Otherwise, fetch remotely
+            return resolver.constructor.versions(resolver.getSource());
+        }.bind(this)
+    );
 };
 
-PackageRepository.prototype.eliminate = function (pkgMeta) {
+PackageRepository.prototype.eliminate = function(pkgMeta) {
     return Q.all([
         this._resolveCache.eliminate(pkgMeta),
-        Q.nfcall(this._registryClient.clearCache.bind(this._registryClient), pkgMeta.name)
+        Q.nfcall(
+            this._registryClient.clearCache.bind(this._registryClient),
+            pkgMeta.name
+        )
     ]);
 };
 
-PackageRepository.prototype.clear = function () {
+PackageRepository.prototype.clear = function() {
     return Q.all([
         this._resolveCache.clear(),
         Q.nfcall(this._registryClient.clearCache.bind(this._registryClient))
     ]);
 };
 
-PackageRepository.prototype.reset = function () {
+PackageRepository.prototype.reset = function() {
     this._resolveCache.reset();
     this._registryClient.resetCache();
 };
 
-PackageRepository.prototype.list = function () {
+PackageRepository.prototype.list = function() {
     return this._resolveCache.list();
 };
 
-PackageRepository.prototype.getRegistryClient = function () {
+PackageRepository.prototype.getRegistryClient = function() {
     return this._registryClient;
 };
 
-PackageRepository.prototype.getResolveCache = function () {
+PackageRepository.prototype.getResolveCache = function() {
     return this._resolveCache;
 };
 
-PackageRepository.clearRuntimeCache = function () {
+PackageRepository.clearRuntimeCache = function() {
     ResolveCache.clearRuntimeCache();
     RegistryClient.clearRuntimeCache();
     resolverFactory.clearRuntimeCache();
@@ -164,28 +228,59 @@ PackageRepository.clearRuntimeCache = function () {
 
 // ---------------------
 
-PackageRepository.prototype._resolve = function (resolver, logger) {
-    // Resolve the resolver
-    return resolver.resolve()
-    // Store in the cache
-    .then(function (canonicalDir) {
-        return this._resolveCache.store(canonicalDir, resolver.getPkgMeta());
-    }.bind(this))
-    // Resolve promise with canonical dir and package meta
-    .then(function (dir) {
-        var pkgMeta = resolver.getPkgMeta();
+PackageRepository.prototype._getResolver = function(decEndpoint, logger) {
+    logger = logger || this._logger;
 
-        logger.info('resolved', resolver.getSource() + (pkgMeta._release ? '#' + pkgMeta._release : ''));
-        return [dir, pkgMeta, resolver.constructor.isTargetable()];
-    }.bind(this));
+    // Get the appropriate resolver
+    return resolverFactory(
+        decEndpoint,
+        { config: this._config, logger: logger },
+        this._registryClient
+    );
 };
 
-PackageRepository.prototype._extendLog = function (log, info) {
+PackageRepository.prototype._resolve = function(resolver, logger) {
+    var that = this;
+
+    // Resolve the resolver
+    return (
+        resolver
+            .resolve()
+            // Store in the cache
+            .then(function(canonicalDir) {
+                if (!resolver.isCacheable()) {
+                    return canonicalDir;
+                }
+
+                return that._resolveCache.store(
+                    canonicalDir,
+                    resolver.getPkgMeta()
+                );
+            })
+            // Resolve promise with canonical dir and package meta
+            .then(function(dir) {
+                var pkgMeta = resolver.getPkgMeta();
+
+                logger.info(
+                    'resolved',
+                    resolver.getSource() +
+                        (pkgMeta._release ? '#' + pkgMeta._release : '')
+                );
+                return [dir, pkgMeta, resolver.constructor.isTargetable()];
+            })
+    );
+};
+
+PackageRepository.prototype._extendLog = function(log, info) {
     log.data = log.data || {};
 
     // Store endpoint info in each log
     if (info.decEndpoint) {
-        log.data.endpoint = mout.object.pick(info.decEndpoint, ['name', 'source', 'target']);
+        log.data.endpoint = mout.object.pick(info.decEndpoint, [
+            'name',
+            'source',
+            'target'
+        ]);
     }
 
     // Store the resolver info in each log

lib/core/ResolveCache.js

@@ -1,15 +1,15 @@
-var fs = require('graceful-fs');
+var fs = require('../util/fs');
 var path = require('path');
 var mout = require('mout');
 var Q = require('q');
 var mkdirp = require('mkdirp');
-var rimraf = require('rimraf');
+var rimraf = require('../util/rimraf');
 var LRU = require('lru-cache');
 var lockFile = require('lockfile');
+var md5 = require('md5-hex');
 var semver = require('../util/semver');
 var readJson = require('../util/readJson');
 var copy = require('../util/copy');
-var md5 = require('../util/md5');
 
 function ResolveCache(config) {
     // TODO: Make some config entries, such as:
@@ -29,7 +29,7 @@ function ResolveCache(config) {
     if (!this._cache) {
         this._cache = new LRU({
             max: 100,
-            maxAge: 60 * 5 * 1000  // 5 minutes
+            maxAge: 60 * 5 * 1000 // 5 minutes
         });
         this.constructor._cache.set(this._dir, this._cache);
     }
@@ -40,7 +40,7 @@ function ResolveCache(config) {
 
 // -----------------
 
-ResolveCache.prototype.retrieve = function (source, target) {
+ResolveCache.prototype.retrieve = function(source, target) {
     var sourceId = md5(source);
     var dir = path.join(this._dir, sourceId);
     var that = this;
@@ -48,56 +48,57 @@ ResolveCache.prototype.retrieve = function (source, target) {
     target = target || '*';
 
     return this._getVersions(sourceId)
-    .spread(function (versions) {
-        var suitable;
+        .spread(function(versions) {
+            var suitable;
 
-        // If target is a semver, find a suitable version
-        if (semver.validRange(target)) {
-            suitable = semver.maxSatisfying(versions, target, true);
+            // If target is a semver, find a suitable version
+            if (semver.validRange(target)) {
+                suitable = semver.maxSatisfying(versions, target, true);
 
-            if (suitable) {
-                return suitable;
+                if (suitable) {
+                    return suitable;
+                }
             }
-        }
 
-        // If target is '*' check if there's a cached '_wildcard'
-        if (target === '*') {
-            return mout.array.find(versions, function (version) {
-                return version === '_wildcard';
+            // If target is '*' check if there's a cached '_wildcard'
+            if (target === '*') {
+                return mout.array.find(versions, function(version) {
+                    return version === '_wildcard';
+                });
+            }
+
+            // Otherwise check if there's an exact match
+            return mout.array.find(versions, function(version) {
+                return version === target;
             });
-        }
+        })
+        .then(function(version) {
+            var canonicalDir;
 
-        // Otherwise check if there's an exact match
-        return mout.array.find(versions, function (version) {
-            return version === target;
+            if (!version) {
+                return [];
+            }
+
+            // Resolve with canonical dir and package meta
+            canonicalDir = path.join(dir, encodeURIComponent(version));
+            return that._readPkgMeta(canonicalDir).then(
+                function(pkgMeta) {
+                    return [canonicalDir, pkgMeta];
+                },
+                function() {
+                    // If there was an error, invalidate the in-memory cache,
+                    // delete the cached package and try again
+                    that._cache.del(sourceId);
+
+                    return Q.nfcall(rimraf, canonicalDir).then(function() {
+                        return that.retrieve(source, target);
+                    });
+                }
+            );
         });
-    })
-    .then(function (version) {
-        var canonicalDir;
-
-        if (!version) {
-            return [];
-        }
-
-        // Resolve with canonical dir and package meta
-        canonicalDir = path.join(dir, encodeURIComponent(version));
-        return that._readPkgMeta(canonicalDir)
-        .then(function (pkgMeta) {
-            return [canonicalDir, pkgMeta];
-        }, function () {
-            // If there was an error, invalidate the in-memory cache,
-            // delete the cached package and try again
-            that._cache.del(sourceId);
-
-            return Q.nfcall(rimraf, canonicalDir)
-            .then(function () {
-                return that.retrieve(source, target);
-            });
-        });
-    });
 };
 
-ResolveCache.prototype.store = function (canonicalDir, pkgMeta) {
+ResolveCache.prototype.store = function(canonicalDir, pkgMeta) {
     var sourceId;
     var release;
     var dir;
@@ -108,70 +109,82 @@ ResolveCache.prototype.store = function (canonicalDir, pkgMeta) {
     promise = pkgMeta ? Q.resolve(pkgMeta) : this._readPkgMeta(canonicalDir);
 
     return promise
-    .then(function (pkgMeta) {
-        sourceId = md5(pkgMeta._source);
-        release = that._getPkgRelease(pkgMeta);
-        dir = path.join(that._dir, sourceId, release);
-        pkgLock = path.join(that._lockDir, sourceId + '-' + release + '.lock');
+        .then(function(pkgMeta) {
+            sourceId = md5(pkgMeta._source);
+            release = that._getPkgRelease(pkgMeta);
+            dir = path.join(that._dir, sourceId, release);
+            pkgLock = path.join(
+                that._lockDir,
+                sourceId + '-' + release + '.lock'
+            );
 
-        // Check if destination directory exists to prevent issuing lock at all times
-        return Q.nfcall(fs.stat, dir)
-        .fail(function (err) {
-            var lockParams = { wait: 250, retries: 25, stale: 60000 };
-            return Q.nfcall(lockFile.lock, pkgLock, lockParams).then(function () {
-                // Ensure other process didn't start copying files before lock was created
-                return Q.nfcall(fs.stat, dir)
-                .fail(function (err) {
-                    // If stat fails, it is expected to return ENOENT
-                    if (err.code !== 'ENOENT') {
-                        throw err;
-                    }
+            // Check if destination directory exists to prevent issuing lock at all times
+            return Q.nfcall(fs.stat, dir)
+                .fail(function(err) {
+                    var lockParams = { wait: 250, retries: 25, stale: 60000 };
+                    return Q.nfcall(lockFile.lock, pkgLock, lockParams)
+                        .then(function() {
+                            // Ensure other process didn't start copying files before lock was created
+                            return Q.nfcall(fs.stat, dir).fail(function(err) {
+                                // If stat fails, it is expected to return ENOENT
+                                if (err.code !== 'ENOENT') {
+                                    throw err;
+                                }
 
-                    // Create missing directory and copy files there
-                    return Q.nfcall(mkdirp, path.dirname(dir)).then(function () {
-                        return Q.nfcall(fs.rename, canonicalDir, dir)
-                        .fail(function (err) {
-                            // If error is EXDEV it means that we are trying to rename
-                            // across different drives, so we copy and remove it instead
-                            if (err.code !== 'EXDEV') {
-                                throw err;
-                            }
+                                // Create missing directory and copy files there
+                                return Q.nfcall(mkdirp, path.dirname(dir)).then(
+                                    function() {
+                                        return Q.nfcall(
+                                            fs.rename,
+                                            canonicalDir,
+                                            dir
+                                        ).fail(function(err) {
+                                            // If error is EXDEV it means that we are trying to rename
+                                            // across different drives, so we copy and remove it instead
+                                            if (err.code !== 'EXDEV') {
+                                                throw err;
+                                            }
 
-                            return copy.copyDir(canonicalDir, dir);
+                                            return copy.copyDir(
+                                                canonicalDir,
+                                                dir
+                                            );
+                                        });
+                                    }
+                                );
+                            });
+                        })
+                        .finally(function() {
+                            lockFile.unlockSync(pkgLock);
                         });
-                    });
+                })
+                .finally(function() {
+                    // Ensure no tmp dir is left on disk.
+                    return Q.nfcall(rimraf, canonicalDir);
                 });
-            }).finally(function () {
-                lockFile.unlockSync(pkgLock);
-            });
-        }).finally(function () {
-            // Ensure no tmp dir is left on disk.
-            return Q.nfcall(rimraf, canonicalDir);
+        })
+        .then(function() {
+            var versions = that._cache.get(sourceId);
+
+            // Add it to the in memory cache
+            // and sort the versions afterwards
+            if (versions && versions.indexOf(release) === -1) {
+                versions.push(release);
+                that._sortVersions(versions);
+            }
+
+            // Resolve with the final location
+            return dir;
         });
-    })
-    .then(function () {
-        var versions = that._cache.get(sourceId);
-
-        // Add it to the in memory cache
-        // and sort the versions afterwards
-        if (versions && versions.indexOf(release) === -1) {
-            versions.push(release);
-            that._sortVersions(versions);
-        }
-
-        // Resolve with the final location
-        return dir;
-    });
 };
 
-ResolveCache.prototype.eliminate = function (pkgMeta) {
+ResolveCache.prototype.eliminate = function(pkgMeta) {
     var sourceId = md5(pkgMeta._source);
     var release = this._getPkgRelease(pkgMeta);
     var dir = path.join(this._dir, sourceId, release);
     var that = this;
 
-    return Q.nfcall(rimraf, dir)
-    .then(function () {
+    return Q.nfcall(rimraf, dir).then(function() {
         var versions = that._cache.get(sourceId) || [];
         mout.array.remove(versions, release);
 
@@ -182,8 +195,7 @@ ResolveCache.prototype.eliminate = function (pkgMeta) {
         if (!versions.length) {
             that._cache.del(sourceId);
 
-            return that._getVersions(sourceId)
-            .spread(function (versions) {
+            return that._getVersions(sourceId).spread(function(versions) {
                 if (!versions.length) {
                     // Do not keep in-memory cache if it's completely
                     // empty
@@ -196,125 +208,144 @@ ResolveCache.prototype.eliminate = function (pkgMeta) {
     });
 };
 
-ResolveCache.prototype.clear = function () {
+ResolveCache.prototype.clear = function() {
     return Q.nfcall(rimraf, this._dir)
-    .then(function () {
-        return Q.nfcall(fs.mkdir, this._dir);
-    }.bind(this))
-    .then(function () {
-        this._cache.reset();
-    }.bind(this));
+        .then(
+            function() {
+                return Q.nfcall(fs.mkdir, this._dir);
+            }.bind(this)
+        )
+        .then(
+            function() {
+                this._cache.reset();
+            }.bind(this)
+        );
 };
 
-ResolveCache.prototype.reset = function () {
+ResolveCache.prototype.reset = function() {
     this._cache.reset();
     return this;
 };
 
-ResolveCache.prototype.versions = function (source) {
+ResolveCache.prototype.versions = function(source) {
     var sourceId = md5(source);
 
-    return this._getVersions(sourceId)
-    .spread(function (versions) {
-        return versions.filter(function (version) {
+    return this._getVersions(sourceId).spread(function(versions) {
+        return versions.filter(function(version) {
             return semver.valid(version);
         });
     });
 };
 
-ResolveCache.prototype.list = function () {
+ResolveCache.prototype.list = function() {
     var promises;
     var dirs = [];
     var that = this;
 
     // Get the list of directories
-    return Q.nfcall(fs.readdir, this._dir)
-    .then(function (sourceIds) {
-        promises = sourceIds.map(function (sourceId) {
-            return Q.nfcall(fs.readdir, path.join(that._dir, sourceId))
-            .then(function (versions) {
-                versions.forEach(function (version) {
-                    var dir = path.join(that._dir, sourceId, version);
-                    dirs.push(dir);
+    return (
+        Q.nfcall(fs.readdir, this._dir)
+            .then(function(sourceIds) {
+                promises = sourceIds.map(function(sourceId) {
+                    return Q.nfcall(
+                        fs.readdir,
+                        path.join(that._dir, sourceId)
+                    ).then(
+                        function(versions) {
+                            versions.forEach(function(version) {
+                                var dir = path.join(
+                                    that._dir,
+                                    sourceId,
+                                    version
+                                );
+                                dirs.push(dir);
+                            });
+                        },
+                        function(err) {
+                            // Ignore lurking files, e.g.: .DS_Store if the user
+                            // has navigated throughout the cache
+                            if (err.code === 'ENOTDIR' && err.path) {
+                                return Q.nfcall(rimraf, err.path);
+                            }
+
+                            throw err;
+                        }
+                    );
                 });
-            }, function (err) {
-                // Ignore lurking files, e.g.: .DS_Store if the user
-                // has navigated throughout the cache
-                if (err.code === 'ENOTDIR' && err.path) {
-                    return Q.nfcall(rimraf, err.path);
-                }
 
-                throw err;
-            });
-        });
+                return Q.all(promises);
+            })
+            // Read every package meta
+            .then(function() {
+                promises = dirs.map(function(dir) {
+                    return that._readPkgMeta(dir).then(
+                        function(pkgMeta) {
+                            return {
+                                canonicalDir: dir,
+                                pkgMeta: pkgMeta
+                            };
+                        },
+                        function() {
+                            // If it fails to read, invalidate the in memory
+                            // cache for the source and delete the entry directory
+                            var sourceId = path.basename(path.dirname(dir));
+                            that._cache.del(sourceId);
 
-        return Q.all(promises);
-    })
-    // Read every package meta
-    .then(function () {
-        promises = dirs.map(function (dir) {
-            return that._readPkgMeta(dir)
-            .then(function (pkgMeta) {
-                return {
-                    canonicalDir: dir,
-                    pkgMeta: pkgMeta
-                };
-            }, function () {
-                // If it fails to read, invalidate the in memory
-                // cache for the source and delete the entry directory
-                var sourceId = path.basename(path.dirname(dir));
-                that._cache.del(sourceId);
+                            return Q.nfcall(rimraf, dir);
+                        }
+                    );
+                });
 
-                return Q.nfcall(rimraf, dir);
-            });
-        });
+                return Q.all(promises);
+            })
+            // Sort by name ASC & release ASC
+            .then(function(entries) {
+                // Ignore falsy entries due to errors reading
+                // package metas
+                entries = entries.filter(function(entry) {
+                    return !!entry;
+                });
 
-        return Q.all(promises);
-    })
-    // Sort by name ASC & release ASC
-    .then(function (entries) {
-        // Ignore falsy entries due to errors reading
-        // package metas
-        entries = entries.filter(function (entry) {
-            return !!entry;
-        });
+                return entries.sort(function(entry1, entry2) {
+                    var pkgMeta1 = entry1.pkgMeta;
+                    var pkgMeta2 = entry2.pkgMeta;
+                    var comp = pkgMeta1.name.localeCompare(pkgMeta2.name);
 
-        return entries.sort(function (entry1, entry2) {
-            var pkgMeta1 = entry1.pkgMeta;
-            var pkgMeta2 = entry2.pkgMeta;
-            var comp = pkgMeta1.name.localeCompare(pkgMeta2.name);
+                    // Sort by name
+                    if (comp) {
+                        return comp;
+                    }
 
-            // Sort by name
-            if (comp) {
-                return comp;
-            }
+                    // Sort by version
+                    if (pkgMeta1.version && pkgMeta2.version) {
+                        return semver.compare(
+                            pkgMeta1.version,
+                            pkgMeta2.version
+                        );
+                    }
+                    if (pkgMeta1.version) {
+                        return -1;
+                    }
+                    if (pkgMeta2.version) {
+                        return 1;
+                    }
 
-            // Sort by version
-            if (pkgMeta1.version && pkgMeta2.version) {
-                return semver.compare(pkgMeta1.version, pkgMeta2.version);
-            }
-            if (pkgMeta1.version) {
-                return -1;
-            }
-            if (pkgMeta2.version) {
-                return 1;
-            }
-
-            // Sort by target
-            return pkgMeta1._target.localeCompare(pkgMeta2._target);
-        });
-    });
+                    // Sort by target
+                    return pkgMeta1._target.localeCompare(pkgMeta2._target);
+                });
+            })
+    );
 };
 
 // ------------------------
 
-ResolveCache.clearRuntimeCache = function () {
+ResolveCache.clearRuntimeCache = function() {
     // Note that _cache refers to the static _cache variable
     // that holds other caches per dir!
     // Do not confuse it with the instance cache
 
     // Clear cache of each directory
-    this._cache.forEach(function (cache) {
+    this._cache.forEach(function(cache) {
         cache.reset();
     });
 
@@ -324,8 +355,10 @@ ResolveCache.clearRuntimeCache = function () {
 
 // ------------------------
 
-ResolveCache.prototype._getPkgRelease = function (pkgMeta) {
-    var release = pkgMeta.version || (pkgMeta._target === '*' ? '_wildcard' : pkgMeta._target);
+ResolveCache.prototype._getPkgRelease = function(pkgMeta) {
+    var release =
+        pkgMeta.version ||
+        (pkgMeta._target === '*' ? '_wildcard' : pkgMeta._target);
 
     // Encode some dangerous chars such as / and \
     release = encodeURIComponent(release);
@@ -333,16 +366,15 @@ ResolveCache.prototype._getPkgRelease = function (pkgMeta) {
     return release;
 };
 
-ResolveCache.prototype._readPkgMeta = function (dir) {
+ResolveCache.prototype._readPkgMeta = function(dir) {
     var filename = path.join(dir, '.bower.json');
 
-    return readJson(filename)
-    .spread(function (json) {
+    return readJson(filename).spread(function(json) {
         return json;
     });
 };
 
-ResolveCache.prototype._getVersions = function (sourceId) {
+ResolveCache.prototype._getVersions = function(sourceId) {
     var dir;
     var versions = this._cache.get(sourceId);
     var that = this;
@@ -352,29 +384,31 @@ ResolveCache.prototype._getVersions = function (sourceId) {
     }
 
     dir = path.join(this._dir, sourceId);
-    return Q.nfcall(fs.readdir, dir)
-    .then(function (versions) {
-        // Sort and cache in memory
-        that._sortVersions(versions);
-        versions = versions.map(decodeURIComponent);
-        that._cache.set(sourceId, versions);
-        return [versions, false];
-    }, function (err) {
-        // If the directory does not exists, resolve
-        // as an empty array
-        if (err.code === 'ENOENT') {
-            versions = [];
+    return Q.nfcall(fs.readdir, dir).then(
+        function(versions) {
+            // Sort and cache in memory
+            that._sortVersions(versions);
+            versions = versions.map(decodeURIComponent);
             that._cache.set(sourceId, versions);
             return [versions, false];
-        }
+        },
+        function(err) {
+            // If the directory does not exists, resolve
+            // as an empty array
+            if (err.code === 'ENOENT') {
+                versions = [];
+                that._cache.set(sourceId, versions);
+                return [versions, false];
+            }
 
-        throw err;
-    });
+            throw err;
+        }
+    );
 };
 
-ResolveCache.prototype._sortVersions = function (versions) {
+ResolveCache.prototype._sortVersions = function(versions) {
     // Sort DESC
-    versions.sort(function (version1, version2) {
+    versions.sort(function(version1, version2) {
         var validSemver1 = semver.valid(version1);
         var validSemver2 = semver.valid(version2);
 
@@ -400,7 +434,7 @@ ResolveCache.prototype._sortVersions = function (versions) {
 
 ResolveCache._cache = new LRU({
     max: 5,
-    maxAge: 60 * 30 * 1000  // 30 minutes
+    maxAge: 60 * 30 * 1000 // 30 minutes
 });
 
 module.exports = ResolveCache;

lib/core/resolverFactory.js

@@ -1,170 +1,275 @@
 var Q = require('q');
-var fs = require('graceful-fs');
+var fs = require('../util/fs');
 var path = require('path');
 var mout = require('mout');
 var resolvers = require('./resolvers');
 var createError = require('../util/createError');
+var resolve = require('../util/resolve');
 
-function createInstance(decEndpoint, config, logger, registryClient) {
-    return getConstructor(decEndpoint.source, config, registryClient)
-    .spread(function (ConcreteResolver, source, fromRegistry) {
-        var decEndpointCopy = mout.object.pick(decEndpoint, ['name', 'target']);
+var pluginResolverFactory = require('./resolvers/pluginResolverFactory');
 
-        decEndpointCopy.source = source;
+function createInstance(decEndpoint, options, registryClient) {
+    decEndpoint = mout.object.pick(decEndpoint, ['name', 'target', 'source']);
 
-        // Signal if it was fetched from the registry
-        if (fromRegistry) {
-            decEndpoint.registry = true;
-            // If no name was specified, assume the name from the registry
-            if (!decEndpointCopy.name) {
-                decEndpointCopy.name = decEndpoint.name = decEndpoint.source;
-            }
-        }
+    options.version = require('../version');
 
-        return new ConcreteResolver(decEndpointCopy, config, logger);
+    return getConstructor(decEndpoint, options, registryClient).spread(function(
+        ConcreteResolver,
+        decEndpoint
+    ) {
+        return new ConcreteResolver(
+            decEndpoint,
+            options.config,
+            options.logger
+        );
     });
 }
 
-function getConstructor(source, config, registryClient) {
-    var absolutePath,
-        promise;
+function getConstructor(decEndpoint, options, registryClient) {
+    var source = decEndpoint.source;
+    var config = options.config;
+
+    // Below we try a series of async tests to guess the type of resolver to use
+    // If a step was unable to guess the resolver, it returns undefined
+    // If a step can guess the resolver, it returns with constructor of resolver
+
+    var promise = Q.resolve();
+
+    var addResolver = function(resolverFactory) {
+        promise = promise.then(function(result) {
+            if (result === undefined) {
+                return resolverFactory(decEndpoint, options);
+            } else {
+                return result;
+            }
+        });
+    };
+
+    // Plugin resolvers.
+    //
+    // It requires each resolver defined in config.resolvers and calls
+    // its "match" to check if given resolves supports given decEndpoint
+    addResolver(function() {
+        var selectedResolver;
+        var resolverNames;
+
+        if (Array.isArray(config.resolvers)) {
+            resolverNames = config.resolvers;
+        } else if (!!config.resolvers) {
+            resolverNames = config.resolvers.split(',');
+        } else {
+            resolverNames = [];
+        }
+
+        var resolverPromises = resolverNames.map(function(resolverName) {
+            var resolver = resolvers[resolverName];
+
+            if (resolver === undefined) {
+                var resolverPath = resolve(resolverName, { cwd: config.cwd });
+
+                if (resolverPath === undefined) {
+                    throw createError(
+                        'Bower resolver not found: ' + resolverName,
+                        'ENORESOLVER'
+                    );
+                }
+
+                resolver = pluginResolverFactory(
+                    require(resolverPath),
+                    options
+                );
+            }
+
+            return function() {
+                if (selectedResolver === undefined) {
+                    var match = resolver.match.bind(resolver);
+
+                    return Q.fcall(match, source).then(function(result) {
+                        if (result) {
+                            return (selectedResolver = resolver);
+                        }
+                    });
+                } else {
+                    return selectedResolver;
+                }
+            };
+        });
+
+        return resolverPromises
+            .reduce(Q.when, new Q(undefined))
+            .then(function(resolver) {
+                if (resolver) {
+                    return Q.fcall(
+                        resolver.locate.bind(resolver),
+                        decEndpoint.source
+                    ).then(function(result) {
+                        if (result && result !== decEndpoint.source) {
+                            decEndpoint.source = result;
+                            decEndpoint.registry = true;
+                            return getConstructor(
+                                decEndpoint,
+                                options,
+                                registryClient
+                            );
+                        } else {
+                            return [resolver, decEndpoint];
+                        }
+                    });
+                }
+            });
+    });
 
     // Git case: git git+ssh, git+http, git+https
     //           .git at the end (probably ssh shorthand)
     //           git@ at the start
-    if (/^git(\+(ssh|https?))?:\/\//i.test(source) || /\.git\/?$/i.test(source) || /^git@/i.test(source)) {
-        source = source.replace(/^git\+/, '');
-        return Q.fcall(function () {
+    addResolver(function() {
+        if (
+            /^git(\+(ssh|https?))?:\/\//i.test(source) ||
+            /\.git\/?$/i.test(source) ||
+            /^git@/i.test(source)
+        ) {
+            decEndpoint.source = source.replace(/^git\+/, '');
 
             // If it's a GitHub repository, return the specialized resolver
             if (resolvers.GitHub.getOrgRepoPair(source)) {
-                return [resolvers.GitHub, source];
+                return [resolvers.GitHub, decEndpoint];
             }
 
-            return [resolvers.GitRemote, source];
-        });
-    }
+            return [resolvers.GitRemote, decEndpoint];
+        }
+    });
 
     // SVN case: svn, svn+ssh, svn+http, svn+https, svn+file
-    if (/^svn(\+(ssh|https?|file))?:\/\//i.test(source)) {
-        return Q.fcall(function () {
-            return [resolvers.Svn, source];
-        });
-    }
+    addResolver(function() {
+        if (/^svn(\+(ssh|https?|file))?:\/\//i.test(source)) {
+            return [resolvers.Svn, decEndpoint];
+        }
+    });
 
     // URL case
-    if (/^https?:\/\//i.exec(source)) {
-        return Q.fcall(function () {
-            return [resolvers.Url, source];
-        });
-    }
-
-    // Below we try a series of async tests to guess the type of resolver to use
-    // If a step was unable to guess the resolver, it throws an error
-    // If a step was able to guess the resolver, it resolves with a function
-    // That function returns a promise that will resolve with the concrete type
+    addResolver(function() {
+        if (/^https?:\/\//i.exec(source)) {
+            return [resolvers.Url, decEndpoint];
+        }
+    });
 
     // If source is ./ or ../ or an absolute path
-    absolutePath = path.resolve(config.cwd, source);
 
-    if (/^\.\.?[\/\\]/.test(source) || /^~\//.test(source) || path.normalize(source).replace(/[\/\\]+$/, '') === absolutePath) {
-        promise = Q.nfcall(fs.stat, path.join(absolutePath, '.git'))
-        .then(function (stats) {
-            if (stats.isDirectory()) {
-                return function () {
-                    return Q.resolve([resolvers.GitFs, absolutePath]);
-                };
-            }
+    addResolver(function() {
+        var absolutePath = path.resolve(config.cwd, source);
 
-            throw new Error('Not a Git repository');
-        })
-        // If not, check if source is a valid Subversion repository
-        .fail(function () {
-            return Q.nfcall(fs.stat, path.join(absolutePath, '.svn'))
-            .then(function (stats) {
-                if (stats.isDirectory()) {
-                    return function () {
-                        return Q.resolve([resolvers.Svn, absolutePath]);
-                    };
-                }
+        if (
+            /^\.\.?[\/\\]/.test(source) ||
+            /^~\//.test(source) ||
+            path.normalize(source).replace(/[\/\\]+$/, '') === absolutePath
+        ) {
+            return (
+                Q.nfcall(fs.stat, path.join(absolutePath, '.git'))
+                    .then(function(stats) {
+                        decEndpoint.source = absolutePath;
 
-                throw new Error('Not a Subversion repository');
-            });
-        })
-        // If not, check if source is a valid file/folder
-        .fail(function () {
-            return Q.nfcall(fs.stat, absolutePath)
-            .then(function () {
-                return function () {
-                    return Q.resolve([resolvers.Fs, absolutePath]);
-                };
-            });
-        });
-    } else {
-        promise = Q.reject(new Error('Not an absolute or relative file'));
-    }
+                        if (stats.isDirectory()) {
+                            return Q.resolve([resolvers.GitFs, decEndpoint]);
+                        }
+
+                        throw new Error('Not a Git repository');
+                    })
+                    // If not, check if source is a valid Subversion repository
+                    .fail(function() {
+                        return Q.nfcall(
+                            fs.stat,
+                            path.join(absolutePath, '.svn')
+                        ).then(function(stats) {
+                            decEndpoint.source = absolutePath;
+
+                            if (stats.isDirectory()) {
+                                return Q.resolve([resolvers.Svn, decEndpoint]);
+                            }
+
+                            throw new Error('Not a Subversion repository');
+                        });
+                    })
+                    // If not, check if source is a valid file/folder
+                    .fail(function() {
+                        return Q.nfcall(fs.stat, absolutePath).then(function() {
+                            decEndpoint.source = absolutePath;
+
+                            return Q.resolve([resolvers.Fs, decEndpoint]);
+                        });
+                    })
+            );
+        }
+    });
 
-    return promise
     // Check if is a shorthand and expand it
-    .fail(function (err) {
-        var parts;
+    addResolver(function() {
+        // Check if the shorthandResolver is falsy
+        if (!config.shorthandResolver) {
+            return;
+        }
 
         // Skip ssh and/or URL with auth
         if (/[:@]/.test(source)) {
-            throw err;
+            return;
         }
 
         // Ensure exactly only one "/"
-        parts = source.split('/');
+        var parts = source.split('/');
         if (parts.length === 2) {
-            source = mout.string.interpolate(config.shorthandResolver, {
-                shorthand: source,
-                owner: parts[0],
-                package: parts[1]
-            });
-
-            return function () {
-                return getConstructor(source, config, registryClient);
-            };
-        }
-
-        throw err;
-    })
-    // As last resort, we try the registry
-    .fail(function (err) {
-        if (!registryClient) {
-            throw err;
-        }
-
-        return function () {
-            return Q.nfcall(registryClient.lookup.bind(registryClient), source)
-            .then(function (entry) {
-                if (!entry) {
-                    throw createError('Package ' + source + ' not found', 'ENOTFOUND');
+            decEndpoint.source = mout.string.interpolate(
+                config.shorthandResolver,
+                {
+                    shorthand: source,
+                    owner: parts[0],
+                    package: parts[1]
                 }
+            );
 
-                // TODO: Handle entry.type.. for now it's only 'alias'
-                //       When we got published packages, this needs to be adjusted
-                source = entry.url;
-
-                return getConstructor(source, config, registryClient)
-                .spread(function (ConcreteResolver, source) {
-                    return [ConcreteResolver, source, true];
-                });
-            });
-        };
-    })
-    // If we got the function, simply call and return
-    .then(function (func) {
-        return func();
-    // Finally throw a meaningful error
-    }, function () {
-        throw createError('Could not find appropriate resolver for ' + source, 'ENORESOLVER');
+            return getConstructor(decEndpoint, options, registryClient);
+        }
     });
+
+    // As last resort, we try the registry
+    addResolver(function() {
+        if (!registryClient) {
+            return;
+        }
+
+        return Q.nfcall(
+            registryClient.lookup.bind(registryClient),
+            source
+        ).then(function(entry) {
+            if (!entry) {
+                throw createError(
+                    'Package ' + source + ' not found',
+                    'ENOTFOUND'
+                );
+            }
+
+            decEndpoint.registry = true;
+
+            if (!decEndpoint.name) {
+                decEndpoint.name = decEndpoint.source;
+            }
+
+            decEndpoint.source = entry.url;
+
+            return getConstructor(decEndpoint, options);
+        });
+    });
+
+    addResolver(function() {
+        throw createError(
+            'Could not find appropriate resolver for ' + source,
+            'ENORESOLVER'
+        );
+    });
+
+    return promise;
 }
 
 function clearRuntimeCache() {
-    mout.object.values(resolvers).forEach(function (ConcreteResolver) {
+    mout.object.values(resolvers).forEach(function(ConcreteResolver) {
         ConcreteResolver.clearRuntimeCache();
     });
 }

lib/core/resolvers/FsResolver.js

@@ -1,5 +1,5 @@
 var util = require('util');
-var fs = require('graceful-fs');
+var fs = require('../../util/fs');
 var path = require('path');
 var mout = require('mout');
 var Q = require('q');
@@ -17,13 +17,19 @@ function FsResolver(decEndpoint, config, logger) {
 
     // If target was specified, simply reject the promise
     if (this._target !== '*') {
-        throw createError('File system sources can\'t resolve targets', 'ENORESTARGET');
+        throw createError(
+            "File system sources can't resolve targets",
+            'ENORESTARGET'
+        );
     }
 
     // If the name was guessed
     if (this._guessedName) {
         // Remove extension
-        this._name = this._name.substr(0, this._name.length - path.extname(this._name).length);
+        this._name = this._name.substr(
+            0,
+            this._name.length - path.extname(this._name).length
+        );
     }
 }
 
@@ -32,7 +38,7 @@ mout.object.mixIn(FsResolver, Resolver);
 
 // -----------------
 
-FsResolver.isTargetable = function () {
+FsResolver.isTargetable = function() {
     return false;
 };
 
@@ -42,19 +48,18 @@ FsResolver.isTargetable = function () {
 // TODO: There's room for improvement by using streams if the source
 //       is an archive file, by piping read stream to the zip extractor
 //       This will likely increase the complexity of code but might worth it
-FsResolver.prototype._resolve = function () {
+FsResolver.prototype._resolve = function() {
     return this._copy()
-    .then(this._extract.bind(this))
-    .then(this._rename.bind(this));
+        .then(this._extract.bind(this))
+        .then(this._rename.bind(this));
 };
 
 // -----------------
 
-FsResolver.prototype._copy = function () {
+FsResolver.prototype._copy = function() {
     var that = this;
 
-    return Q.nfcall(fs.stat, this._source)
-    .then(function (stat) {
+    return Q.nfcall(fs.stat, this._source).then(function(stat) {
         var dst;
         var copyOpts;
         var promise;
@@ -68,22 +73,24 @@ FsResolver.prototype._copy = function () {
 
             // Read the bower.json inside the folder, so that we
             // copy only the necessary files if it has ignore specified
-            promise = that._readJson(that._source)
-            .then(function (json) {
-                copyOpts.ignore = json.ignore;
-                return copy.copyDir(that._source, dst, copyOpts);
-            })
-            .then(function () {
-                // Resolve to null because it's a dir
-                return;
-            });
-        // Else it's a file
+            promise = that
+                ._readJson(that._source)
+                .then(function(json) {
+                    copyOpts.ignore = json.ignore;
+                    return copy.copyDir(that._source, dst, copyOpts);
+                })
+                .then(function() {
+                    // Resolve to null because it's a dir
+                    return;
+                });
+            // Else it's a file
         } else {
             dst = path.join(that._tempDir, path.basename(that._source));
-            promise = copy.copyFile(that._source, dst, copyOpts)
-            .then(function () {
-                return dst;
-            });
+            promise = copy
+                .copyFile(that._source, dst, copyOpts)
+                .then(function() {
+                    return dst;
+                });
         }
 
         that._logger.action('copy', that._source, {
@@ -95,7 +102,7 @@ FsResolver.prototype._copy = function () {
     });
 };
 
-FsResolver.prototype._extract = function (file) {
+FsResolver.prototype._extract = function(file) {
     if (!file || !extract.canExtract(file)) {
         return Q.resolve();
     }
@@ -108,30 +115,34 @@ FsResolver.prototype._extract = function (file) {
     return extract(file, this._tempDir);
 };
 
-FsResolver.prototype._rename = function () {
-    return Q.nfcall(fs.readdir, this._tempDir)
-    .then(function (files) {
-        var file;
-        var oldPath;
-        var newPath;
+FsResolver.prototype._rename = function() {
+    return Q.nfcall(fs.readdir, this._tempDir).then(
+        function(files) {
+            var file;
+            var oldPath;
+            var newPath;
 
-        // Remove any OS specific files from the files array
-        // before checking its length
-        files = files.filter(junk.isnt);
+            // Remove any OS specific files from the files array
+            // before checking its length
+            files = files.filter(junk.isnt);
 
-        // Only rename if there's only one file and it's not the json
-        if (files.length === 1 && !/^(bower|component)\.json$/.test(files[0])) {
-            file = files[0];
-            this._singleFile = 'index' + path.extname(file);
-            oldPath = path.join(this._tempDir, file);
-            newPath = path.join(this._tempDir, this._singleFile);
+            // Only rename if there's only one file and it's not the json
+            if (
+                files.length === 1 &&
+                !/^(bower|component)\.json$/.test(files[0])
+            ) {
+                file = files[0];
+                this._singleFile = 'index' + path.extname(file);
+                oldPath = path.join(this._tempDir, file);
+                newPath = path.join(this._tempDir, this._singleFile);
 
-            return Q.nfcall(fs.rename, oldPath, newPath);
-        }
-    }.bind(this));
+                return Q.nfcall(fs.rename, oldPath, newPath);
+            }
+        }.bind(this)
+    );
 };
 
-FsResolver.prototype._savePkgMeta = function (meta) {
+FsResolver.prototype._savePkgMeta = function(meta) {
     // Store main if is a single file
     if (this._singleFile) {
         meta.main = this._singleFile;

lib/core/resolvers/GitFsResolver.js

@@ -19,31 +19,52 @@ mout.object.mixIn(GitFsResolver, GitResolver);
 // -----------------
 
 // Override the checkout function to work with the local copy
-GitFsResolver.prototype._checkout = function () {
+GitFsResolver.prototype._checkout = function() {
     var resolution = this._resolution;
 
     // The checkout process could be similar to the GitRemoteResolver by prepending file:// to the source
     // But from my performance measures, it's faster to copy the folder and just checkout in there
-    this._logger.action('checkout', resolution.tag || resolution.branch || resolution.commit, {
-        resolution: resolution,
-        to: this._tempDir
-    });
+    this._logger.action(
+        'checkout',
+        resolution.tag || resolution.branch || resolution.commit,
+        {
+            resolution: resolution,
+            to: this._tempDir
+        }
+    );
 
     // Copy files to the temporary directory first
-    return this._copy()
-    .then(cmd.bind(cmd, 'git', ['checkout', '-f', resolution.tag || resolution.branch || resolution.commit], { cwd: this._tempDir }))
-    // Cleanup unstaged files
-    .then(cmd.bind(cmd, 'git', ['clean', '-f', '-d'], { cwd: this._tempDir }));
+    return (
+        this._copy()
+            .then(
+                cmd.bind(
+                    cmd,
+                    'git',
+                    [
+                        'checkout',
+                        '-f',
+                        resolution.tag || resolution.branch || resolution.commit
+                    ],
+                    { cwd: this._tempDir }
+                )
+            )
+            // Cleanup unstaged files
+            .then(
+                cmd.bind(cmd, 'git', ['clean', '-f', '-d'], {
+                    cwd: this._tempDir
+                })
+            )
+    );
 };
 
-GitFsResolver.prototype._copy = function () {
+GitFsResolver.prototype._copy = function() {
     return copy.copyDir(this._source, this._tempDir);
 };
 
 // -----------------
 
 // Grab refs locally
-GitFsResolver.refs = function (source) {
+GitFsResolver.refs = function(source) {
     var value;
 
     // TODO: Normalize source because of the various available protocols?
@@ -52,20 +73,24 @@ GitFsResolver.refs = function (source) {
         return Q.resolve(value);
     }
 
-    value = cmd('git', ['show-ref', '--tags', '--heads'], { cwd : source })
-    .spread(function (stdout) {
-        var refs;
+    value = cmd('git', ['show-ref', '--tags', '--heads'], {
+        cwd: source
+    }).spread(
+        function(stdout) {
+            var refs;
 
-        refs = stdout.toString()
-        .trim()                         // Trim trailing and leading spaces
-        .replace(/[\t ]+/g, ' ')        // Standardize spaces (some git versions make tabs, other spaces)
-        .split(/[\r\n]+/);              // Split lines into an array
+            refs = stdout
+                .toString()
+                .trim() // Trim trailing and leading spaces
+                .replace(/[\t ]+/g, ' ') // Standardize spaces (some git versions make tabs, other spaces)
+                .split(/[\r\n]+/); // Split lines into an array
 
-        // Update the refs with the actual refs
-        this._cache.refs.set(source, refs);
+            // Update the refs with the actual refs
+            this._cache.refs.set(source, refs);
 
-        return refs;
-    }.bind(this));
+            return refs;
+        }.bind(this)
+    );
 
     // Store the promise to be reused until it resolves
     // to a specific value

lib/core/resolvers/GitHubResolver.js

@@ -1,6 +1,7 @@
 var util = require('util');
 var path = require('path');
 var mout = require('mout');
+var Q = require('q');
 var GitRemoteResolver = require('./GitRemoteResolver');
 var download = require('../../util/download');
 var extract = require('../../util/extract');
@@ -28,13 +29,15 @@ function GitHubResolver(decEndpoint, config, logger) {
         this._source += '.git';
     }
 
-    // Check if it's public
-    this._public = mout.string.startsWith(this._source, 'git://');
-
     // Use https:// rather than git:// if on a proxy
     if (this._config.proxy || this._config.httpsProxy) {
         this._source = this._source.replace('git://', 'https://');
     }
+
+    // Enable shallow clones for GitHub repos
+    this._shallowClone = function() {
+        return Q.resolve(true);
+    };
 }
 
 util.inherits(GitHubResolver, GitRemoteResolver);
@@ -42,15 +45,21 @@ mout.object.mixIn(GitHubResolver, GitRemoteResolver);
 
 // -----------------
 
-GitHubResolver.prototype._checkout = function () {
-    // Only fully works with public repositories and tags
-    // Could work with https/ssh protocol but not with 100% certainty
-    if (!this._public || !this._resolution.tag) {
-        return GitRemoteResolver.prototype._checkout.call(this);
-    }
-
+GitHubResolver.prototype._checkout = function() {
     var msg;
-    var tarballUrl = 'https://github.com/' + this._org + '/' + this._repo + '/archive/' + this._resolution.tag + '.tar.gz';
+    var name =
+        this._resolution.tag ||
+        this._resolution.branch ||
+        this._resolution.commit;
+    var tarballUrl =
+        'https://github.com/' +
+        this._org +
+        '/' +
+        this._repo +
+        '/archive/' +
+        name +
+        '.tar.gz';
+
     var file = path.join(this._tempDir, 'archive.tar.gz');
     var reqHeaders = {};
     var that = this;
@@ -66,60 +75,93 @@ GitHubResolver.prototype._checkout = function () {
 
     // Download tarball
     return download(tarballUrl, file, {
-        proxy: this._config.httpsProxy,
+        ca: this._config.ca.default,
         strictSSL: this._config.strictSsl,
         timeout: this._config.timeout,
         headers: reqHeaders
     })
-    .progress(function (state) {
-        // Retry?
-        if (state.retry) {
-            msg = 'Download of ' + tarballUrl + ' failed with ' + state.error.code + ', ';
-            msg += 'retrying in ' + (state.delay / 1000).toFixed(1) + 's';
-            that._logger.debug('error', state.error.message, { error: state.error });
-            return that._logger.warn('retry', msg);
-        }
+        .progress(function(state) {
+            // Retry?
+            if (state.retry) {
+                msg =
+                    'Download of ' +
+                    tarballUrl +
+                    ' failed with ' +
+                    state.error.code +
+                    ', ';
+                msg += 'retrying in ' + (state.delay / 1000).toFixed(1) + 's';
+                that._logger.debug('error', state.error.message, {
+                    error: state.error
+                });
+                return that._logger.warn('retry', msg);
+            }
 
-        // Progress
-        msg = 'received ' + (state.received / 1024 / 1024).toFixed(1) + 'MB';
-        if (state.total) {
-            msg += ' of ' + (state.total / 1024 / 1024).toFixed(1) + 'MB downloaded, ';
-            msg += state.percent + '%';
-        }
-        that._logger.info('progress', msg);
-    })
-    .then(function () {
-        // Extract archive
-        that._logger.action('extract', path.basename(file), {
-            archive: file,
-            to: that._tempDir
-        });
+            // Progress
+            msg =
+                'received ' + (state.received / 1024 / 1024).toFixed(1) + 'MB';
+            if (state.total) {
+                msg +=
+                    ' of ' +
+                    (state.total / 1024 / 1024).toFixed(1) +
+                    'MB downloaded, ';
+                msg += state.percent + '%';
+            }
+            that._logger.info('progress', msg);
+        })
+        .then(
+            function() {
+                // Extract archive
+                that._logger.action('extract', path.basename(file), {
+                    archive: file,
+                    to: that._tempDir
+                });
 
-        return extract(file, that._tempDir)
-        // Fallback to standard git clone if extraction failed
-        .fail(function (err) {
-            msg =  'Decompression of ' + path.basename(file) + ' failed' + (err.code ? ' with ' + err.code : '') + ', ';
-            msg += 'trying with git..';
-            that._logger.debug('error', err.message, { error: err });
-            that._logger.warn('retry', msg);
+                return (
+                    extract(file, that._tempDir)
+                        // Fallback to standard git clone if extraction failed
+                        .fail(function(err) {
+                            msg =
+                                'Decompression of ' +
+                                path.basename(file) +
+                                ' failed' +
+                                (err.code ? ' with ' + err.code : '') +
+                                ', ';
+                            msg += 'trying with git..';
+                            that._logger.debug('error', err.message, {
+                                error: err
+                            });
+                            that._logger.warn('retry', msg);
 
-            return that._cleanTempDir()
-            .then(GitRemoteResolver.prototype._checkout.bind(that));
-        });
-    // Fallback to standard git clone if download failed
-    }, function (err) {
-        msg = 'Download of ' + tarballUrl + ' failed' + (err.code ? ' with ' + err.code : '') + ', ';
-        msg += 'trying with git..';
-        that._logger.debug('error', err.message, { error: err });
-        that._logger.warn('retry', msg);
+                            return that
+                                ._cleanTempDir()
+                                .then(
+                                    GitRemoteResolver.prototype._checkout.bind(
+                                        that
+                                    )
+                                );
+                        })
+                );
+                // Fallback to standard git clone if download failed
+            },
+            function(err) {
+                msg =
+                    'Download of ' +
+                    tarballUrl +
+                    ' failed' +
+                    (err.code ? ' with ' + err.code : '') +
+                    ', ';
+                msg += 'trying with git..';
+                that._logger.debug('error', err.message, { error: err });
+                that._logger.warn('retry', msg);
 
-        return that._cleanTempDir()
-        .then(GitRemoteResolver.prototype._checkout.bind(that));
-
-    });
+                return that
+                    ._cleanTempDir()
+                    .then(GitRemoteResolver.prototype._checkout.bind(that));
+            }
+        );
 };
 
-GitHubResolver.prototype._savePkgMeta = function (meta) {
+GitHubResolver.prototype._savePkgMeta = function(meta) {
     // Set homepage if not defined
     if (!meta.homepage) {
         meta.homepage = 'https://github.com/' + this._org + '/' + this._repo;
@@ -130,10 +172,12 @@ GitHubResolver.prototype._savePkgMeta = function (meta) {
 
 // ----------------
 
-GitHubResolver.getOrgRepoPair = function (url) {
+GitHubResolver.getOrgRepoPair = function(url) {
     var match;
 
-    match = url.match(/(?:@|:\/\/)github.com[:\/]([^\/\s]+?)\/([^\/\s]+?)(?:\.git)?\/?$/i);
+    match = url.match(
+        /(?:@|:\/\/)github.com[:\/]([^\/\s]+?)\/([^\/\s]+?)(?:\.git)?\/?$/i
+    );
     if (!match) {
         return null;
     }

lib/core/resolvers/GitRemoteResolver.js

@@ -19,12 +19,17 @@ function GitRemoteResolver(decEndpoint, config, logger) {
         this._name = this._name.slice(0, -4);
     }
 
-    // Get the host of this source
+    // Get the remote of this source
     if (!/:\/\//.test(this._source)) {
-        this._host = url.parse('ssh://' + this._source).host;
+        this._remote = url.parse('ssh://' + this._source);
     } else {
-        this._host = url.parse(this._source).host;
+        this._remote = url.parse(this._source);
     }
+
+    this._host = this._remote.host;
+
+    // Verify whether the server supports shallow cloning
+    this._shallowClone = this._supportsShallowCloning;
 }
 
 util.inherits(GitRemoteResolver, GitResolver);
@@ -32,33 +37,37 @@ mout.object.mixIn(GitRemoteResolver, GitResolver);
 
 // -----------------
 
-GitRemoteResolver.prototype._checkout = function () {
+GitRemoteResolver.prototype._checkout = function() {
     var promise;
     var timer;
     var reporter;
     var that = this;
     var resolution = this._resolution;
 
-    this._logger.action('checkout', resolution.tag || resolution.branch || resolution.commit, {
-        resolution: resolution,
-        to: this._tempDir
-    });
+    this._logger.action(
+        'checkout',
+        resolution.tag || resolution.branch || resolution.commit,
+        {
+            resolution: resolution,
+            to: this._tempDir
+        }
+    );
 
     // If resolution is a commit, we need to clone the entire repo and check it out
     // Because a commit is not a named ref, there's no better solution
     if (resolution.type === 'commit') {
         promise = this._slowClone(resolution);
-    // Otherwise we are checking out a named ref so we can optimize it
+        // Otherwise we are checking out a named ref so we can optimize it
     } else {
         promise = this._fastClone(resolution);
     }
 
     // Throttle the progress reporter to 1 time each sec
-    reporter = mout.fn.throttle(function (data) {
+    reporter = mout.fn.throttle(function(data) {
         var lines;
 
         lines = data.split(/[\r\n]+/);
-        lines.forEach(function (line) {
+        lines.forEach(function(line) {
             if (/\d{1,3}\%/.test(line)) {
                 // TODO: There are some strange chars that appear once in a while (\u001b[K)
                 //       Trim also those?
@@ -68,99 +77,217 @@ GitRemoteResolver.prototype._checkout = function () {
     }, 1000);
 
     // Start reporting progress after a few seconds
-    timer = setTimeout(function () {
+    timer = setTimeout(function() {
         promise.progress(reporter);
     }, 8000);
 
-    return promise
-    // Add additional proxy information to the error if necessary
-    .fail(function (err) {
-        that._suggestProxyWorkaround(err);
-        throw err;
-    })
-    // Clear timer at the end
-    .fin(function () {
-        clearTimeout(timer);
-        reporter.cancel();
-    });
+    return (
+        promise
+            // Add additional proxy information to the error if necessary
+            .fail(function(err) {
+                that._suggestProxyWorkaround(err);
+                throw err;
+            })
+            // Clear timer at the end
+            .fin(function() {
+                clearTimeout(timer);
+                reporter.cancel();
+            })
+    );
 };
 
-GitRemoteResolver.prototype._findResolution = function (target) {
+GitRemoteResolver.prototype._findResolution = function(target) {
     var that = this;
 
     // Override this function to include a meaningful message related to proxies
     // if necessary
-    return GitResolver.prototype._findResolution.call(this, target)
-    .fail(function (err) {
-        that._suggestProxyWorkaround(err);
-        throw err;
-    });
+    return GitResolver.prototype._findResolution
+        .call(this, target)
+        .fail(function(err) {
+            that._suggestProxyWorkaround(err);
+            throw err;
+        });
 };
 
 // ------------------------------
 
-GitRemoteResolver.prototype._slowClone = function (resolution) {
-    return cmd('git', ['clone', this._source, this._tempDir, '--progress'])
-    .then(cmd.bind(cmd, 'git', ['checkout', resolution.commit], { cwd: this._tempDir }));
+GitRemoteResolver.prototype._slowClone = function(resolution) {
+    return cmd('git', [
+        'clone',
+        this._source,
+        this._tempDir,
+        '--progress'
+    ]).then(
+        cmd.bind(cmd, 'git', ['checkout', resolution.commit], {
+            cwd: this._tempDir
+        })
+    );
 };
 
-GitRemoteResolver.prototype._fastClone = function (resolution) {
+GitRemoteResolver.prototype._fastClone = function(resolution) {
     var branch,
         args,
         that = this;
 
     branch = resolution.tag || resolution.branch;
-    args = ['clone',  this._source, '-b', branch, '--progress', '.'];
+    args = ['clone', this._source, '-b', branch, '--progress', '.'];
 
-    // If the host does not support shallow clones, we don't use --depth=1
-    if (!GitRemoteResolver._noShallow.get(this._host)) {
-        args.push('--depth', 1);
-    }
-
-    return cmd('git', args, { cwd: this._tempDir })
-    .spread(function (stdout, stderr) {
-        // Only after 1.7.10 --branch accepts tags
-        // Detect those cases and inform the user to update git otherwise it's
-        // a lot slower than newer versions
-        if (!/branch .+? not found/i.test(stderr)) {
-            return;
-        }
-
-        that._logger.warn('old-git', 'It seems you are using an old version of git, it will be slower and propitious to errors!');
-        return cmd('git', ['checkout', resolution.commit], { cwd: that._tempDir });
-    }, function (err) {
-        // Some git servers do not support shallow clones
-        // When that happens, we mark this host and try again
-        if (!GitRemoteResolver._noShallow.has(that._source) &&
-            err.details &&
-            /(rpc failed|shallow|--depth)/i.test(err.details)
+    return this._shallowClone().then(function(shallowCloningSupported) {
+        // If the host does not support shallow clones, we don't use --depth=1
+        if (
+            shallowCloningSupported &&
+            !GitRemoteResolver._noShallow.get(that._host)
         ) {
-            GitRemoteResolver._noShallow.set(that._host, true);
-            return that._fastClone(resolution);
+            args.push('--depth', 1);
         }
 
-        throw err;
+        return cmd('git', args, { cwd: that._tempDir }).spread(
+            function(stdout, stderr) {
+                // Only after 1.7.10 --branch accepts tags
+                // Detect those cases and inform the user to update git otherwise it's
+                // a lot slower than newer versions
+                if (!/branch .+? not found/i.test(stderr)) {
+                    return;
+                }
+
+                that._logger.warn(
+                    'old-git',
+                    'It seems you are using an old version of git, it will be slower and propitious to errors!'
+                );
+                return cmd('git', ['checkout', resolution.commit], {
+                    cwd: that._tempDir
+                });
+            },
+            function(err) {
+                // Some git servers do not support shallow clones
+                // When that happens, we mark this host and try again
+                if (
+                    !GitRemoteResolver._noShallow.has(that._source) &&
+                    err.details &&
+                    /(rpc failed|shallow|--depth)/i.test(err.details)
+                ) {
+                    GitRemoteResolver._noShallow.set(that._host, true);
+                    return that._fastClone(resolution);
+                }
+
+                throw err;
+            }
+        );
     });
 };
 
-GitRemoteResolver.prototype._suggestProxyWorkaround = function (err) {
-    if ((this._config.proxy || this._config.httpsProxy) &&
+GitRemoteResolver.prototype._suggestProxyWorkaround = function(err) {
+    if (
+        (this._config.proxy || this._config.httpsProxy) &&
         mout.string.startsWith(this._source, 'git://') &&
-        err.code === 'ECMDERR' && err.details
+        err.code === 'ECMDERR' &&
+        err.details
     ) {
         err.details = err.details.trim();
-        err.details += '\n\nWhen under a proxy, you must configure git to use https:// instead of git://.';
-        err.details += '\nYou can configure it for every endpoint or for this specific host as follows:';
+        err.details +=
+            '\n\nWhen under a proxy, you must configure git to use https:// instead of git://.';
+        err.details +=
+            '\nYou can configure it for every endpoint or for this specific host as follows:';
         err.details += '\ngit config --global url."https://".insteadOf git://';
-        err.details += '\ngit config --global url."https://' + this._host + '".insteadOf git://' + this._host;
-        err.details += 'Ignore this suggestion if you already have this configured.';
+        err.details +=
+            '\ngit config --global url."https://' +
+            this._host +
+            '".insteadOf git://' +
+            this._host;
+        err.details +=
+            'Ignore this suggestion if you already have this configured.';
     }
 };
 
+// Verifies whether the server supports shallow cloning.
+// This is done according to the rules found in the following links:
+// * https://github.com/dimitri/el-get/pull/1921/files
+// * http://stackoverflow.com/questions/9270488/is-it-possible-to-detect-whether-a-http-git-remote-is-smart-or-dumb
+//
+// Summary of the rules:
+// * Protocols like ssh or git always support shallow cloning
+// * HTTP-based protocols can be verified by sending a HEAD or GET request to the URI (appended to the URL of the Git repo):
+//       /info/refs?service=git-upload-pack
+// * If the server responds with a 'Content-Type' header of 'application/x-git-upload-pack-advertisement',
+//      the server supports shallow cloning ("smart server")
+// * If the server responds with a different content type, the server does not support shallow cloning ("dumb server")
+// * Instead of doing the HEAD or GET request using an HTTP client, we're letting Git and Curl do the heavy lifting.
+//      Calling Git with the GIT_CURL_VERBOSE=2 env variable will provide the Git and Curl output, which includes
+//      the content type. This has the advantage that Git will take care of using stored credentials and any additional
+//      negotiation that needs to take place.
+//
+// The above should cover most cases, including BitBucket.
+GitRemoteResolver.prototype._supportsShallowCloning = function() {
+    var value = true;
+
+    // Verify that the remote could be parsed and that a protocol is set
+    // This case is unlikely, but let's still cover it.
+    if (this._remote == null || this._remote.protocol == null) {
+        return Q.resolve(false);
+    }
+
+    if (
+        !this._host ||
+        !this._config.shallowCloneHosts ||
+        this._config.shallowCloneHosts.indexOf(this._host) === -1
+    ) {
+        return Q.resolve(false);
+    }
+
+    // Check for protocol - the remote check for hosts supporting shallow cloning is only required for
+    // HTTP or HTTPS, not for Git or SSH.
+    // Also check for hosts that have been checked in a previous request and have been found to support
+    // shallow cloning.
+    if (
+        mout.string.startsWith(this._remote.protocol, 'http') &&
+        !GitRemoteResolver._canShallow.get(this._host)
+    ) {
+        // Provide GIT_CURL_VERBOSE=2 environment variable to capture curl output.
+        // Calling ls-remote includes a call to the git-upload-pack service, which returns the content type in the response.
+        var processEnv = mout.object.merge(process.env, {
+            GIT_CURL_VERBOSE: '2'
+        });
+
+        value = cmd('git', ['ls-remote', '--heads', this._source], {
+            env: processEnv
+        }).spread(
+            function(stdout, stderr) {
+                // Check stderr for content-type, ignore stdout
+                var isSmartServer;
+
+                // If the content type is 'x-git', then the server supports shallow cloning
+                isSmartServer = mout.string.contains(
+                    stderr,
+                    'Content-Type: application/x-git-upload-pack-advertisement'
+                );
+
+                this._logger.debug(
+                    'detect-smart-git',
+                    'Smart Git host detected: ' + isSmartServer
+                );
+
+                if (isSmartServer) {
+                    // Cache this host
+                    GitRemoteResolver._canShallow.set(this._host, true);
+                }
+
+                return isSmartServer;
+            }.bind(this)
+        );
+    } else {
+        // One of the following cases:
+        // * A non-HTTP/HTTPS protocol
+        // * A host that has been checked before and that supports shallow cloning
+        return Q.resolve(true);
+    }
+
+    return value;
+};
+
 // ------------------------------
 
 // Grab refs remotely
-GitRemoteResolver.refs = function (source) {
+GitRemoteResolver.refs = function(source) {
     var value;
 
     // TODO: Normalize source because of the various available protocols?
@@ -170,20 +297,22 @@ GitRemoteResolver.refs = function (source) {
     }
 
     // Store the promise in the refs object
-    value = cmd('git', ['ls-remote', '--tags', '--heads', source])
-    .spread(function (stdout) {
-        var refs;
+    value = cmd('git', ['ls-remote', '--tags', '--heads', source]).spread(
+        function(stdout) {
+            var refs;
 
-        refs = stdout.toString()
-        .trim()                         // Trim trailing and leading spaces
-        .replace(/[\t ]+/g, ' ')        // Standardize spaces (some git versions make tabs, other spaces)
-        .split(/[\r\n]+/);              // Split lines into an array
+            refs = stdout
+                .toString()
+                .trim() // Trim trailing and leading spaces
+                .replace(/[\t ]+/g, ' ') // Standardize spaces (some git versions make tabs, other spaces)
+                .split(/[\r\n]+/); // Split lines into an array
 
-        // Update the refs with the actual refs
-        this._cache.refs.set(source, refs);
+            // Update the refs with the actual refs
+            this._cache.refs.set(source, refs);
 
-        return refs;
-    }.bind(this));
+            return refs;
+        }.bind(this)
+    );
 
     // Store the promise to be reused until it resolves
     // to a specific value
@@ -195,4 +324,7 @@ GitRemoteResolver.refs = function (source) {
 // Store hosts that do not support shallow clones here
 GitRemoteResolver._noShallow = new LRU({ max: 50, maxAge: 5 * 60 * 1000 });
 
+// Store hosts that support shallow clones here
+GitRemoteResolver._canShallow = new LRU({ max: 50, maxAge: 5 * 60 * 1000 });
+
 module.exports = GitRemoteResolver;

lib/core/resolvers/GitResolver.js

@@ -1,8 +1,7 @@
 var util = require('util');
 var path = require('path');
 var Q = require('q');
-var chmodr = require('chmodr');
-var rimraf = require('rimraf');
+var rimraf = require('../../util/rimraf');
 var mkdirp = require('mkdirp');
 var which = require('which');
 var LRU = require('lru-cache');
@@ -10,7 +9,6 @@ var mout = require('mout');
 var Resolver = require('./Resolver');
 var semver = require('../../util/semver');
 var createError = require('../../util/createError');
-var defaultConfig = require('../../config');
 
 var hasGit;
 
@@ -22,13 +20,25 @@ try {
     hasGit = false;
 }
 
-// Set template dir to the empty directory so that user templates are not run
-// This environment variable is not multiple config aware but it's not documented
-// anyway
-mkdirp.sync(defaultConfig.storage.empty);
-process.env.GIT_TEMPLATE_DIR = defaultConfig.storage.empty;
-
 function GitResolver(decEndpoint, config, logger) {
+    // Set template dir to the empty directory so that user templates are not run
+    // This environment variable is not multiple config aware but it's not documented
+    // anyway
+    mkdirp.sync(config.storage.empty);
+    process.env.GIT_TEMPLATE_DIR = config.storage.empty;
+
+    if (!config.strictSsl) {
+        process.env.GIT_SSL_NO_VERIFY = 'true';
+    }
+
+    if (!config.interactive) {
+        process.env.GIT_TERMINAL_PROMPT = '0';
+
+        if (!process.env.SSH_ASKPASS) {
+            process.env.SSH_ASKPASS = 'echo';
+        }
+    }
+
     Resolver.call(this, decEndpoint, config, logger);
 
     if (!hasGit) {
@@ -41,18 +51,20 @@ mout.object.mixIn(GitResolver, Resolver);
 
 // -----------------
 
-GitResolver.prototype._hasNew = function (canonicalDir, pkgMeta) {
+GitResolver.prototype._hasNew = function(pkgMeta) {
     var oldResolution = pkgMeta._resolution || {};
 
-    return this._findResolution()
-    .then(function (resolution) {
+    return this._findResolution().then(function(resolution) {
         // Check if resolution types are different
         if (oldResolution.type !== resolution.type) {
             return true;
         }
 
         // If resolved to a version, there is new content if the tags are not equal
-        if (resolution.type === 'version' && semver.neq(resolution.tag, oldResolution.tag)) {
+        if (
+            resolution.type === 'version' &&
+            semver.neq(resolution.tag, oldResolution.tag)
+        ) {
             return true;
         }
 
@@ -61,35 +73,37 @@ GitResolver.prototype._hasNew = function (canonicalDir, pkgMeta) {
     });
 };
 
-GitResolver.prototype._resolve = function () {
+GitResolver.prototype._resolve = function() {
     var that = this;
 
-    return this._findResolution()
-    .then(function () {
-        return that._checkout()
-        // Always run cleanup after checkout to ensure that .git is removed!
-        // If it's not removed, problems might arise when the "tmp" module attempts
-        // to delete the temporary folder
-        .fin(function () {
-            return that._cleanup();
-        });
+    return this._findResolution().then(function() {
+        return (
+            that
+                ._checkout()
+                // Always run cleanup after checkout to ensure that .git is removed!
+                // If it's not removed, problems might arise when the "tmp" module attempts
+                // to delete the temporary folder
+                .fin(function() {
+                    return that._cleanup();
+                })
+        );
     });
 };
 
 // -----------------
 
 // Abstract functions that should be implemented by concrete git resolvers
-GitResolver.prototype._checkout = function () {
+GitResolver.prototype._checkout = function() {
     throw new Error('_checkout not implemented');
 };
 
-GitResolver.refs = function (source) {
+GitResolver.refs = function(source) {
     throw new Error('refs not implemented');
 };
 
 // -----------------
 
-GitResolver.prototype._findResolution = function (target) {
+GitResolver.prototype._findResolution = function(target) {
     var err;
     var self = this.constructor;
     var that = this;
@@ -98,20 +112,15 @@ GitResolver.prototype._findResolution = function (target) {
 
     // Target is a commit, so it's a stale target (not a moving target)
     // There's nothing to do in this case
-    if ((/^[a-f0-9]{40}$/).test(target)) {
+    if (/^[a-f0-9]{40}$/.test(target)) {
         this._resolution = { type: 'commit', commit: target };
         return Q.resolve(this._resolution);
     }
 
     // Target is a range/version
     if (semver.validRange(target)) {
-        return self.versions(this._source, true)
-        .then(function (versions) {
-            var versionsArr,
-                version,
-                index;
-
-            versionsArr = versions.map(function (obj) { return obj.version; });
+        return self.versions(this._source, true).then(function(versions) {
+            var versionsArr, version, index;
 
             // If there are no tags and target is *,
             // fallback to the latest commit on master
@@ -119,102 +128,143 @@ GitResolver.prototype._findResolution = function (target) {
                 return that._findResolution('master');
             }
 
-            versionsArr = versions.map(function (obj) { return obj.version; });
+            versionsArr = versions.map(function(obj) {
+                return obj.version;
+            });
             // Find a satisfying version, enabling strict match so that pre-releases
             // have lower priority over normal ones when target is *
             index = semver.maxSatisfyingIndex(versionsArr, target, true);
             if (index !== -1) {
                 version = versions[index];
-                return that._resolution = { type: 'version', tag: version.tag, commit: version.commit };
+                return (that._resolution = {
+                    type: 'version',
+                    tag: version.tag,
+                    commit: version.commit
+                });
             }
 
             // Check if there's an exact branch/tag with this name as last resort
             return Q.all([
                 self.branches(that._source),
                 self.tags(that._source)
-            ])
-            .spread(function (branches, tags) {
+            ]).spread(function(branches, tags) {
                 // Use hasOwn because a branch/tag could have a name like "hasOwnProperty"
                 if (mout.object.hasOwn(tags, target)) {
-                    return that._resolution = { type: 'tag', tag: target, commit: tags[target] };
+                    return (that._resolution = {
+                        type: 'tag',
+                        tag: target,
+                        commit: tags[target]
+                    });
                 }
                 if (mout.object.hasOwn(branches, target)) {
-                    return that._resolution = { type: 'branch', branch: target, commit: branches[target] };
+                    return (that._resolution = {
+                        type: 'branch',
+                        branch: target,
+                        commit: branches[target]
+                    });
                 }
 
-                throw createError('No tag found that was able to satisfy ' + target, 'ENORESTARGET', {
-                    details: !versions.length ?
-                        'No versions found in ' + that._source :
-                        'Available versions: ' + versions.map(function (version) { return version.version; }).join(', ')
-                });
+                throw createError(
+                    'No tag found that was able to satisfy ' + target,
+                    'ENORESTARGET',
+                    {
+                        details: !versions.length
+                            ? 'No versions found in ' + that._source
+                            : 'Available versions in ' +
+                              that._source +
+                              ': ' +
+                              versions
+                                  .map(function(version) {
+                                      return version.version;
+                                  })
+                                  .join(', ')
+                    }
+                );
             });
         });
     }
 
     // Otherwise, target is either a tag or a branch
-    return Q.all([
-        self.branches(that._source),
-        self.tags(that._source)
-    ])
-    .spread(function (branches, tags) {
-        // Use hasOwn because a branch/tag could have a name like "hasOwnProperty"
-        if (mout.object.hasOwn(tags, target)) {
-            return that._resolution = { type: 'tag', tag: target, commit: tags[target] };
+    return Q.all([self.branches(that._source), self.tags(that._source)]).spread(
+        function(branches, tags) {
+            // Use hasOwn because a branch/tag could have a name like "hasOwnProperty"
+            if (mout.object.hasOwn(tags, target)) {
+                return (that._resolution = {
+                    type: 'tag',
+                    tag: target,
+                    commit: tags[target]
+                });
+            }
+            if (mout.object.hasOwn(branches, target)) {
+                return (that._resolution = {
+                    type: 'branch',
+                    branch: target,
+                    commit: branches[target]
+                });
+            }
+
+            if (/^[a-f0-9]{4,40}$/.test(target)) {
+                if (target.length < 12) {
+                    that._logger.warn(
+                        'short-sha',
+                        'Consider using longer commit SHA to avoid conflicts'
+                    );
+                }
+
+                that._resolution = { type: 'commit', commit: target };
+                return that._resolution;
+            }
+
+            branches = Object.keys(branches);
+            tags = Object.keys(tags);
+
+            err = createError(
+                'Tag/branch ' + target + ' does not exist',
+                'ENORESTARGET'
+            );
+            err.details = !tags.length
+                ? 'No tags found in ' + that._source
+                : 'Available tags: ' + tags.join(', ');
+            err.details += '\n';
+            err.details += !branches.length
+                ? 'No branches found in ' + that._source
+                : 'Available branches: ' + branches.join(', ');
+
+            throw err;
         }
-        if (mout.object.hasOwn(branches, target)) {
-            return that._resolution = { type: 'branch', branch: target, commit: branches[target] };
-        }
-
-        branches = Object.keys(branches);
-        tags = Object.keys(tags);
-
-        err = createError('Tag/branch ' + target + ' does not exist', 'ENORESTARGET');
-        err.details = !tags.length ?
-                'No tags found in ' + that._source :
-                'Available tags: ' + tags.join(', ');
-        err.details += '\n';
-        err.details += !branches.length ?
-                'No branches found in ' + that._source :
-                'Available branches: ' + branches.join(', ');
-
-        throw err;
-    });
+    );
 };
 
-GitResolver.prototype._cleanup = function () {
+GitResolver.prototype._cleanup = function() {
     var gitFolder = path.join(this._tempDir, '.git');
 
-    // Remove the .git folder
-    // Note that on windows, we need to chmod to 0777 before due to a bug in git
-    // See: https://github.com/isaacs/rimraf/issues/19
-    if (process.platform === 'win32') {
-        return Q.nfcall(chmodr, gitFolder, 0777)
-        .then(function () {
-            return Q.nfcall(rimraf, gitFolder);
-        }, function (err) {
-            // If .git does not exist, chmodr returns ENOENT
-            // so, we ignore that error code
-            if (err.code !== 'ENOENT') {
-                throw err;
-            }
-        });
-    } else {
-        return Q.nfcall(rimraf, gitFolder);
-    }
+    return Q.nfcall(rimraf, gitFolder);
 };
 
-GitResolver.prototype._savePkgMeta = function (meta) {
+GitResolver.prototype._savePkgMeta = function(meta) {
     var version;
 
     if (this._resolution.type === 'version') {
         version = semver.clean(this._resolution.tag);
 
         // Warn if the package meta version is different than the resolved one
-        if (typeof meta.version === 'string' && semver.neq(meta.version, version)) {
-            this._logger.warn('mismatch', 'Version declared in the json (' + meta.version + ') is different than the resolved one (' + version + ')', {
-                resolution: this._resolution,
-                pkgMeta: meta
-            });
+        if (
+            typeof meta.version === 'string' &&
+            semver.valid(meta.version) &&
+            semver.neq(meta.version, version)
+        ) {
+            this._logger.warn(
+                'mismatch',
+                'Version declared in the json (' +
+                    meta.version +
+                    ') is different than the resolved one (' +
+                    version +
+                    ')',
+                {
+                    resolution: this._resolution,
+                    pkgMeta: meta
+                }
+            );
         }
 
         // Ensure package meta version is the same as the resolution
@@ -228,9 +278,10 @@ GitResolver.prototype._savePkgMeta = function (meta) {
     // Save version/tag/commit in the release
     // Note that we can't store branches because _release is supposed to be
     // an unique id of this ref.
-    meta._release = version ||
-                    this._resolution.tag ||
-                    this._resolution.commit.substr(0, 10);
+    meta._release =
+        version ||
+        this._resolution.tag ||
+        this._resolution.commit.substr(0, 10);
 
     // Save resolution to be used in hasNew later
     meta._resolution = this._resolution;
@@ -240,51 +291,56 @@ GitResolver.prototype._savePkgMeta = function (meta) {
 
 // ------------------------------
 
-GitResolver.versions = function (source, extra) {
+GitResolver.versions = function(source, extra) {
     var value = this._cache.versions.get(source);
 
     if (value) {
-        return Q.resolve(value)
-        .then(function () {
-            var versions = this._cache.versions.get(source);
+        return Q.resolve(value).then(
+            function() {
+                var versions = this._cache.versions.get(source);
 
-            // If no extra information was requested,
-            // resolve simply with the versions
-            if (!extra) {
-                versions = versions.map(function (version) {
-                    return version.version;
-                });
-            }
+                // If no extra information was requested,
+                // resolve simply with the versions
+                if (!extra) {
+                    versions = versions.map(function(version) {
+                        return version.version;
+                    });
+                }
 
-            return versions;
-        }.bind(this));
+                return versions;
+            }.bind(this)
+        );
     }
 
-    value = this.tags(source)
-    .then(function (tags) {
-        var tag;
-        var version;
-        var versions = [];
+    value = this.tags(source).then(
+        function(tags) {
+            var tag;
+            var version;
+            var versions = [];
 
-        // For each tag
-        for (tag in tags) {
-            version = semver.clean(tag);
-            if (version) {
-                versions.push({ version: version, tag: tag, commit: tags[tag] });
+            // For each tag
+            for (tag in tags) {
+                version = semver.clean(tag);
+                if (version) {
+                    versions.push({
+                        version: version,
+                        tag: tag,
+                        commit: tags[tag]
+                    });
+                }
             }
-        }
 
-        // Sort them by DESC order
-        versions.sort(function (a, b) {
-            return semver.rcompare(a.version, b.version);
-        });
+            // Sort them by DESC order
+            versions.sort(function(a, b) {
+                return semver.rcompare(a.version, b.version);
+            });
 
-        this._cache.versions.set(source, versions);
-
-        // Call the function again to keep it DRY
-        return this.versions(source, extra);
-    }.bind(this));
+            this._cache.versions.set(source, versions);
 
+            // Call the function again to keep it DRY
+            return this.versions(source, extra);
+        }.bind(this)
+    );
 
     // Store the promise to be reused until it resolves
     // to a specific value
@@ -293,30 +349,31 @@ GitResolver.versions = function (source, extra) {
     return value;
 };
 
-GitResolver.tags = function (source) {
+GitResolver.tags = function(source) {
     var value = this._cache.tags.get(source);
 
     if (value) {
         return Q.resolve(value);
     }
 
-    value = this.refs(source)
-    .then(function (refs) {
-        var tags = {};
+    value = this.refs(source).then(
+        function(refs) {
+            var tags = {};
 
-        // For each line in the refs, match only the tags
-        refs.forEach(function (line) {
-            var match = line.match(/^([a-f0-9]{40})\s+refs\/tags\/(\S+)/);
+            // For each line in the refs, match only the tags
+            refs.forEach(function(line) {
+                var match = line.match(/^([a-f0-9]{40})\s+refs\/tags\/(\S+)/);
 
-            if (match && !mout.string.endsWith(match[2], '^{}')) {
-                tags[match[2]] = match[1];
-            }
-        });
+                if (match && !mout.string.endsWith(match[2], '^{}')) {
+                    tags[match[2]] = match[1];
+                }
+            });
 
-        this._cache.tags.set(source, tags);
+            this._cache.tags.set(source, tags);
 
-        return tags;
-    }.bind(this));
+            return tags;
+        }.bind(this)
+    );
 
     // Store the promise to be reused until it resolves
     // to a specific value
@@ -325,32 +382,33 @@ GitResolver.tags = function (source) {
     return value;
 };
 
-GitResolver.branches = function (source) {
+GitResolver.branches = function(source) {
     var value = this._cache.branches.get(source);
 
     if (value) {
         return Q.resolve(value);
     }
 
-    value = this.refs(source)
-    .then(function (refs) {
-        var branches = {};
+    value = this.refs(source).then(
+        function(refs) {
+            var branches = {};
 
-        // For each line in the refs, extract only the heads
-        // Organize them in an object where keys are branches and values
-        // the commit hashes
-        refs.forEach(function (line) {
-            var match = line.match(/^([a-f0-9]{40})\s+refs\/heads\/(\S+)/);
+            // For each line in the refs, extract only the heads
+            // Organize them in an object where keys are branches and values
+            // the commit hashes
+            refs.forEach(function(line) {
+                var match = line.match(/^([a-f0-9]{40})\s+refs\/heads\/(\S+)/);
 
-            if (match) {
-                branches[match[2]] = match[1];
-            }
-        });
+                if (match) {
+                    branches[match[2]] = match[1];
+                }
+            });
 
-        this._cache.branches.set(source, branches);
+            this._cache.branches.set(source, branches);
 
-        return branches;
-    }.bind(this));
+            return branches;
+        }.bind(this)
+    );
 
     // Store the promise to be reused until it resolves
     // to a specific value
@@ -359,9 +417,9 @@ GitResolver.branches = function (source) {
     return value;
 };
 
-GitResolver.clearRuntimeCache = function () {
+GitResolver.clearRuntimeCache = function() {
     // Reset cache for branches, tags, etc
-    mout.object.forOwn(GitResolver._cache, function (lru) {
+    mout.object.forOwn(GitResolver._cache, function(lru) {
         lru.reset();
     });
 };

lib/core/resolvers/Resolver.js

@@ -1,12 +1,13 @@
-var fs = require('graceful-fs');
+var fs = require('../../util/fs');
 var path = require('path');
 var Q = require('q');
 var tmp = require('tmp');
 var mkdirp = require('mkdirp');
-var rimraf = require('rimraf');
+var rimraf = require('../../util/rimraf');
 var readJson = require('../../util/readJson');
 var createError = require('../../util/createError');
 var removeIgnores = require('../../util/removeIgnores');
+var md5 = require('md5-hex');
 
 tmp.setGracefulCleanup();
 
@@ -23,29 +24,28 @@ function Resolver(decEndpoint, config, logger) {
 
 // -----------------
 
-Resolver.prototype.getSource = function () {
+Resolver.prototype.getSource = function() {
     return this._source;
 };
 
-Resolver.prototype.getName = function () {
+Resolver.prototype.getName = function() {
     return this._name;
 };
 
-Resolver.prototype.getTarget = function () {
+Resolver.prototype.getTarget = function() {
     return this._target;
 };
 
-Resolver.prototype.getTempDir = function () {
+Resolver.prototype.getTempDir = function() {
     return this._tempDir;
 };
 
-Resolver.prototype.getPkgMeta = function () {
+Resolver.prototype.getPkgMeta = function() {
     return this._pkgMeta;
 };
 
-Resolver.prototype.hasNew = function (canonicalDir, pkgMeta) {
+Resolver.prototype.hasNew = function(pkgMeta) {
     var promise;
-    var metaFile;
     var that = this;
 
     // If already working, error out
@@ -56,31 +56,14 @@ Resolver.prototype.hasNew = function (canonicalDir, pkgMeta) {
     this._working = true;
 
     // Avoid reading the package meta if already given
-    if (pkgMeta) {
-        promise = this._hasNew(canonicalDir, pkgMeta);
-    // Otherwise call _hasNew with both the package meta and the canonical dir
-    } else {
-        metaFile = path.join(canonicalDir, '.bower.json');
+    promise = this._hasNew(pkgMeta);
 
-        promise = readJson(metaFile)
-        .spread(function (pkgMeta) {
-            return that._hasNew(canonicalDir, pkgMeta);
-        }, function (err) {
-            that._logger.debug('read-json', 'Failed to read ' + metaFile, {
-                filename: metaFile,
-                error: err
-            });
-
-            return true;  // Simply resolve to true if there was an error reading the file
-        });
-    }
-
-    return promise.fin(function () {
+    return promise.fin(function() {
         that._working = false;
     });
 };
 
-Resolver.prototype.resolve = function () {
+Resolver.prototype.resolve = function() {
     var that = this;
 
     // If already working, error out
@@ -91,70 +74,104 @@ Resolver.prototype.resolve = function () {
     this._working = true;
 
     // Create temporary dir
-    return this._createTempDir()
-    // Resolve self
-    .then(this._resolve.bind(this))
-    // Read json, generating the package meta
-    .then(this._readJson.bind(this, null))
-    // Apply and save package meta
-    .then(function (meta) {
-        return that._applyPkgMeta(meta)
-        .then(that._savePkgMeta.bind(that, meta));
-    })
-    .then(function () {
-        // Resolve with the folder
-        return that._tempDir;
-    }, function (err) {
-        // If something went wrong, unset the temporary dir
-        that._tempDir = null;
-        throw err;
-    })
-    .fin(function () {
-        that._working = false;
-    });
+    return (
+        this._createTempDir()
+            // Resolve self
+            .then(this._resolve.bind(this))
+            // Read json, generating the package meta
+            .then(this._readJson.bind(this, null))
+            // Apply and save package meta
+            .then(function(meta) {
+                return that
+                    ._applyPkgMeta(meta)
+                    .then(that._savePkgMeta.bind(that, meta));
+            })
+            .then(
+                function() {
+                    // Resolve with the folder
+                    return that._tempDir;
+                },
+                function(err) {
+                    // If something went wrong, unset the temporary dir
+                    that._tempDir = null;
+                    throw err;
+                }
+            )
+            .fin(function() {
+                that._working = false;
+            })
+    );
+};
+
+Resolver.prototype.isCacheable = function() {
+    // Bypass cache for local dependencies
+    if (
+        this._source &&
+        /^(?:file:[\/\\]{2}|[A-Z]:)?\.?\.?[\/\\]/.test(this._source)
+    ) {
+        return false;
+    }
+
+    // We don't want to cache moving targets like branches
+    if (
+        this._pkgMeta &&
+        this._pkgMeta._resolution &&
+        this._pkgMeta._resolution.type === 'branch'
+    ) {
+        return false;
+    }
+
+    return true;
 };
 
 // -----------------
 
 // Abstract functions that must be implemented by concrete resolvers
-Resolver.prototype._resolve = function () {
+Resolver.prototype._resolve = function() {
     throw new Error('_resolve not implemented');
 };
 
 // Abstract functions that can be re-implemented by concrete resolvers
 // as necessary
-Resolver.prototype._hasNew = function (canonicalDir, pkgMeta) {
+Resolver.prototype._hasNew = function(pkgMeta) {
     return Q.resolve(true);
 };
 
-Resolver.isTargetable = function () {
+Resolver.isTargetable = function() {
     return true;
 };
 
-Resolver.versions = function (source) {
+Resolver.versions = function(source) {
     return Q.resolve([]);
 };
 
-Resolver.clearRuntimeCache = function () {};
+Resolver.clearRuntimeCache = function() {};
 
 // -----------------
 
-Resolver.prototype._createTempDir = function () {
+Resolver.prototype._createTempDir = function() {
     return Q.nfcall(mkdirp, this._config.tmp)
-    .then(function () {
-        return Q.nfcall(tmp.dir, {
-            template: path.join(this._config.tmp, this._name + '-' + process.pid + '-XXXXXX'),
-            mode: 0777 & ~process.umask(),
-            unsafeCleanup: true
-        });
-    }.bind(this))
-    .then(function (dir) {
-        this._tempDir = dir;
-        return dir;
-    }.bind(this));
+        .then(
+            function() {
+                return Q.nfcall(tmp.dir, {
+                    template: path.join(
+                        this._config.tmp,
+                        md5(this._name) + '-' + process.pid + '-XXXXXX'
+                    ),
+                    mode: 0777 & ~process.umask(),
+                    unsafeCleanup: true
+                });
+            }.bind(this)
+        )
+        .then(
+            function(dir) {
+                // nfcall may return multiple callback arguments as an array
+                return (this._tempDir = Array.isArray(dir) ? dir[0] : dir);
+            }.bind(this)
+        );
 };
 
-Resolver.prototype._cleanTempDir = function () {
+Resolver.prototype._cleanTempDir = function() {
     var tempDir = this._tempDir;
 
     if (!tempDir) {
@@ -163,31 +180,37 @@ Resolver.prototype._cleanTempDir = function () {
 
     // Delete and create folder
     return Q.nfcall(rimraf, tempDir)
-    .then(function () {
-        return Q.nfcall(mkdirp, tempDir, 0777 & ~process.umask());
-    })
-    .then(function () {
-        return tempDir;
-    });
+        .then(function() {
+            return Q.nfcall(mkdirp, tempDir, 0777 & ~process.umask());
+        })
+        .then(function() {
+            return tempDir;
+        });
 };
 
-Resolver.prototype._readJson = function (dir) {
+Resolver.prototype._readJson = function(dir) {
     var that = this;
 
     dir = dir || this._tempDir;
     return readJson(dir, {
-        assume: { name: this._name }
-    })
-    .spread(function (json, deprecated) {
+        assume: { name: this._name },
+        logger: that._logger
+    }).spread(function(json, deprecated) {
         if (deprecated) {
-            that._logger.warn('deprecated', 'Package ' + that._name + ' is using the deprecated ' + deprecated);
+            that._logger.warn(
+                'deprecated',
+                'Package ' +
+                    that._name +
+                    ' is using the deprecated ' +
+                    deprecated
+            );
         }
 
         return json;
     });
 };
 
-Resolver.prototype._applyPkgMeta = function (meta) {
+Resolver.prototype._applyPkgMeta = function(meta) {
     // Check if name defined in the json is different
     // If so and if the name was "guessed", assume the json name
     if (meta.name !== this._name && this._guessedName) {
@@ -201,13 +224,13 @@ Resolver.prototype._applyPkgMeta = function (meta) {
     }
 
     // Otherwise remove them from the temp dir
-    return removeIgnores(this._tempDir, meta.ignore)
-    .then(function () {
+    return removeIgnores(this._tempDir, meta).then(function() {
         return meta;
     });
 };
 
-Resolver.prototype._savePkgMeta = function (meta) {
+Resolver.prototype._savePkgMeta = function(meta) {
+    var that = this;
     var contents;
 
     // Store original source & target
@@ -217,10 +240,13 @@ Resolver.prototype._savePkgMeta = function (meta) {
     // Stringify contents
     contents = JSON.stringify(meta, null, 2);
 
-    return Q.nfcall(fs.writeFile, path.join(this._tempDir, '.bower.json'), contents)
-    .then(function () {
-        return this._pkgMeta = meta;
-    }.bind(this));
+    return Q.nfcall(
+        fs.writeFile,
+        path.join(this._tempDir, '.bower.json'),
+        contents
+    ).then(function() {
+        return (that._pkgMeta = meta);
+    });
 };
 
 module.exports = Resolver;

lib/core/resolvers/SvnResolver.js

@@ -1,7 +1,5 @@
 var util = require('util');
-var path = require('path');
 var Q = require('q');
-var rimraf = require('rimraf');
 var which = require('which');
 var LRU = require('lru-cache');
 var mout = require('mout');
@@ -33,27 +31,29 @@ mout.object.mixIn(SvnResolver, Resolver);
 
 // -----------------
 
-SvnResolver.getSource = function (source) {
+SvnResolver.getSource = function(source) {
     var uri = this._source || source;
 
     return uri
-        .replace(/^svn\+(https?|file):\/\//i, '$1://')  // Change svn+http or svn+https or svn+file to http(s), file respectively
-        .replace('svn://', 'http://')  // Change svn to http
-        .replace(/\/+$/, '');  // Remove trailing slashes
+        .replace(/^svn\+(https?|file):\/\//i, '$1://') // Change svn+http or svn+https or svn+file to http(s), file respectively
+        .replace('svn://', 'http://') // Change svn to http
+        .replace(/\/+$/, ''); // Remove trailing slashes
 };
 
-SvnResolver.prototype._hasNew = function (canonicalDir, pkgMeta) {
+SvnResolver.prototype._hasNew = function(pkgMeta) {
     var oldResolution = pkgMeta._resolution || {};
 
-    return this._findResolution()
-    .then(function (resolution) {
+    return this._findResolution().then(function(resolution) {
         // Check if resolution types are different
         if (oldResolution.type !== resolution.type) {
             return true;
         }
 
         // If resolved to a version, there is new content if the tags are not equal
-        if (resolution.type === 'version' && semver.neq(resolution.tag, oldResolution.tag)) {
+        if (
+            resolution.type === 'version' &&
+            semver.neq(resolution.tag, oldResolution.tag)
+        ) {
             return true;
         }
 
@@ -62,24 +62,17 @@ SvnResolver.prototype._hasNew = function (canonicalDir, pkgMeta) {
     });
 };
 
-SvnResolver.prototype._resolve = function () {
+SvnResolver.prototype._resolve = function() {
     var that = this;
 
-    return this._findResolution()
-    .then(function () {
-        return that._checkout()
-        // Always run cleanup after checkout to ensure that .svn is removed!
-        // If it's not removed, problems might arise when the "tmp" module attempts
-        // to delete the temporary folder
-        .fin(function () {
-            return that._cleanup();
-        });
+    return this._findResolution().then(function() {
+        return that._export();
     });
 };
 
 // -----------------
 
-SvnResolver.prototype._checkout = function () {
+SvnResolver.prototype._export = function() {
     var promise;
     var timer;
     var reporter;
@@ -88,27 +81,56 @@ SvnResolver.prototype._checkout = function () {
 
     this.source = SvnResolver.getSource(this._source);
 
-    this._logger.action('checkout', resolution.tag || resolution.branch || resolution.commit, {
-        resolution: resolution,
-        to: this._tempDir
-    });
+    this._logger.action(
+        'export',
+        resolution.tag || resolution.branch || resolution.commit,
+        {
+            resolution: resolution,
+            to: this._tempDir
+        }
+    );
 
     if (resolution.type === 'commit') {
-        promise = cmd('svn', ['checkout', this._source + '/trunk', '-r' + resolution.commit, this._tempDir]);
+        promise = cmd('svn', [
+            'export',
+            '--force',
+            '--non-interactive',
+            this._source + '/trunk',
+            '-r' + resolution.commit,
+            this._tempDir
+        ]);
     } else if (resolution.type === 'branch' && resolution.branch === 'trunk') {
-        promise = cmd('svn', ['checkout', this._source + '/trunk', this._tempDir]);
+        promise = cmd('svn', [
+            'export',
+            '--force',
+            '--non-interactive',
+            this._source + '/trunk',
+            this._tempDir
+        ]);
     } else if (resolution.type === 'branch') {
-        promise = cmd('svn', ['checkout', this._source + '/branches/' + resolution.branch, this._tempDir]);
+        promise = cmd('svn', [
+            'export',
+            '--force',
+            '--non-interactive',
+            this._source + '/branches/' + resolution.branch,
+            this._tempDir
+        ]);
     } else {
-        promise = cmd('svn', ['checkout', this._source + '/tags/' + resolution.tag, this._tempDir]);
+        promise = cmd('svn', [
+            'export',
+            '--force',
+            '--non-interactive',
+            this._source + '/tags/' + resolution.tag,
+            this._tempDir
+        ]);
     }
 
     // Throttle the progress reporter to 1 time each sec
-    reporter = mout.fn.throttle(function (data) {
+    reporter = mout.fn.throttle(function(data) {
         var lines;
 
         lines = data.split(/[\r\n]+/);
-        lines.forEach(function (line) {
+        lines.forEach(function(line) {
             if (/\d{1,3}\%/.test(line)) {
                 // TODO: There are some strange chars that appear once in a while (\u001b[K)
                 //       Trim also those?
@@ -118,25 +140,27 @@ SvnResolver.prototype._checkout = function () {
     }, 1000);
 
     // Start reporting progress after a few seconds
-    timer = setTimeout(function () {
+    timer = setTimeout(function() {
         promise.progress(reporter);
     }, 8000);
 
-    return promise
-    // Add additional proxy information to the error if necessary
-    .fail(function (err) {
-        throw err;
-    })
-    // Clear timer at the end
-    .fin(function () {
-        clearTimeout(timer);
-        reporter.cancel();
-    });
+    return (
+        promise
+            // Add additional proxy information to the error if necessary
+            .fail(function(err) {
+                throw err;
+            })
+            // Clear timer at the end
+            .fin(function() {
+                clearTimeout(timer);
+                reporter.cancel();
+            })
+    );
 };
 
 // -----------------
 
-SvnResolver.prototype._findResolution = function (target) {
+SvnResolver.prototype._findResolution = function(target) {
     var err;
     var self = this.constructor;
     var that = this;
@@ -147,7 +171,7 @@ SvnResolver.prototype._findResolution = function (target) {
 
     // Target is a revision, so it's a stale target (not a moving target)
     // There's nothing to do in this case
-    if ((/^r\d+/).test(target)) {
+    if (/^r\d+/.test(target)) {
         target = target.split('r');
 
         this._resolution = { type: 'commit', commit: target[1] };
@@ -156,13 +180,12 @@ SvnResolver.prototype._findResolution = function (target) {
 
     // Target is a range/version
     if (semver.validRange(target)) {
-        return self.versions(this._source, true)
-        .then(function (versions) {
-            var versionsArr,
-                version,
-                index;
+        return self.versions(this._source, true).then(function(versions) {
+            var versionsArr, version, index;
 
-            versionsArr = versions.map(function (obj) { return obj.version; });
+            versionsArr = versions.map(function(obj) {
+                return obj.version;
+            });
 
             // If there are no tags and target is *,
             // fallback to the latest commit on trunk
@@ -170,86 +193,124 @@ SvnResolver.prototype._findResolution = function (target) {
                 return that._findResolution('trunk');
             }
 
-            versionsArr = versions.map(function (obj) { return obj.version; });
+            versionsArr = versions.map(function(obj) {
+                return obj.version;
+            });
             // Find a satisfying version, enabling strict match so that pre-releases
             // have lower priority over normal ones when target is *
             index = semver.maxSatisfyingIndex(versionsArr, target, true);
             if (index !== -1) {
                 version = versions[index];
-                return that._resolution = { type: 'version', tag: version.tag, commit: version.commit };
+                return (that._resolution = {
+                    type: 'version',
+                    tag: version.tag,
+                    commit: version.commit
+                });
             }
 
             // Check if there's an exact branch/tag with this name as last resort
             return Q.all([
                 self.branches(that._source),
                 self.tags(that._source)
-            ])
-            .spread(function (branches, tags) {
+            ]).spread(function(branches, tags) {
                 // Use hasOwn because a branch/tag could have a name like "hasOwnProperty"
                 if (mout.object.hasOwn(tags, target)) {
-                    return that._resolution = { type: 'tag', tag: target, commit: tags[target] };
+                    return (that._resolution = {
+                        type: 'tag',
+                        tag: target,
+                        commit: tags[target]
+                    });
                 }
                 if (mout.object.hasOwn(branches, target)) {
-                    return that._resolution = { type: 'branch', branch: target, commit: branches[target] };
+                    return (that._resolution = {
+                        type: 'branch',
+                        branch: target,
+                        commit: branches[target]
+                    });
                 }
 
-                throw createError('No tag found that was able to satisfy ' + target, 'ENORESTARGET', {
-                    details: !versions.length ?
-                        'No versions found in ' + that._source :
-                        'Available versions: ' + versions.map(function (version) { return version.version; }).join(', ')
-                });
+                throw createError(
+                    'No tag found that was able to satisfy ' + target,
+                    'ENORESTARGET',
+                    {
+                        details: !versions.length
+                            ? 'No versions found in ' + that._source
+                            : 'Available versions in ' +
+                              that._source +
+                              ': ' +
+                              versions
+                                  .map(function(version) {
+                                      return version.version;
+                                  })
+                                  .join(', ')
+                    }
+                );
             });
         });
     }
 
     // Otherwise, target is either a tag or a branch
-    return Q.all([
-        self.branches(that._source),
-        self.tags(that._source)
-    ])
-    .spread(function (branches, tags) {
-        // Use hasOwn because a branch/tag could have a name like "hasOwnProperty"
-        if (mout.object.hasOwn(tags, target)) {
-            return that._resolution = { type: 'tag', tag: target, commit: tags[target] };
+    return Q.all([self.branches(that._source), self.tags(that._source)]).spread(
+        function(branches, tags) {
+            // Use hasOwn because a branch/tag could have a name like "hasOwnProperty"
+            if (mout.object.hasOwn(tags, target)) {
+                return (that._resolution = {
+                    type: 'tag',
+                    tag: target,
+                    commit: tags[target]
+                });
+            }
+            if (mout.object.hasOwn(branches, target)) {
+                return (that._resolution = {
+                    type: 'branch',
+                    branch: target,
+                    commit: branches[target]
+                });
+            }
+
+            branches = Object.keys(branches);
+            tags = Object.keys(tags);
+
+            err = createError(
+                'target ' + target + ' does not exist',
+                'ENORESTARGET'
+            );
+            err.details = !tags.length
+                ? 'No tags found in ' + that._source
+                : 'Available tags: ' + tags.join(', ');
+            err.details += '\n';
+            err.details += !branches.length
+                ? 'No branches found in ' + that._source
+                : 'Available branches: ' + branches.join(', ');
+
+            throw err;
         }
-        if (mout.object.hasOwn(branches, target)) {
-            return that._resolution = { type: 'branch', branch: target, commit: branches[target] };
-        }
-
-        branches = Object.keys(branches);
-        tags = Object.keys(tags);
-
-        err = createError('target ' + target + ' does not exist', 'ENORESTARGET');
-        err.details = !tags.length ?
-                'No tags found in ' + that._source :
-                'Available tags: ' + tags.join(', ');
-        err.details += '\n';
-        err.details += !branches.length ?
-                'No branches found in ' + that._source :
-                'Available branches: ' + branches.join(', ');
-
-        throw err;
-    });
+    );
 };
 
-SvnResolver.prototype._cleanup = function () {
-    var svnFolder = path.join(this._tempDir, '.svn');
-
-    return Q.nfcall(rimraf, svnFolder);
-};
-
-SvnResolver.prototype._savePkgMeta = function (meta) {
+SvnResolver.prototype._savePkgMeta = function(meta) {
     var version;
 
     if (this._resolution.type === 'version') {
         version = semver.clean(this._resolution.tag);
 
         // Warn if the package meta version is different than the resolved one
-        if (typeof meta.version === 'string' && semver.neq(meta.version, version)) {
-            this._logger.warn('mismatch', 'Version declared in the json (' + meta.version + ') is different than the resolved one (' + version + ')', {
-                resolution: this._resolution,
-                pkgMeta: meta
-            });
+        if (
+            typeof meta.version === 'string' &&
+            semver.neq(meta.version, version)
+        ) {
+            this._logger.warn(
+                'mismatch',
+                'Version declared in the json (' +
+                    meta.version +
+                    ') is different than the resolved one (' +
+                    version +
+                    ')',
+                {
+                    resolution: this._resolution,
+                    pkgMeta: meta
+                }
+            );
         }
 
         // Ensure package meta version is the same as the resolution
@@ -263,9 +324,7 @@ SvnResolver.prototype._savePkgMeta = function (meta) {
     // Save version/tag/commit in the release
     // Note that we can't store branches because _release is supposed to be
     // an unique id of this ref.
-    meta._release = version ||
-                    this._resolution.tag ||
-                    this._resolution.commit;
+    meta._release = version || this._resolution.tag || this._resolution.commit;
 
     // Save resolution to be used in hasNew later
     meta._resolution = this._resolution;
@@ -275,52 +334,58 @@ SvnResolver.prototype._savePkgMeta = function (meta) {
 
 // ------------------------------
 
-SvnResolver.versions = function (source, extra) {
+SvnResolver.versions = function(source, extra) {
     source = SvnResolver.getSource(source);
 
     var value = this._cache.versions.get(source);
 
     if (value) {
-        return Q.resolve(value)
-        .then(function () {
-            var versions = this._cache.versions.get(source);
+        return Q.resolve(value).then(
+            function() {
+                var versions = this._cache.versions.get(source);
 
-            // If no extra information was requested,
-            // resolve simply with the versions
-            if (!extra) {
-                versions = versions.map(function (version) {
-                    return version.version;
-                });
-            }
+                // If no extra information was requested,
+                // resolve simply with the versions
+                if (!extra) {
+                    versions = versions.map(function(version) {
+                        return version.version;
+                    });
+                }
 
-            return versions;
-        }.bind(this));
+                return versions;
+            }.bind(this)
+        );
     }
 
-    value = this.tags(source)
-    .then(function (tags) {
-        var tag;
-        var version;
-        var versions = [];
+    value = this.tags(source).then(
+        function(tags) {
+            var tag;
+            var version;
+            var versions = [];
 
-        // For each tag
-        for (tag in tags) {
-            version = semver.clean(tag);
-            if (version) {
-                versions.push({ version: version, tag: tag, commit: tags[tag] });
+            // For each tag
+            for (tag in tags) {
+                version = semver.clean(tag);
+                if (version) {
+                    versions.push({
+                        version: version,
+                        tag: tag,
+                        commit: tags[tag]
+                    });
+                }
             }
-        }
 
-        // Sort them by DESC order
-        versions.sort(function (a, b) {
-            return semver.rcompare(a.version, b.version);
-        });
+            // Sort them by DESC order
+            versions.sort(function(a, b) {
+                return semver.rcompare(a.version, b.version);
+            });
 
-        this._cache.versions.set(source, versions);
+            this._cache.versions.set(source, versions);
 
-        // Call the function again to keep it DRY
-        return this.versions(source, extra);
-    }.bind(this));
+            // Call the function again to keep it DRY
+            return this.versions(source, extra);
+        }.bind(this)
+    );
 
     // Store the promise to be reused until it resolves
     // to a specific value
@@ -329,7 +394,7 @@ SvnResolver.versions = function (source, extra) {
     return value;
 };
 
-SvnResolver.tags = function (source) {
+SvnResolver.tags = function(source) {
     source = SvnResolver.getSource(source);
 
     var value = this._cache.tags.get(source);
@@ -338,14 +403,19 @@ SvnResolver.tags = function (source) {
         return Q.resolve(value);
     }
 
-    value = cmd('svn', ['list', source + '/tags', '--verbose'])
-    .spread(function (stout) {
-        var tags = SvnResolver.parseSubversionListOutput(stout.toString());
+    value = cmd('svn', [
+        'list',
+        source + '/tags',
+        '--verbose',
+        '--non-interactive'
+    ]).spread(
+        function(stout) {
+            var tags = SvnResolver.parseSubversionListOutput(stout.toString());
 
-        this._cache.tags.set(source, tags);
-        return tags;
-
-    }.bind(this));
+            this._cache.tags.set(source, tags);
+            return tags;
+        }.bind(this)
+    );
 
     // Store the promise to be reused until it resolves
     // to a specific value
@@ -354,7 +424,7 @@ SvnResolver.tags = function (source) {
     return value;
 };
 
-SvnResolver.branches = function (source) {
+SvnResolver.branches = function(source) {
     source = SvnResolver.getSource(source);
 
     var value = this._cache.branches.get(source);
@@ -363,17 +433,24 @@ SvnResolver.branches = function (source) {
         return Q.resolve(value);
     }
 
-    value = cmd('svn', ['list', source + '/branches', '--verbose'])
-    .spread(function (stout) {
-        var branches = SvnResolver.parseSubversionListOutput(stout.toString());
+    value = cmd('svn', [
+        'list',
+        source + '/branches',
+        '--verbose',
+        '--non-interactive'
+    ]).spread(
+        function(stout) {
+            var branches = SvnResolver.parseSubversionListOutput(
+                stout.toString()
+            );
 
-        // trunk is a branch!
-        branches.trunk = '*';
+            // trunk is a branch!
+            branches.trunk = '*';
 
-        this._cache.branches.set(source, branches);
-        return branches;
-
-    }.bind(this));
+            this._cache.branches.set(source, branches);
+            return branches;
+        }.bind(this)
+    );
 
     // Store the promise to be reused until it resolves
     // to a specific value
@@ -382,15 +459,12 @@ SvnResolver.branches = function (source) {
     return value;
 };
 
-SvnResolver.parseSubversionListOutput = function (stout) {
-
+SvnResolver.parseSubversionListOutput = function(stout) {
     var entries = {};
-    var lines = stout
-        .trim()
-        .split(/[\r\n]+/);
+    var lines = stout.trim().split(/[\r\n]+/);
 
     // For each line in the refs, match only the branches
-    lines.forEach(function (line) {
+    lines.forEach(function(line) {
         var match = line.match(/\s+([0-9]+)\s.+\s([\w.$-]+)\//i);
 
         if (match && match[2] !== '.') {
@@ -401,9 +475,9 @@ SvnResolver.parseSubversionListOutput = function (stout) {
     return entries;
 };
 
-SvnResolver.clearRuntimeCache = function () {
+SvnResolver.clearRuntimeCache = function() {
     // Reset cache for branches, tags, etc
-    mout.object.forOwn(SvnResolver._cache, function (lru) {
+    mout.object.forOwn(SvnResolver._cache, function(lru) {
         lru.reset();
     });
 };

lib/core/resolvers/UrlResolver.js

@@ -1,6 +1,6 @@
 var util = require('util');
 var path = require('path');
-var fs = require('graceful-fs');
+var fs = require('../../util/fs');
 var url = require('url');
 var request = require('request');
 var Q = require('q');
@@ -16,7 +16,7 @@ function UrlResolver(decEndpoint, config, logger) {
 
     // If target was specified, error out
     if (this._target !== '*') {
-        throw createError('URL sources can\'t resolve targets', 'ENORESTARGET');
+        throw createError("URL sources can't resolve targets", 'ENORESTARGET');
     }
 
     // If the name was guessed
@@ -24,7 +24,10 @@ function UrlResolver(decEndpoint, config, logger) {
         // Remove the ?xxx part
         this._name = this._name.replace(/\?.*$/, '');
         // Remove extension
-        this._name = this._name.substr(0, this._name.length - path.extname(this._name).length);
+        this._name = this._name.substr(
+            0,
+            this._name.length - path.extname(this._name).length
+        );
     }
 
     this._remote = url.parse(this._source);
@@ -35,11 +38,11 @@ mout.object.mixIn(UrlResolver, Resolver);
 
 // -----------------
 
-UrlResolver.isTargetable = function () {
+UrlResolver.isTargetable = function() {
     return false;
 };
 
-UrlResolver.prototype._hasNew = function (canonicalDir, pkgMeta) {
+UrlResolver.prototype._hasNew = function(pkgMeta) {
     var oldCacheHeaders = pkgMeta._cacheHeaders || {};
     var reqHeaders = {};
 
@@ -54,58 +57,78 @@ UrlResolver.prototype._hasNew = function (canonicalDir, pkgMeta) {
     }
 
     // Make an HEAD request to the source
-    return Q.nfcall(request.head, this._source, {
-        proxy: this._remote.protocol === 'https:' ? this._config.httpsProxy : this._config.proxy,
-        strictSSL: this._config.strictSsl,
-        timeout: this._config.timeout,
-        headers: reqHeaders
-    })
-    // Compare new headers with the old ones
-    .spread(function (response) {
-        var cacheHeaders;
+    return (
+        Q.nfcall(request.head, this._source, {
+            ca: this._config.ca.default,
+            strictSSL: this._config.strictSsl,
+            timeout: this._config.timeout,
+            headers: reqHeaders
+        })
+            // Compare new headers with the old ones
+            .spread(
+                function(response) {
+                    var cacheHeaders;
 
-        // If the server responded with 303 then the resource
-        // still has the same ETag
-        if (response.statusCode === 304) {
-            return false;
-        }
+                    // If the server responded with 303 then the resource
+                    // still has the same ETag
+                    if (response.statusCode === 304) {
+                        return false;
+                    }
 
-        // If status code is not in the 2xx range,
-        // then just resolve to true
-        if (response.statusCode < 200 || response.statusCode >= 300) {
-            return true;
-        }
+                    // If status code is not in the 2xx range,
+                    // then just resolve to true
+                    if (
+                        response.statusCode < 200 ||
+                        response.statusCode >= 300
+                    ) {
+                        return true;
+                    }
 
-        // Fallback to comparing cache headers
-        cacheHeaders = this._collectCacheHeaders(response);
-        return !mout.object.equals(oldCacheHeaders, cacheHeaders);
-    }.bind(this), function () {
-        // Assume new contents if the request failed
-        // Note that we do not retry the request using the "request-replay" module
-        // because it would take too long
-        return true;
-    });
+                    // Fallback to comparing cache headers
+                    cacheHeaders = this._collectCacheHeaders(response);
+                    return !mout.object.equals(oldCacheHeaders, cacheHeaders);
+                }.bind(this),
+                function() {
+                    // Assume new contents if the request failed
+                    // Note that we do not retry the request using the "request-replay" module
+                    // because it would take too long
+                    return true;
+                }
+            )
+    );
 };
 
 // TODO: There's room for improvement by using streams if the URL
 //       is an archive file, by piping read stream to the zip extractor
 //       This will likely increase the complexity of code but might worth it
 
-UrlResolver.prototype._resolve = function () {
+UrlResolver.prototype._resolve = function() {
     // Download
-    return this._download()
-    // Parse headers
-    .spread(this._parseHeaders.bind(this))
-    // Extract file
-    .spread(this._extract.bind(this))
-    // Rename file to index
-    .then(this._rename.bind(this));
+    return (
+        this._download()
+            // Parse headers
+            .spread(this._parseHeaders.bind(this))
+            // Extract file
+            .spread(this._extract.bind(this))
+            // Rename file to index
+            .then(this._rename.bind(this))
+    );
 };
 
 // -----------------
 
-UrlResolver.prototype._download = function () {
-    var fileName = url.parse(path.basename(this._source)).pathname;
+UrlResolver.prototype._parseSourceURL = function(_url) {
+    return url.parse(path.basename(_url)).pathname;
+};
+
+UrlResolver.prototype._download = function() {
+    var fileName = this._parseSourceURL(this._source);
+
+    if (!fileName) {
+        this._source = this._source.replace(/\/(?=\?|#)/, '');
+        fileName = this._parseSourceURL(this._source);
+    }
+
     var file = path.join(this._tempDir, fileName);
     var reqHeaders = {};
     var that = this;
@@ -121,37 +144,48 @@ UrlResolver.prototype._download = function () {
 
     // Download the file
     return download(this._source, file, {
-        proxy: this._remote.protocol === 'https:' ? this._config.httpsProxy : this._config.proxy,
+        ca: this._config.ca.default,
         strictSSL: this._config.strictSsl,
         timeout: this._config.timeout,
         headers: reqHeaders
     })
-    .progress(function (state) {
-        var msg;
+        .progress(function(state) {
+            var msg;
 
-        // Retry?
-        if (state.retry) {
-            msg = 'Download of ' + that._source + ' failed' + (state.error.code ? ' with ' + state.error.code : '') + ', ';
-            msg += 'retrying in ' + (state.delay / 1000).toFixed(1) + 's';
-            that._logger.debug('error', state.error.message, { error: state.error });
-            return that._logger.warn('retry', msg);
-        }
+            // Retry?
+            if (state.retry) {
+                msg =
+                    'Download of ' +
+                    that._source +
+                    ' failed' +
+                    (state.error.code ? ' with ' + state.error.code : '') +
+                    ', ';
+                msg += 'retrying in ' + (state.delay / 1000).toFixed(1) + 's';
+                that._logger.debug('error', state.error.message, {
+                    error: state.error
+                });
+                return that._logger.warn('retry', msg);
+            }
 
-        // Progress
-        msg = 'received ' + (state.received / 1024 / 1024).toFixed(1) + 'MB';
-        if (state.total) {
-            msg += ' of ' + (state.total / 1024 / 1024).toFixed(1) + 'MB downloaded, ';
-            msg += state.percent + '%';
-        }
-        that._logger.info('progress', msg);
-    })
-    .then(function (response) {
-        that._response = response;
-        return [file, response];
-    });
+            // Progress
+            msg =
+                'received ' + (state.received / 1024 / 1024).toFixed(1) + 'MB';
+            if (state.total) {
+                msg +=
+                    ' of ' +
+                    (state.total / 1024 / 1024).toFixed(1) +
+                    'MB downloaded, ';
+                msg += state.percent + '%';
+            }
+            that._logger.info('progress', msg);
+        })
+        .then(function(response) {
+            that._response = response;
+            return [file, response];
+        });
 };
 
-UrlResolver.prototype._parseHeaders = function (file, response) {
+UrlResolver.prototype._parseHeaders = function(file, response) {
     var disposition;
     var newFile;
     var match;
@@ -186,20 +220,19 @@ UrlResolver.prototype._parseHeaders = function (file, response) {
 
     newFile = path.join(this._tempDir, newFile);
 
-    return Q.nfcall(fs.rename, file, newFile)
-    .then(function () {
+    return Q.nfcall(fs.rename, file, newFile).then(function() {
         return [newFile, response];
     });
 };
 
-UrlResolver.prototype._extract = function (file, response) {
+UrlResolver.prototype._extract = function(file, response) {
     var mimeType = response.headers['content-type'];
 
     if (mimeType) {
         // Clean everything after ; and trim the end result
         mimeType = mimeType.split(';')[0].trim();
         // Some servers add quotes around the content-type, so we trim that also
-        mimeType = mout.string.trim(mimeType, ['"', '\'']);
+        mimeType = mout.string.trim(mimeType, ['"', "'"]);
     }
 
     if (!extract.canExtract(file, mimeType)) {
@@ -216,36 +249,42 @@ UrlResolver.prototype._extract = function (file, response) {
     });
 };
 
-UrlResolver.prototype._rename = function () {
-    return Q.nfcall(fs.readdir, this._tempDir)
-    .then(function (files) {
-        var file;
-        var oldPath;
-        var newPath;
+UrlResolver.prototype._rename = function() {
+    return Q.nfcall(fs.readdir, this._tempDir).then(
+        function(files) {
+            var file;
+            var oldPath;
+            var newPath;
 
-        // Remove any OS specific files from the files array
-        // before checking its length
-        files = files.filter(junk.isnt);
+            // Remove any OS specific files from the files array
+            // before checking its length
+            files = files.filter(junk.isnt);
 
-        // Only rename if there's only one file and it's not the json
-        if (files.length === 1 && !/^(component|bower)\.json$/.test(files[0])) {
-            file = files[0];
-            this._singleFile = 'index' + path.extname(file);
-            oldPath = path.join(this._tempDir, file);
-            newPath = path.join(this._tempDir, this._singleFile);
+            // Only rename if there's only one file and it's not the json
+            if (
+                files.length === 1 &&
+                !/^(component|bower)\.json$/.test(files[0])
+            ) {
+                file = files[0];
+                this._singleFile = 'index' + path.extname(file);
+                oldPath = path.join(this._tempDir, file);
+                newPath = path.join(this._tempDir, this._singleFile);
 
-            return Q.nfcall(fs.rename, oldPath, newPath);
-        }
-    }.bind(this));
+                return Q.nfcall(fs.rename, oldPath, newPath);
+            }
+        }.bind(this)
+    );
 };
 
-UrlResolver.prototype._savePkgMeta = function (meta) {
+UrlResolver.prototype._savePkgMeta = function(meta) {
     // Store collected headers in the package meta
     meta._cacheHeaders = this._collectCacheHeaders(this._response);
 
     // Store ETAG under _release
     if (meta._cacheHeaders.ETag) {
-        meta._release = 'e-tag:' + mout.string.trim(meta._cacheHeaders.ETag.substr(0, 10), '"');
+        meta._release =
+            'e-tag:' +
+            mout.string.trim(meta._cacheHeaders.ETag.substr(0, 10), '"');
     }
 
     // Store main if is a single file
@@ -256,11 +295,11 @@ UrlResolver.prototype._savePkgMeta = function (meta) {
     return Resolver.prototype._savePkgMeta.call(this, meta);
 };
 
-UrlResolver.prototype._collectCacheHeaders = function (res) {
+UrlResolver.prototype._collectCacheHeaders = function(res) {
     var headers = {};
 
     // Collect cache headers
-    this.constructor._cacheHeaders.forEach(function (name) {
+    this.constructor._cacheHeaders.forEach(function(name) {
         var value = res.headers[name.toLowerCase()];
 
         if (value != null) {

lib/core/resolvers/pluginResolverFactory.js

@@ -0,0 +1,385 @@
+var Q = require('q');
+var path = require('path');
+var fs = require('../../util/fs');
+var object = require('mout/object');
+
+var semver = require('../../util/semver');
+var createError = require('../../util/createError');
+var readJson = require('../../util/readJson');
+var removeIgnores = require('../../util/removeIgnores');
+
+function pluginResolverFactory(resolverFactory, bower) {
+    bower = bower || {};
+
+    if (typeof resolverFactory !== 'function') {
+        throw createError(
+            'Resolver has "' +
+                typeof resolverFactory +
+                '" type instead of "function" type.',
+            'ERESOLERAPI'
+        );
+    }
+
+    var resolver = resolverFactory(bower);
+
+    function maxSatisfyingVersion(versions, target) {
+        var versionsArr, index;
+
+        versionsArr = versions.map(function(obj) {
+            return obj.version;
+        });
+
+        // Find a satisfying version, enabling strict match so that pre-releases
+        // have lower priority over normal ones when target is *
+        index = semver.maxSatisfyingIndex(versionsArr, target, true);
+
+        if (index !== -1) {
+            return versions[index];
+        }
+    }
+
+    function PluginResolver(decEndpoint) {
+        this._decEndpoint = decEndpoint;
+    }
+
+    // @private
+    PluginResolver.prototype.getEndpoint = function() {
+        return object.merge(this._decEndpoint, {
+            name: this.getName(),
+            source: this.getSource(),
+            target: this.getTarget()
+        });
+    };
+
+    PluginResolver.prototype.getSource = function() {
+        return this._decEndpoint.source;
+    };
+
+    PluginResolver.prototype.getTarget = function() {
+        return this._decEndpoint.target || '*';
+    };
+
+    PluginResolver.prototype.getName = function() {
+        if (!this._decEndpoint.name && typeof resolver.getName === 'function') {
+            return resolver.getName.call(resolver, this.getSource());
+        } else if (!this._decEndpoint.name) {
+            return path.basename(this.getSource());
+        } else {
+            return this._decEndpoint.name;
+        }
+    };
+
+    PluginResolver.prototype.getPkgMeta = function() {
+        return this._pkgMeta;
+    };
+
+    // -----------------
+
+    // Plugin Resolver is always considered potentially cacheable
+    // The "resolve" method decides whether to use cached or fetch new version.
+    PluginResolver.prototype.isCacheable = function() {
+        return true;
+    };
+
+    // Not only it's always potentially cacheable, but also always potenially new.
+    // The "resolve" handles logic of re-downloading target if needed.
+    PluginResolver.prototype.hasNew = function(pkgMeta) {
+        if (this.hasNewPromise) {
+            return this.hasNewPromise;
+        }
+
+        this._pkgMeta = pkgMeta;
+
+        return (this.hasNewPromise = this.resolve().then(function(result) {
+            return result !== undefined;
+        }));
+    };
+
+    PluginResolver.prototype.resolve = function() {
+        if (this.resolvePromise) {
+            return this.resolvePromise;
+        }
+
+        var that = this;
+
+        return (this.resolvePromise = Q.fcall(function() {
+            var target = that.getTarget();
+
+            // It means that we can accept ranges as targets
+            if (that.constructor.isTargetable()) {
+                that._release = target;
+
+                if (semver.validRange(target)) {
+                    return Q.fcall(
+                        resolver.releases.bind(resolver),
+                        that.getSource()
+                    ).then(function(result) {
+                        if (!result) {
+                            throw createError(
+                                'Resolver did not provide releases of package.'
+                            );
+                        }
+
+                        var releases = (that._releases = result);
+
+                        var versions = releases.filter(function(target) {
+                            return semver.clean(target.version);
+                        });
+
+                        var maxRelease = maxSatisfyingVersion(versions, target);
+
+                        if (maxRelease) {
+                            that._version = maxRelease.version;
+                            that._release = that._decEndpoint.target =
+                                maxRelease.target;
+                        } else {
+                            throw createError(
+                                'No version found that was able to satisfy ' +
+                                    target,
+                                'ENORESTARGET',
+                                {
+                                    details: !versions.length
+                                        ? 'No versions found in ' +
+                                          that.getSource()
+                                        : 'Available versions: ' +
+                                          versions
+                                              .map(function(version) {
+                                                  return version.version;
+                                              })
+                                              .join(', ')
+                                }
+                            );
+                        }
+                    });
+                }
+            } else {
+                if (semver.validRange(target) && target !== '*') {
+                    return Q.reject(
+                        createError(
+                            'Resolver does not accept version ranges (' +
+                                target +
+                                ')'
+                        )
+                    );
+                }
+            }
+        })
+            .then(function() {
+                // We pass old _resolution (if hasNew has been called before contents).
+                // So resolver can decide whether use cached version of contents new one.
+                if (typeof resolver.fetch !== 'function') {
+                    throw createError(
+                        'Resolver does not implement the "fetch" method.'
+                    );
+                }
+
+                var cached = {};
+
+                if (that._releases) {
+                    cached.releases = that._releases;
+                }
+
+                if (that._pkgMeta) {
+                    cached.endpoint = {
+                        name: that._pkgMeta.name,
+                        source: that._pkgMeta._source,
+                        target: that._pkgMeta._target
+                    };
+
+                    cached.release = that._pkgMeta._release;
+
+                    cached.version = that._pkgMeta.version;
+
+                    cached.resolution = that._pkgMeta._resolution || {};
+                }
+
+                return Q.fcall(
+                    resolver.fetch.bind(resolver),
+                    that.getEndpoint(),
+                    cached
+                );
+            })
+            .then(function(result) {
+                // Empty result means to re-use existing resolution
+                if (!result) {
+                    return;
+                } else {
+                    if (!result.tempPath) {
+                        throw createError(
+                            'Resolver did not provide path to extracted contents of package.'
+                        );
+                    }
+
+                    that._tempDir = result.tempPath;
+
+                    return that._readJson(that._tempDir).then(function(meta) {
+                        return that
+                            ._applyPkgMeta(meta, result)
+                            .then(that._savePkgMeta.bind(that, meta, result))
+                            .then(function() {
+                                return that._tempDir;
+                            });
+                    });
+                }
+            }));
+    };
+
+    PluginResolver.prototype._readJson = function(dir) {
+        var that = this;
+
+        return readJson(dir, {
+            assume: { name: that.getName() },
+            logger: bower.logger
+        }).spread(function(json, deprecated) {
+            if (deprecated) {
+                bower.logger.warn(
+                    'deprecated',
+                    'Package ' +
+                        that.getName() +
+                        ' is using the deprecated ' +
+                        deprecated
+                );
+            }
+
+            return json;
+        });
+    };
+
+    PluginResolver.prototype._applyPkgMeta = function(meta, result) {
+        // Check if name defined in the json is different
+        // If so and if the name was "guessed", assume the json name
+        if (meta.name !== this._name) {
+            this._name = meta.name;
+        }
+
+        // Handle ignore property, deleting all files from the temporary directory
+        // If no ignores were specified, simply resolve
+        if (
+            result.removeIgnores === false ||
+            !meta.ignore ||
+            !meta.ignore.length
+        ) {
+            return Q.resolve(meta);
+        }
+
+        // Otherwise remove them from the temp dir
+        return removeIgnores(this._tempDir, meta).then(function() {
+            return meta;
+        });
+    };
+
+    PluginResolver.prototype._savePkgMeta = function(meta, result) {
+        var that = this;
+
+        meta._source = that.getSource();
+        meta._target = that.getTarget();
+
+        if (result.resolution) {
+            meta._resolution = result.resolution;
+        }
+
+        if (that._release) {
+            meta._release = that._release;
+        }
+
+        if (that._version) {
+            meta.version = that._version;
+        } else {
+            delete meta.version;
+        }
+
+        // Stringify contents
+        var contents = JSON.stringify(meta, null, 2);
+
+        return Q.nfcall(
+            fs.writeFile,
+            path.join(this._tempDir, '.bower.json'),
+            contents
+        ).then(function() {
+            return (that._pkgMeta = meta);
+        });
+    };
+
+    // It is used only by "bower info". It returns all semver versions.
+    PluginResolver.versions = function(source) {
+        return Q.fcall(resolver.releases.bind(resolver), source).then(function(
+            result
+        ) {
+            if (!result) {
+                throw createError(
+                    'Resolver did not provide releases of package.'
+                );
+            }
+
+            var releases = (this._releases = result);
+
+            var versions = releases.map(function(version) {
+                return semver.clean(version.version);
+            });
+
+            versions = versions.filter(function(version) {
+                return version;
+            });
+
+            versions.sort(function(a, b) {
+                return semver.rcompare(a, b);
+            });
+
+            return versions;
+        });
+    };
+
+    PluginResolver.isTargetable = function() {
+        // If resolver doesn't define versions function, it's not targetable..
+        return typeof resolver.releases === 'function';
+    };
+
+    PluginResolver.clearRuntimeCache = function() {
+        resolver = resolverFactory(bower);
+    };
+
+    PluginResolver.match = function(source) {
+        if (typeof resolver.match !== 'function') {
+            throw createError(
+                'Resolver is missing "match" method.',
+                'ERESOLVERAPI'
+            );
+        }
+
+        var match = resolver.match.bind(resolver);
+
+        return Q.fcall(match, source).then(function(result) {
+            if (typeof result !== 'boolean') {
+                throw createError(
+                    'Resolver\'s "match" method should return a boolean',
+                    'ERESOLVERAPI'
+                );
+            }
+
+            return result;
+        });
+    };
+
+    PluginResolver.locate = function(source) {
+        if (typeof resolver.locate !== 'function') {
+            return source;
+        }
+
+        return Q.fcall(resolver.locate.bind(resolver), source).then(function(
+            result
+        ) {
+            if (typeof result !== 'string') {
+                throw createError(
+                    'Resolver\'s "locate" method should return a string',
+                    'ERESOLVERAPI'
+                );
+            }
+
+            return result;
+        });
+    };
+
+    return PluginResolver;
+}
+
+module.exports = pluginResolverFactory;

lib/core/scripts.js

@@ -3,28 +3,36 @@ var cmd = require('../util/cmd');
 var Q = require('q');
 var shellquote = require('shell-quote');
 
-var orderByDependencies = function (packages, installed, json) {
+var orderByDependencies = function(packages, installed, json) {
     var ordered = [];
     installed = mout.object.keys(installed);
 
-    var depsSatisfied = function (packageName) {
-        return mout.array.difference(mout.object.keys(packages[packageName].dependencies), installed, ordered).length === 0;
+    var depsSatisfied = function(packageName) {
+        return (
+            mout.array.difference(
+                mout.object.keys(packages[packageName].dependencies),
+                installed,
+                ordered
+            ).length === 0
+        );
     };
 
-    var depsFromBowerJson = json && json.dependencies ? mout.object.keys(json.dependencies) : [];
+    var depsFromBowerJson =
+        json && json.dependencies ? mout.object.keys(json.dependencies) : [];
     var packageNames = mout.object.keys(packages);
 
     //get the list of the packages that are specified in bower.json in that order
     //its nice to maintain that order for users
     var desiredOrder = mout.array.intersection(depsFromBowerJson, packageNames);
     //then add to the end any remaining packages that werent in bower.json
-    desiredOrder = desiredOrder.concat(mout.array.difference(packageNames, desiredOrder));
+    desiredOrder = desiredOrder.concat(
+        mout.array.difference(packageNames, desiredOrder)
+    );
 
     //the desired order isn't necessarily a correct dependency specific order
     //so we ensure that below
     var resolvedOne = true;
     while (resolvedOne) {
-
         resolvedOne = false;
 
         for (var i = 0; i < desiredOrder.length; i++) {
@@ -43,17 +51,16 @@ var orderByDependencies = function (packages, installed, json) {
             //so lets just jam those names on the end
             ordered = ordered.concat(desiredOrder);
         }
-
     }
 
     return ordered;
 };
 
-var run = function (cmdString, action, logger, config) {
+var run = function(cmdString, action, logger, config) {
     logger.action(action, cmdString);
 
     //pass env + BOWER_PID so callees can identify a preinstall+postinstall from the same bower instance
-    var env = mout.object.mixIn({ 'BOWER_PID': process.pid }, process.env);
+    var env = mout.object.mixIn({ BOWER_PID: process.pid }, process.env);
     var args = shellquote.parse(cmdString, env);
     var cmdName = args[0];
     mout.array.remove(args, cmdName); //no rest() in mout
@@ -65,8 +72,8 @@ var run = function (cmdString, action, logger, config) {
 
     var promise = cmd(cmdName, args, options);
 
-    promise.progress(function (progress) {
-        progress.split('\n').forEach(function (line) {
+    promise.progress(function(progress) {
+        progress.split('\n').forEach(function(line) {
             if (line) {
                 logger.action(action, line);
             }
@@ -76,21 +83,40 @@ var run = function (cmdString, action, logger, config) {
     return promise;
 };
 
-var hook = function (action, ordered, config, logger, packages, installed, json) {
-    if (mout.object.keys(packages).length === 0 || !config.scripts || !config.scripts[action]) {
-        /*jshint newcap: false  */
+var hook = function(
+    action,
+    ordered,
+    config,
+    logger,
+    packages,
+    installed,
+    json
+) {
+    if (
+        mout.object.keys(packages).length === 0 ||
+        !config.scripts ||
+        !config.scripts[action]
+    ) {
         return Q();
     }
 
-    var orderedPackages = ordered ? orderByDependencies(packages, installed, json) : mout.object.keys(packages);
-    var cmdString = mout.string.replace(config.scripts[action], '%', orderedPackages.join(' '));
+    var orderedPackages = ordered
+        ? orderByDependencies(packages, installed, json)
+        : mout.object.keys(packages);
+    var placeholder = new RegExp('%', 'g');
+    var cmdString = mout.string.replace(
+        config.scripts[action],
+        placeholder,
+        orderedPackages.join(' ')
+    );
     return run(cmdString, action, logger, config);
 };
 
 module.exports = {
     preuninstall: mout.function.partial(hook, 'preuninstall', false),
+    postuninstall: mout.function.partial(hook, 'postuninstall', false),
     preinstall: mout.function.partial(hook, 'preinstall', true),
     postinstall: mout.function.partial(hook, 'postinstall', true),
     //only exposed for test
     _orderByDependencies: orderByDependencies
-};
+};

lib/index.js

@@ -1,29 +1,6 @@
-var abbrev = require('abbrev');
-var mout = require('mout');
 var commands = require('./commands');
-
-var abbreviations = abbrev(expandNames(commands));
-abbreviations.i = 'install';
-abbreviations.rm = 'uninstall';
-abbreviations.unlink = 'uninstall';
-abbreviations.ls = 'list';
-
-function expandNames(obj, prefix, stack) {
-    prefix = prefix || '';
-    stack = stack || [];
-
-    mout.object.forOwn(obj, function (value, name) {
-        name = prefix + name;
-
-        stack.push(name);
-
-        if (typeof value === 'object' && !value.line) {
-            expandNames(value, name + ' ', stack);
-        }
-    });
-
-    return stack;
-}
+var version = require('./version');
+var abbreviations = require('./util/abbreviations')(commands);
 
 function clearRuntimeCache() {
     // Note that in edge cases, some architecture components instance's
@@ -34,8 +11,9 @@ function clearRuntimeCache() {
 }
 
 module.exports = {
+    version: version,
     commands: commands,
-    config: require('./config'),
+    config: require('./config')(),
     abbreviations: abbreviations,
     reset: clearRuntimeCache
 };

lib/renderers/JsonRenderer.js

@@ -7,7 +7,7 @@ function JsonRenderer() {
     this._nrLogs = 0;
 }
 
-JsonRenderer.prototype.end = function (data) {
+JsonRenderer.prototype.end = function(data) {
     if (this._nrLogs) {
         process.stderr.write(']\n');
     }
@@ -17,7 +17,7 @@ JsonRenderer.prototype.end = function (data) {
     }
 };
 
-JsonRenderer.prototype.error = function (err) {
+JsonRenderer.prototype.error = function(err) {
     var message = err.message;
     var stack;
 
@@ -31,16 +31,14 @@ JsonRenderer.prototype.error = function (err) {
     err.message = message;
 
     // Stack
-    /*jshint camelcase:false*/
     stack = err.fstream_stack || err.stack || 'N/A';
-    err.stacktrace = (Array.isArray(stack) ? stack.join('\n') : stack);
-    /*jshint camelcase:true*/
+    err.stacktrace = Array.isArray(stack) ? stack.join('\n') : stack;
 
     this.log(err);
     this.end();
 };
 
-JsonRenderer.prototype.log = function (log) {
+JsonRenderer.prototype.log = function(log) {
     if (!this._nrLogs) {
         process.stderr.write('[');
     } else {
@@ -51,12 +49,12 @@ JsonRenderer.prototype.log = function (log) {
     this._nrLogs++;
 };
 
-JsonRenderer.prototype.prompt = function (prompts) {
+JsonRenderer.prototype.prompt = function(prompts) {
     var promise = Q.resolve();
     var answers = {};
     var that = this;
 
-    prompts.forEach(function (prompt) {
+    prompts.forEach(function(prompt) {
         var opts;
         var funcName;
 
@@ -65,67 +63,68 @@ JsonRenderer.prototype.prompt = function (prompts) {
 
         // Prompt
         opts = {
-            silent: true,                                           // To not mess with JSON output
-            trim: false,                                            // To allow " " to not assume the default value
-            default: prompt.default == null ? '' : prompt.default,  // If default is null, make it '' so that it does not retry
-            validator: !prompt.validate ? null : function (value) {
-                var ret = prompt.validate(value);
+            silent: true, // To not mess with JSON output
+            trim: false, // To allow " " to not assume the default value
+            default: prompt.default == null ? '' : prompt.default, // If default is null, make it '' so that it does not retry
+            validator: !prompt.validate
+                ? null
+                : function(value) {
+                      var ret = prompt.validate(value);
 
-                if (typeof ret === 'string') {
-                    throw ret;
-                }
+                      if (typeof ret === 'string') {
+                          throw ret;
+                      }
 
-                return value;
-            },
+                      return value;
+                  }
         };
 
         // For now only "input", "confirm" and "password" are supported
         switch (prompt.type) {
-        case 'input':
-            funcName = 'prompt';
-            break;
-        case 'confirm':
-        case 'password':
-            funcName = prompt.type;
-            break;
-        case 'checkbox':
-            funcName = 'prompt';
-            break;
-        default:
-            promise = promise.then(function () {
-                throw createError('Unknown prompt type', 'ENOTSUP');
-            });
-            return;
+            case 'input':
+                funcName = 'prompt';
+                break;
+            case 'confirm':
+            case 'password':
+                funcName = prompt.type;
+                break;
+            case 'checkbox':
+                funcName = 'prompt';
+                break;
+            default:
+                promise = promise.then(function() {
+                    throw createError('Unknown prompt type', 'ENOTSUP');
+                });
+                return;
         }
 
-        promise = promise.then(function () {
+        promise = promise.then(function() {
             // Log
             prompt.level = 'prompt';
             that.log(prompt);
 
-            return Q.nfcall(promptly[funcName], '', opts)
-            .then(function (answer) {
+            return Q.nfcall(promptly[funcName], '', opts).then(function(
+                answer
+            ) {
                 answers[prompt.name] = answer;
             });
         });
 
         if (prompt.type === 'checkbox') {
-            promise = promise.then(function () {
+            promise = promise.then(function() {
                 answers[prompt.name] = answers[prompt.name].split(',');
             });
         }
     });
 
-    return promise.then(function () {
+    return promise.then(function() {
         return answers;
     });
 };
 
-JsonRenderer.prototype.updateNotice = function () {};
-
 // -------------------------
 
-JsonRenderer.prototype._stringify = function (log) {
+JsonRenderer.prototype._stringify = function(log) {
     // To json
     var str = JSON.stringify(log, null, '  ');
     // Remove colors in case some log has colors..

lib/renderers/StandardRenderer.js

@@ -1,20 +1,19 @@
-var cardinal = require('cardinal');
 var chalk = require('chalk');
 var path = require('path');
 var mout = require('mout');
 var archy = require('archy');
 var Q = require('q');
-var inquirer = require('inquirer');
 var stringifyObject = require('stringify-object');
 var os = require('os');
-var pkg = require(path.join(__dirname, '../..', 'package.json'));
+var semverUtils = require('semver-utils');
+var version = require('../version');
 var template = require('../util/template');
 
 function StandardRenderer(command, config) {
     this._sizes = {
-        id: 13,    // Id max chars
+        id: 13, // Id max chars
         label: 20, // Label max chars
-        sumup: 5   // Amount to sum when the label exceeds
+        sumup: 5 // Amount to sum when the label exceeds
     };
     this._colors = {
         warn: chalk.yellow,
@@ -25,16 +24,26 @@ function StandardRenderer(command, config) {
     };
 
     this._command = command;
-    this._config = config;
+    this._config = config || {};
 
     if (this.constructor._wideCommands.indexOf(command) === -1) {
         this._compact = true;
     } else {
         this._compact = process.stdout.columns < 120;
     }
+
+    var exitOnPipeError = function(err) {
+        if (err.code === 'EPIPE') {
+            process.exit(0);
+        }
+    };
+
+    // It happens when piping command to "head" util
+    process.stdout.on('error', exitOnPipeError);
+    process.stderr.on('error', exitOnPipeError);
 }
 
-StandardRenderer.prototype.end = function (data) {
+StandardRenderer.prototype.end = function(data) {
     var method = '_' + mout.string.camelCase(this._command);
 
     if (this[method]) {
@@ -42,7 +51,7 @@ StandardRenderer.prototype.end = function (data) {
     }
 };
 
-StandardRenderer.prototype.error = function (err) {
+StandardRenderer.prototype.error = function(err) {
     var str;
     var stack;
 
@@ -51,37 +60,48 @@ StandardRenderer.prototype.error = function (err) {
     err.id = err.code || 'error';
     err.level = 'error';
 
-    str = this._prefix(err) + ' ' + err.message.replace(/\r?\n/g, ' ').trim() + '\n';
+    str =
+        this._prefix(err) +
+        ' ' +
+        err.message.replace(/\r?\n/g, ' ').trim() +
+        '\n';
     this._write(process.stderr, 'bower ' + str);
 
     // Check if additional details were provided
     if (err.details) {
-        str = chalk.yellow('\nAdditional error details:\n') + err.details.trim() + '\n';
+        str =
+            chalk.yellow('\nAdditional error details:\n') +
+            err.details.trim() +
+            '\n';
         this._write(process.stderr, str);
     }
 
     // Print trace if verbose, the error has no code
     // or if the error is a node error
     if (this._config.verbose || !err.code || err.errno) {
-        /*jshint camelcase:false*/
         stack = err.fstream_stack || err.stack || 'N/A';
         str = chalk.yellow('\nStack trace:\n');
         str += (Array.isArray(stack) ? stack.join('\n') : stack) + '\n';
         str += chalk.yellow('\nConsole trace:\n');
-        /*jshint camelcase:true*/
 
         this._write(process.stderr, str);
-        console.trace();
+        this._write(process.stderr, new Error().stack);
 
         // Print bower version, node version and system info.
         this._write(process.stderr, chalk.yellow('\nSystem info:\n'));
-        this._write(process.stderr, 'Bower version: ' + pkg.version + '\n');
-        this._write(process.stderr, 'Node version: ' + process.versions.node + '\n');
-        this._write(process.stderr, 'OS: ' + os.type() + ' ' + os.release() + ' ' + os.arch() + '\n');
+        this._write(process.stderr, 'Bower version: ' + version + '\n');
+        this._write(
+            process.stderr,
+            'Node version: ' + process.versions.node + '\n'
+        );
+        this._write(
+            process.stderr,
+            'OS: ' + os.type() + ' ' + os.release() + ' ' + os.arch() + '\n'
+        );
     }
 };
 
-StandardRenderer.prototype.log = function (log) {
+StandardRenderer.prototype.log = function(log) {
     var method = '_' + mout.string.camelCase(log.id) + 'Log';
 
     this._guessOrigin(log);
@@ -94,31 +114,27 @@ StandardRenderer.prototype.log = function (log) {
     }
 };
 
-StandardRenderer.prototype.prompt = function (prompts) {
+StandardRenderer.prototype.prompt = function(prompts) {
     var deferred;
 
     // Strip colors from the prompt if color is disabled
     if (!this._config.color) {
-        prompts.forEach(function (prompt) {
+        prompts.forEach(function(prompt) {
             prompt.message = chalk.stripColor(prompt.message);
         });
     }
 
     // Prompt
     deferred = Q.defer();
+    var inquirer = require('inquirer');
     inquirer.prompt(prompts, deferred.resolve);
 
     return deferred.promise;
 };
 
-StandardRenderer.prototype.updateNotice = function (data) {
-    var str = template.render('std/update-notice.std', data);
-    this._write(process.stderr, str);
-};
-
 // -------------------------
 
-StandardRenderer.prototype._help = function (data) {
+StandardRenderer.prototype._help = function(data) {
     var str;
     var that = this;
     var specific;
@@ -133,56 +149,68 @@ StandardRenderer.prototype._help = function (data) {
         if (template.exists(specific)) {
             str = template.render(specific, data);
         } else {
-            str =  template.render('std/help-generic.std', data);
+            str = template.render('std/help-generic.std', data);
         }
 
         that._write(process.stdout, str);
     }
 };
 
-StandardRenderer.prototype._install = function (packages) {
+StandardRenderer.prototype._install = function(packages) {
     var str = '';
 
-    mout.object.forOwn(packages, function (pkg) {
-        var cliTree;
+    mout.object.forOwn(
+        packages,
+        function(pkg) {
+            var cliTree;
 
-        // List only 1 level deep dependencies
-        mout.object.forOwn(pkg.dependencies, function (dependency) {
-            dependency.dependencies = {};
-        });
-        // Make canonical dir relative
-        pkg.canonicalDir = path.relative(this._config.cwd, pkg.canonicalDir);
-        // Signal as root
-        pkg.root = true;
+            // List only 1 level deep dependencies
+            mout.object.forOwn(pkg.dependencies, function(dependency) {
+                dependency.dependencies = {};
+            });
+            // Make canonical dir relative
+            pkg.canonicalDir = path.relative(
+                this._config.cwd,
+                pkg.canonicalDir
+            );
+            // Signal as root
+            pkg.root = true;
 
-        cliTree = this._tree2archy(pkg);
-        str += '\n' + archy(cliTree);
-    }, this);
+            cliTree = this._tree2archy(pkg);
+            str += '\n' + archy(cliTree);
+        },
+        this
+    );
 
     if (str) {
         this._write(process.stdout, str);
     }
 };
 
-StandardRenderer.prototype._update = function (packages) {
+StandardRenderer.prototype._update = function(packages) {
     this._install(packages);
 };
 
-StandardRenderer.prototype._list = function (tree) {
+StandardRenderer.prototype._list = function(tree) {
     var cliTree;
 
-    tree.root = true;
-    cliTree = this._tree2archy(tree);
+    if (tree.pkgMeta) {
+        tree.root = true;
+        cliTree = archy(this._tree2archy(tree));
+    } else {
+        cliTree =
+            stringifyObject(tree, { indent: '  ' }).replace(/[{}]/g, '') + '\n';
+    }
 
-    this._write(process.stdout, archy(cliTree));
+    this._write(process.stdout, cliTree);
 };
 
-StandardRenderer.prototype._search = function (results) {
+StandardRenderer.prototype._search = function(results) {
     var str = template.render('std/search-results.std', results);
     this._write(process.stdout, str);
 };
 
-StandardRenderer.prototype._info = function (data) {
+StandardRenderer.prototype._info = function(data) {
     var str = '';
     var pkgMeta = data;
     var includeVersions = false;
@@ -201,19 +229,32 @@ StandardRenderer.prototype._info = function (data) {
 
     // Render the versions at the end
     if (includeVersions) {
+        data.hidePreReleases = false;
+        data.numPreReleases = 0;
+        // If output isn't verbose, hide prereleases
+        if (!this._config.verbose) {
+            data.versions = mout.array.filter(data.versions, function(version) {
+                version = semverUtils.parse(version);
+                if (!version.release && !version.build) {
+                    return true;
+                }
+                data.numPreReleases++;
+            });
+            data.hidePreReleases = !!data.numPreReleases;
+        }
         str += '\n' + template.render('std/info.std', data);
     }
 
     this._write(process.stdout, str);
 };
 
-StandardRenderer.prototype._lookup = function (data) {
+StandardRenderer.prototype._lookup = function(data) {
     var str = template.render('std/lookup.std', data);
 
     this._write(process.stdout, str);
 };
 
-StandardRenderer.prototype._link = function (data) {
+StandardRenderer.prototype._link = function(data) {
     this._sizes.id = 4;
 
     this.log({
@@ -228,7 +269,7 @@ StandardRenderer.prototype._link = function (data) {
     }
 };
 
-StandardRenderer.prototype._register = function (data) {
+StandardRenderer.prototype._register = function(data) {
     var str;
 
     // If no data passed, it means the user aborted
@@ -240,17 +281,20 @@ StandardRenderer.prototype._register = function (data) {
     this._write(process.stdout, str);
 };
 
-StandardRenderer.prototype._cacheList = function (entries) {
-    entries.forEach(function (entry) {
+StandardRenderer.prototype._cacheList = function(entries) {
+    entries.forEach(function(entry) {
         var pkgMeta = entry.pkgMeta;
         var version = pkgMeta.version || pkgMeta._target;
-        this._write(process.stdout, pkgMeta.name + '=' + pkgMeta._source + '#' + version + '\n');
+        this._write(
+            process.stdout,
+            pkgMeta.name + '=' + pkgMeta._source + '#' + version + '\n'
+        );
     }, this);
 };
 
 // -------------------------
 
-StandardRenderer.prototype._genericLog = function (log) {
+StandardRenderer.prototype._genericLog = function(log) {
     var stream;
     var str;
 
@@ -264,7 +308,7 @@ StandardRenderer.prototype._genericLog = function (log) {
     this._write(stream, 'bower ' + str);
 };
 
-StandardRenderer.prototype._checkoutLog = function (log) {
+StandardRenderer.prototype._checkoutLog = function(log) {
     if (this._compact) {
         log.message = log.origin.split('#')[0] + '#' + log.message;
     }
@@ -272,7 +316,7 @@ StandardRenderer.prototype._checkoutLog = function (log) {
     this._genericLog(log);
 };
 
-StandardRenderer.prototype._progressLog = function (log) {
+StandardRenderer.prototype._progressLog = function(log) {
     if (this._compact) {
         log.message = log.origin + ' ' + log.message;
     }
@@ -280,7 +324,7 @@ StandardRenderer.prototype._progressLog = function (log) {
     this._genericLog(log);
 };
 
-StandardRenderer.prototype._extractLog = function (log) {
+StandardRenderer.prototype._extractLog = function(log) {
     if (this._compact) {
         log.message = log.origin + ' ' + log.message;
     }
@@ -288,19 +332,23 @@ StandardRenderer.prototype._extractLog = function (log) {
     this._genericLog(log);
 };
 
-StandardRenderer.prototype._incompatibleLog = function (log) {
+StandardRenderer.prototype._incompatibleLog = function(log) {
     var str;
     var templatePath;
 
     // Generate dependants string for each pick
-    log.data.picks.forEach(function (pick) {
-        pick.dependants = pick.dependants.map(function (dependant) {
-            var release = dependant.pkgMeta._release;
-            return dependant.endpoint.name + (release ? '#' + release : '');
-        }).join(', ');
+    log.data.picks.forEach(function(pick) {
+        pick.dependants = pick.dependants
+            .map(function(dependant) {
+                var release = dependant.pkgMeta._release;
+                return dependant.endpoint.name + (release ? '#' + release : '');
+            })
+            .join(', ');
     });
 
-    templatePath = log.data.suitable ? 'std/conflict-resolved.std' : 'std/conflict.std';
+    templatePath = log.data.suitable
+        ? 'std/conflict-resolved.std'
+        : 'std/conflict.std';
     str = template.render(templatePath, log.data);
 
     this._write(process.stdout, '\n');
@@ -308,15 +356,18 @@ StandardRenderer.prototype._incompatibleLog = function (log) {
     this._write(process.stdout, '\n');
 };
 
-StandardRenderer.prototype._solvedLog = function (log) {
+StandardRenderer.prototype._solvedLog = function(log) {
     this._incompatibleLog(log);
 };
 
-StandardRenderer.prototype._jsonLog = function (log) {
-    this._write(process.stdout, '\n' + this._highlightJson(log.data.json) + '\n\n');
+StandardRenderer.prototype._jsonLog = function(log) {
+    this._write(
+        process.stdout,
+        '\n' + this._highlightJson(log.data.json) + '\n\n'
+    );
 };
 
-StandardRenderer.prototype._cachedEntryLog = function (log) {
+StandardRenderer.prototype._cachedEntryLog = function(log) {
     if (this._compact) {
         log.message = log.origin;
     }
@@ -326,7 +377,7 @@ StandardRenderer.prototype._cachedEntryLog = function (log) {
 
 // -------------------------
 
-StandardRenderer.prototype._guessOrigin = function (log) {
+StandardRenderer.prototype._guessOrigin = function(log) {
     var data = log.data;
 
     if (!data) {
@@ -334,7 +385,8 @@ StandardRenderer.prototype._guessOrigin = function (log) {
     }
 
     if (data.endpoint) {
-        log.origin = data.endpoint.name || (data.registry && data.endpoint.source);
+        log.origin =
+            data.endpoint.name || (data.registry && data.endpoint.source);
 
         // Resort to using the resolver name for unnamed endpoints
         if (!log.origin && data.resolver) {
@@ -353,7 +405,7 @@ StandardRenderer.prototype._guessOrigin = function (log) {
     }
 };
 
-StandardRenderer.prototype._prefix = function (log) {
+StandardRenderer.prototype._prefix = function(log) {
     var label;
     var length;
     var nrSpaces;
@@ -385,7 +437,7 @@ StandardRenderer.prototype._prefix = function (log) {
     return chalk.green(label) + mout.string.repeat(' ', nrSpaces) + idColor(id);
 };
 
-StandardRenderer.prototype._write = function (stream, str) {
+StandardRenderer.prototype._write = function(stream, str) {
     if (!this._config.color) {
         str = chalk.stripColor(str);
     }
@@ -393,16 +445,18 @@ StandardRenderer.prototype._write = function (stream, str) {
     stream.write(str);
 };
 
-StandardRenderer.prototype._highlightJson = function (json) {
+StandardRenderer.prototype._highlightJson = function(json) {
+    var cardinal = require('cardinal');
+
     return cardinal.highlight(stringifyObject(json, { indent: '  ' }), {
         theme: {
             String: {
-                _default: function (str) {
+                _default: function(str) {
                     return chalk.cyan(str);
                 }
             },
             Identifier: {
-                _default: function (str) {
+                _default: function(str) {
                     return chalk.green(str);
                 }
             }
@@ -411,9 +465,11 @@ StandardRenderer.prototype._highlightJson = function (json) {
     });
 };
 
-StandardRenderer.prototype._tree2archy = function (node) {
+StandardRenderer.prototype._tree2archy = function(node) {
     var dependencies = mout.object.values(node.dependencies);
-    var version = !node.missing ? node.pkgMeta._release || node.pkgMeta.version : null;
+    var version = !node.missing
+        ? node.pkgMeta._release || node.pkgMeta.version
+        : null;
     var label = node.endpoint.name + (version ? '#' + version : '');
     var update;
 
@@ -436,7 +492,8 @@ StandardRenderer.prototype._tree2archy = function (node) {
     }
 
     if (node.incompatible) {
-        label += chalk.yellow(' incompatible') + ' with ' + node.endpoint.target;
+        label +=
+            chalk.yellow(' incompatible') + ' with ' + node.endpoint.target;
     } else if (node.extraneous) {
         label += chalk.green(' extraneous');
     }
@@ -450,7 +507,7 @@ StandardRenderer.prototype._tree2archy = function (node) {
         }
 
         if (node.update.latest !== node.update.target) {
-            update += (update ? ', ' : '');
+            update += update ? ', ' : '';
             update += 'latest is ' + node.update.latest;
         }
 
@@ -478,7 +535,7 @@ StandardRenderer._wideCommands = [
     'register'
 ];
 StandardRenderer._idMappings = {
-    'mutual': 'conflict',
+    mutual: 'conflict',
     'cached-entry': 'cached'
 };
 

lib/templates/helpers/colors.js

@@ -0,0 +1,13 @@
+var chalk = require('chalk');
+
+var templateColors = ['yellow', 'green', 'cyan', 'red', 'white', 'magenta'];
+
+function colors(Handlebars) {
+    templateColors.forEach(function(color) {
+        Handlebars.registerHelper(color, function(context) {
+            return chalk[color](context.fn(this));
+        });
+    });
+}
+
+module.exports = colors;

lib/templates/helpers/condense.js

@@ -1,9 +1,9 @@
 var mout = require('mout');
 var leadLinesRegExp = /^\r?\n/;
-var multipleLinesRegExp = /\r?\n(\r?\n)+/mg;
+var multipleLinesRegExp = /\r?\n(\r?\n)+/gm;
 
 function condense(Handlebars) {
-    Handlebars.registerHelper('condense', function (context) {
+    Handlebars.registerHelper('condense', function(context) {
         var str = context.fn(this);
 
         // Remove multiple lines

lib/templates/helpers/indent.js

@@ -1,7 +1,7 @@
 var mout = require('mout');
 
 function indent(Handlebars) {
-    Handlebars.registerHelper('indent', function (context) {
+    Handlebars.registerHelper('indent', function(context) {
         var hash = context.hash;
         var indentStr = mout.string.repeat(' ', parseInt(hash.level, 10));
 

lib/templates/helpers/rpad.js

@@ -0,0 +1,12 @@
+var mout = require('mout');
+
+function rpad(Handlebars) {
+    Handlebars.registerHelper('rpad', function(context) {
+        var hash = context.hash;
+        var minLength = parseInt(hash.minLength, 10);
+        var chr = hash.char;
+        return mout.string.rpad(context.fn(this), minLength, chr);
+    });
+}
+
+module.exports = rpad;

lib/templates/helpers/sum.js

@@ -1,5 +1,5 @@
 function sum(Handlebars) {
-    Handlebars.registerHelper('sum', function (val1, val2) {
+    Handlebars.registerHelper('sum', function(val1, val2) {
         return val1 + val2;
     });
 }

lib/templates/json/help-cache/clean.json

@@ -1,5 +1,5 @@
 {
-    "command": "cache list",
+    "command": "cache clean",
     "description": "Cleans cached packages.",
     "usage": [
         "cache clean [<options>]",

lib/templates/json/help-cache/list.json

@@ -1,5 +1,5 @@
 {
-    "command": "cache clean",
+    "command": "cache list",
     "description": "Lists cached packages.",
     "usage": [
         "cache list [<options>]",

lib/templates/json/help-install.json

@@ -11,6 +11,11 @@
             "flag":        "--force-latest",
             "description": "Force latest version on conflict"
         },
+        {
+            "shorthand":   "-f",
+            "flag":        "--force",
+            "description": "If dependencies are installed, it reinstalls all installed components. It also forces installation even when there are non-bower directories with the same name in the components directory. Also bypasses the cache and overwrites to the cache anyway."
+        },
         {
             "shorthand":   "-h",
             "flag":        "--help",
@@ -30,6 +35,11 @@
             "shorthand":   "-D",
             "flag":        "--save-dev",
             "description": "Save installed packages into the project's bower.json devDependencies"
+        },
+        {
+            "shorthand":   "-E",
+            "flag":        "--save-exact",
+            "description": "Configure installed packages with an exact version rather than semver"
         }
     ]
 }

lib/templates/json/help-login.json

@@ -0,0 +1,19 @@
+{
+    "command": "login",
+    "description": "Authenticate with GitHub and store credentials to be used later.",
+    "usage": [
+        "login [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        },
+        {
+            "shorthand":   "-t",
+            "flag":        "--token",
+            "description": "Pass an existing GitHub auth token rather than prompting for username and password."
+        }
+    ]
+}

lib/templates/json/help-lookup.json

@@ -1,6 +1,6 @@
 {
     "command": "lookup",
-    "description": "Looks up a package URL by name.",
+    "description": "Look up a single package URL by name.",
     "usage": [
         "lookup <name> [<options>]"
     ],

lib/templates/json/help-register.json

@@ -5,6 +5,11 @@
         "register <name> <url> [<options>]"
     ],
     "options": [
+        {
+            "shorthand":   "-f",
+            "flag":        "--force",
+            "description": "Bypasses confirmation. Bower login is still needed."
+        },
         {
             "shorthand":   "-h",
             "flag":        "--help",

lib/templates/json/help-search.json

@@ -1,8 +1,7 @@
 {
     "command": "search",
-    "description": "Finds all packages or a specific package.",
+    "description": "Search for packages by name.",
     "usage": [
-        "search [<options>]",
         "search <name> [<options>]"
     ],
     "options": [

lib/templates/json/help-uninstall.json

@@ -5,6 +5,11 @@
         "uninstall <name> [<name> ..] [<options>]"
     ],
     "options": [
+        {
+            "shorthand":   "-f",
+            "flag":        "--force",
+            "description": "Continues uninstallation even after a dependency conflict"
+        },
         {
             "shorthand":   "-h",
             "flag":        "--help",
@@ -13,12 +18,12 @@
         {
             "shorthand":   "-S",
             "flag":        "--save",
-            "description": "Save installed packages into the project's bower.json dependencies"
+            "description": "Remove uninstalled packages from the project's bower.json dependencies"
         },
         {
             "shorthand":   "-D",
             "flag":        "--save-dev",
-            "description": "Save installed packages into the project's bower.json devDependencies"
+            "description": "Remove uninstalled packages from the project's bower.json devDependencies"
         }
     ]
 }

lib/templates/json/help-unregister.json

@@ -0,0 +1,19 @@
+{
+    "command": "unregister",
+    "description": "Unregisters a package.",
+    "usage": [
+        "unregister <name> [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-f",
+            "flag":        "--force",
+            "description": "Bypasses confirmation. Bower login is still needed."
+        },
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        }
+    ]
+}

lib/templates/json/help-update.json

@@ -19,6 +19,16 @@
             "shorthand":   "-p",
             "flag":        "--production",
             "description": "Do not install project devDependencies"
+        },
+        {
+            "shorthand":   "-S",
+            "flag":        "--save",
+            "description": "Update dependencies in bower.json"
+        },
+        {
+            "shorthand":   "-D",
+            "flag":        "--save-dev",
+            "description": "Update devDependencies in bower.json"
         }
     ]
 }

lib/templates/json/help-version.json

@@ -0,0 +1,14 @@
+{
+    "command": "version",
+    "description": "Creates an empty version commit and tag, and fail if the repo is not clean.\n\nThe <version> argument should be a valid semver string, or one of following:\nbuild, patch, minor, major.\n\nIf supplied with --message (shorthand: -m) config option, bower will use it\nas a commit message when creating a version commit. If the message config\ncontains %s then that will be replaced with the resulting version number.\n\nFor example:\n\n    bower version patch -m \"Upgrade to %s for reasons\"",
+    "usage": [
+        "version [<version> | major | minor | patch]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-m",
+            "flag":        "--message",
+            "description": "Custom git commit and tag message"
+        }
+    ]
+}

lib/templates/json/help.json

@@ -10,13 +10,15 @@
         "init":            "Interactively create a bower.json file",
         "install":         "Install a package locally",
         "link":            "Symlink a package folder",
-        "list":            "List local packages",
-        "lookup":          "Look up a package URL by name",
+        "list":            "List local packages - and possible updates",
+        "login":           "Authenticate with GitHub and store credentials",
+        "lookup":          "Look up a single package URL by name",
         "prune":           "Removes local extraneous packages",
         "register":        "Register a package",
-        "search":          "Search for a package by name",
+        "search":          "Search for packages by name",
         "update":          "Update a local package",
         "uninstall":       "Remove a local package",
+        "unregister":      "Remove a package from the registry",
         "version":         "Bump a package version"
     },
     "options": [
@@ -32,7 +34,7 @@
         },
         {
             "shorthand":   "-l",
-            "flag":        "--log-level",
+            "flag":        "--loglevel",
             "description": "What level of logs to report"
         },
         {
@@ -58,6 +60,19 @@
         {
             "flag":        "--allow-root",
             "description": "Allows running commands as root"
+        },
+        {
+            "shorthand":   "-v",
+            "flag":        "--version",
+            "description": "Output Bower version"
+        },
+        {
+            "flag":        "--no-color",
+            "description": "Disable colors"
+        },
+        {
+            "flag":        "--config.interactive=false",
+            "description": "Disable prompts"
         }
     ]
 }

lib/templates/std/conflict-resolved.std

@@ -0,0 +1,9 @@
+{{#yellow}}Please note that,{{/yellow}}
+{{#condense}}
+{{#each picks}}
+    {{#if dependants}}{{#green}}{{dependants}}{{/green}}{{else}}none{{/if}} depends on {{#cyan}}{{endpoint.name}}#{{endpoint.target}}{{/cyan}}{{#if pkgMeta._release}} which resolved to {{#green}}{{endpoint.name}}#{{pkgMeta._release}}{{/green}}{{/if}}
+{{/each}}
+{{/condense}}
+
+Resort to using {{#cyan}}{{suitable.endpoint.name}}#{{resolution}}{{/cyan}} which resolved to {{#green}}{{suitable.endpoint.name}}#{{suitable.pkgMeta._release}}{{/green}}
+Code incompatibilities may occur.

lib/templates/std/conflict.std

@@ -1,9 +1,11 @@
-{{#yellow}}Unable to find a suitable version for {{name}}, please choose one:{{/yellow}}
+{{#yellow}}Unable to find a suitable version for {{name}}, please choose one by typing one of the numbers below:{{/yellow}}
 {{#condense}}
 {{#each picks}}
-    {{#magenta}}{{sum @index 1}}){{/magenta}} {{#cyan}}{{endpoint.name}}#{{endpoint.target}}{{/cyan}}{{#if pkgMeta._release}} which resolved to {{#white}}{{pkgMeta._release}}{{/white}}{{/if}}{{#if dependants}} and is required by {{#white}}{{dependants}}{{/white}} {{/if}}
+    {{#magenta}}{{sum @index 1}}){{/magenta}} {{#cyan}}{{endpoint.name}}#{{endpoint.target}}{{/cyan}}{{#if pkgMeta._release}} which resolved to {{#green}}{{pkgMeta._release}}{{/green}}{{/if}}{{#if dependants}} and is required by {{#green}}{{dependants}}{{/green}}{{/if}}
 {{/each}}
 {{/condense}}
+
 {{#unless saveResolutions}}
+
 Prefix the choice with ! to persist it to bower.json
-{{/unless}}
+{{/unless}}

lib/templates/std/help-cache.std

@@ -11,6 +11,7 @@ Commands:
 
 {{#condense}}
 {{#each commands}}
-    {{#rpad length="23"}}{{@key}}{{/rpad}} {{.}}
+    {{#rpad minLength="23"}}{{@key}}{{/rpad}} {{.}}
 {{/each}}
 {{/condense}}
+{{#rpad minLength="23"}}{{/rpad}}

lib/templates/std/help-generic.std

@@ -7,11 +7,12 @@ Usage:
 {{/each}}
 {{/condense}}
 
+
 Options:
 
 {{#condense}}
 {{#each options}}
-    {{#yellow}}{{#rpad length="23"}}{{#if shorthand}}{{shorthand}}, {{/if}}{{flag}}{{/rpad}}{{/yellow}} {{description}}
+    {{#yellow}}{{#rpad minLength="23"}}{{#if shorthand}}{{shorthand}}, {{/if}}{{flag}}{{/rpad}}{{/yellow}} {{description}}
 {{/each}}
 {{/condense}}
 

lib/templates/std/help.std

@@ -11,7 +11,7 @@ Commands:
 
 {{#condense}}
 {{#each commands}}
-    {{#rpad length="23"}}{{@key}}{{/rpad}} {{.}}
+    {{#rpad minLength="23"}}{{@key}}{{/rpad}} {{.}}
 {{/each}}
 {{/condense}}
 
@@ -19,7 +19,7 @@ Options:
 
 {{#condense}}
 {{#each options}}
-    {{#yellow}}{{#rpad length="23"}}{{#if shorthand}}{{shorthand}}, {{/if}}{{flag}}{{/rpad}}{{/yellow}} {{description}}
+    {{#yellow}}{{#rpad minLength="23"}}{{#if shorthand}}{{shorthand}}, {{/if}}{{flag}}{{/rpad}}{{/yellow}} {{description}}
 {{/each}}
 {{/condense}}
 

lib/templates/std/info.std

@@ -5,6 +5,10 @@
 {{/versions}}
 {{/condense}}
 
+
+{{#if hidePreReleases}}
+Show {{numPreReleases}} additional prereleases with ‘bower info {{name}} --verbose’
+{{/if}}
 You can request info for a specific version with 'bower info {{name}}#<version>'
 {{else}}No versions available.
 {{/if}}

lib/templates/std/lookup.std

@@ -5,3 +5,4 @@
 Package not found.
 {{/if}}
 {{/condense}}
+

lib/templates/std/search-results.std

@@ -5,5 +5,6 @@
     {{#cyan}}{{{name}}}{{/cyan}} {{{url}}}
 {{/.}}
 {{/condense}}
+
 {{else}}No results.
-{{/if}}
+{{/if}}

lib/util/abbreviations.js

@@ -0,0 +1,30 @@
+var abbrev = require('abbrev');
+var mout = require('mout');
+
+function expandNames(obj, prefix, stack) {
+    prefix = prefix || '';
+    stack = stack || [];
+
+    mout.object.forOwn(obj, function(value, name) {
+        name = prefix + name;
+
+        stack.push(name);
+
+        if (typeof value === 'object' && !value.line) {
+            expandNames(value, name + ' ', stack);
+        }
+    });
+
+    return stack;
+}
+
+module.exports = function(commands) {
+    var abbreviations = abbrev(expandNames(commands));
+
+    abbreviations.i = 'install';
+    abbreviations.rm = 'uninstall';
+    abbreviations.unlink = 'uninstall';
+    abbreviations.ls = 'list';
+
+    return abbreviations;
+};

lib/util/analytics.js

@@ -1,61 +0,0 @@
-var Q = require('q');
-var Insight = require('insight');
-var mout = require('mout');
-var config = require('../config');
-var pkg = require('../../package.json');
-
-var analytics = module.exports;
-var insight;
-
-// Initializes the application-wide insight singleton and asks for the
-// permission on the CLI during the first run.
-analytics.setup = function setup() {
-    var deferred = Q.defer();
-    insight = new Insight({
-        trackingCode: 'UA-43531210-1',
-        packageName: pkg.name,
-        packageVersion: pkg.version
-    });
-
-    // Display the ask prompt only if it hasn't been answered before
-    // and the current session is looking to configure the analytics.
-    if (insight.optOut === undefined && config.analytics) {
-        insight.askPermission(null, deferred.resolve);
-    } else {
-        deferred.resolve();
-    }
-
-    return deferred.promise;
-};
-
-var Tracker = analytics.Tracker = function Tracker(config) {
-    if (!config.analytics) {
-        this.track = function noop() {};
-    }
-};
-
-Tracker.prototype.track = function track() {
-    if (!insight) {
-        throw new Error('You must call analytics.setup() prior to tracking.');
-    }
-    insight.track.apply(insight, arguments);
-};
-
-Tracker.prototype.trackDecomposedEndpoints = function trackDecomposedEndpoints(command, endpoints) {
-    endpoints.forEach(function (endpoint) {
-        this.track(command, endpoint.source, endpoint.target);
-    }.bind(this));
-};
-
-Tracker.prototype.trackPackages = function trackPackages(command, packages) {
-    mout.object.forOwn(packages, function (package) {
-        var meta = package.pkgMeta;
-        this.track(command, meta.name, meta.version);
-    }.bind(this));
-};
-
-Tracker.prototype.trackNames = function trackNames(command, names) {
-    names.forEach(function (name) {
-        this.track(command, name);
-    }.bind(this));
-};

lib/util/cli.js

@@ -15,10 +15,10 @@ function readOptions(options, argv) {
         options = options || {};
     }
 
-    types = mout.object.map(options, function (option) {
+    types = mout.object.map(options, function(option) {
         return option.type;
     });
-    mout.object.forOwn(options, function (option, name) {
+    mout.object.forOwn(options, function(option, name) {
         shorthands[option.shorthand] = '--' + name;
     });
 
@@ -26,7 +26,7 @@ function readOptions(options, argv) {
 
     // Filter only the specified options because nopt parses every --
     // Also make them camel case
-    mout.object.forOwn(noptOptions, function (value, key) {
+    mout.object.forOwn(noptOptions, function(value, key) {
         if (options[key]) {
             parsedOptions[mout.string.camelCase(key)] = value;
         }

lib/util/cmd.js

@@ -8,9 +8,12 @@ var createError = require('./createError');
 
 // The concurrency limit here is kind of magic. You don't really gain a lot from
 // having a large number of commands spawned at once, so it isn't super
-// important for this number to be large. However, it would still be nice to
-// *know* how high this number can be, rather than having to guess low.
-var throttler = new PThrottler(50);
+// important for this number to be large. Reports have shown that much more than 5
+// or 10 cause issues for corporate networks, private repos or situations where
+// internet bandwidth is limited. We're running with a concurrency of 5 until
+// 1.4.X is released, at which time we'll move to what was discussed in #1262
+// https://github.com/bower/bower/pull/1262
+var throttler = new PThrottler(5);
 
 var winBatchExtensions;
 var winWhichCache;
@@ -34,17 +37,17 @@ function getWindowsCommand(command) {
     try {
         fullCommand = which.sync(command);
     } catch (err) {
-        return winWhichCache[command] = command;
+        return (winWhichCache[command] = command);
     }
 
     extension = path.extname(fullCommand).toLowerCase();
 
     // Does it need to be converted?
     if (winBatchExtensions.indexOf(extension) === -1) {
-        return winWhichCache[command] = command;
+        return (winWhichCache[command] = command);
     }
 
-    return winWhichCache[command] = fullCommand;
+    return (winWhichCache[command] = fullCommand);
 }
 
 // Executes a shell command, buffering the stdout and stderr
@@ -64,25 +67,25 @@ function executeCmd(command, args, options) {
 
     // Buffer output, reporting progress
     process = cp.spawn(command, args, options);
-    process.stdout.on('data', function (data) {
+    process.stdout.on('data', function(data) {
         data = data.toString();
         deferred.notify(data);
         stdout += data;
     });
-    process.stderr.on('data', function (data) {
+    process.stderr.on('data', function(data) {
         data = data.toString();
         deferred.notify(data);
         stderr += data;
     });
 
     // If there is an error spawning the command, reject the promise
-    process.on('error', function (error) {
+    process.on('error', function(error) {
         return deferred.reject(error);
     });
 
     // Listen to the close event instead of exit
     // They are similar but close ensures that streams are flushed
-    process.on('close', function (code) {
+    process.on('close', function(code) {
         var fullCommand;
         var error;
 
@@ -96,10 +99,19 @@ function executeCmd(command, args, options) {
             fullCommand += args.length ? ' ' + args.join(' ') : '';
 
             // Build the error instance
-            error = createError('Failed to execute "' + fullCommand + '", exit code of #' + code, 'ECMDERR', {
-                details: stderr,
-                exitCode: code
-            });
+            error = createError(
+                'Failed to execute "' +
+                    fullCommand +
+                    '", exit code of #' +
+                    code +
+                    '\n' +
+                    stderr,
+                'ECMDERR',
+                {
+                    details: stderr,
+                    exitCode: code
+                }
+            );
 
             return deferred.reject(error);
         }

lib/util/copy.js

@@ -1,6 +1,6 @@
 var fstream = require('fstream');
 var fstreamIgnore = require('fstream-ignore');
-var fs = require('graceful-fs');
+var fs = require('./fs');
 var Q = require('q');
 
 function copy(reader, writer) {
@@ -26,18 +26,17 @@ function copy(reader, writer) {
     deferred = Q.defer();
 
     reader
-    .on('error', deferred.reject)
-    // Pipe to writer
-    .pipe(fstream.Writer(writer))
-    .on('error', deferred.reject)
-    .on('close', deferred.resolve);
+        .on('error', deferred.reject)
+        // Pipe to writer
+        .pipe(fstream.Writer(writer))
+        .on('error', deferred.reject)
+        .on('close', deferred.resolve);
 
     return deferred.promise;
 }
 
 function copyMode(src, dst) {
-    return Q.nfcall(fs.stat, src)
-    .then(function (stat) {
+    return Q.nfcall(fs.stat, src).then(function(stat) {
         return Q.nfcall(fs.chmod, dst, stat.mode);
     });
 }
@@ -68,14 +67,17 @@ function copyFile(src, dst, opts) {
 
     opts = parseOptions(opts);
 
-    promise = copy({
-        path: src,
-        type: 'File'
-    }, {
-        path: dst,
-        mode: opts.mode,
-        type: 'File'
-    });
+    promise = copy(
+        {
+            path: src,
+            type: 'File'
+        },
+        {
+            path: dst,
+            mode: opts.mode,
+            type: 'File'
+        }
+    );
 
     if (opts.copyMode) {
         promise = promise.then(copyMode.bind(copyMode, src, dst));
@@ -93,15 +95,18 @@ function copyDir(src, dst, opts) {
 
     opts = parseOptions(opts);
 
-    promise = copy({
-        path: src,
-        type: 'Directory',
-        ignore: opts.ignore
-    }, {
-        path: dst,
-        mode: opts.mode,
-        type: 'Directory'
-    });
+    promise = copy(
+        {
+            path: src,
+            type: 'Directory',
+            ignore: opts.ignore
+        },
+        {
+            path: dst,
+            mode: opts.mode,
+            type: 'Directory'
+        }
+    );
 
     if (opts.copyMode) {
         promise = promise.then(copyMode.bind(copyMode, src, dst));

lib/util/createLink.js

@@ -1,4 +1,4 @@
-var fs = require('graceful-fs');
+var fs = require('./fs');
 var path = require('path');
 var Q = require('q');
 var mkdirp = require('mkdirp');
@@ -10,41 +10,55 @@ function createLink(src, dst, type) {
     var dstDir = path.dirname(dst);
 
     // Create directory
-    return Q.nfcall(mkdirp, dstDir)
-    // Check if source exists
-    .then(function () {
-        return Q.nfcall(fs.stat, src)
-        .fail(function (error) {
-            if (error.code === 'ENOENT') {
-                throw createError('Failed to create link to ' + path.basename(src), 'ENOENT', {
-                    details: src + ' does not exist or points to a non-existent file'
+    return (
+        Q.nfcall(mkdirp, dstDir)
+            // Check if source exists
+            .then(function() {
+                return Q.nfcall(fs.stat, src).fail(function(error) {
+                    if (error.code === 'ENOENT') {
+                        throw createError(
+                            'Failed to create link to ' + path.basename(src),
+                            'ENOENT',
+                            {
+                                details:
+                                    src +
+                                    ' does not exist or points to a non-existent file'
+                            }
+                        );
+                    }
+
+                    throw error;
                 });
-            }
+            })
+            // Create symlink
+            .then(function(stat) {
+                type = type || (stat.isDirectory() ? 'dir' : 'file');
 
-            throw error;
-        });
-    })
-    // Create symlink
-    .then(function (stat) {
-        type = type || (stat.isDirectory() ? 'dir' : 'file');
+                return Q.nfcall(fs.symlink, src, dst, type).fail(function(err) {
+                    if (!isWin || err.code !== 'EPERM') {
+                        throw err;
+                    }
 
-        return Q.nfcall(fs.symlink, src, dst, type)
-        .fail(function (err) {
-            if (!isWin || err.code !== 'EPERM') {
-                throw err;
-            }
-
-            // Try with type "junction" on Windows
-            // Junctions behave equally to true symlinks and can be created in
-            // non elevated terminal (well, not always..)
-            return Q.nfcall(fs.symlink, src, dst, 'junction')
-            .fail(function (err) {
-                throw createError('Unable to create link to ' + path.basename(src), err.code, {
-                    details: err.message.trim() + '\n\nTry running this command in an elevated terminal (run as root/administrator).'
+                    // Try with type "junction" on Windows
+                    // Junctions behave equally to true symlinks and can be created in
+                    // non elevated terminal (well, not always..)
+                    return Q.nfcall(fs.symlink, src, dst, 'junction').fail(
+                        function(err) {
+                            throw createError(
+                                'Unable to create link to ' +
+                                    path.basename(src),
+                                err.code,
+                                {
+                                    details:
+                                        err.message.trim() +
+                                        '\n\nTry running this command in an elevated terminal (run as root/administrator).'
+                                }
+                            );
+                        }
+                    );
                 });
-            });
-        });
-    });
+            })
+    );
 }
 
 module.exports = createLink;

lib/util/download.js

@@ -3,107 +3,151 @@ var request = require('request');
 var Q = require('q');
 var mout = require('mout');
 var retry = require('retry');
-var fs = require('graceful-fs');
 var createError = require('./createError');
+var createWriteStream = require('fs-write-stream-atomic');
+var destroy = require('destroy');
 
 var errorCodes = [
     'EADDRINFO',
     'ETIMEDOUT',
     'ECONNRESET',
-    'ESOCKETTIMEDOUT'
+    'ESOCKETTIMEDOUT',
+    'ENOTFOUND'
 ];
 
 function download(url, file, options) {
     var operation;
-    var response;
     var deferred = Q.defer();
     var progressDelay = 8000;
 
-    options = mout.object.mixIn({
-        retries: 5,
-        factor: 2,
-        minTimeout: 1000,
-        maxTimeout: 35000,
-        randomize: true
-    }, options || {});
+    options = mout.object.mixIn(
+        {
+            retries: 5,
+            factor: 2,
+            minTimeout: 1000,
+            maxTimeout: 35000,
+            randomize: true,
+            progressDelay: progressDelay,
+            gzip: true
+        },
+        options || {}
+    );
 
     // Retry on network errors
     operation = retry.operation(options);
-    operation.attempt(function () {
-        var req;
-        var writeStream;
-        var contentLength;
-        var bytesDownloaded = 0;
 
-        req = progress(request(url, options), {
-            delay: progressDelay
-        })
-        .on('response', function (res) {
-            var status = res.statusCode;
+    operation.attempt(function() {
+        Q.fcall(fetch, url, file, options)
+            .then(function(response) {
+                deferred.resolve(response);
+            })
+            .progress(function(status) {
+                deferred.notify(status);
+            })
+            .fail(function(error) {
+                // Save timeout before retrying to report
+                var timeout = operation._timeouts[0];
 
-            if (status < 200 || status >= 300) {
-                return deferred.reject(createError('Status code of ' + status, 'EHTTP'));
-            }
+                // Reject if error is not a network error
+                if (errorCodes.indexOf(error.code) === -1) {
+                    return deferred.reject(error);
+                }
 
-            response = res;
-            contentLength = Number(res.headers['content-length']);
-        })
-        .on('data', function (data) {
-            bytesDownloaded += data.length;
-        })
-        .on('progress', function (state) {
-            deferred.notify(state);
-        })
-        .on('end', function () {
-            // Check if the whole file was downloaded
-            // In some unstable connections the ACK/FIN packet might be sent in the
-            // middle of the download
-            // See: https://github.com/joyent/node/issues/6143
-            if (contentLength && bytesDownloaded < contentLength) {
-                req.emit('error', createError('Transfer closed with ' + (contentLength - bytesDownloaded) + ' bytes remaining to read', 'EINCOMPLETE'));
-            }
-        })
-        .on('error', function (error) {
-            var timeout = operation._timeouts[0];
+                // Next attempt will start reporting download progress immediately
+                progressDelay = 0;
 
-            // Reject if error is not a network error
-            if (errorCodes.indexOf(error.code) === -1) {
-                return deferred.reject(error);
-            }
-
-            // Next attempt will start reporting download progress immediately
-            progressDelay = 0;
-
-            // Check if there are more retries
-            if (operation.retry(error)) {
-                // Ensure that there are no more events from this request
-                req.removeAllListeners();
-                req.on('error', function () {});
-                // Ensure that there are no more events from the write stream
-                writeStream.removeAllListeners();
-                writeStream.on('error', function () {});
-
-                return deferred.notify({
-                    retry: true,
-                    delay: timeout,
-                    error: error
-                });
-            }
-
-            // No more retries, reject!
-            deferred.reject(error);
-        });
-
-        // Pipe read stream to write stream
-        writeStream = req
-        .pipe(fs.createWriteStream(file))
-        .on('error', deferred.reject)
-        .on('close', function () {
-            deferred.resolve(response);
-        });
+                // This will schedule next retry or return false
+                if (operation.retry(error)) {
+                    deferred.notify({
+                        retry: true,
+                        delay: timeout,
+                        error: error
+                    });
+                } else {
+                    deferred.reject(error);
+                }
+            });
     });
 
     return deferred.promise;
 }
 
+function fetch(url, file, options) {
+    var deferred = Q.defer();
+
+    var contentLength;
+    var bytesDownloaded = 0;
+
+    var reject = function(error) {
+        deferred.reject(error);
+    };
+
+    var req = progress(request(url, options), {
+        delay: options.progressDelay
+    })
+        .on('response', function(response) {
+            contentLength = Number(response.headers['content-length']);
+
+            var status = response.statusCode;
+
+            if (status < 200 || status >= 300) {
+                return deferred.reject(
+                    createError('Status code of ' + status, 'EHTTP')
+                );
+            }
+
+            var writeStream = createWriteStream(file);
+            var errored = false;
+
+            // Change error listener so it cleans up writeStream before exiting
+            req.removeListener('error', reject);
+            req.on('error', function(error) {
+                errored = true;
+                destroy(req);
+                destroy(writeStream);
+
+                // Wait for writeStream to cleanup after itself...
+                // TODO: Maybe there's a better way?
+                setTimeout(function() {
+                    deferred.reject(error);
+                }, 50);
+            });
+
+            writeStream.on('finish', function() {
+                if (!errored) {
+                    destroy(req);
+                    deferred.resolve(response);
+                }
+            });
+
+            req.pipe(writeStream);
+        })
+        .on('data', function(data) {
+            bytesDownloaded += data.length;
+        })
+        .on('progress', function(state) {
+            deferred.notify(state);
+        })
+        .on('error', reject)
+        .on('end', function() {
+            // Check if the whole file was downloaded
+            // In some unstable connections the ACK/FIN packet might be sent in the
+            // middle of the download
+            // See: https://github.com/joyent/node/issues/6143
+            if (contentLength && bytesDownloaded < contentLength) {
+                req.emit(
+                    'error',
+                    createError(
+                        'Transfer closed with ' +
+                            (contentLength - bytesDownloaded) +
+                            ' bytes remaining to read',
+                        'EINCOMPLETE'
+                    )
+                );
+            }
+        });
+
+    return deferred.promise;
+}
+
 module.exports = download;