irc 4.1.0

IRC library in Dart providing a simplistic and easy to use API.

example/main.dart

import 'dart:async';
import 'dart:math';

import 'package:irc/client.dart';

typedef CommandHandler = Function(CommandEvent event);

final Random random = Random();

String prefix = '~';
Map<String, StreamController<CommandEvent>> commands = {};

void main() {
  var nickOffset = random.nextInt(9999);
  var config = Configuration(
      host: 'irc.esper.net',
      port: 6667,
      nickname: 'DartBot$nickOffset',
      username: 'DartBot$nickOffset',
      realname: 'DartBot');

  var client = Client(config);
  client.connect();

  client.onLineSent.listen((event) {
    print('<< ${event.line}');
  });

  client.onLineReceive.listen((event) {
    print('>> ${event.line}');
  });

  client.onDisconnect.listen((e) async {
    await Future.delayed(const Duration(seconds: 1));
    client.connect();
  });

  client.onMode.listen((event) {
    if (event.channel != null && event.user != null) {
      print(
          'Mode (${event.mode}) given to ${event.user} in ${event.channel.name}');
    } else if (event.channel != null) {
      print('Mode (${event.mode}) given to ${event.channel.name}');
    } else if (event.user != null) {
      print('Mode (${event.mode}) was set on us.');
    }
  });

  client.onReady.listen((event) {
    event.join('#mysticlgbt');

    if (client.monitor.isSupported) {
      client.monitor.add('azenla');
    }
  });

  client.register(handleAsCommand);

  command('notice-me', (CommandEvent event) {
    event.notice('This is a test notice to you');
  });

  command('server-caps', (CommandEvent e) {
    e.reply('Supported: ${client.supported}');
    e.reply("Capabilities: ${client.serverCapabilities.join(', ')}");
  });

  command('notice-chan', (CommandEvent event) {
    event.notice('This is a test notice to the channel', user: false);
  });

  command('join', (CommandEvent event) {
    if (event.args.length == 1) {
      client.join(event.args[0]);
    } else {
      event.reply('Usage: join <channel>');
    }
  });

  command('part', (CommandEvent event) {
    if (event.args.length == 1) {
      client.part(event.args[0]);
    } else if (event.args.isEmpty) {
      client.part(event.channel.name);
    } else {
      event.reply('Usage: part [channel]');
    }
  });

  command('quit', (CommandEvent event) {
    client.disconnect(reason: '${event.from.name} asked me to quit.');
  });

  command('topic', (CommandEvent event) {
    event.reply(event.channel.topic);
  });

  command('bans', (CommandEvent event) {
    event.reply('${event.channel.bans}');
  });

  command('spam', (CommandEvent event) {
    for (var i = 1; i <= 50; i++) {
      event.reply(i.toString());
    }
  });

  command('users', (CommandEvent event) {
    String joinNicks(Set<User> users) {
      if (users.length > 10) {
        return '${users.length} users';
      }
      return users
          .map((it) {
            return it.nickname;
          })
          .toList()
          .join(', ');
    }

    if (!event.target.isChannel) {
      return;
    }

    Channel channel = event.target;
    if (event.args.isNotEmpty) {
      channel = client.getChannel(event.args[0]);
    }

    if (channel == null) {
      event.notice('${event.args[0]} not found.');
      return;
    }

    event.notice('> Members: ${joinNicks(channel.members)}');
    event.notice('> Ops: ${joinNicks(channel.ops)}');
    event.notice('> Voices: ${joinNicks(channel.voices)}');
    event.notice('> Owners: ${joinNicks(channel.owners)}');
    event.notice('> Half-Ops: ${joinNicks(channel.halfops)}');
    event.notice('> All Users: ${joinNicks(channel.allUsers)}');
  });

  command('act', (CommandEvent event) {
    event.act('is silleh.');
  });

  command('whois', (CommandEvent event) async {
    if (event.args.length != 1) {
      event.reply('Usage: whois <user>');
      return;
    }

    var whois = await client.whois(event.args[0]);
    var info = whois.toString();
    event.notice(info);
  });

  command('away', (CommandEvent event) async {
    if (event.args.length == 1) {
      var user = client.getUser(event.args[0]);
      var isAway = await user.isAway();
      if (isAway) {
        event.reply('${user.name} is away.');
      } else {
        event.reply('${user.name} is not away.');
      }
    }
  });

  command('server-version', (CommandEvent e) async {
    var version = await client.getServerVersion();
    e.reply('Server: ${version.server}, Version: ${version.version}');
  });

  command('online', (CommandEvent e) {
    if (e.args.length != 1) {
      return;
    }

    e.reply('Online: ${client.monitor.isUserOnline(e.args[0])}');
  });
}

void handleAsCommand(MessageEvent event) {
  var message = event.message;

  if (message.startsWith(prefix)) {
    var end = message.contains(' ')
        ? message.indexOf(' ', prefix.length)
        : message.length;
    var command = message.substring(prefix.length, end);
    var args =
        message.substring(end != message.length ? end + 1 : end).split(' ');

    args.removeWhere((i) => i.isEmpty || i == ' ');

    if (commands.containsKey(command)) {
      commands[command].add(CommandEvent(event, command, args));
    } else {
      commandNotFound(CommandEvent(event, command, args));
    }
  }
}

void command(String name, CommandHandler handler) {
  commands
      .putIfAbsent(name, () {
        return StreamController.broadcast();
      })
      .stream
      .listen((e) async {
        try {
          await handler(e);
        } catch (e, stack) {
          print(e);
          print(stack);
        }
      }, onError: (e, stack) {
        print(e);
        print(stack);
      });
}

void commandNotFound(CommandEvent event) {
  event.reply('Command not found.');
}

class CommandEvent extends MessageEvent {
  String command;
  List<String> args;

  CommandEvent(MessageEvent event, this.command, this.args)
      : super(event.client, event.from, event.target, event.message);

  void notice(String message, {bool user = true}) =>
      client.sendNotice(from.name, message);

  void act(String message) => client.sendAction(target.name, message);

  String argument(int index) => args[index];
}