[refactor] Address issues identified by CI, Codacy, Sonarcloud, and code reviews

Author: alanpaxton

exist-core/src/main/java/org/exist/xquery/XQueryContext.java

@@ -3327,14 +3327,6 @@ public String getDefaultLanguage() {
         return DefaultLanguage;
     }
 
-    /**
-     * TODO (AP) this is a temporary implementation which will conflict and be sorted at merge
-     * @return the default language for the locale
-     */
-    public String getDefaultLanguage() {
-        return Locale.getDefault().getLanguage();
-    }
-
     /**
      * NOTE: the {@link #unsubscribe()} method can be called
      * from {@link org.exist.storage.NotificationService#unsubscribe(UpdateListener)}

exist-core/src/main/java/org/exist/xquery/functions/fn/FnFormatIntegers.java

@@ -22,18 +22,18 @@
 
 package org.exist.xquery.functions.fn;
 
-import org.exist.xquery.*;
+import org.exist.xquery.BasicFunction;
+import org.exist.xquery.FunctionSignature;
+import org.exist.xquery.XPathException;
+import org.exist.xquery.XQueryContext;
 import org.exist.xquery.functions.integer.IntegerPicture;
 import org.exist.xquery.value.*;
 
 import java.math.BigInteger;
 import java.util.ArrayList;
-import java.util.IllformedLocaleException;
 import java.util.List;
-import java.util.Locale;
 
 import static org.exist.xquery.FunctionDSL.*;
-import static org.exist.xquery.FunctionDSL.arity;
 import static org.exist.xquery.functions.fn.FnModule.functionSignatures;
 
 /**
@@ -77,7 +77,7 @@ public Sequence eval(final Sequence[] args, final Sequence contextSequence)
         // If $value is an empty sequence, the function returns a zero-length string
         // https://www.w3.org/TR/xpath-functions-31/#func-format-integer
         if (args[0].isEmpty()) {
-            return AtomicValue.EMPTY_SEQUENCE;
+            return Sequence.EMPTY_SEQUENCE;
         }
 
         // If the value of $value is negative, the rules below are applied to the absolute value of $value,
@@ -86,6 +86,9 @@ public Sequence eval(final Sequence[] args, final Sequence contextSequence)
         final BigInteger bigInteger = integerValue.toJavaObject(BigInteger.class);
 
         final IntegerPicture picture = IntegerPicture.fromString(args[1].getStringValue());
+
+        // Build a list of languages to try
+        // the called picture will use the first one with a valid locale
         final List<String> languages = new ArrayList<>(2);
         if (args.length == 3 && !args[2].isEmpty()) {
             languages.add(args[2].getStringValue());

exist-core/src/main/java/org/exist/xquery/functions/integer/DigitsIntegerPicture.java

@@ -1,3 +1,25 @@
+/*
+ * eXist-db Open Source Native XML Database
+ * Copyright (C) 2001 The eXist-db Authors
+ *
+ * [email protected]
+ * http://www.exist-db.org
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
 package org.exist.xquery.functions.integer;
 
 import org.exist.xquery.ErrorCodes;
@@ -6,23 +28,23 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+/**
+ * Represent format modifier part of the formatting picture for integer formatting
+ * {@see https://www.w3.org/TR/xpath-functions-31/#formatting-integers}
+ */
 class FormatModifier {
 
-    enum Numbering {Cardinal, Ordinal}
-
-    ;
-
-    enum LetterSequence {Alphabetic, Traditional}
+    enum Numbering {CARDINAL, ORDINAL}
 
-    ;
+    enum LetterSequence {ALPHABETIC, TRADITIONAL}
 
     final String modifier;
     final boolean isEmpty;
-    Numbering numbering = Numbering.Cardinal;
+    Numbering numbering = Numbering.CARDINAL;
     String variation;
-    LetterSequence letterSequence = LetterSequence.Alphabetic;
+    LetterSequence letterSequence = LetterSequence.ALPHABETIC;
 
-    final static Pattern modifierPattern = Pattern.compile("^(?:([co])(\\((.+)\\))?)?([at])?$");
+    static final Pattern modifierPattern = Pattern.compile("^(?:([co])(\\((.+)\\))?)?([at])?$");
 
     FormatModifier(final String modifier) throws XPathException {
         this.modifier = modifier;
@@ -33,28 +55,28 @@ enum LetterSequence {Alphabetic, Traditional}
     }
 
     private void parseModifier() throws XPathException {
-        Matcher m = modifierPattern.matcher(modifier);
+        final Matcher m = modifierPattern.matcher(modifier);
         if (!m.matches()) {
             throw new XPathException(ErrorCodes.FODF1310, "Modifier " + modifier + " is not a valid pattern modifier");
         }
-        String n = m.group(1);
+        final String n = m.group(1);
         if (n != null) {
-            if (n.equals("c")) numbering = Numbering.Cardinal;
-            if (n.equals("o")) numbering = Numbering.Ordinal;
+            if (n.equals("c")) numbering = Numbering.CARDINAL;
+            if (n.equals("o")) numbering = Numbering.ORDINAL;
         }
-        String v = m.group(3);
+        final String v = m.group(3);
         if (v != null) {
             variation = v;
         }
-        String l = m.group(4);
+        final String l = m.group(4);
         if (l != null) {
-            if (l.equals("a")) letterSequence = LetterSequence.Alphabetic;
-            if (l.equals("t")) letterSequence = LetterSequence.Traditional;
+            if (l.equals("a")) letterSequence = LetterSequence.ALPHABETIC;
+            if (l.equals("t")) letterSequence = LetterSequence.TRADITIONAL;
         }
     }
 
     public String toString() {
-        StringBuilder sb = new StringBuilder();
+        final StringBuilder sb = new StringBuilder();
         sb.append("numbering=").append(numbering).append("::");
         sb.append("variation=").append(variation).append("::");
         sb.append("lettersequence=").append(letterSequence).append("::");

exist-core/src/main/java/org/exist/xquery/functions/integer/FormatModifier.java

@@ -32,28 +32,18 @@
 import java.util.regex.Pattern;
 
 /**
- * Format numbers according to the rules
- * {@see https://www.w3.org/TR/xpath-functions-31/#formatting-integers}
+ * Format numbers according to the rules for
+ * <a href="https://www.w3.org/TR/xpath-functions-31/#formatting-integers">format-integer</a>
  */
 public abstract class IntegerPicture {
 
-    static IntegerPicture DEFAULT;
-
-    static {
-        try {
-            DEFAULT = new DigitsIntegerPicture("1", new FormatModifier(""));
-        } catch (final XPathException e) {
-            e.printStackTrace();
-        }
-    }
-
-    final static BigInteger TEN = BigInteger.valueOf(10L);
+    static final BigInteger TEN = BigInteger.valueOf(10L);
 
     //This contains \\v (vertical whitespace characters) so anything with vertical white space isn't a pattern
     //It also disallows 0 instances of the pattern
     //When decimal digit pattern doesn't match, we end up falling into a standard default.
-    final static Pattern decimalDigitPattern = Pattern.compile("^((\\p{Nd}|#|[^\\p{N}\\p{L}\\v])+)$", Pattern.UNICODE_CHARACTER_CLASS);
-    final static Pattern invalidDigitPattern = Pattern.compile("(\\p{Nd})");
+    static final Pattern decimalDigitPattern = Pattern.compile("^((\\p{Nd}|#|[^\\p{N}\\p{L}\\v])+)$", Pattern.UNICODE_CHARACTER_CLASS);
+    static final Pattern invalidDigitPattern = Pattern.compile("(\\p{Nd})");
 
     /**
      * The value of $picture consists of a primary format token,
@@ -81,19 +71,19 @@ public static IntegerPicture fromString(final String pictureFormat) throws XPath
         }
 
         // type 1 matcher (some digits)
-        final Matcher decimalDigitMatcher = decimalDigitPattern.matcher(primaryFormatToken);
+        final Matcher decimalDigitMatcher = IntegerPicture.decimalDigitPattern.matcher(primaryFormatToken);
         if (decimalDigitMatcher.matches()) {
             return new DigitsIntegerPicture(primaryFormatToken, formatModifier);
         }
 
         // incorrect type 1 matcher (and not anything else)
-        final Matcher invalidDigitMatcher = invalidDigitPattern.matcher(primaryFormatToken);
+        final Matcher invalidDigitMatcher = IntegerPicture.invalidDigitPattern.matcher(primaryFormatToken);
         if (invalidDigitMatcher.find()) {
             throw new XPathException(ErrorCodes.FODF1310, "Invalid primary format token is not a valid decimal digital pattern: " + primaryFormatToken);
         }
 
         // specifically defined format token rules 2-8
-        // {@see https://www.w3.org/TR/xpath-functions-31/#formatting-integers}
+        // <a href="https://www.w3.org/TR/xpath-functions-31/#formatting-integers"/>
         switch (primaryFormatToken) {
             case "A":
                 return new SequenceIntegerPicture('A');
@@ -104,21 +94,21 @@ public static IntegerPicture fromString(final String pictureFormat) throws XPath
             case "I":
                 return new RomanIntegerPicture(true/*isUpper*/);
             case "W":
-                return new WordPicture(WordPicture.CaseAndCaps.Upper, formatModifier);
+                return new WordPicture(WordPicture.CaseAndCaps.UPPER, formatModifier);
             case "w":
-                return new WordPicture(WordPicture.CaseAndCaps.Lower, formatModifier);
+                return new WordPicture(WordPicture.CaseAndCaps.LOWER, formatModifier);
             case "Ww":
-                return new WordPicture(WordPicture.CaseAndCaps.Capitalized, formatModifier);
+                return new WordPicture(WordPicture.CaseAndCaps.CAPITALIZED, formatModifier);
             default:
                 break;
         }
 
         // Rule 9 - sequences
-        // {@see https://www.w3.org/TR/xpath-functions-31/#formatting-integers}
-        final List<Integer> codePoints = CodePoints(primaryFormatToken);
+        // <a href="https://www.w3.org/TR/xpath-functions-31/#formatting-integers"/>
+        final List<Integer> codePoints = IntegerPicture.codePoints(primaryFormatToken);
         final Optional<IntegerPicture> numberingPicture = NumberingPicture.fromIndexCodePoint(codePoints.get(0), formatModifier);
 
-        return numberingPicture.orElse(defaultPictureWithModifier(formatModifier));
+        return numberingPicture.orElse(IntegerPicture.defaultPictureWithModifier(formatModifier));
     }
 
     static IntegerPicture defaultPictureWithModifier(final FormatModifier formatModifier) throws XPathException {
@@ -131,10 +121,11 @@ static IntegerPicture defaultPictureWithModifier(final FormatModifier formatModi
      * @param bigInteger the integer to format
      * @param locale of the language to use in formatting
      * @return a string containing the formatted integer
+     * @throws XPathException if the locale is ill-formed
      */
-    abstract protected String formatInteger(BigInteger bigInteger, Locale locale) throws XPathException;
+    protected abstract String formatInteger(BigInteger bigInteger, Locale locale) throws XPathException;
 
-    private Locale getLocaleFromLanguages(final List<String> languages) throws XPathException {
+    private static Locale getLocaleFromLanguages(final List<String> languages) throws XPathException {
 
         IllformedLocaleException languageILE = null;
         for (final String language : languages) {
@@ -146,12 +137,13 @@ private Locale getLocaleFromLanguages(final List<String> languages) throws XPath
                 languageILE = ile;
             }
         }
+        assert languageILE != null;
         throw new XPathException(ErrorCodes.FODF1310, languageILE.getMessage());
     }
 
     public final String formatInteger(final BigInteger bigInteger, final List<String> languages) throws XPathException {
 
-        final Locale locale = getLocaleFromLanguages(languages);
+        final Locale locale = IntegerPicture.getLocaleFromLanguages(languages);
         return formatInteger(bigInteger, locale);
     }
 
@@ -161,17 +153,18 @@ public final String formatInteger(final BigInteger bigInteger, final List<String
      * @param s the input string
      * @return a list of the codepoints forming the string
      */
-    protected static List<Integer> CodePoints(final String s) {
+    protected static List<Integer> codePoints(final String s) {
         final List<Integer> codePointList = new ArrayList<>(s.length());
-        for (int i = 0; i < s.length(); ) {
+        int i = 0;
+        while (i < s.length()) {
             final int codePoint = Character.codePointAt(s, i);
             i += Character.charCount(codePoint);
             codePointList.add(codePoint);
         }
         return codePointList;
     }
 
-    protected static String FromCodePoint(final int codePoint) {
+    protected static String fromCodePoint(final int codePoint) {
         final StringBuilder sb = new StringBuilder();
         for (final char c : Character.toChars(codePoint)) {
             sb.append(c);
@@ -187,6 +180,4 @@ protected static String ordinalSuffix(final int value, final Locale locale) {
         for (; sb.length() > 0 && Character.isAlphabetic(sb.charAt(i)); i++) ;
         return sb.delete(i, sb.length()).reverse().toString();
     }
-
-
 }