anchor.diff:  
   * https://github.com/openshift/origin/tree/master/pkg/cmd[pkg/cmd]
   ** https://github.com/openshift/origin/tree/master/pkg/cmd/openshift[pkg/cmd/openshift] - `openshift` or `origin` command.
  -** https://github.com/openshift/origin/tree/master/pkg/cmd/admin[pkg/cmd/admin] - `oc adm` or `oadm` or `openshift admin` command.
   ** https://github.com/openshift/origin/tree/master/pkg/cmd/infra[pkg/cmd/infra]
   *** https://github.com/openshift/origin/tree/master/pkg/cmd/infra/builder[pkg/cmd/infra/builder] - `openshift-sti-build` and `openshift-docker-build` commands.
   *** https://github.com/openshift/origin/tree/master/pkg/cmd/infra/deployer[pkg/cmd/infra/deployer] - `openshift-deploy` command.
  
positive.code: *** https://github.com/openshift/origin/tree/master/pkg/cmd/infra/router[pkg/cmd/infra/router] - `openshift-router` command.
  
  * https://github.com/openshift/origin/tree/master/pkg/oc[pkg/oc]
  ** https://github.com/openshift/origin/tree/master/pkg/oc/cli[pkg/cmd/cli] - `oc` or `openshift cli`, and `kubectl` commands.
  ** https://github.com/openshift/origin/tree/master/pkg/oc/experimental[pkg/cmd/experimental] - `oc ex` command.
  
  === Command Structure
  
  For every command we have a `NewCmd<CommandName>` function that creates the command and returns a pointer to a `cobra.Command`, which can later be added to other parent commands to compose the structure tree.
  
  We usually have a struct with a variable to every flag and argument declared by the command (and any other variable required for the command to run). This makes tests and mocking easier. The struct exposes three functions:
  
  * `Complete`: Completes the struct variables with values that may not be directly provided, for example, by flags pointers. Here you will usually take the `args` slice and set the values as appropriate variables, instantiate configs or clients, etc.
  * `Validate`: performs validation and returns errors.
  * `Run<CommandName>`: runs the actual command, taking as assumption that the struct is complete with all required values to run, and they are valid.
  
  Sample command skeleton:
  
  
negative.code:     %[1]s second --latest`)
  )
  
  func NewMineOptions(streams genericclioptions.IOStreams) *MineOptions {
    return &MineOptions{
      PrintFlags: genericclioptions.NewPrintFlags("this message is printed on command success").WithTypeSetter(scheme.Scheme), // here we instantiate our PrintFlags		
  
      mineLatest: true, // perform flag defaulting here
      IOStreams: streams,
    }
  }
  
  // NewCmdMine implement the OpenShift cli mine command.
  func NewCmdMine(name, fullName string, f *clientcmd.Factory, streams genericclioptions.IOStreams) *cobra.Command {
    o := NewMineOptions(streams)
    cmd := &cobra.Command{
      Use:     fmt.Sprintf("%s [--latest]", name),
      Short:   "Run my command",
      Long:    mineLong,
      Example: fmt.Sprintf(mineExample, fullName),
      Run: func(cmd *cobra.Command, args []string) {
        kcmdutil.CheckErr(o.Complete(f, cmd, args))
        kcmdutil.CheckErr(o.Validate())
        kcmdutil.CheckErr(o.Run())
      },
    }
  
    // always use <Type>Var cobra methods, as they allow us to bind flag values
    // directly to struct fields by passing their address as the first parameter.
    cmd.Flags().BoolVar(&o.mineLatest, "latest", o.mineLatest, "Use latest stuff")
  
    // make sure to bind any printing flags if the command makes use of the printing stack
    o.PrintFlags.AddFlags(cmd)
    return cmd
  }
  
  // Complete completes all the required options for mine.
  func (o *MineOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string) error { 
    // obtain a printer from our PrintFlags
    var err error
    o.Printer, err = o.PrintFlags.ToPrinter()
    return err
  }
  
  // Validate validates all the required options for mine.
  func (o *MineOptions) Validate() error {
    return nil
  }
  
  // Run implements all the necessary functionality for mine.
  func (o *MineOptions) Run() error {
    return nil
  }
  ----
  ====
  
  === Writing Usage
  
  When writing a usage string, make sure you cover the most important path for the given command. Use the following conventions:
  
  * Arguments and flag values names in upper case, e.g. `RESOURCE`, `-n NAME`.
  * Optional arguments or flags between brackets, e.g. `[RESOURCE]`, `[-f FILENAME]`.
  