Removed now obsolete curlies and java:S1602

Zabuzard · Zabuzard · commit 2087bfd4a0f0 · 2021-11-18T19:51:16.000+01:00
diff --git a/application/src/main/java/org/togetherjava/tjbot/commands/basic/DatabaseCommand.java b/application/src/main/java/org/togetherjava/tjbot/commands/basic/DatabaseCommand.java
@@ -85,12 +85,12 @@ private void handleGetCommand(@NotNull CommandInteraction event) {
         // /db get hello
         String key = Objects.requireNonNull(event.getOption(KEY_OPTION)).getAsString();
         try {
-            Optional<String> value = database.read(context -> {
-                try (var select = context.selectFrom(Storage.STORAGE)) {
-                    return Optional.ofNullable(select.where(Storage.STORAGE.KEY.eq(key)).fetchOne())
-                        .map(StorageRecord::getValue);
-                }
-            });
+            Optional<String> value = database.read(
+                    context -> Optional
+                        .ofNullable(context.selectFrom(Storage.STORAGE)
+                            .where(Storage.STORAGE.KEY.eq(key))
+                            .fetchOne())
+                        .map(StorageRecord::getValue));
             if (value.isEmpty()) {
                 event.reply("Nothing found for the key '" + key + "'").setEphemeral(true).queue();
                 return;
diff --git a/application/src/main/java/org/togetherjava/tjbot/commands/componentids/ComponentIdStore.java b/application/src/main/java/org/togetherjava/tjbot/commands/componentids/ComponentIdStore.java
@@ -210,16 +210,13 @@ public void putOrThrow(@NotNull UUID uuid, @NotNull ComponentId componentId,
         }
     }
 
-    @SuppressWarnings({"resource", "java:S1602"})
     private @NotNull Optional<ComponentId> getFromDatabase(@NotNull UUID uuid) {
-        return database.read(context -> {
-            return Optional
-                .ofNullable(context.selectFrom(ComponentIds.COMPONENT_IDS)
-                    .where(ComponentIds.COMPONENT_IDS.UUID.eq(uuid.toString()))
-                    .fetchOne())
-                .map(ComponentIdsRecord::getComponentId)
-                .map(ComponentIdStore::deserializeComponentId);
-        });
+        return database.read(context -> Optional
+            .ofNullable(context.selectFrom(ComponentIds.COMPONENT_IDS)
+                .where(ComponentIds.COMPONENT_IDS.UUID.eq(uuid.toString()))
+                .fetchOne())
+            .map(ComponentIdsRecord::getComponentId)
+            .map(ComponentIdStore::deserializeComponentId));
     }
 
     /**
@@ -230,16 +227,14 @@ public void putOrThrow(@NotNull UUID uuid, @NotNull ComponentId componentId,
      * @param uuid the uuid to heat
      * @throws IllegalArgumentException if there is no, or multiple, records associated to that UUID
      */
-    @SuppressWarnings({"resource", "java:S1602"})
     private void heatRecord(@NotNull UUID uuid) {
         int updatedRecords;
         synchronized (storeLock) {
-            updatedRecords = database.writeAndProvide(context -> {
-                return context.update(ComponentIds.COMPONENT_IDS)
-                    .set(ComponentIds.COMPONENT_IDS.LAST_USED, Instant.now())
-                    .where(ComponentIds.COMPONENT_IDS.UUID.eq(uuid.toString()))
-                    .execute();
-            });
+            updatedRecords =
+                    database.writeAndProvide(context -> context.update(ComponentIds.COMPONENT_IDS)
+                        .set(ComponentIds.COMPONENT_IDS.LAST_USED, Instant.now())
+                        .where(ComponentIds.COMPONENT_IDS.UUID.eq(uuid.toString()))
+                        .execute());
         }
 
         // NOTE Case 0, where no records are updated, is ignored on purpose.
@@ -255,7 +250,6 @@ private void evictDatabase() {
         AtomicInteger evictedCounter = new AtomicInteger(0);
         synchronized (storeLock) {
             database.write(context -> {
-                @SuppressWarnings("resource")
                 Result<ComponentIdsRecord> oldRecords = context
                     .selectFrom(ComponentIds.COMPONENT_IDS)
                     .where(ComponentIds.COMPONENT_IDS.LIFESPAN.notEqual(Lifespan.PERMANENT.name())
@@ -317,13 +311,11 @@ private void logDebugSizeStatistics() {
             return;
         }
 
-        // Without curly braces on the lambda, the call would be ambiguous
-        @SuppressWarnings("java:S1602")
         Map<Lifespan, Integer> lifespanToCount = Arrays.stream(Lifespan.values())
-            .collect(Collectors.toMap(Function.identity(), lifespan -> database.read(context -> {
-                return context.fetchCount(ComponentIds.COMPONENT_IDS,
-                        ComponentIds.COMPONENT_IDS.LIFESPAN.eq(lifespan.name()));
-            })));
+            .collect(Collectors.toMap(Function.identity(),
+                    lifespan -> database
+                        .read(context -> context.fetchCount(ComponentIds.COMPONENT_IDS,
+                                ComponentIds.COMPONENT_IDS.LIFESPAN.eq(lifespan.name())))));
         int recordsCount = lifespanToCount.values().stream().mapToInt(Integer::intValue).sum();
 
         logger.debug("The component id store consists of {} records ({})", recordsCount,
diff --git a/application/src/main/java/org/togetherjava/tjbot/commands/tags/TagSystem.java b/application/src/main/java/org/togetherjava/tjbot/commands/tags/TagSystem.java
@@ -80,11 +80,9 @@ boolean handleIsUnknownTag(@NotNull String id, @NotNull Interaction event) {
      * @return whether the tag is known to the tag system
      */
     boolean hasTag(String id) {
-        return database.readTransaction(context -> {
-            try (var selectFrom = context.selectFrom(Tags.TAGS)) {
-                return selectFrom.where(Tags.TAGS.ID.eq(id)).fetchOne() != null;
-            }
-        });
+        return database.readTransaction(context -> context.selectFrom(Tags.TAGS)
+            .where(Tags.TAGS.ID.eq(id))
+            .fetchOne() != null);
     }
 
     /**
@@ -94,12 +92,9 @@ boolean hasTag(String id) {
      * @throws IllegalArgumentException if the tag is unknown to the system, see
      *         {@link #hasTag(String)}
      */
-    // Execute closes resources; without curly braces on the lambda, the call would be ambiguous
-    @SuppressWarnings({"resource", "java:S1602"})
     void deleteTag(String id) {
-        int deletedRecords = database.writeAndProvide(context -> {
-            return context.deleteFrom(Tags.TAGS).where(Tags.TAGS.ID.eq(id)).execute();
-        });
+        int deletedRecords = database.writeAndProvide(
+                context -> context.deleteFrom(Tags.TAGS).where(Tags.TAGS.ID.eq(id)).execute());
         if (deletedRecords == 0) {
             throw new IllegalArgumentException(
                     "Unable to delete the tag '%s', it is unknown to the system".formatted(id));
@@ -113,15 +108,13 @@ void deleteTag(String id) {
      * @param content the content of the tag to put
      */
     // Execute closes resources; without curly braces on the lambda, the call would be ambiguous
-    @SuppressWarnings({"resource", "java:S1602"})
     void putTag(String id, String content) {
-        database.writeTransaction(context -> {
-            context.insertInto(Tags.TAGS, Tags.TAGS.ID, Tags.TAGS.CONTENT)
-                .values(id, content)
-                .onDuplicateKeyUpdate()
-                .set(Tags.TAGS.CONTENT, content)
-                .execute();
-        });
+        database.writeTransaction(
+                context -> context.insertInto(Tags.TAGS, Tags.TAGS.ID, Tags.TAGS.CONTENT)
+                    .values(id, content)
+                    .onDuplicateKeyUpdate()
+                    .set(Tags.TAGS.CONTENT, content)
+                    .execute());
     }
 
     /**
@@ -132,12 +125,9 @@ void putTag(String id, String content) {
      * @return the content of the tag, if the tag is known to the system
      */
     Optional<String> getTag(String id) {
-        return database.readTransaction(context -> {
-            try (var selectFrom = context.selectFrom(Tags.TAGS)) {
-                return Optional.ofNullable(selectFrom.where(Tags.TAGS.ID.eq(id)).fetchOne())
-                    .map(TagsRecord::getContent);
-            }
-        });
+        return database.readTransaction(context -> Optional
+            .ofNullable(context.selectFrom(Tags.TAGS).where(Tags.TAGS.ID.eq(id)).fetchOne())
+            .map(TagsRecord::getContent));
     }
 
     /**
@@ -146,14 +136,11 @@ Optional<String> getTag(String id) {
      * @return a set of all ids known to the system, not backed
      */
     Set<String> getAllIds() {
-        return database.readTransaction(context -> {
-            try (var select = context.select(Tags.TAGS.ID)) {
-                return select.from(Tags.TAGS)
-                    .fetch()
-                    .stream()
-                    .map(dbRecord -> dbRecord.getValue(Tags.TAGS.ID))
-                    .collect(Collectors.toSet());
-            }
-        });
+        return database.readTransaction(context -> context.select(Tags.TAGS.ID)
+            .from(Tags.TAGS)
+            .fetch()
+            .stream()
+            .map(dbRecord -> dbRecord.getValue(Tags.TAGS.ID))
+            .collect(Collectors.toSet()));
     }
 }
diff --git a/application/src/main/java/org/togetherjava/tjbot/routines/ModAuditLogRoutine.java b/application/src/main/java/org/togetherjava/tjbot/routines/ModAuditLogRoutine.java
@@ -259,15 +259,15 @@ private void checkAuditLogsRoutine() {
     private void handleAuditLogs(@NotNull MessageChannel auditLogChannel,
             @NotNull PaginationAction<? extends AuditLogEntry, AuditLogPaginationAction> auditLogAction,
             long guildId) {
-        @SuppressWarnings("squid:S1602")
-        Instant lastAuditLogEntryTimestamp = database.read(context -> {
-            return Optional
-                .ofNullable(context.fetchOne(ModAuditLogGuildProcess.MOD_AUDIT_LOG_GUILD_PROCESS,
-                        ModAuditLogGuildProcess.MOD_AUDIT_LOG_GUILD_PROCESS.GUILD_ID.eq(guildId)))
-                .map(entry -> entry.get(
-                        ModAuditLogGuildProcess.MOD_AUDIT_LOG_GUILD_PROCESS.LAST_PROCESSED_AUDIT_LOG_ENTRY))
-                .orElse(Instant.now());
-        });
+        Instant lastAuditLogEntryTimestamp =
+                database.read(context -> Optional
+                    .ofNullable(context.fetchOne(
+                            ModAuditLogGuildProcess.MOD_AUDIT_LOG_GUILD_PROCESS,
+                            ModAuditLogGuildProcess.MOD_AUDIT_LOG_GUILD_PROCESS.GUILD_ID
+                                .eq(guildId)))
+                    .map(entry -> entry.get(
+                            ModAuditLogGuildProcess.MOD_AUDIT_LOG_GUILD_PROCESS.LAST_PROCESSED_AUDIT_LOG_ENTRY))
+                    .orElse(Instant.now()));
         // NOTE This is a minor race condition. By taking the time before the actual lookup we
         // ensure that we do not miss anything but instead it is possible to receive an
         // action twice in such a rare case, which is okay.
diff --git a/application/src/test/java/org/togetherjava/tjbot/commands/basic/DatabaseCommandTest.java b/application/src/test/java/org/togetherjava/tjbot/commands/basic/DatabaseCommandTest.java
@@ -43,9 +43,7 @@ private static SlashCommandEvent createPut(@NotNull String key, @NotNull String
     void setupDatabase() throws SQLException {
         // TODO This has to be done dynamically by the Flyway script, adjust gradle test settings
         database = new Database("jdbc:sqlite:");
-        database.write(context -> {
-            context.ddl(Storage.STORAGE).executeBatch();
-        });
+        database.write(context -> context.ddl(Storage.STORAGE).executeBatch());
     }
 
     @Test
@@ -131,11 +129,11 @@ void getOrPutWithNoTable() throws SQLException {
     }
 
     private void assertValueInDatabase(@NotNull String key, @NotNull String value) {
-        Result<Record1<String>> results = database.read(context -> {
-            try (var select = context.select(Storage.STORAGE.VALUE)) {
-                return select.from(Storage.STORAGE).where(Storage.STORAGE.KEY.eq(key)).fetch();
-            }
-        });
+        Result<Record1<String>> results =
+                database.read(context -> context.select(Storage.STORAGE.VALUE)
+                    .from(Storage.STORAGE)
+                    .where(Storage.STORAGE.KEY.eq(key))
+                    .fetch());
         assertEquals(1, results.size());
         assertEquals(value, results.get(0).get(Storage.STORAGE.VALUE));
     }
diff --git a/logviewer/src/main/java/org/togetherjava/tjbot/logwatcher/logs/LogRepositoryImpl.java b/logviewer/src/main/java/org/togetherjava/tjbot/logwatcher/logs/LogRepositoryImpl.java
@@ -44,22 +44,16 @@ public void save(Logevents event) {
     }
 
     @Override
-    @SuppressWarnings("java:S1602") // Curly Braces are necessary here
     public List<Logevents> findAll() {
-        return this.db.read(ctx -> {
-            return ctx.selectFrom(LOGEVENTS).fetch(this::recordToPojo);
-        });
+        return this.db.read(ctx -> ctx.selectFrom(LOGEVENTS).fetch(this::recordToPojo));
     }
 
 
     @Override
-    @SuppressWarnings("java:S1602") // Curly Braces are necessary here
     public List<Logevents> findWithLevelMatching(Collection<String> logLevels) {
-        return this.db.read(ctx -> {
-            return ctx.selectFrom(LOGEVENTS)
-                .where(LOGEVENTS.LEVEL.in(logLevels))
-                .fetch(this::recordToPojo);
-        });
+        return this.db.read(ctx -> ctx.selectFrom(LOGEVENTS)
+            .where(LOGEVENTS.LEVEL.in(logLevels))
+            .fetch(this::recordToPojo));
     }
 
     private Logevents recordToPojo(final LogeventsRecord logRecord) {
diff --git a/logviewer/src/main/java/org/togetherjava/tjbot/logwatcher/users/UserRepositoryImpl.java b/logviewer/src/main/java/org/togetherjava/tjbot/logwatcher/users/UserRepositoryImpl.java
@@ -15,7 +15,6 @@
 import static org.togetherjava.tjbot.db.generated.tables.Users.USERS;
 
 @Component
-@SuppressWarnings("java:S1602") // Curly Braces are necessary here
 public class UserRepositoryImpl implements UserRepository {
 
     private final Database db;
@@ -26,60 +25,48 @@ public UserRepositoryImpl(Database db) {
 
     @Override
     public Users findByDiscordID(long discordID) {
-        return this.db.readTransaction(ctx -> {
-            return ctx.selectFrom(USERS)
-                .where(USERS.DISCORDID.eq(discordID))
-                .fetchOne(this::recordToRole);
-        });
+        return this.db.readTransaction(ctx -> ctx.selectFrom(USERS)
+            .where(USERS.DISCORDID.eq(discordID))
+            .fetchOne(this::recordToRole));
     }
 
     @Override
     public Users findByUsername(String username) {
-        return this.db.readTransaction(ctx -> {
-            return ctx.selectFrom(USERS)
-                .where(USERS.USERNAME.eq(username))
-                .fetchOne(this::recordToRole);
-        });
+        return this.db.readTransaction(ctx -> ctx.selectFrom(USERS)
+            .where(USERS.USERNAME.eq(username))
+            .fetchOne(this::recordToRole));
     }
 
     @Override
     public List<Users> findAll() {
-        return this.db.readTransaction(ctx -> {
-            return ctx.selectFrom(USERS).fetch(this::recordToRole);
-        });
+        return this.db.readTransaction(ctx -> ctx.selectFrom(USERS).fetch(this::recordToRole));
     }
 
     @Override
     public int count() {
-        return this.db.readTransaction(ctx -> {
-            return ctx.fetchCount(USERS);
-        });
+        return this.db.readTransaction(ctx -> ctx.fetchCount(USERS));
     }
 
     @Override
     public void save(Users user) {
-        this.db.writeTransaction(ctx -> {
-            ctx.newRecord(USERS)
-                .setDiscordid(user.getDiscordid())
-                .setUsername(user.getUsername())
-                .merge();
-        });
+        this.db.writeTransaction(ctx -> ctx.newRecord(USERS)
+            .setDiscordid(user.getDiscordid())
+            .setUsername(user.getUsername())
+            .merge());
     }
 
     @Override
     public void delete(Users user) {
-        this.db.writeTransaction(ctx -> {
-            ctx.deleteFrom(USERS).where(USERS.DISCORDID.eq(user.getDiscordid())).execute();
-        });
+        this.db.writeTransaction(ctx -> ctx.deleteFrom(USERS)
+            .where(USERS.DISCORDID.eq(user.getDiscordid()))
+            .execute());
     }
 
     @Override
     public Set<Role> fetchRolesForUser(Users user) {
-        return new HashSet<>(this.db.readTransaction(ctx -> {
-            return ctx.selectFrom(Userroles.USERROLES)
-                .where(Userroles.USERROLES.USERID.eq(user.getDiscordid()))
-                .fetch(this::recordToRole);
-        }));
+        return new HashSet<>(this.db.readTransaction(ctx -> ctx.selectFrom(Userroles.USERROLES)
+            .where(Userroles.USERROLES.USERID.eq(user.getDiscordid()))
+            .fetch(this::recordToRole)));
     }
 
     @Override
