Merge branch 'master' into update-request

Update year to 2017

.appveyor.yml

@@ -0,0 +1,46 @@
+# http://www.appveyor.com/docs/appveyor-yml
+
+# Set build version format here instead of in the admin panel.
+version: "{build}"
+
+# Fix line endings in Windows. (runs before repo cloning)
+init:
+  - git config --global core.autocrlf input
+
+# Test against these versions of Node.js.
+environment:
+  matrix:
+    - nodejs_version: "0.10"
+    - nodejs_version: "0.12"
+    - nodejs_version: "4"
+    - nodejs_version: "6"
+    - nodejs_version: "8"
+    - nodejs_version: "9"
+
+# Finish on first failed build
+matrix:
+  fast_finish: true
+
+# Install node, display versions, install dependencies
+install:
+  - ps: Install-Product node 8
+  - node --version && npm --version
+  - git --version && svn --version
+  - npm install -g yarn grunt
+  - yarn
+  - ps: Install-Product node $env:nodejs_version
+
+# Post-install test scripts.
+test_script:
+  - cmd: npm run ci
+
+# Make clone much faster
+shallow_clone: true
+
+# Disable Visual Studio build and deploy
+build: off
+deploy: off
+
+# Cache node modules, and refresh if package.json changes
+cache:
+  - "%LOCALAPPDATA%\\Yarn"

.editorconfig

@@ -0,0 +1,18 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[**.std]
+insert_final_newline = false
+
+[{package,bower}.json]
+indent_size = 2

.eslintrc

