This is an automated email from the ASF dual-hosted git repository. andy pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/jena.git
commit be059c0d540b999a5a1e0d69cb953915426434fa Author: Andy Seaborne <[email protected]> AuthorDate: Tue Nov 12 16:15:24 2024 +0000 GH-2833: Refactor RegexEngine --- .../org/apache/jena/ext/xerces_regex/REUtil.java | 4 +- .../apache/jena/ext/xerces_regex/RegexParser.java | 4 +- .../src/main/java/org/apache/jena/query/ARQ.java | 24 ++-- .../java/org/apache/jena/sparql/expr/E_Regex.java | 129 +++++++---------- .../org/apache/jena/sparql/expr/E_StrReplace.java | 2 +- .../org/apache/jena/sparql/expr/RegexEngine.java | 159 ++++++++++++++++++++- .../org/apache/jena/sparql/expr/RegexJava.java | 77 ---------- .../org/apache/jena/sparql/expr/RegexXerces.java | 53 ------- .../jena/sparql/expr/nodevalue/XSDFuncOp.java | 2 +- .../jena/ext/xerces_regex/message.properties | 2 +- .../jena/ext/xerces_regex/message_fr.properties | 2 +- .../jena/ext/xerces_regex/message_ja.properties | 2 +- .../org/apache/jena/sparql/expr/TestRegex.java | 9 +- .../shacl/engine/constraint/PatternConstraint.java | 6 +- .../jena/shex/expressions/StrRegexConstraint.java | 4 +- 15 files changed, 236 insertions(+), 243 deletions(-) diff --git a/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/REUtil.java b/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/REUtil.java index 15acf0f072..9cc70af473 100644 --- a/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/REUtil.java +++ b/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/REUtil.java @@ -205,7 +205,7 @@ public final class REUtil { /** * Sample entry. - * <div>Usage: <KBD>org.apache.jena.ext.xerces.utils.regex.REUtil <regex> <string></KBD></div> + * <div>Usage: <KBD>org.apache.jena.ext.xerces_regex.REUtil <regex> <string></KBD></div> */ public static void main(String[] argv) { String pattern = null; @@ -258,7 +258,7 @@ public final class REUtil { if (pattern == null) { pe.printStackTrace(); } else { - System.err.println("org.apache.jena.ext.xerces.utils.regex.ParseException: "+pe.getMessage()); + System.err.println("org.apache.jena.ext.xerces_regex.ParseException: "+pe.getMessage()); String indent = " "; System.err.println(indent+pattern); int loc = pe.getLocation(); diff --git a/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/RegexParser.java b/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/RegexParser.java index 1955b895a9..24bfc10dc0 100644 --- a/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/RegexParser.java +++ b/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/RegexParser.java @@ -92,10 +92,10 @@ class RegexParser { public void setLocale(Locale locale) { try { if (locale != null) { - this.resources = ResourceBundle.getBundle("org.apache.jena.ext.xerces.impl.xpath.regex.message", locale); + this.resources = ResourceBundle.getBundle("org.apache.jena.ext.xerces_regex.message", locale); } else { - this.resources = ResourceBundle.getBundle("org.apache.jena.ext.xerces.impl.xpath.regex.message"); + this.resources = ResourceBundle.getBundle("org.apache.jena.ext.xerces_regex.message"); } } catch (MissingResourceException mre) { diff --git a/jena-arq/src/main/java/org/apache/jena/query/ARQ.java b/jena-arq/src/main/java/org/apache/jena/query/ARQ.java index 941f90f6c8..74d0a9361a 100644 --- a/jena-arq/src/main/java/org/apache/jena/query/ARQ.java +++ b/jena-arq/src/main/java/org/apache/jena/query/ARQ.java @@ -229,18 +229,26 @@ public class ARQ /** * Determine which regular expression system to use. - * The value of this context entry should be a string or symbol - * of one of the following: - * javaRegex : use java.util.regex (support features outside the strict SPARQL regex language) - * xercesRegex : use the internal XPath regex engine (more compliant) + * The value of this context entry should be a string: + * <ul> + * <li>"{@code javaRegex}" : use java.util.regex (support features outside the strict SPARQL regex language)</li> + * <li>"{@code xercesRegex}" : use the internal XPath regex engine (more compliant; slower)</li> + * </ul> + * The default is to use the JDK regular expression. */ - public static final Symbol regexImpl = SystemARQ.allocSymbol("regexImpl"); - - /** Symbol to name java.util.regex regular expression engine */ + /** + * Symbol to name java.util.regex regular expression engine + * @deprecated Use string "javaRegex" + */ + @Deprecated(forRemoval = true) public static final Symbol javaRegex = SystemARQ.allocSymbol("javaRegex"); - /** Symbol to name the Xerces-J regular expression engine */ + /** + * Symbol to name the Xerces-J regular expression engine + * @deprecated Use string "xercesRegex" + */ + @Deprecated(forRemoval = true) public static final Symbol xercesRegex = SystemARQ.allocSymbol("xercesRegex"); /** diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Regex.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Regex.java index ff37b00413..62ae033d0f 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Regex.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_Regex.java @@ -27,121 +27,89 @@ import org.apache.jena.query.ARQ ; import org.apache.jena.sparql.expr.nodevalue.NodeFunctions ; import org.apache.jena.sparql.sse.Tags ; import org.apache.jena.sparql.util.FmtUtils ; -import org.apache.jena.sparql.util.Symbol ; - -/** Indirect to the chosen regular expression implementation */ public class E_Regex extends ExprFunctionN { - private static Symbol regexImpl = null ; - static - { - Object v = ARQ.getContext().get(ARQ.regexImpl, ARQ.javaRegex) ; - if ( v instanceof Symbol ) - regexImpl = (Symbol)v ; - if ( v instanceof String ) - regexImpl = Symbol.create((String)v) ; - - if ( regexImpl == null ) - { - Log.warn(E_Regex.class, "Regex implementation some weird setting: default to Java") ; - regexImpl = ARQ.javaRegex; - } - if ( !regexImpl.equals(ARQ.javaRegex) && - !regexImpl.equals(ARQ.xercesRegex) ) - { - Log.warn(E_Regex.class, "Regex implementation not recognized : default to Java") ; - regexImpl = ARQ.javaRegex; - } - } - - private static final String name = Tags.tagRegex ; - private RegexEngine regexEngine = null ; - - public E_Regex(Expr expr, Expr pattern, Expr flags) - { - super(name, expr, pattern, flags) ; - init(pattern, flags) ; + private static final String name = Tags.tagRegex; + private RegexEngine regexEngine = null; + + public E_Regex(Expr expr, Expr pattern, Expr flags) { + super(name, expr, pattern, flags); + init(pattern, flags); } // Not used by parser - public E_Regex(Expr expr, String pattern, String flags) - { - super(name, expr, NodeValue.makeString(pattern), NodeValue.makeString(flags)) ; - init(getArg(2), getArg(3)) ; + public E_Regex(Expr expr, String pattern, String flags) { + super(name, expr, NodeValue.makeString(pattern), NodeValue.makeString(flags)); + init(getArg(2), getArg(3)); } - - private void init(Expr pattern, Expr flags) - { - if ( ! ARQ.isStrictMode() ) { + + private void init(Expr pattern, Expr flags) { + if ( !ARQ.isStrictMode() ) { try { - if ( pattern.isConstant() && pattern.getConstant().isString() && ( flags==null || flags.isConstant() ) ) - regexEngine = makeRegexEngine(pattern.getConstant(), (flags==null)?null:flags.getConstant()) ; + if ( pattern.isConstant() && pattern.getConstant().isString() && (flags == null || flags.isConstant()) ) + regexEngine = makeRegexEngine(pattern.getConstant(), (flags == null) ? null : flags.getConstant()); } catch (ExprEvalException ex) { // Here, we are doing static compilation of the pattern. - // ExprEvalException does not have a stacktrace. + // ExprEvalException does not have a stacktrace. // We could throw a non-eval exception. - throw ex; //new ExprException(ex.getMessage(), ex.getCause()); + throw ex; // new ExprException(ex.getMessage(), ex.getCause()); } } } private String currentFailMessage = null; - + @Override - public NodeValue eval(List<NodeValue> args) - { - Node arg = NodeFunctions.checkAndGetStringLiteral("REGEX", args.get(0)) ; - NodeValue vPattern = args.get(1) ; - NodeValue vFlags = ( args.size() == 2 ? null : args.get(2) ) ; - - RegexEngine regex = regexEngine ; - if ( regex == null ) { + public NodeValue eval(List<NodeValue> args) { + Node arg = NodeFunctions.checkAndGetStringLiteral("REGEX", args.get(0)); + NodeValue vPattern = args.get(1); + NodeValue vFlags = (args.size() == 2 ? null : args.get(2)); + + RegexEngine regex = regexEngine; + if ( regex == null ) { // Execution time regex compile (not a constant pattern). try { - regex = makeRegexEngine(vPattern, vFlags) ; + regex = makeRegexEngine(vPattern, vFlags); } catch (ExprEvalException ex) { - // Avoid multiple logging of the same message (at least if adjacent) + // Avoid multiple logging of the same message (at least if adjacent) String m = ex.getMessage(); - if ( m != null && ! m.equals(currentFailMessage) ) + if ( m != null && !m.equals(currentFailMessage) ) Log.warn(this, m); currentFailMessage = m; - // This becomes an eval error, the FILTER is false and the current row rejected. + // This becomes an eval error, the FILTER is false and the current + // row rejected. throw ex; } } - boolean b = regex.match(arg.getLiteralLexicalForm()) ; - return b ? NodeValue.TRUE : NodeValue.FALSE ; + boolean b = regex.match(arg.getLiteralLexicalForm()); + return b ? NodeValue.TRUE : NodeValue.FALSE; } - public static RegexEngine makeRegexEngine(NodeValue vPattern, NodeValue vFlags) - { - if ( ! vPattern.isString() ) - throw new ExprException("REGEX: Pattern is not a string: "+vPattern) ; - if ( vFlags != null && ! vFlags.isString() ) - throw new ExprException("REGEX: Pattern flags are not a string: "+vFlags) ; - String s = (vFlags==null)?null:vFlags.getString() ; + public static RegexEngine makeRegexEngine(NodeValue vPattern, NodeValue vFlags) { + if ( !vPattern.isString() ) + throw new ExprException("REGEX: Pattern is not a string: " + vPattern); + if ( vFlags != null && !vFlags.isString() ) + throw new ExprException("REGEX: Pattern flags are not a string: " + vFlags); + String s = (vFlags == null) ? null : vFlags.getString(); checkFlags(s); - - return makeRegexEngine(vPattern.getString(), s) ; + return makeRegexEngine(vPattern.getString(), s); } - + private static void checkFlags(String flags) { if ( flags == null ) return; // F&O spec defines regex: Can only contain s, m, i, x, q // Not all are supported by all regex engines. - if ( ! StringUtils.containsOnly(flags, "smixq") ) - throw new ExprEvalException("REGEX: Only 'smixq' are legal as pattern flags: got \""+FmtUtils.stringEsc(flags)+"\""); + if ( !StringUtils.containsOnly(flags, "smixq") ) + throw new ExprEvalException("REGEX: Only 'smixq' are legal as pattern flags: got \"" + FmtUtils.stringEsc(flags) + "\""); } - public static RegexEngine makeRegexEngine(String pattern, String flags) - { - if ( regexImpl.equals(ARQ.xercesRegex)) - return new RegexXerces(pattern, flags) ; - return new RegexJava(pattern, flags) ; + /** Indirect to the chosen regular expression implementation */ + public static RegexEngine makeRegexEngine(String pattern, String flags) { + return RegexEngine.create(pattern, flags); } - + // /** @return Returns the expr of the regex */ // public final Expr getRegexExpr() { return expr1 ; } // @@ -152,10 +120,9 @@ public class E_Regex extends ExprFunctionN // public final Expr getFlags() { return expr3 ; } @Override - public Expr copy(ExprList newArgs) - { + public Expr copy(ExprList newArgs) { if ( newArgs.size() == 2 ) - return new E_Regex(newArgs.get(0), newArgs.get(1), null) ; - return new E_Regex(newArgs.get(0), newArgs.get(1), newArgs.get(2)) ; + return new E_Regex(newArgs.get(0), newArgs.get(1), null); + return new E_Regex(newArgs.get(0), newArgs.get(1), newArgs.get(2)); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_StrReplace.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_StrReplace.java index 1d458c3620..3fafec212e 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_StrReplace.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_StrReplace.java @@ -36,7 +36,7 @@ public class E_StrReplace extends ExprFunctionN { if ( expr4 != null && expr4.isConstant() && expr4.getConstant().isString() ) flags = expr4.getConstant().getString(); String patternStr = expr2.getConstant().getString(); - pattern = RegexJava.makePattern("REPLACE", patternStr, flags); + pattern = RegexEngine.makePattern("REPLACE", patternStr, flags); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java index a890f50377..091bb6e3d0 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java @@ -18,10 +18,159 @@ package org.apache.jena.sparql.expr; -/** Interface to abstract away from specific regular expression systems - * (Apache Xerces and java.util.regex) */ +import java.util.Objects; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.regex.PatternSyntaxException; + +import org.apache.jena.atlas.logging.Log; +import org.apache.jena.ext.xerces_regex.REUtil; +import org.apache.jena.ext.xerces_regex.RegexParseException; +import org.apache.jena.ext.xerces_regex.RegularExpression; +import org.apache.jena.query.ARQ; +import org.apache.jena.sparql.util.Context; +import org.apache.jena.sparql.util.Symbol; + +/** + * Encapsulate a specific regular expression systems. + * <p> + * The two provided are the regular expression implement in Apache Xerces (2.11.0) + * and the JDK {@code java.util.regex}. + * <p> + * By default {@code java.util.regex} is used. It does not support the "x" flag. + * <p> + * The default is set by symbol {@code ARQ.regexImpl} (comand line {@code arq:regexImpl}) + * to either "javaRegex" or "xercesRegex". + * + */ +public abstract class RegexEngine { + public abstract boolean match(String string); + + // ---- ---- + + public static enum RegexImpl { Java, Xerces } + + private static RegexImpl regexImpl = chooseRegexImpl(ARQ.getContext()); + + // Set from the context. + @SuppressWarnings("removal") + private static RegexImpl chooseRegexImpl(Context context) { + Object v = ARQ.getContext().get(ARQ.regexImpl, ARQ.javaRegex); + Symbol symbol = null; + if ( v instanceof Symbol sym ) + symbol = sym; + if ( v instanceof String str ) + symbol = Symbol.create(str); + + if ( ARQ.javaRegex.equals(symbol) ) + return RegexImpl.Java; + if ( ARQ.xercesRegex.equals(symbol) ) + return RegexImpl.Xerces; + Log.warn(E_Regex.class, "Regex implementation not recognized : default to Java"); + return RegexImpl.Java; + } + + /** For testing */ + public static void setRegexImpl(RegexImpl valRegexImpl) { + Objects.requireNonNull(valRegexImpl); + regexImpl = valRegexImpl; + } + + // These functions are used E_StrReplace, SHACL and ShEx which only use Java regex. + public static Pattern makePattern(String label, String patternStr, String flags) { + try { + int mask = 0; + if ( flags != null ) { + mask = makeMask(flags); + if ( flags.contains("q") ) + patternStr = Pattern.quote(patternStr); + } + return Pattern.compile(patternStr, mask); + } catch (PatternSyntaxException pEx) { + throw new ExprEvalException(label + " pattern exception: " + pEx); + } + } + + public static int makeMask(String modifiers) { + if ( modifiers == null ) + return 0; + + int newMask = 0; + for ( int i = 0 ; i < modifiers.length() ; i++ ) { + switch (modifiers.charAt(i)) { + case 'i' : + newMask |= Pattern.UNICODE_CASE; + newMask |= Pattern.CASE_INSENSITIVE; + break; + case 'm' : + newMask |= Pattern.MULTILINE; + break; + case 's' : + newMask |= Pattern.DOTALL; + break; + // Not supported by Java regex + // case 'x': newMask |= Pattern.; break; + case 'q' :; + break; + + default : + throw new ExprEvalException("Unsupported flag in regex modifiers: " + modifiers.charAt(i)); + } + } + return newMask; + } + + public static class RegexJava extends RegexEngine { + private final Pattern regexPattern; + + public RegexJava(String pattern, String flags) { + regexPattern = makePattern("Regex", pattern, flags); + } + + @Override + public boolean match(String s) { + Matcher m = regexPattern.matcher(s); + return m.find(); + } + + } + + public static class RegexXerces extends RegexEngine { + private final RegularExpression regexPattern; + + public RegexXerces(String pattern, String flags) { + if ( flags != null && flags.contains("q") ) { + flags = flags.replace("q", ""); + pattern = REUtil.quoteMeta(pattern); + } + regexPattern = makePattern(pattern, flags); + } + + @Override + public boolean match(String s) { + return regexPattern.matches(s); + } + + private RegularExpression makePattern(String patternStr, String flags) { + // flag q supported above. + // Input : only m s i x + // Check/modify flags. + // Always "u", never patternStr + // x: Remove whitespace characters (#x9, #xA, #xD and #x20) unless in [] classes + try { + return new RegularExpression(patternStr, flags); + } catch (RegexParseException pEx) { + throw new ExprEvalException("Regex: Pattern exception: " + pEx); + } + } + } + + public static RegexEngine create(String pattern, String flags) { + return switch (regexImpl) { + case Java -> new RegexEngine.RegexJava(pattern, flags); + case Xerces -> new RegexEngine.RegexXerces(pattern, flags); + default -> new RegexEngine.RegexJava(pattern, flags); + }; + } -public interface RegexEngine -{ - public boolean match(String string) ; } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexJava.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexJava.java deleted file mode 100644 index c6bfbb0f9d..0000000000 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexJava.java +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.jena.sparql.expr; - -import java.util.regex.Matcher; -import java.util.regex.Pattern; -import java.util.regex.PatternSyntaxException; - -public class RegexJava implements RegexEngine -{ - private Pattern regexPattern; - - public RegexJava(String pattern, String flags) { - regexPattern = makePattern("Regex", pattern, flags); - } - - @Override - public boolean match(String s) { - Matcher m = regexPattern.matcher(s); - return m.find(); - } - - public static Pattern makePattern(String label, String patternStr, String flags) { - try { - int mask = 0; - if ( flags != null ) { - mask = makeMask(flags); - if ( flags.contains("q") ) - patternStr = Pattern.quote(patternStr); - } - return Pattern.compile(patternStr, mask); - } - catch (PatternSyntaxException pEx) { - throw new ExprEvalException(label+" pattern exception: " + pEx); - } - } - - public static int makeMask(String modifiers) { - if ( modifiers == null ) - return 0; - - int newMask = 0; - for ( int i = 0; i < modifiers.length(); i++ ) { - switch (modifiers.charAt(i)) { - case 'i': - newMask |= Pattern.UNICODE_CASE; - newMask |= Pattern.CASE_INSENSITIVE; - break; - case 'm': newMask |= Pattern.MULTILINE; break; - case 's': newMask |= Pattern.DOTALL; break; - // Not suported by Java regex - //case 'x': newMask |= Pattern.; break; - case 'q':; break; - - default: - throw new ExprEvalException("Unsupported flag in regex modifiers: "+modifiers.charAt(i)); - } - } - return newMask; - } -} diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexXerces.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexXerces.java deleted file mode 100644 index da7deceda4..0000000000 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexXerces.java +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.jena.sparql.expr; - -import org.apache.jena.ext.xerces_regex.RegexParseException; -import org.apache.jena.ext.xerces_regex.REUtil; -import org.apache.jena.ext.xerces_regex.RegularExpression; - -public class RegexXerces implements RegexEngine -{ - RegularExpression regexPattern ; - - public RegexXerces(String pattern, String flags) - { - if ( flags.contains("q") ) - pattern = REUtil.quoteMeta(pattern); - regexPattern = makePattern(pattern, flags) ; - } - - @Override - public boolean match(String s) - { - return regexPattern.matches(s) ; - } - - private RegularExpression makePattern(String patternStr, String flags) - { - // flag q supported above. - // Input : only m s i x - // Check/modify flags. - // Always "u", never patternStr - // x: Remove whitespace characters (#x9, #xA, #xD and #x20) unless in [] classes - try { return new RegularExpression(patternStr, flags) ; } - catch (RegexParseException pEx) - { throw new ExprEvalException("Regex: Pattern exception: "+pEx) ; } - } -} diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java index 08175154b3..7c134f9397 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java @@ -567,7 +567,7 @@ public class XSDFuncOp String flagsStr = null; if ( nvFlags != null ) flagsStr = checkAndGetStringLiteral("replace", nvFlags).getLiteralLexicalForm(); - return strReplace(nvStr, RegexJava.makePattern("replace", pat, flagsStr), nvReplacement); + return strReplace(nvStr, RegexEngine.makePattern("replace", pat, flagsStr), nvReplacement); } public static NodeValue strReplace(NodeValue nvStr, Pattern pattern, NodeValue nvReplacement) { diff --git a/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/message.properties b/jena-arq/src/main/resources/org/apache/jena/ext/xerces_regex/message.properties similarity index 97% rename from jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/message.properties rename to jena-arq/src/main/resources/org/apache/jena/ext/xerces_regex/message.properties index ee5d50d491..5eb83fa671 100644 --- a/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/message.properties +++ b/jena-arq/src/main/resources/org/apache/jena/ext/xerces_regex/message.properties @@ -15,7 +15,7 @@ # limitations under the License. # -# @version $Id: message.properties 595212 2007-11-15 05:28:57Z mrglavas $ +# Version message.properties svn:595212 2007-11-15 05:28:57Z mrglavas parser.parse.1=Wrong character. parser.parse.2=Invalid reference number. diff --git a/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/message_fr.properties b/jena-arq/src/main/resources/org/apache/jena/ext/xerces_regex/message_fr.properties similarity index 97% rename from jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/message_fr.properties rename to jena-arq/src/main/resources/org/apache/jena/ext/xerces_regex/message_fr.properties index 6c1e84029e..3ab1cd816f 100644 --- a/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/message_fr.properties +++ b/jena-arq/src/main/resources/org/apache/jena/ext/xerces_regex/message_fr.properties @@ -15,7 +15,7 @@ # limitations under the License. # -# @version $Id: message_fr.properties 595212 2007-11-15 05:28:57Z mrglavas $ +# Version message_fr.properties svn:595212 2007-11-15 05:28:57Z mrglavas parser.parse.1=Caract\u00e8re erron\u00e9. parser.parse.2=Num\u00e9ro de r\u00e9f\u00e9rence non valide. diff --git a/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/message_ja.properties b/jena-arq/src/main/resources/org/apache/jena/ext/xerces_regex/message_ja.properties similarity index 98% rename from jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/message_ja.properties rename to jena-arq/src/main/resources/org/apache/jena/ext/xerces_regex/message_ja.properties index 043e5fa666..199c21738c 100644 --- a/jena-arq/src/main/java/org/apache/jena/ext/xerces_regex/message_ja.properties +++ b/jena-arq/src/main/resources/org/apache/jena/ext/xerces_regex/message_ja.properties @@ -15,7 +15,7 @@ # limitations under the License. # -# @version $Id: message_ja.properties 595212 2007-11-15 05:28:57Z mrglavas $ +# Version message_ja.properties svn: 595212 2007-11-15 05:28:57Z mrglavas parser.parse.1=\u4e0d\u5f53\u306a\u6587\u5b57\u3002 parser.parse.2=\u7121\u52b9\u306a\u53c2\u7167\u756a\u53f7\u3002 diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java index cb05f04d49..746ff8f8f9 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java @@ -25,7 +25,6 @@ import java.util.Collection; import org.apache.jena.query.ARQ ; import org.apache.jena.sparql.engine.binding.BindingFactory ; -import org.apache.jena.sparql.util.Symbol; import org.junit.AfterClass; import org.junit.BeforeClass ; import org.junit.Test ; @@ -38,12 +37,12 @@ public class TestRegex { @Parameters(name = "{index}: {0}") public static Collection<Object[]> data() { - return Arrays.asList(new Object[][] { { "Java Regex", ARQ.javaRegex }, - { "Xerces Regex", ARQ.xercesRegex } }); + return Arrays.asList(new Object[][] { { "Java Regex", RegexEngine.RegexImpl.Java }, + { "Xerces Regex", RegexEngine.RegexImpl.Xerces } }); } - public TestRegex(String name, Symbol setting) { - ARQ.getContext().set(ARQ.regexImpl, setting) ; + public TestRegex(String name, RegexEngine.RegexImpl regexImpl) { + RegexEngine.setRegexImpl(regexImpl); } private static Object value; diff --git a/jena-shacl/src/main/java/org/apache/jena/shacl/engine/constraint/PatternConstraint.java b/jena-shacl/src/main/java/org/apache/jena/shacl/engine/constraint/PatternConstraint.java index 04673fba30..c7ab97b273 100644 --- a/jena-shacl/src/main/java/org/apache/jena/shacl/engine/constraint/PatternConstraint.java +++ b/jena-shacl/src/main/java/org/apache/jena/shacl/engine/constraint/PatternConstraint.java @@ -18,7 +18,7 @@ package org.apache.jena.shacl.engine.constraint; -import static org.apache.jena.shacl.compact.writer.CompactOut.*; +import static org.apache.jena.shacl.compact.writer.CompactOut.compactQuotedString; import java.util.Objects; import java.util.regex.Pattern; @@ -31,7 +31,7 @@ import org.apache.jena.shacl.lib.ShLib; import org.apache.jena.shacl.parser.ConstraintVisitor; import org.apache.jena.shacl.validation.ReportItem; import org.apache.jena.shacl.vocabulary.SHACL; -import org.apache.jena.sparql.expr.RegexJava; +import org.apache.jena.sparql.expr.RegexEngine; import org.apache.jena.sparql.expr.nodevalue.NodeFunctions; /** sh:pattern. @@ -46,7 +46,7 @@ public class PatternConstraint extends ConstraintTerm { public PatternConstraint(String pattern, String flagsStr) { this.flagsStr = flagsStr; - int flags = RegexJava.makeMask(flagsStr); + int flags = RegexEngine.makeMask(flagsStr); if ( flagsStr != null && flagsStr.contains("q") ) this.patternString = Pattern.quote(pattern); else diff --git a/jena-shex/src/main/java/org/apache/jena/shex/expressions/StrRegexConstraint.java b/jena-shex/src/main/java/org/apache/jena/shex/expressions/StrRegexConstraint.java index ec7e03c06f..c907f41de9 100644 --- a/jena-shex/src/main/java/org/apache/jena/shex/expressions/StrRegexConstraint.java +++ b/jena-shex/src/main/java/org/apache/jena/shex/expressions/StrRegexConstraint.java @@ -26,7 +26,7 @@ import java.util.regex.Pattern; import org.apache.jena.graph.Node; import org.apache.jena.shex.sys.ReportItem; import org.apache.jena.shex.sys.ValidationContext; -import org.apache.jena.sparql.expr.RegexJava; +import org.apache.jena.sparql.expr.RegexEngine; import org.apache.jena.sparql.expr.nodevalue.NodeFunctions; /** sh:pattern. @@ -44,7 +44,7 @@ public class StrRegexConstraint extends NodeConstraintComponent { this.flagsStr = flagsStr; // Special quotes // Adds "q" - int flags = RegexJava.makeMask(flagsStr); + int flags = RegexEngine.makeMask(flagsStr); if ( flagsStr != null && flagsStr.contains("q") ) this.patternString = Pattern.quote(pattern); else
