Deprecating redundant magics: %jars, %addMavenDependency #89

.. also removing unused stuff from GlobFinder

Author: andrus

RELEASE-NOTES.md

@@ -12,7 +12,8 @@
 - #82 Refactoring: Move JavaKernel init logic from constructor to Builder
 - #83 Simplify Kernel metadata loading approach
 - #84 Refactoring: reorg Maven modules for reusability
-- $86 ineffecient / incorrect classpath handling
+- #86 ineffecient / incorrect classpath handling
+- #89 Deprecating redundant magics: %jars, %addMavenDependency
 
 ## 1.0-a5
 

jjava-distro/src/main/java/org/dflib/jjava/distro/JJava.java

@@ -8,6 +8,7 @@
 import org.dflib.jjava.kernel.magics.JarsMagic;
 import org.dflib.jjava.kernel.magics.LoadCodeMagic;
 import org.dfllib.jjava.maven.MavenDependencyResolver;
+import org.dfllib.jjava.maven.magics.AddMavenDependencyMagic;
 import org.dfllib.jjava.maven.magics.LoadFromPomCellMagic;
 import org.dfllib.jjava.maven.magics.LoadFromPomLineMagic;
 import org.dfllib.jjava.maven.magics.MavenMagic;
@@ -62,8 +63,11 @@ public static void main(String[] args) throws Exception {
                 .lineMagic("maven", new MavenMagic(mavenResolver))
                 .lineMagic("mavenRepo", new MavenRepoMagic(mavenResolver))
                 .lineMagic("loadFromPOM", new LoadFromPomLineMagic(mavenResolver))
-                .lineMagic("jars", new JarsMagic()) // TODO: deprecate redundant "jars" alias; "classpath" is a superset of this
-                .lineMagic("addMavenDependency", new MavenMagic(mavenResolver)) // TODO: deprecate redundant "addMavenDependency" alias
+
+                // temporarily support a few deprecated magics
+                .lineMagic("jars", new JarsMagic())
+                .lineMagic("addMavenDependency", new AddMavenDependencyMagic(mavenResolver))
+
                 .cellMagic("loadFromPOM", new LoadFromPomCellMagic(mavenResolver))
 
                 .build();

…java/jupyter/kernel/util/GlobFinder.java …va/jupyter/kernel/util/GlobResolver.javajjava-jupyter/src/main/java/org/dflib/jjava/jupyter/kernel/util/GlobFinder.java renamed to jjava-jupyter/src/main/java/org/dflib/jjava/jupyter/kernel/util/GlobResolver.java jjava-jupyter/src/main/java/org/dflib/jjava/jupyter/kernel/util/GlobFinder.java renamed to jjava-jupyter/src/main/java/org/dflib/jjava/jupyter/kernel/util/GlobResolver.java

@@ -3,7 +3,6 @@
 import java.io.IOException;
 import java.nio.file.DirectoryStream;
 import java.nio.file.FileSystem;
-import java.nio.file.FileSystems;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.attribute.BasicFileAttributes;
@@ -21,78 +20,9 @@
  * match a single character. A glob ending in {@code "/"} will match all files in a directories matching
  * the glob.
  * <p>
- * Important note for Windows file systems: Globs should use {@code "/"} to separate the glob despite it not being the
- * platform separator.
+ * On Windows globs should use {@code "/"} to separate the glob despite it not being the platform separator.
  */
-public class GlobFinder {
-    private static class GlobSegment {
-        public enum FilterRestriction {
-            ONLY_FILES(true, false),
-            ONLY_DIRECTORIES(false, true),
-            ANYTHING(true, true);
-
-            private final boolean acceptsFiles;
-            private final boolean acceptsDirectories;
-
-            FilterRestriction(boolean acceptsFiles, boolean acceptsDirectories) {
-                this.acceptsFiles = acceptsFiles;
-                this.acceptsDirectories = acceptsDirectories;
-            }
-
-            public boolean acceptsFiles() {
-                return acceptsFiles;
-            }
-
-            public boolean acceptsDirectories() {
-                return acceptsDirectories;
-            }
-        }
-
-        public static final GlobSegment ANY = new GlobSegment(Pattern.compile("^.*$"));
-
-        private final String literal;
-        private final Pattern regex;
-
-        public GlobSegment(String literal) {
-            this.literal = literal;
-            this.regex = null;
-        }
-
-        public GlobSegment(Pattern regex) {
-            this.literal = null;
-            this.regex = regex;
-        }
-
-        public boolean isLiteral() {
-            return this.literal != null;
-        }
-
-        public DirectoryStream.Filter<Path> filter(FilterRestriction restriction) {
-            return s -> {
-                BasicFileAttributes attributes = Files.readAttributes(s, BasicFileAttributes.class);
-
-                if ((attributes.isRegularFile() && !restriction.acceptsFiles()) || (attributes.isDirectory() && !restriction.acceptsDirectories())) {
-                    return false;
-                }
-
-                Path pathName = s.getFileName();
-
-                if (pathName == null) {
-                    return false;
-                }
-
-                String name = pathName.toString();
-                return this.literal != null
-                        ? this.literal.equals(name)
-                        : this.regex.matcher(name).matches();
-            };
-        }
-
-        @Override
-        public String toString() {
-            return this.isLiteral() ? this.literal : this.regex.pattern();
-        }
-    }
+class GlobResolver {
 
     private static final Pattern GLOB_SEGMENT_COMPONENT = Pattern.compile(
             "" +
@@ -106,12 +36,10 @@ public String toString() {
 
     private final Path base;
     private final List<GlobSegment> segments;
-    private final boolean isExplicitDirectory;
 
-    public GlobFinder(FileSystem fs, String glob) {
+    public GlobResolver(FileSystem fs, String glob) {
         // Split with "/" but match with the actual separator
         String[] segments = SPLITTER.split(glob);
-        this.isExplicitDirectory = glob.endsWith("/");
 
         List<GlobSegment> matchers = new ArrayList<>(segments.length);
         int lastBaseSegmentIdx = 0;
@@ -169,72 +97,109 @@ public GlobFinder(FileSystem fs, String glob) {
         this.segments = matchers.subList(lastBaseSegmentIdx, matchers.size());
     }
 
-    public GlobFinder(String glob) {
-        this(FileSystems.getDefault(), glob);
-    }
-
-    public Iterable<Path> computeMatchingPaths() throws IOException {
-        if (this.segments.isEmpty()) {
-            if (Files.exists(this.base))
-                return Collections.singletonList(this.base);
-            else
-                return Collections.emptyList();
+    public List<Path> resolve() throws IOException {
+        if (segments.isEmpty()) {
+            return Files.exists(this.base)
+                    ? Collections.singletonList(base)
+                    : Collections.emptyList();
         }
 
         List<Path> paths = new ArrayList<>();
         GlobSegment head = this.segments.get(0);
         List<GlobSegment> tail = this.segments.subList(1, this.segments.size());
 
-        collectExplicit(GlobSegment.FilterRestriction.ANYTHING, this.base, head, tail, paths);
+        collectExplicit(Filter.ANYTHING, this.base, head, tail, paths);
 
         return paths;
     }
 
-    private void collectExplicit(GlobSegment.FilterRestriction finalFilterRestriction, Path dir, GlobSegment segment, List<GlobSegment> segments, Collection<Path> into) throws IOException {
+    private void collectExplicit(
+            Filter finalFilter,
+            Path dir,
+            GlobSegment segment,
+            List<GlobSegment> segments,
+            Collection<Path> into) throws IOException {
+
         boolean isMoreSegments = !segments.isEmpty();
         // Should match files if there are more segments in which case this must be a directory so
-        // we can continue. Otherwise we let the search determine if a file is acceptable.
-        GlobSegment.FilterRestriction filterRestriction = isMoreSegments ? GlobSegment.FilterRestriction.ONLY_DIRECTORIES : finalFilterRestriction;
+        // we can continue. Otherwise, we let the search determine if a file is acceptable.
+        Filter filter = isMoreSegments ? Filter.ONLY_DIRECTORIES : finalFilter;
 
-        try (DirectoryStream<Path> files = Files.newDirectoryStream(dir, segment.filter(filterRestriction))) {
+        try (DirectoryStream<Path> files = Files.newDirectoryStream(dir, segment.filter(filter))) {
             GlobSegment head = isMoreSegments ? segments.get(0) : null;
             List<GlobSegment> tail = isMoreSegments ? segments.subList(1, segments.size()) : Collections.emptyList();
 
             for (Path p : files) {
-                if (isMoreSegments)
-                    collectExplicit(finalFilterRestriction, p, head, tail, into);
-                else
+                if (isMoreSegments) {
+                    collectExplicit(finalFilter, p, head, tail, into);
+                } else {
                     into.add(p);
+                }
             }
         }
     }
 
-    public Iterable<Path> computeMatchingFiles() throws IOException {
-        if (this.segments.isEmpty()) {
-            if (Files.isDirectory(this.base) && this.isExplicitDirectory)
-                return Files.newDirectoryStream(this.base, Files::isRegularFile);
-            if (Files.isRegularFile(this.base))
-                return Collections.singleton(this.base);
-            return Collections.emptyList();
+    private enum Filter {
+        ONLY_DIRECTORIES(false, true),
+        ANYTHING(true, true);
+
+        private final boolean acceptsFiles;
+        private final boolean acceptsDirectories;
+
+        Filter(boolean acceptsFiles, boolean acceptsDirectories) {
+            this.acceptsFiles = acceptsFiles;
+            this.acceptsDirectories = acceptsDirectories;
         }
 
-        List<Path> paths = new ArrayList<>();
-        GlobSegment head = this.segments.get(0);
-        List<GlobSegment> tail;
-
-        // If explicitly ends with a "/" then the pattern means match all files in this directory
-        // otherwise we assume the last pattern is a file matcher.
-        if (this.isExplicitDirectory) {
-            tail = new ArrayList<>(this.segments.size() + 1);
-            Collections.copy(tail, this.segments.subList(1, this.segments.size()));
-            tail.add(GlobSegment.ANY);
-        } else {
-            tail = this.segments.subList(1, this.segments.size());
+        public boolean acceptsFiles() {
+            return acceptsFiles;
         }
 
-        collectExplicit(GlobSegment.FilterRestriction.ONLY_FILES, this.base, head, tail, paths);
+        public boolean acceptsDirectories() {
+            return acceptsDirectories;
+        }
+    }
 
-        return paths;
+    private static class GlobSegment {
+
+        private final String literal;
+        private final Pattern regex;
+
+        public GlobSegment(String literal) {
+            this.literal = literal;
+            this.regex = null;
+        }
+
+        public GlobSegment(Pattern regex) {
+            this.literal = null;
+            this.regex = regex;
+        }
+
+        public DirectoryStream.Filter<Path> filter(Filter restriction) {
+            return s -> {
+                BasicFileAttributes attributes = Files.readAttributes(s, BasicFileAttributes.class);
+
+                if ((attributes.isRegularFile() && !restriction.acceptsFiles()) || (attributes.isDirectory() && !restriction.acceptsDirectories())) {
+                    return false;
+                }
+
+                Path pathName = s.getFileName();
+
+                if (pathName == null) {
+                    return false;
+                }
+
+                String name = pathName.toString();
+                return literal != null
+                        ? literal.equals(name)
+                        : regex.matcher(name).matches();
+            };
+        }
+
+        @Override
+        public String toString() {
+            return literal != null ? literal : regex.pattern();
+        }
     }
 }
 

jjava-jupyter/src/main/java/org/dflib/jjava/jupyter/kernel/util/PathsHandler.java

@@ -2,6 +2,7 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.file.FileSystems;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -10,7 +11,7 @@
 import java.util.stream.Collectors;
 
 /**
- * Helper methods to split paths and resolve globs.
+ * Helper methods to split and join paths and resolve glob patterns.
  */
 public class PathsHandler {
 
@@ -41,12 +42,7 @@ public static List<Path> splitAndResolveGlobs(String paths) {
                 continue;
             }
 
-            Iterable<Path> subPaths;
-            try {
-                subPaths = new GlobFinder(p).computeMatchingPaths();
-            } catch (IOException e) {
-                throw new RuntimeException(String.format("Error computing classpath entries for '%s': %s", p, e.getMessage()), e);
-            }
+            List<Path> subPaths = resolveGlobs(p);
 
             for (Path entry : subPaths) {
                 result.add(entry);
@@ -55,4 +51,12 @@ public static List<Path> splitAndResolveGlobs(String paths) {
 
         return result;
     }
+
+    public static List<Path> resolveGlobs(String path) {
+        try {
+            return new GlobResolver(FileSystems.getDefault(), path).resolve();
+        } catch (IOException e) {
+            throw new RuntimeException(String.format("Error resolving glob '%s': %s", path, e.getMessage()), e);
+        }
+    }
 }