refactor(java): retire FileMetaDataLoader + loader/file/; migrate to unified MetaDataLoader factories

Deletes the entire com.metaobjects.loader.file package (FileMetaDataLoader,
FileMetaDataSources, LocalFileMetaDataSources, URIFileMetaDataSources,
FileLoaderOptions) and the old createFromURIs / createFromResources
aliases on MetaDataLoader.

All callsites — production (core-spring MetaDataLoaderConfiguration) and
tests (omdb, omdb-ktx, maven-plugin, codegen-mustache, metadata gson +
proxy tests) — migrate to MetaDataLoader.fromResources / fromUris.
Bundle-file XML loading in om/OMXMLTest is replaced with a stub @ignore
test (the original Apple test data is already commented out).

CoreTypeInitializer drops the dead Class.forName(FileMetaDataLoader)
warm-up (FileMetaDataLoader had no static block to trigger).

LoaderOptions header doc updated to describe the unified loader, not
the old file-only loader.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: dmealing

server/java/codegen-base/src/main/java/com/metaobjects/generator/direct/metadata/html/MetaDataHtmlDocumentationWriter.java

@@ -464,7 +464,7 @@ private void generateOverviewSection() {
         writer.println("                <h3>Architecture Patterns</h3>");
         writer.println("                <div class=\"code-block\">");
         writer.println("// MetaDataLoader operates like Java ClassLoader - load once, read many");
-        writer.println("MetaDataLoader loader = MetaDataLoader.createFromResources(\"myApp\", sources);");
+        writer.println("MetaDataLoader loader = MetaDataLoader.fromResources(\"myApp\", sources);");
         writer.println("loader.init(); // Heavy initialization, permanent in memory");
         writer.println("");
         writer.println("// Runtime access is O(1) cached lookup - no synchronization needed");

server/java/codegen-base/src/test/java/com/metaobjects/generator/direct/metadata/html/HtmlDocumentationGeneratorExample.java

@@ -60,7 +60,7 @@ public void demonstrateGeneratorConfiguration() {
      *             </goals>
      *             <configuration>
      *                 <loader>
-     *                     <classname>com.metaobjects.loader.file.FileMetaDataLoader</classname>
+     *                     <classname>com.metaobjects.loader.MetaDataLoader</classname>
      *                     <name>html-doc-generator</name>
      *                     <sources/>
      *                 </loader>

server/java/codegen-mustache/src/test/java/com/metaobjects/generator/mustache/MustacheTemplateEngineTest.java

@@ -26,7 +26,7 @@ public void setUp() throws Exception {
         engine = new MustacheTemplateEngine();
 
         // Load test metadata using MetaDataLoader directly
-        loader = MetaDataLoader.createFromURIs("mustache-test",
+        loader = MetaDataLoader.fromUris("mustache-test",
             Arrays.asList(URIHelper.toURI("model:resource:mustache-test-metadata.json")));
 
         // Get the User MetaObject

server/java/core-spring/src/main/java/com/metaobjects/spring/MetaDataLoaderConfiguration.java

@@ -1,6 +1,5 @@
 package com.metaobjects.spring;
 
-import com.metaobjects.loader.LoaderOptions;
 import com.metaobjects.loader.MetaDataLoader;
 
 import org.springframework.boot.context.properties.ConfigurationProperties;
@@ -35,16 +34,12 @@
  * <pre>{@code
  * @Configuration
  * public class MyMetaDataConfig {
- *     
+ *
  *     @Bean
  *     public MetaDataLoader userMetaDataLoader() {
- *         MetaDataLoader loader = new MetaDataLoader(
- *             LoaderOptions.create(false, false, true), MetaDataLoader.SUBTYPE_MANUAL, "userLoader");
- *         loader.setSourceURIs(Arrays.asList(
+ *         return MetaDataLoader.fromUris("userLoader", List.of(
  *             URI.create("classpath:metadata/users.json")
  *         ));
- *         loader.init();
- *         return loader;
  *     }
  * }
  * }</pre>
@@ -83,16 +78,9 @@ public MetaDataLoader applicationMetaDataLoader() throws Exception {
         for (String source : metadataSources) {
             sourceURIs.add(URI.create(source));
         }
-        
-        // Create and configure loader
-        MetaDataLoader loader = new MetaDataLoader(
-                LoaderOptions.create(false, false, true),
-                MetaDataLoader.SUBTYPE_MANUAL, "applicationLoader");
-
-        loader.setSourceURIs(sourceURIs);
-        loader.init();
 
-        return loader;
+        // Build a loader via the unified factory (init + load + register in one call).
+        return MetaDataLoader.fromUris("applicationLoader", sourceURIs);
     }
 
     /**
@@ -113,10 +101,7 @@ public MetaDataLoader applicationMetaDataLoader() throws Exception {
     // @Bean
     // @ConditionalOnProperty("metaobjects.external-path")
     // public MetaDataLoader externalMetaDataLoader(@Value("${metaobjects.external-path}") String path) {
-    //     FileMetaDataLoader loader = new FileMetaDataLoader("externalLoader");
-    //     loader.setSourceURIs(Arrays.asList(URI.create("file:" + path)));
-    //     loader.init(); 
-    //     return loader;
+    //     return MetaDataLoader.fromUris("externalLoader", List.of(URI.create("file:" + path)));
     // }
 
     /**

server/java/examples/basic-example/src/main/java/com/metaobjects/examples/basic/BasicMetaObjectsExample.java

@@ -175,7 +175,7 @@ public static void main(String[] args) {
             // 7. Simple vs Complex pattern comparison
             System.out.println("\n7. When to use simple vs complex patterns...");
             System.out.println("   SIMPLE PATTERN (this example):");
-            System.out.println("     - Single MetaDataLoader (MetaDataLoader.createFromResources or setSourceURIs + init)");
+            System.out.println("     - Single MetaDataLoader (MetaDataLoader.fromResources or setSourceURIs + init)");
             System.out.println("     - Direct loader.getMetaObjectByName() or MetaDataUtil.findMetaObjectByName(loader, ...)");
             System.out.println("     - No registry complexity needed");
             System.out.println("   COMPLEX PATTERN (see spring-example, osgi-example):");

server/java/maven-plugin/src/main/java/com/metaobjects/mojo/LoaderParam.java

@@ -52,7 +52,7 @@ public String getClassname() {
 
     /**
      * Set the fully qualified classname of the loader implementation
-     * @param classname Loader classname (e.g., "com.metaobjects.loader.file.FileMetaDataLoader")
+     * @param classname Loader classname (e.g., "com.metaobjects.loader.MetaDataLoader")
      */
     public void setClassname(String classname) {
         this.classname = classname;

server/java/maven-plugin/src/test/java/com/metaobjects/mojo/MetaDataMigrateMojoTest.java

@@ -1,9 +1,6 @@
 package com.metaobjects.mojo;
 
 import com.metaobjects.loader.MetaDataLoader;
-import com.metaobjects.loader.file.FileLoaderOptions;
-import com.metaobjects.loader.file.FileMetaDataLoader;
-import com.metaobjects.loader.file.LocalFileMetaDataSources;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.MojoFailureException;
 import org.codehaus.plexus.PlexusTestCase;
@@ -28,7 +25,7 @@
  * {@link org.apache.maven.project.MavenProject} context that the maven-plugin-testing-harness
  * cannot trivially provide for a mojo with JDBC + engine wiring, this test uses a
  * <em>focused direct-instantiation</em> approach: it subclasses {@code MetaDataMigrateMojo},
- * overrides {@code createLoader} to build a {@link FileMetaDataLoader} from the test fixture
+ * overrides {@code createLoader} to build a {@link MetaDataLoader} from the test fixture
  * without touching the Maven classpath machinery, and drives the engine end-to-end against an
  * in-memory Derby database. The {@code SchemaMigrationEngine} and {@code DerbyDriver} are the
  * real implementations — nothing is mocked or faked.
@@ -75,23 +72,15 @@ static class TestableMigrateMojo extends MetaDataMigrateMojo {
 
         /**
          * Bypass {@code MetaDataMigrateMojo.createLoader} (needs loaderConfig + MavenProject).
-         * Uses a {@link FileMetaDataLoader} that reads directly from the filesystem via
-         * {@code LocalFileMetaDataSources(sourceDir, filename)}.
+         * Uses the unified {@link MetaDataLoader#fromUris(String, java.util.List)} factory
+         * reading the fixture directly from the filesystem.
          */
         @Override
         protected MetaDataLoader createLoader(ClassLoader ignored) {
             try {
-                FileMetaDataLoader xl = new FileMetaDataLoader(
-                    new FileLoaderOptions()
-                        .setShouldRegister(false)
-                        .setAllowAutoAttrs(true)
-                        .setStrict(false)
-                        .setVerbose(false),
-                    "mojo-test-loader");
-                // LocalFileMetaDataSources(baseDir, filename) → getFileInputStream(baseDir + "/" + filename)
-                xl.init(new LocalFileMetaDataSources(fixtureDir, fixtureFile));
-                xl.register();
-                return xl;
+                java.net.URI fixtureUri = java.nio.file.Path.of(fixtureDir, fixtureFile).toUri();
+                return MetaDataLoader.fromUris("mojo-test-loader",
+                    java.util.List.of(fixtureUri));
             } catch (Exception e) {
                 throw new RuntimeException("Could not build test loader: " + e.getMessage(), e);
             }

server/java/metadata/src/main/java/com/metaobjects/MetaData.java

@@ -52,7 +52,7 @@
  * <strong>Usage Examples:</strong>
  * <pre>{@code
  * // Loading Phase - Happens once at startup
- * MetaDataLoader loader = MetaDataLoader.createFromResources("myLoader",
+ * MetaDataLoader loader = MetaDataLoader.fromResources("myLoader",
  *     Arrays.asList("com/example/metadata.json"));
  * // OR: loader = new MetaDataLoader(...); loader.setSourceURIs(...); loader.init();
  * 

server/java/metadata/src/main/java/com/metaobjects/loader/LoaderOptions.java

@@ -4,7 +4,8 @@
 
 
 /**
- * FileMetaDataLoader Configuration Settings
+ * MetaDataLoader configuration settings — toggle behavior flags that apply
+ * across all loader sources (file, URI, directory, in-memory).
  */
 public class LoaderOptions {
 

server/java/metadata/src/main/java/com/metaobjects/loader/MetaDataLoader.java

@@ -185,37 +185,6 @@ public static MetaDataLoader createManual( boolean shouldRegister, String name )
                         SUBTYPE_MANUAL, name );
     }
 
-    /**
-     * Construct a MetaDataLoader, set the given URI list, then init + load — all in one call.
-     * Equivalent to the old {@code SimpleLoader.createManualURIs(name, uris)}.
-     *
-     * @param name the loader name
-     * @param uris model URIs to load (e.g. {@code model:resource:…}, {@code model:file:…})
-     * @return a fully-initialized loader with all URIs loaded
-     */
-    public static MetaDataLoader createFromURIs(String name, List<URI> uris) {
-        MetaDataLoader loader = new MetaDataLoader(
-                LoaderOptions.create(false, false, true), SUBTYPE_MANUAL, name);
-        loader.setSourceURIs(uris);
-        loader.init();
-        return loader;
-    }
-
-    /**
-     * Construct a MetaDataLoader from classpath resource paths, then init + load.
-     * Each resource path is wrapped as {@code model:resource:<path>}.
-     * Equivalent to the old {@code SimpleLoader.createManual(name, List&lt;String&gt;)}.
-     *
-     * @param name      the loader name
-     * @param resources classpath resource paths (no {@code model:} prefix needed)
-     * @return a fully-initialized loader with all resources loaded
-     */
-    public static MetaDataLoader createFromResources(String name, List<String> resources) {
-        List<URI> uris = new ArrayList<>();
-        for (String r : resources) uris.add(URIHelper.toURI("model:resource:" + r));
-        return createFromURIs(name, uris);
-    }
-
     ///////////////////////////////////////////////////////////////////////
     // Unified static factories (cross-language consistent — see TS / C# / Python)
 
@@ -258,8 +227,8 @@ public static MetaDataLoader fromDirectory(String name, Path directory, Director
     }
 
     /**
-     * Build {@link UriSource}s and load them. Replaces the deprecated
-     * {@link #createFromURIs(String, List)} alias.
+     * Build {@link UriSource}s and load them. The cross-language URI-based
+     * factory — every port (TS/Java/C#/Python) exposes the same shape.
      *
      * @param name the loader name
      * @param uris model URIs to load