Oobranch e : add backend

src/main/java/org/jabref/logic/openoffice/backend/Codec52.java

@@ -0,0 +1,137 @@
+package org.jabref.logic.openoffice.backend;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import org.jabref.model.openoffice.style.CitationType;
+
+/**
+ *  How and what is encoded in reference mark names under JabRef 5.2.
+ *
+ *  - pageInfo does not appear here. It is not encoded in the mark name.
+ */
+class Codec52 {
+    private static final String BIB_CITATION = "JR_cite";
+    private static final Pattern CITE_PATTERN =
+        // Pattern.compile(BIB_CITATION + "(\\d*)_(\\d*)_(.*)");
+        // citationType is always "1" "2" or "3"
+        Pattern.compile(BIB_CITATION + "(\\d*)_([123])_(.*)");
+
+    private Codec52() {
+        /**/
+    }
+
+    /**
+     * This is what we get back from parsing a refMarkName.
+     */
+    public static class ParsedMarkName {
+        /**  "", "0", "1" ... */
+        public final String i;
+        /** in-text-citation type */
+        public final CitationType citationType;
+        /** Citation keys embedded in the reference mark. */
+        public final List<String> citationKeys;
+
+        ParsedMarkName(String i, CitationType citationType, List<String> citationKeys) {
+            Objects.requireNonNull(i);
+            Objects.requireNonNull(citationKeys);
+            this.i = i;
+            this.citationType = citationType;
+            this.citationKeys = citationKeys;
+        }
+    }
+
+    /**
+     * Integer representation was written into the document in JabRef52, keep it for compatibility.
+     */
+    private static CitationType citationTypeFromInt(int i) {
+        return switch (i) {
+            case 1 -> CitationType.AUTHORYEAR_PAR;
+            case 2 -> CitationType.AUTHORYEAR_INTEXT;
+            case 3 -> CitationType.INVISIBLE_CIT;
+            default -> throw new IllegalArgumentException("Invalid CitationType code");
+        };
+    }
+
+    private static int citationTypeToInt(CitationType i) {
+        return switch (i) {
+            case AUTHORYEAR_PAR -> 1;
+            case AUTHORYEAR_INTEXT -> 2;
+            case INVISIBLE_CIT -> 3;
+            default -> throw new IllegalArgumentException("Invalid CitationType");
+        };
+    }
+
+    /**
+     * Produce a reference mark name for JabRef for the given citationType and list citation keys that
+     * does not yet appear among the reference marks of the document.
+     *
+     * @param usedNames    Reference mark names already in use.
+     * @param citationKeys Identifies the cited sources.
+     * @param citationType Encodes the effect of withText and inParenthesis options.
+     *
+     * The first occurrence of citationKeys gets no serial number, the second gets 0, the third 1 ...
+     *
+     * Or the first unused in this series, after removals.
+     */
+    public static String getUniqueMarkName(Set<String> usedNames,
+                                           List<String> citationKeys,
+                                           CitationType citationType) {
+
+        String citationKeysPart = String.join(",", citationKeys);
+
+        int i = 0;
+        int citTypeCode = citationTypeToInt(citationType);
+        String name = BIB_CITATION + '_' + citTypeCode + '_' + citationKeysPart;
+        while (usedNames.contains(name)) {
+            name = BIB_CITATION + i + '_' + citTypeCode + '_' + citationKeysPart;
+            i++;
+        }
+        return name;
+    }
+
+    /**
+     * Parse a JabRef (reference) mark name.
+     *
+     * @return Optional.empty() on failure.
+     *
+     */
+    public static Optional<ParsedMarkName> parseMarkName(String refMarkName) {
+
+        Matcher citeMatcher = CITE_PATTERN.matcher(refMarkName);
+        if (!citeMatcher.find()) {
+            return Optional.empty();
+        }
+
+        List<String> keys = Arrays.asList(citeMatcher.group(3).split(","));
+        String i = citeMatcher.group(1);
+        int citTypeCode = Integer.parseInt(citeMatcher.group(2));
+        CitationType citationType = citationTypeFromInt(citTypeCode);
+        return (Optional.of(new Codec52.ParsedMarkName(i, citationType, keys)));
+    }
+
+    /**
+     * @return true if name matches the pattern used for JabRef
+     * reference mark names.
+     */
+    public static boolean isJabRefReferenceMarkName(String name) {
+        return (CITE_PATTERN.matcher(name).find());
+    }
+
+    /**
+     * Filter a list of reference mark names by `isJabRefReferenceMarkName`
+     *
+     * @param names The list to be filtered.
+     */
+    public static List<String> filterIsJabRefReferenceMarkName(List<String> names) {
+        return (names.stream()
+                     .filter(Codec52::isJabRefReferenceMarkName)
+                     .collect(Collectors.toList()));
+    }
+}

