feat(#4846): Implement simple cache mechanism for EO compilation

Author: volodya-lombrozo

eo-maven-plugin/src/main/java/org/eolang/maven/Cache.java

@@ -0,0 +1,94 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2016-2026 Objectionary.com
+ * SPDX-License-Identifier: MIT
+ */
+package org.eolang.maven;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Base64;
+import org.cactoos.Func;
+import org.cactoos.func.UncheckedFunc;
+
+/**
+ * Simple cache mechanism.
+ * @since 0.60
+ */
+final class Cache {
+
+    /**
+     * Base cache directory.
+     */
+    private final Path base;
+
+    /**
+     * Compilation function.
+     */
+    private final Func<Path, String> compilation;
+
+    /**
+     * Ctor.
+     * @param base Base cache directory
+     * @param compilation Compilation function
+     */
+    Cache(final Path base, final Func<Path, String> compilation) {
+        this.base = base;
+        this.compilation = compilation;
+    }
+
+    /**
+     * Check cache and apply compilation if needed.
+     * @param source From file
+     * @param target To file
+     * @param tail Tail path in cache
+     */
+    public void apply(final Path source, final Path target, final Path tail) {
+        try {
+            final String hash = Cache.sha(source);
+            final Path hfile = this.hash(tail);
+            final Path cfile = this.base.resolve(tail);
+            if (Files.notExists(hfile) || !Files.readString(hfile).equals(hash)) {
+                final String content = new UncheckedFunc<>(this.compilation).apply(source);
+                Files.writeString(this.hash(tail), hash);
+                Files.writeString(cfile, content);
+                Files.writeString(target, content);
+            } else {
+                Files.writeString(target, Files.readString(cfile));
+            }
+        } catch (final IOException ioexception) {
+            throw new IllegalStateException(
+                "Failed to perform an IO operation with cache",
+                ioexception
+            );
+        } catch (final NoSuchAlgorithmException exception) {
+            throw new IllegalStateException("SHA-256 hashing algorithm isn't found", exception);
+        }
+    }
+
+    /**
+     * Get hash file path for the given tail.
+     * @param tail Tail path
+     * @return Hash file path
+     */
+    private Path hash(final Path tail) {
+        final Path full = this.base.resolve(tail);
+        return full.getParent().resolve(String.format("%s.sha256", full.getFileName().toString()));
+    }
+
+    /**
+     * Calculate SHA-256 hash of a file and return it as Base64 string.
+     * @param file File path
+     * @return Base64-encoded SHA-256 hash
+     * @throws NoSuchAlgorithmException If SHA-256 algorithm is not available
+     * @throws IOException If an I/O error occurs reading the file
+     */
+    private static String sha(final Path file) throws NoSuchAlgorithmException, IOException {
+        final MessageDigest digest = MessageDigest.getInstance("SHA-256");
+        final byte[] hash = digest.digest(Files.readAllBytes(file));
+        return Base64.getEncoder().encodeToString(hash);
+    }
+}
+

eo-maven-plugin/src/test/java/org/eolang/maven/CacheTest.java

@@ -0,0 +1,104 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2016-2026 Objectionary.com
+ * SPDX-License-Identifier: MIT
+ */
+package org.eolang.maven;
+
+import com.yegor256.Mktmp;
+import com.yegor256.MktmpResolver;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.hamcrest.MatcherAssert;
+import org.hamcrest.Matchers;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * Test for {@link Cache}.
+ * @since 0.60
+ */
+@ExtendWith(MktmpResolver.class)
+final class CacheTest {
+
+    @Test
+    void compilesSourceAndAddsToCache(@Mktmp final Path temp) throws Exception {
+        final var base = temp.resolve("cache");
+        Files.createDirectories(base);
+        final var source = temp.resolve("source.eo");
+        Files.writeString(source, "[] > main\n  (stdout \"Hello, EO!\") > @\n");
+        final var target = temp.resolve("target.xmir");
+        final var tail = source.getFileName();
+        final String content = "compiled";
+        new Cache(base, p -> content).apply(source, target, tail);
+        MatcherAssert.assertThat(
+            "Target file must be created from source",
+            Files.readString(target),
+            Matchers.equalTo(content)
+        );
+        MatcherAssert.assertThat(
+            "Cache file must be created",
+            Files.exists(base.resolve(tail)),
+            Matchers.is(true)
+        );
+        MatcherAssert.assertThat(
+            "Hash file must be created",
+            Files.exists(base.resolve(String.format("%s.sha256", tail))),
+            Matchers.is(true)
+        );
+    }
+
+    @Test
+    void readsFromCacheWhenUnchanged(@Mktmp final Path temp) throws Exception {
+        final var base = temp.resolve("cache-directory");
+        Files.createDirectories(base);
+        final var source = temp.resolve("stdin.eo");
+        Files.writeString(source, "[] > main\n  (stdout \"Hello, EO!\") > @\n");
+        final var target = temp.resolve("stdin.xmir");
+        final var counter = new AtomicInteger(0);
+        final var cache = new Cache(
+            base,
+            p -> String.format("stdin %d", counter.incrementAndGet())
+        );
+        final Path tail = source.getFileName();
+        cache.apply(source, target, tail);
+        MatcherAssert.assertThat(
+            "Compilation should happen only once",
+            counter.get(),
+            Matchers.equalTo(1)
+        );
+        cache.apply(source, target, tail);
+        MatcherAssert.assertThat(
+            "Compilation should not happen again",
+            counter.get(),
+            Matchers.equalTo(1)
+        );
+    }
+
+    @Test
+    void compilesAgainWhenChanged(@Mktmp final Path temp) throws Exception {
+        final var base = temp.resolve("cache-base-dir");
+        Files.createDirectories(base);
+        final var source = temp.resolve("stdout.eo");
+        Files.writeString(source, "[] > main\n  (stdout \"Hello, EO!\") > @\n");
+        final var target = temp.resolve("stdout.xmir");
+        final var counter = new AtomicInteger(0);
+        final var cache = new Cache(
+            base,
+            p -> String.format("compiled %d", counter.incrementAndGet())
+        );
+        cache.apply(source, target, source.getFileName());
+        MatcherAssert.assertThat(
+            "Compilation should happen once",
+            counter.get(),
+            Matchers.equalTo(1)
+        );
+        Files.writeString(source, "[] > main\n  (stdout \"Hello, EO! Modified\") > @\n");
+        cache.apply(source, target, source.getFileName());
+        MatcherAssert.assertThat(
+            "Compilation should happen again after source change",
+            counter.get(),
+            Matchers.equalTo(2)
+        );
+    }
+}