Imnprove PDF-Importer use convenience constructors, normalize wrap blocks and ExtractorMatchers

Replace the verbose three-line subject lambda with the AccountTransaction(Type) convenience constructor introduced in #5614 across all PDF importers.

   **Additionally:**
   - Add BuySellEntry(PortfolioTransaction.Type) and PortfolioTransaction(Type) convenience constructors and apply the same single-line subject lambda pattern to all BuySellEntry and PortfolioTransaction subject lambdas
   - Convert the remaining three verbose AccountTransferEntry subject lambdas to method references (AccountTransferEntry::new)
   - Replace setCurrencyCode(CurrencyUnit.X) with setCurrencyCode(asCurrencyCode("X"))
   - Add missing t.getCurrencyCode() != null guard to bare t.getAmount() == 0 checks
   - Normalize all simple wrap blocks to a consistent if/return SkippedItem format, removing intermediate item variables and unused ctx parameters
   - Add final modifier to all var type = new DocumentType(...) declarations

   **Improvement Arkéa Direct Bank and ExtractorMatchers**
   - Extend `hasExDate(String)` to accept `null`, allowing dividend tests to explicitly assert that no ex-date is present in a document
   - Add `hasExDate(null)` assertions to all three dividend tests to document the absence of an ex-date in Arkéa Direct Bank documents

   **Normalize currency handling in DocumentContext**
   - Extend `hasExDate(String)` to accept `null`, allowing dividend tests to explicitly assert that no ex-date is present in a document
   - Add `hasExDate(null)` assertions to all three dividend tests to document the absence of an ex-date in Arkéa Direct Bank documents

   **Normalize currency handling in DocumentContext**
   - Fix missing asCurrencyCode() in ctx.put("currency", ...) in BundesschatzPDFExtractor (two document types stored the raw captured string instead of the normalized currency code)
   - Remove redundant asCurrencyCode() wrapping in 15 extractors where currency is read back via .documentContext("currency") — the value stored in the context is already normalized, so the second call was unnecessary
   (affected: ABNAMROGroup, AkfBank, AudiBank, AustrianAnadi, BarclaysBankIreland, BawagAG, BoursesDirect, Bundesschatz, Crowdestor, DKB, INGDiBa, RaiffeisenBankgruppe, SantanderConsumerBank, Tradegate, VolkswagenBank)

   **Normalize currency handling — fixed-currency extractors and raw section reads**
   - Introduce `private static final String XXX = "XXX"` constants and replace all `CurrencyUnit.XXX` object references and unwrapped bare string literals with `asCurrencyCode(XXX)` in fixed-currency extractors (affected:
   LimeTradingCorp, FidelityInternational, Computershare, AvivaPLC, ScorePriorityInc, Simpel, Sunrise, SutorBankGmbH, KFintech)
   - Wrap `v.put("currency", stripBlanks(...))` with `asCurrencyCode()` where currency is captured from raw PDF text (affected: Comdirect 4×, Commerzbank 1×, LibertyVorsorgeAG 7×)
   - Wrap `v.put("currency", v.get("currency1/2"))` with `asCurrencyCode()` for currency1/currency2 relay patterns (affected: Consorsbank 12×, DZBankGruppe 6×, DKB 6×, INGDiBa 6×, Postbank 6×)
   - Wrap `Money.of(v.get("currency/feeCurrency"), ...)` with `asCurrencyCode()` in BSDEXPDFExtractor where both currency fields are extracted locally from raw PDF text (8× across buy/sell sections)

   **Improve asCurrencyCode() in AbstractPDFExtractor and fix TextUtil.trim()**
   - Replace `currency.trim()` (Java's String.trim, strips only ASCII ≤ 0x20) with `TextUtil.trim()` (already statically imported) which additionally handles Unicode spaces such as U+00A0 (NO-BREAK SPACE) and U+FEFF
   (Zero-Width BOM)
   - Fix asymmetric bug in `TextUtil.trim()`: the trailing whitespace loop used `Character.isWhitespace()` while the leading loop used the more comprehensive `TextUtil.isWhitespace()` — U+00A0, U+202F and U+FEFF were
   therefore trimmed leading but not trailing; both loops now use `TextUtil.isWhitespace()`
   - As a side effect, `MessagesTest` now detects a stray U+202F (NARROW NO-BREAK SPACE) trailing in the Spanish translation key `AttributeSettings_LimitPrice_ColorSettings` — removed
   - Add `TextUtilTest.testTrim()` covering regular whitespace, U+00A0 and U+FEFF trimming on both sides
   - Add `AbstractPDFExtractorTest` covering: standard ISO codes, U+00A0 trimming, regular whitespace trimming, null input, and unknown-code fallback to base currency

Author: Nirus2000

.claude/rules/pdfextractors.md

@@ -20,6 +20,84 @@ PDF importers extract transactions from bank and broker PDF statements.
   - Consistency in coding style between all extractors is more important than nice code.
   - Add comment-blocks with `@formatter:off` and `@formatter:on` before each section-block showing the format that is handled there.
 
+## Conventions
+
+**DocumentType declaration** — always `final`:
+```java
+final var type = new DocumentType("...");
+```
+
+**subject() lambda** — always use the single-argument convenience constructor or method reference, never the verbose 3-line form:
+```java
+// correct
+.subject(() -> new AccountTransaction(AccountTransaction.Type.DIVIDENDS))
+.subject(() -> new BuySellEntry(PortfolioTransaction.Type.BUY))
+.subject(() -> new PortfolioTransaction(PortfolioTransaction.Type.DELIVERY_INBOUND))
+.subject(AccountTransferEntry::new)   // no Type parameter — use method reference
+
+// wrong
+.subject(() -> {
+    var t = new AccountTransaction();
+    t.setType(AccountTransaction.Type.DIVIDENDS);
+    return t;
+})
+```
+
+**setCurrencyCode** — always use `asCurrencyCode()`, never `CurrencyUnit` constants:
+```java
+t.setCurrencyCode(asCurrencyCode("EUR"));   // correct
+t.setCurrencyCode(CurrencyUnit.EUR);         // wrong
+```
+
+**Fixed-currency extractors** — when an extractor always deals with one currency (e.g. a USD-only broker), declare a private String constant and use it with `asCurrencyCode()`. Keep `asCurrencyCode()` — it has normalization side-effects even for known codes:
+```java
+private static final String USD = "USD";
+
+v.put("currency", asCurrencyCode(USD));          // correct
+v.put("currency", CurrencyUnit.USD);              // wrong — CurrencyUnit object, not String
+v.put("currency", asCurrencyCode("USD"));         // works but prefer named constant
+```
+
+**DocumentContext currency** — when storing currency into the document context, always normalize with `asCurrencyCode()`. When the value is later read back via `.documentContext("currency")`, it is already normalized — do NOT wrap it with `asCurrencyCode()` again:
+```java
+// storing — always normalize
+.assign((ctx, v) -> ctx.put("currency", asCurrencyCode(v.get("currency"))))  // correct
+.assign((ctx, v) -> ctx.put("currency", v.get("currency")))                   // wrong
+
+// reading via documentContext — already normalized, no wrapping needed
+.section("tax").optional()
+.documentContext("currency")
+.assign((t, v) -> {
+    var tax = Money.of(v.get("currency"), asAmount(v.get("tax")));             // correct
+    var tax = Money.of(asCurrencyCode(v.get("currency")), asAmount(...));      // wrong — redundant
+})
+
+// reading via local .section — currency is raw, asCurrencyCode() is required
+.section("tax", "currency").optional()
+.assign((t, v) -> {
+    var tax = Money.of(asCurrencyCode(v.get("currency")), asAmount(v.get("tax")));  // correct
+})
+```
+
+**wrap() block** — use the canonical `if/return SkippedItem` form; no ternary, no intermediate `item` variable, no unused `ctx` parameter. Always guard the amount check with a currency code null-check:
+```java
+// AccountTransaction
+.wrap(t -> {
+    if (t.getCurrencyCode() != null && t.getAmount() == 0)
+        return new SkippedItem(new TransactionItem(t), Messages.MsgErrorTransactionTypeNotSupportedOrRequired);
+
+    return new TransactionItem(t);
+})
+
+// BuySellEntry
+.wrap(t -> {
+    if (t.getPortfolioTransaction().getCurrencyCode() != null && t.getPortfolioTransaction().getAmount() == 0)
+        return new SkippedItem(new BuySellEntryItem(t), Messages.MsgErrorTransactionTypeNotSupportedOrRequired);
+
+    return new BuySellEntryItem(t);
+})
+```
+
 
 # Testing
 Test methods should be in following structure
@@ -61,8 +139,37 @@ public void testWertpapierKauf01()
 }
 ```
 
+`withFailureMessage(...)` assertions follow this structure — the `//` after the opening parenthesis is required:
+
+```java
+// check failure message
+assertThat(results, hasItem(withFailureMessage( //
+                Messages.MsgErrorTransactionOrderCancellationUnsupported, //
+                dividend( //
+                                hasDate("2022-06-13"), hasExDate(null), //
+                                hasShares(10.672), //
+                                hasSource("DividendeStorno01.txt"), //
+                                hasNote("Vorgangs-Nr.: XXXXX"), //
+                                hasAmount("EUR", 7.04), hasGrossValue("EUR", 7.04), //
+                                hasTaxes("EUR", 0.00), hasFees("EUR", 0.00)))));
+```
+`skippedItem(...)` assertions follow the same structure — the `//` after the opening parenthesis is required:
+
+```java
+// check skipped item
+assertThat(results, hasItem(skippedItem( //
+                Messages.MsgErrorTransactionTypeNotSupportedOrRequired, //
+                purchase( //
+                                hasDate("2012-07-02T00:00"), hasShares(0.00), //
+                                hasSource("Quartalsbericht06.txt"), //
+                                hasNote(null), //
+                                hasAmount("EUR", 0.00), hasGrossValue("EUR", 0.00), //
+                                hasTaxes("EUR", 0.00), hasFees("EUR", 0.00)))));
+```
+
 - Each method has a starting `assertThat`-Block checking the counts. All 8 assertions need to be present.
 - Use `//` to enforce line-breaks when checking securities and transactions
 - Include time (hours, minutes, seconds) in `hasDate` when the source document provides it.
 - The `ExtractorMatchers`-class contains test assertion helpers
 - The fees and taxes could consist of multiple values, do not merge or consolidate them for better understanding
