Add concrete JsPlugin

plugin/src/main/java/io/deephaven/plugin/js/JsPlugin.java

@@ -3,16 +3,115 @@
  */
 package io.deephaven.plugin.js;
 
+import io.deephaven.annotations.BuildableStyle;
 import io.deephaven.plugin.Plugin;
+import io.deephaven.plugin.PluginBase;
+import org.immutables.value.Value.Check;
+import org.immutables.value.Value.Default;
+import org.immutables.value.Value.Immutable;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 /**
- * A js plugin is a {@link Plugin} that allows adding javascript code under the server's URL path "js-plugins/". See
+ * A JS plugin is a {@link Plugin} that allows adding javascript code under the server's URL path "js-plugins/". See
  * <a href="https://github.com/deephaven/deephaven-plugins#js-plugins">deephaven-plugins#js-plugins</a> for more details
- * about the underlying construction for js plugins.
- *
- * @see JsPluginPackagePath
- * @see JsPluginManifestPath
+ * about the underlying construction for JS plugins.
  */
-public interface JsPlugin extends Plugin {
+@Immutable
+@BuildableStyle
+public abstract class JsPlugin extends PluginBase {
+
+    public static Builder builder() {
+        return ImmutableJsPlugin.builder();
+    }
+
+    /**
+     * The JS plugin name. The JS plugin contents will be served via the URL path "js-plugins/{name}/", as well as
+     * included as the "name" field for the manifest entry in "js-plugins/manifest.json".
+     *
+     * @return the name
+     */
+    public abstract String name();
+
+    /**
+     * The JS plugin version. Will be included as the "version" field for the manifest entry in
+     * "js-plugins/manifest.json".
+     *
+     * @return the version
+     */
+    public abstract String version();
+
+    /**
+     * The main JS file path, specified relative to {@link #root()}. The main JS file must exist
+     * ({@code Files.isRegularFile(root().resolve(main()))}) and must be included in {@link #paths()}. Will be included
+     * as the "main" field for the manifest entry in "js-plugins/manifest.json".
+     *
+     *
+     * @return the main JS file path
+     */
+    public abstract Path main();
+
+    /**
+     * The root directory of the resources to serve. The root must exist ({@code Files.isDirectory(root())}).
+     *
+     * @return the root
+     */
+    public abstract Path root();
+
+    /**
+     * The paths to serve, specified relative to {@link #root()}. The resources will be served via the URL path
+     * "js-plugins/{name}/{pathRelativeToRoot}". By default, is {@link Paths#all()}.
+     *
+     * @return the paths
+     */
+    @Default
+    public Paths paths() {
+        return Paths.all();
+    }
+
+    @Override
+    public final <T, V extends Plugin.Visitor<T>> T walk(V visitor) {
+        return visitor.visit(this);
+    }
+
+    @Check
+    final void checkRoot() {
+        if (!Files.isDirectory(root())) {
+            throw new IllegalArgumentException(String.format("root ('%s') must exist and be a directory", root()));
+        }
+    }
+
+    @Check
+    final void checkMain() {
+        final Path mainPath = root().resolve(main());
+        if (!Files.isRegularFile(mainPath)) {
+            throw new IllegalArgumentException(String.format("main ('%s') must exist and be a regular file", mainPath));
+        }
+    }
+
+    @Check
+    final void checkPaths() {
+        if (!(paths() instanceof PathsInternal)) {
+            throw new IllegalArgumentException("Must construct one of the approved Paths");
+        }
+        final Path relativeMain = root().relativize(root().resolve(main()));
+        if (!((PathsInternal) paths()).matches(relativeMain)) {
+            throw new IllegalArgumentException(String.format("main ('%s') is not in paths", relativeMain));
+        }
+    }
+
+    public interface Builder {
+        Builder name(String name);
+
+        Builder version(String version);
+
+        Builder main(Path main);
+
+        Builder root(Path root);
+
+        Builder paths(Paths paths);
 
+        JsPlugin build();
+    }
 }

plugin/src/main/java/io/deephaven/plugin/js/Paths.java

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2016-2023 Deephaven Data Labs and Patent Pending
+ */
+package io.deephaven.plugin.js;
+
+import java.nio.file.Path;
+
+public interface Paths {
+
+    /**
+     * Includes all paths.
+     *
+     * @return the paths
+     */
+    static Paths all() {
+        return PathsAll.INSTANCE;
+    }
+
+    /**
+     * Includes only the paths that are prefixed by {@code prefix}.
+     *
+     * @param prefix the prefix
+     * @return the paths
+     */
+    static Paths ofPrefixes(Path prefix) {
+        // Note: we have specific overload for single element to explicitly differentiate from Iterable overload since
+        // Path extends Iterable<Path>.
+        return PathsPrefixes.builder().addPrefixes(prefix).build();
+    }
+
+    /**
+     * Includes only the paths that are prefixed by one of {@code prefixes}.
+     *
+     * @param prefixes the prefixes
+     * @return the paths
+     */
+    static Paths ofPrefixes(Path... prefixes) {
+        return PathsPrefixes.builder().addPrefixes(prefixes).build();
+    }
+
+    /**
+     * Includes only the paths that are prefixed by one of {@code prefixes}.
+     *
+     * @param prefixes the prefixes
+     * @return the paths
+     */
+    static Paths ofPrefixes(Iterable<? extends Path> prefixes) {
+        return PathsPrefixes.builder().addAllPrefixes(prefixes).build();
+    }
+}

plugin/src/main/java/io/deephaven/plugin/js/PathsAll.java

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2016-2023 Deephaven Data Labs and Patent Pending
+ */
+package io.deephaven.plugin.js;
+
+import java.nio.file.Path;
+
+enum PathsAll implements PathsInternal {
+    INSTANCE;
+
+    @Override
+    public boolean matches(Path path) {
+        return true;
+    }
+}

plugin/src/main/java/io/deephaven/plugin/js/PathsInternal.java

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2016-2023 Deephaven Data Labs and Patent Pending
+ */
+package io.deephaven.plugin.js;
+
+import java.nio.file.PathMatcher;
+
+interface PathsInternal extends Paths, PathMatcher {
+
+}

plugin/src/main/java/io/deephaven/plugin/js/PathsPrefixes.java

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2016-2023 Deephaven Data Labs and Patent Pending
+ */
+package io.deephaven.plugin.js;
+
+import io.deephaven.annotations.BuildableStyle;
+import org.immutables.value.Value.Check;
+import org.immutables.value.Value.Immutable;
+
+import java.nio.file.Path;
+import java.util.Set;
+
+@Immutable
+@BuildableStyle
+abstract class PathsPrefixes implements PathsInternal {
+
+    public static Builder builder() {
+        return ImmutablePathsPrefixes.builder();
+    }
+
+    public abstract Set<Path> prefixes();
+
+    @Override
+    public final boolean matches(Path path) {
+        if (prefixes().contains(path)) {
+            return true;
+        }
+        // Note: we could make a more efficient impl w/ a tree-based approach based on the names
+        for (Path prefix : prefixes()) {
+            if (path.startsWith(prefix)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Check
+    final void checkPrefixesNonEmpty() {
+        if (prefixes().isEmpty()) {
+            throw new IllegalArgumentException("prefixes must be non-empty");
+        }
+    }
+
+    interface Builder {
+        Builder addPrefixes(Path element);
+
+        Builder addPrefixes(Path... elements);
+
+        Builder addAllPrefixes(Iterable<? extends Path> elements);
+
+        PathsPrefixes build();
+    }
+}