← Back to branch summary

~jseutter/mup/count-branches-in-review

« back to all changes in this revision

Viewing changes to src/mup_message.erl

  • Committer: Gustavo Niemeyer
  • Date: 2008-10-14 01:15:45 UTC
  • Revision ID: gustavo@niemeyer.net-20081014011545-oc5wnwf5bi6yc4nn
- Moved mup_server:answer() to the new mup_message module.
- Implemented mup_message:match_channels() to support a flexible
  common channels specification among all plugins.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mup_message.erl
 
1
-module(mup_message).
 
2
-include("mup.hrl").
 
3
-include_lib("eunit/include/eunit.hrl").
 
4
-export([match_channels/2, answer/2, answer/3]).
 
5
 
 
6
 
 
7
match_channels(_Message, any) ->
 
8
    true;
 
9
match_channels(_Message, [any|_]) ->
 
10
    true;
 
11
match_channels(#message{for_mup=true, target=Target,
 
12
                        server=#server{name=ServerName}},
 
13
               [{ServerName, Target}|_ChannelsSpec]) ->
 
14
    true;
 
15
match_channels(#message{for_mup=true, mup_nick=MupNick, target=MupNick},
 
16
               [private|_ChannelsSpec])
 
17
        when MupNick =/= undefined ->
 
18
    true;
 
19
match_channels(#message{for_mup=true, mup_nick=MupNick, target=MupNick,
 
20
                       server=#server{name=ServerName}},
 
21
               [{ServerName, private}|_ChannelsSpec])
 
22
        when MupNick =/= undefined ->
 
23
    true;
 
24
match_channels(#message{for_mup=true, server=#server{name=ServerName}},
 
25
               [{ServerName, any}|_ChannelsSpec]) ->
 
26
    true;
 
27
match_channels(Message, [{ServerName, [Item|Items]}|ChannelsSpec]) ->
 
28
    match_channels(Message, [{ServerName, Item}])
 
29
    orelse
 
30
    match_channels(Message, [{ServerName, Items}|ChannelsSpec]);
 
31
match_channels(Message, [_ChannelSpec|ChannelsSpec]) ->
 
32
    match_channels(Message, ChannelsSpec);
 
33
match_channels(_Message, _ChannelsSpec) ->
 
34
    false.
 
35
 
 
36
 
 
37
match_channels_test_() ->
 
38
    [?_assertEqual(true,
 
39
                   match_channels(#message{}, any)),
 
40
     ?_assertEqual(true,
 
41
                   match_channels(#message{}, [one, any, two])),
 
42
     ?_assertEqual(false,
 
43
                   match_channels(#message{server=#server{name=freenode},
 
44
                                           for_mup=false, target="#channel"},
 
45
                                  [{freenode, "#channel"}])),
 
46
     ?_assertEqual(false,
 
47
                   match_channels(#message{server=#server{name=freenode},
 
48
                                           for_mup=true, target="#channel"},
 
49
                                  [{otherserver, "#channel"}])),
 
50
     ?_assertEqual(false,
 
51
                   match_channels(#message{server=#server{name=freenode},
 
52
                                           for_mup=true, target="#channel"},
 
53
                                  [{freenode, "#otherchannel"}])),
 
54
     ?_assertEqual(true,
 
55
                   match_channels(#message{server=#server{name=freenode},
 
56
                                           for_mup=true, target="#channel"},
 
57
                                  [{freenode, "#channel"}])),
 
58
     ?_assertEqual(true,
 
59
                   match_channels(#message{server=#server{name=freenode},
 
60
                                           for_mup=true, target="#channel"},
 
61
                                  [{foo, "#bar"}, {freenode, "#channel"}])),
 
62
     ?_assertEqual(false,
 
63
                   match_channels(#message{server=#server{name=freenode},
 
64
                                           for_mup=false, target="#channel"},
 
65
                                  [{foo, "#bar"}, {freenode, any}])),
 
66
     ?_assertEqual(false,
 
67
                   match_channels(#message{server=#server{name=freenode},
 
68
                                           for_mup=true, target="#channel"},
 
69
                                  [{foo, "#bar"}, {otherserver, any}])),
 
70
     ?_assertEqual(true,
 
71
                   match_channels(#message{server=#server{name=freenode},
 
72
                                           for_mup=true, target="#channel"},
 
73
                                  [{foo, "#bar"}, {freenode, any}])),
 
