/*
* 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.tinkerpop.gremlin.jsr223;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* A module that allows custom class, static method and enum imports (i.e. those that are statically defined by a
* module within itself). A user might utilize this class to supply their own imports. This module is not specific
* to any {@link GremlinScriptEngine} - the imports are supplied to all engines. This {@link GremlinPlugin} is not
* enabled for the {@code ServiceLoader}. It is designed to be instantiated manually.
*
* @author Stephen Mallette (http://stephen.genoprime.com)
*/
public final class ImportGremlinPlugin extends AbstractGremlinPlugin {
private static final String NAME = "tinkerpop.import";
private ImportGremlinPlugin(final Builder builder) {
super(NAME, builder.appliesTo, DefaultImportCustomizer.build()
.addClassImports(builder.classImports)
.addEnumImports(builder.enumImports)
.addMethodImports(builder.methodImports).create());
}
public static Builder build() {
return new Builder();
}
public static final class Builder {
private static final Pattern METHOD_PATTERN = Pattern.compile("(.*)#(.*)\\((.*)\\)");
private static final Pattern ENUM_PATTERN = Pattern.compile("(.*)#(.*)");
private Set<Class> classImports = new HashSet<>();
private Set<Method> methodImports = new HashSet<>();
private Set<Enum> enumImports = new HashSet<>();
private final Set<String> appliesTo = new HashSet<>();
private Builder() {}
/**
* The name of the {@link GremlinScriptEngine} that this module will apply to. Setting no values here will
* make the module available to all the engines.
*/
public Builder appliesTo(final Collection<String> scriptEngineName) {
this.appliesTo.addAll(scriptEngineName);
return this;
}
public Builder classImports(final Class<?>... classes) {
classImports.addAll(Arrays.asList(classes));
return this;
}
public Builder classImports(final Collection<String> classes) {
for (String clazz : classes) {
try {
classImports.add(Class.forName(clazz));
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
}
return this;
}
public Builder methodImports(final Collection<String> methods) {
for (String method : methods) {
try {
if (method.endsWith("#*")) {
final String classString = method.substring(0, method.length() - 2);
final Class<?> clazz = Class.forName(classString);
methodImports.addAll(allStaticMethods(clazz));
} else {
final Matcher matcher = METHOD_PATTERN.matcher(method);
if (!matcher.matches())
throw new IllegalArgumentException(String.format("Could not read method descriptor - check format of: %s", method));
final String classString = matcher.group(1);
final String methodString = matcher.group(2);
final String argString = matcher.group(3);
final Class<?> clazz = Class.forName(classString);
methodImports.add(clazz.getMethod(methodString, parse(argString)));
}
} catch (IllegalArgumentException iae) {
throw iae;
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
}
return this;
}
public Builder methodImports(final Method... methods) {
methodImports.addAll(Arrays.asList(methods));
return this;
}
public Builder enumImports(final Collection<String> enums) {
for (String enumItem : enums) {
try {
if (enumItem.endsWith("#*")) {
final String classString = enumItem.substring(0, enumItem.length() - 2);
final Class<?> clazz = Class.forName(classString);
enumImports.addAll(allEnums(clazz));
} else {
final Matcher matcher = ENUM_PATTERN.matcher(enumItem);
if (!matcher.matches())
throw new IllegalArgumentException(String.format("Could not read enum descriptor - check format of: %s", enumItem));
final String classString = matcher.group(1);
final String enumValString = matcher.group(2);
final Class<?> clazz = Class.forName(classString);
Stream.of(clazz.getEnumConstants())
.filter(e -> ((Enum) e).name().equals(enumValString))
.findFirst().ifPresent(e -> enumImports.add((Enum) e));
}
} catch (IllegalArgumentException iae) {
throw iae;
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
}
return this;
}
public Builder enumImports(final Enum... enums) {
enumImports.addAll(Arrays.asList(enums));
return this;
}
public ImportGremlinPlugin create() {
if (enumImports.isEmpty() && classImports.isEmpty() && methodImports.isEmpty())
throw new IllegalStateException("At least one import must be specified");
return new ImportGremlinPlugin(this);
}
private static List<Enum> allEnums(final Class<?> clazz) {
return Stream.of(clazz.getEnumConstants()).map(e -> (Enum) e).collect(Collectors.toList());
}
private static List<Method> allStaticMethods(final Class<?> clazz) {
return Stream.of(clazz.getMethods()).filter(m -> Modifier.isStatic(m.getModifiers())).collect(Collectors.toList());
}
private static Class<?>[] parse(final String argString) {
if (null == argString || argString.isEmpty())
return new Class<?>[0];
final List<String> args = Stream.of(argString.split(",")).map(String::trim).collect(Collectors.toList());
final Class<?>[] classes = new Class<?>[args.size()];
for (int ix = 0; ix < args.size(); ix++) {
try {
classes[ix] = Class.forName(args.get(ix));
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
}
return classes;
}
}
}