Fixes generated bibtex key and display of institute authors (#6479)

* Fix Pattern.compile for frequently used regexes

* Fix one additional Pattern.compile

* Fix style and unnecessary escape sequences

* Fix invalid index in call to substring

The original condition is evaluated to false.
The substring is shorter than "uni".

* Refactor name and javadoc of a regex

* Fix use of compiled regex for matching department

* Fix check for uppercase letter

Perhaps the assumption should be that the letters are ASCII.
If all letters are ASCII checking 'A' <= k.charAt(0) <= 'Z'
might make more sense.
I am not convinced about doing this with a regex.

* Fix usage of uncompiled regex

* Fix readability?

* Add test cases

Both test cases involves an author name containing department or school
 without university or institute of technology.

* Fix `null` appearing as part of author name

Corporate authors without university/institute of technology

* Refactor name of capital regex pattern

* Add debug output for reordering of names in fields

* Add helper methods

* Fix missing negation in "uni" matching

* Fix test cases for corporate authors

* Fix to keep all uppercase letters in abbreviation

* Fix commented out code

* Fix key for institution's name containing keyword

If the name of an institution can't be split, assume that
"School"/"Department" is part of the name.

* Fix test case for short institution name

* Refactor check for institution types

* Refactor comments and names improving readability?

* Refactor to improve readability and closure

* Fix JavaDoc

Minor typos and the "rest" part is now created differently.

* Fix JavaDoc typos

* Fix preliminary order for authors -> latexfree

* Drop logger

* Add convenience methods for cached latexfree names

* Add name format method for names containing latex

* Add call to formatNameLatexFree

* Fix unclear statement in JavaDoc

* Fix to only keep the first character of each word

There are some examples that will turn out wrong if only capital letters
 are kept, e.g., "iOS Developer University Program".
 The original problem with "The School of Life" becoming too short is
 avoided by only removing school/department for names containing two or
  more ',' separated strings. This will still produce an unexpected
   result if the address of the institution is part of the authors field

* Add latexfree Natbib test cases

* Fix typo in latex-free test cases

* Add Natbib test with escaped brackets

* Add Natbib institution test with escaped brackets

* Add test for latex-free comma separated lastnames

* Add test for latex-free comma separated first name

First name first and abbreviated first name first

* Add test for latex-free comma separated last name

Last name first and abbreviated first names

* Fix adherence to JavaDoc and readability(?)

* Fix readability(?)

* Fix CheckStyle issues

The deprecated static methods BibtexKeyGenerator.generateKey are moved
to the test file as a similar convenience method is required for
the test cases. Suppress warning has been added for some methods.

* Fix CHANGELOG.md

* Fix mistake in BibtexKeyGeneratorTest

generateKey was not copy-pasted properly.

* Add test for oxford comma

* Fix miss-capitalization of enum

* Fix fields not displayed latex-free

* Fix in-line methods in MainTableNameFormatter

* Fix in-line of generateKey() method

* Fix separating tests into parsing/representation

* Fix cache check and simplify expressions

* Drop inlined methods

* Fix most abbreviated abbreviations

* Drop old formatName method

* Refactor formatNameLatexFree

The author list parsing is moved outside of the if/else statements

* Refactor new parse tests

* Add more parse tests

* Drop all test cases containing escaped brackets

* Refactor parse with latex tests

Move them close to other parse tests

* Fix my own spelling mistakes

* Refactor abbreviation name

Author: k3KAW8Pnf7mkmdSMPHz27

CHANGELOG.md

@@ -75,6 +75,8 @@ Note that this project **does not** adhere to [Semantic Versioning](http://semve
 - We fixed an issue where brackets in regular expressions were not working. [6469](https://github.com/JabRef/jabref/pull/6469)
 - We fixed an issue where LaTeX citations for specific commands (\autocites) of biblatex-mla were not recognized. [#6476](https://github.com/JabRef/jabref/issues/6476)
 - We fixed an issue where drag and drop was not working on empty database. [#6487](https://github.com/JabRef/jabref/issues/6487)
+- We fixed an issue where "null" appeared in generated BibTeX keys. [#6459](https://github.com/JabRef/jabref/issues/6459)
+- We fixed an issue where the authors' names were incorrectly displayed in the authors' column when they were bracketed. [#6465](https://github.com/JabRef/jabref/issues/6465) [#6459](https://github.com/JabRef/jabref/issues/6459)
 
 ### Removed
 

src/main/java/org/jabref/gui/maintable/BibEntryTableViewModel.java

@@ -115,28 +115,27 @@ public ObservableValue<String> getFields(OrFields fields) {
         ObservableValue<String> value = fieldValues.get(fields);
         if (value != null) {
             return value;
-        } else {
-            value = Bindings.createStringBinding(() -> {
-                boolean isName = false;
+        }
 
-                Optional<String> content = Optional.empty();
-                for (Field field : fields) {
-                    content = entry.getResolvedFieldOrAliasLatexFree(field, database);
-                    if (content.isPresent()) {
-                        isName = field.getProperties().contains(FieldProperty.PERSON_NAMES);
-                        break;
-                    }
-                }
+        value = Bindings.createStringBinding(() -> {
+            for (Field field : fields) {
+                if (field.getProperties().contains(FieldProperty.PERSON_NAMES)) {
+                    Optional<String> name = entry.getResolvedFieldOrAlias(field, database);
 
-                String result = content.orElse(null);
-                if (isName) {
-                    return nameFormatter.formatName(result);
+                    if (name.isPresent()) {
+                        return nameFormatter.formatNameLatexFree(name.get());
+                    }
                 } else {
-                    return result;
+                    Optional<String> content = entry.getResolvedFieldOrAliasLatexFree(field, database);
+
+                    if (content.isPresent()) {
+                        return content.get();
+                    }
                 }
-            }, entry.getObservables());
-            fieldValues.put(fields, value);
-            return value;
-        }
+            }
+            return "";
+        }, entry.getObservables());
+        fieldValues.put(fields, value);
+        return value;
     }
 }

src/main/java/org/jabref/gui/maintable/MainTableNameFormatter.java

@@ -20,26 +20,28 @@ public class MainTableNameFormatter {
     }
 
     /**
-     * Format a name field for the table, according to user preferences.
+     * Format a name field for the table, according to user preferences and with latex expressions translated if
+     * possible.
      *
      * @param nameToFormat The contents of the name field.
      * @return The formatted name field.
      */
-    public String formatName(final String nameToFormat) {
+    public String formatNameLatexFree(final String nameToFormat) {
         if (nameToFormat == null) {
             return null;
         }
+        AuthorList authors = AuthorList.parse(nameToFormat);
 
         if (namesAsIs) {
             return nameToFormat;
         } else if (namesNatbib) {
-            return AuthorList.fixAuthorNatbib(nameToFormat);
+            return authors.getAsNatbibLatexFree();
         } else if (namesLastOnly) {
-            return AuthorList.fixAuthorLastNameOnlyCommas(nameToFormat, false);
+            return authors.getAsLastNamesLatexFree(false);
         } else if (namesFf) {
-            return AuthorList.fixAuthorFirstNameFirstCommas(nameToFormat, abbrAuthorNames, false);
+            return authors.getAsFirstLastNamesLatexFree(abbrAuthorNames, false);
         } else {
-            return AuthorList.fixAuthorLastNameFirstCommas(nameToFormat, abbrAuthorNames, false);
+            return authors.getAsLastFirstNamesLatexFree(abbrAuthorNames, false);
         }
     }
 }

src/main/java/org/jabref/logic/bibtexkeypattern/BracketedPattern.java

@@ -3,13 +3,15 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.EnumSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Scanner;
 import java.util.StringJoiner;
 import java.util.StringTokenizer;
+import java.util.function.Predicate;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -41,9 +43,54 @@
 public class BracketedPattern {
     private static final Logger LOGGER = LoggerFactory.getLogger(BracketedPattern.class);
 
-    private static final String STARTING_CAPITAL_PATTERN = "[^A-Z]";
     private static final int CHARS_OF_FIRST = 5;
-    private static final Pattern REGEX_PATTERN = Pattern.compile(".*\\(\\{([A-Z]+)\\}\\).*");
+
+    /** Matches everything that is not an uppercase ASCII letter */
+    private static final Pattern NOT_CAPITAL_FIRST_CHARACTER = Pattern.compile("[^A-Z]");
+    /** Matches with "({[A-Z]}+)", which should be used to abbreviate the name of an institution */
+    private static final Pattern ABBREVIATIONS = Pattern.compile(".*\\(\\{[A-Z]+}\\).*");
+    /** Matches with "dep"/"dip", case insensitive */
+    private static final Pattern DEPARTMENTS = Pattern.compile("^d[ei]p.*", Pattern.CASE_INSENSITIVE);
+    private enum Institution {
+        SCHOOL,
+        DEPARTMENT,
+        UNIVERSITY,
+        TECHNOLOGY;
+
+        /** Matches "uni" at the start of a string or after a space, case insensitive */
+        private static final Pattern UNIVERSITIES = Pattern.compile("^uni.*", Pattern.CASE_INSENSITIVE);
+        /** Matches with "tech", case insensitive */
+        private static final Pattern TECHNOLOGICAL_INSTITUTES = Pattern.compile("^tech.*", Pattern.CASE_INSENSITIVE);
+        /** Matches with "dep"/"dip"/"lab", case insensitive */
+        private static final Pattern DEPARTMENTS_OR_LABS = Pattern.compile("^(d[ei]p|lab).*", Pattern.CASE_INSENSITIVE);
+
+        /**
+         * Find which types of institutions have words in common with the given name parts.
+         * @param nameParts a list of words that constitute parts of an institution's name.
+         * @return set containing all types that matches
+         */
+        public static EnumSet<Institution> findTypes(List<String> nameParts) {
+            EnumSet<Institution> parts = EnumSet.noneOf(Institution.class);
+            // Deciding about a part type…
+            for (String namePart : nameParts) {
+                if (UNIVERSITIES.matcher(namePart).matches()) {
+                    parts.add(Institution.UNIVERSITY);
+                } else if (TECHNOLOGICAL_INSTITUTES.matcher(namePart).matches()) {
+                    parts.add(Institution.TECHNOLOGY);
+                } else if (StandardField.SCHOOL.getName().equalsIgnoreCase(namePart)) {
+                    parts.add(Institution.SCHOOL);
+                } else if (DEPARTMENTS_OR_LABS.matcher(namePart).matches()) {
+                    parts.add(Institution.DEPARTMENT);
+                }
+            }
+
+            if (parts.contains(Institution.TECHNOLOGY)) {
+                parts.remove(Institution.UNIVERSITY); // technology institute isn't university :-)
+            }
+
+            return parts;
+        }
+    }
 
     private final String pattern;
 
@@ -1200,8 +1247,8 @@ private static boolean isInstitution(String author) {
      *
      * <p>
      * An institution name should be inside <code>{}</code> brackets. If the
-     * institution name also includes its abbreviation this abbreviation should
-     * be also in <code>{}</code> brackets. For the previous example the value
+     * institution name includes its abbreviation this abbreviation should
+     * be in <code>{}</code> brackets. For the previous example the value
      * should look like:
      * <code>{The Attributed Graph Grammar System ({AGG})}</code>.
      * </p>
@@ -1213,33 +1260,34 @@ private static boolean isInstitution(String author) {
      *
      * <p>
      * If an institution does not include its abbreviation the key should be
-     * generated form its name in the following way:
+     * generated from its name in the following way:
      * </p>
      *
      * <p>
      * The institution value can contain: institution name, part of the
-     * institution, address, etc. Those information should be separated by
-     * comma. Name of the institution and possible part of the institution
-     * should be on the beginning, while address and secondary information
-     * should be on the end.
+     * institution, address, etc. These values should be comma separated.
+     * Institution name and possible part of the institution
+     * should be in the beginning, while address and secondary information
+     * should be in the end.
      * </p>
      *
      * Each part is examined separately:
      * <ol>
      * <li>We remove all tokens of a part which are one of the defined ignore
      * words (the, press), which end with a dot (ltd., co., ...) and which first
      * character is lowercase (of, on, di, ...).</li>
-     * <li>We detect a type of the part: university, technology institute,
+     * <li>We detect the types of the part: university, technology institute,
      * department, school, rest
      * <ul>
      * <li>University: <code>"Uni[NameOfTheUniversity]"</code></li>
-     * <li>Department: will be an abbreviation of all words beginning with the
-     * uppercase letter except of words: <code>d[ei]p.*</code>, school,
-     * faculty</li>
+     * <li>Department: If the institution value contains more than one comma
+     * separated part, the department will be an abbreviation of all words
+     * beginning with the uppercase letter except of words:
+     * <code>d[ei]p.*</code>, school, faculty</li>
      * <li>School: same as department</li>
      * <li>Rest: If there are less than 3 tokens in such part than the result
-     * will be by concatenating those tokens, otherwise the result will be build
-     * from the first letters of words starting with and uppercase letter.</li>
+     * is a concatenation of those tokens. Otherwise, the result will be built
+     * from the first letter in each token.</li>
      * </ul>
      * </ol>
      * <p>
@@ -1262,134 +1310,121 @@ private static boolean isInstitution(String author) {
      *         </ul>
      */
     private static String generateInstitutionKey(String content) {
-        if (content.isEmpty()) {
-            return content;
+        if (content == null) {
+            return null;
+        }
+        if (content.isBlank()) {
+            return "";
         }
 
         String result = content;
         result = unifyDiacritics(result);
-        result = result.replaceAll("^\\{", "").replaceAll("\\}$", "");
-        Matcher matcher = REGEX_PATTERN.matcher(result);
+        result = result.replaceAll("^\\{", "").replaceAll("}$", "");
+        Matcher matcher = ABBREVIATIONS.matcher(result);
         if (matcher.matches()) {
             return matcher.group(1);
         }
 
         result = removeDiacritics(result);
-        String[] parts = result.split(",");
+        String[] institutionNameTokens = result.split(",");
 
         // Key parts
         String university = null;
         String department = null;
         String school = null;
         String rest = null;
 
-        List<String> ignore = Arrays.asList("press", "the");
-        for (int index = 0; index < parts.length; index++) {
-            List<String> part = new ArrayList<>();
-
-            // Cleanup: remove unnecessary words.
-            for (String k : parts[index].replaceAll("\\{[A-Z]+\\}", "").split("[ \\-_]")) {
-                if ((!(k.isEmpty()) // remove empty
-                        && !ignore.contains(k.toLowerCase(Locale.ENGLISH)) // remove ignored words
-                        && (k.charAt(k.length() - 1) != '.')
-                        && (String.valueOf(k.charAt(0))).matches("[A-Z]"))
-                        || ((k.length() >= 3) && "uni".equalsIgnoreCase(k.substring(0, 2)))) {
-                    part.add(k);
-                }
-            }
+        for (int index = 0; index < institutionNameTokens.length; index++) {
+            List<String> tokenParts = getValidInstitutionNameParts(institutionNameTokens[index]);
+            EnumSet<Institution> tokenTypes = Institution.findTypes(tokenParts);
 
-            boolean isUniversity = false; // university
-            boolean isTechnology = false; // technology institute
-            boolean isDepartment = false; // departments
-            boolean isSchool = false; // schools
-
-            // Deciding about a part type...
-            for (String k : part) {
-                if (k.matches("^[Uu][Nn][Ii].*")) { // Starts with "uni" case and locale independent
-                    isUniversity = true;
-                }
-                if (k.matches("^[Tt][Ee][Cc][Hh].*")) { // Starts with "tech" case and locale independent
-                    isTechnology = true;
-                }
-                if (StandardField.SCHOOL.getName().equalsIgnoreCase(k)) {
-                    isSchool = true;
-                }
-                if (k.matches("^[Dd][EeIi][Pp].*") || k.matches("^[Ll][Aa][Bb].*")) { // Starts with "dep"/"dip"/"lab", case and locale independent
-                    isDepartment = true;
-                }
-            }
-            if (isTechnology) {
-                isUniversity = false; // technology institute isn't university :-)
-            }
-
-            // University part looks like: Uni[NameOfTheUniversity]
-            //
-            // If university is detected than the previous part is suggested
-            // as department
-            if (isUniversity) {
+            if (tokenTypes.contains(Institution.UNIVERSITY)) {
                 StringBuilder universitySB = new StringBuilder();
+                // University part looks like: Uni[NameOfTheUniversity]
                 universitySB.append("Uni");
-                for (String k : part) {
-                    if (!k.matches("^[Uu][Nn][Ii].*")) {
+                for (String k : tokenParts) {
+                    if (!"uni".regionMatches(true, 0, k, 0, 3)) {
                         universitySB.append(k);
                     }
                 }
                 university = universitySB.toString();
+                // If university is detected than the previous part is suggested
+                // as department
                 if ((index > 0) && (department == null)) {
-                    department = parts[index - 1];
+                    department = institutionNameTokens[index - 1];
                 }
-
+            } else if ((tokenTypes.contains(Institution.SCHOOL)
+                    || tokenTypes.contains(Institution.DEPARTMENT))
+                    && institutionNameTokens.length > 1) {
                 // School is an abbreviation of all the words beginning with a
                 // capital letter excluding: department, school and faculty words.
-                //
-                // Explicitly defined department part is build the same way as
-                // school
-            } else if (isSchool || isDepartment) {
                 StringBuilder schoolSB = new StringBuilder();
                 StringBuilder departmentSB = new StringBuilder();
-                for (String k : part) {
-                    if (!k.matches("^[Dd][EeIi][Pp].*") && !StandardField.SCHOOL.getName().equalsIgnoreCase(k)
-                            && !"faculty".equalsIgnoreCase(k)
-                            && !(k.replaceAll(STARTING_CAPITAL_PATTERN, "").isEmpty())) {
-                        if (isSchool) {
-                            schoolSB.append(k.replaceAll(STARTING_CAPITAL_PATTERN, ""));
+                for (String k : tokenParts) {
+                    if (noOtherInstitutionKeyWord(k)) {
+                        if (tokenTypes.contains(Institution.SCHOOL)) {
+                            schoolSB.append(NOT_CAPITAL_FIRST_CHARACTER.matcher(k).replaceAll(""));
                         }
-                        if (isDepartment) {
-                            departmentSB.append(k.replaceAll(STARTING_CAPITAL_PATTERN, ""));
+                        // Explicitly defined department part is build the same way as school
+                        if (tokenTypes.contains(Institution.DEPARTMENT)) {
+                            departmentSB.append(NOT_CAPITAL_FIRST_CHARACTER.matcher(k).replaceAll(""));
                         }
                     }
                 }
-                if (isSchool) {
+                if (tokenTypes.contains(Institution.SCHOOL)) {
                     school = schoolSB.toString();
                 }
-                if (isDepartment) {
+                if (tokenTypes.contains(Institution.DEPARTMENT)) {
                     department = departmentSB.toString();
                 }
-                // A part not matching university, department nor school.
             } else if (rest == null) {
-                StringBuilder restSB = new StringBuilder();
-                // Less than 3 parts -> concatenate those
-                if (part.size() < 3) {
-                    for (String k : part) {
-                        restSB.append(k);
-                        // More than 3 parts -> use 1st letter abbreviation
-                    }
+                // A part not matching university, department nor school
+                if (tokenParts.size() >= 3) {
+                    // If there are more than 3 parts, only keep the first character of each word
+                    final int[] codePoints = tokenParts.stream()
+                                                       .filter(Predicate.not(String::isBlank))
+                                                       .mapToInt((s) -> s.codePointAt(0))
+                                                       .toArray();
+                    rest = new String(codePoints, 0, codePoints.length);
                 } else {
-                    for (String k : part) {
-                        k = k.replaceAll(STARTING_CAPITAL_PATTERN, "");
-                        if (!(k.isEmpty())) {
-                            restSB.append(k);
-                        }
-                    }
+                    rest = String.join("", tokenParts);
                 }
-                rest = restSB.toString();
             }
         }
 
         // Putting parts together.
-        return (university == null ? rest : university)
+        return (university == null ? Objects.toString(rest, "") : university)
                 + (school == null ? "" : school)
                 + ((department == null)
                 || ((school != null) && department.equals(school)) ? "" : department);
     }
+
+    /**
+     * Checks that this is not an institution keyword and has an uppercase first letter, except univ/tech key word.
+     * @param word to check
+     * @return
+     */
+    private static boolean noOtherInstitutionKeyWord(String word) {
+        return !DEPARTMENTS.matcher(word).matches()
+                && !StandardField.SCHOOL.getName().equalsIgnoreCase(word)
+                && !"faculty".equalsIgnoreCase(word)
+                && !NOT_CAPITAL_FIRST_CHARACTER.matcher(word).replaceAll("").isEmpty();
+    }
+
+    private static List<String> getValidInstitutionNameParts(String name) {
+        List<String> nameParts = new ArrayList<>();
+        List<String> ignore = Arrays.asList("press", "the");
+
+        // Cleanup: remove unnecessary words.
+        for (String part : name.replaceAll("\\{[A-Z]+}", "").split("[ \\-_]")) {
+            if ((!(part.isEmpty()) // remove empty
+                    && !ignore.contains(part.toLowerCase(Locale.ENGLISH)) // remove ignored words
+                    && (part.charAt(part.length() - 1) != '.')
+                    && Character.isUpperCase(part.charAt(0)))
+                    || ((part.length() >= 3) && "uni".equalsIgnoreCase(part.substring(0, 3)))) {
+                nameParts.add(part);
+            }
+        }
+        return nameParts;
+    }
 }

src/main/java/org/jabref/model/entry/AuthorList.java

@@ -11,6 +11,8 @@
 import java.util.WeakHashMap;
 import java.util.stream.Collectors;
 
+import org.jabref.model.strings.LatexToUnicodeAdapter;
+
 /**
  * This is an immutable class representing information of either <CODE>author</CODE>
  * or <CODE>editor</CODE> field in bibtex record.
@@ -125,14 +127,18 @@ public class AuthorList {
     private final static Collection<String> AVOID_TERMS_IN_LOWER_CASE = Arrays.asList("jr", "sr", "jnr", "snr", "von", "zu", "van", "der");
     private final List<Author> authors;
     private final String[] authorsFirstFirst = new String[4];
+    private final String[] authorsFirstFirstLatexFree = new String[4];
     private final String[] authorsLastOnly = new String[2];
+    private final String[] authorsLastOnlyLatexFree = new String[2];
     private final String[] authorLastFirstAnds = new String[2];
     private final String[] authorsLastFirst = new String[4];
+    private final String[] authorsLastFirstLatexFree = new String[4];
     private final String[] authorsLastFirstFirstLast = new String[2];
     // Variables for storing computed strings, so they only need to be created once:
     private String authorsNatbib;
     private String authorsFirstFirstAnds;
     private String authorsAlph;
+    private String authorsNatbibLatexFree;
 
     /**
      * Creates a new list of authors.
@@ -223,8 +229,8 @@ public static AuthorList parse(String authors) {
      *
      * @see AuthorList#getAsFirstLastNames
      */
-    public static String fixAuthorFirstNameFirstCommas(String authors, boolean abbr, boolean oxfordComma) {
-        return AuthorList.parse(authors).getAsFirstLastNames(abbr, oxfordComma);
+    public static String fixAuthorFirstNameFirstCommas(String authors, boolean abbreviate, boolean oxfordComma) {
+        return AuthorList.parse(authors).getAsFirstLastNames(abbreviate, oxfordComma);
     }
 
     /**
@@ -241,8 +247,8 @@ public static String fixAuthorFirstNameFirst(String authors) {
      *
      * @see AuthorList#getAsLastFirstNames
      */
-    public static String fixAuthorLastNameFirstCommas(String authors, boolean abbr, boolean oxfordComma) {
-        return AuthorList.parse(authors).getAsLastFirstNames(abbr, oxfordComma);
+    public static String fixAuthorLastNameFirstCommas(String authors, boolean abbreviate, boolean oxfordComma) {
+        return AuthorList.parse(authors).getAsLastFirstNames(abbreviate, oxfordComma);
     }
 
     /**
@@ -390,6 +396,15 @@ public String getAsNatbib() {
         return authorsNatbib;
     }
 
+    public String getAsNatbibLatexFree() {
+        // Check if we've computed this before:
+        if (authorsNatbibLatexFree != null) {
+            return authorsNatbibLatexFree;
+        }
+        authorsNatbibLatexFree = LatexToUnicodeAdapter.format(getAsNatbib());
+        return authorsNatbibLatexFree;
+    }
+
     /**
      * Returns the list of authors separated by commas with last name only; If
      * the list consists of two or more authors, "and" is inserted before the
@@ -409,11 +424,11 @@ public String getAsNatbib() {
      * Oxford comma.</a>
      */
     public String getAsLastNames(boolean oxfordComma) {
-        int abbrInt = oxfordComma ? 0 : 1;
+        int abbreviationIndex = oxfordComma ? 0 : 1;
 
         // Check if we've computed this before:
-        if (authorsLastOnly[abbrInt] != null) {
-            return authorsLastOnly[abbrInt];
+        if (authorsLastOnly[abbreviationIndex] != null) {
+            return authorsLastOnly[abbreviationIndex];
         }
 
         StringBuilder result = new StringBuilder();
@@ -433,8 +448,19 @@ public String getAsLastNames(boolean oxfordComma) {
                 result.append(getAuthor(i).getLastOnly());
             }
         }
-        authorsLastOnly[abbrInt] = result.toString();
-        return authorsLastOnly[abbrInt];
+        authorsLastOnly[abbreviationIndex] = result.toString();
+        return authorsLastOnly[abbreviationIndex];
+    }
+
+    public String getAsLastNamesLatexFree(boolean oxfordComma) {
+        int abbreviationIndex = oxfordComma ? 0 : 1;
+
+        // Check if we've computed this before:
+        if (authorsLastOnlyLatexFree[abbreviationIndex] != null) {
+            return authorsLastOnlyLatexFree[abbreviationIndex];
+        }
+        authorsLastOnlyLatexFree[abbreviationIndex] = LatexToUnicodeAdapter.format(getAsLastNames(oxfordComma));
+        return authorsLastOnlyLatexFree[abbreviationIndex];
     }
 
     /**
@@ -460,12 +486,12 @@ public String getAsLastNames(boolean oxfordComma) {
      * Oxford comma.</a>
      */
     public String getAsLastFirstNames(boolean abbreviate, boolean oxfordComma) {
-        int abbrInt = abbreviate ? 0 : 1;
-        abbrInt += oxfordComma ? 0 : 2;
+        int abbreviationIndex = abbreviate ? 0 : 1;
+        abbreviationIndex += oxfordComma ? 0 : 2;
 
         // Check if we've computed this before:
-        if (authorsLastFirst[abbrInt] != null) {
-            return authorsLastFirst[abbrInt];
+        if (authorsLastFirst[abbreviationIndex] != null) {
+            return authorsLastFirst[abbreviationIndex];
         }
 
         StringBuilder result = new StringBuilder();
@@ -485,8 +511,21 @@ public String getAsLastFirstNames(boolean abbreviate, boolean oxfordComma) {
                 result.append(getAuthor(i).getLastFirst(abbreviate));
             }
         }
-        authorsLastFirst[abbrInt] = result.toString();
-        return authorsLastFirst[abbrInt];
+        authorsLastFirst[abbreviationIndex] = result.toString();
+        return authorsLastFirst[abbreviationIndex];
+    }
+
+    public String getAsLastFirstNamesLatexFree(boolean abbreviate, boolean oxfordComma) {
+        int abbreviationIndex = abbreviate ? 0 : 1;
+        abbreviationIndex += oxfordComma ? 0 : 2;
+
+        // Check if we've computed this before:
+        if (authorsLastFirstLatexFree[abbreviationIndex] != null) {
+            return authorsLastFirstLatexFree[abbreviationIndex];
+        }
+
+        authorsLastFirstLatexFree[abbreviationIndex] = LatexToUnicodeAdapter.format(getAsLastFirstNames(abbreviate, oxfordComma));
+        return authorsLastFirstLatexFree[abbreviationIndex];
     }
 
     @Override
@@ -509,22 +548,22 @@ public String toString() {
      * @return formatted list of authors.
      */
     public String getAsLastFirstNamesWithAnd(boolean abbreviate) {
-        int abbrInt = abbreviate ? 0 : 1;
+        int abbreviationIndex = abbreviate ? 0 : 1;
         // Check if we've computed this before:
-        if (authorLastFirstAnds[abbrInt] != null) {
-            return authorLastFirstAnds[abbrInt];
+        if (authorLastFirstAnds[abbreviationIndex] != null) {
+            return authorLastFirstAnds[abbreviationIndex];
         }
 
-        authorLastFirstAnds[abbrInt] = getAuthors().stream().map(author -> author.getLastFirst(abbreviate))
+        authorLastFirstAnds[abbreviationIndex] = getAuthors().stream().map(author -> author.getLastFirst(abbreviate))
                                                    .collect(Collectors.joining(" and "));
-        return authorLastFirstAnds[abbrInt];
+        return authorLastFirstAnds[abbreviationIndex];
     }
 
     public String getAsLastFirstFirstLastNamesWithAnd(boolean abbreviate) {
-        int abbrInt = abbreviate ? 0 : 1;
+        int abbreviationIndex = abbreviate ? 0 : 1;
         // Check if we've computed this before:
-        if (authorsLastFirstFirstLast[abbrInt] != null) {
-            return authorsLastFirstFirstLast[abbrInt];
+        if (authorsLastFirstFirstLast[abbreviationIndex] != null) {
+            return authorsLastFirstFirstLast[abbreviationIndex];
         }
 
         StringBuilder result = new StringBuilder();
@@ -536,8 +575,8 @@ public String getAsLastFirstFirstLastNamesWithAnd(boolean abbreviate) {
             }
         }
 
-        authorsLastFirstFirstLast[abbrInt] = result.toString();
-        return authorsLastFirstFirstLast[abbrInt];
+        authorsLastFirstFirstLast[abbreviationIndex] = result.toString();
+        return authorsLastFirstFirstLast[abbreviationIndex];
     }
 
     /**
@@ -555,41 +594,54 @@ public String getAsLastFirstFirstLastNamesWithAnd(boolean abbreviate) {
      * Smith and P. Black Brown" </li>
      * </ul>
      *
-     * @param abbr        whether to abbreivate first names.
+     * @param abbreviate        whether to abbreivate first names.
      * @param oxfordComma Whether to put a comma before the and at the end.
      * @return formatted list of authors.
      * @see <a href="http://en.wikipedia.org/wiki/Serial_comma">serial comma for an detailed explaination about the
      * Oxford comma.</a>
      */
-    public String getAsFirstLastNames(boolean abbr, boolean oxfordComma) {
+    public String getAsFirstLastNames(boolean abbreviate, boolean oxfordComma) {
 
-        int abbrInt = abbr ? 0 : 1;
-        abbrInt += oxfordComma ? 0 : 2;
+        int abbreviationIndex = abbreviate ? 0 : 1;
+        abbreviationIndex += oxfordComma ? 0 : 2;
 
         // Check if we've computed this before:
-        if (authorsFirstFirst[abbrInt] != null) {
-            return authorsFirstFirst[abbrInt];
+        if (authorsFirstFirst[abbreviationIndex] != null) {
+            return authorsFirstFirst[abbreviationIndex];
         }
 
         StringBuilder result = new StringBuilder();
         if (!isEmpty()) {
-            result.append(getAuthor(0).getFirstLast(abbr));
+            result.append(getAuthor(0).getFirstLast(abbreviate));
             int i = 1;
             while (i < (getNumberOfAuthors() - 1)) {
                 result.append(", ");
-                result.append(getAuthor(i).getFirstLast(abbr));
+                result.append(getAuthor(i).getFirstLast(abbreviate));
                 i++;
             }
             if ((getNumberOfAuthors() > 2) && oxfordComma) {
                 result.append(',');
             }
             if (getNumberOfAuthors() > 1) {
                 result.append(" and ");
-                result.append(getAuthor(i).getFirstLast(abbr));
+                result.append(getAuthor(i).getFirstLast(abbreviate));
             }
         }
-        authorsFirstFirst[abbrInt] = result.toString();
-        return authorsFirstFirst[abbrInt];
+        authorsFirstFirst[abbreviationIndex] = result.toString();
+        return authorsFirstFirst[abbreviationIndex];
+    }
+
+    public String getAsFirstLastNamesLatexFree(boolean abbreviate, boolean oxfordComma) {
+        int abbreviationIndex = abbreviate ? 0 : 1;
+        abbreviationIndex += oxfordComma ? 0 : 2;
+
+        // Check if we've computed this before:
+        if (authorsFirstFirstLatexFree[abbreviationIndex] != null) {
+            return authorsFirstFirstLatexFree[abbreviationIndex];
+        }
+
+        authorsFirstFirstLatexFree[abbreviationIndex] = LatexToUnicodeAdapter.format(getAsFirstLastNames(abbreviate, oxfordComma));
+        return authorsFirstFirstLatexFree[abbreviationIndex];
     }
 
     /**
@@ -660,7 +712,7 @@ public String getForAlphabetization() {
         return authorsAlph;
     }
 
-    public void addAuthor(String first, String firstabbr, String von, String last, String jr) {
-        authors.add(new Author(first, firstabbr, von, last, jr));
+    public void addAuthor(String first, String firstNameAbbreviation, String von, String last, String jr) {
+        authors.add(new Author(first, firstNameAbbreviation, von, last, jr));
     }
 }