74
     ?_assertEqual(false,
 
75
                   match_channels(#message{server=#server{name=freenode},
 
76
                                           for_mup=true, target="mupnick",
 
77
                                           mup_nick="differentnick"},
 
78
                                  [{foo, "#bar"}, private])),
 
79
     ?_assertEqual(false,
 
80
                   match_channels(#message{server=#server{name=freenode},
 
81
                                           for_mup=true},
 
82
                                  [{foo, "#bar"}, private])),
 
83
     ?_assertEqual(false,
 
84
                   match_channels(#message{server=#server{name=freenode},
 
85
                                           for_mup=false, target="mupnick",
 
86
                                           mup_nick="mupnick"},
 
87
                                  [{foo, "#bar"}, private])),
 
88
     ?_assertEqual(true,
 
89
                   match_channels(#message{server=#server{name=freenode},
 
90
                                           for_mup=true, target="mupnick",
 
91
                                           mup_nick="mupnick"},
 
92
                                  [{foo, "#bar"}, private])),
 
93
     ?_assertEqual(false,
 
94
                   match_channels(#message{server=#server{name=freenode},
 
95
                                           for_mup=true, target="mupnick",
 
96
                                           mup_nick="mupnick"},
 
97
                                  [{foo, "#bar"}, {diffserver, private}])),
 
98
     ?_assertEqual(false,
 
99
                   match_channels(#message{server=#server{name=freenode},
 
100
                                           for_mup=true},
 
101
                                  [{foo, "#bar"}, {freenode, private}])),
 
102
     ?_assertEqual(false,
 
103
                   match_channels(#message{server=#server{name=freenode},
 
104
                                           for_mup=false, target="mupnick",
 
105
                                           mup_nick="mupnick"},
 
106
                                  [{foo, "#bar"}, {freenode, private}])),
 
107
     ?_assertEqual(true,
 
108
                   match_channels(#message{server=#server{name=freenode},
 
109
                                           for_mup=true, target="mupnick",
 
110
                                           mup_nick="mupnick"},
 
111
                                  [{foo, "#bar"}, {freenode, private}])),
 
112
     ?_assertEqual(false,
 
113
                   match_channels(#message{server=#server{name=freenode},
 
114
                                           for_mup=true, target="mupnick",
 
115
                                           mup_nick="mupnick"},
 
116
                                  [foo, {freenode, [bar, "#otherchannel"]}])),
 
117
     ?_assertEqual(true,
 
118
                   match_channels(#message{server=#server{name=freenode},
 
119
                                           for_mup=true, target="mupnick",
 
120
                                           mup_nick="mupnick"},
 
121
                                  [foo, {freenode, [bar, private]}])),
 
122
     ?_assertEqual(false,
 
123
                   match_channels(#message{server=#server{name=freenode},
 
124
                                           for_mup=true, target="#channel"},
 
125
                                  [foo, {freenode, [bar, "#otherchannel"]}])),
 
126
     ?_assertEqual(true,
 
127
                   match_channels(#message{server=#server{name=freenode},
 
128
                                           for_mup=true, target="#channel"},
 
129
                                  [foo, {freenode, [bar, "#channel"]}])),
 
130
     ?_assertEqual(false,
 
131
                   match_channels(#message{server=#server{name=freenode},
 
132
                                           for_mup=true, target="#channel"},
 
133
                                  [{foo, [bar]}, {freenode, "#otherchannel"}])),
 
134
     ?_assertEqual(true,
 
135
                   match_channels(#message{server=#server{name=freenode},
 
136
                                          for_mup=true, target="#channel"},
 
137
                                 [{foo, [bar]}, {freenode, "#channel"}]))
 
138
    ].
 
139
 
 
140
 
 
141
answer(Message, Text) ->
 
142
    answer(Message, Text, []).
 
143
 
 
144
answer(Message, Text, Options) ->
 