@@ -0,0 +1,52 @@
+{
+  "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, "consistent", { "keywords": true }],
+    "quotes": [2, "single", "avoid-escape"],
+    "indent": [2, 4],
+    "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, {"anonymous": "always", "named": "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/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:**

.gitignore

@@ -1,3 +1,14 @@
-node_modules
-components
-.DS_Store
+/node_modules
+/npm-debug.log
+
+/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

.travis.yml

@@ -1,3 +1,43 @@
+sudo: false
+
 language: node_js
+
+# Use node 8 for build
 node_js:
-  - 0.8
+  - "8"
+
+# Then test with specific node version
+env:
+  - TEST_NODE_VERSION="0.10"
+  - TEST_NODE_VERSION="0.12"
+  - TEST_NODE_VERSION="4"
+  - TEST_NODE_VERSION="6"
+  - TEST_NODE_VERSION="8"
+  - TEST_NODE_VERSION="9"
+
+before_install:
+  - node --version
+  - curl -o- -L https://yarnpkg.com/install.sh | bash -s -- --version 1.5.1
+  - export PATH=$HOME/.yarn/bin:$PATH
+
+cache:
+  yarn: true
+
+install:
+  - yarn
+  - nvm install $TEST_NODE_VERSION
+  - npm install -g grunt
+
+os:
+  - osx
+  - linux
+
+matrix:
+  fast_finish: true
+  allow_failures:
+    - os: osx
+
+script:
+  - nvm use $TEST_NODE_VERSION
+  - node --version && npm --version && git --version && svn --version | head -n 1
+  - grunt travis

CHANGELOG.md

@@ -0,0 +1,670 @@
+# Changelog
+
+## 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.
+
+
+## 1.3.0 - 2014-03-10
+
+- **Removed support for node 0.8.** It may still work but we will no longer fix bugs for older versions of node.
+- Add **Bower Insight** for opt-in analytics integration to help improve tool and gain insight on community trends
+  - Old overview of [Insight](https://github.com/yeoman/yeoman/wiki/Insight), [Issue #260](https://github.com/bower/bower/issues/260)
+  - Reporting to GA. Public Dashboard is in progress.
+  - [Turn off interactive mode](https://github.com/bower/bower/issues/1162) if you run Bower in a CI environment
+- Add `moduleType` property to bower init ([#934](https://github.com/bower/bower/pull/934))
+- Fix prune command to log only after cleanup is completed ([#1023](https://github.com/bower/bower/issues/1023))
+- Fix git resolver to ignore pre-release versions ([#1017](https://github.com/bower/bower/issues/1017))
+- Fix shorthand flag for `save` option on `uninstall` command ([#1031](https://github.com/bower/bower/pull/1031))
+- Add `bower version` command ([#961](https://github.com/bower/bower/pull/961))
+- Add .bowerrc option to use `--save` by default when using `bower install` command ([#1074](https://github.com/bower/bower/pull/1074))
+- Fix git resolver caching ([#1083](https://github.com/bower/bower/issues/1083))
+- Fix reading versions from cache directory ([#1076](https://github.com/bower/bower/pull/1076))
+- Add svn support ([#1055](https://github.com/bower/bower/pull/1055))
+- Allow circular dependencies to be installed ([#1104](https://github.com/bower/bower/pull/1104))
+- Add scripts/hooks support ([#718](https://github.com/bower/bower/pull/718))
+
+_NOTE_: It's advisable that users use `--config.interactive=false` on automated scripts.
+
+
+## 1.2.8 - 2013-12-02
+- Fix absolute paths ending with / not going through the FsResolver, ([#898](https://github.com/bower/bower/issues/898))
+- Allow query string parameters in package URLs
+- Swapped 'unzip' module for 'decompress-zip', and some other small unzipping fixes([#873](https://github.com/bower/bower/issues/873), [#896](https://github.com/bower/bower/issues/896))
+- Allow the root-check to be overridden when calling bower programmatically.
+- Fixed some bugs relating to packages with a very large dependency tree
+- Fix a bug caused by a recent change to semver
+
+
+## 1.2.7 - 2013-09-29
+
+- Do not swallow sync errors when using the programmatic API ([#849](https://github.com/bower/bower/issues/849))
+- Fix resolutions not being saved if `--force-latest` is specified ([#861](https://github.com/bower/bower/issues/861))
+- Fix `bower register` warning about URL conversion, even if no conversion occurred
+- Fix `bower update` not correctly catching up branch commits
+- Add configured directory in `.bowerrc` to the ignores in `bower init` ([#854](https://github.com/bower/bower/issues/854))
+- Fix some case sensitive issues with data stored in registry cache (e.g.: jquery/jQuery, [#859](https://github.com/bower/bower/issues/859))
+- Fix bower not checking out a tag if it looks like a semver (e.g.: 1.0, [#872](https://github.com/bower/bower/issues/872))
+- Fix install & update commands printing the wrong versions in some cases ([#879](https://github.com/bower/bower/issues/879))
+- Give priority to mime type headers when deciding if a package need to be extracted, except if it is `octet-stream`
+
+_NOTE_: It's advisable that users run `bower cache clean`.
+
+
+## 1.2.6 - 2013-09-04
+
+- Bower now reports download progress even for servers that do not respond with `content-length` header.
+- Do not translate endpoints when registering a package to a private registry server ([#832](https://github.com/bower/bower/issues/832))
+- Detect corrupted downloads by comparing downloaded bytes with `content-length` header if possible; this fixes Bower silently failing on unstable networks ([#824](https://github.com/bower/bower/issues/824) and [#792](https://github.com/bower/bower/issues/792))
+- Fix quotes in fields causing Bower to crash in the `init` command ([#841](https://github.com/bower/bower/issues/841))
+
+
+## 1.2.5 - 2013-08-28
+
+- Fix persistent conflict resolutions not working correctly for branches ([#818](https://github.com/bower/bower/issues/818))
+- Fix Bower failing to run if HOME is not set ([#826](https://github.com/bower/bower/issues/826))
+- Bower now prints a warning if HOME is not set ([#827](https://github.com/bower/bower/issues/827))
+- Fix progress message being fired after completion of long running `git clone` commands
+- Other minor improvements
+
+
+## 1.2.4 - 2013-08-23
+
+- Fix ignored nested folders not being correctly handled in some cases ([#814](https://github.com/bower/bower/issues/814))
+
+
+## 1.2.3 - 2013-08-22
+
+- Fix read of environment variables that map to config properties with dashes and also support nested ones ([#8@bower-config](https://github.com/bower/config/issues/8))
+- Fix `bower info <package> <property>` printing the available versions (it shouldn't!)
+- Fix interactive shell not being correctly detected in node `0.8.x` ([#802](https://github.com/bower/bower/issues/802))
+- Fix `extraneous` flag in the `list` command being incorrectly set for saved dev dependencies in some cases
+- Fix linked dependencies not being read in `bower list` on Windows ([#813](https://github.com/bower/bower/issues/813))
+- Fix update notice not working with `--json`
+
+
+## 1.2.2 - 2013-08-20
+
+- Standardize prompt behaviour with and without `--json`
+- Improve detection of `git` servers that do not support shallow clones ([#805](https://github.com/bower/bower/issues/805))
+- Ignore remote tags (tags ending with ^{})
+- Fix bower not saving the correct endpoint in some edge cases ([#806](https://github.com/bower/bower/issues/806))
+
+
+## 1.2.1 - 2013-08-19
+
+- Fix bower throwing on non-semver targets ([#800](https://github.com/bower/bower/issues/800))
+
+
+## 1.2.0 - 2013-08-19
+
+- __Bower no longer installs a pre-release version by default, that is, if no version/range is specified__ ([#782](https://github.com/bower/bower/issues/782))
+- __`bower info <package>` will now show the latest `<package>` information along with the available versions__ ([#759](https://github.com/bower/bower/issues/759))
+- __`bower link` no longer requires an elevated user on Windows in most cases__ ([#472](https://github.com/bower/bower/issues/472))
+- __Init command now prompts for the whole `bower.json` spec properties, filling in default values for `author` and `homepage` based on `git` settings__ ([#693](https://github.com/bower/bower/issues/693))
+- Changes to endpoint sources in `bower.json` are now catched up by `bower install` and `bower update` ([#788](https://github.com/bower/bower/issues/788))
+- Allow semver ranges in `bower cache clean`, e.g. `bower cache clean jquery#<2.0.0` ([#688](https://github.com/bower/bower/issues/688))
+- Normalize `bower list --paths` on Windows ([#279](https://github.com/bower/bower/issues/279))
+- Multiple mains are now correctly outputted as an array in `bower list --paths` ([#784](https://github.com/bower/bower/issues/784))
+- Add `--relative` option to `bower list --json` so that Bower outputs relative paths instead of absolute ([#714](https://github.com/bower/bower/issues/714))
+- `bower list --paths` now outputs relative paths by default; can be turned off with `--no-relative` ([#785](https://github.com/bower/bower/issues/785))
+- Bower no longer fails if `symlinks` to files are present in the `bower_components` folder ([#783](https://github.com/bower/bower/issues/783) and [#791](https://github.com/bower/bower/issues/791))
+- Disable git templates/hooks when running `git` ([#761](https://github.com/bower/bower/issues/761))
+- Add instructions to setup git workaround for proxies when execution of `git` fails ([#250](https://github.com/bower/bower/issues/250))
+- Ignore `component.json` if it looks like a component(1) file ([#556](https://github.com/bower/bower/issues/556))
+- Fix multi-user usage on bower when it creates temporary directories to hold some files
+- Fix prompting causing an invalid JSON output when running commands with `--json`
+- When running Bower commands programmatically, prompting is now disabled by default (see the updated programmatic [usage](https://github.com/bower/bower#programmatic-api) for more info)
+- Other minor improvements and fixes
+
+Fix for `#788` requires installed components to be re-installed.
+
+
+## 1.1.2 - 2013-08-10
+
+- Detect and fallback if the git server does not support `--depth=1` when cloning ([#747](https://github.com/bower/bower/issues/747))
+
+
+## 1.1.1 - 2013-08-08
+
+- Fix silent fail when spawning child processes in some edge cases ([#722](https://github.com/bower/bower/issues/722))
+- Fix `home` command not guessing the correct URL for `GitHub` ssh endpoints (requires `bower cache-clean`)
+- Fix bower not correctly filtering packages with symlinks in some cases ([#730](https://github.com/bower/bower/issues/730))
+- Fix multi-user usage on bower when it falls back to create a `/tmp/bower` folder ([#743](https://github.com/bower/bower/issues/743))
+- Bower now sends a fake user agent when behind a proxy by default, so that corporate proxies do not block requests ([#698](https://github.com/bower/bower/issues/698))
+- Bower now translates GitHub public `git://` URLs to `git@` when behind a proxy ([#731](https://github.com/bower/bower/issues/731))
+- Minor improvements to the CLI output on small terminals
+- Minor programmatic usage improvements
+- Minor help usage fixes
+
+
+## 1.1.0 - 2013-08-03
+
+- __Fix `--save` and `--save-dev` not working correctly for the uninstall command in some situations__
+- __Attempting to register a package that declares `"private": true` in `bower.json` will result in an error ([#162](https://github.com/bower/bower/issues/162))__
+- __Fix retry strategy on download error that was causing some strange I/O errors__ ([#699](https://github.com/bower/bower/issues/699) and [#704](https://github.com/bower/bower/issues/704))
+- __`bower prune` now clears pruned packages dependencies if they are also extraneous__ ([#708](https://github.com/bower/bower/issues/708))
+- __`bower uninstall` now uninstalls uninstalled packages dependencies if they are not shared ([#609](https://github.com/bower/bower/issues/609))__
+- Fix `bower list` display the `incompatible` label even if they are compatible ([#710](https://github.com/bower/bower/issues/710))
+- Fix `bower cache clean` not working correctly when `package#non-semver` is specified
+- Implement no operation `completion` command to prevent weird output when hitting tab ([#691](https://github.com/bower/bower/issues/691))
+- Fix `bower info --help` ([#703](https://github.com/bower/bower/issues/703))
+- Add colorized output for `bower info <package>#<version>` ([#571](https://github.com/bower/bower/issues/571))
+- Added `bower ls` as an alias to `bower list`
+- Fix regression: do not create a json file when saving is required, warn instead
+- Ignore linked packages when reading dependencies in `bower init` ([#709](https://github.com/bower/bower/issues/709))
+- `bower list` is now able to (partially) reconstruct the dependency tree, even for dependencies not declared in `bower.json` ([#622](https://github.com/bower/bower/issues/622))
+
+
+## 1.0.3 - 2013-07-30
+
+- Fix some changes not being saved to bower.json ([#685](https://github.com/bower/bower/issues/685))
+- Fix `bower info <package> <property>` not showing information related to property of the latest version of that package ([#684](https://github.com/bower/bower/issues/684))
+
+
+## 1.0.2 - 2013-07-30
+
+- Fix severe bug originated from a wrong merge that caused conflict messages to not show up correctly
+
+
+## 1.0.1 - 2013-07-29
+
+- Fix `bower register` going ahead even if the answer was `no` ([#644](https://github.com/bower/bower/issues/644))
+- Fix local endpoints with backslashes on Windows ([#2@endpoint-parser](https://github.com/bower/endpoint-parser/pull/2))
+- Fix usage of multiple registries in the registry-client ([#3@registry-client](https://github.com/bower/registry-client/pull/3) and [#2@registry-client](https://github.com/bower/registry-client/pull/2))
+- File extensions now have more priority than mime types when deciding if extraction is necessary ([#657](https://github.com/bower/bower/pull/657))
+- Fix `Bower` not working when calling `.bat`/`.cmd` commands on Windows; it affected people using `Git portable` ([#626](https://github.com/bower/bower/issues/626))
+- Fix `bower list --paths` not resolving all files to absolute paths when the `main` property contained multiple files ([660](https://github.com/bower/bower/issues/660))
+- Fix `Bower` renaming `bower.json` and `component.json` files to `index.json` when it was the only file in the folder ([#674](https://github.com/bower/bower/issues/674))
+- Ignore symlinks when copying/extracting since they are not portable, specially across different hard-drives ([#665](https://github.com/bower/bower/issues/665))
+- Local file/dir endpoints are now exclusively referenced by an absolute path or relative path starting with `.` ([#666](https://github.com/bower/bower/issues/666))
+- Linked packages `bower.json` files are now parsed, making `bower list` account linked packages dependencies ([#659](https://github.com/bower/bower/issues/659))
+- Bower now fails to run with sudo unless `--allow-root` is passed ([#498](https://github.com/bower/bower/issues/498))
+- Add additional system information such as node version, bower version, OS version when an error occurs ([#670](https://github.com/bower/bower/issues/670))
+- `bower install` no longer overwrites `linked` packages unless it needs to ([#593](https://github.com/bower/bower/issues/593)).
+- All endpoint parts are now trimmed so that the Manager can better detect similar endpoints ([#3@endpoint-parser](https://github.com/bower/endpoint-parser/pull/3))
+- `bower register` now shows the server that will be used ([#647](https://github.com/bower/endpoint-parser/pull/647))
+
+
+## 1.0.0 - 2013-07-23
+
+Total rewrite of bower.
+The list bellow highlights the most important stuff.
+For a complete list of changes that this rewrite and release brings please read: https://github.com/bower/bower/wiki/Rewrite-state
+
+
+- Clear architecture and separation of concerns
+- Much much faster
+- `--json` output for all commands
+- `--offline` usage for all commands, except `register`
+- Proper `install` and `update` commands, similar to `npm` in behaviour
+- Named endpoints when installing, e.g. `bower install backbone-amd=backbone#~1.0.0`
+- New interactive conflict resolution strategy
+- Prevent human errors when using `register`
+- New `home` command, similar to `npm`
+- New `cache list` command
+- New `prune` command
+- Many many general bug fixes
+
+Non-backwards compatible changes:
+
+- The value of the `json` property from .bowerrc is no longer used
+- `--map` and `--sources` from the list command were removed, use `--json` instead
+- Programmatic usage changed, specially the commands interface
+
+Users upgrading from `bower-canary` and `bower@~0.x.x` should do a `bower cache clean`.
+Additionally you may remove the `~/.bower` folder manually since it's no longer used.
+On Windows the folder is located in `AppData/bower`.
+
+
+## 0.10.0 - 2013-07-02
+
+- __Allow specific commits to be targeted__ ([#275](https://github.com/bower/bower/issues/275))
+- __Change bower default folder from `components` to `bower_components`__ ([#434](https://github.com/bower/bower/issues/434))
+- __Support semver pre-releases and builds__ ([#188](https://github.com/bower/bower/issues/188))
+- Use `Content-Type` and `Content-Disposition` to guess file types, such as zip files ([#454](https://github.com/bower/bower/pull/454))
+- Fix bower failing silently when using an invalid version value in the bower.json file ([#439](https://github.com/bower/bower/issues/439))
+- Fix bower slowness when downloading after redirects ([#437](https://github.com/bower/bower/issues/437))
+- Detect and error out with a friendly message when `git` is not installed ([#362](https://github.com/bower/bower/issues/362))
+- Add `--quiet` and `--silent` CLI options ([#343](https://github.com/bower/bower/issues/343))
+- Minor programmatic usage improvements
+
+_NOTE_: The `components` folder will still be used if already created, making it easier for users to upgrade.
+
+## 0.9.2 - 2013-04-28
+- Better fix for [#429](https://github.com/bower/bower/issues/429)
+
+## 0.9.1 - 2013-04-27
+- Update `package.json`, docs and other stuff to point to the new `Bower` organisation on GitHub
+- Fix root label of `bower list` being an absolute path; now uses the package name
+- Fix `bower update <pkg>` updating all packages; now throws when updating an unknown package
+- Fix `list` command when package use different names than the `guessed` one ([#429](https://github.com/bower/bower/issues/429))
+
+## 0.9.0 - 2013-04-25
+- __Change from `component.json` to `bower.json`__ ([#39](https://github.com/bower/bower/issues/39))
+- __Compatibility with `node 0.10.x`, including fix hangs/errors when extracting `zip` files__
+- Fix `--save` and `--save-dev` not working with URLs that get redirected ([#417](https://github.com/bower/bower/issues/417))
+- Fix `init` command targeting `~commit` instead of `*`. ([#385](https://github.com/bower/bower/issues/385))
+- Remove temporary directories before exiting ([#345](https://github.com/bower/bower/issues/345))
+- Integrate `update-notifier` ([#202](https://github.com/bower/bower/issues/202))
+- Use `json` name when a package name was inferred ([#192](https://github.com/bower/bower/issues/192))
+- Fix `bin/bower` not exiting with an exit code greater than zero when an error occurs ([#187](https://github.com/bower/bower/issues/187))
+- Fix `--save` and `--save-dev` saving resolved shorthands instead of the actual shorthands
+- Fix bower using user defined git templates ([#324](https://github.com/bower/bower/issues/324))
+- Add command abbreviations ([#262](https://github.com/bower/bower/issues/262))
+- Improve help messages and fix abuse of colors in output
+- Wait for every package to resolve before printing error messages ([#290](https://github.com/bower/bower/issues/290))
+- Add `shorthand_resolver` to allow shorthands to be resolved to repositories other than GitHub ([#278](https://github.com/bower/bower/issues/278))
+
+## 0.8.6 - 2013-04-03
+- Emergency fix for `node 0.8.x` users to make `zip` extraction work again
+
+## 0.8.5 - 2013-03-04
+- Fix `cache-clean` command clearing the completion cache when the command was called with specific packages
+- Add error message when an error is caught parsing an invalid `component.json`
+
+## 0.8.4 - 2013-03-01
+- Fix some more duplicate async callbacks being called twice
+- Preserve new lines when saving `component.json` ([#285](https://github.com/bower/bower/issues/285))
+
+## 0.8.3 - 2013-02-27
+- Fix error when using the `update` command ([#282](https://github.com/bower/bower/issues/282))
+
+## 0.8.2 - 2013-02-26
+- Fix some errors in windows while removing directories, had to downgrade `rimraf` ([#274](https://github.com/bower/bower/issues/274))
+- Prevent duplicate package names in error summaries ([#277](https://github.com/bower/bower/issues/277))
+
+## 0.8.1 - 2013-02-25
+- Fix some async callbacks being fired twice ([#274](https://github.com/bower/bower/issues/274))
+
+## 0.8.0 - 2013-02-24
+- __Add init command similar to `npm init`__ ([#219](https://github.com/bower/bower/issues/219))
+- __Add devDependencies__ support ([#251](https://github.com/bower/bower/issues/251))
+- __Add `--save-dev` flag to install/uninstall commands__ ([#258](https://github.com/bower/bower/issues/258))
+- `cache-clean` command now clears links pointing to nonexistent folders ([#182](https://github.com/bower/bower/issues/182))
+- Fix issue when downloading assets behind a proxy using `https` ([#230](https://github.com/bower/bower/issues/230))
+- Fix --save saving unresolved components ([#240](https://github.com/bower/bower/issues/240))
+- Fix issue when extracting some zip files ([#225](https://github.com/bower/bower/issues/225))
+- Fix automatic conflict resolver not selecting the correct version
+- Add `--sources` option to the `list` command ([#235](https://github.com/bower/bower/issues/235))
+- Automatically clear cache when git commands fail with code 128 ([#216](https://github.com/bower/bower/issues/216))
+- Fix `bower` not working correctly behind a proxy in some commands ([#208](https://github.com/bower/bower/issues/208))
+
+## 0.7.1 - 2013-02-20
+- Remove postinstall script from `bower` installation
+
+## 0.7.0 - 2013-02-01
+- __Ability to resolve conflicts__ ([#214](https://github.com/bower/bower/issues/214))
+- __Ability to search and publish to different endpoints by specifying them in the `.bowerrc` file__
+- __Experimental autocompletion__
+- __Ability to exclude (ignore) files__
+- Fix minor issues in the cache clean command
+- Better error message for invalid semver tags ([#185](https://github.com/bower/bower/issues/185))
+- Only show discover message in the list command only if there are packages
+- Fix mismatch issue due to reading cached component.json files ([#214](https://github.com/bower/bower/issues/214))
+- Better error messages when reading invalid .bowerrc files ([#220](https://github.com/bower/bower/issues/220))
+- Fix update command when used in packages pointing to assets ([#197](https://github.com/bower/bower/issues/197))
+- Bower now obeys packages's `.bowerrc` if they define a different `json` ([#205](https://github.com/bower/bower/issues/205))
+
+## 0.6.8 - 2012-12-14
+- Improve list command
+  - Does not fetch versions if not necessary (for --map and --paths options)
+  - Add --offline option to prevent versions from being fetched
+- Fix uninstall command not firing the `end` event
+- Fix error when executing an unknown command ([#179](https://github.com/bower/bower/issues/179))
+- Fix help for the ls command (alias of list)
+
+## 0.6.7 - 2012-12-10
+- Fix uninstall removing all unsaved dependencies ([#178](https://github.com/bower/bower/issues/178))
+- Fix uninstall --force flag in some cases
+- Add --silent option to the register option, to avoid questioning
+- Fix possible issues with options in some commands
+- Fix error reporting when reading invalid project component.json
+
+## 0.6.6 - 2012-12-03
+- Improve error handling while reading component.json
+- Fix package name not being correctly collected in the error summary
+
+## 0.6.5 - 2012-12-01
+- Fix error summary not being displayed in some edge cases
+- Fix bower not fetching latest commits correctly in some cases
+
+## 0.6.4 - 2012-11-29
+- Fix permission on downloaded files ([#160](https://github.com/bower/bower/issues/160))
+
+## 0.6.3 - 2012-11-24
+- Fix version not being correctly set for local packages ([#155](https://github.com/bower/bower/issues/155))
+
+## 0.6.2 - 2012-11-23
+- Fix uninstall --save when there is no component.json
+
+## 0.6.1 - 2012-11-22
+- Fix uninstall when the project component.json has no deps saved ([#153](https://github.com/bower/bower/issues/153))
+- Fix uncaught errors when using file writer (they are now caught and reported)
+- Fix temporary directories not being deleted when an exception occurs ([#153](https://github.com/bower/bower/issues/140))
+
+## 0.6.0 - 2012-11-21
+- __Add link command__ (similar to npm)
+- Fix error reporting for nested deps
+- Abort if a repository is detected when installing.
+  This is useful to prevent people from loosing their work
+- Minor fixes and improvements
+
+## 0.5.1 - 2012-11-20
+- Add errors summary to the end of install/update commands
+- Add windows instructions to the README
+
+## 0.5.0 - 2012-11-19
+- __Remove package.json support__
+- __Support for local path repositories__ ([#132](https://github.com/bower/bower/issues/132))
+- `install --save` now saves the correct tag (e.g: ~0.0.1) instead of 'latest'
+- `install --save` now saves packages pointing directly to assets correctly
+- Bower automatically creates a component.json when install with `--save` is used
+- Fix issues with list command ([#142](https://github.com/bower/bower/issues/142))
+- Fix local paths not being saved when installing with --save ([#114](https://github.com/bower/bower/issues/114))
+- `uninstall` now uninstalls nested dependencies if they are not shared ([#83](https://github.com/bower/bower/issues/83))
+- `uninstall` now warns when a dependency conflict occurs and aborts.
+  It will only proceed if the `--force` flag is passed
+- Bower now detects mismatches between the version specified in the component.json and the tag, informing the user
+- `bower ls` now informs when a package has a new commit (for non-tagged repos)
+- Add jshintrc and fix a lot of issues related with JSHint warnings
+- `bower register` now prompts if the user really wants to proceed

CONTRIBUTING.md

@@ -0,0 +1,167 @@
+# 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. 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))
+* Comment on issues and drive to resolution
+
+## High-impact Involvement
+
+* 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)
+
+## Team Meetings
+
+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),
+  [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="features"></a>
+## Feature requests
+
+Feature requests are welcome. But take a moment to find out whether your idea
+fits with the scope and aims of the project. It's up to *you* to make a strong
+case to convince the project's developers of the merits of this feature. Please
+provide as much detail and context as possible.
+
+
+<a name="pull-requests"></a>
+## Pull requests
+
+Good pull requests - patches, improvements, new features - are a fantastic
+help. They should remain focused in scope and avoid containing unrelated
+commits.
+
+**Please ask first** before embarking on any significant pull request (e.g.
+implementing features, refactoring code), otherwise you risk spending a lot of
+time working on something that the project's developers might not want to merge
+into the project.
+
+Please adhere to the coding conventions used throughout a project (indentation,
+accurate comments, etc.) and any other requirements (such as test coverage).
+
+Adhering to the following this process is the best way to get your work
+included in the project:
+
+1. [Fork](http://help.github.com/fork-a-repo/) the project, clone your fork,
+   and configure the remotes:
+
+   ```bash
+   # Clone your fork of the repo into the current directory
+   git clone https://github.com/<your-username>/bower
+   # Navigate to the newly cloned directory
+   cd bower
+   # Assign the original repo to a remote called "upstream"
+   git remote add upstream https://github.com/bower/bower
+   ```
+
+2. If you cloned a while ago, get the latest changes from upstream:
+
+   ```bash
+   git checkout master
+   git pull upstream master
+   ```
+
+3. Create a new topic branch (off the main project development branch) to
+   contain your feature, change, or fix:
+
+   ```bash
+   git checkout -b <topic-branch-name>
+   ```
+
+4. Make sure to update, or add to the tests when appropriate. Patches and
+   features will not be accepted without tests. Run `npm test` to check that
+   all tests pass after you've made changes.
+
+5. Commit your changes in logical chunks. Please adhere to these [git commit
+   message guidelines](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
+   or your code is unlikely be merged into the main project. Use Git's
+   [interactive rebase](https://help.github.com/articles/interactive-rebase)
+   feature to tidy up your commits before making them public.
+
+6. Locally merge (or rebase) the upstream development branch into your topic branch:
+
+   ```bash
+   git pull [--rebase] upstream master
+   ```
+
+7. Push your topic branch up to your fork:
+
+   ```bash
+   git push origin <topic-branch-name>
+   ```
+
+8. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/)
+    with a clear title and description.
+
+9. If you are asked to amend your changes before they can be merged in, please
+   use `git commit --amend` (or rebasing for multi-commit Pull Requests) and
+   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.
+
+
+<a name="maintainers"></a>
+## Maintainers
+
+If you have commit access, please follow this process for merging patches and cutting new releases.
+
+### Reviewing changes
+
+1. Check that a change is within the scope and philosophy of the project.
+2. Check that a change has any necessary tests and a proper, descriptive commit message.
+3. Checkout the change and test it locally.
+4. If the change is good, and authored by someone who cannot commit to
+   `master`, please try to avoid using GitHub's merge button. Apply the change
+   to `master` locally (feel free to amend any minor problems in the author's
+   original commit if necessary).
+5. If the change is good, and authored by another maintainer/collaborator, give
+   them a "Ship it!" comment and let them handle the merge.
+
+### Submitting changes
+
+1. All non-trivial changes should be put up for review using GitHub Pull
+   Requests.
+2. Your change should not be merged into `master` (or another feature branch),
+   without at least one "Ship it!" comment from another maintainer/collaborator
+   on the project. "Looks good to me" is not the same as "Ship it!".
+3. Try to avoid using GitHub's merge button. Locally rebase your change onto
+   `master` and then push to GitHub.
+4. Once a feature branch has been merged into its target branch, please delete
+   the feature branch from the remote repository.
+
+### Releasing a new version
+
+1. Include all new functional changes in the CHANGELOG.
+2. Use a dedicated commit to increment the version. The version needs to be
+   added to the `CHANGELOG.md` (inc. date) and the `package.json`.
+3. The commit message must be of `v0.0.0` format.
+4. Create an annotated tag for the version: `git tag -m "v0.0.0" v0.0.0`.
+5. Push the changes and tags to GitHub: `git push --tags origin master`.
+6. Publish the new version to npm: `npm publish`.

Gruntfile.js

@@ -0,0 +1,213 @@
+'use strict';
+
+var tmp = require('tmp');
+var childProcess = require('child_process');
+var arraydiff = require('arr-diff');
+var fs = require('fs');
+var wrench = require('wrench');
+var inquirer = require('inquirer');
+var path = require('path');
+
+module.exports = function (grunt) {
+    require('load-grunt-tasks')(grunt);
+
+    grunt.initConfig({
+        eslint: {
+            options: {
+                fix: true
+            },
+            files: [
+                'Gruntfile.js',
+                'bin/*',
+                'lib/**/*.js',
+                'test/**/*.js',
+                '!test/assets/**/*',
+                '!test/reports/**/*',
+                '!test/sample/**/*',
+                '!test/tmp/**/*'
+            ]
+        },
+        simplemocha: {
+            options: {
+                reporter: 'spec',
+                timeout: '15000'
+            },
+            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 -- --timeout 30000 -R dot test/test.js'
+            },
+            'coveralls': {
+                command: 'npm run coveralls < test/reports/lcov.info',
+                exitCodes: [0, 1, 2, 3] // Alow for failure for coverage report
+            }
+        },
+        watch: {
+            files: ['<%= eslint.files %>'],
+            tasks: ['eslint', 'simplemocha:short']
+        }
+    });
+
+    grunt.registerTask('assets', ['exec:assets-force']);
+    grunt.registerTask('test', ['eslint', 'exec:assets', 'simplemocha:full']);
+    grunt.registerTask('cover', 'exec:cover');
+    grunt.registerTask('travis', ['eslint', 'exec:assets', 'exec:cover', 'exec:coveralls']);
+    grunt.registerTask('default', 'test');
+
+    grunt.task.registerTask('publish', 'Perform final checks and publish Bower', function () {
+        var npmVersion = JSON.parse(childProcess.execSync('npm version --json').toString()).npm.split('.');
+        var npmMajor = parseInt(npmVersion[0], 10);
+        var npmMinor = parseInt(npmVersion[1], 10);
+
+        var jsonPackage = require('./package');
+
+        if (npmMajor !== 3 || npmMinor < 5) {
+            grunt.log.writeln('You need to use at least npm@3.5 to publish bower.');
+            grunt.log.writeln('It is because npm 2.x produces too long paths that Windows does not handle.');
+            grunt.log.writeln('Please upgrade it: npm install -g npm');
+            process.exit(1);
+        }
+
+        var version = jsonPackage.version;
+        var changelog = fs.readFileSync('./CHANGELOG.md');
+
+        if (changelog.indexOf('## ' + version) === -1) {
+            grunt.log.writeln('Please add changelog.md entry for this bower version (' + version + ')');
+
+            var lastRelease = childProcess.execSync('git tag | tail -1').toString().trim();
+
+            grunt.log.writeln('Commits since last release (' + lastRelease + '): \n');
+
+            grunt.log.writeln(childProcess.execSync('git log --oneline ' + lastRelease + '..').toString());
+
+            process.exit(1);
+        }
+
+        if (childProcess.execSync('git rev-parse --abbrev-ref HEAD').toString().trim() !== 'master') {
+            grunt.log.writeln('You need to release bower from the "master" branch');
+
+            process.exit(1);
+        }
+
+        if (process.env.SKIP_TESTS !== '1') {
+            grunt.log.writeln('Reinstalling dependencies...');
+            childProcess.execSync('rm -rf node_modules && npm install', { stdio: [0, 1, 2] });
+
+            grunt.log.writeln('Running test suite...');
+            childProcess.execSync('grunt test', { stdio: [0, 1, 2] });
+        }
+
+        var dir = tmp.dirSync().name;
+
+        wrench.copyDirSyncRecursive(__dirname, dir, {
+            forceDelete: true,
+            include: function (path) {
+                return !path.match(/node_modules|\.git|test/);
+            }
+        });
+
+        grunt.log.writeln('Installing production dependencies...');
+        childProcess.execSync('npm install --production --silent', { cwd: dir, stdio: [0, 1, 2] });
+
+        delete jsonPackage.dependencies;
+        delete jsonPackage.devDependencies;
+        delete jsonPackage.scripts;
+
+        fs.writeFileSync(path.resolve(dir, 'package.json'), JSON.stringify(jsonPackage, null, '  ') + '\n');
+
+
+        grunt.log.writeln('Moving node_modules to lib directory...');
+
+        wrench.copyDirSyncRecursive(path.resolve(dir, 'node_modules'), path.resolve(dir, 'lib', 'node_modules'));
+        wrench.rmdirSyncRecursive(path.resolve(dir, 'node_modules'));
+
+        grunt.log.writeln('Testing bower on sample project...');
+
+        childProcess.execSync(
+            'cd test/sample && rm -rf bower_components && ' + dir + '/bin/bower install --force', { stdio: [0, 1, 2] }
+        );
+
+        var expectedPackages = (
+            'SHA-1 ace-builds almond angular angular-animate angular-bootstrap angular-charts angular-contenteditable ' +
+            'angular-deckgrid angular-fullscreen angular-gravatar angular-hotkeys angular-local-storage angular-marked ' +
+            'angular-moment angular-sanitize angular-touch angular-ui-router angular-ui-sortable ' +
+            'angulartics asEvented bootstrap coffee-script d3 es6-shim font-awesome howler jquery ' +
+            'jquery-ui jquery-waypoints js-beautify lodash lz-string marked moment ng-file-upload peerjs ' +
+            'requirejs restangular slimScroll slimScrollHorizontal venturocket-angular-slider'
+        ).split(' ');
+
+        var installedPackages = fs.readdirSync('./test/sample/bower_components');
+
+        var installedDiff = arraydiff(expectedPackages, installedPackages);
+
+        if (installedDiff.length > 0) {
+            grunt.log.writeln('ERROR. Some packages were not installed by bower: ');
+            grunt.log.writeln(installedDiff.join(', '));
+
+            process.exit(1);
+        }
+
+        grunt.log.writeln('\nBower production bundle installed in:');
+        grunt.log.writeln(dir + '\n');
+
+        var questions = [
+            {
+                type: 'confirm',
+                name: 'review',
+                message: 'Did you review all the changes with "git diff"?',
+                default: false
+            },
+            {
+                type: 'confirm',
+                name: 'changelog',
+                message: 'Are you sure the CHANGELOG.md contains all changes?',
+                default: false
+            },
+            {
+                type: 'confirm',
+                name: 'tests',
+                message: 'Are you sure all tests are passing on Travis and Appveyor?',
+                default: false
+            },
+            {
+                type: 'confirm',
+                name: 'publish',
+                message: 'Are you SURE you want to publish ' + jsonPackage.name + '@' + jsonPackage.version + '?',
+                default: false
+            }
+        ];
+
+        var done = this.async();
+
+        inquirer.prompt(questions, function (answers) {
+            if (!answers.review || !answers.changelog || !answers.tests || !answers.publish) {
+                grunt.log.writeln('Please publish bower after you fix this issue');
+
+                process.exit(1);
+            }
+
+            grunt.log.writeln('\nPlease remember to tag this relese, and add a release on Github!');
+            grunt.log.writeln('\nAlso, please remember to test published Bower one more time!');
+            grunt.log.writeln('\nPublishing Bower...');
+
+            childProcess.execSync('npm publish --tag beta', { cwd: dir, stdio: [0, 1, 2] });
+
+            done();
+        });
+    });
+};

LICENSE

@@ -1,7 +1,19 @@
-Copyright (c) 2012 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 the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+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
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -1,4 +0,0 @@
-test:
-	./node_modules/.bin/mocha -R spec -t 10000
-
-.PHONY: test

README.md

@@ -1,217 +1,200 @@
-BOWER [![Build Status](https://secure.travis-ci.org/twitter/bower.png)](http://travis-ci.org/twitter/bower)
-=====
+# Bower - A package manager for the web
 
-### Introduction
+[![Backers on Open Collective](https://opencollective.com/bower/backers/badge.svg)](#backers)
+[![Sponsors on Open Collective](https://opencollective.com/bower/sponsors/badge.svg)](#sponsors)
 
-Bower is a package manager for the web. Bower lets you easily install assets such as images, CSS and JavaScript, and manages dependencies for you.
+> ..psst! While Bower is maintained, we recommend [yarn](https://yarnpkg.com/) and [webpack](https://webpack.js.org/) for new front-end projects!
 
-For example, to install a package, run:
+[![Unix CI](https://img.shields.io/travis/bower/bower/master.svg?maxAge=2592000)](https://travis-ci.org/bower/bower)
+[![Windows CI](https://img.shields.io/appveyor/ci/bower/bower/master.svg)](https://ci.appveyor.com/project/bower/bower)
+[![Coverage Status](https://img.shields.io/coveralls/bower/bower.svg)](https://coveralls.io/r/bower/bower?branch=master)
+[![Discord chat](https://img.shields.io/badge/discord-join%20chat%20%E2%86%92-brightgreen.svg?style=flat)](https://discord.gg/0fFM7QF0KpZRh2cY)
 
-    bower install jquery
+<img align="right" height="300" src="http://bower.io/img/bower-logo.png">
 
-This will download jQuery to `./components/jquery`. That's it. The idea is that Bower does package management and package management only.
+---
 
-### Installing Bower
+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 is installed using [Node](http://nodejs.org/) and [npm](http://npmjs.org/) (oh my, how meta).
+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.).
 
-    npm install bower -g
+**View complete docs on [bower.io](http://bower.io)**
 
-### Usage
+[View all packages available through Bower's registry](http://bower.io/search/).
 
-Your best friend at this stage is probably `bower --help`.
+## Install
 
-To install a package:
-
-    bower install jquery
-    bower install git://github.com/maccman/package-jquery.git
-    bower install http://code.jquery.com/jquery-1.7.2.js
-    bower install ./repos/jquery
-
-As you can see, packages can be installed by name, Git endpoint, URL or local path.
-
-[View all packages available through Bower's registry](http://sindresorhus.com/bower-components/).
-
-During install you can have Bower add an entry to your component.json as well:
-
-    bower install --save jquery
-
-To update a package, reference it by name:
-
-    bower update jquery-ui
-
-To list installed packages:
-
-    bower list
-
-To search for packages:
-
-    bower search [name]
-
-To list all the available packages, just call `bower search` without specifying a name.
-
-### Defining a package
-
-You can create a `component.json` file in your project's root, specifying 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.
-
-```json
-{
-  "name": "myProject",
-  "version": "1.0.0",
-  "main": "./path/to/main.css",
-  "dependencies": {
-    "jquery": "~1.7.2"
-  }
-}
+```sh
+$ npm install -g bower
 ```
 
-Put this under your project's root, listing all of your dependencies. When you run `bower install`, Bower will read this `component.json` file, resolve all the relevant dependencies and install them.
+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.
 
-For now, `name`, `version`, `main`, and `dependencies` are the only properties that are used by Bower. If you have several files you're distributing as part of your package, pass an array to `main` like this:
 
-```json
-{
-  "name": "myProject",
-  "version": "1.0.0",
-  "main": ["./path/to/app.css", "./path/to/app.js", "./path/to/sprite.img"],
-  "dependencies": {
-    "jquery": "~1.7.2"
-  }
-}
+## Usage
+
+See complete command line reference at [bower.io/docs/api/](http://bower.io/docs/api/)
+
+### Installing packages and dependencies
+
+```sh
+# install dependencies listed in bower.json
+$ bower install
+
+# 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
 ```
 
-There should only be at most one file per file type in the `main` list. So only one `.js` or `.css`.
+### Using packages
 
-### Installing dependencies
+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).
 
-Dependencies are installed locally via the `bower install` command. First they’re resolved to find conflicts. Then they’re downloaded and unpacked in a local subdirectory called `./components`, for example:
+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
 
-```
-/component.json
-/components/jquery/index.js
-/components/jquery/component.json
+To uninstall a locally installed package:
+
+```sh
+$ bower uninstall <package-name>
 ```
 
-You can also install packages one at a time `bower install git://my/git/thing`
+### prezto and oh-my-zsh users
 
-There are no system wide dependencies, no dependencies are shared between different apps, and the dependency tree is flat.
+On `prezto` or `oh-my-zsh`, do not forget to `alias bower='noglob bower'` or `bower install jquery\#1.9.1`
 
-### Deploying
+### Never run Bower with sudo
 
-The easiest approach is to use Bower statically, just reference the packages manually from a script tag:
+Bower is a user command; there is no need to execute it with superuser permissions.
 
-    <script src="components/jquery/index.js"></script>
+### Windows users
 
-For more complex projects, you'll probably want to concatenate your scripts. Bower is just a package manager, but there are lots of awesome libraries out there to help you do this, such as [Sprockets](https://github.com/sstephenson/sprockets) and [RequireJS](http://requirejs.org/).
+To use Bower on Windows, you must install
+[Git for Windows](http://git-for-windows.github.io/) correctly. Be sure to check the
+options shown below:
 
-For example, to use Sprockets:
+<img src="https://cloud.githubusercontent.com/assets/10702007/10532690/d2e8991a-7386-11e5-9a57-613c7f92e84e.png" width="534" height="418" alt="Git for Windows" />
 
-```ruby
-environment = Sprockets::Environment.new
-environment.append_path 'components'
-environment.append_path 'public'
-run environment
+<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.
+
+### Ubuntu users
+
+To use Bower on Ubuntu, you might need to link `nodejs` executable to `node`:
+
+```
+sudo ln -s /usr/bin/nodejs /usr/bin/node
 ```
 
-### Package Consumption
+## Configuration
 
-Bower also makes available a source mapping – this can be used by build tools to easily consume Bower components.
+Bower can be configured using JSON in a `.bowerrc` file. Read over available options at [bower.io/docs/config](http://bower.io/docs/config).
 
-If you pass the option `--map` to bower's `list` command, it will generate a JSON with dependency objects. Alternatively, you can pass the `--paths` flag to the `list` command to get a simple path to name mapping:
 
-```json
-{
-  "backbone": "components/backbone/index.js",
-  "jquery": "components/jquery/index.js",
-  "underscore": "components/underscore/index.js"
-}
+## Support
+
+* [Discord chat](https://discord.gg/0fFM7QF0KpZRh2cY)
+* [StackOverflow](http://stackoverflow.com/questions/tagged/bower)
+* [Mailinglist](http://groups.google.com/group/twitter-bower) - twitter-bower@googlegroups.com
+
+## Contributing
+
+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).
+
+* [Bug reports](https://github.com/bower/bower/wiki/Report-a-Bug)
+* [Feature requests](CONTRIBUTING.md#features)
+* [Pull requests](CONTRIBUTING.md#pull-requests)
+
+
+Note that on Windows for tests to pass you need to configure Git before cloning:
+
+```
+git config --global core.autocrlf input
 ```
 
-### Authoring packages
 
-To register a new package, it's as simple as specifying a `component.json`, pushing the package to a Git endpoint, say GitHub, and running:
+## Backers
 
-    bower register myawesomepackagename git://github.com/maccmans/face
+Support us with a monthly donation and help us continue our activities. [[Become a backer](https://opencollective.com/bower#backer)]
 
-There's no authentication or user management. It's on a first come, first served basis. Think of it like a URL shortener. Now anyone can run `bower install myawesomepackagename`, and get your library installed.
-
-### Philosophy
-
-Currently, people are managing dependencies, such as JavaScript libraries, manually. This sucks, and we want to change it.
-
-In a nutshell, Bower is a generic tool which will resolve dependencies and lock packages down to a version. It runs over Git, and is package-agnostic. A package may contain JavaScript, CSS, images, etc., and doesn't rely on any particular transport (AMD, CommonJS, etc.).
-
-Bower then makes available a simple programmatic API which exposes the package dependency model, so that existing build tools (like Sprockets, LoadBuilder, curls.js, Ender, etc.) can consume it and build files accordingly.
+<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>
 
 
-### FAQ
+## Sponsors
 
-**What distinguishes Bower from Jam, Volo, Component, or Ender? What does it do better?**
+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)]
 
-Bower is a lower level component than Jam, Volo, Component, or Ender. These managers could consume Bower as a dependency.
+<a href="https://opencollective.com/bower/sponsor/0/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/0/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/1/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/2/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/3/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/4/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/5/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/6/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/7/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/8/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/9/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/9/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/10/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/10/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/11/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/11/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/12/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/12/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/13/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/13/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/14/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/14/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/15/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/15/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/16/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/16/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/17/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/17/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/18/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/18/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/19/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/19/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/20/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/20/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/21/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/21/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/22/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/22/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/23/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/23/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/24/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/24/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/25/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/25/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/26/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/26/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/27/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/27/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/28/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/28/avatar.svg"></a>
+<a href="https://opencollective.com/bower/sponsor/29/website" target="_blank"><img src="https://opencollective.com/bower/sponsor/29/avatar.svg"></a>
 
-Bower's aim is simply to install Git paths, resolve dependencies from a `component.json`, check versions, and then provide an API which reports on these things. Nothing more. This is a major diversion from past attempts at browser package management.
-
-Bower is working under the assumption that there is a single, common problem in frontend application development: dependency resolution. Past attempts (Jam, Volo, Ender, Component) try to tackle this problem in such a way that they actually end up alienating and further segregating the JavaScript community around transports (Sprockets, CommonJS, RequireJS, regular script tags).
-
-Bower offers a generic, unopinionated solution to the problem of package management, while exposing an API that can be consumed by a more opinionated build stack.
-
-
-**Volo is an arguably more established project and works with the GitHub search API. Will it take long for Bower to contain a decent number of packages?**
-
-Bower (being a Git powered package manager) should, in theory, be capable of consuming every package that Volo does, with the additional benefit of supporting internal networks and other Git repositories not hosted on GitHub.
-
-**We recently saw what happened when the main NPM registry went down. Is a single point of failure possible for Bower and if so, do you have redundancy planned?**
-
-There's no redundancy planned at the moment, as Bower just installs Git URLs. It's up to the URL provider to establish redundancy.
-
-**Isn't having a `package.json` file going to conflict with my npm's `package.json`? Will this be a problem?**
-
-Don't use a `package.json` – use a `component.json`.
-
-**Bower is an open-source Twitter project. How well can we expect it to be maintained in the future?**
-
-Twitter is in the process of migrating its frontend architecture onto Bower, so it's fairly safe to say it will be maintained and invested in going forward.
-
-
-### Contact
-
-Have a question? Ask on our mailing list!
-
-twitter-bower@googlegroups.com
-
-http://groups.google.com/group/twitter-bower
-
-### Authors
-
-+ [@fat](http://github.com/fat)
-+ [@maccman](http://github.com/maccman)
-
-Thanks for assistance and contributions:
-
-+ [@addyosmani](http://github.com/addyosmani)
-+ [@angus-c](http://github.com/angus-c)
-+ [@borismus](http://github.com/borismus)
-+ [@chriseppstein](http://github.com/chriseppstein)
-+ [@danwrong](http://github.com/danwrong)
-+ [@desandro](http://github.com/desandro)
-+ [@isaacs](http://github.com/isaacs)
-+ [@josh](http://github.com/josh)
-+ [@jrburke](http://github.com/jrburke)
-+ [@mklabs](http://github.com/mklabs)
-+ [@paulirish](http://github.com/paulirish)
-+ [@rvagg](http://github.com/rvagg)
-+ [@sindresorhus](http://github.com/sindresorhus)
-+ [@SlexAxton](http://github.com/SlexAxton)
-+ [@sstephenson](http://github.com/sstephenson)
-+ [@tomdale](http://github.com/tomdale)
-+ [@visionmedia](http://github.com/visionmedia)
-+ [@wagenet](http://github.com/wagenet)
-+ [@wycats](http://github.com/wycats)
 
 ## License
 
-Copyright 2012 Twitter, Inc.
+Copyright (c) 2012-present Twitter and [other contributors](https://github.com/bower/bower/graphs/contributors)
 
 Licensed under the MIT License

bin/bower

@@ -1,40 +1,3 @@
 #!/usr/bin/env node
 
-var semver = require('semver');
-var nopt   = require('nopt');
-var path   = require('path');
-var pkg    = require(path.join(__dirname, '..', 'package.json'));
-
-var template = require('../lib/util/template');
-var bower    = require('../lib');
-
-var command;
-var options;
-var shorthand;
-var input   = process.argv;
-var cmdList = Object.keys(bower.commands);
-var nodeVer = process.version;
-var reqVer  = pkg.engines.node;
-
-process.title = 'bower';
-
-if (reqVer && !semver.satisfies(nodeVer, reqVer)) {
-  throw new Error('Required: node ' + reqVer);
-}
-
-shorthand = { 'v': ['--version'] };
-options   = { version: Boolean };
-options   = nopt(options, shorthand, process.argv);
-
-bower.version = pkg.version;
-
-if (options.version) return console.log(bower.version);
-if (~cmdList.indexOf(command = options.argv.remain && options.argv.remain.shift())) bower.command = command;
-
-bower.commands[bower.command || 'help'].line(input)
-  .on('data',  function (data) { data && console.log(data); })
-  .on('end',   function (data) { data && console.log(data); })
-  .on('error', function (err)  {
-    if   (options.verbose) throw err;
-    else template('error', { message: err.message }).on('data', function (d) { console.log (d); });
-  })
+require('../lib/bin/bower');

lib/bin/bower.js

@@ -0,0 +1,145 @@
+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

@@ -0,0 +1,185 @@
+var fs = require('../../util/fs');
+var path = require('path');
+var mout = require('mout');
+var Q = require('q');
+var rimraf = require('../../util/rimraf');
+var endpointParser = require('bower-endpoint-parser');
+var PackageRepository = require('../../core/PackageRepository');
+var semver = require('../../util/semver');
+var defaultConfig = require('../../config');
+
+function clean(logger, endpoints, options, config) {
+    var decEndpoints;
+    var names;
+
+    options = options || {};
+    config = defaultConfig(config);
+
+    // If endpoints is an empty array, null them
+    if (endpoints && !endpoints.length) {
+        endpoints = null;
+    }
+
+    // Generate decomposed endpoints and names based on the endpoints
+    if (endpoints) {
+        decEndpoints = endpoints.map(function (endpoint) {
+            return endpointParser.decompose(endpoint);
+        });
+        names = decEndpoints.map(function (decEndpoint) {
+            return decEndpoint.name || decEndpoint.source;
+        });
+    }
+
+    return Q.all([
+        clearPackages(decEndpoints, config, logger),
+        clearLinks(names, config, logger)
+    ])
+    .spread(function (entries) {
+        return entries;
+    });
+}
+
+function clearPackages(decEndpoints, config, logger) {
+    var repository =  new PackageRepository(config, logger);
+
+    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) {
+                    var entryPkgMeta = entry.pkgMeta;
+
+                    // Check if name or source match the entry
+                    if  (decEndpoint.name !== entryPkgMeta.name &&
+                        decEndpoint.source !== entryPkgMeta.name &&
+                        decEndpoint.source !== entryPkgMeta._source
+                    ) {
+                        return false;
+                    }
+
+                    // If target is a wildcard, simply return true
+                    if (decEndpoint.target === '*') {
+                        return true;
+                    }
+
+                    // If it's a semver target, compare using semver spec
+                    if (semver.validRange(decEndpoint.target)) {
+                        return semver.satisfies(entryPkgMeta.version, decEndpoint.target);
+                    }
+
+                    // Otherwise, compare against target/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
+                });
+            });
+        });
+
+        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;
+        });
+    });
+}
+
+function clearLinks(names, config, logger) {
+    var promise;
+    var dir = config.storage.links;
+
+    // If no names are passed, grab all links
+    if (!names) {
+        promise = Q.nfcall(fs.readdir, dir)
+        .fail(function (err) {
+            if (err.code === 'ENOENT') {
+                return [];
+            }
+
+            throw err;
+        });
+    // Otherwise use passed ones
+    } else {
+        promise = Q.resolve(names);
+    }
+
+    return promise
+    .then(function (names) {
+        var promises;
+        var linksToRemove = [];
+
+        // Decide which links to delete
+        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()) {
+                        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 () {
+            var promises;
+
+            // Remove each link that was declared as invalid
+            promises = linksToRemove.map(function (link) {
+                return Q.nfcall(rimraf, link)
+                .then(function () {
+                    logger.info('deleted', 'Invalid link: ' + link, {
+                        file: link
+                    });
+                });
+            });
+
+            return Q.all(promises);
+        });
+    });
+}
+
+// -------------------
+
+clean.readOptions = function (argv) {
+    var cli = require('../../util/cli');
+    var options = cli.readOptions(argv);
+    var endpoints = options.argv.remain.slice(2);
+
+    delete options.argv;
+
+    return [endpoints, options];
+};
+
+module.exports = clean;

lib/commands/cache/list.js

@@ -0,0 +1,43 @@
+var mout = require('mout');
+var PackageRepository = require('../../core/PackageRepository');
+var defaultConfig = require('../../config');
+
+function list(logger, packages, options, config) {
+    var repository;
+
+    config = defaultConfig(config);
+    repository = new PackageRepository(config, logger);
+
+    // If packages is an empty array, null them
+    if (packages && !packages.length) {
+        packages = null;
+    }
+
+    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) {
+                    return pkg === entry.pkgMeta.name;
+                });
+            });
+        }
+
+        return entries;
+    });
+}
+
+// -------------------
+
+list.readOptions = function (argv) {
+    var cli = require('../../util/cli');
+    var options = cli.readOptions(argv);
+    var packages = options.argv.remain.slice(2);
+
+    delete options.argv;
+
+    return [packages, options];
+};
+
+module.exports = list;

lib/commands/help.js

@@ -1,35 +1,39 @@
-// ==========================================
-// BOWER: Help API
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
+var Q = require('q');
+var path = require('path');
+var fs = require('../util/fs');
+var createError = require('../util/createError');
 
-var events = require('events');
-var hogan  = require('hogan.js');
-var nopt   = require('nopt');
-var path   = require('path');
-var fs     = require('fs');
-var _      = require('lodash');
+function help(logger, name, config) {
+    var json;
 
-var template  = require('../util/template');
-var config    = require('../core/config');
+    if (name) {
+        json = path.resolve(__dirname, '../templates/json/help-' + name.replace(/\s+/g, '/') + '.json');
+    } else {
+        json = path.resolve(__dirname, '../templates/json/help.json');
+    }
 
-module.exports = function (name) {
-  var context      = {};
-  var emitter      = new events.EventEmitter;
-  var commands     = require('../commands');
-  var templateName = name ? 'help-' + name : 'help';
+    return Q.promise(function (resolve) {
+        fs.exists(json, resolve);
+    })
+    .then(function (exists) {
+        if (!exists) {
+            throw createError('Unknown command: ' + name, 'EUNKNOWNCMD', {
+                command: name
+            });
+        }
 
-  if (!name) context = { commands: Object.keys(commands).join(', ') };
-  _.extend(context, config)
-  template(templateName, context).on('data', emitter.emit.bind(emitter, 'end'));
-  return emitter;
+        return require(json);
+    });
 }
 
-module.exports.line = function (argv) {
-  var options  = nopt({}, {}, argv);
-  var paths    = options.argv.remain.slice(1);
-  return module.exports(paths[0]);
-};
+// -------------------
+
+help.readOptions = function (argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
+    var name = options.argv.remain.slice(1).join(' ');
+
+    return [name];
+};
+
+module.exports = help;

lib/commands/home.js

@@ -0,0 +1,58 @@
+var Project = require('../core/Project');
+var open = require('opn');
+var endpointParser = require('bower-endpoint-parser');
+var createError = require('../util/createError');
+var defaultConfig = require('../config');
+
+function home(logger, name, config) {
+    var project;
+    var promise;
+    var decEndpoint;
+
+    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) {
+            if (!json) {
+                throw createError('You are not inside a package', 'ENOENT');
+            }
+
+            return project.getJson();
+        });
+    } else {
+        decEndpoint = endpointParser.decompose(name);
+        promise = project.getPackageRepository().fetch(decEndpoint)
+        .spread(function (canonicalDir, pkgMeta) {
+            return pkgMeta;
+        });
+    }
+
+    // Get homepage and open it
+    return promise.then(function (pkgMeta) {
+        var homepage = pkgMeta.homepage;
+
+        if (!homepage) {
+            throw createError('No homepage set for ' + pkgMeta.name, 'ENOHOME');
+        }
+
+        open(homepage, { wait: false });
+        return homepage;
+    });
+}
+
+// -------------------
+
+home.readOptions = function (argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
+    var name = options.argv.remain[1];
+
+    return [name];
+};
+
+module.exports = home;

lib/commands/index.js

@@ -1,20 +1,81 @@
-// ==========================================
-// BOWER: Public Commands List
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
+var Q = require('q');
+var Logger = require('bower-logger');
+var config = require('../config');
+
+/**
+ * Require commands only when called.
+ *
+ * Running `commandFactory(id)` is equivalent to `require(id)`. Both calls return
+ * a command function. The difference is that `cmd = commandFactory()` and `cmd()`
+ * return as soon as possible and load and execute the command asynchronously.
+ */
+function commandFactory(id) {
+    function runApi() {
+        var command = require(id);
+        var commandArgs = [].slice.call(arguments);
+
+        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;
+    }
+
+    runApi.line = runFromArgv;
+
+    return runApi;
+}
+
 
 module.exports = {
-  'help':       require('./help'),
-  'install':    require('./install'),
-  'list':       require('./list'),
-  'ls':         require('./list'),
-  'uninstall':  require('./uninstall'),
-  'update':     require('./update'),
-  'lookup':     require('./lookup'),
-  'info':       require('./info'),
-  'register':   require('./register'),
-  'search':     require('./search')
-};
+    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,44 +1,70 @@
-// ==========================================
-// BOWER: Lookup API
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
+var mout = require('mout');
+var Q = require('q');
+var endpointParser = require('bower-endpoint-parser');
+var PackageRepository = require('../core/PackageRepository');
+var defaultConfig = require('../config');
 
-var Emitter  = require('events').EventEmitter;
-var nopt     = require('nopt');
+function info(logger, endpoint, property, config) {
+    if (!endpoint) {
+        return;
+    }
 
-var template = require('../util/template');
-var source   = require('../core/source');
-var help     = require('./help');
+    // handle @ as version divider
+    var splitParts = endpoint.split('/');
+    splitParts[splitParts.length - 1] = splitParts[splitParts.length - 1].replace('@', '#');
+    endpoint = splitParts.join('/');
 
-var optionTypes = { help: Boolean };
-var shorthand   = { 'h': ['--help'] };
 
-module.exports = function (name) {
-  var emitter = new Emitter;
+    var repository;
+    var decEndpoint;
 
-  name && source.info(name, function (err, result) {
-    if (err) return emitter.emit('error', err);
-    emitter.emit('end', result);
-  });
+    config = defaultConfig(config);
+    repository = new PackageRepository(config, logger);
 
-  return emitter;
+    decEndpoint = endpointParser.decompose(endpoint);
+
+    return Q.all([
+        getPkgMeta(repository, decEndpoint, property),
+        decEndpoint.target === '*' && !property ? repository.versions(decEndpoint.source) : null
+    ])
+        .spread(function (pkgMeta, versions) {
+            if (versions) {
+                return {
+                    name: decEndpoint.source,
+                    versions: versions,
+                    latest: pkgMeta
+                };
+            }
+
+            return pkgMeta;
+        });
+}
+
+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) !== '_';
+            });
+
+            // Retrieve specific property
+            if (property) {
+                pkgMeta = mout.object.get(pkgMeta, property);
+            }
+
+            return pkgMeta;
+        });
+}
+
+// -------------------
+
+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];
+
+    return [pkg, property];
 };
 
-module.exports.line = function (argv) {
-  var emitter  = new Emitter;
-  var options  = nopt(optionTypes, shorthand, argv);
-  var names    = options.argv.remain.slice(1);
-
-  if (options.help || !names.length) return help('info');
-
-  module.exports(names[0])
-    .on('error', emitter.emit.bind(emitter, 'error'))
-    .on('end'  , function (data) {
-      template('info', data).on('data', emitter.emit.bind(emitter, 'end'));
-    });
-
-  return emitter;
-};
+module.exports = info;

lib/commands/init.js

@@ -0,0 +1,313 @@
+var mout = require('mout');
+var fs = require('../util/fs');
+var path = require('path');
+var Q = require('q');
+var endpointParser = require('bower-endpoint-parser');
+var Project = require('../core/Project');
+var defaultConfig = require('../config');
+var GitHubResolver = require('../core/resolvers/GitHubResolver');
+var cmd = require('../util/cmd');
+var createError = require('../util/createError');
+
+function init(logger, config) {
+    var project;
+
+    config = config || {};
+
+    if (!config.cwd) {
+        config.cwd = process.cwd();
+    }
+
+    config = defaultConfig(config);
+
+    // This command requires interactive to be enabled
+    if (!config.interactive) {
+        throw createError('Register requires an interactive shell', 'ENOINT', {
+            details: 'Note that you can manually force an interactive shell with --config.interactive'
+        });
+    }
+
+    project = new Project(config, logger);
+
+    // Start with existing JSON details
+    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) {
+        if (json) {
+            logger.warn('existing', 'The existing ' + path.basename(json) + ' file will be used and filled in');
+        }
+
+        return project.getJson();
+    });
+}
+
+function saveJson(project, logger, json) {
+    // Cleanup empty props (null values, empty strings, objects and arrays)
+    mout.object.forOwn(json, function (value, key) {
+        if (!validConfigValue(value)) {
+            delete json[key];
+        }
+    });
+
+    logger.info('json', 'Generated json', { json: json });
+
+    // Confirm the json with the user
+    return Q.nfcall(logger.prompt.bind(logger), {
+        type: 'confirm',
+        message: 'Looks good?',
+        default: true
+    })
+    .then(function (good) {
+        if (!good) {
+            return null;
+        }
+
+        // Save json (true forces file creation)
+        return project.saveJson(true);
+    });
+}
+
+// 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();
+
+    // Name
+    if (!json.name) {
+        json.name = path.basename(config.cwd);
+    }
+
+    // Main
+    if (!json.main) {
+        // Remove '.js' from the end of the package name if it is there
+        name = path.basename(json.name, '.js');
+
+        if (fs.existsSync(path.join(config.cwd, 'index.js'))) {
+            json.main = 'index.js';
+        } else if (fs.existsSync(path.join(config.cwd, name + '.js'))) {
+            json.main = name + '.js';
+        }
+    }
+
+    // Homepage
+    if (!json.homepage) {
+        // Set as GitHub homepage if it's a GitHub repository
+        promise = promise.then(function () {
+            return cmd('git', ['config', '--get', 'remote.origin.url'])
+            .spread(function (stdout) {
+                var pair;
+
+                stdout = stdout.trim();
+                if (!stdout) {
+                    return;
+                }
+
+                pair = GitHubResolver.getOrgRepoPair(stdout);
+                if (pair) {
+                    json.homepage = 'https://github.com/' + pair.org + '/' + pair.repo;
+                }
+            })
+            .fail(function () { });
+        });
+    }
+
+    if (!json.authors) {
+        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();
+
+                // 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 () {});
+        });
+    }
+
+    return promise.then(function () {
+        return json;
+    });
+}
+
+function promptUser(logger, json) {
+    var questions = [
+        {
+            'name': 'name',
+            'message': 'name',
+            'default': json.name,
+            'type': 'input'
+        },
+        {
+            'name': 'description',
+            'message': 'description',
+            'default': json.description,
+            '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': 'authors',
+            'message': 'authors',
+            'default': json.authors ? json.authors.toString() : null,
+            'type': 'input'
+        },
+        {
+            'name': 'license',
+            'message': 'license',
+            'default': json.license || 'MIT',
+            'type': 'input'
+        },
+        {
+            'name': 'homepage',
+            'message': 'homepage',
+            'default': json.homepage,
+            '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': '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'
+        }
+    ];
+
+    return Q.nfcall(logger.prompt.bind(logger), questions)
+    .then(function (answers) {
+        json.name = answers.name;
+        json.description = answers.description;
+        json.main = answers.main;
+        json.keywords = toArray(answers.keywords);
+        json.authors = toArray(answers.authors, ',');
+        json.license = answers.license;
+        json.homepage = answers.homepage;
+        json.private = answers.private || null;
+
+        return [json, answers];
+    });
+}
+
+function toArray(value, splitter) {
+    var arr = value.split(splitter || /[\s,]/);
+
+    // Trim values
+    arr = arr.map(function (item) {
+        return item.trim();
+    });
+
+    // Filter empty values
+    arr = arr.filter(function (item) {
+        return !!item;
+    });
+
+    return arr.length ? arr : null;
+}
+
+function setIgnore(config, json, answers) {
+    if (answers.ignore) {
+        json.ignore = mout.array.combine(json.ignore || [], [
+            '**/.*',
+            'node_modules',
+            'bower_components',
+            config.directory,
+            'test',
+            'tests'
+        ]);
+    }
+
+    return [json, answers];
+}
+
+function setDependencies(project, json, answers) {
+    if (answers.dependencies) {
+        return project.getTree()
+        .spread(function (tree, flattened, extraneous) {
+            if (extraneous.length) {
+                json.dependencies = {};
+
+                // Add extraneous as dependencies
+                extraneous.forEach(function (extra) {
+                    var jsonEndpoint;
+
+                    // Skip linked packages
+                    if (extra.linked) {
+                        return;
+                    }
+
+                    jsonEndpoint = endpointParser.decomposed2json(extra.endpoint);
+                    mout.object.mixIn(json.dependencies, jsonEndpoint);
+                });
+            }
+
+            return [json, answers];
+        });
+    }
+
+    return [json, answers];
+}
+
+// -------------------
+
+init.readOptions = function (argv) {
+    return [];
+};
+
+module.exports = init;

lib/commands/install.js

@@ -1,47 +1,51 @@
-// ==========================================
-// BOWER: Install API
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
-// 1. Recursively resolve dependencies
-// 2. Intelligently work out which deps to
-//    use (versioning)
-// 3. Throw if deps conflict
-// ==========================================
+var endpointParser = require('bower-endpoint-parser');
+var Project = require('../core/Project');
+var defaultConfig = require('../config');
 
-var Emitter = require('events').EventEmitter;
-var async   = require('async');
-var nopt    = require('nopt');
+function install(logger, endpoints, options, config) {
+    var project;
+    var decEndpoints;
 
-var Manager = require('../core/manager');
-var save    = require('../util/save');
-var list    = require('./list');
-var help    = require('./help');
+    options = options || {};
+    config = defaultConfig(config);
+    if (options.save === undefined) {
+        options.save = config.defaultSave;
+    }
+    project = new Project(config, logger);
 
-var optionTypes = { help: Boolean };
-var shorthand   = { 'h': ['--help'], 'S': ['--save'] };
+    // Convert endpoints to decomposed endpoints
+    endpoints = endpoints || [];
+    decEndpoints = endpoints.map(function (endpoint) {
 
-module.exports = function (paths, options) {
-  var emitter = new Emitter;
-  var manager = new Manager(paths)
+        // handle @ as version divider
+        var splitParts = endpoint.split('/');
+        splitParts[splitParts.length - 1] = splitParts[splitParts.length - 1].replace('@', '#');
+        endpoint = splitParts.join('/');
 
-  if (options && options.save) save(emitter, manager, paths);
+        return endpointParser.decompose(endpoint);
+    });
 
-  manager
-    .on('data'    , emitter.emit.bind(emitter, 'data'))
-    .on('error'   , emitter.emit.bind(emitter, 'error'))
-    .on('resolve' , emitter.emit.bind(emitter, 'end'))
-    .resolve();
+    return project.install(decEndpoints, options, config);
+}
 
-  return emitter;
+// -------------------
+
+install.readOptions = function (argv) {
+    var cli = require('../util/cli');
+
+    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);
+
+    var packages = options.argv.remain.slice(1);
+
+    delete options.argv;
+
+    return [packages, options];
 };
 
-module.exports.line = function (argv) {
-  var options  = nopt(optionTypes, shorthand, argv);
-  var paths    = options.argv.remain.slice(1);
-
-  if (options.help) return help('install');
-  return module.exports(paths, options);
-};
+module.exports = install;

lib/commands/link.js

@@ -0,0 +1,85 @@
+var path = require('path');
+var rimraf = require('../util/rimraf');
+var Q = require('q');
+var Project = require('../core/Project');
+var createLink = require('../util/createLink');
+var defaultConfig = require('../config');
+var relativeToBaseDir = require('../util/relativeToBaseDir');
+
+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;
+
+    config = defaultConfig(config);
+    project = new Project(config, logger);
+
+    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
+            };
+        });
+    });
+}
+
+function linkTo(logger, name, localName, config) {
+    var src;
+    var dst;
+    var project;
+
+    config = defaultConfig(config);
+    project = new Project(config, logger);
+
+    localName = localName || name;
+    src = path.join(config.storage.links, name);
+    dst = path.join(relativeToBaseDir(config.cwd)(config.directory), localName);
+
+    // Delete destination folder if any
+    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
+        };
+    });
+}
+
+// -------------------
+
+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];
+
+    return [name, localName];
+};
+
+module.exports = link;

lib/commands/list.js

@@ -1,181 +1,166 @@
-// ==========================================
-// BOWER: List API
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
+var path = require('path');
+var mout = require('mout');
+var Q = require('q');
+var Project = require('../core/Project');
+var semver = require('../util/semver');
+var defaultConfig = require('../config');
 
-var Emitter = require('events').EventEmitter;
-var semver  = require('semver');
-var archy   = require('archy');
-var async   = require('async');
-var nopt    = require('nopt');
-var path    = require('path');
-var _       = require('lodash');
+function list(logger, options, config) {
+    var project;
 
-var template = require('../util/template');
-var Manager  = require('../core/manager');
-var Package  = require('../core/package');
-var config   = require('../core/config');
-var help     = require('./help');
+    options = options || {};
 
-var shorthand   = { 'h': ['--help'] };
-var optionTypes = { help: Boolean, paths: Boolean, map: Boolean };
-
-var getTree = function (packages, subPackages, result) {
-  var result = result || {};
-
-  _.each(subPackages || packages, function (pkg, name) {
-
-    result[pkg.name] = {};
-
-    Object.keys(pkg.json.dependencies || {}).forEach(function (name) {
-      result[pkg.name][name] = {};
-    });
-
-    var subPackages = {};
-
-    Object.keys(pkg.json.dependencies || {}).forEach(function (name) {
-      subPackages[name] = packages[name] || new Package(name, null);
-    });
-
-    getTree(packages, subPackages, result[pkg.name]);
-  });
-
-  return result;
-};
-
-var generatePath = function (name, main) {
-  if (typeof main == 'string') {
-    return path.join(config.directory, name, main);
-  } else {
-    var main = main.map(function (main) { return generatePath(name, main); });
-    return main.length == 1 ? main[0] : main;
-  }
-}
-
-var buildSource = function (pkg, shallow) {
-  var result = {};
-
-  ['main', 'scripts', 'styles', 'templates', 'images'].forEach(function (type) {
-    if (pkg.json[type]) result[type] = generatePath(pkg.name, pkg.json[type]);
-  });
-
-  if (shallow) {
-    result.main = result.main      ? result.main
-                : result.scripts   ? result.scripts
-                : result.styles    ? result.styles
-                : result.templates ? result.templates
-                : result.images    ? result.images
-                : generatePath(pkg.name, '');
-  }
-
-  return result;
-}
-
-var shallowTree = function (packages, tree) {
-  var result = {};
-
-  Object.keys(tree).forEach(function (packageName) {
-    result[packageName] = buildSource(packages[packageName], true).main;
-  });
-
-  return result;
-}
-
-var deepTree = function (packages, tree) {
-
-  var result = {};
-
-  Object.keys(tree).forEach(function (packageName) {
-
-    result[packageName] = {};
-    result[packageName].source = buildSource(packages[packageName])
-
-    if (Object.keys(tree[packageName]).length) {
-      result[packageName].dependencies = deepTree(packages, tree[packageName]);
+    // Make relative option true by default when used with paths
+    if (options.paths && options.relative == null)  {
+        options.relative = true;
     }
 
-  });
+    config = defaultConfig(config);
+    project = new Project(config, logger);
 
-  return result;
-}
+    return project.getTree(options)
+    .spread(function (tree, flattened) {
+        // Relativize paths
+        // Also normalize paths on windows
+        project.walkTree(tree, function (node) {
+            if (node.missing) {
+                return;
+            }
 
-var getNodes = function (packages, tree) {
-  return Object.keys(tree).map(function (key) {
-    var upgrade;
+            if (options.relative) {
+                node.canonicalDir = path.relative(config.cwd, node.canonicalDir);
+            }
+            if (options.paths) {
+                node.canonicalDir = normalize(node.canonicalDir);
+            }
+        }, true);
 
-    var version = packages[key].json.repository
-      && packages[key].json.repository.type == 'asset'
-      && packages[key]
-      && packages[key].version == "0.0.0" ?
-         packages[key].json.repository.url : packages[key] && packages[key].version;
+        // Note that we need to to parse the flattened tree because it might
+        // contain additional packages
+        mout.object.forOwn(flattened, function (node) {
+            if (node.missing) {
+                return;
+            }
 
-    if (version && packages[key].tags.indexOf(version)) {
-      upgrade = packages[key].tags[0];
-    }
+            if (options.relative) {
+                node.canonicalDir = path.relative(config.cwd, node.canonicalDir);
+            }
+            if (options.paths) {
+                node.canonicalDir = normalize(node.canonicalDir);
+            }
+        });
 
-    if (Object.keys(tree[key]).length) {
-      return {
-        label: template('tree-branch', { package: key, version: version, upgrade: upgrade }, true),
-        nodes: getNodes(packages, tree[key])
-      };
-    } else {
-      return template('tree-branch', { package: key, version: version, upgrade: upgrade }, true);
-    }
-  });
-}
-
-var cliTree = function (emitter, packages, tree) {
-  emitter.emit('data', archy({
-    label: process.cwd(),
-    nodes: getNodes(packages, tree)
-  }));
-};
-
-module.exports = function (options) {
-  var manager = new Manager;
-  var emitter = new Emitter;
-
-  options = options || {};
-
-  manager.on('data',  emitter.emit.bind(emitter, 'data'));
-  manager.on('error', emitter.emit.bind(emitter, 'error'));
-
-  manager.once('resolveLocal', function () {
-    var packages = {};
-
-    Object.keys(manager.dependencies).forEach(function (key) {
-      packages[key] = manager.dependencies[key][0];
-    });
-
-    async.forEach(_.values(packages), function (pkg, next) {
-      pkg.once('loadJSON', function () {
-        if (this.json.repository && this.json.repository.type == 'git') {
-          pkg.once('versions', function (versions) {
-            pkg.tags = versions.map(semver.clean);
-            next();
-          }).versions();
-        } else {
-          pkg.tags = [];
-          next();
+        // Render paths?
+        if (options.paths) {
+            return paths(flattened);
         }
-      }).loadJSON();
-    }, function () {
-      var tree = getTree(packages);
-      if (!options.paths && !options.map && options.argv) return cliTree(emitter, packages, tree);
-      tree = options.paths ? shallowTree(packages, tree) : deepTree(packages, tree);
-      emitter.emit('data', options.argv ? JSON.stringify(tree, null, 2) : tree);
+
+        // Do not check for new versions?
+        if (config.offline) {
+            return tree;
+        }
+
+        // Check for new versions
+        return checkVersions(project, tree, logger)
+        .then(function () {
+            return tree;
+        });
+    });
+}
+
+function checkVersions(project, tree, logger) {
+    var promises;
+    var nodes = [];
+    var repository = project.getPackageRepository();
+
+    // Gather all nodes, ignoring linked nodes
+    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...');
+    }
+
+    // Check for new versions for each node
+    promises = nodes.map(function (node) {
+        var target = node.endpoint.target;
+
+        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, '*')
+                };
+            }
+        });
     });
 
-  }).resolveLocal();
+    // Set the versions also for the root node
+    tree.versions = [];
 
-  return emitter;
+    return Q.all(promises);
+}
+
+function paths(flattened) {
+    var ret = {};
+
+    mout.object.forOwn(flattened, function (pkg, name) {
+        var main;
+
+        if (pkg.missing) {
+            return;
+        }
+
+        main = pkg.pkgMeta.main;
+
+        // If no main was specified, fallback to canonical dir
+        if (!main) {
+            ret[name] = pkg.canonicalDir;
+            return;
+        }
+
+        // Normalize main
+        if (typeof main === 'string') {
+            main = [main];
+        }
+
+        // Concatenate each main entry with the canonical dir
+        main = main.map(function (part) {
+            return normalize(path.join(pkg.canonicalDir, part).trim());
+        });
+
+        // If only one main file, use a string
+        // Otherwise use an array
+        ret[name] = main.length === 1 ? main[0] : main;
+    });
+
+    return ret;
+}
+
+function normalize(src) {
+    return src.replace(/\\/g, '/');
+}
+
+// -------------------
+
+list.readOptions = function (argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions({
+        'paths': { type: Boolean, shorthand: 'p' },
+        'relative': { type: Boolean, shorthand: 'r' }
+    }, argv);
+
+    delete options.argv;
+
+    return [options];
 };
 
-module.exports.line = function (argv) {
-  var options = nopt(optionTypes, shorthand, argv);
-  if (options.help) return help('list');
-  return module.exports(options);
-};
+module.exports = list;

lib/commands/login.js

@@ -0,0 +1,125 @@
+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,49 +1,34 @@
-// ==========================================
-// BOWER: Lookup API
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
+var Q = require('q');
+var PackageRepository = require('../core/PackageRepository');
+var defaultConfig = require('../config');
 
-var Emitter  = require('events').EventEmitter;
-var nopt     = require('nopt');
-
-var template = require('../util/template');
-var source   = require('../core/source');
-var help     = require('./help');
-
-var optionTypes = { help: Boolean };
-var shorthand   = { 'h': ['--help'] };
-
-module.exports = function (name) {
-  var emitter = new Emitter;
-
-  source.lookup(name, function (err, url) {
-    if (err) {
-      source.search(name, function (err, packages) {
-        if (packages.length) {
-          template('suggestions', {packages: packages, name: name})
-            .on('data', emitter.emit.bind(emitter, 'data'));
-        } else {
-          template('warning-missing', {name: name})
-            .on('data', emitter.emit.bind(emitter, 'data'));
-        }
-      });
-
-    } else {
-      template('lookup', {name: name, url: url})
-        .on('data', emitter.emit.bind(emitter, 'data'));
+function lookup(logger, name, config) {
+    if (!name) {
+        return new Q(null);
     }
-  });
 
-  return emitter;
+    config = defaultConfig(config);
+
+    var repository = new PackageRepository(config, logger);
+    var registryClient = repository.getRegistryClient();
+
+    return Q.nfcall(registryClient.lookup.bind(registryClient), name)
+    .then(function (entry) {
+        return !entry ? null : {
+            name: name,
+            url: entry.url
+        };
+    });
+}
+
+// -------------------
+
+lookup.readOptions = function (argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
+    var name = options.argv.remain[1];
+
+    return [name];
 };
 
-module.exports.line = function (argv) {
-  var options  = nopt(optionTypes, shorthand, argv);
-  var names    = options.argv.remain.slice(1);
-
-  if (options.help || !names.length) return help('lookup');
-  return module.exports(names[0]);
-};
+module.exports = lookup;

lib/commands/prune.js

@@ -0,0 +1,55 @@
+var mout = require('mout');
+var Project = require('../core/Project');
+var defaultConfig = require('../config');
+
+function prune(logger, options, config) {
+    var project;
+
+    options = options || {};
+    config = defaultConfig(config);
+    project = new Project(config, logger);
+
+    return clean(project, options);
+}
+
+function clean(project, options, removed) {
+    removed = 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;
+        });
+
+        // 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);
+        });
+    });
+}
+
+// -------------------
+
+prune.readOptions = function (argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions({
+        'production': { type: Boolean, shorthand: 'p' },
+    }, argv);
+
+    delete options.argv;
+
+    return [options];
+};
+
+module.exports = prune;

lib/commands/register.js

@@ -1,38 +1,88 @@
-// ==========================================
-// BOWER: Lookup API
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
+var Q = require('q');
+var chalk = require('chalk');
+var PackageRepository = require('../core/PackageRepository');
+var createError = require('../util/createError');
+var defaultConfig = require('../config');
 
-var Emitter  = require('events').EventEmitter;
-var nopt     = require('nopt');
+function register(logger, name, source, config) {
+    var repository;
+    var registryClient;
+    var force;
+    var url;
+    var githubSourceRegex = /^\w[\w-]*\/\w[\w-]*$/;
+    var getGithubUrl = function (source) {
+        return 'git@github.com:' + source + '.git';
+    };
 
-var template = require('../util/template');
-var source   = require('../core/source');
-var help     = require('./help');
+    config = defaultConfig(config);
+    force = config.force;
 
-var optionTypes = { help: Boolean };
-var shorthand   = { 'h': ['--help'] };
+    name = (name || '').trim();
+    source = (source || '').trim();
 
-module.exports = function (name, url) {
-  var emitter = new Emitter;
+    url = source.match(githubSourceRegex) ? getGithubUrl(source) : source;
 
-  source.register(name, url, function (err) {
-    if (err) return emitter.emit('error', err);
+    // Bypass any cache
+    config.offline = false;
+    config.force = true;
 
-    template('register', {name: name, url: url})
-      .on('data', emitter.emit.bind(emitter, 'data'));
-  });
+    return Q.try(function () {
+        // Verify name and url
+        if (!name || !url) {
+            throw createError('Usage: bower register <name> <url>', 'EINVFORMAT');
+        }
 
-  return emitter;
+        // Attempt to resolve the package referenced by the URL to ensure
+        // everything is ok before registering
+        repository = new PackageRepository(config, logger);
+        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');
+        }
+
+        // If non interactive or user forced, bypass confirmation
+        if (!config.interactive || force) {
+            return true;
+        }
+
+        // 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?',
+            default: true
+        });
+    })
+    .then(function (result) {
+        // If user response was negative, abort
+        if (!result) {
+            return;
+        }
+
+        // Register
+        registryClient = repository.getRegistryClient();
+
+        logger.action('register', url, {
+            name: name,
+            url: url
+        });
+
+        return Q.nfcall(registryClient.register.bind(registryClient), name, url);
+    });
+}
+
+// -------------------
+
+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];
+
+    return [name, url];
 };
 
-module.exports.line = function (argv) {
-  var options  = nopt(optionTypes, shorthand, argv);
-  var args     = options.argv.remain.slice(1);
-
-  if (options.help || args.length != 2) return help('register');
-  return module.exports(args[0], args[1]);
-};
+module.exports = register;

lib/commands/search.js

@@ -1,49 +1,39 @@
-// ==========================================
-// BOWER: Lookup API
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
+var Q = require('q');
+var PackageRepository = require('../core/PackageRepository');
+var defaultConfig = require('../config');
+var cli = require('../util/cli');
+var createError = require('../util/createError');
 
-var Emitter  = require('events').EventEmitter;
-var nopt     = require('nopt');
+function search(logger, name, config) {
+    var registryClient;
 
-var template = require('../util/template');
-var source   = require('../core/source');
-var help     = require('./help');
+    config = defaultConfig(config);
 
-var optionTypes = { help: Boolean };
-var shorthand   = { 'h': ['--help'] };
+    var repository = new PackageRepository(config, logger);
+    var registryClient = repository.getRegistryClient();
 
-module.exports = function (name) {
-  var emitter = new Emitter;
-
-  var callback = function (err, results) {
-    if (err) return emitter.emit('error', err);
-
-    if (results.length) {
-      template('search', {results: results})
-        .on('data', emitter.emit.bind(emitter, 'data'));
+    if (name) {
+        return Q.nfcall(registryClient.search.bind(registryClient), name);
     } else {
-      template('search-empty', {results: results})
-        .on('data', emitter.emit.bind(emitter, 'data'));
+        // 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));
     }
-  };
+}
 
-  if (name) {
-    source.search(name, callback);
-  } else {
-    source.all(callback);
-  }
+// -------------------
 
-  return emitter;
+search.readOptions = function (argv) {
+    var options = cli.readOptions(argv);
+    var terms = options.argv.remain.slice(1);
+
+    var name = terms.join(' ');
+
+    return [name];
 };
 
-module.exports.line = function (argv) {
-  var options  = nopt(optionTypes, shorthand, argv);
-  var names    = options.argv.remain.slice(1);
-
-  if (options.help) return help('search');
-  return module.exports(names[0]);
-};
+module.exports = search;

lib/commands/uninstall.js

@@ -1,81 +1,115 @@
-// ==========================================
-// BOWER: Uninstall API
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
+var mout = require('mout');
+var Q = require('q');
+var Project = require('../core/Project');
+var defaultConfig = require('../config');
 
-var Emitter  = require('events').EventEmitter;
-var async    = require('async');
-var nopt     = require('nopt');
-var _        = require('lodash');
+function uninstall(logger, names, options, config) {
+    if (!names.length) {
+        return new Q();
+    }
 
-var template = require('../util/template');
-var Manager  = require('../core/manager');
-var save     = require('../util/save');
-var help     = require('./help');
+    var project;
 
-var shorthand   = { 'h': ['--help'], 'S': ['--save'] };
-var optionTypes = { help: Boolean };
+    options = options || {};
+    config = defaultConfig(config);
+    project = new Project(config, logger);
 
-module.exports = function (names, options) {
+    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 = [];
 
-  var packages, uninstallables;
-  var emitter = new Emitter;
-  var manager = new Manager;
+            // 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));
+                }
+            });
 
-  if (options.save) save.discard(emitter, manager, names);
-
-  manager.on('data',  emitter.emit.bind(emitter, 'data'));
-  manager.on('error', emitter.emit.bind(emitter, 'error'));
-
-  var resolveLocal = function () {
-    packages = _.flatten(_.values(manager.dependencies));
-
-    uninstallables = packages.filter(function (pkg) {
-      return _.include(names, pkg.name);
+            // Clean them!
+            return clean(project, children, uninstalled);
+        });
     });
+}
 
-    async.forEach(packages, function (pkg, next) {
-      pkg.once('loadJSON', next).loadJSON();
-    }, function () {
-      showWarnings();
-      uninstall();
+function clean(project, names, removed) {
+    removed = removed || {};
+
+    return project.getTree()
+    .spread(function (tree, flattened) {
+        var nodes = [];
+        var dependantsCounter = {};
+
+        // Grab the nodes of each specified name
+        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);
+
+
+        // Filter out those that have no dependants
+        nodes = nodes.filter(function (node) {
+            return !dependantsCounter[node.endpoint.name];
+        });
+
+        // Are we done?
+        if (!nodes.length) {
+            return Q.resolve(removed);
+        }
+
+        // Grab the nodes after filtering
+        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;
+
+            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));
+            });
+
+            // Recurse!
+            return clean(project, children, removed);
+        });
     });
-  };
+}
 
-  var showWarnings = function () {
-    packages.forEach(function (pkg) {
-      if (!pkg.json.dependencies) return;
+// -------------------
 
-      var conflicts = _.intersection(
-        Object.keys(pkg.json.dependencies),
-        _.pluck(uninstallables, 'name')
-      );
+uninstall.readOptions = function (argv) {
+    var cli = require('../util/cli');
 
-      conflicts.forEach(function (conflictName) {
-        template('warning-uninstall', {packageName: pkg.name, conflictName: conflictName})
-          .on('data', emitter.emit.bind(emitter, 'data'));
-      });
-    });
-  };
+    var options = cli.readOptions({
+        'save': { type: Boolean, shorthand: 'S' },
+        'save-dev': { type: Boolean, shorthand: 'D' }
+    }, argv);
 
-  var uninstall = function () {
-    async.forEach(uninstallables, function (pkg, next) {
-      pkg.on('uninstall', next).uninstall();
-    }, emitter.emit.bind(emitter, 'end'));
-  };
+    var names = options.argv.remain.slice(1);
 
-  manager.on('resolveLocal', resolveLocal).resolveLocal();
+    delete options.argv;
 
-  return emitter;
+    return [names, options];
 };
 
-module.exports.line = function (argv) {
-  var options = nopt(optionTypes, shorthand, argv);
-  if (options.help) return help('uninstall');
-  var names   = options.argv.remain.slice(1);
-
-  return module.exports(names, options)
-};
+module.exports = uninstall;

lib/commands/unregister.js

@@ -0,0 +1,79 @@
+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,60 +1,36 @@
-// ==========================================
-// BOWER: Update API
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
+var Project = require('../core/Project');
+var defaultConfig = require('../config');
 
-var Emitter = require('events').EventEmitter;
-var async   = require('async');
-var nopt    = require('nopt');
-var _       = require('lodash');
+function update(logger, names, options, config) {
+    var project;
 
-var Manager = require('../core/manager');
-var install = require('./install');
-var help    = require('./help');
+    options = options || {};
+    config = defaultConfig(config);
+    project = new Project(config, logger);
 
-var shorthand   = { 'h': ['--help'] };
-var optionTypes = { help: Boolean };
+    // If names is an empty array, null them
+    if (names && !names.length) {
+        names = null;
+    }
 
-module.exports = function (argv) {
-  var manager = new Manager;
-  var emitter = new Emitter;
+    return project.update(names, options);
+}
 
-  manager.on('data',  emitter.emit.bind(emitter, 'data'));
-  manager.on('error', emitter.emit.bind(emitter, 'error'));
+// -------------------
 
-  var installURLS = function (err, urls) {
-    var installEmitter = install(urls);
-    installEmitter.on('data',  emitter.emit.bind(emitter, 'data'));
-    installEmitter.on('error', emitter.emit.bind(emitter, 'error'));
-    installEmitter.on('end',   emitter.emit.bind(emitter, 'end'));
-  };
+update.readOptions = function (argv) {
+    var cli = require('../util/cli');
 
-  manager.once('resolveLocal', function () {
-    var packages = {};
+    var options = cli.readOptions({
+        'force-latest': { type: Boolean, shorthand: 'F' },
+        'production': { type: Boolean, shorthand: 'p' }
+    }, argv);
 
-    _.each(manager.dependencies, function (value, name) {
-      packages[name] = value[0];
-    });
+    var names = options.argv.remain.slice(1);
 
-    var urls = async.map(_.values(packages), function (pkg, next) {
-      pkg.once('loadJSON', function () {
-        pkg.once('fetchURL', function (url) {
-          next(null, url + '#~' + pkg.version);
-        }).fetchURL();
-      }).loadJSON();
-    }, installURLS);
-  }).resolveLocal();
+    delete options.argv;
 
-  return emitter;
+    return [names, options];
 };
 
-module.exports.line = function (argv) {
-  var options = nopt(optionTypes, shorthand, argv);
-  if (options.help) return help('update');
-
-  var paths = options.argv.remain.slice(1);
-  return module.exports(paths);
-};
+module.exports = update;

lib/commands/version.js

@@ -0,0 +1,161 @@
+var semver = require('semver');
+var which = require('which');
+var fs = require('../util/fs');
+var path = require('path');
+var Q = require('q');
+var execFile = require('child_process').execFile;
+var defaultConfig = require('../config');
+var createError = require('../util/createError');
+
+function version(logger, versionArg, options, config) {
+    options = options || {};
+
+    config = defaultConfig(config);
+
+    return bump(logger, config, versionArg, options.message);
+}
+
+function bump(logger, config, versionArg, message) {
+    var cwd = config.cwd || process.cwd();
+    var newVersion;
+
+    if (!versionArg) {
+        throw createError('No <version> agrument provided', 'EREADOPTIONS');
+    }
+
+    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;
+    });
+}
+
+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;
+            });
+        }
+
+        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;
+            });
+        }
+
+        function filterModifiedStatusLines(stdout) {
+            return stdout.trim().split('\n')
+            .filter(function (line) {
+                return line.trim() && !line.match(/^\?\? /);
+            }).map(function (line) {
+                return line.trim();
+            });
+        }
+
+        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];
+
+            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.readOptions = function (argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions({
+        'message': { type: String, shorthand: 'm'}
+    }, argv);
+
+    return [options.argv.remain[1], options];
+};
+
+module.exports = version;

lib/config.js

@@ -0,0 +1,63 @@
+var tty = require('tty');
+var object = require('mout').object;
+var bowerConfig = require('bower-config');
+var Configstore = require('configstore');
+
+var current;
+
+function defaultConfig(config) {
+    config = config || {};
+
+    return readCachedConfig(config.cwd || process.cwd(), config);
+}
+
+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;
+}
+
+function restoreConfig() {
+    if (current) {
+        current.restore();
+    }
+}
+
+function resetCache() {
+    restoreConfig();
+    current = undefined;
+}
+
+module.exports = defaultConfig;
+module.exports.restore = restoreConfig;
+module.exports.reset = resetCache;

lib/core/PackageRepository.js

@@ -0,0 +1,227 @@
+var mout = require('mout');
+var Q = require('q');
+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;
+
+    this._config = config;
+    this._logger = 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
+    this._resolveCache = new ResolveCache(this._config);
+}
+
+// -----------------
+
+PackageRepository.prototype.fetch = function (decEndpoint) {
+    var logger;
+    var that = this;
+    var isTargetable;
+    var info = {
+        decEndpoint: decEndpoint
+    };
+
+    // Create a new logger that pipes everything to ours that will be
+    // used to fetch
+    logger = this._logger.geminate();
+    // Intercept all logs, adding additional information
+    logger.intercept(function (log) {
+        that._extendLog(log, info);
+    });
+
+    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 (!resolver.isCacheable()) {
+            return that._resolve(resolver, logger);
+        }
+
+        // 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);
+        }
+
+        // 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
+                    });
+                }
+
+                // 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) {
+    // Resolve the source using the factory because the
+    // source can actually be a registry name
+    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 resolver.constructor.versions(resolver.getSource());
+    }.bind(this));
+};
+
+PackageRepository.prototype.eliminate = function (pkgMeta) {
+    return Q.all([
+        this._resolveCache.eliminate(pkgMeta),
+        Q.nfcall(this._registryClient.clearCache.bind(this._registryClient), pkgMeta.name)
+    ]);
+};
+
+PackageRepository.prototype.clear = function () {
+    return Q.all([
+        this._resolveCache.clear(),
+        Q.nfcall(this._registryClient.clearCache.bind(this._registryClient))
+    ]);
+};
+
+PackageRepository.prototype.reset = function () {
+    this._resolveCache.reset();
+    this._registryClient.resetCache();
+};
+
+PackageRepository.prototype.list = function () {
+    return this._resolveCache.list();
+};
+
+PackageRepository.prototype.getRegistryClient = function () {
+    return this._registryClient;
+};
+
+PackageRepository.prototype.getResolveCache = function () {
+    return this._resolveCache;
+};
+
+PackageRepository.clearRuntimeCache = function () {
+    ResolveCache.clearRuntimeCache();
+    RegistryClient.clearRuntimeCache();
+    resolverFactory.clearRuntimeCache();
+};
+
+// ---------------------
+
+PackageRepository.prototype._getResolver = function (decEndpoint, logger) {
+    logger = logger || this._logger;
+
+    // Get the appropriate resolver
+    return resolverFactory(decEndpoint, { config: this._config, logger: logger }, this._registryClient);
+};
+
+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']);
+    }
+
+    // Store the resolver info in each log
+    if (info.resolver) {
+        log.data.resolver = {
+            name: info.resolver.getName(),
+            source: info.resolver.getSource(),
+            target: info.resolver.getTarget()
+        };
+    }
+
+    // Store the canonical dir and its meta in each log
+    if (info.canonicalDir) {
+        log.data.canonicalDir = info.canonicalDir;
+        log.data.pkgMeta = info.pkgMeta;
+    }
+
+    return log;
+};
+
+module.exports = PackageRepository;

lib/core/Project.js

@@ -0,0 +1,869 @@
+var glob = require('glob');
+var path = require('path');
+var fs = require('../util/fs');
+var Q = require('q');
+var mout = require('mout');
+var rimraf = require('../util/rimraf');
+var endpointParser = require('bower-endpoint-parser');
+var Logger = require('bower-logger');
+var md5 = require('md5-hex');
+var Manager = require('./Manager');
+var semver = require('../util/semver');
+var createError = require('../util/createError');
+var readJson = require('../util/readJson');
+var validLink = require('../util/validLink');
+var scripts = require('./scripts');
+var relativeToBaseDir = require('../util/relativeToBaseDir');
+
+function Project(config, logger) {
+    this._config = config;
+    this._logger = logger || new Logger();
+    this._manager = new Manager(this._config, this._logger);
+
+    this._options = {};
+}
+
+// -----------------
+
+Project.prototype.install = function (decEndpoints, options, config) {
+    var that = this;
+    var targets = [];
+    var resolved = {};
+    var incompatibles = [];
+
+    // If already working, error out
+    if (this._working) {
+        return Q.reject(createError('Already working', 'EWORKING'));
+    }
+
+    this._options = options || {};
+    this._config = config || {};
+    this._working = true;
+
+    // Analyse the project
+    return this._analyse()
+    .spread(function (json, tree) {
+        // It shows an error when issuing `bower install`
+        // and no bower.json is present in current directory
+        if (!that._jsonFile && decEndpoints.length === 0 ) {
+            throw createError('No bower.json present', 'ENOENT');
+        }
+
+        // Recover tree
+        that.walkTree(tree, function (node, name) {
+            if (node.incompatible) {
+                incompatibles.push(node);
+            } else if (node.missing || node.different || that._config.force) {
+                targets.push(node);
+            } else {
+                resolved[name] = node;
+            }
+        }, true);
+
+        // Add decomposed endpoints as targets
+        decEndpoints = decEndpoints || [];
+        decEndpoints.forEach(function (decEndpoint) {
+            // Mark as new so that a conflict for this target
+            // always require a choice
+            // Also allows for the target to be converted in case
+            // of being *
+            decEndpoint.newly = true;
+            targets.push(decEndpoint);
+        });
+
+        // Bootstrap the process
+        return that._bootstrap(targets, resolved, incompatibles);
+    })
+    .then(function () {
+        return that._manager.preinstall(that._json);
+    })
+    .then(function () {
+        return that._manager.install(that._json);
+    })
+    .then(function (installed) {
+        // Handle save and saveDev options
+        if (that._options.save || that._options.saveDev || that._options.saveExact || that._config.save || that._config.saveExact) {
+            // Cycle through the specified endpoints
+            decEndpoints.forEach(function (decEndpoint) {
+                var jsonEndpoint;
+
+                jsonEndpoint = endpointParser.decomposed2json(decEndpoint);
+
+                if (that._options.saveExact || that._config.saveExact) {
+                    if (decEndpoint.name !== decEndpoint.source) {
+                        jsonEndpoint[decEndpoint.name] = decEndpoint.source + '#' + decEndpoint.pkgMeta.version;
+                    } else {
+                        jsonEndpoint[decEndpoint.name] = decEndpoint.pkgMeta.version;
+                    }
+                }
+
+                if (that._options.saveDev) {
+                    that._json.devDependencies = mout.object.mixIn(that._json.devDependencies || {}, jsonEndpoint);
+                } else {
+                    that._json.dependencies = mout.object.mixIn(that._json.dependencies || {}, jsonEndpoint);
+                }
+            });
+        }
+
+        // Save JSON, might contain changes to dependencies and resolutions
+        return that.saveJson()
+        .then(function () {
+            return that._manager.postinstall(that._json).then(function () {
+                return installed;
+            });
+        });
+    })
+    .fin(function () {
+        that._installed = null;
+        that._working = false;
+    });
+};
+
+Project.prototype.update = function (names, options) {
+    var that = this;
+    var targets = [];
+    var resolved = {};
+    var incompatibles = [];
+
+    // If already working, error out
+    if (this._working) {
+        return Q.reject(createError('Already working', 'EWORKING'));
+    }
+
+    this._options = options || {};
+    this._working = true;
+
+    // Analyse the project
+    return this._analyse()
+    .spread(function (json, tree, flattened) {
+        // If no names were specified, update every package
+        if (!names) {
+            // Mark each root dependency as targets
+            that.walkTree(tree, function (node) {
+                // We don't know the real source of linked packages
+                // Instead we read its dependencies
+                if (node.linked) {
+                    targets.push.apply(targets, mout.object.values(node.dependencies));
+                } else {
+                    targets.push(node);
+                }
+
+                return false;
+            }, true);
+        // Otherwise, selectively update the specified ones
+        } else {
+            // Error out if some of the specified names
+            // are not installed
+            names.forEach(function (name) {
+                if (!flattened[name]) {
+                    throw createError('Package ' + name + ' is not installed', 'ENOTINS', {
+                        name: name
+                    });
+                }
+            });
+
+            // Add packages whose names are specified to be updated
+            that.walkTree(tree, function (node, name) {
+                if (names.indexOf(name) !== -1) {
+                    // We don't know the real source of linked packages
+                    // Instead we read its dependencies
+                    if (node.linked) {
+                        targets.push.apply(targets, mout.object.values(node.dependencies));
+                    } else {
+                        targets.push(node);
+                    }
+
+                    return false;
+                }
+            }, true);
+
+            // Recover tree
+            that.walkTree(tree, function (node, name) {
+                if (node.missing || node.different) {
+                    targets.push(node);
+                } else if (node.incompatible) {
+                    incompatibles.push(node);
+                } else {
+                    resolved[name] = node;
+                }
+            }, true);
+        }
+
+        // Bootstrap the process
+        return that._bootstrap(targets, resolved, incompatibles)
+        .then(function () {
+            return that._manager.preinstall(that._json);
+        })
+        .then(function () {
+            return that._manager.install(that._json);
+        })
+        .then(function (installed) {
+            // Save JSON, might contain changes to resolutions
+            return that.saveJson()
+            .then(function () {
+                return that._manager.postinstall(that._json).then(function () {
+                    return installed;
+                });
+            });
+        });
+    })
+    .fin(function () {
+        that._installed = null;
+        that._working = false;
+    });
+};
+
+function resolveUrlNames(names, flattened)
+{
+    for (var i = 0; i < names.length; i++)
+        if (! flattened[names[i]])
+    {
+            var url = names[i].trim().replace(/\/$/, '');
+            var packName;
+            for (packName in flattened)
+                if (! ( !flattened[packName].source))
+                    if (url == flattened[packName].source.trim().replace(/\/$/, ''))
+                        names[i] = packName;
+        }
+}
+
+Project.prototype.uninstall = function (names, options) {
+    var that = this;
+    var packages = {};
+
+    // If already working, error out
+    if (this._working) {
+        return Q.reject(createError('Already working', 'EWORKING'));
+    }
+
+    this._options = options || {};
+    this._working = true;
+
+    // Analyse the project
+    return this._analyse()
+    // Fill in the packages to be uninstalled
+    .spread(function (json, tree, flattened) {
+        var promise = Q.resolve();
+        resolveUrlNames(names, flattened);
+
+        names.forEach(function (name) {
+            var decEndpoint = flattened[name];
+
+            // Check if it is not installed
+            if (!decEndpoint || decEndpoint.missing) {
+                packages[name] = null;
+                return;
+            }
+
+            promise = promise
+            .then(function () {
+                var message;
+                var data;
+                var dependantsNames;
+                var dependants = [];
+
+                // Walk the down the tree, gathering dependants of the package
+                that.walkTree(tree, function (node, nodeName) {
+                    if (name === nodeName) {
+                        dependants.push.apply(dependants, mout.object.values(node.dependants));
+                    }
+                }, true);
+
+                // Remove duplicates
+                dependants = mout.array.unique(dependants);
+
+                // Note that the root is filtered from the dependants
+                // as well as other dependants marked to be uninstalled
+                dependants = dependants.filter(function (dependant) {
+                    return !dependant.root && names.indexOf(dependant.name) === -1;
+                });
+
+                // If the package has no dependants or the force config is enabled,
+                // mark it to be removed
+                if (!dependants.length || that._config.force) {
+                    packages[name] = decEndpoint.canonicalDir;
+                    return;
+                }
+
+                // Otherwise we need to figure it out if the user really wants to remove it,
+                // even with dependants
+                // As such we need to prompt the user with a meaningful message
+                dependantsNames = dependants.map(function (dep) { return dep.name; });
+                dependantsNames.sort(function (name1, name2) { return name1.localeCompare(name2); });
+                dependantsNames = mout.array.unique(dependantsNames);
+                dependants = dependants.map(function (dependant) { return that._manager.toData(dependant); });
+                message = dependantsNames.join(', ') + ' depends on ' + decEndpoint.name;
+                data = {
+                    name: decEndpoint.name,
+                    dependants: dependants
+                };
+
+                // If interactive is disabled, error out
+                if (!that._config.interactive) {
+                    throw createError(message, 'ECONFLICT', {
+                        data: data
+                    });
+                }
+
+                that._logger.conflict('mutual', message, data);
+
+                // Prompt the user
+                return Q.nfcall(that._logger.prompt.bind(that._logger), {
+                    type: 'confirm',
+                    message: 'Continue anyway?',
+                    default: true
+                })
+                .then(function (confirmed) {
+                    // If the user decided to skip it, remove from the array so that it won't
+                    // influence subsequent dependants
+                    if (!confirmed) {
+                        mout.array.remove(names, name);
+                    } else {
+                        packages[name] = decEndpoint.canonicalDir;
+                    }
+                });
+            });
+        });
+
+        return promise;
+    })
+    // Remove packages
+    .then(function () {
+        return that._removePackages(packages);
+    })
+    .fin(function () {
+        that._installed = null;
+        that._working = false;
+    });
+};
+
+Project.prototype.getTree = function (options) {
+    this._options = options || {};
+
+    return this._analyse()
+    .spread(function (json, tree, flattened) {
+        var extraneous = [];
+        var additionalKeys = ['missing', 'extraneous', 'different', 'linked'];
+
+        // Convert tree
+        tree = this._manager.toData(tree, additionalKeys);
+
+        // Mark incompatibles
+        this.walkTree(tree, function (node) {
+            var version;
+            var target = node.endpoint.target;
+
+            if (node.pkgMeta && semver.validRange(target)) {
+                version = node.pkgMeta.version;
+
+                // Ignore if target is '*' and resolved to a non-semver release
+                if (!version && target === '*') {
+                    return;
+                }
+
+                if (!version || !semver.satisfies(version, target)) {
+                    node.incompatible = true;
+                }
+            }
+        }, true);
+
+        // Convert extraneous
+        mout.object.forOwn(flattened, function (pkg) {
+            if (pkg.extraneous) {
+                extraneous.push(this._manager.toData(pkg, additionalKeys));
+            }
+        }, this);
+
+        // Convert flattened
+        flattened = mout.object.map(flattened, function (node) {
+            return this._manager.toData(node, additionalKeys);
+        }, this);
+
+        return [tree, flattened, extraneous];
+    }.bind(this));
+};
+
+Project.prototype.walkTree = function (node, fn, onlyOnce) {
+    var result;
+    var dependencies;
+    var queue = mout.object.values(node.dependencies);
+
+    if (onlyOnce === true) {
+        onlyOnce = [];
+    }
+
+    while (queue.length) {
+        node = queue.shift();
+        result = fn(node, node.endpoint ? node.endpoint.name : node.name);
+
+        // Abort traversal if result is false
+        if (result === false) {
+            continue;
+        }
+
+        // Add dependencies to the queue
+        dependencies = mout.object.values(node.dependencies);
+
+        // If onlyOnce was true, do not add if already traversed
+        if (onlyOnce) {
+            dependencies = dependencies.filter(function (dependency) {
+                return !mout.array.find(onlyOnce, function (stacked) {
+                    if (dependency.endpoint) {
+                        return mout.object.equals(dependency.endpoint, stacked.endpoint);
+                    }
+
+                    return dependency.name === stacked.name &&
+                           dependency.source === stacked.source &&
+                           dependency.target === stacked.target;
+                });
+            });
+
+            onlyOnce.push.apply(onlyOnce, dependencies);
+        }
+
+        queue.unshift.apply(queue, dependencies);
+    }
+};
+
+Project.prototype.saveJson = function (forceCreate) {
+    var file;
+    var jsonStr = JSON.stringify(this._json, null, '  ') + '\n';
+    var jsonHash = md5(jsonStr);
+
+    // Save only if there's something different
+    if (jsonHash === this._jsonHash) {
+        return Q.resolve();
+    }
+
+    // Error out if the json file does not exist, unless force create
+    // is true
+    if (!this._jsonFile && !forceCreate) {
+        this._logger.warn('no-json', 'No bower.json file to save to, use bower init to create one');
+        return Q.resolve();
+    }
+
+    file = this._jsonFile || path.join(this._config.cwd, 'bower.json');
+    return Q.nfcall(fs.writeFile, file, jsonStr)
+    .then(function () {
+        this._jsonHash = jsonHash;
+        this._jsonFile = file;
+        return this._json;
+    }.bind(this));
+};
+
+Project.prototype.hasJson = function () {
+    return this._readJson()
+    .then(function (json) {
+        return json ? this._jsonFile : false;
+    }.bind(this));
+};
+
+Project.prototype.getJson = function () {
+    return this._readJson();
+};
+
+Project.prototype.getManager = function () {
+    return this._manager;
+};
+
+Project.prototype.getPackageRepository = function () {
+    return this._manager.getPackageRepository();
+};
+
+// -----------------
+
+Project.prototype._analyse = function () {
+    return Q.all([
+        this._readJson(),
+        this._readInstalled(),
+        this._readLinks()
+    ])
+    .spread(function (json, installed, links) {
+        var root;
+        var jsonCopy = mout.lang.deepClone(json);
+
+        root = {
+            name: json.name,
+            source: this._config.cwd,
+            target: json.version || '*',
+            pkgMeta: jsonCopy,
+            canonicalDir: this._config.cwd,
+            root: true
+        };
+
+        mout.object.mixIn(installed, links);
+
+        // Mix direct extraneous as dependencies
+        // (dependencies installed without --save/--save-dev)
+        jsonCopy.dependencies = jsonCopy.dependencies || {};
+        jsonCopy.devDependencies = jsonCopy.devDependencies || {};
+        mout.object.forOwn(installed, function (decEndpoint, key) {
+            var pkgMeta = decEndpoint.pkgMeta;
+            var isSaved = jsonCopy.dependencies[key] || jsonCopy.devDependencies[key];
+
+            // The _direct propery is saved by the manager when .newly is specified
+            // It may happen pkgMeta is undefined if package is uninstalled
+            if (!isSaved && pkgMeta && pkgMeta._direct) {
+                decEndpoint.extraneous = true;
+
+                if (decEndpoint.linked) {
+                    jsonCopy.dependencies[key] = pkgMeta.version || '*';
+                } else {
+                    jsonCopy.dependencies[key] = (pkgMeta._originalSource || pkgMeta._source) + '#' + pkgMeta._target;
+                }
+            }
+        });
+
+        // Restore the original dependencies cross-references,
+        // that is, the parent-child relationships
+        this._restoreNode(root, installed, 'dependencies');
+        // Do the same for the dev dependencies
+        if (!this._options.production) {
+            this._restoreNode(root, installed, 'devDependencies');
+        }
+
+        // Restore the rest of the extraneous (not installed directly)
+        mout.object.forOwn(installed, function (decEndpoint, name) {
+            if (!decEndpoint.dependants) {
+                decEndpoint.extraneous = true;
+                this._restoreNode(decEndpoint, installed, 'dependencies');
+                // Note that it has no dependants, just dependencies!
+                root.dependencies[name] = decEndpoint;
+            }
+        }, this);
+
+        // Remove root from the flattened tree
+        delete installed[json.name];
+
+        return [json, root, installed];
+    }.bind(this));
+};
+
+Project.prototype._bootstrap = function (targets, resolved, incompatibles) {
+    var installed = mout.object.map(this._installed, function (decEndpoint) {
+        return decEndpoint.pkgMeta;
+    });
+
+    this._json.resolutions = this._json.resolutions || {};
+
+    // Configure the manager and kick in the resolve process
+    return this._manager
+    .configure({
+        targets: targets,
+        resolved: resolved,
+        incompatibles: incompatibles,
+        resolutions: this._json.resolutions,
+        installed: installed,
+        forceLatest: this._options.forceLatest
+    })
+    .resolve()
+    .then(function () {
+        // If the resolutions is empty, delete key
+        if (!mout.object.size(this._json.resolutions)) {
+            delete this._json.resolutions;
+        }
+    }.bind(this));
+};
+
+Project.prototype._readJson = function () {
+    var that = this;
+
+    if (this._json) {
+        return Q.resolve(this._json);
+    }
+
+    return Q.fcall(function () {
+        // This will throw if package.json does not exist
+        return fs.readFileSync(path.join(that._config.cwd, 'package.json'));
+    })
+    .then(function (buffer) {
+        // If package.json exists, use it's values as defaults
+        var defaults = {}, npm = JSON.parse(buffer.toString());
+
+        defaults.name        = npm.name || path.basename(that._config.cwd) || 'root';
+        defaults.description = npm.description;
+        defaults.main        = npm.main;
+        defaults.authors     = npm.contributors || npm.author;
+        defaults.license     = npm.license;
+        defaults.keywords    = npm.keywords;
+
+        return defaults;
+    })
+    .catch(function (err) {
+        // Most likely no package.json so just set default name
+        return { name: path.basename(that._config.cwd) || 'root' };
+    })
+    .then(function (defaults) {
+        return that._json = readJson(that._config.cwd, { assume: defaults, logger: that._logger });
+    })
+    .spread(function (json, deprecated, assumed) {
+        var jsonStr;
+
+        if (deprecated) {
+            that._logger.warn('deprecated', 'You are using the deprecated ' + deprecated + ' file');
+        }
+
+        if (!assumed) {
+            that._jsonFile = path.join(that._config.cwd, deprecated ? deprecated : 'bower.json');
+        }
+
+        jsonStr = JSON.stringify(json, null, '  ') + '\n';
+        that._jsonHash = md5(jsonStr);
+        return that._json = json;
+    });
+};
+
+Project.prototype._readInstalled = function () {
+    var componentsDir;
+    var that = this;
+
+    if (this._installed) {
+        return Q.resolve(this._installed);
+    }
+
+    // Gather all folders that are actual packages by
+    // looking for the package metadata file
+    componentsDir = relativeToBaseDir(this._config.cwd)(this._config.directory);
+    return this._installed = Q.nfcall(glob, '*/.bower.json', {
+        cwd: componentsDir,
+        dot: true
+    })
+    .then(function (filenames) {
+        var promises;
+        var decEndpoints = {};
+
+        // Foreach bower.json found
+        promises = filenames.map(function (filename) {
+            var name = path.dirname(filename);
+            var metaFile = path.join(componentsDir, filename);
+
+            // Read package metadata
+            return readJson(metaFile)
+            .spread(function (pkgMeta) {
+                decEndpoints[name] = {
+                    name: name,
+                    source: pkgMeta._originalSource || pkgMeta._source,
+                    target: pkgMeta._target,
+                    canonicalDir: path.dirname(metaFile),
+                    pkgMeta: pkgMeta
+                };
+            });
+        });
+
+        // Wait until all files have been read
+        // and resolve with the decomposed endpoints
+        return Q.all(promises)
+        .then(function () {
+            return that._installed = decEndpoints;
+        });
+    });
+};
+
+Project.prototype._readLinks = function () {
+    var componentsDir;
+    var that = this;
+
+    // Read directory, looking for links
+    componentsDir = relativeToBaseDir(this._config.cwd)(this._config.directory);
+    return Q.nfcall(fs.readdir, componentsDir)
+    .then(function (filenames) {
+        var promises;
+        var decEndpoints = {};
+
+        promises = filenames.map(function (filename) {
+            var dir = path.join(componentsDir, filename);
+
+            // Filter only those that are valid links
+            return validLink(dir)
+            .spread(function (valid, err) {
+                var name;
+
+                if (!valid) {
+                    if (err) {
+                        that._logger.debug('read-link', 'Link ' + dir + ' is invalid', {
+                            filename: dir,
+                            error: err
+                        });
+                    }
+                    return;
+                }
+
+                // Skip links to files (see #783)
+                if (!valid.isDirectory()) {
+                    return;
+                }
+
+                name = path.basename(dir);
+                return readJson(dir, {
+                    assume: { name: name }
+                })
+                .spread(function (json, deprecated) {
+                    if (deprecated) {
+                        that._logger.warn('deprecated', 'Package ' + name + ' is using the deprecated ' + deprecated);
+                    }
+
+                    json._direct = true;  // Mark as a direct dep of root
+                    decEndpoints[name] = {
+                        name: name,
+                        source: dir,
+                        target: '*',
+                        canonicalDir: dir,
+                        pkgMeta: json,
+                        linked: true
+                    };
+                });
+            });
+        });
+
+        // Wait until all links have been read
+        // and resolve with the decomposed endpoints
+        return Q.all(promises)
+        .then(function () {
+            return decEndpoints;
+        });
+    // Ignore if folder does not exist
+    }, function (err) {
+        if (err.code !== 'ENOENT') {
+            throw err;
+        }
+
+        return {};
+    });
+};
+
+Project.prototype._removePackages = function (packages) {
+    var that = this;
+    var promises = [];
+
+    return scripts.preuninstall(that._config, that._logger, packages, that._installed, that._json)
+    .then(function () {
+
+        mout.object.forOwn(packages, function (dir, name) {
+            var promise;
+
+            // Delete directory
+            if (!dir) {
+                promise = Q.resolve();
+                that._logger.warn('not-installed', '\'' + name + '\'' + ' cannot be uninstalled as it is not currently installed', {
+                    name: name
+                });
+            } else {
+                promise = Q.nfcall(rimraf, dir);
+                that._logger.action('uninstall', name, {
+                    name: name,
+                    dir: dir
+                });
+            }
+
+            // Remove from json only if successfully deleted
+            if ((that._options.save || that._config.save) && that._json.dependencies) {
+                promise = promise
+                .then(function () {
+                    delete that._json.dependencies[name];
+                });
+            }
+
+            if (that._options.saveDev && that._json.devDependencies) {
+                promise = promise
+                .then(function () {
+                    delete that._json.devDependencies[name];
+                });
+            }
+
+            promises.push(promise);
+        });
+
+        return Q.all(promises);
+
+    })
+    .then(function () {
+        return that.saveJson();
+    })
+    // Run post-uninstall hook before resolving with removed packages.
+    .then(scripts.postuninstall.bind(
+        null, that._config, that._logger, packages, that._installed, that._json))
+    // Resolve with removed packages
+    .then(function () {
+        return mout.object.filter(packages, function (dir) {
+            return !!dir;
+        });
+    });
+};
+
+Project.prototype._restoreNode = function (node, flattened, jsonKey, processed) {
+    var deps;
+
+    // Do not restore if the node is missing
+    if (node.missing) {
+        return;
+    }
+
+    node.dependencies = node.dependencies || {};
+    node.dependants = node.dependants || {};
+    processed = processed || {};
+
+    // Only process deps that are not yet processed
+    deps = mout.object.filter(node.pkgMeta[jsonKey], function (value, key) {
+        return !processed[node.name + ':' + key];
+    });
+
+    mout.object.forOwn(deps, function (value, key) {
+        var local = flattened[key];
+        var json = endpointParser.json2decomposed(key, value);
+        var restored;
+        var compatible;
+        var originalSource;
+
+        // Check if the dependency is not installed
+        if (!local) {
+            flattened[key] = restored = json;
+            restored.missing = true;
+        // Even if it is installed, check if it's compatible
+        // Note that linked packages are interpreted as compatible
+        // This might change in the future: #673
+        } else {
+            compatible = local.linked || (!local.missing && json.target === local.pkgMeta._target);
+
+            if (!compatible) {
+                restored = json;
+
+                if (!local.missing) {
+                    restored.pkgMeta = local.pkgMeta;
+                    restored.canonicalDir = local.canonicalDir;
+                    restored.incompatible = true;
+                } else {
+                    restored.missing = true;
+                }
+            } else {
+                restored = local;
+                mout.object.mixIn(local, json);
+            }
+
+            // Check if source changed, marking as different if it did
+            // We only do this for direct root dependencies that are compatible
+            if (node.root && compatible) {
+                originalSource = mout.object.get(local, 'pkgMeta._originalSource');
+                if (originalSource && originalSource !== json.source) {
+                    restored.different = true;
+                }
+            }
+        }
+
+        // Cross reference
+        node.dependencies[key] = restored;
+        processed[node.name + ':' + key] = true;
+
+        restored.dependants = restored.dependants || {};
+        restored.dependants[node.name] = mout.object.mixIn({}, node);  // We need to clone due to shared objects in the manager!
+
+        // Call restore for this dependency
+        this._restoreNode(restored, flattened, 'dependencies', processed);
+
+        // Do the same for the incompatible local package
+        if (local && restored !== local) {
+            this._restoreNode(local, flattened, 'dependencies', processed);
+        }
+    }, this);
+};
+
+module.exports = Project;

lib/core/ResolveCache.js

@@ -0,0 +1,406 @@
+var fs = require('../util/fs');
+var path = require('path');
+var mout = require('mout');
+var Q = require('q');
+var mkdirp = require('mkdirp');
+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');
+
+function ResolveCache(config) {
+    // TODO: Make some config entries, such as:
+    //       - Max MB
+    //       - Max versions per source
+    //       - Max MB per source
+    //       - etc..
+    this._config = config;
+    this._dir = this._config.storage.packages;
+    this._lockDir = this._config.storage.packages;
+
+    mkdirp.sync(this._lockDir);
+
+    // Cache is stored/retrieved statically to ensure singularity
+    // among instances
+    this._cache = this.constructor._cache.get(this._dir);
+    if (!this._cache) {
+        this._cache = new LRU({
+            max: 100,
+            maxAge: 60 * 5 * 1000  // 5 minutes
+        });
+        this.constructor._cache.set(this._dir, this._cache);
+    }
+
+    // Ensure dir is created
+    mkdirp.sync(this._dir);
+}
+
+// -----------------
+
+ResolveCache.prototype.retrieve = function (source, target) {
+    var sourceId = md5(source);
+    var dir = path.join(this._dir, sourceId);
+    var that = this;
+
+    target = target || '*';
+
+    return this._getVersions(sourceId)
+    .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 (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';
+            });
+        }
+
+        // Otherwise check if there's an exact match
+        return mout.array.find(versions, function (version) {
+            return version === 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) {
+    var sourceId;
+    var release;
+    var dir;
+    var pkgLock;
+    var promise;
+    var that = this;
+
+    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');
+
+        // 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;
+                            }
+
+                            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);
+        });
+    })
+    .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) {
+    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 () {
+        var versions = that._cache.get(sourceId) || [];
+        mout.array.remove(versions, release);
+
+        // If this was the last package in the cache,
+        // delete the parent folder (source)
+        // For extra security, check against the file system
+        // if this was really the last package
+        if (!versions.length) {
+            that._cache.del(sourceId);
+
+            return that._getVersions(sourceId)
+            .spread(function (versions) {
+                if (!versions.length) {
+                    // Do not keep in-memory cache if it's completely
+                    // empty
+                    that._cache.del(sourceId);
+
+                    return Q.nfcall(rimraf, path.dirname(dir));
+                }
+            });
+        }
+    });
+};
+
+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));
+};
+
+ResolveCache.prototype.reset = function () {
+    this._cache.reset();
+    return this;
+};
+
+ResolveCache.prototype.versions = function (source) {
+    var sourceId = md5(source);
+
+    return this._getVersions(sourceId)
+    .spread(function (versions) {
+        return versions.filter(function (version) {
+            return semver.valid(version);
+        });
+    });
+};
+
+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);
+                });
+            }, 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.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 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 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);
+        });
+    });
+};
+
+// ------------------------
+
+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) {
+        cache.reset();
+    });
+
+    // Clear root cache
+    this._cache.reset();
+};
+
+// ------------------------
+
+ResolveCache.prototype._getPkgRelease = function (pkgMeta) {
+    var release = pkgMeta.version || (pkgMeta._target === '*' ? '_wildcard' : pkgMeta._target);
+
+    // Encode some dangerous chars such as / and \
+    release = encodeURIComponent(release);
+
+    return release;
+};
+
+ResolveCache.prototype._readPkgMeta = function (dir) {
+    var filename = path.join(dir, '.bower.json');
+
+    return readJson(filename)
+    .spread(function (json) {
+        return json;
+    });
+};
+
+ResolveCache.prototype._getVersions = function (sourceId) {
+    var dir;
+    var versions = this._cache.get(sourceId);
+    var that = this;
+
+    if (versions) {
+        return Q.resolve([versions, true]);
+    }
+
+    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 = [];
+            that._cache.set(sourceId, versions);
+            return [versions, false];
+        }
+
+        throw err;
+    });
+};
+
+ResolveCache.prototype._sortVersions = function (versions) {
+    // Sort DESC
+    versions.sort(function (version1, version2) {
+        var validSemver1 = semver.valid(version1);
+        var validSemver2 = semver.valid(version2);
+
+        // If both are semvers, compare them
+        if (validSemver1 && validSemver2) {
+            return semver.rcompare(version1, version2);
+        }
+
+        // If one of them are semvers, give higher priority
+        if (validSemver1) {
+            return -1;
+        }
+        if (validSemver2) {
+            return 1;
+        }
+
+        // Otherwise they are considered equal
+        return 0;
+    });
+};
+
+// ------------------------
+
+ResolveCache._cache = new LRU({
+    max: 5,
+    maxAge: 60 * 30 * 1000  // 30 minutes
+});
+
+module.exports = ResolveCache;

lib/core/config.js

@@ -1,4 +0,0 @@
-module.exports = {
-  directory: 'components', 
-  json:      'component.json'
-}

lib/core/manager.js

@@ -1,152 +0,0 @@
-// ==========================================
-// BOWER: Manager Object Definition
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
-// Events:
-//  - install: fired when package installed
-//  - resolve: fired when deps resolved
-//  - error: fired on all errors
-//  - data: fired when trying to output data
-//  - end: fired when finished installing
-// ==========================================
-
-var Package = require('./package');
-var config  = require('./config');
-var prune   = require('../util/prune');
-var events  = require('events');
-var async   = require('async');
-var path    = require('path');
-var glob    = require('glob');
-var fs      = require('fs');
-
-// read local dependencies (with versions)
-// read json dependencies (resolving along the way into temp dir)
-// merge local dependencies with json dependencies
-// prune and move dependencies into local directory
-
-var Manager = function (endpoints) {
-  this.dependencies = {};
-  this.cwd          = process.cwd();
-  this.endpoints    = endpoints || [];
-};
-
-Manager.prototype = Object.create(events.EventEmitter.prototype);
-Manager.prototype.constructor = Manager;
-
-Manager.prototype.resolve = function () {
-  var resolved = function () {
-    this.prune();
-    this.on('install', this.emit.bind(this, 'resolve'));
-    this.install();
-  }.bind(this);
-
-  this.once('resolveLocal', function () {
-    if (this.endpoints.length) {
-      this.once('resolveEndpoints', resolved).resolveEndpoints();
-    } else {
-      this.once('resolveFromJson', resolved).resolveFromJson();
-    }
-  }).resolveLocal();
-
-  return this;
-};
-
-Manager.prototype.resolveLocal = function () {
-  glob('./' + config.directory + '/*', function (err, dirs) {
-    if (err) return this.emit('error', err);
-    dirs.forEach(function (dir) {
-      var name = path.basename(dir);
-      this.dependencies[name] = [];
-      this.dependencies[name].push(new Package(name, dir, this));
-    }.bind(this));
-    this.emit('resolveLocal');
-  }.bind(this));
-};
-
-Manager.prototype.resolveEndpoints = function () {
-  // Iterate through paths
-  // Add to depedencies array
-  // Prune & install
-
-  async.forEach(this.endpoints, function (endpoint, next) {
-    var name = path.basename(endpoint).replace(/(\.git)?(#.*)?$/, '');
-    var pkg  = new Package(name, endpoint, this);
-    this.dependencies[name] = this.dependencies[name] || [];
-    this.dependencies[name].push(pkg);
-    pkg.on('resolve', next).resolve();
-  }.bind(this), this.emit.bind(this, 'resolveEndpoints'));
-};
-
-Manager.prototype.loadJSON = function () {
-  var json = path.join(this.cwd, config.json);
-
-  fs.exists(json, function (exists) {
-    if (!exists) return this.emit('error', new Error('Could not find local ' + config.json));
-    fs.readFile(json, 'utf8', function (err, json) {
-      if (err) return this.emit('error', err);
-      this.json    = JSON.parse(json);
-      this.name    = this.json.name;
-      this.version = this.json.version;
-      this.emit('loadJSON');
-    }.bind(this));
-  }.bind(this));
-};
-
-Manager.prototype.resolveFromJson = function () {
-  // loadJSON
-  // Resolve dependencies
-  // Add to dependencies array
-  // Prune & install
-
-  this.once('loadJSON', function () {
-
-    if (!this.json.dependencies) return this.emit('error', new Error('Could not find any dependencies'));
-
-    async.forEach(Object.keys(this.json.dependencies), function (name, next) {
-      var endpoint = this.json.dependencies[name];
-      var pkg      = new Package(name, endpoint, this);
-      this.dependencies[name] = this.dependencies[name] || [];
-      this.dependencies[name].push(pkg);
-      pkg.on('resolve', next).resolve();
-    }.bind(this), this.emit.bind(this, 'resolveFromJson'));
-
-  }.bind(this)).loadJSON();
-};
-
-Manager.prototype.getDeepDependencies = function () {
-  var result = {};
-
-  for (var name in this.dependencies) {
-    this.dependencies[name].forEach(function (pkg) {
-      result[pkg.name] = result[pkg.name] || [];
-      result[pkg.name].push(pkg);
-      pkg.getDeepDependencies().forEach(function (pkg) {
-        result[pkg.name] = result[pkg.name] || [];
-        result[pkg.name].push(pkg);
-      });
-    });
-  }
-
-  return result;
-};
-
-Manager.prototype.prune = function () {
-  try {
-    this.dependencies = prune(this.getDeepDependencies());
-  } catch (err) {
-    this.emit('error', err);
-  }
-  return this;
-};
-
-Manager.prototype.install = function () {
-  async.forEach(Object.keys(this.dependencies), function (name, next) {
-    this.dependencies[name][0].once('install', next).install();
-  }.bind(this), this.emit.bind(this, 'install'));
-  return this;
-};
-
-module.exports = Manager;

lib/core/package.js

@@ -1,425 +0,0 @@
-// ==========================================
-// BOWER: Package Object Definition
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
-// Events:
-//  - install: fired when package installed
-//  - resolve: fired when deps resolved
-//  - error: fired on all errors
-//  - data: fired when trying to output data
-// ==========================================
-
-var spawn    = require('child_process').spawn;
-var _        = require('lodash');
-var fstream  = require('fstream');
-var mkdirp   = require('mkdirp');
-var events   = require('events');
-var rimraf   = require('rimraf');
-var semver   = require('semver');
-var async    = require('async');
-var https    = require('https');
-var http     = require('http');
-var path     = require('path');
-var url      = require('url');
-var tmp      = require('tmp');
-var fs       = require('fs');
-
-var config   = require('./config');
-var source   = require('./source');
-var template = require('../util/template');
-var readJSON = require('../util/read-json');
-
-var temp = process.env.TMPDIR
- || process.env.TMP
- || process.env.TEMP
- || process.platform === "win32" ? "c:\\windows\\temp" : "/tmp";
-
-var home = (process.platform === "win32"
-  ? process.env.USERPROFILE
-  : process.env.HOME) || temp;
-
-var cache = process.platform === "win32"
-  ? path.resolve(process.env.APPDATA || home || temp, "bower-cache")
-  : path.resolve(home || temp, ".bower")
-
-var Package = function (name, endpoint, manager) {
-  this.dependencies = {};
-  this.json         = {};
-  this.name         = name;
-  this.manager      = manager;
-
-  if (endpoint) {
-
-    if (/^(.*\.git)$/.exec(endpoint)) {
-      this.gitUrl = RegExp.$1.replace(/^git\+/, '');
-      this.tag    = false;
-
-    } else if (/^(.*\.git)#(.*)$/.exec(endpoint)) {
-      this.tag    = RegExp.$2;
-      this.gitUrl = RegExp.$1.replace(/^git\+/, '');
-
-    } else if (/^(?:(git):|git\+(https?):)\/\/([^#]+)#?(.*)$/.exec(endpoint)) {
-      this.gitUrl = (RegExp.$1 || RegExp.$2) + "://" + RegExp.$3;
-      this.tag    = RegExp.$4;
-
-    } else if (semver.validRange(endpoint)) {
-      this.tag = endpoint;
-
-    } else if (/^[\.\/~]\.?[^.]*\.(js|css)/.test(endpoint) && fs.statSync(endpoint).isFile()) {
-      this.path      = path.resolve(endpoint);
-      this.assetType = path.extname(endpoint);
-      this.name      = this.name.replace(this.assetType, '');
-
-    } else if (/^[\.\/~]/.test(endpoint)) {
-      this.path = path.resolve(endpoint);
-
-    } else if (/^https?:\/\//.exec(endpoint)) {
-      this.assetUrl  = endpoint;
-      this.assetType = path.extname(endpoint);
-      this.name      = this.name.replace(this.assetType, '');
-
-    } else {
-      this.tag = endpoint.split('#', 2)[1];
-    }
-
-  }
-
-  if (this.manager) {
-    this.on('data',  this.manager.emit.bind(this.manager, 'data'));
-    this.on('error', this.manager.emit.bind(this.manager, 'error'));
-  }
-};
-
-Package.prototype = Object.create(events.EventEmitter.prototype);
-
-Package.prototype.constructor = Package;
-
-Package.prototype.resolve = function () {
-
-  if (this.assetUrl) {
-    this.download();
-  } else if (this.gitUrl) {
-    this.clone();
-  } else if (this.path) {
-    this.copy();
-  } else {
-    this.once('lookup', this.clone).lookup();
-  }
-
-  return this;
-};
-
-Package.prototype.lookup = function () {
-  source.lookup(this.name, function (err, url) {
-    if (err) return this.emit('error', err);
-    this.gitUrl = url;
-    this.emit('lookup');
-  }.bind(this));
-};
-
-Package.prototype.install = function () {
-  if (path.resolve(this.path) == this.localPath) return this.emit('install');
-  mkdirp(path.dirname(this.localPath), function (err) {
-    if (err) return this.emit('error', err);
-    rimraf(this.localPath, function (err) {
-      if (err) return this.emit('error', err);
-      return fs.rename(this.path, this.localPath, function (err) {
-        if (!err) return this.cleanUpLocal();
-        fstream.Reader(this.path)
-          .on('error', this.emit.bind(this, 'error'))
-          .on('end', rimraf.bind(this, this.path, this.cleanUpLocal.bind(this)))
-          .pipe(
-            fstream.Writer({
-              type: 'Directory',
-              path: this.localPath
-            })
-          );
-      }.bind(this));
-    }.bind(this));
-  }.bind(this));
-};
-Package.prototype.cleanUpLocal = function () {
-  if (this.gitUrl) this.json.repository = { type: "git", url: this.gitUrl };
-  if (this.assetUrl) this.json = this.generateAssetJSON();
-  fs.writeFile(path.join(this.localPath, config.json), JSON.stringify(this.json, null, 2));
-  rimraf(path.join(this.localPath, '.git'), this.emit.bind(this, 'install'));
-};
-Package.prototype.generateAssetJSON = function () {
-  var semverParser = new RegExp('(' + semver.expressions.parse.toString().replace(/\$?\/\^?/g, '') + ')');
-  return {
-    name: this.name,
-    main: 'index' + this.assetType,
-    version: semverParser.exec(this.assetUrl) ? RegExp.$1 : "0.0.0",
-    repository: { type: "asset", url: this.assetUrl }
-  }
-}
-
-Package.prototype.uninstall = function () {
-  template('action', { name: 'uninstalling', shizzle: this.path })
-    .on('data', this.emit.bind(this, 'data'));
-  rimraf(this.path, function (err) {
-    if (err) return this.emit('error', err);
-    this.emit.bind(this, 'uninstall');
-  }.bind(this));
-};
-
-// Private
-Package.prototype.loadJSON = function (name) {
-  var pathname = name || ( this.assetType ? 'index' + this.assetType : config.json );
-
-  readJSON(path.join(this.path, pathname), function (err, json) {
-
-    if (err) {
-      if (!name) return this.loadJSON('package.json');
-      return this.assetUrl ? this.emit('loadJSON') : this.path && this.on('describeTag', function (tag) {
-        this.version = this.tag = semver.clean(tag);
-        this.emit('loadJSON')
-      }.bind(this)).describeTag();
-    }
-    this.json    = json;
-    this.name    = this.json.name;
-    this.version = this.json.version;
-    this.emit('loadJSON');
-  }.bind(this), this);
-}
-
-Package.prototype.download = function () {
-  template('action', { name: 'downloading', shizzle: this.assetUrl })
-    .on('data', this.emit.bind(this, 'data'));
-
-  var src  = url.parse(this.assetUrl);
-  var req  = src.protocol === 'https:' ? https : http;
-
-  if (process.env.HTTP_PROXY) {
-    src = url.parse(process.env.HTTP_PROXY);
-    src.path = this.assetUrl;
-  }
-
-  tmp.dir(function (err, tmpPath) {
-
-    var file = fs.createWriteStream(path.join((this.path = tmpPath), 'index' + this.assetType));
-
-    req.get(src, function (res) {
-
-      // if assetUrl results in a redirect we update the assetUrl to the redirect to url
-      if (res.statusCode > 300 && res.statusCode < 400 && res.headers.location) {
-        template('action', { name: 'redirect detected', shizzle: this.assetUrl })
-          .on('data', this.emit.bind(this, 'data'));
-        this.assetUrl = res.headers.location;
-        this.download();
-      }
-
-      res.on('data', function (data) {
-        file.write(data);
-      });
-
-      res.on('end', function () {
-        file.end();
-        this.once('loadJSON', this.addDependencies).loadJSON();
-      }.bind(this));
-
-    }.bind(this)).on('error', this.emit.bind(this, 'error'));
-
-  }.bind(this));
-}
-
-Package.prototype.copy = function () {
-  template('action', { name: 'copying', shizzle: this.path }).on('data', this.emit.bind(this, 'data'));
-
-  tmp.dir(function (err, tmpPath) {
-    fs.stat(this.path, function (err, stats) {
-      if (err) return this.emit('error', err);
-
-      if (this.assetType) {
-        return fs.readFile(this.path, function (err, data) {
-          fs.writeFile(path.join((this.path = tmpPath), 'index' + this.assetType), data, function () {
-            this.once('loadJSON', this.addDependencies).loadJSON();
-          }.bind(this));
-        }.bind(this));
-      }
-
-      var reader = fstream.Reader(this.path).pipe(
-        fstream.Writer({
-          type: 'Directory',
-          path: (this.path = tmpPath)
-        })
-      );
-
-      this.once('loadJSON', this.addDependencies);
-
-      reader.on('error', this.emit.bind(this, 'error'));
-      reader.on('end', this.loadJSON.bind(this));
-    }.bind(this));
-  }.bind(this));
-};
-
-Package.prototype.getDeepDependencies = function (result) {
-  var result = result || [];
-  for (var name in this.dependencies) {
-    result.push(this.dependencies[name])
-    this.dependencies[name].getDeepDependencies(result);
-  }
-  return result;
-};
-
-Package.prototype.addDependencies = function () {
-  var dependencies = this.json.dependencies || {};
-  var callbacks    = Object.keys(dependencies).map(function (name) {
-    return function (callback) {
-      var endpoint = dependencies[name];
-      this.dependencies[name] = new Package(name, endpoint, this);
-      this.dependencies[name].once('resolve', callback).resolve();
-    }.bind(this);
-  }.bind(this));
-  async.parallel(callbacks, this.emit.bind(this, 'resolve'));
-};
-
-Package.prototype.exists = function (callback) {
-  fs.exists(this.localPath, callback);
-};
-
-Package.prototype.clone = function () {
-  template('action', { name: 'cloning', shizzle: this.gitUrl }).on('data', this.emit.bind(this, 'data'));
-  this.path = path.resolve(cache, this.name);
-  this.once('cache', function () {
-    this.once('loadJSON', this.copy.bind(this)).checkout();
-  }.bind(this)).cache();
-}
-
-Package.prototype.cache = function () {
-  mkdirp(cache, function (err) {
-    if (err) return this.emit('error', err);
-    fs.stat(this.path, function (err) {
-      if (!err) {
-        template('action', { name: 'cached', shizzle: this.gitUrl }).on('data', this.emit.bind(this, 'data'));
-        return this.emit('cache');
-      }
-      template('action', { name: 'caching', shizzle: this.gitUrl }).on('data', this.emit.bind(this, 'data'));
-      var url = this.gitUrl;
-      if (process.env.HTTP_PROXY) {
-        url = url.replace(/^git:/, 'https:');
-      }
-      var cp = spawn('git', ['clone', url, this.path]);
-      cp.stderr.setEncoding('utf8');
-      cp.stderr.on('data', this.emit.bind(this, 'data'));
-      cp.on('close', function (code) {
-        if (code != 0) return this.emit('error', new Error('Git status: ' + code));
-        this.emit('cache');
-      }.bind(this));
-    }.bind(this));
-  }.bind(this));
-};
-
-Package.prototype.checkout = function () {
-  template('action', { name: 'fetching', shizzle: this.name })
-    .on('data', this.emit.bind(this, 'data'));
-
-  this.once('versions', function (versions) {
-
-    if (!versions.length) {
-      this.emit('checkout');
-      this.loadJSON();
-    }
-
-    // If tag is specified, try to satisfy it
-    if (this.tag) {
-      versions = versions.filter(function (version) {
-        return semver.satisfies(version, this.tag);
-      }.bind(this));
-
-      if (!versions.length) {
-        return this.emit('error', new Error(
-          'Can not find tag: ' + this.name + '#' + this.tag
-        ));
-      }
-    }
-
-    // Use latest version
-    this.tag = versions[0];
-
-    if (this.tag) {
-      template('action', {
-        name: 'checking out',
-        shizzle: this.name + '#' + this.tag
-      }).on('data', this.emit.bind(this, 'data'));
-
-      spawn('git', [ 'checkout', '-b', this.tag, this.tag], { cwd: this.path }).on('close', function (code) {
-        if (code == 128) {
-          return spawn('git', [ 'checkout', this.tag], { cwd: this.path }).on('close', function (code) {
-            this.emit('checkout');
-            this.loadJSON();
-          }.bind(this));
-        }
-        if (code != 0) return this.emit('error', new Error('Git status: ' + code));
-        this.emit('checkout');
-        this.loadJSON();
-      }.bind(this));
-    }
-  }).versions();
-};
-
-Package.prototype.describeTag = function () {
-  var cp = spawn('git', ['describe', '--always', '--tag'], { cwd: path.resolve(cache, this.name) });
-
-  var tag = '';
-
-  cp.stdout.setEncoding('utf8');
-  cp.stdout.on('data',  function (data) {
-    tag += data;
-  });
-
-  cp.on('close', function (code) {
-    if (code == 128) tag = 'unspecified'.grey; // not a git repo
-    else if (code != 0) return this.emit('error', new Error('Git status: ' + code));
-    this.emit('describeTag', tag.replace(/\n$/, ''));
-  }.bind(this));
-}
-
-Package.prototype.versions = function () {
-  this.on('fetch', function () {
-    var cp = spawn('git', ['tag'], { cwd: path.resolve(cache, this.name) });
-
-    var versions = '';
-
-    cp.stdout.setEncoding('utf8');
-    cp.stdout.on('data',  function (data) {
-      versions += data;
-    });
-
-    cp.on('close', function (code) {
-      versions = versions.split("\n");
-      versions = versions.filter(function (ver) {
-        return semver.valid(ver);
-      });
-      versions = versions.sort(function (a, b) {
-        return semver.gt(a, b) ? -1 : 1;
-      });
-      this.emit('versions', versions);
-    }.bind(this));
-  }.bind(this)).fetch();
-};
-
-Package.prototype.fetch = function () {
-  var cp = spawn('git', ['fetch'], { cwd: path.resolve(cache, this.name) });
-  cp.on('close', function (code) {
-    if (code != 0) return this.emit('error', new Error('Git status: ' + code));
-    this.emit('fetch');
-  }.bind(this));
-};
-
-Package.prototype.fetchURL = function () {
-  if (this.json.repository && this.json.repository.type == 'git') {
-    this.emit('fetchURL',  this.json.repository.url);
-  } else {
-    this.emit('error', new Error('No git url found for ' + this.json.name));
-  }
-};
-
-Package.prototype.__defineGetter__('localPath', function () {
-  return path.join(process.cwd(), config.directory, this.name);
-});
-
-module.exports = Package;

lib/core/resolverFactory.js

@@ -0,0 +1,236 @@
+var Q = require('q');
+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');
+
+var pluginResolverFactory = require('./resolvers/pluginResolverFactory');
+
+function createInstance(decEndpoint, options, registryClient) {
+    decEndpoint = mout.object.pick(decEndpoint, ['name', 'target', 'source']);
+
+    options.version = require('../version');
+
+    return getConstructor(decEndpoint, options, registryClient)
+    .spread(function (ConcreteResolver, decEndpoint) {
+        return new ConcreteResolver(decEndpoint, options.config, options.logger);
+    });
+}
+
+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
+    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, decEndpoint];
+            }
+
+            return [resolvers.GitRemote, decEndpoint];
+        }
+    });
+
+    // SVN case: svn, svn+ssh, svn+http, svn+https, svn+file
+    addResolver(function () {
+        if (/^svn(\+(ssh|https?|file))?:\/\//i.test(source)) {
+            return [resolvers.Svn, decEndpoint];
+        }
+    });
+
+    // URL case
+    addResolver(function () {
+        if (/^https?:\/\//i.exec(source)) {
+            return [resolvers.Url, decEndpoint];
+        }
+    });
+
+
+    // If source is ./ or ../ or an absolute path
+
+    addResolver(function () {
+        var absolutePath = path.resolve(config.cwd, source);
+
+        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;
+
+                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]);
+                });
+            });
+        }
+    });
+
+    // Check if is a shorthand and expand it
+    addResolver(function () {
+        // Skip ssh and/or URL with auth
+        if (/[:@]/.test(source)) {
+            return;
+        }
+
+        // Ensure exactly only one "/"
+        var parts = source.split('/');
+        if (parts.length === 2) {
+            decEndpoint.source = mout.string.interpolate(config.shorthandResolver, {
+                shorthand: source,
+                owner: parts[0],
+                package: parts[1]
+            });
+
+            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) {
+        ConcreteResolver.clearRuntimeCache();
+    });
+}
+
+module.exports = createInstance;
+module.exports.getConstructor = getConstructor;
+module.exports.clearRuntimeCache = clearRuntimeCache;

lib/core/resolvers/FsResolver.js

@@ -0,0 +1,143 @@
+var util = require('util');
+var fs = require('../../util/fs');
+var path = require('path');
+var mout = require('mout');
+var Q = require('q');
+var junk = require('junk');
+var Resolver = require('./Resolver');
+var copy = require('../../util/copy');
+var extract = require('../../util/extract');
+var createError = require('../../util/createError');
+
+function FsResolver(decEndpoint, config, logger) {
+    Resolver.call(this, decEndpoint, config, logger);
+
+    // Ensure absolute path
+    this._source = path.resolve(this._config.cwd, this._source);
+
+    // If target was specified, simply reject the promise
+    if (this._target !== '*') {
+        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);
+    }
+}
+
+util.inherits(FsResolver, Resolver);
+mout.object.mixIn(FsResolver, Resolver);
+
+// -----------------
+
+FsResolver.isTargetable = function () {
+    return false;
+};
+
+// TODO: Should we store latest mtimes in the resolution and compare?
+//       This would be beneficial when copying big files/folders
+
+// 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 () {
+    return this._copy()
+    .then(this._extract.bind(this))
+    .then(this._rename.bind(this));
+};
+
+// -----------------
+
+FsResolver.prototype._copy = function () {
+    var that = this;
+
+    return Q.nfcall(fs.stat, this._source)
+    .then(function (stat) {
+        var dst;
+        var copyOpts;
+        var promise;
+
+        that._sourceStat = stat;
+        copyOpts = { mode: stat.mode };
+
+        // If it's a folder
+        if (stat.isDirectory()) {
+            dst = that._tempDir;
+
+            // 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
+        } else {
+            dst = path.join(that._tempDir, path.basename(that._source));
+            promise = copy.copyFile(that._source, dst, copyOpts)
+            .then(function () {
+                return dst;
+            });
+        }
+
+        that._logger.action('copy', that._source, {
+            src: that._source,
+            dst: dst
+        });
+
+        return promise;
+    });
+};
+
+FsResolver.prototype._extract = function (file) {
+    if (!file || !extract.canExtract(file)) {
+        return Q.resolve();
+    }
+
+    this._logger.action('extract', path.basename(this._source), {
+        archive: file,
+        to: this._tempDir
+    });
+
+    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;
+
+        // 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);
+
+            return Q.nfcall(fs.rename, oldPath, newPath);
+        }
+    }.bind(this));
+};
+
+FsResolver.prototype._savePkgMeta = function (meta) {
+    // Store main if is a single file
+    if (this._singleFile) {
+        meta.main = this._singleFile;
+    }
+
+    return Resolver.prototype._savePkgMeta.call(this, meta);
+};
+
+module.exports = FsResolver;

lib/core/resolvers/GitFsResolver.js

@@ -0,0 +1,77 @@
+var util = require('util');
+var Q = require('q');
+var mout = require('mout');
+var path = require('path');
+var GitResolver = require('./GitResolver');
+var copy = require('../../util/copy');
+var cmd = require('../../util/cmd');
+
+function GitFsResolver(decEndpoint, config, logger) {
+    GitResolver.call(this, decEndpoint, config, logger);
+
+    // Ensure absolute path
+    this._source = path.resolve(this._config.cwd, this._source);
+}
+
+util.inherits(GitFsResolver, GitResolver);
+mout.object.mixIn(GitFsResolver, GitResolver);
+
+// -----------------
+
+// Override the checkout function to work with the local copy
+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
+    });
+
+    // 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 }));
+};
+
+GitFsResolver.prototype._copy = function () {
+    return copy.copyDir(this._source, this._tempDir);
+};
+
+// -----------------
+
+// Grab refs locally
+GitFsResolver.refs = function (source) {
+    var value;
+
+    // TODO: Normalize source because of the various available protocols?
+    value = this._cache.refs.get(source);
+    if (value) {
+        return Q.resolve(value);
+    }
+
+    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
+
+        // Update the refs with the actual refs
+        this._cache.refs.set(source, refs);
+
+        return refs;
+    }.bind(this));
+
+    // Store the promise to be reused until it resolves
+    // to a specific value
+    this._cache.refs.set(source, value);
+
+    return value;
+};
+
+module.exports = GitFsResolver;

lib/core/resolvers/GitHubResolver.js

@@ -0,0 +1,145 @@
+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');
+var createError = require('../../util/createError');
+
+function GitHubResolver(decEndpoint, config, logger) {
+    var pair;
+
+    GitRemoteResolver.call(this, decEndpoint, config, logger);
+
+    // Grab the org/repo
+    // /xxxxx/yyyyy.git or :xxxxx/yyyyy.git (.git is optional)
+    pair = GitHubResolver.getOrgRepoPair(this._source);
+    if (!pair) {
+        throw createError('Invalid GitHub URL', 'EINVEND', {
+            details: this._source + ' does not seem to be a valid GitHub URL'
+        });
+    }
+
+    this._org = pair.org;
+    this._repo = pair.repo;
+
+    // Ensure trailing for all protocols
+    if (!mout.string.endsWith(this._source, '.git')) {
+        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);
+mout.object.mixIn(GitHubResolver, GitRemoteResolver);
+
+// -----------------
+
+GitHubResolver.prototype._checkout = function () {
+    var msg;
+    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;
+
+    if (this._config.userAgent) {
+        reqHeaders['User-Agent'] = this._config.userAgent;
+    }
+
+    this._logger.action('download', tarballUrl, {
+        url: that._source,
+        to: file
+    });
+
+    // Download tarball
+    return download(tarballUrl, file, {
+        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
+        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 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));
+    });
+};
+
+GitHubResolver.prototype._savePkgMeta = function (meta) {
+    // Set homepage if not defined
+    if (!meta.homepage) {
+        meta.homepage = 'https://github.com/' + this._org + '/' + this._repo;
+    }
+
+    return GitRemoteResolver.prototype._savePkgMeta.call(this, meta);
+};
+
+// ----------------
+
+GitHubResolver.getOrgRepoPair = function (url) {
+    var match;
+
+    match = url.match(/(?:@|:\/\/)github.com[:\/]([^\/\s]+?)\/([^\/\s]+?)(?:\.git)?\/?$/i);
+    if (!match) {
+        return null;
+    }
+
+    return {
+        org: match[1],
+        repo: match[2]
+    };
+};
+
+module.exports = GitHubResolver;

lib/core/resolvers/GitRemoteResolver.js

@@ -0,0 +1,281 @@
+var util = require('util');
+var url = require('url');
+var Q = require('q');
+var mout = require('mout');
+var LRU = require('lru-cache');
+var GitResolver = require('./GitResolver');
+var cmd = require('../../util/cmd');
+
+function GitRemoteResolver(decEndpoint, config, logger) {
+    GitResolver.call(this, decEndpoint, config, logger);
+
+    if (!mout.string.startsWith(this._source, 'file://')) {
+        // Trim trailing slashes
+        this._source = this._source.replace(/\/+$/, '');
+    }
+
+    // If the name was guessed, remove the trailing .git
+    if (this._guessedName && mout.string.endsWith(this._name, '.git')) {
+        this._name = this._name.slice(0, -4);
+    }
+
+    // Get the remote of this source
+    if (!/:\/\//.test(this._source)) {
+        this._remote = url.parse('ssh://' + this._source);
+    } else {
+        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);
+mout.object.mixIn(GitRemoteResolver, GitResolver);
+
+// -----------------
+
+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
+    });
+
+    // 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
+    } else {
+        promise = this._fastClone(resolution);
+    }
+
+    // Throttle the progress reporter to 1 time each sec
+    reporter = mout.fn.throttle(function (data) {
+        var lines;
+
+        lines = data.split(/[\r\n]+/);
+        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?
+                that._logger.info('progress', line.trim());
+            }
+        });
+    }, 1000);
+
+    // Start reporting progress after a few seconds
+    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();
+    });
+};
+
+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;
+    });
+};
+
+// ------------------------------
+
+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) {
+    var branch,
+        args,
+        that = this;
+
+    branch = resolution.tag || resolution.branch;
+    args = ['clone',  this._source, '-b', branch, '--progress', '.'];
+
+    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)) {
+            args.push('--depth', 1);
+        }
+
+        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) &&
+        mout.string.startsWith(this._source, 'git://') &&
+        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 += '\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.';
+    }
+};
+
+// 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) {
+    var value;
+
+    // TODO: Normalize source because of the various available protocols?
+    value = this._cache.refs.get(source);
+    if (value) {
+        return Q.resolve(value);
+    }
+
+    // Store the promise in the refs object
+    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
+
+        // Update the refs with the actual refs
+        this._cache.refs.set(source, refs);
+
+        return refs;
+    }.bind(this));
+
+    // Store the promise to be reused until it resolves
+    // to a specific value
+    this._cache.refs.set(source, value);
+
+    return value;
+};
+
+// 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

@@ -0,0 +1,380 @@
+var util = require('util');
+var path = require('path');
+var Q = require('q');
+var rimraf = require('../../util/rimraf');
+var mkdirp = require('mkdirp');
+var which = require('which');
+var LRU = require('lru-cache');
+var mout = require('mout');
+var Resolver = require('./Resolver');
+var semver = require('../../util/semver');
+var createError = require('../../util/createError');
+
+var hasGit;
+
+// Check if git is installed
+try {
+    which.sync('git');
+    hasGit = true;
+} catch (ex) {
+    hasGit = false;
+}
+
+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) {
+        throw createError('git is not installed or not in the PATH', 'ENOGIT');
+    }
+}
+
+util.inherits(GitResolver, Resolver);
+mout.object.mixIn(GitResolver, Resolver);
+
+// -----------------
+
+GitResolver.prototype._hasNew = function (pkgMeta) {
+    var oldResolution = pkgMeta._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)) {
+            return true;
+        }
+
+        // As last check, we compare both commit hashes
+        return resolution.commit !== oldResolution.commit;
+    });
+};
+
+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();
+        });
+    });
+};
+
+// -----------------
+
+// Abstract functions that should be implemented by concrete git resolvers
+GitResolver.prototype._checkout = function () {
+    throw new Error('_checkout not implemented');
+};
+
+GitResolver.refs = function (source) {
+    throw new Error('refs not implemented');
+};
+
+// -----------------
+
+GitResolver.prototype._findResolution = function (target) {
+    var err;
+    var self = this.constructor;
+    var that = this;
+
+    target = target || this._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)) {
+        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;
+
+            // If there are no tags and target is *,
+            // fallback to the latest commit on master
+            if (!versions.length && target === '*') {
+                return that._findResolution('master');
+            }
+
+            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 };
+            }
+
+            // 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) {
+                // 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] };
+                }
+
+                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] };
+        }
+        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;
+    });
+};
+
+GitResolver.prototype._cleanup = function () {
+    var gitFolder = path.join(this._tempDir, '.git');
+
+    return Q.nfcall(rimraf, gitFolder);
+};
+
+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.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
+        meta.version = version;
+    } else {
+        // If resolved to a target that is not a version,
+        // remove the version from the meta
+        delete meta.version;
+    }
+
+    // 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);
+
+    // Save resolution to be used in hasNew later
+    meta._resolution = this._resolution;
+
+    return Resolver.prototype._savePkgMeta.call(this, meta);
+};
+
+// ------------------------------
+
+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);
+
+            // 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));
+    }
+
+    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] });
+            }
+        }
+
+        // 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));
+
+
+    // Store the promise to be reused until it resolves
+    // to a specific value
+    this._cache.versions.set(source, value);
+
+    return value;
+};
+
+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 = {};
+
+        // 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];
+            }
+        });
+
+        this._cache.tags.set(source, tags);
+
+        return tags;
+    }.bind(this));
+
+    // Store the promise to be reused until it resolves
+    // to a specific value
+    this._cache.tags.set(source, value);
+
+    return value;
+};
+
+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 = {};
+
+        // 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];
+            }
+        });
+
+        this._cache.branches.set(source, branches);
+
+        return branches;
+    }.bind(this));
+
+    // Store the promise to be reused until it resolves
+    // to a specific value
+    this._cache.branches.set(source, value);
+
+    return value;
+};
+
+GitResolver.clearRuntimeCache = function () {
+    // Reset cache for branches, tags, etc
+    mout.object.forOwn(GitResolver._cache, function (lru) {
+        lru.reset();
+    });
+};
+
+GitResolver._cache = {
+    branches: new LRU({ max: 50, maxAge: 5 * 60 * 1000 }),
+    tags: new LRU({ max: 50, maxAge: 5 * 60 * 1000 }),
+    versions: new LRU({ max: 50, maxAge: 5 * 60 * 1000 }),
+    refs: new LRU({ max: 50, maxAge: 5 * 60 * 1000 })
+};
+
+module.exports = GitResolver;

lib/core/resolvers/Resolver.js

@@ -0,0 +1,230 @@
+var fs = require('../../util/fs');
+var path = require('path');
+var Q = require('q');
+var tmp = require('tmp');
+var mkdirp = require('mkdirp');
+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();
+
+function Resolver(decEndpoint, config, logger) {
+    this._source = decEndpoint.source;
+    this._target = decEndpoint.target || '*';
+    this._name = decEndpoint.name || path.basename(this._source);
+
+    this._config = config;
+    this._logger = logger;
+
+    this._guessedName = !decEndpoint.name;
+}
+
+// -----------------
+
+Resolver.prototype.getSource = function () {
+    return this._source;
+};
+
+Resolver.prototype.getName = function () {
+    return this._name;
+};
+
+Resolver.prototype.getTarget = function () {
+    return this._target;
+};
+
+Resolver.prototype.getTempDir = function () {
+    return this._tempDir;
+};
+
+Resolver.prototype.getPkgMeta = function () {
+    return this._pkgMeta;
+};
+
+Resolver.prototype.hasNew = function (pkgMeta) {
+    var promise;
+    var that = this;
+
+    // If already working, error out
+    if (this._working) {
+        return Q.reject(createError('Already working', 'EWORKING'));
+    }
+
+    this._working = true;
+
+    // Avoid reading the package meta if already given
+    promise = this._hasNew(pkgMeta);
+
+    return promise.fin(function () {
+        that._working = false;
+    });
+};
+
+Resolver.prototype.resolve = function () {
+    var that = this;
+
+    // If already working, error out
+    if (this._working) {
+        return Q.reject(createError('Already working', 'EWORKING'));
+    }
+
+    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;
+    });
+};
+
+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 () {
+    throw new Error('_resolve not implemented');
+};
+
+// Abstract functions that can be re-implemented by concrete resolvers
+// as necessary
+Resolver.prototype._hasNew = function (pkgMeta) {
+    return Q.resolve(true);
+};
+
+Resolver.isTargetable = function () {
+    return true;
+};
+
+Resolver.versions = function (source) {
+    return Q.resolve([]);
+};
+
+Resolver.clearRuntimeCache = 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, 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 () {
+    var tempDir = this._tempDir;
+
+    if (!tempDir) {
+        return Q.resolve();
+    }
+
+    // Delete and create folder
+    return Q.nfcall(rimraf, tempDir)
+    .then(function () {
+        return Q.nfcall(mkdirp, tempDir, 0777 & ~process.umask());
+    })
+    .then(function () {
+        return tempDir;
+    });
+};
+
+Resolver.prototype._readJson = function (dir) {
+    var that = this;
+
+    dir = dir || this._tempDir;
+    return readJson(dir, {
+        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);
+        }
+
+        return json;
+    });
+};
+
+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) {
+        this._name = meta.name;
+    }
+
+    // Handle ignore property, deleting all files from the temporary directory
+    // If no ignores were specified, simply resolve
+    if (!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;
+    });
+};
+
+Resolver.prototype._savePkgMeta = function (meta) {
+    var that = this;
+    var contents;
+
+    // Store original source & target
+    meta._source = this._source;
+    meta._target = this._target;
+
+    // Stringify contents
+    contents = JSON.stringify(meta, null, 2);
+
+    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

@@ -0,0 +1,403 @@
+var util = require('util');
+var Q = require('q');
+var which = require('which');
+var LRU = require('lru-cache');
+var mout = require('mout');
+var Resolver = require('./Resolver');
+var semver = require('../../util/semver');
+var createError = require('../../util/createError');
+var cmd = require('../../util/cmd');
+
+var hasSvn;
+
+// Check if svn is installed
+try {
+    which.sync('svn');
+    hasSvn = true;
+} catch (ex) {
+    hasSvn = false;
+}
+
+function SvnResolver(decEndpoint, config, logger) {
+    Resolver.call(this, decEndpoint, config, logger);
+
+    if (!hasSvn) {
+        throw createError('svn is not installed or not in the PATH', 'ENOSVN');
+    }
+}
+
+util.inherits(SvnResolver, Resolver);
+mout.object.mixIn(SvnResolver, Resolver);
+
+// -----------------
+
+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
+};
+
+SvnResolver.prototype._hasNew = function (pkgMeta) {
+    var oldResolution = pkgMeta._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)) {
+            return true;
+        }
+
+        // As last check, we compare both commit hashes
+        return resolution.commit !== oldResolution.commit;
+    });
+};
+
+SvnResolver.prototype._resolve = function () {
+    var that = this;
+
+    return this._findResolution()
+    .then(function () {
+        return that._export();
+    });
+};
+
+// -----------------
+
+SvnResolver.prototype._export = function () {
+    var promise;
+    var timer;
+    var reporter;
+    var that = this;
+    var resolution = this._resolution;
+
+    this.source = SvnResolver.getSource(this._source);
+
+    this._logger.action('export', resolution.tag || resolution.branch || resolution.commit, {
+        resolution: resolution,
+        to: this._tempDir
+    });
+
+    if (resolution.type === 'commit') {
+        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', ['export', '--force', '--non-interactive', this._source + '/trunk', this._tempDir]);
+    } else if (resolution.type === 'branch') {
+        promise = cmd('svn', ['export', '--force', '--non-interactive', this._source + '/branches/' + resolution.branch, this._tempDir]);
+    } else {
+        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) {
+        var lines;
+
+        lines = data.split(/[\r\n]+/);
+        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?
+                that._logger.info('progress', line.trim());
+            }
+        });
+    }, 1000);
+
+    // Start reporting progress after a few seconds
+    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();
+    });
+};
+
+// -----------------
+
+SvnResolver.prototype._findResolution = function (target) {
+    var err;
+    var self = this.constructor;
+    var that = this;
+
+    target = target || this._target || '*';
+
+    this._source = SvnResolver.getSource(this._source);
+
+    // 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)) {
+        target = target.split('r');
+
+        this._resolution = { type: 'commit', commit: target[1] };
+        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; });
+
+            // If there are no tags and target is *,
+            // fallback to the latest commit on trunk
+            if (!versions.length && target === '*') {
+                return that._findResolution('trunk');
+            }
+
+            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 };
+            }
+
+            // 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) {
+                // 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] };
+                }
+
+                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] };
+        }
+        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._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
+            });
+        }
+
+        // Ensure package meta version is the same as the resolution
+        meta.version = version;
+    } else {
+        // If resolved to a target that is not a version,
+        // remove the version from the meta
+        delete meta.version;
+    }
+
+    // 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;
+
+    // Save resolution to be used in hasNew later
+    meta._resolution = this._resolution;
+
+    return Resolver.prototype._savePkgMeta.call(this, meta);
+};
+
+// ------------------------------
+
+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);
+
+            // 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));
+    }
+
+    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] });
+            }
+        }
+
+        // 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));
+
+    // Store the promise to be reused until it resolves
+    // to a specific value
+    this._cache.versions.set(source, value);
+
+    return value;
+};
+
+SvnResolver.tags = function (source) {
+    source = SvnResolver.getSource(source);
+
+    var value = this._cache.tags.get(source);
+
+    if (value) {
+        return Q.resolve(value);
+    }
+
+    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));
+
+    // Store the promise to be reused until it resolves
+    // to a specific value
+    this._cache.tags.set(source, value);
+
+    return value;
+};
+
+SvnResolver.branches = function (source) {
+    source = SvnResolver.getSource(source);
+
+    var value = this._cache.branches.get(source);
+
+    if (value) {
+        return Q.resolve(value);
+    }
+
+    value = cmd('svn', ['list', source + '/branches', '--verbose', '--non-interactive'])
+    .spread(function (stout) {
+        var branches = SvnResolver.parseSubversionListOutput(stout.toString());
+
+        // trunk is a branch!
+        branches.trunk = '*';
+
+        this._cache.branches.set(source, branches);
+        return branches;
+
+    }.bind(this));
+
+    // Store the promise to be reused until it resolves
+    // to a specific value
+    this._cache.branches.set(source, value);
+
+    return value;
+};
+
+SvnResolver.parseSubversionListOutput = function (stout) {
+
+    var entries = {};
+    var lines = stout
+        .trim()
+        .split(/[\r\n]+/);
+
+    // For each line in the refs, match only the branches
+    lines.forEach(function (line) {
+        var match = line.match(/\s+([0-9]+)\s.+\s([\w.$-]+)\//i);
+
+        if (match && match[2] !== '.') {
+            entries[match[2]] = match[1];
+        }
+    });
+
+    return entries;
+};
+
+SvnResolver.clearRuntimeCache = function () {
+    // Reset cache for branches, tags, etc
+    mout.object.forOwn(SvnResolver._cache, function (lru) {
+        lru.reset();
+    });
+};
+
+SvnResolver._cache = {
+    branches: new LRU({ max: 50, maxAge: 5 * 60 * 1000 }),
+    tags: new LRU({ max: 50, maxAge: 5 * 60 * 1000 }),
+    versions: new LRU({ max: 50, maxAge: 5 * 60 * 1000 })
+};
+
+module.exports = SvnResolver;

lib/core/resolvers/UrlResolver.js

@@ -0,0 +1,294 @@
+var util = require('util');
+var path = require('path');
+var fs = require('../../util/fs');
+var url = require('url');
+var request = require('request');
+var Q = require('q');
+var mout = require('mout');
+var junk = require('junk');
+var Resolver = require('./Resolver');
+var download = require('../../util/download');
+var extract = require('../../util/extract');
+var createError = require('../../util/createError');
+
+function UrlResolver(decEndpoint, config, logger) {
+    Resolver.call(this, decEndpoint, config, logger);
+
+    // If target was specified, error out
+    if (this._target !== '*') {
+        throw createError('URL sources can\'t resolve targets', 'ENORESTARGET');
+    }
+
+    // If the name was guessed
+    if (this._guessedName) {
+        // 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._remote = url.parse(this._source);
+}
+
+util.inherits(UrlResolver, Resolver);
+mout.object.mixIn(UrlResolver, Resolver);
+
+// -----------------
+
+UrlResolver.isTargetable = function () {
+    return false;
+};
+
+UrlResolver.prototype._hasNew = function (pkgMeta) {
+    var oldCacheHeaders = pkgMeta._cacheHeaders || {};
+    var reqHeaders = {};
+
+    // If the previous cache headers contain an ETag,
+    // send the "If-None-Match" header with it
+    if (oldCacheHeaders.ETag) {
+        reqHeaders['If-None-Match'] = oldCacheHeaders.ETag;
+    }
+
+    if (this._config.userAgent) {
+        reqHeaders['User-Agent'] = this._config.userAgent;
+    }
+
+    // Make an HEAD request to the source
+    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 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;
+    });
+};
+
+// 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 () {
+    // 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));
+};
+
+// -----------------
+
+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;
+
+    if (this._config.userAgent) {
+        reqHeaders['User-Agent'] = this._config.userAgent;
+    }
+
+    this._logger.action('download', that._source, {
+        url: that._source,
+        to: file
+    });
+
+    // Download the file
+    return download(this._source, file, {
+        ca: this._config.ca.default,
+        strictSSL: this._config.strictSsl,
+        timeout: this._config.timeout,
+        headers: reqHeaders
+    })
+    .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);
+        }
+
+        // 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) {
+    var disposition;
+    var newFile;
+    var match;
+
+    // Check if we got a Content-Disposition header
+    disposition = response.headers['content-disposition'];
+    if (!disposition) {
+        return Q.resolve([file, response]);
+    }
+
+    // Since there's various security issues with parsing this header, we only
+    // interpret word chars plus dots, dashes and spaces
+    match = disposition.match(/filename=(?:"([\w\-\. ]+)")/i);
+    if (!match) {
+        // The spec defines that the filename must be in quotes,
+        // though a wide range of servers do not follow the rule
+        match = disposition.match(/filename=([\w\-\.]+)/i);
+        if (!match) {
+            return Q.resolve([file, response]);
+        }
+    }
+
+    // Trim spaces
+    newFile = match[1].trim();
+
+    // The filename can't end with a dot because this is known
+    // to cause issues in Windows
+    // See: http://superuser.com/questions/230385/dots-at-end-of-file-name
+    if (mout.string.endsWith(newFile, '.')) {
+        return Q.resolve([file, response]);
+    }
+
+    newFile = path.join(this._tempDir, newFile);
+
+    return Q.nfcall(fs.rename, file, newFile)
+    .then(function () {
+        return [newFile, 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, ['"', '\'']);
+    }
+
+    if (!extract.canExtract(file, mimeType)) {
+        return Q.resolve();
+    }
+
+    this._logger.action('extract', path.basename(this._source), {
+        archive: file,
+        to: this._tempDir
+    });
+
+    return extract(file, this._tempDir, {
+        mimeType: mimeType
+    });
+};
+
+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);
+
+        // 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));
+};
+
+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), '"');
+    }
+
+    // Store main if is a single file
+    if (this._singleFile) {
+        meta.main = this._singleFile;
+    }
+
+    return Resolver.prototype._savePkgMeta.call(this, meta);
+};
+
+UrlResolver.prototype._collectCacheHeaders = function (res) {
+    var headers = {};
+
+    // Collect cache headers
+    this.constructor._cacheHeaders.forEach(function (name) {
+        var value = res.headers[name.toLowerCase()];
+
+        if (value != null) {
+            headers[name] = value;
+        }
+    });
+
+    return headers;
+};
+
+UrlResolver._cacheHeaders = [
+    'Content-MD5',
+    'ETag',
+    'Last-Modified',
+    'Content-Language',
+    'Content-Length',
+    'Content-Type',
+    'Content-Disposition'
+];
+
+module.exports = UrlResolver;

lib/core/resolvers/index.js

@@ -0,0 +1,8 @@
+module.exports = {
+    GitFs: require('./GitFsResolver'),
+    GitRemote: require('./GitRemoteResolver'),
+    GitHub: require('./GitHubResolver'),
+    Svn: require('./SvnResolver'),
+    Fs: require('./FsResolver'),
+    Url: require('./UrlResolver')
+};

lib/core/resolvers/pluginResolverFactory.js

@@ -0,0 +1,323 @@
+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 wheter 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

@@ -0,0 +1,97 @@
+var mout = require('mout');
+var cmd = require('../util/cmd');
+var Q = require('q');
+var shellquote = require('shell-quote');
+
+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 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));
+
+    //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++) {
+            var packageName = desiredOrder[i];
+            if (depsSatisfied(packageName)) {
+                ordered.push(packageName);
+                mout.array.remove(desiredOrder, packageName);
+                //as soon as we resolve a package start the loop again
+                resolvedOne = true;
+                break;
+            }
+        }
+
+        if (!resolvedOne && desiredOrder.length > 0) {
+            //if we're here then some package(s) doesn't have all its deps satisified
+            //so lets just jam those names on the end
+            ordered = ordered.concat(desiredOrder);
+        }
+
+    }
+
+    return ordered;
+};
+
+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 args = shellquote.parse(cmdString, env);
+    var cmdName = args[0];
+    mout.array.remove(args, cmdName); //no rest() in mout
+
+    var options = {
+        cwd: config.cwd,
+        env: env
+    };
+
+    var promise = cmd(cmdName, args, options);
+
+    promise.progress(function (progress) {
+        progress.split('\n').forEach(function (line) {
+            if (line) {
+                logger.action(action, line);
+            }
+        });
+    });
+
+    return promise;
+};
+
+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 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/core/source.js

@@ -1,72 +0,0 @@
-// ==========================================
-// BOWER: Source Api
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
-
-var request  = require('request');
-var _        = require('lodash');
-
-var endpoint = 'https://bower.herokuapp.com/packages';
-
-if (process.env.HTTP_PROXY) {
-  request = request.defaults({'proxy': process.env.HTTP_PROXY});
-}
-
-exports.lookup = function (name, callback) {
-  request.get(endpoint + '/' + encodeURIComponent(name), function (err, response, body) {
-    if (err || response.statusCode !== 200) return callback(err || new Error(name + ' not found'));
-    callback(err, body && JSON.parse(body).url);
-  });
-};
-
-exports.register = function (name, url, callback) {
-  var body = {name: name, url: url};
-
-  request.post({url: endpoint, form: body}, function (err, response, body) {
-    if (err) return callback(err);
-
-    if (response.statusCode === 406) {
-      return callback(new Error('Duplicate package'));
-    }
-
-    if (response.statusCode === 400) {
-      return callback(new Error('Incorrect format'));
-    }
-
-    if (response.statusCode !== 201) {
-      return callback(new Error('Unknown error: ' + response.statusCode));
-    }
-
-    callback();
-  });
-};
-
-exports.search = function (name, callback) {
-  request.get(endpoint + '/search/' + encodeURIComponent(name), function (err, response, body) {
-    callback(err, body && JSON.parse(body));
-  });
-};
-
-exports.info = function (name, callback) {
-  exports.lookup(name, function (err, url) {
-    if (err) return callback(err);
-
-    var Package = require('./package');
-    var pkg     = new Package(name, url);
-
-    pkg.once('resolve', function () {
-      pkg.once('versions', function (versions) {
-        callback(null, { pkg: pkg, versions: versions });
-      }).versions();
-    }).resolve();
-  });
-};
-
-exports.all = function (callback) {
-  request.get(endpoint, function (err, response, body) {
-    callback(err, body && JSON.parse(body));
-  });
-};

lib/index.js

@@ -1,11 +1,19 @@
-// ==========================================
-// BOWER: Public API Defintion
-// ==========================================
-// Copyright 2012 Twitter, Inc
-// Licensed under The MIT License
-// http://opensource.org/licenses/MIT
-// ==========================================
+var commands = require('./commands');
+var version = require('./version');
+var abbreviations = require('./util/abbreviations')(commands);
+
+function clearRuntimeCache() {
+    // Note that in edge cases, some architecture components instance's
+    // in-memory cache might be skipped.
+    // If that's a problem, you should create and fresh instances instead.
+    var PackageRepository = require('./core/PackageRepository');
+    PackageRepository.clearRuntimeCache();
+}
 
 module.exports = {
-  commands: require('./commands')
-};
+    version: version,
+    commands: commands,
+    config: require('./config')(),
+    abbreviations: abbreviations,
+    reset: clearRuntimeCache
+};

lib/renderers/JsonRenderer.js

@@ -0,0 +1,133 @@
+var chalk = require('chalk');
+var Q = require('q');
+var promptly = require('promptly');
+var createError = require('../util/createError');
+
+function JsonRenderer() {
+    this._nrLogs = 0;
+}
+
+JsonRenderer.prototype.end = function (data) {
+    if (this._nrLogs) {
+        process.stderr.write(']\n');
+    }
+
+    if (data) {
+        process.stdout.write(this._stringify(data) + '\n');
+    }
+};
+
+JsonRenderer.prototype.error = function (err) {
+    var message = err.message;
+    var stack;
+
+    err.id = err.code || 'error';
+    err.level = 'error';
+    err.data = err.data || {};
+
+    // Need to set message again because it is
+    // not enumerable in some cases
+    delete err.message;
+    err.message = message;
+
+    // Stack
+    stack = err.fstream_stack || err.stack || 'N/A';
+    err.stacktrace = (Array.isArray(stack) ? stack.join('\n') : stack);
+
+    this.log(err);
+    this.end();
+};
+
+JsonRenderer.prototype.log = function (log) {
+    if (!this._nrLogs) {
+        process.stderr.write('[');
+    } else {
+        process.stderr.write(', ');
+    }
+
+    process.stderr.write(this._stringify(log));
+    this._nrLogs++;
+};
+
+JsonRenderer.prototype.prompt = function (prompts) {
+    var promise = Q.resolve();
+    var answers = {};
+    var that = this;
+
+    prompts.forEach(function (prompt) {
+        var opts;
+        var funcName;
+
+        // Strip colors
+        prompt.message = chalk.stripColor(prompt.message);
+
+        // 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);
+
+                if (typeof ret === 'string') {
+                    throw ret;
+                }
+
+                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;
+        }
+
+        promise = promise.then(function () {
+            // Log
+            prompt.level = 'prompt';
+            that.log(prompt);
+
+            return Q.nfcall(promptly[funcName], '', opts)
+            .then(function (answer) {
+                answers[prompt.name] = answer;
+            });
+        });
+
+        if (prompt.type === 'checkbox') {
+            promise = promise.then(function () {
+                answers[prompt.name] = answers[prompt.name].split(',');
+            });
+        }
+    });
+
+    return promise.then(function () {
+        return answers;
+    });
+};
+
+// -------------------------
+
+JsonRenderer.prototype._stringify = function (log) {
+    // To json
+    var str = JSON.stringify(log, null, '  ');
+    // Remove colors in case some log has colors..
+    str = chalk.stripColor(str);
+
+    return str;
+};
+
+module.exports = JsonRenderer;

lib/renderers/StandardRenderer.js

@@ -0,0 +1,507 @@
+var chalk = require('chalk');
+var path = require('path');
+var mout = require('mout');
+var archy = require('archy');
+var Q = require('q');
+var stringifyObject = require('stringify-object');
+var os = require('os');
+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
+        label: 20, // Label max chars
+        sumup: 5   // Amount to sum when the label exceeds
+    };
+    this._colors = {
+        warn: chalk.yellow,
+        error: chalk.red,
+        conflict: chalk.magenta,
+        debug: chalk.gray,
+        default: chalk.cyan
+    };
+
+    this._command = command;
+    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) {
+    var method = '_' + mout.string.camelCase(this._command);
+
+    if (this[method]) {
+        this[method](data);
+    }
+};
+
+StandardRenderer.prototype.error = function (err) {
+    var str;
+    var stack;
+
+    this._guessOrigin(err);
+
+    err.id = err.code || 'error';
+    err.level = 'error';
+
+    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';
+        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) {
+        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');
+
+        this._write(process.stderr, str);
+        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: ' + 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) {
+    var method = '_' + mout.string.camelCase(log.id) + 'Log';
+
+    this._guessOrigin(log);
+
+    // Call render method for this log entry or the generic one
+    if (this[method]) {
+        this[method](log);
+    } else {
+        this._genericLog(log);
+    }
+};
+
+StandardRenderer.prototype.prompt = function (prompts) {
+    var deferred;
+
+    // Strip colors from the prompt if color is disabled
+    if (!this._config.color) {
+        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._help = function (data) {
+    var str;
+    var that = this;
+    var specific;
+
+    if (!data.command) {
+        str = template.render('std/help.std', data);
+        that._write(process.stdout, str);
+    } else {
+        // Check if a specific template exists for the command
+        specific = 'std/help-' + data.command.replace(/\s+/g, '/') + '.std';
+
+        if (template.exists(specific)) {
+            str = template.render(specific, data);
+        } else {
+            str =  template.render('std/help-generic.std', data);
+        }
+
+        that._write(process.stdout, str);
+    }
+};
+
+StandardRenderer.prototype._install = function (packages) {
+    var str = '';
+
+    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;
+
+        cliTree = this._tree2archy(pkg);
+        str += '\n' + archy(cliTree);
+    }, this);
+
+    if (str) {
+        this._write(process.stdout, str);
+    }
+};
+
+StandardRenderer.prototype._update = function (packages) {
+    this._install(packages);
+};
+
+StandardRenderer.prototype._list = function (tree) {
+    var cliTree;
+
+    if (tree.pkgMeta) {
+        tree.root = true;
+        cliTree = archy(this._tree2archy(tree));
+    } else {
+        cliTree = stringifyObject(tree, { indent: '  ' }).replace(/[{}]/g, '') + '\n';
+    }
+
+    this._write(process.stdout, cliTree);
+};
+
+StandardRenderer.prototype._search = function (results) {
+    var str = template.render('std/search-results.std', results);
+    this._write(process.stdout, str);
+};
+
+StandardRenderer.prototype._info = function (data) {
+    var str = '';
+    var pkgMeta = data;
+    var includeVersions = false;
+
+    // If the response is the whole package info, the package meta
+    // is under the "latest" property
+    if (typeof data === 'object' && data.versions) {
+        pkgMeta = data.latest;
+        includeVersions = true;
+    }
+
+    // Render package meta
+    if (pkgMeta != null) {
+        str += '\n' + this._highlightJson(pkgMeta) + '\n';
+    }
+
+    // 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) {
+    var str = template.render('std/lookup.std', data);
+
+    this._write(process.stdout, str);
+};
+
+StandardRenderer.prototype._link = function (data) {
+    this._sizes.id = 4;
+
+    this.log({
+        id: 'link',
+        level: 'info',
+        message: data.dst + ' > ' + data.src
+    });
+
+    // Print also a tree of the installed packages
+    if (data.installed) {
+        this._install(data.installed);
+    }
+};
+
+StandardRenderer.prototype._register = function (data) {
+    var str;
+
+    // If no data passed, it means the user aborted
+    if (!data) {
+        return;
+    }
+
+    str = '\n' + template.render('std/register.std', data);
+    this._write(process.stdout, str);
+};
+
+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);
+};
+
+// -------------------------
+
+StandardRenderer.prototype._genericLog = function (log) {
+    var stream;
+    var str;
+
+    if (log.level === 'warn') {
+        stream = process.stderr;
+    } else {
+        stream = process.stdout;
+    }
+
+    str = this._prefix(log) + ' ' + log.message + '\n';
+    this._write(stream, 'bower ' + str);
+};
+
+StandardRenderer.prototype._checkoutLog = function (log) {
+    if (this._compact) {
+        log.message = log.origin.split('#')[0] + '#' + log.message;
+    }
+
+    this._genericLog(log);
+};
+
+StandardRenderer.prototype._progressLog = function (log) {
+    if (this._compact) {
+        log.message = log.origin + ' ' + log.message;
+    }
+
+    this._genericLog(log);
+};
+
+StandardRenderer.prototype._extractLog = function (log) {
+    if (this._compact) {
+        log.message = log.origin + ' ' + log.message;
+    }
+
+    this._genericLog(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(', ');
+    });
+
+    templatePath = log.data.suitable ? 'std/conflict-resolved.std' : 'std/conflict.std';
+    str = template.render(templatePath, log.data);
+
+    this._write(process.stdout, '\n');
+    this._write(process.stdout, str);
+    this._write(process.stdout, '\n');
+};
+
+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._cachedEntryLog = function (log) {
+    if (this._compact) {
+        log.message = log.origin;
+    }
+
+    this._genericLog(log);
+};
+
+// -------------------------
+
+StandardRenderer.prototype._guessOrigin = function (log) {
+    var data = log.data;
+
+    if (!data) {
+        return;
+    }
+
+    if (data.endpoint) {
+        log.origin = data.endpoint.name || (data.registry && data.endpoint.source);
+
+        // Resort to using the resolver name for unnamed endpoints
+        if (!log.origin && data.resolver) {
+            log.origin = data.resolver.name;
+        }
+
+        if (log.origin && data.endpoint.target) {
+            log.origin += '#' + data.endpoint.target;
+        }
+    } else if (data.name) {
+        log.origin = data.name;
+
+        if (data.version) {
+            log.origin += '#' + data.version;
+        }
+    }
+};
+
+StandardRenderer.prototype._prefix = function (log) {
+    var label;
+    var length;
+    var nrSpaces;
+    var id = this.constructor._idMappings[log.id] || log.id;
+    var idColor = this._colors[log.level] || this._colors.default;
+
+    if (this._compact) {
+        // If there's not enough space for the id, adjust it
+        // for subsequent logs
+        if (id.length > this._sizes.id) {
+            this._sizes.id = id.length += this._sizes.sumup;
+        }
+
+        return idColor(mout.string.rpad(id, this._sizes.id));
+    }
+
+    // Construct the label
+    label = log.origin || '';
+    length = id.length + label.length + 1;
+    nrSpaces = this._sizes.id + this._sizes.label - length;
+
+    // Ensure at least one space between the label and the id
+    if (nrSpaces < 1) {
+        // Also adjust the label size for subsequent logs
+        this._sizes.label = label.length + this._sizes.sumup;
+        nrSpaces = this._sizes.id + this._sizes.label - length;
+    }
+
+    return chalk.green(label) + mout.string.repeat(' ', nrSpaces) + idColor(id);
+};
+
+StandardRenderer.prototype._write = function (stream, str) {
+    if (!this._config.color) {
+        str = chalk.stripColor(str);
+    }
+
+    stream.write(str);
+};
+
+StandardRenderer.prototype._highlightJson = function (json) {
+    var cardinal = require('cardinal');
+
+    return cardinal.highlight(stringifyObject(json, { indent: '  ' }), {
+        theme: {
+            String: {
+                _default: function (str) {
+                    return chalk.cyan(str);
+                }
+            },
+            Identifier: {
+                _default: function (str) {
+                    return chalk.green(str);
+                }
+            }
+        },
+        json: true
+    });
+};
+
+StandardRenderer.prototype._tree2archy = function (node) {
+    var dependencies = mout.object.values(node.dependencies);
+    var version = !node.missing ? node.pkgMeta._release || node.pkgMeta.version : null;
+    var label = node.endpoint.name + (version ? '#' + version : '');
+    var update;
+
+    if (node.root) {
+        label += ' ' + node.canonicalDir;
+    }
+
+    // State labels
+    if (node.missing) {
+        label += chalk.red(' not installed');
+        return label;
+    }
+
+    if (node.different) {
+        label += chalk.red(' different');
+    }
+
+    if (node.linked) {
+        label += chalk.magenta(' linked');
+    }
+
+    if (node.incompatible) {
+        label += chalk.yellow(' incompatible') + ' with ' + node.endpoint.target;
+    } else if (node.extraneous) {
+        label += chalk.green(' extraneous');
+    }
+
+    // New versions
+    if (node.update) {
+        update = '';
+
+        if (node.update.target && node.pkgMeta.version !== node.update.target) {
+            update += node.update.target + ' available';
+        }
+
+        if (node.update.latest !== node.update.target) {
+            update += (update ? ', ' : '');
+            update += 'latest is ' + node.update.latest;
+        }
+
+        if (update) {
+            label += ' (' + chalk.cyan(update) + ')';
+        }
+    }
+
+    if (!dependencies.length) {
+        return label;
+    }
+
+    return {
+        label: label,
+        nodes: mout.object.values(dependencies).map(this._tree2archy, this)
+    };
+};
+
+StandardRenderer._wideCommands = [
+    'install',
+    'update',
+    'link',
+    'info',
+    'home',
+    'register'
+];
+StandardRenderer._idMappings = {
+    'mutual': 'conflict',
+    'cached-entry': 'cached'
+};
+
+module.exports = StandardRenderer;

lib/renderers/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    Json: require('./JsonRenderer'),
+    Standard: require('./StandardRenderer')
+};

lib/templates/helpers/colors.js

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,22 @@
+var mout = require('mout');
+var leadLinesRegExp = /^\r?\n/;
+var multipleLinesRegExp = /\r?\n(\r?\n)+/mg;
+
+function condense(Handlebars) {
+    Handlebars.registerHelper('condense', function (context) {
+        var str = context.fn(this);
+
+        // Remove multiple lines
+        str = str.replace(multipleLinesRegExp, '$1');
+
+        // Remove leading new lines (while keeping indentation)
+        str = str.replace(leadLinesRegExp, '');
+
+        // Remove trailing whitespaces (including new lines);
+        str = mout.string.rtrim(str);
+
+        return str;
+    });
+}
+
+module.exports = condense;

lib/templates/helpers/indent.js

@@ -0,0 +1,12 @@
+var mout = require('mout');
+
+function indent(Handlebars) {
+    Handlebars.registerHelper('indent', function (context) {
+        var hash = context.hash;
+        var indentStr = mout.string.repeat(' ', parseInt(hash.level, 10));
+
+        return context.fn(this).replace(/\n/g, '\n' + indentStr);
+    });
+}
+
+module.exports = indent;

lib/templates/helpers/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+    colors: require('./colors'),
+    condense: require('./condense'),
+    indent: require('./indent'),
+    rpad: require('./rpad'),
+    sum: require('./sum')
+};

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

@@ -0,0 +1,7 @@
+function sum(Handlebars) {
+    Handlebars.registerHelper('sum', function (val1, val2) {
+        return val1 + val2;
+    });
+}
+
+module.exports = sum;

lib/templates/json/help-cache.json

@@ -0,0 +1,11 @@
+{
+    "command": "cache",
+    "usage": [
+        "cache <command> [<args>] [<options>]"
+    ],
+    "commands": {
+        "clean":           "Clean cached packages",
+        "list":            "List cached packages"
+    },
+    "options": []
+}

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

@@ -0,0 +1,16 @@
+{
+    "command": "cache clean",
+    "description": "Cleans cached packages.",
+    "usage": [
+        "cache clean [<options>]",
+        "cache clean <name> [<name> ...] [<options>]",
+        "cache clean <name>#<version> [<name>#<version> ..] [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        }
+    ]
+}

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

@@ -0,0 +1,15 @@
+{
+    "command": "cache list",
+    "description": "Lists cached packages.",
+    "usage": [
+        "cache list [<options>]",
+        "cache list <name> [<name> ...] [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        }
+    ]
+}

lib/templates/json/help-home.json

@@ -0,0 +1,16 @@
+{
+    "command": "home",
+    "description": "Opens a package homepage into your favorite browser.\n\nIf no <package> is passed, opens the homepage of the local package.",
+    "usage": [
+        "home [<options>]",
+        "home <package> [<options>]",
+        "home <package>#<version> [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        }
+    ]
+}

lib/templates/json/help-info.json

@@ -0,0 +1,16 @@
+{
+    "command": "info",
+    "description": "Displays overall information of a package or of a particular version.",
+    "usage": [
+        "info <package> [<options>]",
+        "info <package> [<property>] [<options>]",
+        "info <package>#<version> [<property>] [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        }
+    ]
+}

lib/templates/json/help-init.json

@@ -0,0 +1,14 @@
+{
+    "command": "init",
+    "description": "Creates a bower.json file based on answers to questions.",
+    "usage": [
+        "init [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        }
+    ]
+}

lib/templates/json/help-install.json

@@ -0,0 +1,45 @@
+{
+    "command": "install",
+    "description": "Installs the project dependencies or a specific set of endpoints.\nEndpoints can have multiple forms:\n- <source>\n- <source>#<target>\n- <name>=<source>#<target>\n\nWhere:\n- <source> is a package URL, physical location or registry name\n- <target> is a valid range, commit, branch, etc.\n- <name> is the name it should have locally.",
+    "usage": [
+        "install [<options>]",
+        "install <endpoint> [<endpoint> ..] [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-F",
+            "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",
+            "description": "Show this help message"
+        },
+        {
+            "shorthand":   "-p",
+            "flag":        "--production",
+            "description": "Do not install project devDependencies"
+        },
+        {
+            "shorthand":   "-S",
+            "flag":        "--save",
+            "description": "Save installed packages into the project's bower.json dependencies"
+        },
+        {
+            "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-link.json

@@ -0,0 +1,15 @@
+{
+    "command": "link",
+    "description": "The link functionality allows developers to easily test their packages.\nLinking is a two-step process.\n\nUsing 'bower link' in a project folder will create a global link.\nThen, in some other package, 'bower link <name>' will create a link in the components folder pointing to the previously created link.\n\nThis allows to easily test a package because changes will be reflected immediately.\nWhen the link is no longer necessary, simply remove it with 'bower uninstall <name>'.",
+    "usage": [
+        "link [<options>]",
+        "link <name> [<local name>] [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        }
+    ]
+}

lib/templates/json/help-list.json

@@ -0,0 +1,24 @@
+{
+    "command": "list",
+    "description": "List local packages - and possible updates.",
+    "usage": [
+        "list [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        },
+        {
+            "shorthand":   "-p",
+            "flag":        "--paths",
+            "description": "Generates a simple JSON source mapping"
+        },
+        {
+            "shorthand":   "-r",
+            "flag":        "--relative",
+            "description": "Make paths relative to the directory config property, which defaults to bower_components"
+        }
+    ]
+}

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

@@ -0,0 +1,14 @@
+{
+    "command": "lookup",
+    "description": "Look up a single package URL by name.",
+    "usage": [
+        "lookup <name> [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        }
+    ]
+}

lib/templates/json/help-prune.json

@@ -0,0 +1,14 @@
+{
+    "command": "prune",
+    "description": "Uninstalls local extraneous packages.",
+    "usage": [
+        "prune [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        }
+    ]
+}

lib/templates/json/help-register.json

@@ -0,0 +1,19 @@
+{
+    "command": "register",
+    "description": "Registers a package.",
+    "usage": [
+        "register <name> <url> [<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-search.json

@@ -0,0 +1,14 @@
+{
+    "command": "search",
+    "description": "Search for packages by name.",
+    "usage": [
+        "search <name> [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        }
+    ]
+}

lib/templates/json/help-uninstall.json

@@ -0,0 +1,29 @@
+{
+    "command": "uninstall",
+    "description": "Uninstalls a package locally from your bower_components directory",
+    "usage": [
+        "uninstall <name> [<name> ..] [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-f",
+            "flag":        "--force",
+            "description": "Continues uninstallation even after a dependency conflict"
+        },
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        },
+        {
+            "shorthand":   "-S",
+            "flag":        "--save",
+            "description": "Remove uninstalled packages from the project's bower.json dependencies"
+        },
+        {
+            "shorthand":   "-D",
+            "flag":        "--save-dev",
+            "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

@@ -0,0 +1,34 @@
+{
+    "command": "update",
+    "description": "Updates installed packages to their newest version according to bower.json.",
+    "usage": [
+        "update <name> [<name> ..] [<options>]"
+    ],
+    "options": [
+        {
+            "shorthand":   "-F",
+            "flag":        "--force-latest",
+            "description": "Force latest version on conflict"
+        },
+        {
+            "shorthand":   "-h",
+            "flag":        "--help",
+            "description": "Show this help message"
+        },
+        {
+            "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

@@ -0,0 +1,78 @@
+{
+    "usage": [
+        "<command> [<args>] [<options>]"
+    ],
+    "commands": {
+        "cache":           "Manage bower cache",
+        "help":            "Display help information about Bower",
+        "home":            "Opens a package homepage into your favorite browser",
+        "info":            "Info of a particular package",
+        "init":            "Interactively create a bower.json file",
+        "install":         "Install a package locally",
+        "link":            "Symlink a package folder",
+        "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 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": [
+        {
+            "shorthand":   "-f",
+            "flag":        "--force",
+            "description": "Makes various commands more forceful"
+        },
+        {
+            "shorthand":   "-j",
+            "flag":        "--json",
+            "description": "Output consumable JSON"
+        },
+        {
+            "shorthand":   "-l",
+            "flag":        "--loglevel",
+            "description": "What level of logs to report"
+        },
+        {
+            "shorthand":   "-o",
+            "flag":        "--offline",
+            "description": "Do not hit the network"
+        },
+        {
+            "shorthand":   "-q",
+            "flag":        "--quiet",
+            "description": "Only output important information"
+        },
+        {
+            "shorthand":   "-s",
+            "flag":        "--silent",
+            "description": "Do not output anything, besides errors"
+        },
+        {
+            "shorthand":   "-V",
+            "flag":        "--verbose",
+            "description": "Makes output more verbose"
+        },
+        {
+            "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

@@ -0,0 +1,11 @@
+{{#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 {{#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}}

lib/templates/std/help-cache.std

@@ -0,0 +1,17 @@
+
+Usage:
+
+{{#condense}}
+{{#each usage}}
+    {{#cyan}}bower{{/cyan}} {{.}}
+{{/each}}
+{{/condense}}
+
+Commands:
+
+{{#condense}}
+{{#each commands}}
+    {{#rpad minLength="23"}}{{@key}}{{/rpad}} {{.}}
+{{/each}}
+{{/condense}}
+{{#rpad minLength="23"}}{{/rpad}}

lib/templates/std/help-generic.std

@@ -0,0 +1,23 @@
+
+Usage:
+
+{{#condense}}
+{{#each usage}}
+    {{#cyan}}bower{{/cyan}} {{.}}
+{{/each}}
+{{/condense}}
+
+
+Options:
+
+{{#condense}}
+{{#each options}}
+    {{#yellow}}{{#rpad minLength="23"}}{{#if shorthand}}{{shorthand}}, {{/if}}{{flag}}{{/rpad}}{{/yellow}} {{description}}
+{{/each}}
+{{/condense}}
+
+    Additionally all global options listed in 'bower help' are available
+
+Description:
+
+    {{#indent level="4"}}{{description}}{{/indent}}

lib/templates/std/help.std

@@ -0,0 +1,26 @@
+
+Usage:
+
+{{#condense}}
+{{#each usage}}
+    {{#cyan}}bower{{/cyan}} {{.}}
+{{/each}}
+{{/condense}}
+
+Commands:
+
+{{#condense}}
+{{#each commands}}
+    {{#rpad minLength="23"}}{{@key}}{{/rpad}} {{.}}
+{{/each}}
+{{/condense}}
+
+Options:
+
+{{#condense}}
+{{#each options}}
+    {{#yellow}}{{#rpad minLength="23"}}{{#if shorthand}}{{shorthand}}, {{/if}}{{flag}}{{/rpad}}{{/yellow}} {{description}}
+{{/each}}
+{{/condense}}
+
+See 'bower help <command>' for more information on a specific command.

lib/templates/std/info.std

@@ -0,0 +1,14 @@
+{{#if versions}}{{#cyan}}Available versions:{{/cyan}}
+{{#condense}}
+{{#versions}}
+  - {{.}}
+{{/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

@@ -0,0 +1,8 @@
+{{#condense}}
+{{#if url}}
+{{#cyan}}{{name}}{{/cyan}} {{url}}
+{{else}}
+Package not found.
+{{/if}}
+{{/condense}}
+

lib/templates/std/register.std

@@ -0,0 +1,5 @@
+Package {{#cyan}}{{name}}{{/cyan}} registered successfully!
+All valid semver tags on {{#cyan}}{{url}}{{/cyan}} will be available as versions.
+To publish a new version, just release a valid semver tag.
+
+Run {{#cyan}}bower info {{name}}{{/cyan}} to list the available versions.

lib/templates/std/search-results.std

@@ -0,0 +1,10 @@
+{{#if .}}Search results:
+
+{{#condense}}
+{{#.}}
+    {{#cyan}}{{{name}}}{{/cyan}} {{{url}}}
+{{/.}}
+{{/condense}}
+
+{{else}}No results.
+{{/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/cli.js

@@ -0,0 +1,49 @@
+var mout = require('mout');
+var nopt = require('nopt');
+var renderers = require('../renderers');
+
+function readOptions(options, argv) {
+    var types;
+    var noptOptions;
+    var parsedOptions = {};
+    var shorthands = {};
+
+    if (Array.isArray(options)) {
+        argv = options;
+        options = {};
+    } else {
+        options = options || {};
+    }
+
+    types = mout.object.map(options, function (option) {
+        return option.type;
+    });
+    mout.object.forOwn(options, function (option, name) {
+        shorthands[option.shorthand] = '--' + name;
+    });
+
+    noptOptions = nopt(types, shorthands, argv);
+
+    // Filter only the specified options because nopt parses every --
+    // Also make them camel case
+    mout.object.forOwn(noptOptions, function (value, key) {
+        if (options[key]) {
+            parsedOptions[mout.string.camelCase(key)] = value;
+        }
+    });
+
+    parsedOptions.argv = noptOptions.argv;
+
+    return parsedOptions;
+}
+
+function getRenderer(command, json, config) {
+    if (config.json || json) {
+        return new renderers.Json(command, config);
+    }
+
+    return new renderers.Standard(command, config);
+}
+
+module.exports.readOptions = readOptions;
+module.exports.getRenderer = getRenderer;

lib/util/cmd.js

@@ -0,0 +1,120 @@
+var cp = require('child_process');
+var path = require('path');
+var Q = require('q');
+var mout = require('mout');
+var which = require('which');
+var PThrottler = require('p-throttler');
+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. 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;
+var isWin = process.platform === 'win32';
+
+if (isWin) {
+    winBatchExtensions = ['.bat', '.cmd'];
+    winWhichCache = {};
+}
+
+function getWindowsCommand(command) {
+    var fullCommand;
+    var extension;
+
+    // Do we got the value converted in the cache?
+    if (mout.object.hasOwn(winWhichCache, command)) {
+        return winWhichCache[command];
+    }
+
+    // Use which to retrieve the full command, which puts the extension in the end
+    try {
+        fullCommand = which.sync(command);
+    } catch (err) {
+        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] = fullCommand;
+}
+
+// Executes a shell command, buffering the stdout and stderr
+// If an error occurs, a meaningful error is generated
+// Returns a promise that gets fulfilled if the command succeeds
+// or rejected if it fails
+function executeCmd(command, args, options) {
+    var process;
+    var stderr = '';
+    var stdout = '';
+    var deferred = Q.defer();
+
+    // Windows workaround for .bat and .cmd files, see #626
+    if (isWin) {
+        command = getWindowsCommand(command);
+    }
+
+    // Buffer output, reporting progress
+    process = cp.spawn(command, args, options);
+    process.stdout.on('data', function (data) {
+        data = data.toString();
+        deferred.notify(data);
+        stdout += 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) {
+        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) {
+        var fullCommand;
+        var error;
+
+        if (code) {
+            // Generate the full command to be presented in the error message
+            if (!Array.isArray(args)) {
+                args = [];
+            }
+
+            fullCommand = command;
+            fullCommand += args.length ? ' ' + args.join(' ') : '';
+
+            // Build the error instance
+            error = createError('Failed to execute "' + fullCommand + '", exit code of #' + code + '\n' + stderr, 'ECMDERR', {
+                details: stderr,
+                exitCode: code
+            });
+
+            return deferred.reject(error);
+        }
+
+        return deferred.resolve([stdout, stderr]);
+    });
+
+    return deferred.promise;
+}
+
+function cmd(command, args, options) {
+    return throttler.enqueue(executeCmd.bind(null, command, args, options));
+}
+
+module.exports = cmd;

lib/util/copy.js

@@ -0,0 +1,114 @@
+var fstream = require('fstream');
+var fstreamIgnore = require('fstream-ignore');
+var fs = require('./fs');
+var Q = require('q');
+
+function copy(reader, writer) {
+    var deferred;
+    var ignore;
+
+    // Filter symlinks because they are not 100% portable, specially
+    // when linking between different drives
+    // Following can't be enabled either because symlinks that reference
+    // another symlinks will get filtered
+    // See: https://github.com/bower/bower/issues/699
+    reader.filter = filterSymlinks;
+    reader.follow = false;
+
+    if (reader.type === 'Directory' && reader.ignore) {
+        ignore = reader.ignore;
+        reader = fstreamIgnore(reader);
+        reader.addIgnoreRules(ignore);
+    } else {
+        reader = fstream.Reader(reader);
+    }
+
+    deferred = Q.defer();
+
+    reader
+    .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.chmod, dst, stat.mode);
+    });
+}
+
+function filterSymlinks(entry) {
+    return entry.type !== 'SymbolicLink';
+}
+
+function parseOptions(opts) {
+    opts = opts || {};
+
+    if (opts.mode != null) {
+        opts.copyMode = false;
+    } else if (opts.copyMode == null) {
+        opts.copyMode = true;
+    }
+
+    return opts;
+}
+
+// ---------------------
+
+// Available options:
+// - mode: force final mode of dst (defaults to null)
+// - copyMode: copy mode of src to dst, only if mode is not specified (defaults to true)
+function copyFile(src, dst, opts) {
+    var promise;
+
+    opts = parseOptions(opts);
+
+    promise = copy({
+        path: src,
+        type: 'File'
+    }, {
+        path: dst,
+        mode: opts.mode,
+        type: 'File'
+    });
+
+    if (opts.copyMode) {
+        promise = promise.then(copyMode.bind(copyMode, src, dst));
+    }
+
+    return promise;
+}
+
+// Available options:
+// - ignore: array of patterns to be ignored (defaults to null)
+// - mode: force final mode of dst (defaults to null)
+// - copyMode: copy mode of src to dst, only if mode is not specified (defaults to true)
+function copyDir(src, dst, opts) {
+    var promise;
+
+    opts = parseOptions(opts);
+
+    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));
+    }
+
+    return promise;
+}
+
+module.exports.copyDir = copyDir;
+module.exports.copyFile = copyFile;

lib/util/createError.js

@@ -0,0 +1,14 @@
+var mout = require('mout');
+
+function createError(msg, code, props) {
+    var err = new Error(msg);
+    err.code = code;
+
+    if (props) {
+        mout.object.mixIn(err, props);
+    }
+
+    return err;
+}
+
+module.exports = createError;

lib/util/createLink.js

@@ -0,0 +1,50 @@
+var fs = require('./fs');
+var path = require('path');
+var Q = require('q');
+var mkdirp = require('mkdirp');
+var createError = require('./createError');
+
+var isWin = process.platform === 'win32';
+
+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'
+                });
+            }
+
+            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;
+            }
+
+            // 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

@@ -0,0 +1,143 @@
+var progress = require('request-progress');
+var request = require('request');
+var Q = require('q');
+var mout = require('mout');
+var retry = require('retry');
+var createError = require('./createError');
+var createWriteStream = require('fs-write-stream-atomic');
+var destroy = require('destroy');
+
+var errorCodes = [
+    'EADDRINFO',
+    'ETIMEDOUT',
+    'ECONNRESET',
+    'ESOCKETTIMEDOUT',
+    'ENOTFOUND'
+];
+
+function download(url, file, options) {
+    var operation;
+    var deferred = Q.defer();
+    var progressDelay = 8000;
+
+    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 () {
+        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];
+
+            // 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;
+
+            // 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;

lib/util/extract.js

@@ -0,0 +1,266 @@
+var path = require('path');
+var fs = require('./fs');
+var zlib = require('zlib');
+var DecompressZip = require('decompress-zip');
+var tar = require('tar-fs');
+var Q = require('q');
+var mout = require('mout');
+var junk = require('junk');
+var createError = require('./createError');
+var createWriteStream = require('fs-write-stream-atomic');
+var destroy = require('destroy');
+var tmp = require('tmp');
+
+// This forces the default chunk size to something small in an attempt
+// to avoid issue #314
+zlib.Z_DEFAULT_CHUNK = 1024 * 8;
+
+var extractors;
+var extractorTypes;
+
+extractors = {
+    '.zip': extractZip,
+    '.tar': extractTar,
+    '.tar.gz': extractTarGz,
+    '.tgz': extractTarGz,
+    '.gz': extractGz,
+    'application/zip': extractZip,
+    'application/x-zip': extractZip,
+    'application/x-zip-compressed': extractZip,
+    'application/x-tar': extractTar,
+    'application/x-tgz': extractTarGz,
+    'application/x-gzip': extractGz
+};
+
+extractorTypes = Object.keys(extractors);
+
+function extractZip(archive, dst) {
+    var deferred = Q.defer();
+
+    new DecompressZip(archive)
+    .on('error', deferred.reject)
+    .on('extract', deferred.resolve.bind(deferred, dst))
+    .extract({
+        path: dst,
+        follow: false,           // Do not follow symlinks (#699)
+        filter: filterSymlinks   // Filter symlink files
+    });
+
+    return deferred.promise;
+}
+
+function extractTar(archive, dst) {
+    var deferred = Q.defer();
+
+    var stream = fs.createReadStream(archive);
+
+    var reject = function (error) {
+        destroy(stream);
+        deferred.reject(error);
+    };
+
+    stream.on('error', reject)
+    .pipe(tar.extract(dst, {
+        ignore: isSymlink, // Filter symlink files
+        dmode: 0555,       // Ensure dirs are readable
+        fmode: 0444        // Ensure files are readable
+    }))
+    .on('error', reject)
+    .on('finish', function (result) {
+        destroy(stream);
+        deferred.resolve(dst);
+    });
+
+    return deferred.promise;
+}
+
+function extractTarGz(archive, dst) {
+    var deferred = Q.defer();
+
+    var stream = fs.createReadStream(archive);
+
+    var reject = function (error) {
+        destroy(stream);
+        deferred.reject(error);
+    };
+
+    stream.on('error', reject)
+    .pipe(zlib.createGunzip())
+    .on('error', reject)
+    .pipe(tar.extract(dst, {
+        ignore: isSymlink, // Filter symlink files
+        dmode: 0555,       // Ensure dirs are readable
+        fmode: 0444        // Ensure files are readable
+    }))
+    .on('error', reject)
+    .on('finish', function (result) {
+        destroy(stream);
+        deferred.resolve(dst);
+    });
+
+    return deferred.promise;
+}
+
+function extractGz(archive, dst) {
+    var deferred = Q.defer();
+
+    var stream = fs.createReadStream(archive);
+
+    var reject = function (error) {
+        destroy(stream);
+        deferred.reject(error);
+    };
+    stream.on('error', reject)
+    .pipe(zlib.createGunzip())
+    .on('error', reject)
+    .pipe(createWriteStream(dst))
+    .on('error', reject)
+    .on('finish', function (result) {
+        destroy(stream);
+        deferred.resolve(dst);
+    });
+
+    return deferred.promise;
+}
+
+function isSymlink(entry) {
+    return entry.type === 'SymbolicLink';
+}
+
+function filterSymlinks(entry) {
+    return entry.type !== 'SymbolicLink';
+}
+
+function getExtractor(archive) {
+    // Make the archive lower case to match against the types
+    // This ensures that upper-cased extensions work
+    archive = archive.toLowerCase();
+
+    var type = mout.array.find(extractorTypes, function (type) {
+        return mout.string.endsWith(archive, type);
+    });
+
+    return type ? extractors[type] : null;
+}
+
+function isSingleDir(dir) {
+    return Q.nfcall(fs.readdir, dir)
+    .then(function (files) {
+        var singleDir;
+
+        // Remove any OS specific files from the files array
+        // before checking its length
+        files = files.filter(junk.isnt);
+
+        if (files.length !== 1) {
+            return false;
+        }
+
+        singleDir = path.join(dir, files[0]);
+
+        return Q.nfcall(fs.stat, singleDir)
+        .then(function (stat) {
+            return stat.isDirectory() ? singleDir : false;
+        });
+    });
+}
+
+function moveDirectory(srcDir, destDir) {
+    return Q.nfcall(fs.readdir, srcDir)
+    .then(function (files) {
+        var promises = files.map(function (file) {
+            var src = path.join(srcDir, file);
+            var dst = path.join(destDir, file);
+
+            return Q.nfcall(fs.rename, src, dst);
+        });
+
+        return Q.all(promises);
+    })
+    .then(function () {
+        return Q.nfcall(fs.rmdir, srcDir);
+    });
+}
+
+// -----------------------------
+
+function canExtract(src, mimeType) {
+    if (mimeType && mimeType !== 'application/octet-stream') {
+        return !!getExtractor(mimeType);
+    }
+
+    return !!getExtractor(src);
+}
+
+// Available options:
+// - keepArchive: true to keep the archive afterwards (defaults to false)
+// - keepStructure: true to keep the extracted structure unchanged (defaults to false)
+function extract(src, dst, opts) {
+    var extractor;
+    var promise;
+
+    opts = opts || {};
+    extractor = getExtractor(src);
+
+    // Try to get extractor from mime type
+    if (!extractor && opts.mimeType) {
+        extractor = getExtractor(opts.mimeType);
+    }
+
+    // If extractor is null, then the archive type is unknown
+    if (!extractor) {
+        return Q.reject(createError('File ' + src + ' is not a known archive', 'ENOTARCHIVE'));
+    }
+
+    // Extract to a temporary directory in case of file name clashes
+    return Q.nfcall(tmp.dir, {
+        template: dst + '-XXXXXX',
+        mode: 0777 & ~process.umask()
+    }).then(function (tempDir) {
+        // nfcall may return multiple callback arguments as an array
+        return Array.isArray(tempDir) ? tempDir[0] : tempDir;
+    }).then(function (tempDir) {
+
+        // Check archive file size
+        promise = Q.nfcall(fs.stat, src)
+        .then(function (stat) {
+            if (stat.size <= 8) {
+                throw createError('File ' + src + ' is an invalid archive', 'ENOTARCHIVE');
+            }
+
+            // Extract archive
+            return extractor(src, tempDir);
+        });
+
+        // Remove archive
+        if (!opts.keepArchive) {
+            promise = promise
+            .then(function () {
+                return Q.nfcall(fs.unlink, src);
+            });
+        }
+
+        // Move contents from the temporary directory
+        // If the contents are a single directory (and we're not preserving structure),
+        // move its contents directly instead.
+        promise = promise
+        .then(function () {
+            return isSingleDir(tempDir);
+        })
+        .then(function (singleDir) {
+            if (singleDir && !opts.keepStructure) {
+                return moveDirectory(singleDir, dst);
+            } else {
+                return moveDirectory(tempDir, dst);
+            }
+        });
+
+        // Resolve promise to the dst dir
+        return promise.then(function () {
+            return dst;
+        });
+    });
+}
+
+module.exports = extract;
+module.exports.canExtract = canExtract;