[#164] fix error found in #164

cli/src/main/java/io/github/bmarwell/jfmt/commands/AbstractCommand.java

@@ -311,7 +311,7 @@ String createRevisedSourceCode(CodeFormatter formatter, Path javaFile, String so
         final IDocument workingDoc = new Document(unixSourceCode);
 
         ImportOrderProcessor importOrderProcessor = createImportOrderProcessor();
-        importOrderProcessor.rewriteImportsIfAny(compilationUnit, workingDoc);
+        importOrderProcessor.rewriteImportsIfAny(javaFile, compilationUnit, workingDoc);
 
         // Now format the (possibly) updated document
         FormatterProcessor formatterProcessor = new FormatterProcessor(formatter);

cli/src/main/java/io/github/bmarwell/jfmt/commands/ImportOrderProcessor.java

@@ -1,9 +1,12 @@
 package io.github.bmarwell.jfmt.commands;
 
 import io.github.bmarwell.jfmt.imports.ImportOrderConfiguration;
+import io.github.bmarwell.jfmt.imports.ImportOrderProcessorException;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Locale;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.ImportDeclaration;
@@ -27,7 +30,7 @@ public ImportOrderProcessor(ImportOrderConfiguration importOrderTokens) {
      * Rewrites the imports in the provided document according to the configured order.
      * If there are no imports, this method is a no-op.
      */
-    public void rewriteImportsIfAny(CompilationUnit compilationUnit, IDocument workingDoc)
+    public void rewriteImportsIfAny(Path javaFile, CompilationUnit compilationUnit, IDocument workingDoc)
         throws BadLocationException {
         @SuppressWarnings("unchecked")
         List<ImportDeclaration> imports = new ArrayList<>((List<ImportDeclaration>) compilationUnit.imports());
@@ -42,7 +45,7 @@ public void rewriteImportsIfAny(CompilationUnit compilationUnit, IDocument worki
         List<ImportOrderGroup> groups = buildGroupsFromConfig(p);
 
         String rendered = renderGroups(groups);
-        replaceImportsInDocument(compilationUnit, workingDoc, rendered);
+        replaceImportsInDocument(javaFile, compilationUnit, workingDoc, rendered);
     }
 
     private Partition partitionImports(List<ImportDeclaration> imports) {
@@ -144,7 +147,21 @@ private String renderGroups(List<ImportOrderGroup> groups) {
         return sb.toString();
     }
 
-    private void replaceImportsInDocument(CompilationUnit compilationUnit, IDocument workingDoc, String rendered)
+    /**
+     *
+     * @param javaFile
+     * @param compilationUnit
+     * @param workingDoc
+     * @param rendered
+     *     the newly rendered import block
+     * @throws BadLocationException
+     */
+    private void replaceImportsInDocument(
+        Path javaFile,
+        CompilationUnit compilationUnit,
+        IDocument workingDoc,
+        String rendered
+    )
         throws BadLocationException {
         @SuppressWarnings("unchecked")
         List<ImportDeclaration> imports = (List<ImportDeclaration>) compilationUnit.imports();
@@ -161,8 +178,21 @@ private void replaceImportsInDocument(CompilationUnit compilationUnit, IDocument
             .orElse(importStart);
 
         workingDoc.replace(importStart, importEnd - importStart, rendered);
-        TextEdit importRewrite = compilationUnit.rewrite(workingDoc, null);
-        importRewrite.apply(workingDoc);
+        try {
+            TextEdit importRewrite = compilationUnit.rewrite(workingDoc, null);
+            importRewrite.apply(workingDoc);
+        } catch (IllegalArgumentException jdtEx) {
+            String message = String.format(
+                Locale.ROOT,
+                "Problem formatting file [%s]. Range: [%d-%d]. Rendered old: >>>\n%s\n<<<",
+                javaFile.toAbsolutePath(),
+                importStart,
+                importEnd,
+                workingDoc.get().substring(importStart, importEnd)
+            );
+
+            throw new ImportOrderProcessorException(javaFile, message, jdtEx);
+        }
     }
 
     // contains all imports read from the original source file.

cli/src/main/java/io/github/bmarwell/jfmt/imports/ImportOrderProcessorException.java

@@ -0,0 +1,21 @@
+package io.github.bmarwell.jfmt.imports;
+
+import java.nio.file.Path;
+import java.util.StringJoiner;
+
+public class ImportOrderProcessorException extends RuntimeException {
+    private final Path path;
+
+    public ImportOrderProcessorException(Path path, String message, Throwable cause) {
+        super(message, cause);
+        this.path = path;
+    }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", ImportOrderProcessorException.class.getSimpleName() + "[", "]")
+            .add("super=" + super.toString())
+            .add("path=" + path)
+            .toString();
+    }
+}

cli/src/test/java/io/github/bmarwell/jfmt/imports/ApacheImportOrderTest.java

@@ -1,11 +1,8 @@
 package io.github.bmarwell.jfmt.imports;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import java.io.IOException;
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
@@ -17,11 +14,7 @@ protected String getProfileName() {
 
     @BeforeAll
     static void loadSource() throws IOException {
-        try (InputStream in =
-            ImportOrderProcessorTestBase.class.getClassLoader().getResourceAsStream("imports/MavenCore.java")) {
-            assertNotNull(in, "Test resource imports/MavenCore.java must exist");
-            source = new String(in.readAllBytes(), StandardCharsets.UTF_8);
-        }
+        source = ImportOrderTestUtil.loadTestResource("imports/MavenCore.java");
     }
 
     @Test

cli/src/test/java/io/github/bmarwell/jfmt/imports/EmptyConfigurationImportOrderTest.java

@@ -22,13 +22,13 @@ class EmptyConfigurationImportOrderTest {
     @Test
     void empty_configuration_should_place_static_imports_first() throws Exception {
         // given
-        String source = loadTestResource("imports/AbstractCommandLike.java");
-        CompilationUnit cu = parseCompilationUnit(source, "AbstractCommandLike.java");
-        IDocument workingDoc = new Document(source);
+        ImportOrderTestUtil.TestResource source = loadTestResource("imports/AbstractCommandLike.java");
+        CompilationUnit cu = parseCompilationUnit(source.contents(), "AbstractCommandLike.java");
+        IDocument workingDoc = new Document(source.contents());
         ImportOrderConfiguration emptyConfig = ImportOrderConfiguration.empty();
 
         // when
-        new ImportOrderProcessor(emptyConfig).rewriteImportsIfAny(cu, workingDoc);
+        new ImportOrderProcessor(emptyConfig).rewriteImportsIfAny(source.path(), cu, workingDoc);
 
         // then
         String[] lines = workingDoc.get().split("\n");

cli/src/test/java/io/github/bmarwell/jfmt/imports/FallbackMatchesDefaultTest.java

@@ -17,7 +17,7 @@
  */
 class FallbackMatchesDefaultTest {
 
-    private String source;
+    private ImportOrderTestUtil.TestResource source;
 
     @BeforeEach
     void setUp() {
@@ -39,23 +39,23 @@ void fallback_should_match_default_configuration() throws Exception {
     }
 
     private String processWithDefaultConfiguration() throws Exception {
-        CompilationUnit cu = parseCompilationUnit(source, "MixedImports.java");
-        IDocument workingDoc = new Document(source);
+        CompilationUnit cu = parseCompilationUnit(source.contents(), "MixedImports.java");
+        IDocument workingDoc = new Document(source.contents());
 
         NamedImportOrder nio = NamedImportOrder.valueOf("defaultorder");
         ImportOrderConfiguration config = new ImportOrderLoader().loadFromResource(nio.getResourcePath());
 
-        new ImportOrderProcessor(config).rewriteImportsIfAny(cu, workingDoc);
+        new ImportOrderProcessor(config).rewriteImportsIfAny(source.path(), cu, workingDoc);
         return workingDoc.get();
     }
 
     private String processWithEmptyConfiguration() throws Exception {
-        CompilationUnit cu = parseCompilationUnit(source, "MixedImports.java");
-        IDocument workingDoc = new Document(source);
+        CompilationUnit cu = parseCompilationUnit(source.contents(), "MixedImports.java");
+        IDocument workingDoc = new Document(source.contents());
 
         ImportOrderConfiguration config = ImportOrderConfiguration.empty();
 
-        new ImportOrderProcessor(config).rewriteImportsIfAny(cu, workingDoc);
+        new ImportOrderProcessor(config).rewriteImportsIfAny(source.path(), cu, workingDoc);
         return workingDoc.get();
     }
 }

cli/src/test/java/io/github/bmarwell/jfmt/imports/ImportOrderProcessorTestBase.java

@@ -1,11 +1,7 @@
 package io.github.bmarwell.jfmt.imports;
 
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-
 import io.github.bmarwell.jfmt.commands.ImportOrderProcessor;
 import java.io.IOException;
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
 import java.util.Map;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.dom.AST;
@@ -19,31 +15,27 @@
 abstract class ImportOrderProcessorTestBase {
 
     public static final String MIXED_IMPORTS_JAVA = "MixedImports.java";
-    static String source;
+    static ImportOrderTestUtil.TestResource source;
 
     @BeforeAll
     static void loadSource() throws IOException {
-        try (InputStream in =
-            ImportOrderProcessorTestBase.class.getClassLoader().getResourceAsStream("imports/MixedImports.java")) {
-            assertNotNull(in, "Test resource imports/MixedImports.java must exist");
-            source = new String(in.readAllBytes(), StandardCharsets.UTF_8);
-        }
+        source = ImportOrderTestUtil.loadTestResource("imports/MixedImports.java");
     }
 
     protected String runAndGetImportBlock() {
         try {
             // Parse the source into a CompilationUnit
-            CompilationUnit cu = parseCompilationUnit(source);
+            CompilationUnit cu = parseCompilationUnit(source.contents());
 
             // Prepare the working document
-            IDocument workingDoc = new Document(source);
+            IDocument workingDoc = new Document(source.contents());
 
             // Load tokens for the given profile
             NamedImportOrder nio = NamedImportOrder.valueOf(getProfileName());
             ImportOrderConfiguration tokens = new ImportOrderLoader().loadFromResource(nio.getResourcePath());
 
             // Rewrite imports according to tokens
-            new ImportOrderProcessor(tokens).rewriteImportsIfAny(cu, workingDoc);
+            new ImportOrderProcessor(tokens).rewriteImportsIfAny(source.path(), cu, workingDoc);
 
             // Extract and return the import block
             return extractImportBlock(workingDoc);

cli/src/test/java/io/github/bmarwell/jfmt/imports/ImportOrderTestUtil.java

@@ -2,6 +2,8 @@
 
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.Map;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.dom.AST;
@@ -20,6 +22,8 @@ private ImportOrderTestUtil() {
         // Utility class
     }
 
+    record TestResource(Path path, String contents) {}
+
     /**
      * Loads a test resource file as a string.
      *
@@ -29,12 +33,12 @@ private ImportOrderTestUtil() {
      * @throws IllegalStateException
      *     if the resource cannot be loaded
      */
-    static String loadTestResource(String resourcePath) {
+    static TestResource loadTestResource(String resourcePath) {
         try (InputStream in = ImportOrderTestUtil.class.getClassLoader().getResourceAsStream(resourcePath)) {
             if (in == null) {
                 throw new IllegalStateException("Test resource not found: " + resourcePath);
             }
-            return new String(in.readAllBytes(), StandardCharsets.UTF_8);
+            return new TestResource(Paths.get(resourcePath), new String(in.readAllBytes(), StandardCharsets.UTF_8));
         } catch (Exception e) {
             throw new IllegalStateException("Failed to load test resource: " + resourcePath, e);
         }

cli/src/test/java/io/github/bmarwell/jfmt/imports/Issue164Test.java

@@ -0,0 +1,46 @@
+package io.github.bmarwell.jfmt.imports;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+final class Issue164Test extends ImportOrderProcessorTestBase {
+
+    @BeforeAll
+    static void loadSource() {
+        source = ImportOrderTestUtil.loadTestResource("imports/Issue164TestDatasource.java");
+    }
+
+    @Override
+    protected String getProfileName() {
+        return "defaultorder";
+    }
+
+    @Test
+    void is_correctly_formatted() {
+        // given
+        String expected = """
+                          import invalid.tool.dao.JpaUserDao;
+                          import invalid.tool.dao.UserDao;
+                          import jakarta.persistence.EntityManager;
+                          import jakarta.persistence.EntityTransaction;
+                          import jakarta.persistence.Parameter;
+                          import jakarta.persistence.Query;
+                          import jakarta.persistence.TypedQuery;
+                          import jakarta.persistence.criteria.CriteriaQuery;
+                          import java.util.function.Supplier;
+                          import org.eclipse.persistence.internal.helper.DatabaseField;
+                          import org.eclipse.persistence.internal.jpa.EJBQueryImpl;
+                          import org.eclipse.persistence.jpa.JpaEntityManager;
+                          import org.eclipse.persistence.queries.DatabaseQuery;
+                          import org.eclipse.persistence.sessions.DatabaseRecord;
+                          import org.eclipse.persistence.sessions.Session;""";
+
+        // when
+        String actual = runAndGetImportBlock();
+
+        // then
+        assertTrue(actual.startsWith(expected), "Import block should have been as expected but was: " + actual);
+    }
+}

cli/src/test/resources/imports/Issue164TestDatasource.java

@@ -0,0 +1,36 @@
+package invalid.tool.test.junit5;
+
+import invalid.tool.dao.UserDao;
+import invalid.tool.dao.JpaUserDao;
+
+import org.eclipse.persistence.internal.helper.DatabaseField;
+import org.eclipse.persistence.internal.jpa.EJBQueryImpl;
+import org.eclipse.persistence.jpa.JpaEntityManager;
+import org.eclipse.persistence.queries.DatabaseQuery;
+import org.eclipse.persistence.sessions.DatabaseRecord;
+import org.eclipse.persistence.sessions.Session;
+
+import java.util.function.Supplier;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityTransaction;
+import jakarta.persistence.Parameter;
+import jakarta.persistence.Query;
+import jakarta.persistence.TypedQuery;
+import jakarta.persistence.criteria.CriteriaQuery;
+
+final class Issue164TestDatasource implements TestDataSource {
+    @Override
+    public <RET> RET executeInTransaction(final Supplier<RET> function) {
+        return executeInTransaction(function, this.em);
+    }
+
+    @Override
+    public void executeInTransaction(final Runnable function) {
+        throw new UnsupportedOperationException("removed for testing.");
+    }
+
+    private static <RET> RET executeInTransaction(final Supplier<RET> function, final EntityManager entityManager) {
+        throw new UnsupportedOperationException("removed for testing.");
+    }
+
+}