feat: add project files

localizationlib/build.gradle.kts

@@ -0,0 +1,72 @@
+plugins {
+    id("java-library")
+    id("maven-publish")
+    id("com.gradleup.shadow") version "9.4.1"
+}
+
+group = providers.gradleProperty("group").get()
+version = providers.gradleProperty("version").get()
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    compileOnly("org.projectlombok:lombok:1.18.46")
+    annotationProcessor("org.projectlombok:lombok:1.18.46")
+
+    implementation("org.jetbrains:annotations:26.1.0")
+    implementation("com.google.code.gson:gson:2.14.0")
+
+    implementation(project(":localizationlib-abstraction"))
+    shadow(project(":localizationlib-abstraction"))
+
+    testImplementation(libs.junit.jupiter)
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+}
+
+java {
+    toolchain.languageVersion = JavaLanguageVersion.of(25)
+}
+
+tasks {
+    build {
+        dependsOn(shadowJar)
+    }
+
+    shadowJar {
+        archiveClassifier.set("")
+        configurations = listOf(project.configurations.shadow.get())
+    }
+
+    named<Test>("test") {
+        useJUnitPlatform()
+    }
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("mavenJava") {
+            from(components["shadow"])
+
+            groupId = project.group.toString()
+            artifactId = project.name
+            version = project.version.toString()
+        }
+    }
+
+    repositories {
+        maven {
+            name = "Reposilite"
+            
+            val releasesUrl = "https://maven.axolotsh.org/releases"
+            val snapshotsUrl = "https://maven.axolotsh.org/snapshots"
+            url = uri(if (version.toString().endsWith("SNAPSHOT")) snapshotsUrl else releasesUrl)
+
+            credentials {
+                username = providers.gradleProperty("reposiliteUser").orNull ?: "admin"
+                password = providers.gradleProperty("reposilitePassword").orNull ?: "password"
+            }
+        }
+    }
+}

localizationlib/src/main/java/org/axolotsh/localizationlib/LocalizationEntry.java

@@ -0,0 +1,32 @@
+package org.axolotsh.localizationlib;
+
+import java.util.Locale;
+
+import org.axolotsh.localizationlib.abstraction.ILocalizationEntry;
+import org.jetbrains.annotations.Nullable;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.experimental.Accessors;
+
+@Getter
+@EqualsAndHashCode
+@Accessors(chain = true, fluent = true)
+@Builder(toBuilder = true)
+@AllArgsConstructor
+public class LocalizationEntry implements ILocalizationEntry {
+    @Nullable
+    private Locale locale;
+
+    @NonNull
+    private String key;
+    @NonNull
+    private String value;
+
+    public LocalizationEntry(String key, String value) {
+        this(null, key, value);
+    }
+}

localizationlib/src/main/java/org/axolotsh/localizationlib/LocalizationFactory.java

