bit of cleanup, switched some commands to use regular expressions for parsing input

client.go

 	"fmt"
 	"log"
 	"net"
+	"regexp"
 	"strings"
 	"unicode"
 )
 	case strings.HasPrefix(message, "@create "):
 		c.createCmd(strings.TrimPrefix(message, "@create "))
 	case strings.HasPrefix(message, "@dig "):
-		c.digCmd(strings.TrimPrefix(message, "@dig "))
+		c.digCmd(message)
 	case strings.HasPrefix(message, "@open "):
-		c.openCmd(strings.TrimPrefix(message, "@open "))
+		c.openCmd(message)
 	case strings.HasPrefix(message, "@name "):
-		c.nameCmd(strings.TrimPrefix(message, "@name "))
+		c.nameCmd(message)
 	case strings.HasPrefix(message, "@desc "):
-		c.descCmd(strings.TrimPrefix(message, "@desc "))
+		c.descCmd(message)
 	case strings.HasPrefix(message, "@tel "):
 		c.telCmd(strings.TrimPrefix(message, "@tel "))
 	case strings.HasPrefix(message, "@dump "):
 
 }
 
-func (c *Client) openCmd(message string) {
+func (c *Client) openCmd(input string) {
 	// @open <in1;in2;in3;etc>=#<room>,<out1;out2;out3;etc>
 
-	slicey := strings.SplitN(message, "=", 2)
+	r, _ := regexp.Compile(`^@open\pZ+([^=]*[^=\pZ]+)\pZ*=#([0-9]+)(?:\pZ*,\pZ*([^,]*[^,\pZ]+)\pZ*)?`)
+	params := r.FindStringSubmatch(input)
 
-	if len(slicey) < 2 {
-		c.write("Bad command or file name.\n")
+	if params == nil {
 		return
 	}
 
-	srcExitSpec := strings.TrimSpace(slicey[0])
+	inExit, roomIDStr, outExit := params[1], params[2], params[3]
 
-	stuff := strings.Split(slicey[1], ",")
-	if len(stuff) > 2 {
+	if len(inExit) == 0 || len(roomIDStr) == 0 {
 		c.write("Bad command or file name.\n")
 		return
 	}
 
-	makeReturnExit := false
-	var returnExitSpec string
-	if len(stuff) == 2 {
-		makeReturnExit = true
-		returnExitSpec = strings.TrimSpace(stuff[1])
-	}
-
-	target, err := NewDBRefFromHashRef(strings.TrimSpace(stuff[0]))
-	if err != nil {
-		c.write("Bad target DBRef.\n")
+	targetID, _ := NewDBRefFromString(roomIDStr) // this will never fail, the regexp guarantees that
+	targetRoom, found := c.db.Fetch(targetID)
+	if !found {
+		c.write("Target not found.\n")
 		return
 	}
 
 		return
 	}
 
-	targetRoom, found := c.db.Fetch(target)
-	if !found {
-		c.write("Target not found.\n")
-		return
-	}
-
-	toExit := c.factory.NewExit()
-	toExit.Name = srcExitSpec
-	toExit.Next = targetRoom.ID
-	toExit.Owner = c.player.ID
+	toExit := c.factory.NewExit(inExit, targetRoom.ID, c.player.ID)
 	toExit.Commit()
-
-	err = room.Contains(&toExit)
+	err := room.Contains(&toExit)
 	if err != nil {
 		return
 	}
-
 	c.write("%s Created.\n", toExit.DetailedName())
 
-	if makeReturnExit {
-		fromExit := c.factory.NewExit()
-		fromExit.Name = returnExitSpec
-		fromExit.Next = room.ID
-		fromExit.Owner = c.player.ID
+	if len(outExit) > 0 {
+		fromExit := c.factory.NewExit(outExit, room.ID, c.player.ID)
 		fromExit.Commit()
-
 		err = targetRoom.Contains(&fromExit)
 		if err != nil {
 			return
 		}
-
 		c.write("%s Created.\n", fromExit.DetailedName())
 	}
 
 }
 
-func (c *Client) digCmd(message string) {
+func (c *Client) digCmd(input string) {
 	// @dig <Room name>=<in1;in2;in3;etc>,<out1;out2;out3;etc>
-	//@dig foo=<F>oo;foo;f,<B>ack;back;b
-	slicey := strings.SplitN(message, "=", 2)
+	//@dig foo bar  = <F>oo;foo;f,<B>ack;back;b
 
-	if len(slicey) < 1 {
-		c.write("Rooms can't not have names.\n")
+	r, _ := regexp.Compile(`^@dig\pZ+([^=]*[^=\pZ]+)(\pZ*=\pZ*(?:([^,]*[^,\pZ]+)\pZ*)?(?:\pZ*,\pZ*([^,]*[^,\pZ]+)\pZ*)?)?`)
+	params := r.FindStringSubmatch(input)
+	if params == nil {
 		return
 	}
 
-	roomName := strings.TrimSpace(slicey[0])
+	roomName, inExit, outExit := params[1], params[2], params[3]
 
-	exits := make([]string, 0)
-
-	if len(slicey) == 2 {
-		exitSpec := strings.TrimSpace(slicey[1])
-		exits = strings.Split(exitSpec, ",")
-		if len(exits) > 2 {
-			c.write("You've listed more than two exits. That doesn't even make sense.\n")
-			return
-		}
+	if len(roomName) == 0 {
+		c.write("Rooms can't not have names.\n")
+		return
 	}
 
 	newRoom := c.factory.NewRoom()
 
 	c.write("%s Created.\n", newRoom.DetailedName())
 
-	if len(exits) > 0 {
+	if len(inExit) > 0 || len(outExit) > 0 {
 		roomID, found := c.db.GetParent(c.player.ID)
 		room, found := c.db.Fetch(roomID)
 		if !found {
 			return
 		}
-		toExit := c.factory.NewExit()
-		toExit.Name = exits[0]
-		toExit.Next = newRoom.ID
-		toExit.Owner = c.player.ID
-		toExit.Commit()
-
-		err := room.Contains(&toExit)
-		if err != nil {
-			return
+		if len(inExit) > 0 {
+			toExit := c.factory.NewExit(inExit, newRoom.ID, c.player.ID)
+			toExit.Commit()
+			err := room.Contains(&toExit)
+			if err != nil {
+				return
+			}
+			c.write("%s Created.\n", toExit.DetailedName())
 		}
-
-		c.write("%s Created.\n", toExit.DetailedName())
-
-		if len(exits) == 2 {
-			fromExit := c.factory.NewExit()
-			fromExit.Name = exits[1]
-			fromExit.Next = room.ID
-			fromExit.Owner = c.player.ID
+		if len(outExit) > 0 {
+			fromExit := c.factory.NewExit(outExit, room.ID, c.player.ID)
 			fromExit.Commit()
-
-			err = newRoom.Contains(&fromExit)
+			err := newRoom.Contains(&fromExit)
 			if err != nil {
 				return
 			}
-
 			c.write("%s Created.\n", fromExit.DetailedName())
-
 		}
 	}
 
 }
 
-func (c *Client) nameCmd(message string) {
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	if !found {
+func (c *Client) nameCmd(input string) {
+
+	r, _ := regexp.Compile(`^@name\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(.*)\pZ*$`)
+	params := r.FindStringSubmatch(input)
+	if params == nil {
 		return
 	}
 
-	slicey := strings.SplitN(message, "=", 2)
+	objectName, name := params[1], params[2]
 
-	if len(slicey) == 1 {
-		c.write("Things can't not have names.\n")
+	roomID, found := c.db.GetParent(c.player.ID)
+	room, found := c.db.Fetch(roomID)
+	if !found {
 		return
 	}
 
-	objectName := strings.TrimSpace(slicey[0])
-	name := strings.TrimSpace(slicey[1])
-
 	candidate, matchType := room.MatchLinkNames(objectName, c.player.ID, false).ExactlyOne()
 	switch matchType {
 	case MatchOne:
 	}
 
 }
-func (c *Client) descCmd(message string) {
 
-	roomID, found := c.db.GetParent(c.player.ID)
-	room, found := c.db.Fetch(roomID)
-	if !found {
+func (c *Client) descCmd(input string) {
+
+	r, _ := regexp.Compile(`^@desc\pZ+([^=]*[^=\pZ]{1})\pZ*=\pZ*(.*)\pZ*$`)
+	params := r.FindStringSubmatch(input)
+	if params == nil {
 		return
 	}
 
-	slicey := strings.SplitN(message, "=", 2)
+	objectName, description := params[1], params[2]
+
+	roomID, found := c.db.GetParent(c.player.ID)
+	room, found := c.db.Fetch(roomID)
 
-	objectName := strings.TrimSpace(slicey[0])
-	description := ""
-	if len(slicey) > 1 {
-		description = strings.TrimSpace(slicey[1])
+	if !found {
+		return
 	}
 
 	var editObject *Object

object.go

 	return o
 }
 
-func (f *ObjectFactory) NewExit() Object {
-	o := Object{}
+func (f *ObjectFactory) NewExit(name string, next DBRef, owner DBRef) Object {
+	o := Object{
+		Type:  "exit",
+		Name:  name,
+		Next:  next,
+		Owner: owner,
+		db:    f.db,
+	}
 	o.ID, _ = f.db.Allocate()
-	o.Type = "exit"
-	o.db = f.db
 	return o
 }