145
    {ok, Pid} = mup_server_sup:find_server(Message#message.server),
 
146
    Notice = mup_util:option(notice, Options, false),
 
147
    Action = mup_util:option(action, Options, false),
 
148
    Indirect = mup_util:option(indirect, Options, false),
 
149
    Private = Message#message.target == Message#message.mup_nick,
 
150
    if
 
151
        Notice ->
 
152
            Command = "NOTICE";
 
153
        true ->
 
154
            Command = "PRIVMSG"
 
155
    end,
 
156
    if
 
157
        Private and Action ->
 
158
            Data = io_lib:fwrite("PRIVMSG ~s :~cACTION ~s~c",
 
159
                                 [Message#message.nick, 1, Text, 1]);
 
160
        Private ->
 
161
            Data = io_lib:fwrite("~s ~s :~s",
 
162
                                 [Command, Message#message.nick, Text]);
 
163
        Action ->
 
164
            Data = io_lib:fwrite("PRIVMSG ~s :~cACTION ~s~c",
 
165
                                 [Message#message.target, 1, Text, 1]);
 
166
        Indirect or Notice ->
 
167
            Data = io_lib:fwrite("~s ~s :~s",
 
168
                                 [Command, Message#message.target, Text]);
 
169
        true ->
 
170
            Data = io_lib:fwrite("PRIVMSG ~s :~s: ~s",
 
171
                                 [Message#message.target,
 
172
                                  Message#message.nick, Text])
 
173
    end,
 
174
    mup_server:send(Pid, lists:flatten(Data)).
 
175
 
 
176
 
 
177
mup_server_test_() ->
 
178
    {foreach,
 
179
     fun () ->
 
180
        {ok, ConfigPid} = mup_config:start_link(),
 
181
        {ok, ServerSupPid} = mup_server_sup:start_link(),
 
182
        {ok, PluginSupPid} = mup_plugin_sup:start_link(),
 
183
        {ConfigPid, ServerSupPid, PluginSupPid}
 
184
     end,
 
185
     fun ({ConfigPid, ServerSupPid, PluginSupPid}) ->
 
186
        mup_util:sync_stop(ConfigPid),
 
187
        mup_util:sync_stop(ServerSupPid),
 
188
        mup_util:sync_stop(PluginSupPid)
 
189
     end,
 
190
     [fun answer_on_channel_subtest/0,
 
191
      fun answer_on_channel_indirectly_subtest/0,
 
192
      fun answer_on_channel_with_notice_subtest/0,
 
193
      fun answer_on_channel_with_action_subtest/0,
 
194
      fun answer_privately_subtest/0,
 
195
      fun answer_privately_indirectly_subtest/0,
 
196
      fun answer_privately_with_notice_subtest/0,
 
197
      fun answer_privately_with_action_subtest/0]}.
 
198
 
 
199
answer_on_channel_subtest() ->
 
200
    Server = #server{name=example,
 
201
                     options=[{host, "irc.example.com"},
 
202
                              {port, 6667},
 
203
                              {network_module, mock_tcp}]},
 
204
    mup_config:add_term(Server),
 
205
    {ok, _Pid} = mup_server_sup:start_server(example),
 
206
    mup_server:mock_until_connected(),
 
207
    mup_message:answer(#message{server=Server, nick="bob", target="#channel"},
 
208
                       "Hi!"),
 
209
    ?assertEqual({mock_tcp, send, the_socket, "PRIVMSG #channel :bob: Hi!\r\n"},
 
210
                 mock:next()),
 
211
    mock:answer(ok).
 
212
 
 
213
answer_on_channel_indirectly_subtest() ->
 
214
    Server = #server{name=example,
 
215
                     options=[{host, "irc.example.com"},
 
216
                              {port, 6667},
 
217
                              {network_module, mock_tcp}]},
 
218
    mup_config:add_term(Server),
 
219
    {ok, _Pid} = mup_server_sup:start_server(example),
 
220
    mup_server:mock_until_connected(),
 
221
    mup_message:answer(#message{server=Server, nick="bob", target="#channel"},
 
222
                       "Hi!", [indirect]),
 
223
    ?assertEqual({mock_tcp, send, the_socket, "PRIVMSG #channel :Hi!\r\n"},
 
224
                 mock:next()),
 
225
    mock:answer(ok).
 
226
 
 
227
answer_on_channel_with_notice_subtest() ->
 
228
    Server = #server{name=example,
 
229
                     options=[{host, "irc.example.com"},
 
230
                              {port, 6667},
 
231
                              {network_module, mock_tcp}]},
 
232
    mup_config:add_term(Server),
 
233
    {ok, _Pid} = mup_server_sup:start_server(example),
 
234
    mup_server:mock_until_connected(),
 
235
    mup_message:answer(#message{server=Server, nick="bob", target="#channel"},
 
236
                       "Hi!", [notice]),
 
237
    ?assertEqual({mock_tcp, send, the_socket, "NOTICE #channel :Hi!\r\n"},
 
238
                 mock:next()),
 
239
    mock:answer(ok).
 
240
 
 
241
answer_on_channel_with_action_subtest() ->
 
242
    Server = #server{name=example,
 
243
                     options=[{host, "irc.example.com"},
 
244
                              {port, 6667},
 
245
                              {network_module, mock_tcp}]},
 
246
    mup_config:add_term(Server),
 
247
    {ok, _Pid} = mup_server_sup:start_server(example),
 
248
    mup_server:mock_until_connected(),
 
249
    mup_message:answer(#message{server=Server, nick="bob", target="#channel"},
 
250
                       "Hi!", [action]),
 
251
    ?assertEqual({mock_tcp, send, the_socket,
 
252
                  lists:flatten(["PRIVMSG #channel :", 1, "ACTION Hi!", 1,
 
253
                                 "\r\n"])},
 
254
                 mock:next()),
 
255
    mock:answer(ok).
 
256
 
 
257
answer_privately_subtest() ->
 
258
    Server = #server{name=example,
 
259
                     options=[{host, "irc.example.com"},
 
260
                              {port, 6667},
 
261
                              {network_module, mock_tcp}]},
 
262
    mup_config:add_term(Server),
 
263
    {ok, _Pid} = mup_server_sup:start_server(example),
 
264
    mup_server:mock_until_connected(),
 
265
    mup_message:answer(#message{server=Server, nick="bob", target="mup",
 
266
                                mup_nick="mup"},
 
267
                      "Hi!"),
 
268
    ?assertEqual({mock_tcp, send, the_socket, "PRIVMSG bob :Hi!\r\n"},
 
269
                 mock:next()),
 
270
    mock:answer(ok).
 
271
 
 
272
answer_privately_indirectly_subtest() ->
 
273
    Server = #server{name=example,
 
274
                     options=[{host, "irc.example.com"},
 
275
                              {port, 6667},
 
276
                              {network_module, mock_tcp}]},
 
277
    mup_config:add_term(Server),
 
278
    {ok, _Pid} = mup_server_sup:start_server(example),
 
279
    mup_server:mock_until_connected(),
 
280
    mup_message:answer(#message{server=Server, nick="bob", target="mup",
 
281
                                mup_nick="mup"},
 
282
                       "Hi!", [indirect]),
 
283
    ?assertEqual({mock_tcp, send, the_socket, "PRIVMSG bob :Hi!\r\n"},
 
284
                 mock:next()),
 
285
    mock:answer(ok).
 
286
 
 
287
answer_privately_with_notice_subtest() ->
 
288
    Server = #server{name=example,
 
289
                     options=[{host, "irc.example.com"},
 
290
                              {port, 6667},
 
291
                              {network_module, mock_tcp}]},
 
292
    mup_config:add_term(Server),
 
293
    {ok, _Pid} = mup_server_sup:start_server(example),
 
294
    mup_server:mock_until_connected(),
 
295
    mup_message:answer(#message{server=Server, nick="bob", target="mup",
 
296
                                mup_nick="mup"},
 
297
                       "Hi!", [notice]),
 
298
    ?assertEqual({mock_tcp, send, the_socket, "NOTICE bob :Hi!\r\n"},
 
299
                 mock:next()),
 
300
    mock:answer(ok).
 
301
 
 
302
answer_privately_with_action_subtest() ->
 
303
    Server = #server{name=example,
 
304
                     options=[{host, "irc.example.com"},
 
305
                              {port, 6667},
 
306
                              {network_module, mock_tcp}]},
 
307
    mup_config:add_term(Server),
 
308
    {ok, _Pid} = mup_server_sup:start_server(example),
 
309
    mup_server:mock_until_connected(),
 
310
    mup_message:answer(#message{server=Server, nick="bob", target="mup",
 
311
                                mup_nick="mup"},
 
312
                       "Hi!", [action]),
 
313
    ?assertEqual({mock_tcp, send, the_socket,
 
314
                  lists:flatten(["PRIVMSG bob :", 1, "ACTION Hi!", 1, "\r\n"])},
 
315
                 mock:next()),
 
316
    mock:answer(ok).
 
317