Release v0.4.0

BOM/build.gradle

@@ -1,5 +1,5 @@
 plugins {
-    id "ru.vyarus.pom" version "1.3.0"
+    id "io.spring.dependency-management" version "1.0.6.RELEASE"
 }
 
 description = "Bills of Materials (BOM) for Glitch packages"
@@ -12,17 +12,13 @@ tasks.withType(Jar) {
 delombok.enabled = false
 test.enabled = false
 
-withPomXml { Node node ->
-    node.appendNode("name").value = "Glitch BOM"
-    node.remove(node.dependencyManagement) // removes Project Reactor form dependency management
-    Node deps = node.appendNode("dependencyManagement").appendNode("dependencies")
-
-    project.rootProject.subprojects.each {
-        if (it.name != "BOM" && it.name != "docs") {
-            Node dep = deps.appendNode('dependency')
-            dep.appendNode('groupId', it.group)
-            dep.appendNode('artifactId', it.archivesBaseName)
-            dep.appendNode('version', it.version)
+dependencyManagement {
+    dependencies {
+        rootProject.subprojects.each {
+            if (it.name != "BOM" && it.name != "docs") {
+                dependency(group: it.group, name: it.archivesBaseName, version: it.version)
+            }
         }
     }
 }
+

chat/src/main/java/glitch/chat/Configuration.java

@@ -31,11 +31,6 @@ public class Configuration {
 //        });
     }
 
-    // TODO: Kraken API
-//    public Mono<GlobalUserState> getBotGlobalUserState() {
-//        return chat.getApi().getGlobalUserState(botCredentials);
-//    }
-
     public Mono<Long> getChatLimits(boolean moderator) {
         return Mono.delay(rateLimits.getChatDuration(moderator));
     }

chat/src/main/java/glitch/chat/GlitchChat.java

@@ -127,7 +127,10 @@ private void compose() {
     }
 
     private void doWhisperRateLimit() {
-        configuration.getWhisperLimits().subscribe(limit -> this.whispers = CacheBuilder.newBuilder().maximumSize(limit.getT2()).expireAfterWrite(Duration.ofMillis(limit.getT1())).build());
+        configuration.getWhisperLimits()
+                .subscribe(limit -> this.whispers = CacheBuilder.newBuilder()
+                        .maximumSize(limit.getT2())
+                        .expireAfterWrite(Duration.ofMillis(limit.getT1())).build());
     }
 
     private Mono<ChannelEntity> getChannel(String name, boolean join) {

chat/src/main/java/glitch/chat/IrcConverter.java

@@ -2,10 +2,9 @@
 
 import glitch.api.ws.Converter;
 import glitch.api.ws.events.IEvent;
-import glitch.chat.events.ChannelMessageEvent;
-import glitch.chat.events.JoinUserChannelEvent;
-import glitch.chat.events.PartUserChannelEvent;
-import glitch.chat.events.RawIrcEvent;
+import glitch.api.ws.events.PingEvent;
+import glitch.api.ws.events.PongEvent;
+import glitch.chat.events.*;
 import glitch.chat.object.irc.Command;
 import glitch.chat.object.irc.Message;
 import glitch.chat.object.irc.Prefix;
@@ -30,42 +29,45 @@ private Message toMessage(String raw) {
                 return toMessage(l);
             }
         }
-
+        String[] splitRawMsg = Arrays.copyOf(raw.split(" :", 3), 3);
         Message.Builder rawMsg = Message.builder().rawMessage(raw);
 
-        boolean trailingLocked = false;
+        if (splitRawMsg[0].startsWith("@")) {
+            String rawTag = splitRawMsg[0].substring(1, splitRawMsg[0].indexOf(" "));
+            Map<String, String> tags = new LinkedHashMap<>();
+            Arrays.stream(rawTag.split(";"))
+                    .map(tag -> Arrays.copyOf(tag.split("=", 2), 2))
+                    .map(entry -> new AbstractMap.SimpleImmutableEntry<>(entry[0], entry[1]))
+                    .forEach(tag -> {
+                        String value = tag.getValue();
+                        if (value.contains("\\r")) value = value.replace("\\r", "\r");
+                        if (value.contains("\\n")) value = value.replace("\\n", "\n");
+                        if (value.contains("\\\\")) value = value.replace("\\\\", "\\");
+                        if (value.contains("\\s")) value = value.replace("\\s", " ");
+                        if (value.contains("\\:")) value = value.replace("\\:", ":");
 
-        for (String part : raw.split(" ")) {
-            if (part.startsWith("@") && !trailingLocked) {
-                Map<String, String> tags = new LinkedHashMap<>();
-                Arrays.stream(part.substring(1).split(";"))
-                        .map(tag -> tag.split("=", 2))
-                        .map(entry -> new AbstractMap.SimpleImmutableEntry<>(entry[0], entry[1]))
-                        .forEach(tag -> {
-                            String value = tag.getValue();
-                            if (value.contains("\\r")) value = value.replace("\\r", "\r");
-                            if (value.contains("\\n")) value = value.replace("\\n", "\n");
-                            if (value.contains("\\\\")) value = value.replace("\\\\", "\\");
-                            if (value.contains("\\s")) value = value.replace("\\s", " ");
-                            if (value.contains("\\:")) value = value.replace("\\:", ":");
+                        if (tag.getKey() != null && !tag.getKey().equals("")) {
+                            tags.put(tag.getKey(), value);
+                        }
+                    });
+            rawMsg.tags(Tags.of(tags));
 
-                            if (tag.getKey() != null && !tag.getKey().equals("")) {
-                                tags.put(tag.getKey(), value);
-                            }
-                        });
-                rawMsg.tags(Tags.of(tags));
-            } else if (part.startsWith(":")) {
-                if (part.matches("^:(.+)(!.+)*?(@.+)*?$")) {
-                    rawMsg.prefix(Prefix.fromRaw(part));
-                } else {
-                    trailingLocked = true;
-                    rawMsg.trailing(raw.substring(raw.indexOf(part) + 1));
-                }
+            splitRawMsg[0] = splitRawMsg[1].trim();
+
+            if (splitRawMsg.length > 2) {
+                splitRawMsg[1] = splitRawMsg[2].trim();
+            }
+        }
+
+        rawMsg.trailing(splitRawMsg[1]);
+
+        for (String part : splitRawMsg[0].split(" ", 3)) {
+            if (part.matches("^(.+)(!.+)*?(@.+)*?$")) {
+                rawMsg.prefix(Prefix.fromRaw(part));
             } else if (part.matches("^([A-Z]+|[0-9]{1,3})")) {
                 rawMsg.command(Command.of(part));
             } else {
-                if (!trailingLocked)
-                    rawMsg.middle(part);
+                rawMsg.middle(Arrays.asList(part.split(" ")));
             }
         }
 
@@ -80,7 +82,51 @@ private IEvent<GlitchChat> doConvert(Message message, GlitchChat chat) {
                 return new PartUserChannelEvent(chat, message);
             case PRIV_MSG:
                 return new ChannelMessageEvent(chat, message);
-            case UNKNOWN:
+            case CLEAR_CHAT:
+                if (message.getTrailing() != null) {
+                    if (message.getTags().containsKey("ban-duration")) {
+                        return new ChannelTimeoutEvent(chat, message);
+                    } else {
+                        return new ChannelBanEvent(chat, message);
+                    }
+                } else {
+                    return new ChannelClearChatEvent(chat, message);
+                }
+            case CLEAR_MESSAGE:
+                return new ChannelDeleteMessageEvent(chat, message);
+            case PING:
+                return new PingEvent<>(chat);
+            case PONG:
+                return new PongEvent<>(chat);
+            case GLOBAL_USER_STATE:
+                return new GlobalUserStateEvent(chat, message);
+            case NOTICE:
+                return new ChannelNoticeEvent(chat, message);
+            case ROOM_STATE:
+                if (message.getTags().size() > 1) {
+                    return new ChannelStateEvent(chat, message);
+                } else {
+                    return new ChannelStateChangedEvent(chat, message);
+                }
+            case USER_NOTICE:
+                return doUserNotice(chat, message);
+            case USER_STATE:
+                return new ChannelUserStateEvent(chat, message);
+            default:
+                return new RawIrcEvent(chat, message);
+        }
+    }
+
+    private IEvent<GlitchChat> doUserNotice(GlitchChat chat, Message message) {
+        switch (message.getTags().get("msg-id")) {
+            case "sub":
+                return new ChannelSubscriptionEvent(chat, message);
+            case "resub":
+                return new ChannelResubEvent(chat, message);
+            case "raid":
+                return new ChannelRaidEvent(chat, message);
+            case "ritual":
+                return new ChannelNewChatterEvent(chat, message);
             default:
                 return new RawIrcEvent(chat, message);
         }

chat/src/main/java/glitch/chat/events/ChannelBanEvent.java

@@ -0,0 +1,28 @@
+package glitch.chat.events;
+
+import glitch.api.ws.events.AbstractEvent;
+import glitch.api.ws.events.IEvent;
+import glitch.chat.GlitchChat;
+import glitch.chat.object.entities.ChannelEntity;
+import glitch.chat.object.entities.ChannelUserEntity;
+import glitch.chat.object.irc.Message;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import reactor.core.publisher.Mono;
+
+import java.util.Optional;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ChannelBanEvent extends AbstractEvent<GlitchChat> implements IEvent<GlitchChat> {
+    private final Mono<ChannelUserEntity> user;
+    private final Mono<ChannelEntity> channel;
+    private final Optional<String> reason;
+
+    public ChannelBanEvent(GlitchChat client, Message message) {
+        super(client);
+        this.channel = client.getChannel(message.getMiddle().get(0).substring(1));
+        this.user = this.channel.flatMap(c -> c.getUser(message.getTrailing()));
+        this.reason = Optional.ofNullable(message.getTags().getOrDefault("ban-reason", null));
+    }
+}

chat/src/main/java/glitch/chat/events/ChannelBitsMessageEvent.java

@@ -0,0 +1,18 @@
+package glitch.chat.events;
+
+import glitch.api.ws.events.IEvent;
+import glitch.chat.GlitchChat;
+import glitch.chat.object.irc.Message;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ChannelBitsMessageEvent extends ChannelMessageEvent implements IEvent<GlitchChat> {
+    private final int bits;
+
+    public ChannelBitsMessageEvent(GlitchChat client, Message message) {
+        super(client, message);
+        this.bits = message.getTags().getInteger("bits");
+    }
+}

chat/src/main/java/glitch/chat/events/ChannelClearChatEvent.java

@@ -0,0 +1,21 @@
+package glitch.chat.events;
+
+import glitch.api.ws.events.AbstractEvent;
+import glitch.api.ws.events.IEvent;
+import glitch.chat.GlitchChat;
+import glitch.chat.object.entities.ChannelEntity;
+import glitch.chat.object.irc.Message;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import reactor.core.publisher.Mono;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ChannelClearChatEvent extends AbstractEvent<GlitchChat> implements IEvent<GlitchChat> {
+    private final Mono<ChannelEntity> channel;
+
+    public ChannelClearChatEvent(GlitchChat client, Message message) {
+        super(client);
+        this.channel = client.getChannel(message.getMiddle().get(0).substring(1));
+    }
+}

chat/src/main/java/glitch/chat/events/ChannelDeleteMessageEvent.java

@@ -0,0 +1,30 @@
+package glitch.chat.events;
+
+import glitch.api.ws.events.AbstractEvent;
+import glitch.api.ws.events.IEvent;
+import glitch.chat.GlitchChat;
+import glitch.chat.object.entities.ChannelEntity;
+import glitch.chat.object.entities.ChannelUserEntity;
+import glitch.chat.object.irc.Message;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import reactor.core.publisher.Mono;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ChannelDeleteMessageEvent extends AbstractEvent<GlitchChat> implements IEvent<GlitchChat> {
+    private final Mono<ChannelEntity> channel;
+    private final Mono<ChannelUserEntity> user;
+    private final String message;
+    private final String targetId;
+    private final boolean actionMessage;
+
+    public ChannelDeleteMessageEvent(GlitchChat client, Message message) {
+        super(client);
+        this.channel = client.getChannel(message.getMiddle().get(0).substring(1));
+        this.user = this.channel.flatMap(c -> c.getUser(message.getTags().get("login")));
+        this.message = message.getFormattedTrailing();
+        this.targetId = message.getTags().get("target-msg-id");
+        this.actionMessage = message.isActionMessage();
+    }
+}

chat/src/main/java/glitch/chat/events/ChannelHostEvent.java

@@ -0,0 +1,26 @@
+package glitch.chat.events;
+
+import glitch.api.ws.events.AbstractEvent;
+import glitch.api.ws.events.IEvent;
+import glitch.chat.GlitchChat;
+import glitch.chat.object.entities.ChannelEntity;
+import glitch.chat.object.entities.UserEntity;
+import glitch.chat.object.irc.Message;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import reactor.core.publisher.Mono;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ChannelHostEvent extends AbstractEvent<GlitchChat> implements IEvent<GlitchChat> {
+    private final Mono<ChannelEntity> channel;
+    private final Mono<UserEntity> hostedChannel;
+    private final int numberOfViews;
+
+    public ChannelHostEvent(GlitchChat client, Message message) {
+        super(client);
+        this.channel = client.getChannel(message.getMiddle().get(0).substring(1));
+        this.hostedChannel = client.getUser(message.getMiddle().get(1));
+        this.numberOfViews = Integer.parseInt(message.getMiddle().get(2));
+    }
+}

chat/src/main/java/glitch/chat/events/ChannelMessageEvent.java

@@ -2,6 +2,7 @@
 
 import com.google.common.collect.ImmutableSet;
 import glitch.api.objects.json.Badge;
+import glitch.api.objects.json.interfaces.IDObject;
 import glitch.api.ws.events.AbstractEvent;
 import glitch.api.ws.events.IEvent;
 import glitch.chat.GlitchChat;
@@ -14,17 +15,25 @@
 
 @Data
 @EqualsAndHashCode(callSuper = true)
-public class ChannelMessageEvent extends AbstractEvent<GlitchChat> implements IEvent<GlitchChat> {
+public class ChannelMessageEvent extends AbstractEvent<GlitchChat> implements IEvent<GlitchChat>, IDObject<String> {
     private final Mono<ChannelEntity> channel;
     private final Mono<ChannelUserEntity> user;
     private final String content;
     private final ImmutableSet<Badge> badges;
+    private final boolean actionMessage;
+    private final String id;
 
     public ChannelMessageEvent(GlitchChat client, Message message) {
         super(client, message.getTags().getSentTimestamp());
-        this.content = message.getTrailing();
+        this.content = message.getFormattedTrailing();
         this.channel = client.getChannel(message.getMiddle().get(0).substring(1));
         this.badges = message.getTags().getBadges();
         this.user = this.channel.map(c -> new ChannelUserEntity(c, message.getPrefix().getNick(), badges));
+        this.actionMessage = message.isActionMessage();
+        this.id = message.getTags().get("id");
+    }
+
+    public Mono<Void> deleteMessage() {
+        return this.channel.flatMap(e -> e.moderate().delete(this.id));
     }
 }