4 files changed, 235 insertions, 0 deletions

diff --git a/subprojects/language/src/main/java/tools/refinery/language/library/BuiltinLibrary.java b/subprojects/language/src/main/java/tools/refinery/language/library/BuiltinLibrary.java
new file mode 100644
index 00000000..ce80504e
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/BuiltinLibrary.java
@@ -0,0 +1,27 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.library;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.naming.QualifiedName;
+
+import java.util.List;
+
+public class BuiltinLibrary extends ClasspathBasedLibrary {
+        public static final QualifiedName BUILTIN_LIBRARY_NAME = QualifiedName.create("builtin");
+        public static final URI BUILTIN_LIBRARY_URI = ClasspathBasedLibrary.getLibraryUri(
+                        BuiltinLibrary.class, BUILTIN_LIBRARY_NAME).orElseThrow(
+                        () -> new IllegalStateException("Builtin library was not found"));
+
+        public BuiltinLibrary() {
+                super(BUILTIN_LIBRARY_NAME);
+        }
+
+        @Override
+        public List<QualifiedName> getAutomaticImports() {
+                return List.of(BUILTIN_LIBRARY_NAME);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/library/ClasspathBasedLibrary.java b/subprojects/language/src/main/java/tools/refinery/language/library/ClasspathBasedLibrary.java
new file mode 100644
index 00000000..56bb8b96
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/ClasspathBasedLibrary.java
@@ -0,0 +1,92 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.library;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.naming.QualifiedName;
+
+import java.nio.file.Path;
+import java.util.*;
+
+public abstract class ClasspathBasedLibrary implements RefineryLibrary {
+        private final Class<?> context;
+        private final QualifiedName prefix;
+        private final URI rootUri;
+
+        protected ClasspathBasedLibrary(Class<?> context, QualifiedName prefix) {
+        this.context = context == null ? getClass() : context;
+        this.prefix = prefix;
+                var contextPath = this.context.getCanonicalName().replace('.', '/') + ".class";
+                var contextResource = this.context.getClassLoader().getResource(contextPath);
+                if (contextResource == null) {
+                        throw new IllegalStateException("Failed to find library context");
+                }
+                var contextUri = URI.createURI(contextResource.toString());
+                var segments = Arrays.copyOf(contextUri.segments(), contextUri.segmentCount() - 1);
+                rootUri = URI.createHierarchicalURI(contextUri.scheme(), contextUri.authority(), contextUri.device(),
+                                segments, null, null);
+        }
+
+        protected ClasspathBasedLibrary(QualifiedName prefix) {
+                this(null, prefix);
+        }
+
+        @Override
+        public Optional<URI> resolveQualifiedName(QualifiedName qualifiedName, List<Path> libraryPaths) {
+                if (qualifiedName.startsWith(prefix)) {
+                        return getLibraryUri(context, qualifiedName);
+                }
+                return Optional.empty();
+        }
+
+        @Override
+        public Optional<QualifiedName> getQualifiedName(URI uri, List<Path> libraryPaths) {
+                if (!uri.isHierarchical() ||
+                                !Objects.equals(rootUri.scheme(), uri.scheme()) ||
+                                !Objects.equals(rootUri.authority(), uri.authority()) ||
+                                !Objects.equals(rootUri.device(), uri.device()) ||
+                                rootUri.segmentCount() >= uri.segmentCount()) {
+                        return Optional.empty();
+                }
+                int rootSegmentCount = rootUri.segmentCount();
+                int uriSegmentCount = uri.segmentCount();
+                if (!uri.segment(uriSegmentCount - 1).endsWith(RefineryLibrary.FILE_NAME_SUFFIX)) {
+                        return Optional.empty();
+                }
+                var segments = new ArrayList<String>();
+                int i = 0;
+                while (i < rootSegmentCount) {
+                        if (!rootUri.segment(i).equals(uri.segment(i))) {
+                                return Optional.empty();
+                        }
+                        i++;
+                }
+                while (i < uriSegmentCount) {
+                        var segment = uri.segment(i);
+                        if (i == uriSegmentCount - 1) {
+                                segment = segment.substring(0, segment.length() - RefineryLibrary.FILE_NAME_SUFFIX.length());
+                        }
+                        segments.add(segment);
+                        i++;
+                }
+                var qualifiedName = QualifiedName.create(segments);
+                if (!qualifiedName.startsWith(prefix)) {
+                        return Optional.empty();
+                }
+                return Optional.of(qualifiedName);
+        }
+
+        public static Optional<URI> getLibraryUri(Class<?> context, QualifiedName qualifiedName) {
+                var packagePath = context.getPackageName().replace('.', '/');
+                var libraryPath = String.join("/", qualifiedName.getSegments());
+                var resourceName = "%s/%s%s".formatted(packagePath, libraryPath, RefineryLibrary.FILE_NAME_SUFFIX);
+                var resource = context.getClassLoader().getResource(resourceName);
+                if (resource == null) {
+                        return Optional.empty();
+                }
+                return Optional.of(URI.createURI(resource.toString()));
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/library/PathLibrary.java b/subprojects/language/src/main/java/tools/refinery/language/library/PathLibrary.java
new file mode 100644
index 00000000..8eaf8458
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/PathLibrary.java
@@ -0,0 +1,90 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.library;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.naming.QualifiedName;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public final class PathLibrary implements RefineryLibrary {
+        @Override
+        public Optional<URI> resolveQualifiedName(QualifiedName qualifiedName, List<Path> libraryPaths) {
+                if (libraryPaths.isEmpty()) {
+                        return Optional.empty();
+                }
+                if (qualifiedName.getSegmentCount() == 0) {
+                        return Optional.empty();
+                }
+                var relativePath = qualifiedNameToRelativePath(qualifiedName);
+                for (var library : libraryPaths) {
+                        var absoluteResolvedPath = library.resolve(relativePath).toAbsolutePath().normalize();
+                        if (absoluteResolvedPath.startsWith(library) && Files.exists(absoluteResolvedPath)) {
+                                var uri = URI.createFileURI(absoluteResolvedPath.toString());
+                                return Optional.of(uri);
+                        }
+                }
+                return Optional.empty();
+        }
+
+        private static Path qualifiedNameToRelativePath(QualifiedName qualifiedName) {
+                int segmentCount = qualifiedName.getSegmentCount();
+                String first = null;
+                var rest = new String[segmentCount - 1];
+                for (var i = 0; i < segmentCount; i++) {
+                        var segment = qualifiedName.getSegment(i);
+                        if (i == segmentCount - 1) {
+                                segment = segment + RefineryLibrary.FILE_NAME_SUFFIX;
+                        }
+                        if (i == 0) {
+                                first = segment;
+                        } else {
+                                rest[i - 1] = segment;
+                        }
+                }
+                if (first == null) {
+                        throw new AssertionError("Expected qualified name to have non-null segments");
+                }
+        return Path.of(first, rest);
+        }
+
+        @Override
+        public Optional<QualifiedName> getQualifiedName(URI uri, List<Path> libraryPaths) {
+                if (libraryPaths.isEmpty()) {
+                        return Optional.empty();
+                }
+                if (!uri.isFile() || !uri.hasAbsolutePath()) {
+                        return Optional.empty();
+                }
+                var path = Path.of(uri.toFileString());
+                for (var library : libraryPaths) {
+                        if (path.startsWith(library)) {
+                                return getRelativeQualifiedName(library, path);
+                        }
+                }
+                return Optional.empty();
+        }
+
+        private static Optional<QualifiedName> getRelativeQualifiedName(Path library, Path path) {
+                var relativePath = path.relativize(library);
+                var segments = new ArrayList<String>();
+                for (Path value : relativePath) {
+                        segments.add(value.toString());
+                }
+                int lastIndex = segments.size() - 1;
+                var lastSegment = segments.get(lastIndex);
+                if (!lastSegment.endsWith(FILE_NAME_SUFFIX)) {
+                        return Optional.empty();
+                }
+                lastSegment = lastSegment.substring(0, lastSegment.length() - RefineryLibrary.FILE_NAME_SUFFIX.length());
+                segments.set(lastIndex, lastSegment);
+                return Optional.of(QualifiedName.create(segments));
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibrary.java b/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibrary.java
new file mode 100644
index 00000000..2559749a
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/library/RefineryLibrary.java
@@ -0,0 +1,26 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.library;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.naming.QualifiedName;
+import tools.refinery.language.utils.ProblemUtil;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Optional;
+
+public interface RefineryLibrary {
+        String FILE_NAME_SUFFIX = "." + ProblemUtil.MODULE_EXTENSION;
+
+        default List<QualifiedName> getAutomaticImports() {
+                return List.of();
+        }
+
+        Optional<URI> resolveQualifiedName(QualifiedName qualifiedName, List<Path> libraryPaths);
+
+        Optional<QualifiedName> getQualifiedName(URI uri, List<Path> libraryPaths);
+}