ConditionFunctions.java
/*
* 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.maven.impl.model.profile;
import java.util.List;
import org.apache.maven.api.services.InterpolatorException;
import org.apache.maven.api.services.ModelBuilderException;
import org.apache.maven.api.services.VersionParser;
import org.apache.maven.api.services.model.ProfileActivationContext;
import static org.apache.maven.impl.model.profile.ConditionParser.toInt;
/**
* Provides a set of functions for evaluating profile activation conditions.
* These functions can be used in profile activation expressions to determine
* whether a profile should be activated based on various criteria.
*/
@SuppressWarnings("unused")
public class ConditionFunctions {
private final ProfileActivationContext context;
private final VersionParser versionParser;
/**
* Constructs a new ConditionFunctions instance.
*
* @param context The profile activation context
* @param versionParser The version parser for comparing versions
*/
public ConditionFunctions(ProfileActivationContext context, VersionParser versionParser) {
this.context = context;
this.versionParser = versionParser;
}
/**
* Returns the length of the given string.
*
* @param args A list containing a single string argument
* @return The length of the string
* @throws IllegalArgumentException if the number of arguments is not exactly one
*/
public Object length(List<Object> args) {
if (args.size() != 1) {
throw new IllegalArgumentException("length function requires exactly one argument");
}
String s = ConditionParser.toString(args.get(0));
return s.length();
}
/**
* Converts the given string to uppercase.
*
* @param args A list containing a single string argument
* @return The uppercase version of the input string
* @throws IllegalArgumentException if the number of arguments is not exactly one
*/
public Object upper(List<Object> args) {
if (args.size() != 1) {
throw new IllegalArgumentException("upper function requires exactly one argument");
}
String s = ConditionParser.toString(args.get(0));
return s.toUpperCase();
}
/**
* Converts the given string to lowercase.
*
* @param args A list containing a single string argument
* @return The lowercase version of the input string
* @throws IllegalArgumentException if the number of arguments is not exactly one
*/
public Object lower(List<Object> args) {
if (args.size() != 1) {
throw new IllegalArgumentException("lower function requires exactly one argument");
}
String s = ConditionParser.toString(args.get(0));
return s.toLowerCase();
}
/**
* Returns a substring of the given string.
*
* @param args A list containing 2 or 3 arguments: the string, start index, and optionally end index
* @return The substring
* @throws IllegalArgumentException if the number of arguments is not 2 or 3
*/
public Object substring(List<Object> args) {
if (args.size() < 2 || args.size() > 3) {
throw new IllegalArgumentException("substring function requires 2 or 3 arguments");
}
String s = ConditionParser.toString(args.get(0));
int start = toInt(args.get(1));
int end = args.size() == 3 ? toInt(args.get(2)) : s.length();
return s.substring(start, end);
}
/**
* Finds the index of a substring within a string.
*
* @param args A list containing two strings: the main string and the substring to find
* @return The index of the substring, or -1 if not found
* @throws IllegalArgumentException if the number of arguments is not exactly two
*/
public Object indexOf(List<Object> args) {
if (args.size() != 2) {
throw new IllegalArgumentException("indexOf function requires exactly two arguments");
}
String s = ConditionParser.toString(args.get(0));
String substring = ConditionParser.toString(args.get(1));
return s.indexOf(substring);
}
/**
* Checks if a string contains a given substring.
*
* @param args A list containing two strings: the main string and the substring to check
* @return true if the main string contains the substring, false otherwise
* @throws IllegalArgumentException if the number of arguments is not exactly two
*/
public Object contains(List<Object> args) {
if (args.size() != 2) {
throw new IllegalArgumentException("contains function requires exactly two arguments");
}
String s = ConditionParser.toString(args.get(0));
String substring = ConditionParser.toString(args.get(1));
return s.contains(substring);
}
/**
* Checks if a string matches a given regular expression.
*
* @param args A list containing two strings: the string to check and the regex pattern
* @return true if the string matches the regex, false otherwise
* @throws IllegalArgumentException if the number of arguments is not exactly two
*/
public Object matches(List<Object> args) {
if (args.size() != 2) {
throw new IllegalArgumentException("matches function requires exactly two arguments");
}
String s = ConditionParser.toString(args.get(0));
String regex = ConditionParser.toString(args.get(1));
return s.matches(regex);
}
/**
* Negates a boolean value.
*
* @param args A list containing a single boolean argument
* @return The negation of the input boolean
* @throws IllegalArgumentException if the number of arguments is not exactly one
*/
public Object not(List<Object> args) {
if (args.size() != 1) {
throw new IllegalArgumentException("not function requires exactly one argument");
}
return !ConditionParser.toBoolean(args.get(0));
}
/**
* Implements an if-then-else operation.
*
* @param args A list containing three arguments: condition, value if true, value if false
* @return The second argument if the condition is true, the third argument otherwise
* @throws IllegalArgumentException if the number of arguments is not exactly three
*/
@SuppressWarnings("checkstyle:MethodName")
public Object if_(List<Object> args) {
if (args.size() != 3) {
throw new IllegalArgumentException("if function requires exactly three arguments");
}
boolean condition = ConditionParser.toBoolean(args.get(0));
return condition ? args.get(1) : args.get(2);
}
/**
* Checks if a file or directory exists at the given path.
*
* @param args A list containing a single string argument representing the path
* @return {@code true} if the file or directory exists, {@code false} otherwise
* @throws IllegalArgumentException if the number of arguments is not exactly one
* @throws ModelBuilderException if a problem occurs while walking the file system
* @throws InterpolatorException if an error occurs during interpolation
*/
public Object exists(List<Object> args) {
if (args.size() != 1) {
throw new IllegalArgumentException("exists function requires exactly one argument");
}
String path = ConditionParser.toString(args.get(0));
return context.exists(path, true);
}
/**
* Checks if a file or directory is missing at the given path.
*
* @param args A list containing a single string argument representing the path
* @return {@code true} if the file or directory does not exist, {@code false} otherwise
* @throws IllegalArgumentException if the number of arguments is not exactly one
* @throws ModelBuilderException if a problem occurs while walking the file system
* @throws InterpolatorException if an error occurs during interpolation
*/
public Object missing(List<Object> args) {
if (args.size() != 1) {
throw new IllegalArgumentException("missing function requires exactly one argument");
}
String path = ConditionParser.toString(args.get(0));
return !context.exists(path, true);
}
/**
* Checks if a version is within a specified version range.
*
* @param args A list containing two strings: the version to check and the version range
* @return true if the version is within the range, false otherwise
* @throws IllegalArgumentException if the number of arguments is not exactly two
*/
public Object inrange(List<Object> args) {
if (args.size() != 2) {
throw new IllegalArgumentException("inrange function requires exactly two arguments");
}
String version = ConditionParser.toString(args.get(0));
String range = ConditionParser.toString(args.get(1));
return versionParser.parseVersionRange(range).contains(versionParser.parseVersion(version));
}
}