@@ -0,0 +1,83 @@
+package org.axolotsh.localizationlib;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+import org.axolotsh.localizationlib.abstraction.ILocalizationEntry;
+import org.axolotsh.localizationlib.abstraction.ILocalizationFactory;
+import org.axolotsh.localizationlib.abstraction.ILocalizationService;
+import org.axolotsh.localizationlib.providers.CollectionProvider;
+import org.axolotsh.localizationlib.providers.ILocalizationEntriesProvider;
+
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+
+@Getter
+@Accessors(chain = true, fluent = true)
+public class LocalizationFactory implements ILocalizationFactory {
+    public static final Locale DEFAULT_LOCALE = Locale.US;
+
+    @Getter(AccessLevel.NONE)
+    private Collection<ILocalizationEntriesProvider> providers;
+
+    private volatile Map<Locale, Map<String, String>> storage = Collections.emptyMap();
+    private Locale defaultLocale = DEFAULT_LOCALE;
+
+    @Builder(toBuilder = true)
+    public LocalizationFactory(Collection<ILocalizationEntriesProvider> providers, Locale defaultLocale) {
+        this.providers = providers != null ? Set.copyOf(providers) : Collections.emptySet();
+
+        if (defaultLocale != null)
+            this.defaultLocale = defaultLocale;
+    }
+
+    public static class LocalizationFactoryBuilder {
+        public LocalizationFactoryBuilder provider(ILocalizationEntry... entries) {
+            return provider(new CollectionProvider(entries));
+        }
+
+        public LocalizationFactoryBuilder provider(ILocalizationEntriesProvider provider) {
+            if (providers == null)
+                providers = new HashSet<>();
+            this.providers.add(provider);
+            return this;
+        }
+    }
+
+    public synchronized LocalizationFactory reloadProviders() {
+        Map<Locale, Map<String, String>> newStorage = new HashMap<>();
+
+        for (ILocalizationEntriesProvider provider : providers) {
+            for (ILocalizationEntry entry : provider.provide()) {
+                var locale = entry.locale() != null ? entry.locale() : defaultLocale;
+
+                newStorage.computeIfAbsent(locale, k -> new HashMap<>())
+                        .put(entry.key(), entry.value());
+            }
+        }
+
+        newStorage.replaceAll((k, v) -> Collections.unmodifiableMap(v));
+        this.storage = Collections.unmodifiableMap(newStorage);
+
+        return this;
+    }
+
+    public ILocalizationService service() {
+        return service(defaultLocale);
+    }
+
+    public ILocalizationService service(Locale locale) {
+        return service(locale, defaultLocale);
+    }
+
+    public ILocalizationService service(Locale locale, Locale fallbackLocale) {
+        return new LocalizationService(this, locale, fallbackLocale);
+    }
+}

localizationlib/src/main/java/org/axolotsh/localizationlib/LocalizationService.java

@@ -0,0 +1,70 @@
+package org.axolotsh.localizationlib;
+
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Optional;
+
+import org.axolotsh.localizationlib.abstraction.ILocalizationService;
+
+import lombok.Getter;
+import lombok.experimental.Accessors;
+
+@Getter
+@Accessors(chain = true, fluent = true)
+public class LocalizationService implements ILocalizationService {
+    private LocalizationFactory factory;
+
+    private Locale locale = LocalizationFactory.DEFAULT_LOCALE;
+
+    private Locale fallbackLocale = LocalizationFactory.DEFAULT_LOCALE;
+
+    LocalizationService(LocalizationFactory factory) {
+        this.factory = factory;
+    }
+
+    LocalizationService(LocalizationFactory factory, Locale locale) {
+        this.factory = factory;
+        this.locale = locale;
+    }
+
+    LocalizationService(LocalizationFactory factory, Locale locale, Locale fallbackLocale) {
+        this.factory = factory;
+        this.locale = locale;
+        this.fallbackLocale = fallbackLocale;
+    }
+
+    public String translate(String key) {
+        return translate(key, locale);
+    }
+
+    public String translate(String key, Locale locale) {
+        var result = get(key, locale);
+
+        if (result.isEmpty()) {
+            if (fallbackLocale == null || Objects.equals(locale, fallbackLocale))
+                return key;
+            return translate(key, fallbackLocale);
+        }
+
+        return result.get();
+    }
+
+    public Optional<String> get(String key) {
+        return get(key, locale);
+    }
+
+    public Optional<String> get(String key, Locale locale) {
+        var storage = factory.storage();
+        var map = storage.get(locale);
+        if (map == null)
+            return Optional.empty();
+
+        var result = map.get(key);
+
+        if (result == null)
+            return Optional.empty();
+
+        return Optional.of(result);
+    }
+
+}

localizationlib/src/main/java/org/axolotsh/localizationlib/providers/CollectionProvider.java

@@ -0,0 +1,31 @@
+package org.axolotsh.localizationlib.providers;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+
+import org.axolotsh.localizationlib.abstraction.ILocalizationEntry;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Singular;
+import lombok.experimental.Accessors;
+
+@Getter
+@Accessors(chain = true, fluent = true)
+@Builder(toBuilder = true)
+public class CollectionProvider implements ILocalizationEntriesProvider {
+    private Collection<ILocalizationEntry> entries;
+
+    public Collection<ILocalizationEntry> provide() {
+        return Collections.unmodifiableCollection(entries);
+    }
+
+    public CollectionProvider(ILocalizationEntry... entries) {
+        this.entries = Set.of(entries);
+    }
+
+    public CollectionProvider(@Singular Collection<ILocalizationEntry> entries) {
+        this.entries = entries;
+    }
+}

