Add a composed base class for commands.

cmd/juju/addrelation.go

 package main
 
 import (
         "fmt"
-        "launchpad.net/gnuflag"
         "launchpad.net/juju-core/cmd"
         "launchpad.net/juju-core/juju"
 )
 
 // AddRelationCommand adds relations between service endpoints.
 type AddRelationCommand struct {
-        EnvName   string

[dimitern, 2013/02/28 09:10:55]

Why?

+        EnvCommandBase
         Endpoints []string
 }
 
 func (c *AddRelationCommand) Info() *cmd.Info {
         return &cmd.Info{
                 Name:    "add-relation",
                 Args:    "<service1>[:<relation name1>] <service2>[:<relation name2>]",
                 Purpose: "add a relation between two services",
         }
 }
 
-func (c *AddRelationCommand) SetFlags(f *gnuflag.FlagSet) {

[dimitern, 2013/02/28 09:10:55]

Why is this removed? And the EnvName up there?

[rog, 2013/02/28 12:31:57]

i see why it's removed (EnvCommandBase.SetFlags adds the relevant environ
flags), but i'm not sure whether this change is a net improvement overall.

i think i prefer that it's obvious what flags a given command implements even at
the expense of some repetition of (trivial) code. as things are, i can look at
the implementation of any command and see at a glance what flags and arguments
it takes. this change makes those flags and arguments one or two levels of
indirection away, and implicit.

if the code being factored out was in any way complex, i'd see more
justification for the change, but AFAICS it makes the code harder to read and
not significantly easier to maintain.

-        addEnvironFlags(&c.EnvName, f)
-}
-
 func (c *AddRelationCommand) Init(args []string) error {
         if len(args) != 2 {
                 return fmt.Errorf("a relation must involve two services")
         }
         c.Endpoints = args
         return nil
 }
 
 func (c *AddRelationCommand) Run(_ *cmd.Context) error {
         conn, err := juju.NewConnFromName(c.EnvName)
         if err != nil {
                 return err
         }
         defer conn.Close()
         eps, err := conn.State.InferEndpoints(c.Endpoints)
         if err != nil {
                 return err
         }
         _, err = conn.State.AddRelation(eps...)
         return err
 }