JabRef
diff --git a/‎CHANGELOG.md‎
Lines changed: 2 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎build-logic/src/main/kotlin/org.jabref.gradle.base.dependency-rules.gradle.kts‎
Lines changed: 6 additions & 0 deletions b/‎build-logic/src/main/kotlin/org.jabref.gradle.base.dependency-rules.gradle.kts‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎docs/decisions/0054-allow-using-jilt-in-tests.md‎
Lines changed: 119 additions & 0 deletions b/‎docs/decisions/0054-allow-using-jilt-in-tests.md‎
Lines changed: 119 additions & 0 deletions
diff --git a/‎docs/requirements/files.md‎
Lines changed: 22 additions & 0 deletions b/‎docs/requirements/files.md‎
Lines changed: 22 additions & 0 deletions
diff --git a/‎jabgui/src/main/java/module-info.java‎
Lines changed: 2 additions & 4 deletions b/‎jabgui/src/main/java/module-info.java‎
Lines changed: 2 additions & 4 deletions
diff --git a/‎jabgui/src/main/java/org/jabref/gui/JabRefGUI.java‎
Lines changed: 2 additions & 1 deletion b/‎jabgui/src/main/java/org/jabref/gui/JabRefGUI.java‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎jabgui/src/main/java/org/jabref/gui/LibraryTab.java‎
Lines changed: 34 additions & 15 deletions b/‎jabgui/src/main/java/org/jabref/gui/LibraryTab.java‎
Lines changed: 34 additions & 15 deletions
@@ -24,6 +24,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 - We added the possibility to configure the email provided to unpaywall. [#14340](https://github.com/JabRef/jabref/pull/14340)
 - We added "Close library" to the File menu. [#14381](https://github.com/JabRef/jabref/issues/14381)
 - We added a "Regenerate" button for the AI chat allowing the user to make the language model reformulate its response to the previous prompt. [#12191](https://github.com/JabRef/jabref/issues/12191)
+- We added the option to enable auto-copying and adjusting of attached files when copy and pasting (Preferences → Linked files → Attached files) [#12267](https://github.com/JabRef/jabref/issues/12267)
 - We added support for transliteration of fields to English and automatic transliteration of generated citation key. [#11377](https://github.com/JabRef/jabref/issues/11377)
 - We added the generation of follow-up questions in AI chat. [#12243](https://github.com/JabRef/jabref/issues/12243)
 - We added support for "Search Google Scholar" and "Search Semantic Scholar" to quickly search for a selected entry's title in Google Scholar or Semantic Scholar directly from the main table's context menu [#12268](https://github.com/JabRef/jabref/issues/12268)
@@ -35,6 +36,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 - We separated the "Clean up entries" dialog into three tabs for clarity [#13819](https://github.com/JabRef/jabref/issues/13819)
 - `JabKit`: `--porcelain` does not output any logs to the console anymore. [#14244](https://github.com/JabRef/jabref/pull/14244)
 - <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>L</kbd> now opens the terminal in the active library directory. [#14130](https://github.com/JabRef/jabref/issues/14130)
+- After importing, now all imported entries are marked. [#13535](https://github.com/JabRef/jabref/pull/13535)
 - The URL integrity check now checks the complete URL syntax. [#14370](https://github.com/JabRef/jabref/pull/14370)
 - We changed  fixed-value ComboBoxes to SearchableComboBox for better usability. [#14083](https://github.com/JabRef/jabref/issues/14083)
 
 
@@ -105,6 +105,12 @@ extraJavaModuleInfo {
         uses("ai.djl.repository.RepositoryFactory")
     }
     module("at.favre.lib:hkdf", "hkdf")
+
+    module("cc.jilt:jilt", "jilt")         {
+        exportAllPackages()
+        requires("java.compiler") // Reason: javax.annotation.processor
+    }
+
     module("com.github.javakeyring:java-keyring", "java.keyring")
 
     module("com.github.tomtung:latex2unicode_2.13", "com.github.tomtung.latex2unicode") {
 
@@ -0,0 +1,119 @@
+---
+nav_order: 54
+parent: Decision Records
+---
+# Use Jilt staged builders for complex test configurations
+
+## Context and Problem Statement
+
+For tests around linked files we frequently need `BibTestConfiguration` instances with multiple required and optional parameters:
+
+```java
+@Builder(style = BuilderStyle.STAGED_PRESERVING_ORDER)
+BibTestConfiguration(
+        String bibDir,
+        @Opt String librarySpecificFileDir,
+        @Opt String userSpecificFileDir,
+        String pdfFileDir,
+        FileTestConfiguration.TestFileLinkMode fileLinkMode,
+        Path tempDir
+) throws IOException {
+}
+```
+
+Usage in tests currently follows a staged builder style:
+
+```java
+BibTestConfigurationBuilder
+        .bibTestConfiguration()
+        .bibDir("source-dir")
+        .pdfFileDir("source-dir")
+        .fileLinkMode(TestFileLinkMode.RELATIVE_TO_BIB");
+
+// later in the code
+
+BibTestConfiguration sourceBibTestConfiguration =
+        sourceBibTestConfigurationBuilder.tempDir(tempDir).build();
+```
+
+We want a clear, type-safe, and readable way to construct such configurations.
+Especially important is the ordering of the "setters" to increase code readability.
+
+## Decision Drivers
+
+* Make test setup code more readable and explicit.
+* Enforce required vs. optional parameters at compile time.
+* Keep the order of builder calls aligned with the parameter declaration order.
+* Avoid handwritten builder boilerplate and its maintenance.
+* Provide a reusable template for future configuration/value classes.
+
+## Considered Options
+
+* Jilt staged builder (`@Builder(style = BuilderStyle.STAGED_PRESERVING_ORDER)`).
+* Plain constructors (direct `new BibTestConfiguration(…)`), setters, and `initialize()` method.
+* Handwritten classic builder.
+* Lombok’s `@Builder`.
+
+## Decision Outcome
+
+Chosen option: "Jilt staged builder (`@Builder(style = BuilderStyle.STAGED_PRESERVING_ORDER)`)", because it gives us:
+
+* type-safe staged construction,
+* stable call order matching parameter order,
+* clear distinction between required and optional parameters,
+* no handwritten builder code.
+
+### Consequences
+
+* Good, because **test code is more readable** – parameter names are visible at the call site instead of a long constructor argument list.
+* Good, because **required parameters are enforced by the compiler**; tests cannot accidentally omit them.
+* Good, because **builder invocation order matches declaration order**, which makes it easier to compare code and constructor signature.
+* Good, because **no runtime dependency** is introduced; Jilt is an annotation processor only.
+* Bad, because **another annotation processor** is in the toolchain, which slightly increases build complexity and can interact with other processors.
+* Bad, because **developers must learn the Jilt conventions**, especially staged builders and generated builder class naming.
+
+### Confirmation
+
+* `BibTestConfigurationBuilder` and similar builders are generated successfully during the build.
+* Tests compile only if all required fields are set via the staged builder.
+
+## Pros and Cons of the Options
+
+### Jilt staged builder (`@Builder(style = BuilderStyle.STAGED_PRESERVING_ORDER)`)
+
+Homepage: <https://github.com/skinny85/jilt>
+
+* Good, because it generates **staged** builders with clear required/optional semantics.
+* Good, because `BuilderStyle.STAGED_PRESERVING_ORDER` keeps **builder call order aligned with parameter order**.
+* Good, because no runtime dependency; Jilt is compile-time only.
+* Good, because it is compatible with new Java releases.
+* Good, because it integrates with existing Java code without changing runtime behavior.
+* Bad, because adding an annotation processor requires **IDE/build configuration** and developer knowledge.
+* Bad, because navigating to generated code can be less convenient, depending on IDE support.
+
+### Plain constructors (direct `new BibTestConfiguration(…)`), setters, and `initialize()` method
+
+* Good, because useful for very small classes.
+* Good, because no extra dependency.
+* Good, because IDEs understand plain constructors well.
+* Bad, because more complicated calling code - and unusual calling code.
+* Bad, because call sites with many parameters are hard to read and fragile.
+* Bad, because no compile-time enforcement of “required vs. optional” beyond primitive defaults and `null`.
+* Bad, because changing constructor parameter order can silently break call sites.
+
+### Handwritten classic builder
+
+* Good, because familiar builder pattern; no extra tools.
+* Good, because call sites are readable and explicit.
+* Bad, because builder code is boilerplate and must be maintained manually.
+* Bad, because easy to introduce inconsistencies between builder and target class.
+* Bad, because type-safety of required/optional parameters might be weaker than staged builders.
+
+### Lombok’s `@Builder`
+
+* Good, because concise annotation, common in many Java projects.
+* Good, because builder usage is clear at call sites.
+* Bad, because Lombok adds its own ecosystem and tooling constraints.
+* Bad, because Lombok is not always compatible with the most recent Java versions.
+* Bad, because staged/type-safe builders for required/optional distinction are less explicit than with Jilt.
+* Bad, because we avoid additional Lombok usage where possible.
@@ -0,0 +1,22 @@
+# File Transfer Between Bib Entries
+
+*Note:*  
+"Reachable" here denotes that the linked file can be accessed via a relative path that does **not** climb up the directory structure (i.e., no "`..`" segments beyond the root directory).  
+Additionally, this check respects all configured **directories for files** as defined in JabRef's file linking settings (see [directories for files](https://docs.jabref.org/finding-sorting-and-cleaning-entries/filelinks#directories-for-files)).
+
+## A reachable file should be linked (and not copied)
+`req~logic.externalfiles.file-transfer.reachable-no-copy~1`
+
+When a linked file is reachable from the target context, the system must adjust the relative path in the target entry but must not copy the file again.
+
+Needs: impl
+
+## A non-reachable file should keep the relative path
+`req~logic.externalfiles.file-transfer.not-reachable-same-path~1`
+
+When a linked file is not reachable from the target context, the relative path within the source library should be kept in the target library.
+As a consequence, the file is copied.
+
+Needs: impl
+
+<!-- markdownlint-disable-file MD022 -->
@@ -80,9 +80,7 @@
     // region: data mapping
     requires jdk.xml.dom;
     // requires com.google.gson;
-    // requires com.fasterxml.jackson.databind;
-    // requires com.fasterxml.jackson.dataformat.yaml;
-    // requires com.fasterxml.jackson.datatype.jsr310;
+    requires tools.jackson.databind;
     // endregion
 
     // dependency injection using HK2
@@ -179,14 +177,14 @@
     // uses org.eclipse.jgit.lib.Signer;
 
     requires transitive org.jspecify;
+    requires io.github.adr;
 
     // region: other libraries (alphabetically)
     // requires cuid;
     requires com.dlsc.pdfviewfx;
     requires com.pixelduke.fxthemes;
     // requires com.sun.jna;
     // requires dd.plist;
-    requires io.github.adr;
     // required by okhttp and some AI library
     // requires kotlin.stdlib;
     // requires mslinks;
 
@@ -16,6 +16,7 @@
 import javafx.stage.Stage;
 import javafx.stage.WindowEvent;
 
+import org.jabref.gui.clipboard.ClipBoardManager;
 import org.jabref.gui.frame.JabRefFrame;
 import org.jabref.gui.help.VersionWorker;
 import org.jabref.gui.icon.IconTheme;
@@ -207,7 +208,7 @@ public void initialize() {
         JabRefGUI.dialogService = new JabRefDialogService(mainStage);
         Injector.setModelOrService(DialogService.class, dialogService);
 
-        JabRefGUI.clipBoardManager = new ClipBoardManager();
+        JabRefGUI.clipBoardManager = new ClipBoardManager(stateManager);
         Injector.setModelOrService(ClipBoardManager.class, clipBoardManager);
 
         JabRefGUI.aiService = new AiService(
 
@@ -39,6 +39,7 @@
 import org.jabref.gui.autocompleter.SuggestionProviders;
 import org.jabref.gui.autosaveandbackup.AutosaveManager;
 import org.jabref.gui.autosaveandbackup.BackupManager;
+import org.jabref.gui.clipboard.ClipBoardManager;
 import org.jabref.gui.collab.DatabaseChangeMonitor;
 import org.jabref.gui.dialogs.AutosaveUiManager;
 import org.jabref.gui.exporter.SaveDatabaseAction;
@@ -76,6 +77,8 @@
 import org.jabref.logic.util.TaskExecutor;
 import org.jabref.logic.util.io.FileUtil;
 import org.jabref.model.FieldChange;
+import org.jabref.model.TransferInformation;
+import org.jabref.model.TransferMode;
 import org.jabref.model.database.BibDatabase;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.database.event.BibDatabaseContextChangedEvent;
@@ -103,6 +106,8 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import static org.jabref.gui.util.InsertUtil.addEntriesWithFeedback;
+
 /**
  * Represents the ui area where the notifier pane, the library table and the entry editor are shown.
  */
@@ -820,7 +825,7 @@ public void insertEntries(final List<BibEntry> entries) {
             return;
         }
 
-        importHandler.importCleanedEntries(entries);
+        importHandler.importCleanedEntries(null, entries);
         getUndoManager().addEdit(new UndoableInsertEntries(bibDatabaseContext.getDatabase(), entries));
         markBaseChanged();
         stateManager.setSelectedEntries(entries);
@@ -832,26 +837,22 @@ public void insertEntries(final List<BibEntry> entries) {
     }
 
     public void copyEntry() {
-        int entriesCopied = doCopyEntry(getSelectedEntries());
+        int entriesCopied = doCopyEntry(TransferMode.COPY, getSelectedEntries());
         if (entriesCopied >= 0) {
             dialogService.notify(Localization.lang("Copied %0 entry(s)", entriesCopied));
         } else {
             dialogService.notify(Localization.lang("Copy failed", entriesCopied));
         }
     }
 
-    private int doCopyEntry(List<BibEntry> selectedEntries) {
+    private int doCopyEntry(TransferMode transferMode, List<BibEntry> selectedEntries) {
         if (selectedEntries.isEmpty()) {
             return 0;
         }
 
         List<BibtexString> stringConstants = bibDatabaseContext.getDatabase().getUsedStrings(selectedEntries);
         try {
-            if (stringConstants.isEmpty()) {
-                clipBoardManager.setContent(selectedEntries, entryTypesManager);
-            } else {
-                clipBoardManager.setContent(selectedEntries, entryTypesManager, stringConstants);
-            }
+            clipBoardManager.setContent(transferMode, bibDatabaseContext, selectedEntries, entryTypesManager, stringConstants);
             return selectedEntries.size();
         } catch (IOException e) {
             LOGGER.error("Error while copying selected entries to clipboard.", e);
@@ -860,17 +861,26 @@ private int doCopyEntry(List<BibEntry> selectedEntries) {
     }
 
     public void pasteEntry() {
-        List<BibEntry> entriesToAdd;
         String content = ClipBoardManager.getContents();
-        entriesToAdd = importHandler.handleBibTeXData(content);
+        List<BibEntry> entriesToAdd = importHandler.handleBibTeXData(content);
         if (entriesToAdd.isEmpty()) {
             entriesToAdd = handleNonBibTeXStringData(content);
         }
         if (entriesToAdd.isEmpty()) {
             return;
         }
-
-        importHandler.importEntriesWithDuplicateCheck(bibDatabaseContext, entriesToAdd);
+        // Now, the BibEntries to add are known
+        // The definitive insertion needs to happen now.
+        addEntriesWithFeedback(
+                clipBoardManager.getJabRefClipboardTransferData(),
+                entriesToAdd,
+                bibDatabaseContext,
+                Localization.lang("Pasted %0 entry(s) to %1"),
+                Localization.lang("Pasted %0 entry(s) to %1. %2 were skipped"),
+                dialogService,
+                importHandler,
+                stateManager
+        );
     }
 
     private List<BibEntry> handleNonBibTeXStringData(String data) {
@@ -888,12 +898,21 @@ private List<BibEntry> handleNonBibTeXStringData(String data) {
         }
     }
 
-    public void dropEntry(List<BibEntry> entriesToAdd) {
-        importHandler.importEntriesWithDuplicateCheck(bibDatabaseContext, entriesToAdd);
+    public void dropEntry(BibDatabaseContext sourceBibDatabaseContext, List<BibEntry> entriesToAdd) {
+        addEntriesWithFeedback(
+                new TransferInformation(sourceBibDatabaseContext, TransferMode.NONE), // "NONE", because we don't know the modifiers here and thus cannot say whether the attached file (and entry(s)) should be copied or moved
+                entriesToAdd,
+                bibDatabaseContext,
+                Localization.lang("Moved %0 entry(s) to %1"),
+                Localization.lang("Moved %0 entry(s) to %1. %2 were skipped"),
+                dialogService,
+                importHandler,
+                stateManager
+        );
     }
 
     public void cutEntry() {
-        int entriesCopied = doCopyEntry(getSelectedEntries());
+        int entriesCopied = doCopyEntry(TransferMode.MOVE, getSelectedEntries());
         int entriesDeleted = doDeleteEntry(StandardActions.CUT, mainTable.getSelectedEntries());
 
         if (entriesCopied == entriesDeleted) {