This change enables the user to diff between two environments that are
either local or remote.

i.e.,

`kubecfg diff local:dev local:prod` will diff between the expanded
templates for each environment on disk.

`kubecfg diff remote:dev remote:prod` will diff between two remote
environment clusters. It does this by first expanding the component
templates of each environment. Then, the live objects are fetched from
each of the clusters and the diff is performed against the live objects.

`kubecfg diff local:dev remote:prod` is also an option. This will diff
between the expanded templates for 'dev' on disk and the live objects
on 'prod's server.

`ks env set foo --namespace=""` and `ks env add foo` will both set the
namespace to 'default' in the environment's spec.json file.

`ks env add myenv --context=dev` will initialize the environment URI
and namespace based on the context `dev`, as specfied in the
kubeconfig file. The same applies for `ks init foo --context=dev`.

If both the context and uri argument is not provided, the current
context is used.

This change will also remove uri as a mandatory arg in `ks env add`.
The uri will be moved to a flag. It cannot be used at the same time as
`context`.

Environments currently have the concept of a server URI, but it is
ambiguous which cluster namespace to use.

This commit will introduce the concept of namespaces to the env
commands.

For example,
`kubecfg env add staging http://mock-staging-uri \
 --namespace=staging-namespace`
`kubecfg env set staging --namespace=staging-namespace`

The default environment will use the namespace of the default context.

This commit will also update commands that take the <env> arg such as
`apply` to make use of the env namespace, if specified.

Commands that take `env` as a param currently expand all files in the
`components` directory. This is no longer necessary with the
introduction of `base.libsonnet` and the per-environment override
`<env>.jsonnet` file.

This commit will simply expand the single `<env>.jsonnet` file (which
will implicitly expand all component files). The case of running
`ksonnet apply default`, is equivalent to running `ksonnet apply -f
environments/default/default.jsonnet`.

base.libsonnet is a generated file that exists at the root of the
environments directory. This file is generated for all ksonnet projects.
The main goal of this file is to import all components in the components
directory, so that environments are able to easily extend / override any
one of these components in a modular structure.

The `clientConfig` param currently being passed is not needed, because
it exists as a package level var in root. It also makes little sense to
pass a custom `clientConfig` because if `overrides.Context.Namespace` is
populated, the namespace that is returned is configured as an override
in the package level `clientConfig` and not the `clientConfig` in the
param.

In order to support environment heirarchy, we need to be able to
reference all components. This commit will implement component imports
as k-v pairs ex: foo: "import/foo.jsonnet" as a Jsonnet object. This
jsonnet object will then be assigned as an ExtCode so that it can be
referenced by a base.libsonnet file which environments can build /
override upon.

Fixes #108.

Currently if we use a command like `apply default -f
components/whatever.yaml`, kubecfg will fail to emit flags that add
ksonnet-lib to the -J paths. This means that, while a command like
`apply default` will correctly linke against (e.g.) `k.libsonnet`,
adding the `-f` flag will not.

This commit will correct this problem for all commands of this form.

For example, 'apply <env' currently operates as a no-op. With the
introduction of simple environments in PR #131, 'apply <env>' should
perform basic validation such that:

1. The user has added the environment that is being deployed against to
their Ksonnet project.

2. The URI in the environment's spec file that the user wishes to deploy
to should correspond to at least one cluster location as listed in
kubeconfig.

If either of those conditions are not satisfied, the kubecfg user will
receive the corresponding error.

In addition, this commit will set the kubectl --cluster flag to point at
the cluster listed by the environment URI.

Currently, commands take either an <env> or a '-f' argument but not
both. With this commit, we are allowing both args to be provided. The
behavior is expand the files passed by the '-f' flag and deploy the
objects to <env>.

Currently 'Info' level logs are only shown with the '-v' flag. This
makes commands without the '-v' flag of little use to users, especially
on success cases, due to no output.

This commit will set the default log level to 'Info', and passing a '-v'
flag will log at a 'Debug' level.

'env set <name>' sets environment fields such as the name, and cluster
URI. It currently accepts the flags '--name' and '--uri'. Changing the
name of an environment will also update the directory structure in
'environments'.

