Add patindexOf() and appendLink() override with collateralCapture param

Allows specifying additional syntax to identify
characters which might have been captured by
{BrowseableURI} but which in the context of the
capture (e.g., inside a single-quoted string)
should be pushed back.

Author: idodeclare

src/org/opensolaris/opengrok/analysis/JFlexXref.java

@@ -35,6 +35,7 @@
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
+import java.util.regex.Pattern;
 import org.opensolaris.opengrok.analysis.Definitions.Tag;
 import org.opensolaris.opengrok.analysis.Scopes.Scope;
 import org.opensolaris.opengrok.configuration.Project;
@@ -217,8 +218,8 @@ protected void appendProject() throws IOException {
     }
 
     /**
-     * Calls {@link #appendLink(java.lang.String, boolean)} with false to
-     * disable {@code doPushback} handling.
+     * Calls {@link #appendLink(java.lang.String, boolean)} with {@code url}
+     * and false.
      * @param url the URL to append
      * @throws IOException if an error occurs while appending
      */
@@ -227,30 +228,64 @@ protected void appendLink(String url) throws IOException {
     }
 
     /**
-     * Appends the {@code url} to the active {@link Writer}. If
-     * {@code doPushback} is true, then any characters counted by
-     * {@link StringUtils#countURIEndingPushback(java.lang.String)} are
-     * handled by {@link #yypushback(int)} with {@code url} only partially
-     * written.
-     * <p>If the count is equal to the length of {@code url}, then it is
-     * simply written, and nothing is pushed back.
+     * Calls
+     * {@link #appendLink(java.lang.String, boolean, java.util.regex.Pattern)}
+     * with {@code url}, {@code doEndingPushback}, and null.
      * @param url the URL to append
-     * @param doPushback a value indicating whether to test the {@code url}
-     * with {@link StringUtils#countURIEndingPushback(java.lang.String)}.
+     * @param doEndingPushback a value indicating whether to test the
+     * {@code url} with
+     * {@link StringUtils#countURIEndingPushback(java.lang.String)}
      * @throws IOException if an error occurs while appending
      */
