Merge pull request #4847 from volodya-lombrozo/4846-new-cache

feat(#4846): implement a simple caching mechanism in the Maven plugin

Author: yegor256

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

@@ -0,0 +1,112 @@
+/*
+ * 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
+ * @todo #4846:30min Make Cache thread-safe.
+ *  The Cache class lacks thread-safety mechanisms. If multiple threads call the apply method
+ *  concurrently with the same source file, there could be race conditions where both threads
+ *  determine the cache is stale and attempt to write simultaneously, potentially leading to
+ *  corrupted files or inconsistent state. Consider adding synchronization or using atomic file
+ *  operations. See ChCachedTest.java:63-86 for an example of how concurrency is tested in similar
+ *  caching classes in this codebase.
+ * @todo #4846:30min Replace {@link FpDefault} with {@link Cache}.
+ *  The FpDefault class currently implements caching logic that is similar to the Cache class.
+ *  Refactor the codebase to use Cache instead of FpDefault for caching functionality to
+ *  improve code reuse and maintainability.
+ */
+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 sha = Cache.sha(source);
+            final Path hash = this.hash(tail);
+            final Path cache = this.base.resolve(tail);
+            if (Files.notExists(hash)
+                || Files.notExists(cache)
+                || !Files.readString(hash).equals(sha)) {
+                final String content = new UncheckedFunc<>(this.compilation).apply(source);
+                new Saved(sha, this.hash(tail)).value();
+                new Saved(content, cache).value();
+                new Saved(content, target).value();
+            } else {
+                new Saved(Files.readString(cache), target).value();
+            }
+        } 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.normalize());
+        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
+     * @todo #4846:30min OutOfMemoryError for large files in cache.
+     *  The sha method reads the entire file into memory using Files.readAllBytes(file) which
+     *  could cause OutOfMemoryError for large files. Consider using a streaming approach with
+     *  MessageDigest.update() in a loop to hash the file in chunks, similar to how it's typically
+     *  done for large file hashing operations.
+     */
+    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,81 @@
+/*
+ * 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
+ * @todo #4846:30min Add more tests for Cache class.
+ *  Currently only two basic tests are implemented. More tests should be added to cover edge cases
+ *  and ensure robustness of the caching mechanism.
+ *  For example, you can add a test to verify the behavior when the source file is modified.
+ */
+@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)
+        );
+    }
+}