This commit will remove the vendor/lib and vendor/schema directories
generated by 'init'. An 'environments' directory will be created from
the root app directory, with the default environment directory 'dev'
and it's containing contents rooted at 'environments'.

The intention of environments are to represent the deployment
environments of Kubernete clusters, with the following example
directory structure:

app-name/
  ..
  envs/
    dev/
    us-west/
      prod/
      staging/

This commit is a follow-up to the discussion in the ksonnet.next design
doc, in which users consistently expressed their preference that the
`update` command be called `apply`.

NOTE: We have renamed `pkg/kubecfg/update_test.go` ->
`pkg/kubecfg/apply_test.go`, but we copy the `update`'s integration test
file. The reason is that the `update` unit tests actually test things
like GC (rather than the command itself), so the file name is
inconsequential. On the other hand, the integration tests test the
commands themselves, so it is important to have two copies, one for
`update` and one for `apply`.

Currently, if the user wants to deploy a ksonnet application, and that
application uses some vendored library, or something in the `lib/`
directory, they will have to pass the appropriate `-J` flags into the
command themselves.

This commit will automatically add these whenever we're in an app
directory and a command is issued. In particular, even if the user
passes in the `-f` flag (rather than an environment name), we'll still
add library paths to the command if we're in a ksonnet app directory.
This is meant to capture the case that a user wants to update one
resource in particular in a ksonnet application.

If the current kubeconfig context is declared with an
explicit (non-empty) namespace, then `mergedKubeConfig.Namespace()`
returns that *config file* namespace value, ignoring an explicit
`--namespace` command line flag.

See https://github.com/kubernetes/client-go/issues/288 for upstream
client-go bug/discussion.

This change works around the issue by just checking the Namespace
override ourselves before falling through to the regular function.

Further fixes #103

This reverts commit 020d5da0.

The change broke --namespace (and other flag) handling, because it
recreates the `clientConfig` global singleton multiple times - only
some of which are correctly tied to the relevant flags.

This commit will separate the application level logic for the 'show', 'delete',
'validate', and 'diff' commands from the Cobra logic in the cmd/ package.  The
application level logic will be placed in pkg/kubecfg/.

The ksonnet.next design doc specifies the core kubecfg verbs (i.e., the
ones listed above) to all have the form:

  kubecfg <verb> [<env-name>|-f <file-or-dir>]

That is to say, each of these should be able to take either an
environment name, or a `-f` flag with a list of files and directories to
apply `verb` on. In the case of the environment, we will apply `verb` to
every component in the `components/` directory.

This commit implements this behavior for all these verbs.

This commit will introduce the `template.Expander` abstraction, which is
meant to abstract over an invocation of the Jsonnet VM. Specifically, it
provides facilities for users to provide (e.g.) Jpaths, ext vars, and so
on.

The main justification for this change is:

* We need a common way for the `pkg` and `cmd` packages to interact with
  the Jsonnet VM.
* The `utils` package is already too much of a catch-all.
* It's easier to think about an invocation of the Jsonnet VM when we
  additionally encapsulate the parameters we pass to it on every
  invocation in kubecfg.

Fixes #15

Improve interactive output experience by switching to a logging
library (logrus) that allows customising the output format.

This also removes the glog command line flags.  Replaced with a
simpler `--verbose`/`-v` option:
- quiet by default (warnings and errors only)
- `-v` for progress info
- `-vv` for debug

Fixes #34

Fixes #35

For consistency with other options (hyphenated, not camel case), and
the upstream `jsonnet` tool.

Add a new native function that resolves docker image names into more
specific forms.  In particular, it can look up a docker registry and
convert image:tag to image@digest at jsonnet-eval time.

Limitations: Does not currently support private docker
registries (that require authentication).

Controlled via two new command line flags:
- `--resolve-images` Change implementation of resolveImage native
  function. One of: noop, registry (default "noop")
- `--resolve-images-error` Action when resolveImage fails. One of
  ignore,warn,error (default "warn")

Note in particular that the defaults will *not* do remote registry
lookups, and will only add an explicit ":latest" tag where no tag was
given.

Fixes #13