Add Show to ProcessBuilder

More work on porting errors

Get nested dependencies working

Support any bytes container

Start migrating to new CargoResult

Get compile test passing

Cleanup ProcessBuilder

Track Rust master changes

More up to date

Update Hamcrest

Have cargo-compile automatically find the root

TODO: Deal with Paths vs. Strings (which come from serialized forms like
flags and manifests)

Get cargo-read-manifest working again

Clean up cargo-compile

Merge pull request #7 from Aeyk/patch-1

Update README.md

Clean up error messages from config

Test unit tests passing again

Source list returns summaries

Comment cleanup

Core struct refactor

Add some convenience methods

Break apart internal and CLI errors

The Cargo library now uses internal errors to represent problems, and
the operations convert those errors into CLIErrors, which contain a
user-friendly error message, additional information for verbose mode,
and an exit code.

Cleanup ProcessBuilder, work towards getting tests passing

Fix a bunch of warnings

Start breaking up cargo-compile

Bring up to date with Rust master

cargo-compile delegates to cargo-rustc

Let the resolver return a PackageSet

Merge branch 'master' of https://github.com/carlhuda/cargo

Compiling with deps progress

Use the resolver to collect packages

Progress towards compiling with dependencies

Move package mapping to Source

Map config paths onto Packages

TODO: Move this logic into PathSource

Topological sort of packages

API for SerializedManifest->Manifest and other org

Also fleshed out the Package struct.

Setting up to convert a vec of project paths into a vec of Packages to
pass to cargo-rustc.

Bump rust-toml

Cleanup + topological sort

Cleanup

Fleshed out Package a bit more

Clean up config and support array inheritance

Add vimrc settings

Add Show for PackagePath

Everything's compiling again

Bump submodules

Start pulling out the configured paths

Restructure and progress towards simple compile

For now, we're going to use the operations as a library. We have some
work to do before they can transparently be used as commands, but we're
keeping an eye on making sure they remain conceptually usable over the
shell.

WIP

Update README.md

Removed comment about make install as no install directive, added --recursive tag

Add a resolving test

Add transitive dependencies to the resolver

Whitespace

Beginnings of a dependency resolver

Track Rust master

Update README.md

Start extracting core types

Track rust master

Now can get all configs

Add support for reading config

Implement process hamcrest matcher

Update tests against Rust master

Up to date with master

Encoding and decoding now in libcargo

Commands can now call a simple function (execute_main) with some type
params, and get flags and stdin converted into their expected structs
automatically. Commands that return a json-serializable struct will also
get that struct automatically serialized into the output.

Additionally, error handling is now handled in a central location. If a
command returns a CargoError, its message will be printed (soon in
color!) and its exit code will be used to exit the process.

Cleanup integration test

Merge branch 'integration-tests'

Conflicts:
Makefile
src/bin/cargo-read-manifest.rs
src/bin/cargo-rustc.rs
src/cargo/mod.rs
src/cargo/util/process_builder.rs
tests/test_cargo_compile.rs

Lots of cleanup and more generic commands

Started to extract some of the generic behavior across all commands into
`execute_main` so that the commands themselves just need to operate
against structs (for JSON in and Flags)

Clean up dynamic option checks

Initial stab at integration tests

At the same time, we started adding a generic error handling concept to
Cargo.

The idea is that every Result gets converted to a CargoError, which
includes all the information that Cargo needs to print out a friendly
human error message and exit gracefully.

Move test build into target

Integration tests working

Next up: cleanup

A passing test

Make everything pub for Alex

Bugs?

Help me Alexwan Kenobi

Trying to shell out

Initial stab at integration tests

At the same time, we started adding a generic error handling concept to
Cargo.

The idea is that every Result gets converted to a CargoError, which
includes all the information that Cargo needs to print out a friendly
human error message and exit gracefully.

Add cargo-compile command

Proxy output w/ color to tty

Move design docs to DESIGN

Switch to 4-space tabs

Fix warnings

Vendor hamcrest-rust

Use cargo conventions for cargo itself

Add missing files

Bump hammer

cargo-read-manifest | cargo-rustc is working

At the moment, only the bare bones command is working with some defaults
hardcoded. Also, there is a bunch of necessary cleanup and no tests.

However, this marks the first end-to-end functionality in Cargo!

Bump hammer

Share manifest structs

`executable`->`bin` and initial impl

Move design documents

Bump hammer

Initial cargo-read-manifest

Bump dep

Stub out cargo-read-manifest

Update deps and Makefile

Import toml

Import Toml

Add sketch of cargo-verify-project

Initial README with some commands sketched out

Initial commit