localizationlib/src/main/java/org/axolotsh/localizationlib/providers/DirectoryProvider.java

@@ -0,0 +1,67 @@
+package org.axolotsh.localizationlib.providers;
+
+import java.io.File;
+import java.nio.charset.Charset;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+
+import org.axolotsh.localizationlib.abstraction.ILocalizationEntry;
+import org.jetbrains.annotations.Nullable;
+
+import com.google.gson.Gson;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.experimental.Accessors;
+
+@Getter
+@Accessors(chain = true, fluent = true)
+@Builder(toBuilder = true)
+public class DirectoryProvider implements ILocalizationEntriesProvider {
+    @NonNull
+    private File directory;
+    @Builder.Default
+    private Charset charset = Charset.defaultCharset();
+    @Builder.Default
+    private Gson gson = JsonProvider.DEFAULT_GSON;
+
+    @Nullable
+    private Runnable onEmptyInitializer;
+
+    public Collection<ILocalizationEntry> provide() {
+        if (isEmptyDirectory()) {
+            if (onEmptyInitializer == null)
+                return Collections.emptySet();
+            onEmptyInitializer.run();
+        }
+
+        var files = directory.listFiles();
+        Collection<ILocalizationEntry> allEntries = new HashSet<>();
+
+        for (var file : files) {
+            if (file.isFile()) {
+                var fileProvider = FileProvider.builder()
+                        .file(file)
+                        .charset(this.charset)
+                        .gson(this.gson)
+                        .build();
+
+                allEntries.addAll(fileProvider.provide());
+            }
+        }
+
+        return allEntries;
+    }
+
+    private boolean isEmptyDirectory() {
+        if (directory == null || !directory.exists())
+            return true;
+        if (directory.isDirectory()) {
+            var files = directory.listFiles();
+            return files == null || files.length == 0;
+        }
+        return false;
+    }
+}

localizationlib/src/main/java/org/axolotsh/localizationlib/providers/FileProvider.java

