chat/message: Remove User.Ignore(...) and User.Unignore(...)

Also changes some messaging

chat/command.go

@@ -249,6 +249,7 @@ func InitCommands(c *Commands) {
 		Handler: func(room *Room, msg message.CommandMsg) error {
 			id := strings.TrimSpace(strings.TrimLeft(msg.Body(), "/ignore"))
 			if id == "" {
+				// Print ignored names, if any.
 				var names []string
 				msg.From().Ignored.Each(func(_ string, item set.Item) error {
 					names = append(names, item.Key())
@@ -266,17 +267,22 @@ func InitCommands(c *Commands) {
 				return nil
 			}
 
+			if id == msg.From().ID() {
+				return errors.New("cannot ignore self")
+			}
 			target, ok := room.MemberByID(id)
 			if !ok {
-				return fmt.Errorf("user %s not found.", id)
+				return fmt.Errorf("user not found: %s", id)
 			}
 
-			err := msg.From().Ignore(target)
+			err := msg.From().Ignored.Add(set.Itemize(id, target))
-			if err != nil {
+			if err == set.ErrCollision {
+				return fmt.Errorf("user already ignored: %s", id)
+			} else if err != nil {
 				return err
 			}
 
-			room.Send(message.NewSystemMsg(fmt.Sprintf("%s is now being ignored.", target.Name()), msg.From()))
+			room.Send(message.NewSystemMsg(fmt.Sprintf("Ignoring: %s", target.Name()), msg.From()))
 			return nil
 		},
 	})
@@ -290,12 +296,11 @@ func InitCommands(c *Commands) {
 				return errors.New("must specify user")
 			}
 
-			err := msg.From().Unignore(id)
+			if err := msg.From().Ignored.Remove(id); err != nil {
-			if err != nil {
 				return err
 			}
 
-			room.Send(message.NewSystemMsg(fmt.Sprintf("%s is not ignored anymore.", id), msg.From()))
+			room.Send(message.NewSystemMsg(fmt.Sprintf("No longer ignoring: %s", id), msg.From()))
 			return nil
 		},
 	})

chat/message/user.go

@@ -21,11 +21,11 @@ var ErrUserClosed = errors.New("user closed")
 // User definition, implemented set Item interface and io.Writer
 type User struct {
 	Identifier
+	Ignored  *set.Set
 	colorIdx int
 	joined   time.Time
 	msg      chan Message
 	done     chan struct{}
-	Ignored  *set.Set
 
 	screen    io.WriteCloser
 	closeOnce sync.Once
@@ -178,9 +178,9 @@ func (u *User) HandleMsg(m Message) error {
 // Add message to consume by user
 func (u *User) Send(m Message) error {
 	select {
-	case u.msg <- m:
 	case <-u.done:
 		return ErrUserClosed
+	case u.msg <- m:
 	case <-time.After(messageTimeout):
 		logger.Printf("Message buffer full, closing: %s", u.Name())
 		u.Close()
@@ -189,31 +189,6 @@ func (u *User) Send(m Message) error {
 	return nil
 }
 
-func (u *User) Ignore(other Identifier) error {
-	if other == nil {
-		return errors.New("user is nil.")
-	}
-
-	if other.ID() == u.ID() {
-		return errors.New("cannot ignore self.")
-	}
-
-	if u.Ignored.In(other.ID()) {
-		return errors.New("user already ignored.")
-	}
-
-	u.Ignored.Add(set.Itemize(other.ID(), other))
-	return nil
-}
-
-func (u *User) Unignore(id string) error {
-	if id == "" {
-		return errors.New("user is nil.")
-	}
-
-	return u.Ignored.Remove(id)
-}
-
 // Container for per-user configurations.
 type UserConfig struct {
 	Highlight *regexp.Regexp

chat/room_test.go

@@ -87,19 +87,19 @@ func TestIgnore(t *testing.T) {
 	if err := sendCommand("/ignore test", ignorer, ch, &buffer); err != nil {
 		t.Fatal(err)
 	}
-	expectOutput(t, buffer, "-> Err: user test not found."+message.Newline)
+	expectOutput(t, buffer, "-> Err: user not found: test"+message.Newline)
 
 	// test ignoring existing user
 	if err := sendCommand("/ignore "+ignored.user.Name(), ignorer, ch, &buffer); err != nil {
 		t.Fatal(err)
 	}
-	expectOutput(t, buffer, "-> "+ignored.user.Name()+" is now being ignored."+message.Newline)
+	expectOutput(t, buffer, "-> Ignoring: "+ignored.user.Name()+message.Newline)
 
 	// ignoring the same user twice returns an error message and doesn't add the user twice
 	if err := sendCommand("/ignore "+ignored.user.Name(), ignorer, ch, &buffer); err != nil {
 		t.Fatal(err)
 	}
-	expectOutput(t, buffer, "-> Err: user already ignored."+message.Newline)
+	expectOutput(t, buffer, "-> Err: user already ignored: user1"+message.Newline)
 	if ignoredList := ignorer.user.Ignored.ListPrefix(""); len(ignoredList) != 1 {
 		t.Fatalf("should have %d ignored users, has %d", 1, len(ignoredList))
 	}
@@ -125,7 +125,7 @@ func TestIgnore(t *testing.T) {
 	if err := sendCommand("/unignore "+ignored.user.Name(), users[0], ch, &buffer); err != nil {
 		t.Fatal(err)
 	}
-	expectOutput(t, buffer, "-> "+ignored.user.Name()+" is not ignored anymore."+message.Newline)
+	expectOutput(t, buffer, "-> No longer ignoring: user1"+message.Newline)
 
 	if err := sendCommand("/ignore", users[0], ch, &buffer); err != nil {
 		t.Fatal(err)