001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017package org.apache.camel.util; 018 019import java.util.ArrayList; 020import java.util.Collections; 021import java.util.List; 022import java.util.regex.Matcher; 023import java.util.regex.Pattern; 024 025/** 026 * Helper for Camel OGNL (Object-Graph Navigation Language) expressions. 027 */ 028public final class OgnlHelper { 029 030 private static final Pattern INDEX_PATTERN = Pattern.compile("^(.*)\\[(.*)\\]$"); 031 032 private OgnlHelper() { 033 } 034 035 /** 036 * Tests whether or not the given String is a Camel OGNL expression. 037 * <p/> 038 * An expression is considered an OGNL expression when it contains either one of the following chars: . or [ 039 * 040 * @param expression the String 041 * @return <tt>true</tt> if a Camel OGNL expression, otherwise <tt>false</tt>. 042 */ 043 public static boolean isValidOgnlExpression(String expression) { 044 if (expression == null || expression.isEmpty()) { 045 return false; 046 } 047 048 // the brackets should come in a pair 049 int bracketBegin = StringHelper.countChar(expression, '['); 050 int bracketEnd = StringHelper.countChar(expression, ']'); 051 if (bracketBegin > 0 && bracketEnd > 0) { 052 return bracketBegin == bracketEnd; 053 } 054 055 return expression.contains("."); 056 } 057 058 public static boolean isInvalidValidOgnlExpression(String expression) { 059 if (expression == null) { 060 return false; 061 } 062 063 if (expression.indexOf('.') == -1 && expression.indexOf('[') == -1 && expression.indexOf(']') == -1) { 064 return false; 065 } 066 067 // the brackets should come in pair 068 int bracketBegin = StringHelper.countChar(expression, '['); 069 int bracketEnd = StringHelper.countChar(expression, ']'); 070 if (bracketBegin > 0 || bracketEnd > 0) { 071 return bracketBegin != bracketEnd; 072 } 073 074 // check for double dots 075 if (expression.contains("..")) { 076 return true; 077 } 078 079 return false; 080 } 081 082 /** 083 * Validates whether the method name is using valid java identifiers in the name Will throw 084 * {@link IllegalArgumentException} if the method name is invalid. 085 */ 086 public static void validateMethodName(String method) { 087 for (int i = 0; i < method.length(); i++) { 088 char ch = method.charAt(i); 089 if (i == 0 && '.' == ch) { 090 // its a dot before a method name 091 continue; 092 } 093 if (ch == '(' || ch == '[' || ch == '.' || ch == '?') { 094 // break when method name ends and sub method or arguments begin 095 break; 096 } 097 if (i == 0 && !Character.isJavaIdentifierStart(ch)) { 098 throw new IllegalArgumentException( 099 "Method name must start with a valid java identifier at position: 0 in method: " + method); 100 } else if (!Character.isJavaIdentifierPart(ch)) { 101 throw new IllegalArgumentException( 102 "Method name must be valid java identifier at position: " + i + " in method: " + method); 103 } 104 } 105 } 106 107 /** 108 * Tests whether or not the given Camel OGNL expression is using the null safe operator or not. 109 * 110 * @param ognlExpression the Camel OGNL expression 111 * @return <tt>true</tt> if the null safe operator is used, otherwise <tt>false</tt>. 112 */ 113 public static boolean isNullSafeOperator(String ognlExpression) { 114 return ognlExpression.startsWith("?"); 115 } 116 117 /** 118 * Removes any leading operators from the Camel OGNL expression. 119 * <p/> 120 * Will remove any leading of the following chars: ? or . 121 * 122 * @param ognlExpression the Camel OGNL expression 123 * @return the Camel OGNL expression without any leading operators. 124 */ 125 public static String removeLeadingOperators(String ognlExpression) { 126 if (ognlExpression.startsWith("?")) { 127 ognlExpression = ognlExpression.substring(1); 128 } 129 if (ognlExpression.startsWith(".")) { 130 ognlExpression = ognlExpression.substring(1); 131 } 132 return ognlExpression; 133 } 134 135 /** 136 * Removes any trailing operators from the Camel OGNL expression. 137 * 138 * @param ognlExpression the Camel OGNL expression 139 * @return the Camel OGNL expression without any trailing operators. 140 */ 141 public static String removeTrailingOperators(String ognlExpression) { 142 int pos = ognlExpression.indexOf('['); 143 if (pos != -1) { 144 return ognlExpression.substring(0, pos); 145 } 146 return ognlExpression; 147 } 148 149 public static String removeOperators(String ognlExpression) { 150 return removeLeadingOperators(removeTrailingOperators(ognlExpression)); 151 } 152 153 public static KeyValueHolder<String, String> isOgnlIndex(String ognlExpression) { 154 Matcher matcher = INDEX_PATTERN.matcher(ognlExpression); 155 if (matcher.matches()) { 156 157 // to avoid empty strings as we want key/value to be null in such cases 158 String key = matcher.group(1); 159 if (key != null && key.isEmpty()) { 160 key = null; 161 } 162 163 // to avoid empty strings as we want key/value to be null in such cases 164 String value = matcher.group(2); 165 if (value != null && value.isEmpty()) { 166 value = null; 167 } 168 169 return new KeyValueHolder<>(key, value); 170 } 171 172 return null; 173 } 174 175 /** 176 * Regular expression with repeating groups is a pain to get right and then nobody understands the reg exp 177 * afterwards. So we use a bit ugly/low-level Java code to split the OGNL into methods. 178 * 179 * @param ognl the ognl expression 180 * @return a list of methods, will return an empty list, if ognl expression has no methods 181 * @throws IllegalArgumentException if the last method has a missing ending parenthesis 182 */ 183 public static List<String> splitOgnl(String ognl) { 184 // return an empty list if ognl is empty 185 if (ognl == null || ognl.isEmpty() || ognl.trim().isEmpty()) { 186 return Collections.emptyList(); 187 } 188 189 List<String> methods = new ArrayList<>(4); 190 StringBuilder sb = new StringBuilder(); 191 192 int j = 0; // j is used as counter per method 193 int squareBracketCnt = 0; // special to keep track if and how deep we are inside a square bracket block, eg: [foo] 194 int parenthesisBracketCnt = 0; // special to keep track if and how deep we are inside a parenthesis block, eg: bar(${body}, ${header.foo}) 195 boolean singleQuoted = false; 196 boolean doubleQuoted = false; 197 198 for (int i = 0; i < ognl.length(); i++) { 199 char ch = ognl.charAt(i); 200 201 if (!doubleQuoted && ch == '\'') { 202 singleQuoted = !singleQuoted; 203 } else if (!singleQuoted && ch == '\"') { 204 doubleQuoted = !doubleQuoted; 205 } 206 if (singleQuoted || doubleQuoted) { 207 // quoted text so append as literal text 208 sb.append(ch); 209 continue; 210 } 211 212 // special for starting a new method 213 if (j == 0 || j == 1 && ognl.charAt(i - 1) == '?' 214 || ch != '.' && ch != '?' && ch != ']') { 215 sb.append(ch); 216 217 // special if we are doing square bracket 218 if (ch == '[' && parenthesisBracketCnt == 0) { 219 squareBracketCnt++; 220 } else if (ch == '(') { 221 parenthesisBracketCnt++; 222 } else if (ch == ')') { 223 parenthesisBracketCnt--; 224 } 225 j++; // advance 226 } else { 227 if (ch == '.' && squareBracketCnt == 0 && parenthesisBracketCnt == 0) { 228 // only treat dot as a method separator if not inside a square bracket block 229 // as dots can be used in key names when accessing maps 230 231 // a dit denotes end of this method and a new method is to be invoked 232 String s = sb.toString(); 233 234 // reset sb 235 sb.setLength(0); 236 237 // pass over ? to the new method 238 if (s.endsWith("?")) { 239 sb.append("?"); 240 s = s.substring(0, s.length() - 1); 241 } 242 243 // add the method 244 methods.add(s); 245 246 // reset j to begin a new method 247 j = 0; 248 } else if (ch == ']' && parenthesisBracketCnt == 0) { 249 // append ending ] to method name 250 sb.append(ch); 251 String s = sb.toString(); 252 253 // reset sb 254 sb.setLength(0); 255 256 // add the method 257 methods.add(s); 258 259 // reset j to begin a new method 260 j = 0; 261 262 // no more square bracket 263 squareBracketCnt--; 264 } 265 266 // and don't lose the char if its not an ] end marker (as we already added that) 267 if (ch != ']' || parenthesisBracketCnt > 0) { 268 sb.append(ch); 269 } 270 271 // only advance if already begun on the new method 272 if (j > 0) { 273 j++; 274 } 275 } 276 } 277 278 // add remainder in buffer when reached end of data 279 if (sb.length() > 0) { 280 methods.add(sb.toString()); 281 } 282 283 String last = methods.isEmpty() ? null : methods.get(methods.size() - 1); 284 if (parenthesisBracketCnt > 0 && last != null) { 285 // there is an unclosed parenthesis bracket on the last method, so it should end with a parenthesis 286 if (last.contains("(") && !last.endsWith(")")) { 287 throw new IllegalArgumentException("Method should end with parenthesis, was " + last); 288 } 289 } 290 291 return methods; 292 } 293 294 public static String methodAsDoubleQuotes(String ognl) { 295 StringBuilder sb = new StringBuilder(); 296 297 int singleBracketCnt = 0; 298 int doubleBracketCnt = 0; 299 for (int i = 0; i < ognl.length(); i++) { 300 char ch = ognl.charAt(i); 301 char next = i < ognl.length() - 1 ? ognl.charAt(i + 1) : 0; 302 303 if (ch == '\\' && next == '\'') { 304 if (singleBracketCnt % 2 != 0) { 305 // its an escaped single quote inside an existing quote 306 // then unescape it 307 sb.append('\''); 308 // and skip over to next 309 i++; 310 continue; 311 } 312 } 313 314 if (doubleBracketCnt % 2 == 0 && ch == '\'') { 315 singleBracketCnt++; 316 sb.append('"'); 317 } else if (singleBracketCnt % 2 == 0 && ch == '"') { 318 doubleBracketCnt++; 319 sb.append('"'); 320 } else { 321 sb.append(ch); 322 } 323 } 324 325 return sb.toString(); 326 } 327 328}