@@ -0,0 +1,76 @@
+package org.axolotsh.localizationlib.providers;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Map;
+
+import org.axolotsh.localizationlib.LocalizationEntry;
+import org.axolotsh.localizationlib.abstraction.ILocalizationEntry;
+import org.jetbrains.annotations.Nullable;
+
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+
+@Getter
+@Accessors(chain = true, fluent = true)
+@Builder(toBuilder = true)
+public class FileProvider implements ILocalizationEntriesProvider {
+    private File file;
+    @Builder.Default
+    private Charset charset = Charset.defaultCharset();
+
+    @Nullable
+    private Locale locale;
+
+    @Nullable
+    private Runnable onEmptyInitializer;
+    @Builder.Default
+    private Gson gson = JsonProvider.DEFAULT_GSON;
+
+    public Collection<ILocalizationEntry> provide() {
+        if (isEmptyFile())
+            onEmptyInitializer.run();
+
+        var fileLocale = locale == null ? Locale.forLanguageTag(fileName()) : locale;
+
+        try (var reader = new FileReader(file, charset)) {
+            var mapType = new TypeToken<Map<String, String>>() {
+            }.getType();
+            Map<String, String> map = gson.fromJson(reader, mapType);
+            if (map == null)
+                return Collections.emptySet();
+
+            Collection<ILocalizationEntry> result = new HashSet<>();
+            map.forEach((key, value) -> {
+                result.add(new LocalizationEntry(fileLocale, key, value));
+            });
+
+            return result;
+        } catch (IOException e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
+
+    private String fileName() {
+        var fileName = file.getName();
+        var dotIndex = fileName.lastIndexOf('.');
+
+        return (dotIndex == -1) ? fileName : fileName.substring(0, dotIndex);
+    }
+
+    private boolean isEmptyFile() {
+        if (file == null || !file.exists())
+            return true;
+        return false;
+    }
+}

localizationlib/src/main/java/org/axolotsh/localizationlib/providers/ILocalizationEntriesProvider.java

@@ -0,0 +1,9 @@
+package org.axolotsh.localizationlib.providers;
+
+import java.util.Collection;
+
+import org.axolotsh.localizationlib.abstraction.ILocalizationEntry;
+
+public interface ILocalizationEntriesProvider {
+    public Collection<ILocalizationEntry> provide();
+}

localizationlib/src/main/java/org/axolotsh/localizationlib/providers/JsonProvider.java

@@ -0,0 +1,53 @@
+package org.axolotsh.localizationlib.providers;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Map;
+
+import org.axolotsh.localizationlib.LocalizationEntry;
+import org.axolotsh.localizationlib.abstraction.ILocalizationEntry;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.Strictness;
+import com.google.gson.reflect.TypeToken;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+
+@Getter
+@Accessors(chain = true, fluent = true)
+@Builder(toBuilder = true)
+public class JsonProvider implements ILocalizationEntriesProvider {
+    static final Gson DEFAULT_GSON = new GsonBuilder()
+            .setStrictness(Strictness.LENIENT)
+            .create();
+
+    private String json;
+    private Locale locale;
+
+    @Builder.Default
+    private Gson gson = DEFAULT_GSON;
+
+    public Collection<ILocalizationEntry> provide() {
+        return provide(locale, json, gson);
+    }
+
+    public static Collection<ILocalizationEntry> provide(Locale locale, String json, Gson gson) {
+        var mapType = new TypeToken<Map<String, String>>() {
+        }.getType();
+        Map<String, String> map = gson.fromJson(json, mapType);
+        if (map == null)
+            return Collections.emptySet();
+
+        Collection<ILocalizationEntry> result = new HashSet<>();
+        map.forEach((key, value) -> {
+            result.add(new LocalizationEntry(locale, key, value));
+        });
+
+        return result;
+    }
+}

localizationlib/src/test/java/org/axolotsh/localizationlib/LocalizationLibTest.java

@@ -0,0 +1,178 @@
+package org.axolotsh.localizationlib;
+
+import com.google.gson.Gson;
+
+import org.axolotsh.localizationlib.abstraction.ILocalizationEntry;
+import org.axolotsh.localizationlib.abstraction.ILocalizationService;
+import org.axolotsh.localizationlib.providers.CollectionProvider;
+import org.axolotsh.localizationlib.providers.DirectoryProvider;
+import org.axolotsh.localizationlib.providers.FileProvider;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class LocalizationLibTest {
+
+    private static final Gson GSON = new Gson();
+
+    @TempDir
+    Path tempDir;
+
+    private File enFile;
+    private File ruFile;
+
+    @BeforeEach
+    public void setup() throws IOException {
+        enFile = tempDir.resolve("en.json").toFile();
+        ruFile = tempDir.resolve("ru.json").toFile();
+
+        try (FileWriter writer = new FileWriter(enFile, StandardCharsets.UTF_8)) {
+            GSON.toJson(Map.of("message.greeting", "Hello World!", "btn.save", "Save"), writer);
+        }
+
+        try (FileWriter writer = new FileWriter(ruFile, StandardCharsets.UTF_8)) {
+            GSON.toJson(Map.of("message.greeting", "Привет, Мир!"), writer);
+        }
+    }
+
+    @Test
+    public void testLocalizationEntryCreation() {
+        LocalizationEntry entry = new LocalizationEntry(Locale.ENGLISH, "key", "value");
+        assertEquals(Locale.ENGLISH, entry.locale());
+        assertEquals("key", "key");
+        assertEquals("value", entry.value());
+
+        LocalizationEntry entryNoLocale = new LocalizationEntry("key2", "value2");
+        assertNull(entryNoLocale.locale());
+
+        assertThrows(NullPointerException.class, () -> new LocalizationEntry(null, null));
+    }
+
+    @Test
+    public void testCollectionProvider() {
+        LocalizationEntry entry1 = new LocalizationEntry(Locale.ENGLISH, "k1", "v1");
+        LocalizationEntry entry2 = new LocalizationEntry(Locale.ENGLISH, "k2", "v2");
+
+        CollectionProvider provider = new CollectionProvider(entry1, entry2);
+        Collection<ILocalizationEntry> entries = provider.provide();
+
+        assertEquals(2, entries.size());
+        assertTrue(entries.contains(entry1));
+
+        assertThrows(UnsupportedOperationException.class, () -> entries.add(new LocalizationEntry("k3", "v3")));
+    }
+
+    @Test
+    public void testFileProviderAutomaticLocale() {
+        FileProvider fileProvider = FileProvider.builder()
+                .file(enFile)
+                .charset(StandardCharsets.UTF_8)
+                .gson(GSON)
+                .build();
+
+        Collection<ILocalizationEntry> entries = fileProvider.provide();
+        assertEquals(2, entries.size());
+
+        ILocalizationEntry greetingEntry = entries.stream()
+                .filter(e -> e.key().equals("message.greeting"))
+                .findFirst()
+                .orElseThrow();
+
+        assertEquals(Locale.ENGLISH, greetingEntry.locale());
+        assertEquals("Hello World!", greetingEntry.value());
+    }
+
+    @Test
+    public void testDirectoryProvider() {
+        DirectoryProvider directoryProvider = DirectoryProvider.builder()
+                .directory(tempDir.toFile())
+                .charset(StandardCharsets.UTF_8)
+                .gson(GSON)
+                .build();
+
+        Collection<ILocalizationEntry> entries = directoryProvider.provide();
+        assertEquals(3, entries.size());
+    }
+
+    @Test
+    public void testFactoryAndServiceWithCollectionProvider() {
+        LocalizationEntry enGreeting = new LocalizationEntry(Locale.US, "message.greeting", "Hello World!");
+        LocalizationEntry ruGreeting = new LocalizationEntry(Locale.forLanguageTag("ru"), "message.greeting",
+                "Привет, Мир!");
+
+        LocalizationEntry defaultGreeting = new LocalizationEntry("message.fallback", "Default Fallback");
+
+        LocalizationFactory factory = LocalizationFactory.builder()
+                .defaultLocale(Locale.US)
+                .provider(enGreeting, ruGreeting, defaultGreeting)
+                .build();
+
+        assertTrue(factory.storage().isEmpty());
+
+        factory.reloadProviders();
+        assertFalse(factory.storage().isEmpty());
+
+        assertEquals("Default Fallback", factory.storage().get(Locale.US).get("message.fallback"));
+
+        ILocalizationService serviceEn = factory.service(Locale.US);
+        assertEquals("Hello World!", serviceEn.translate("message.greeting"));
+
+        ILocalizationService serviceRu = factory.service(Locale.forLanguageTag("ru"));
+        assertEquals("Привет, Мир!", serviceRu.translate("message.greeting"));
+    }
+
+    @Test
+    public void testServiceFallbackLogic() {
+        CollectionProvider provider = new CollectionProvider(
+                new LocalizationEntry(Locale.US, "message.greeting", "Hello World!"),
+                new LocalizationEntry(Locale.US, "btn.save", "Save"),
+                new LocalizationEntry(Locale.forLanguageTag("ru"), "message.greeting", "Привет, Мир!"));
+
+        LocalizationFactory factory = LocalizationFactory.builder()
+                .defaultLocale(Locale.US)
+                .provider(provider)
+                .build()
+                .reloadProviders();
+
+        ILocalizationService service = factory.service(Locale.forLanguageTag("ru"), Locale.US);
+
+        assertEquals("Привет, Мир!", service.translate("message.greeting"));
+
+        assertEquals("Save", service.translate("btn.save"));
+
+        assertEquals("non.existent.key", service.translate("non.existent.key"));
+    }
+
+    @Test
+    public void testServiceGetOptional() {
+        CollectionProvider provider = new CollectionProvider(
+                new LocalizationEntry(Locale.US, "message.greeting", "Hello World!"));
+
+        LocalizationFactory factory = LocalizationFactory.builder()
+                .defaultLocale(Locale.US)
+                .provider(provider)
+                .build()
+                .reloadProviders();
+
+        ILocalizationService service = factory.service(Locale.US);
+
+        Optional<String> existing = service.get("message.greeting");
+        assertTrue(existing.isPresent());
+        assertEquals("Hello World!", existing.get());
+
+        Optional<String> nonExisting = service.get("unknown.key");
+        assertTrue(nonExisting.isEmpty());
+    }
+}