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

Also changes some messaging

diff --git a/chat/command.go b/chat/command.go
index 065021d894672462a6a783eda90b99ec61f3d5cb..a36e9d11bb84b58fdd672c761f417dac38b008f1 100644 (file)
--- a/chat/command.go
+++ b/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)
-                       if err != nil {
+                       err := msg.From().Ignored.Add(set.Itemize(id, target))
+                       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 != nil {
+                       if err := msg.From().Ignored.Remove(id); 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
                },
        })

diff --git a/chat/message/user.go b/chat/message/user.go
index 9152d5191d702ba2f4ffd0bdb6a677ed549cc072..225cd71bfbc6fac25c924508c1fc288e1b589ed7 100644 (file)
--- a/chat/message/user.go
+++ b/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

diff --git a/chat/room_test.go b/chat/room_test.go
index 9466ec7d27f33611a7e3fa466e29ebef8e6498ea..71224fd0d8475a59f61c96cc17c6911364a92065 100644 (file)
--- a/chat/room_test.go
+++ b/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)