Mercurial > irccd

comparison irccd-test/main.cpp @ 773:8c44bbcbbab9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Misc: style, cleanup and update
author David Demelier <markand@malikania.fr>
date Fri, 26 Oct 2018 13:01:00 +0200
parents f25c878d823b
children 7145a3df4cb7
comparison
equal deleted inserted replaced
772:f5ccf65ae929 773:8c44bbcbbab9
27 #include <boost/algorithm/string/trim.hpp> 27 #include <boost/algorithm/string/trim.hpp>
28 #include <boost/filesystem.hpp> 28 #include <boost/filesystem.hpp>
29 #include <boost/format.hpp> 29 #include <boost/format.hpp>
30 30
31 #if defined(IRCCD_HAVE_LIBEDIT) 31 #if defined(IRCCD_HAVE_LIBEDIT)
32 # include <histedit.h> 32 # include <histedit.h>
33 #endif 33 #endif
34 34
35 #include <irccd/options.hpp> 35 #include <irccd/options.hpp>
36 #include <irccd/string_util.hpp> 36 #include <irccd/string_util.hpp>
37 37
41 #include <irccd/daemon/server_service.hpp> 41 #include <irccd/daemon/server_service.hpp>
42 42
43 #include <irccd/test/debug_server.hpp> 43 #include <irccd/test/debug_server.hpp>
44 44
45 #if defined(IRCCD_HAVE_JS) 45 #if defined(IRCCD_HAVE_JS)
46 # include <irccd/js/js_api.hpp> 46 # include <irccd/js/js_api.hpp>
47 # include <irccd/js/js_plugin.hpp> 47 # include <irccd/js/js_plugin.hpp>
48 #endif 48 #endif
49 49
50 using boost::format; 50 using boost::format;
51 using boost::str; 51 using boost::str;
52 52
89 */ 89 */
90 using function = std::function<void (const std::string&)>; 90 using function = std::function<void (const std::string&)>;
91 using functions = std::unordered_map<std::string, function>; 91 using functions = std::unordered_map<std::string, function>;
92 92
93 static const functions list{ 93 static const functions list{
94 { "onCommand", &(on_command) }, 94 { "onCommand", &(on_command) },
95 { "onConnect", &(on_connect) }, 95 { "onConnect", &(on_connect) },
96 { "onInvite", &(on_invite) }, 96 { "onInvite", &(on_invite) },
97 { "onJoin", &(on_join) }, 97 { "onJoin", &(on_join) },
98 { "onKick", &(on_kick) }, 98 { "onKick", &(on_kick) },
99 { "onLoad", &(on_load) }, 99 { "onLoad", &(on_load) },
100 { "onMe", &(on_me) }, 100 { "onMe", &(on_me) },
101 { "onMessage", &(on_message) }, 101 { "onMessage", &(on_message) },
102 { "onMode", &(on_mode) }, 102 { "onMode", &(on_mode) },
103 { "onNames", &(on_names) }, 103 { "onNames", &(on_names) },
104 { "onNick", &(on_nick) }, 104 { "onNick", &(on_nick) },
105 { "onNotice", &(on_notice) }, 105 { "onNotice", &(on_notice) },
106 { "onPart", &(on_part) }, 106 { "onPart", &(on_part) },
107 { "onReload", &(on_reload) }, 107 { "onReload", &(on_reload) },
108 { "onTopic", &(on_topic) }, 108 { "onTopic", &(on_topic) },
109 { "onUnload", &(on_unload) }, 109 { "onUnload", &(on_unload) },
110 { "onWhois", &(on_whois) } 110 { "onWhois", &(on_whois) }
111 }; 111 };
112 112
113 // }}} 113 // }}}
114 114
115 // {{{ usage 115 // {{{ usage
116 116
117 void usage() 117 void usage()
118 { 118 {
119 std::cerr << "usage: irccd-test [-c config] plugin-name" << std::endl; 119 std::cerr << "usage: irccd-test [-c config] plugin-name" << std::endl;
120 std::exit(1); 120 std::exit(1);
121 } 121 }
122 122
123 // }}} 123 // }}}
124 124
125 // {{{ get_server 125 // {{{ get_server
126 126
127 std::shared_ptr<server> get_server(std::string name) 127 auto get_server(std::string name) -> std::shared_ptr<server>
128 { 128 {
129 name = boost::algorithm::trim_copy(name); 129 name = boost::algorithm::trim_copy(name);
130 130
131 if (name.empty()) 131 if (name.empty())
132 name = "test"; 132 name = "test";
133 133
134 auto s = daemon->servers().get(name); 134 auto s = daemon->servers().get(name);
135 135
136 if (!s) { 136 if (!s) {
137 s = std::make_shared<debug_server>(io, std::move(name), "localhost"); 137 s = std::make_shared<debug_server>(io, std::move(name), "localhost");
138 daemon->servers().add(s); 138 daemon->servers().add(s);
139 } 139 }
140 140
141 return s; 141 return s;
142 } 142 }
143 143
144 // }}} 144 // }}}
145 145
146 // {{{ get_arg 146 // {{{ get_arg
147 147
148 std::string get_arg(const std::vector<std::string>& args, unsigned index) 148 auto get_arg(const std::vector<std::string>& args, unsigned index) -> std::string
149 { 149 {
150 if (index >= args.size()) 150 if (index >= args.size())
151 return ""; 151 return "";
152 152
153 return args[index]; 153 return args[index];
154 } 154 }
155 155
156 // }}} 156 // }}}
157 157
158 // {{{ on_command 158 // {{{ on_command
160 /* 160 /*
161 * onCommand server origin channel message 161 * onCommand server origin channel message
162 */ 162 */
163 void on_command(const std::string& data) 163 void on_command(const std::string& data)
164 { 164 {
165 const auto args = su::split(data, " ", 4); 165 const auto args = su::split(data, " ", 4);
166 166
167 plugin->handle_command(*daemon, { 167 plugin->handle_command(*daemon, {
168 get_server(get_arg(args, 0)), 168 get_server(get_arg(args, 0)),
169 get_arg(args, 1), 169 get_arg(args, 1),
170 get_arg(args, 2), 170 get_arg(args, 2),
171 get_arg(args, 3) 171 get_arg(args, 3)
172 }); 172 });
173 } 173 }
174 174
175 // }}} 175 // }}}
176 176
177 // {{{ on_connect 177 // {{{ on_connect
179 /* 179 /*
180 * onConnect server 180 * onConnect server
181 */ 181 */
182 void on_connect(const std::string& data) 182 void on_connect(const std::string& data)
183 { 183 {
184 const auto args = su::split(data, " "); 184 const auto args = su::split(data, " ");
185 185
186 plugin->handle_connect(*daemon, {get_server(get_arg(args, 0))}); 186 plugin->handle_connect(*daemon, {get_server(get_arg(args, 0))});
187 } 187 }
188 188
189 // }}} 189 // }}}
190 190
191 // {{{ on_invite 191 // {{{ on_invite
193 /* 193 /*
194 * onInvite server origin channel target 194 * onInvite server origin channel target
195 */ 195 */
196 void on_invite(const std::string& data) 196 void on_invite(const std::string& data)
197 { 197 {
198 const auto args = su::split(data, " "); 198 const auto args = su::split(data, " ");
199 199
200 plugin->handle_invite(*daemon, { 200 plugin->handle_invite(*daemon, {
201 get_server(get_arg(args, 0)), 201 get_server(get_arg(args, 0)),
202 get_arg(args, 1), 202 get_arg(args, 1),
203 get_arg(args, 2), 203 get_arg(args, 2),
204 get_arg(args, 3), 204 get_arg(args, 3),
205 }); 205 });
206 } 206 }
207 207
208 // }}} 208 // }}}
209 209
210 // {{{ on_join 210 // {{{ on_join
212 /* 212 /*
213 * onJoin server origin channel 213 * onJoin server origin channel
214 */ 214 */
215 void on_join(const std::string& data) 215 void on_join(const std::string& data)
216 { 216 {
217 const auto args = su::split(data, " "); 217 const auto args = su::split(data, " ");
218 218
219 plugin->handle_join(*daemon, { 219 plugin->handle_join(*daemon, {
220 get_server(get_arg(args, 0)), 220 get_server(get_arg(args, 0)),
221 get_arg(args, 1), 221 get_arg(args, 1),
222 get_arg(args, 2) 222 get_arg(args, 2)
223 }); 223 });
224 } 224 }
225 225
226 // }}} 226 // }}}
227 227
228 // {{{ on_kick 228 // {{{ on_kick
230 /* 230 /*
231 * onKick server origin channel reason 231 * onKick server origin channel reason
232 */ 232 */
233 void on_kick(const std::string& data) 233 void on_kick(const std::string& data)
234 { 234 {
235 const auto args = su::split(data, " ", 5); 235 const auto args = su::split(data, " ", 5);
236 236
237 plugin->handle_kick(*daemon, { 237 plugin->handle_kick(*daemon, {
238 get_server(get_arg(args, 0)), 238 get_server(get_arg(args, 0)),
239 get_arg(args, 1), 239 get_arg(args, 1),
240 get_arg(args, 2), 240 get_arg(args, 2),
241 get_arg(args, 3), 241 get_arg(args, 3),
242 get_arg(args, 4), 242 get_arg(args, 4),
243 }); 243 });
244 } 244 }
245 245
246 // }}} 246 // }}}
247 247
248 // {{{ on_load 248 // {{{ on_load
250 /* 250 /*
251 * onLoad 251 * onLoad
252 */ 252 */
253 void on_load(const std::string&) 253 void on_load(const std::string&)
254 { 254 {
255 plugin->handle_load(*daemon); 255 plugin->handle_load(*daemon);
256 } 256 }
257 257
258 // }}} 258 // }}}
259 259
260 // {{{ on_me 260 // {{{ on_me
262 /* 262 /*
263 * onMe server origin channel message 263 * onMe server origin channel message
264 */ 264 */
265 void on_me(const std::string& data) 265 void on_me(const std::string& data)
266 { 266 {
267 const auto args = su::split(data, " ", 4); 267 const auto args = su::split(data, " ", 4);
268 268
269 plugin->handle_me(*daemon, { 269 plugin->handle_me(*daemon, {
270 get_server(get_arg(args, 0)), 270 get_server(get_arg(args, 0)),
271 get_arg(args, 1), 271 get_arg(args, 1),
272 get_arg(args, 2), 272 get_arg(args, 2),
273 get_arg(args, 3) 273 get_arg(args, 3)
274 }); 274 });
275 } 275 }
276 276
277 // }}} 277 // }}}
278 278
279 // {{{ on_message 279 // {{{ on_message
281 /* 281 /*
282 * onMessage server origin channel message 282 * onMessage server origin channel message
283 */ 283 */
284 void on_message(const std::string& data) 284 void on_message(const std::string& data)
285 { 285 {
286 const auto args = su::split(data, " ", 4); 286 const auto args = su::split(data, " ", 4);
287 287
288 plugin->handle_message(*daemon, { 288 plugin->handle_message(*daemon, {
289 get_server(get_arg(args, 0)), 289 get_server(get_arg(args, 0)),
290 get_arg(args, 1), 290 get_arg(args, 1),
291 get_arg(args, 2), 291 get_arg(args, 2),
292 get_arg(args, 3) 292 get_arg(args, 3)
293 }); 293 });
294 } 294 }
295 295
296 // }}} 296 // }}}
297 297
298 // {{{ on_mode 298 // {{{ on_mode
300 /* 300 /*
301 * onMode server origin channel mode limit user mask 301 * onMode server origin channel mode limit user mask
302 */ 302 */
303 void on_mode(const std::string& data) 303 void on_mode(const std::string& data)
304 { 304 {
305 const auto args = su::split(data, " ", 7); 305 const auto args = su::split(data, " ", 7);
306 306
307 plugin->handle_mode(*daemon, { 307 plugin->handle_mode(*daemon, {
308 get_server(get_arg(args, 0)), 308 get_server(get_arg(args, 0)),
309 get_arg(args, 1), 309 get_arg(args, 1),
310 get_arg(args, 2), 310 get_arg(args, 2),
311 get_arg(args, 3), 311 get_arg(args, 3),
312 get_arg(args, 4), 312 get_arg(args, 4),
313 get_arg(args, 5), 313 get_arg(args, 5),
314 get_arg(args, 6), 314 get_arg(args, 6),
315 }); 315 });
316 } 316 }
317 317
318 // }}} 318 // }}}
319 319
320 // {{{ on_names 320 // {{{ on_names
322 /* 322 /*
323 * onNames server channel nick1 nick2 nickN 323 * onNames server channel nick1 nick2 nickN
324 */ 324 */
325 void on_names(const std::string& data) 325 void on_names(const std::string& data)
326 { 326 {
327 const auto args = su::split(data, " "); 327 const auto args = su::split(data, " ");
328 328
329 names_event ev; 329 names_event ev;
330 330
331 ev.server = get_server(get_arg(args, 0)); 331 ev.server = get_server(get_arg(args, 0));
332 ev.channel = get_arg(args, 1); 332 ev.channel = get_arg(args, 1);
333 333
334 if (args.size() >= 3U) 334 if (args.size() >= 3U)
335 ev.names.insert(ev.names.begin(), args.begin() + 2, args.end()); 335 ev.names.insert(ev.names.begin(), args.begin() + 2, args.end());
336 336
337 plugin->handle_names(*daemon, ev); 337 plugin->handle_names(*daemon, ev);
338 } 338 }
339 339
340 // }}} 340 // }}}
341 341
342 // {{{ on_nick 342 // {{{ on_nick
344 /* 344 /*
345 * onNick server origin nickname 345 * onNick server origin nickname
346 */ 346 */
347 void on_nick(const std::string& data) 347 void on_nick(const std::string& data)
348 { 348 {
349 const auto args = su::split(data, " "); 349 const auto args = su::split(data, " ");
350 350
351 plugin->handle_nick(*daemon, { 351 plugin->handle_nick(*daemon, {
352 get_server(get_arg(args, 0)), 352 get_server(get_arg(args, 0)),
353 get_arg(args, 1), 353 get_arg(args, 1),
354 get_arg(args, 2) 354 get_arg(args, 2)
355 }); 355 });
356 } 356 }
357 357
358 // }}} 358 // }}}
359 359
360 // {{{ on_notice 360 // {{{ on_notice
362 /* 362 /*
363 * onNotice server origin channel nickname 363 * onNotice server origin channel nickname
364 */ 364 */
365 void on_notice(const std::string& data) 365 void on_notice(const std::string& data)
366 { 366 {
367 const auto args = su::split(data, " ", 4); 367 const auto args = su::split(data, " ", 4);
368 368
369 plugin->handle_notice(*daemon, { 369 plugin->handle_notice(*daemon, {
370 get_server(get_arg(args, 0)), 370 get_server(get_arg(args, 0)),
371 get_arg(args, 1), 371 get_arg(args, 1),
372 get_arg(args, 2), 372 get_arg(args, 2),
373 get_arg(args, 3) 373 get_arg(args, 3)
374 }); 374 });
375 } 375 }
376 376
377 // }}} 377 // }}}
378 378
379 // {{{ on_part 379 // {{{ on_part
381 /* 381 /*
382 * onPart server origin channel reason 382 * onPart server origin channel reason
383 */ 383 */
384 void on_part(const std::string& data) 384 void on_part(const std::string& data)
385 { 385 {
386 const auto args = su::split(data, " ", 4); 386 const auto args = su::split(data, " ", 4);
387 387
388 plugin->handle_part(*daemon, { 388 plugin->handle_part(*daemon, {
389 get_server(get_arg(args, 0)), 389 get_server(get_arg(args, 0)),
390 get_arg(args, 1), 390 get_arg(args, 1),
391 get_arg(args, 2), 391 get_arg(args, 2),
392 get_arg(args, 3), 392 get_arg(args, 3),
393 }); 393 });
394 } 394 }
395 395
396 // }}} 396 // }}}
397 397
398 // {{{ on_reload 398 // {{{ on_reload
400 /* 400 /*
401 * onReload 401 * onReload
402 */ 402 */
403 void on_reload(const std::string&) 403 void on_reload(const std::string&)
404 { 404 {
405 plugin->handle_reload(*daemon); 405 plugin->handle_reload(*daemon);
406 } 406 }
407 407
408 // }}} 408 // }}}
409 409
410 // {{{ on_topic 410 // {{{ on_topic
412 /* 412 /*
413 * onTopic server origin channel topic 413 * onTopic server origin channel topic
414 */ 414 */
415 void on_topic(const std::string& data) 415 void on_topic(const std::string& data)
416 { 416 {
417 const auto args = su::split(data, " ", 4); 417 const auto args = su::split(data, " ", 4);
418 418
419 plugin->handle_topic(*daemon, { 419 plugin->handle_topic(*daemon, {
420 get_server(get_arg(args, 0)), 420 get_server(get_arg(args, 0)),
421 get_arg(args, 1), 421 get_arg(args, 1),
422 get_arg(args, 2), 422 get_arg(args, 2),
423 get_arg(args, 3) 423 get_arg(args, 3)
424 }); 424 });
425 } 425 }
426 426
427 // }}} 427 // }}}
428 428
429 // {{{ on_unload 429 // {{{ on_unload
431 /* 431 /*
432 * onUnload 432 * onUnload
433 */ 433 */
434 void on_unload(const std::string&) 434 void on_unload(const std::string&)
435 { 435 {
436 plugin->handle_unload(*daemon); 436 plugin->handle_unload(*daemon);
437 } 437 }
438 438
439 // }}} 439 // }}}
440 440
441 // {{{ on_whois 441 // {{{ on_whois
443 /* 443 /*
444 * onWhois server nick user host realname chan1 chan2 chanN 444 * onWhois server nick user host realname chan1 chan2 chanN
445 */ 445 */
446 void on_whois(const std::string& data) 446 void on_whois(const std::string& data)
447 { 447 {
448 const auto args = su::split(data, " "); 448 const auto args = su::split(data, " ");
449 449
450 whois_event ev; 450 whois_event ev;
451 451
452 ev.server = get_server(get_arg(args, 0)); 452 ev.server = get_server(get_arg(args, 0));
453 ev.whois.nick = get_arg(args, 1); 453 ev.whois.nick = get_arg(args, 1);
454 ev.whois.user = get_arg(args, 2); 454 ev.whois.user = get_arg(args, 2);
455 ev.whois.host = get_arg(args, 3); 455 ev.whois.host = get_arg(args, 3);
456 ev.whois.realname = get_arg(args, 4); 456 ev.whois.realname = get_arg(args, 4);
457 457
458 if (args.size() >= 5) 458 if (args.size() >= 5)
459 ev.whois.channels.insert(ev.whois.channels.begin(), args.begin() + 5, args.end()); 459 ev.whois.channels.insert(ev.whois.channels.begin(), args.begin() + 5, args.end());
460 460
461 plugin->handle_whois(*daemon, ev); 461 plugin->handle_whois(*daemon, ev);
462 } 462 }
463 463
464 // }}} 464 // }}}
465 465
466 // {{{ exec 466 // {{{ exec
467 467
468 void exec(const std::string& line) 468 void exec(const std::string& line)
469 { 469 {
470 const auto pos = line.find(' '); 470 const auto pos = line.find(' ');
471 const auto it = list.find(line.substr(0, pos)); 471 const auto it = list.find(line.substr(0, pos));
472 472
473 if (it != list.end()) 473 if (it != list.end())
474 it->second(pos == std::string::npos ? "" : line.substr(pos + 1)); 474 it->second(pos == std::string::npos ? "" : line.substr(pos + 1));
475 } 475 }
476 476
477 // }}} 477 // }}}
478 478
479 #if defined(IRCCD_HAVE_LIBEDIT) 479 #if defined(IRCCD_HAVE_LIBEDIT)
480 480
481 // {{{ prompt (libedit version) 481 // {{{ prompt (libedit version)
482 482
483 const char* prompt(EditLine*) 483 auto prompt(EditLine*) -> const char*
484 { 484 {
485 static const char* text = "> "; 485 static const char* text = "> ";
486 486
487 return text; 487 return text;
488 } 488 }
489 489
490 std::string clean(std::string input) 490 auto clean(std::string input) -> std::string
491 { 491 {
492 while (!input.empty() && (input.back() == '\n' || input.back() == '\r')) 492 while (!input.empty() && (input.back() == '\n' || input.back() == '\r'))
493 input.pop_back(); 493 input.pop_back();
494 494
495 return input; 495 return input;
496 } 496 }
497 497
498 std::vector<std::string> matches(const std::string& name) 498 auto matches(const std::string& name) -> std::vector<std::string>
499 { 499 {
500 std::vector<std::string> result; 500 std::vector<std::string> result;
501 501
502 for (const auto& pair : list) 502 for (const auto& pair : list)
503 if (pair.first.compare(0U, name.size(), name) == 0U) 503 if (pair.first.compare(0U, name.size(), name) == 0U)
504 result.push_back(pair.first); 504 result.push_back(pair.first);
505 505
506 return result; 506 return result;
507 } 507 }
508 508
509 unsigned char complete(EditLine* el, int) 509 auto complete(EditLine* el, int) -> unsigned char
510 { 510 {
511 const auto* lf = el_line(el); 511 const auto* lf = el_line(el);
512 const auto args = su::split(std::string(lf->buffer, lf->cursor), " "); 512 const auto args = su::split(std::string(lf->buffer, lf->cursor), " ");
513 513
514 if (args.size() == 0U) 514 if (args.size() == 0U)
515 return CC_REFRESH; 515 return CC_REFRESH;
516 516
517 const auto found = matches(args[0]); 517 const auto found = matches(args[0]);
518 518
519 if (found.size() != 1U) 519 if (found.size() != 1U)
520 return CC_REFRESH; 520 return CC_REFRESH;
521 521
522 // Insert the missing text, e.g. onCom -> onCommand. 522 // Insert the missing text, e.g. onCom -> onCommand.
523 if (el_insertstr(el, &found[0].c_str()[args[0].size()]) < 0) 523 if (el_insertstr(el, &found[0].c_str()[args[0].size()]) < 0)
524 return CC_ERROR; 524 return CC_ERROR;
525 525
526 return CC_REFRESH; 526 return CC_REFRESH;
527 } 527 }
528 528
529 void run() 529 void run()
530 { 530 {
531 std::unique_ptr<EditLine, void (*)(EditLine*)> el( 531 std::unique_ptr<EditLine, void (*)(EditLine*)> el(
532 el_init("irccd-test", stdin, stdout, stderr), 532 el_init("irccd-test", stdin, stdout, stderr),
533 el_end 533 el_end
534 ); 534 );
535 std::unique_ptr<History, void (*)(History*)> hist( 535 std::unique_ptr<History, void (*)(History*)> hist(
536 history_init(), 536 history_init(),
537 history_end 537 history_end
538 ); 538 );
539 HistEvent hev; 539 HistEvent hev;
540 540
541 history(hist.get(), &hev, H_SETSIZE, 1024); 541 history(hist.get(), &hev, H_SETSIZE, 1024);
542 el_set(el.get(), EL_EDITOR, "emacs"); 542 el_set(el.get(), EL_EDITOR, "emacs");
543 el_set(el.get(), EL_PROMPT, prompt); 543 el_set(el.get(), EL_PROMPT, prompt);
544 el_set(el.get(), EL_HIST, history, hist.get()); 544 el_set(el.get(), EL_HIST, history, hist.get());
545 el_set(el.get(), EL_ADDFN, "ed-complete", "Complete command", complete); 545 el_set(el.get(), EL_ADDFN, "ed-complete", "Complete command", complete);
546 el_set(el.get(), EL_BIND, "^I", "ed-complete", nullptr); 546 el_set(el.get(), EL_BIND, "^I", "ed-complete", nullptr);
547 547
548 const char* s; 548 const char* s;
549 int size; 549 int size;
550 550
551 while ((s = el_gets(el.get(), &size)) && size >= 0) { 551 while ((s = el_gets(el.get(), &size)) && size >= 0) {
552 if (size > 0) 552 if (size > 0)
553 history(hist.get(), &hev, H_ENTER, s); 553 history(hist.get(), &hev, H_ENTER, s);
554 554
555 exec(clean(s)); 555 exec(clean(s));
556 } 556 }
557 } 557 }
558 558
559 // }}} 559 // }}}
560 560
561 #else 561 #else
562 562
563 // {{{ run (standard version) 563 // {{{ run (standard version)
564 564
565 void run() 565 void run()
566 { 566 {
567 std::string line; 567 std::string line;
568 568
569 for (;;) { 569 for (;;) {
570 std::cout << "> "; 570 std::cout << "> ";
571 571
572 if (!std::getline(std::cin, line)) 572 if (!std::getline(std::cin, line))
573 return; 573 return;
574 574
575 exec(line); 575 exec(line);
576 } 576 }
577 } 577 }
578 578
579 // }}} 579 // }}}
580 580
581 #endif 581 #endif
582 582
583 // {{{ load_plugins 583 // {{{ load_plugins
584 584
585 void load_plugins(int argc, char** argv) 585 void load_plugins(int argc, char** argv)
586 { 586 {
587 if (argc <= 0) 587 if (argc <= 0)
588 usage(); 588 usage();
589 589
590 daemon->plugins().load("test", boost::filesystem::exists(argv[0]) ? argv[0] : ""); 590 daemon->plugins().load("test", boost::filesystem::exists(argv[0]) ? argv[0] : "");
591 plugin = daemon->plugins().get("test"); 591 plugin = daemon->plugins().get("test");
592 } 592 }
593 593
594 // }}} 594 // }}}
595 595
596 // {{{ load_config 596 // {{{ load_config
597 597
598 auto load_config(const option::result& result) -> config 598 auto load_config(const option::result& result) -> config
599 { 599 {
600 auto it = result.find("-c"); 600 auto it = result.find("-c");
601 601
602 if (it != result.end() || (it = result.find("--config")) != result.end()) 602 if (it != result.end() || (it = result.find("--config")) != result.end())
603 return config(it->second); 603 return config(it->second);
604 604
605 auto cfg = config::search("irccd.conf"); 605 auto cfg = config::search("irccd.conf");
606 606
607 return *cfg; 607 return *cfg;
608 } 608 }
609 609
610 // }}} 610 // }}}
611 611
612 // {{{ load_options 612 // {{{ load_options
613 613
614 void load_options(int& argc, char**& argv) 614 void load_options(int& argc, char**& argv)
615 { 615 {
616 static const option::options def{ 616 static const option::options def{
617 { "-c", true }, 617 { "-c", true },
618 { "--config", true } 618 { "--config", true }
619 }; 619 };
620 620
621 try { 621 try {
622 daemon->set_config(load_config(option::read(argc, argv, def))); 622 daemon->set_config(load_config(option::read(argc, argv, def)));
623 } catch (const std::exception& ex) { 623 } catch (const std::exception& ex) {
624 throw std::runtime_error(str(format("%1%") % ex.what())); 624 throw std::runtime_error(str(format("%1%") % ex.what()));
625 } 625 }
626 } 626 }
627 627
628 // }}} 628 // }}}
629 629
630 // {{{ load 630 // {{{ load
631 631
632 void load(int argc, char** argv) 632 void load(int argc, char** argv)
633 { 633 {
634 daemon = std::make_unique<irccd>(io); 634 daemon = std::make_unique<irccd>(io);
635 daemon->plugins().add_loader(std::make_unique<dynlib_plugin_loader>()); 635 daemon->plugins().add_loader(std::make_unique<dynlib_plugin_loader>());
636 636
637 #if defined(IRCCD_HAVE_JS) 637 #if defined(IRCCD_HAVE_JS)
638 auto loader = std::make_unique<js::js_plugin_loader>(*daemon); 638 auto loader = std::make_unique<js::js_plugin_loader>(*daemon);
639 639
640 for (const auto& f : js::js_api::registry) 640 for (const auto& f : js::js_api::registry)
641 loader->get_modules().push_back(f()); 641 loader->get_modules().push_back(f());
642 642
643 daemon->plugins().add_loader(std::move(loader)); 643 daemon->plugins().add_loader(std::move(loader));
644 #endif 644 #endif
645 645
646 load_options(argc, argv); 646 load_options(argc, argv);
647 load_plugins(argc, argv); 647 load_plugins(argc, argv);
648 } 648 }
649 649
650 // }}} 650 // }}}
651 651
652 } // !namespace 652 } // !namespace
653 653
654 } // !irccd 654 } // !irccd
655 655
656 int main(int argc, char** argv) 656 int main(int argc, char** argv)
657 { 657 {
658 try { 658 try {
659 irccd::load(--argc, ++argv); 659 irccd::load(--argc, ++argv);
660 irccd::run(); 660 irccd::run();
661 } catch (const std::exception& ex) { 661 } catch (const std::exception& ex) {
662 std::cerr << "abort: " << ex.what() << std::endl; 662 std::cerr << "abort: " << ex.what() << std::endl;
663 return 1; 663 return 1;
664 } 664 }
665 } 665 }