-    protected void appendLink(String url, boolean doPushback)
+    protected void appendLink(String url, boolean doEndingPushback)
         throws IOException {
 
-        if (doPushback) {
-            int n = StringUtils.countURIEndingPushback(url);
-            // Push back if positive, but not if equal to the current length,
-            // or else the pushback might cause a neverending loop.
-            if (n > 0 && n < url.length()) {
-                yypushback(n);
-                url = url.substring(0, url.length() - n);
+        appendLink(url, doEndingPushback, null);
+    }
+
+    /**
+     * Appends the {@code url} to the active {@link Writer}.
+     * <p>If {@code doEndingPushback} is true, then
+     * {@link StringUtils#countURIEndingPushback(java.lang.String)} is enlisted
+     * for use with {@link #yypushback(int)} -- i.e., {@code url} is only
+     * partially written.
+     * <p>If {@code collateralCapture} is not null, then its match in
+     * {@code url} will alternatively mark the start of a count for pushback --
+     * i.e., everything at and beyond the first {@code collateralCapture} match
+     * will be considered not to belong to the URI.
+     * <p>If the pushback count is equal to the length of {@code url}, then it
+     * is simply written -- and nothing is pushed back -- in order to avoid a
+     * never-ending {@code yylex()} loop.
+     * @param url the URL to append
+     * @param doEndingPushback a value indicating whether to test the
+     * {@code url} with
+     * {@link StringUtils#countURIEndingPushback(java.lang.String)}
+     * @param collateralCapture optional pattern to indicate characters which
+     * may have been captured as valid URI characters but in a particular
+     * context should mark the start of a pushback
+     * @throws IOException if an error occurs while appending
+     */
+    protected void appendLink(String url, boolean doEndingPushback,
+        Pattern collateralCapture)
+            throws IOException {
+
+        int n = 0;
+        if (doEndingPushback) {
+            n = StringUtils.countURIEndingPushback(url);
+        }
+        if (collateralCapture != null) {
+            int o = StringUtils.patindexOf(url, collateralCapture);
+            if (o > 0) {
+                int ccn = url.length() - o;
+                if (ccn > n) n = ccn;
             }
         }
+        // Push back if positive, but not if equal to the current length.
+        if (n > 0 && n < url.length()) {
+            yypushback(n);
+            url = url.substring(0, url.length() - n);
+        }
+
         out.write("<a href=\"");
         out.write(Util.formQuoteEscape(url));
         out.write("\">");

src/org/opensolaris/opengrok/util/StringUtils.java

@@ -24,6 +24,7 @@
 
 package org.opensolaris.opengrok.util;
 
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
@@ -34,8 +35,30 @@
 public final class StringUtils {
 
     /**
-     * Edit and paste (in NetBeans) for easy escaping:
-     * {@code [a-zA-Z0-9_\-\.] }.
+     * Matches an apostrophe not following a backslash escape or following an
+     * even number¹ of backslash escapes:
+     * <pre>
+     * {@code
+     * \'((?<=^.)|(?<=[^\\].)|(?<=^(\\\\){1,3}.)|(?<=[^\\](\\\\){1,3}.))
+     * }
+     * </pre>
+     * (Edit above and paste below [in NetBeans] for easy String escaping.)
+     * <p>
+     * ¹"even number" is limited to 2,4,6 because Java look-behind is not
+     * variable length but instead must have a definite upper bound in the
+     * regex definition.
+     */
+    public static final Pattern APOS_NO_BSESC =
+        Pattern.compile("\\'((?<=^.)|(?<=[^\\\\].)|(?<=^(\\\\\\\\){1,3}.)|(?<=[^\\\\](\\\\\\\\){1,3}.))");
+
+    /**
+     * Matches the same possible character as CommonPath.lexh's {FNameChar}:
+     * <pre>
+     * {@code
+     * [a-zA-Z0-9_\-\.]
+     * }
+     * </pre>
+     * (Edit above and paste below [in NetBeans] for easy String escaping.)
      */
     private static final String FNAME_CHARS_PAT =
         "[a-zA-Z0-9_\\-\\.]";
@@ -47,10 +70,15 @@ public final class StringUtils {
         Pattern.compile("^" + FNAME_CHARS_PAT);
 
     /**
-     * Edit and paste (in NetBeans) for easy escaping:
-     * {@code [a-zA-Z0-9\-\._~%:/\?\#\[\]@!\$&\'\(\)\*\+,;=] }
+     * Matches one of the same¹ possible characters as Common.lexh's {URIChar}:
+     * <pre>
+     * {@code
+     * [a-zA-Z0-9\-\._~%:/\?\#\[\]@!\$&\'\(\)\*\+,;=]
+     * }
+     * </pre>
+     * (Edit above and paste below [in NetBeans] for easy String escaping.)
      * <p>
-     * Backslash, '\', was in {URIChar} in many .lex files, but that is not
+     * ¹Backslash, '\', was in {URIChar} in many .lex files, but that is not
      * a valid URI character per RFC-3986.
      */
     private static final String URI_CHARS_PAT =
@@ -225,7 +253,7 @@ public static int countURIEndingPushback(String value) {
         }
         return n;
     }
-    
+
     /**
      * Find out if string contains only alphanumeric characters.
      * @param str string to check
@@ -241,4 +269,18 @@ public static boolean isAlphanumeric(String str) {
 
         return true;
     }
+
+    /**
+     * Determines if the specified {@code pattern} matches in the specified
+     * {@code value}.
+     * @param value the string to inspect
+     * @param pattern the pattern to match
+     * @return the index of the first occurrence of the specified pattern, or
+     * -1 if there is no such occurrence
+     */
+    public static int patindexOf(String value, Pattern pattern) {
+        Matcher m = pattern.matcher(value);
+        if (!m.find()) return -1;
+        return m.start();
+    }
 }

test/org/opensolaris/opengrok/util/StringUtilsTest.java

@@ -19,12 +19,12 @@
 
 /*
  * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Portions Copyright (c) 2017, Chris Fraire <[email protected]>.
  */
 package org.opensolaris.opengrok.util;
 
 import org.junit.Assert;
 import org.junit.Test;
-
 import static org.junit.Assert.assertEquals;
 
 /**
@@ -130,10 +130,44 @@ public void uriEmptyShouldNotCountAnyPushback() {
         int n = StringUtils.countURIEndingPushback(uri);
         assertEquals("empty pushback", 0, n);
     }
-    
+
     @Test
     public void testIsAlphanumeric() {
         Assert.assertTrue(StringUtils.isAlphanumeric("foo123"));
         Assert.assertFalse(StringUtils.isAlphanumeric("foo_123"));
     }
+
+    @Test
+    public void shouldMatchNonescapedApostrophe() {
+        // Copy-and-paste the following so Netbeans does the escaping:
+        // value: \'1-2-3\''
+        final String value = "\\'1-2-3\\''";
+        int i = StringUtils.patindexOf(value, StringUtils.APOS_NO_BSESC);
+        assertEquals("unquoted apostrophe", 9, i);
+    }
+
+    @Test
+    public void shouldMatchApostropheAfterEvenEscapes() {
+        // Copy-and-paste the following so Netbeans does the escaping:
+        // value: \\'
+        final String value = "\\\\'";
+        int i = StringUtils.patindexOf(value, StringUtils.APOS_NO_BSESC);
+        assertEquals("unquoted apostrophe after backslashes", 2, i);
+    }
+
+    @Test
+    public void shouldNotMatchApostropheAfterOddEscapes() {
+        // Copy-and-paste the following so Netbeans does the escaping:
+        // value: \\\'
+        final String value = "\\\\\\'";
+        int i = StringUtils.patindexOf(value, StringUtils.APOS_NO_BSESC);
+        assertEquals("quoted apostrophe after backslashes", -1, i);
+    }
+
+    @Test
+    public void shouldMatchInitialApostrophe() {
+        final String value = "'";
+        int i = StringUtils.patindexOf(value, StringUtils.APOS_NO_BSESC);
+        assertEquals("initial apostrophe", 0, i);
+    }
 }