+- Every `dividend(...)` assertion must include `hasExDate(...)`. The correct value comes from the JUnit test failure message: look for `dividend with exDate = <value>` in the mismatch output. Use that exact value. If the extractor does not extract an ex-date, the actual value will be `null`.

name.abuchen.portfolio.tests/src/name/abuchen/portfolio/datatransfer/ExtractorMatchers.java

@@ -95,7 +95,7 @@ public ExtractorItemMatcher(String label, Function<Extractor.Item, V> transactio
         @Override
         protected boolean matchesSafely(Extractor.Item item, Description mismatchDescription)
         {
-            V tx = transaction.apply(item);
+            var tx = transaction.apply(item);
             if (tx == null)
             {
                 mismatchDescription.appendText("\n* not a '").appendText(label).appendText("' item"); //$NON-NLS-1$ //$NON-NLS-2$
@@ -206,7 +206,7 @@ protected boolean matchesSafely(Extractor.Item item, Description mismatchDescrip
                 return false;
             }
 
-            boolean result = matcher.matches(item);
+            var result = matcher.matches(item);
             if (!result)
             {
                 matcher.describeMismatch(item, mismatchDescription);
@@ -369,7 +369,7 @@ public static Matcher<Extractor.Item> feeRefund(Matcher<Transaction>... properti
     @SafeVarargs
     public static Matcher<Extractor.Item> inboundCash(Matcher<Transaction>... properties)
     {
-        return new ExtractorItemMatcher<Transaction>("cash transfer", //$NON-NLS-1$
+        return new ExtractorItemMatcher<>("cash transfer", //$NON-NLS-1$
                         item -> item instanceof AccountTransferItem transfer //
                                         && transfer.getSubject() instanceof AccountTransferEntry entry
                                                         ? entry.getTargetTransaction()
@@ -380,7 +380,7 @@ public static Matcher<Extractor.Item> inboundCash(Matcher<Transaction>... proper
     @SafeVarargs
     public static Matcher<Extractor.Item> outboundCash(Matcher<Transaction>... properties)
     {
-        return new ExtractorItemMatcher<Transaction>("cash transfer", //$NON-NLS-1$
+        return new ExtractorItemMatcher<>("cash transfer", //$NON-NLS-1$
                         item -> item instanceof AccountTransferItem transfer //
                                         && transfer.getSubject() instanceof AccountTransferEntry entry
                                                         ? entry.getSourceTransaction()
@@ -391,7 +391,7 @@ public static Matcher<Extractor.Item> outboundCash(Matcher<Transaction>... prope
     @SafeVarargs
     public static Matcher<Extractor.Item> purchase(Matcher<Transaction>... properties)
     {
-        return new ExtractorItemMatcher<Transaction>("purchase", //$NON-NLS-1$
+        return new ExtractorItemMatcher<>("purchase", //$NON-NLS-1$
                         item -> item instanceof BuySellEntryItem buysell //
                                         && buysell.getSubject() instanceof BuySellEntry entry
                                         && entry.getPortfolioTransaction().getType() == PortfolioTransaction.Type.BUY
@@ -403,7 +403,7 @@ public static Matcher<Extractor.Item> purchase(Matcher<Transaction>... propertie
     @SafeVarargs
     public static Matcher<Extractor.Item> sale(Matcher<Transaction>... properties)
     {
-        return new ExtractorItemMatcher<Transaction>("sale", //$NON-NLS-1$
+        return new ExtractorItemMatcher<>("sale", //$NON-NLS-1$
                         item -> item instanceof BuySellEntryItem buysell //
                                         && buysell.getSubject() instanceof BuySellEntry entry
                                         && entry.getPortfolioTransaction().getType() == PortfolioTransaction.Type.SELL
@@ -415,7 +415,7 @@ public static Matcher<Extractor.Item> sale(Matcher<Transaction>... properties)
     @SafeVarargs
     public static Matcher<Extractor.Item> inboundDelivery(Matcher<Transaction>... properties)
     {
-        return new ExtractorItemMatcher<Transaction>("inbound delivery", //$NON-NLS-1$
+        return new ExtractorItemMatcher<>("inbound delivery", //$NON-NLS-1$
                         item -> item instanceof TransactionItem tItem //
                                         && tItem.getSubject() instanceof PortfolioTransaction tx
                                         && tx.getType() == PortfolioTransaction.Type.DELIVERY_INBOUND ? tx : null, //
@@ -425,7 +425,7 @@ public static Matcher<Extractor.Item> inboundDelivery(Matcher<Transaction>... pr
     @SafeVarargs
     public static Matcher<Extractor.Item> outboundDelivery(Matcher<Transaction>... properties)
     {
-        return new ExtractorItemMatcher<Transaction>("outbound delivery", //$NON-NLS-1$
+        return new ExtractorItemMatcher<>("outbound delivery", //$NON-NLS-1$
                         item -> item instanceof TransactionItem tItem //
                                         && tItem.getSubject() instanceof PortfolioTransaction tx
                                         && tx.getType() == PortfolioTransaction.Type.DELIVERY_OUTBOUND ? tx : null, //
@@ -435,7 +435,7 @@ public static Matcher<Extractor.Item> outboundDelivery(Matcher<Transaction>... p
     @SafeVarargs
     public static Matcher<Extractor.Item> securityTransfer(Matcher<Transaction>... properties)
     {
-        return new ExtractorItemMatcher<Transaction>("securityTransfer", //$NON-NLS-1$
+        return new ExtractorItemMatcher<>("securityTransfer", //$NON-NLS-1$
                         item -> item instanceof PortfolioTransferItem transfer //
                                         && transfer.getSubject() instanceof PortfolioTransferEntry entry
                                                         ? entry.getSourceTransaction()
@@ -451,7 +451,7 @@ public static Matcher<Transaction> hasSecurity(Matcher<Security>... properties)
 
     public static Matcher<Transaction> hasDate(String dateString)
     {
-        LocalDateTime expectecd = dateString.contains("T") //$NON-NLS-1$
+        var expectecd = dateString.contains("T") //$NON-NLS-1$
                         ? LocalDateTime.parse(dateString)
                         : LocalDate.parse(dateString).atStartOfDay();
 
@@ -462,9 +462,10 @@ public static Matcher<Transaction> hasDate(String dateString)
 
     public static Matcher<Transaction> hasExDate(String dateString)
     {
-        var expected = dateString.contains("T") //$NON-NLS-1$
-                        ? LocalDateTime.parse(dateString)
-                        : LocalDate.parse(dateString).atStartOfDay();
+        var expected = dateString == null ? null
+                        : dateString.contains("T") //$NON-NLS-1$
+                                        ? LocalDateTime.parse(dateString)
+                                        : LocalDate.parse(dateString).atStartOfDay();
 
         return new PropertyMatcher<>("exDate", //$NON-NLS-1$
                         expected, //
@@ -474,7 +475,7 @@ public static Matcher<Transaction> hasExDate(String dateString)
     public static Matcher<Transaction> hasShares(double value)
     {
         // work with BigDecimal to have better assertion failed messages
-        return new PropertyMatcher<Transaction, BigDecimal>("shares", //$NON-NLS-1$
+        return new PropertyMatcher<>("shares", //$NON-NLS-1$
                         BigDecimal.valueOf(value).setScale(Values.Share.precision(), Values.MC.getRoundingMode()), //
                         tx -> BigDecimal.valueOf(tx.getShares()).divide(Values.Share.getBigDecimalFactor(), Values.MC)
                                         .setScale(Values.Share.precision(), Values.MC.getRoundingMode()));
@@ -511,7 +512,7 @@ public static Matcher<Transaction> hasForexGrossValue(String currencyCode, doubl
         return new PropertyMatcher<>("forexGrossValue", //$NON-NLS-1$
                         Money.of(currencyCode, Values.Amount.factorize(value)), //
                         tx -> {
-                            Unit grossValueUnit = tx.getUnit(Unit.Type.GROSS_VALUE).orElseThrow(AssertionError::new);
+                            var grossValueUnit = tx.getUnit(Unit.Type.GROSS_VALUE).orElseThrow(AssertionError::new);
                             return grossValueUnit.getForex();
                         });
     }
@@ -547,7 +548,7 @@ public static Matcher<Transaction> check(Consumer<Transaction> check)
     @SafeVarargs
     public static Matcher<Extractor.Item> security(Matcher<Security>... properties)
     {
-        return new ExtractorItemMatcher<Security>("security", //$NON-NLS-1$
+        return new ExtractorItemMatcher<>("security", //$NON-NLS-1$
                         item -> item instanceof SecurityItem securityItem ? securityItem.getSecurity() : null,
                         properties);
     }
@@ -590,7 +591,7 @@ public static Matcher<Security> hasFeed(String quoteFeed)
 
     public static Matcher<Security> hasFeedProperty(String name, String value)
     {
-        return new PropertyMatcher<Security, String>("feedProperty " + name, value, //$NON-NLS-1$
+        return new PropertyMatcher<>("feedProperty " + name, value, //$NON-NLS-1$
                         s -> s.getPropertyValue(SecurityProperty.Type.FEED, name).orElse(null));
     }
 

name.abuchen.portfolio.tests/src/name/abuchen/portfolio/datatransfer/ExtractorMatchersTest.java

@@ -49,7 +49,7 @@ public class ExtractorMatchersTest
     @BeforeClass
     public static void setup()
     {
-        Security s = new Security();
+        var s = new Security();
         s.setName("test name");
         s.setIsin("DE01");
         s.setWkn("WKN");
@@ -58,7 +58,7 @@ public static void setup()
 
         someSecurity = new SecurityItem(s);
 
-        AccountTransaction tx = new AccountTransaction();
+        var tx = new AccountTransaction();
         tx.setType(AccountTransaction.Type.DIVIDENDS);
         tx.setCurrencyCode(CurrencyUnit.EUR);
         tx.setAmount(Values.Amount.factorize(100));
@@ -87,7 +87,7 @@ public void testEmptyList()
     @Test(expected = AssertionError.class)
     public void testList()
     {
-        List<Extractor.Item> items = new ArrayList<Extractor.Item>();
+        List<Extractor.Item> items = new ArrayList<>();
 
         items.add(new Extractor.TransactionItem(new AccountTransaction()));
 
@@ -97,11 +97,11 @@ public void testList()
     @Test(expected = AssertionError.class)
     public void testDividend()
     {
-        List<Extractor.Item> items = new ArrayList<Extractor.Item>();
+        List<Extractor.Item> items = new ArrayList<>();
 
         items.add(someTransactionItem);
 
-        AccountTransaction tx = new AccountTransaction();
+        var tx = new AccountTransaction();
         tx.setType(AccountTransaction.Type.DIVIDENDS);
         tx.setCurrencyCode(CurrencyUnit.EUR);
         tx.setAmount(1000);
@@ -278,6 +278,24 @@ public void testExDateSuccess()
         assertThat(List.of(someTransactionItem), hasItem(dividend(hasExDate("2023-04-28"))));
     }
 
+    @Test(expected = AssertionError.class)
+    public void testExDateNullFailure()
+    {
+        assertThat(List.of(someTransactionItem), hasItem(dividend(hasExDate(null))));
+    }
+
+    @Test
+    public void testExDateNullSuccess()
+    {
+        var tx = new AccountTransaction();
+        tx.setType(AccountTransaction.Type.DIVIDENDS);
+        tx.setCurrencyCode(CurrencyUnit.EUR);
+        tx.setAmount(Values.Amount.factorize(100));
+        tx.setDateTime(LocalDateTime.parse("2023-04-30T12:45"));
+
+        assertThat(List.of(new TransactionItem(tx)), hasItem(dividend(hasExDate(null))));
+    }
+
     @Test(expected = AssertionError.class)
     public void testSkippedItemNotSkipped()
     {