src/main/java/org/jabref/logic/openoffice/backend/GetContext.java

@@ -0,0 +1,81 @@
+package org.jabref.logic.openoffice.backend;
+
+import com.sun.star.text.XTextCursor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Utility methods for processing OO Writer documents.
+ */
+public class GetContext {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(GetContext.class);
+
+    private GetContext() {
+        // Just to hide the public constructor
+    }
+
+    /**
+     *  Get the text belonging to cursor with up to
+     *  charBefore and charAfter characters of context.
+     *
+     *  The actual context may be smaller than requested.
+     *
+     *  @param cursor
+     *  @param charBefore Number of characters requested.
+     *  @param charAfter  Number of characters requested.
+     *  @param htmlMarkup If true, the text belonging to the reference mark is surrounded by bold
+     *                    html tag.
+     *
+     */
+    public static String getCursorStringWithContext(XTextCursor cursor,
+                                                    int charBefore,
+                                                    int charAfter,
+                                                    boolean htmlMarkup) {
+
+        String citPart = cursor.getString();
+
+        // extend cursor range left
+        int flex = 8;
+        for (int i = 0; i < charBefore; i++) {
+            try {
+                cursor.goLeft((short) 1, true);
+                // If we are close to charBefore and see a space, then cut here. Might avoid cutting
+                // a word in half.
+                if ((i >= (charBefore - flex))
+                    && Character.isWhitespace(cursor.getString().charAt(0))) {
+                    break;
+                }
+            } catch (IndexOutOfBoundsException ex) {
+                LOGGER.warn("Problem going left", ex);
+            }
+        }
+
+        int lengthWithBefore = cursor.getString().length();
+        int addedBefore = lengthWithBefore - citPart.length();
+
+        cursor.collapseToStart();
+        for (int i = 0; i < (charAfter + lengthWithBefore); i++) {
+            try {
+                cursor.goRight((short) 1, true);
+                if (i >= ((charAfter + lengthWithBefore) - flex)) {
+                    String strNow = cursor.getString();
+                    if (Character.isWhitespace(strNow.charAt(strNow.length() - 1))) {
+                        break;
+                    }
+                }
+            } catch (IndexOutOfBoundsException ex) {
+                LOGGER.warn("Problem going right", ex);
+            }
+        }
+
+        String result = cursor.getString();
+        if (htmlMarkup) {
+            result = (result.substring(0, addedBefore)
+                      + "<b>" + citPart + "</b>"
+                      + result.substring(lengthWithBefore));
+        }
+        return result.trim();
+    }
+
+}

src/main/java/org/jabref/logic/openoffice/backend/NamedRangeManagerReferenceMark.java

@@ -0,0 +1,46 @@
+package org.jabref.logic.openoffice.backend;
+
+import java.util.List;
+import java.util.Optional;
+
+import org.jabref.model.openoffice.backend.NamedRange;
+import org.jabref.model.openoffice.backend.NamedRangeManager;
+import org.jabref.model.openoffice.uno.CreationException;
+import org.jabref.model.openoffice.uno.NoDocumentException;
+import org.jabref.model.openoffice.uno.UnoReferenceMark;
+
+import com.sun.star.lang.WrappedTargetException;
+import com.sun.star.text.XTextCursor;
+import com.sun.star.text.XTextDocument;
+
+public class NamedRangeManagerReferenceMark implements NamedRangeManager {
+
+    @Override
+    public NamedRange createNamedRange(XTextDocument doc,
+                                       String refMarkName,
+                                       XTextCursor position,
+                                       boolean insertSpaceAfter,
+                                       boolean withoutBrackets)
+        throws
+        CreationException {
+        return NamedRangeReferenceMark.create(doc, refMarkName, position, insertSpaceAfter, withoutBrackets);
+    }
+
+    @Override
+    public List<String> getUsedNames(XTextDocument doc)
+        throws
+        NoDocumentException {
+        return UnoReferenceMark.getListOfNames(doc);
+    }
+
+    @Override
+    public Optional<NamedRange> getNamedRangeFromDocument(XTextDocument doc, String refMarkName)
+        throws
+        NoDocumentException,
+        WrappedTargetException {
+        return (NamedRangeReferenceMark
+                .getFromDocument(doc, refMarkName)
+                .map(x -> x));
+    }
+}
+