/*
* ModeShape (http://www.modeshape.org)
*
* Licensed 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.modeshape.schematic.internal.schema;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.StringTokenizer;
import org.modeshape.schematic.SchemaLibrary;
import org.modeshape.schematic.document.Document;
import org.modeshape.schematic.document.Path;
/**
*
*/
public class DocumentTransformer {
private static final String CURLY_PREFIX = "${";
private static final String CURLY_SUFFIX = "}";
private static final String VAR_DELIM = ",";
private static final String DEFAULT_DELIM = ":";
protected static interface PropertyAccessor {
String getProperty( String name );
}
protected static final class PropertiesAccessor implements PropertyAccessor {
private final Properties properties;
protected PropertiesAccessor( Properties properties ) {
this.properties = properties;
}
@Override
public String getProperty( String name ) {
return properties.getProperty(name);
}
}
protected static final class SystemPropertyAccessor implements PropertyAccessor {
public static final SystemPropertyAccessor INSTANCE = new SystemPropertyAccessor();
private SystemPropertyAccessor() {
// prevent instantiation
}
@Override
public String getProperty( final String name ) {
return AccessController.doPrivileged((PrivilegedAction<String>) () -> System.getProperty(name));
}
}
/**
* getSubstitutedProperty is called to perform the property substitution on the value.
*
* @param value
* @param propertyAccessor
* @return String
*/
public static String getSubstitutedProperty( String value,
PropertyAccessor propertyAccessor ) {
if (value == null || value.trim().length() == 0) return value;
StringBuilder sb = new StringBuilder(value);
// Get the index of the first constant, if any
int startName = sb.indexOf(CURLY_PREFIX);
if (startName == -1) return value;
// process as many different variable groupings that are defined, where one group will resolve to one property
// substitution
while (startName != -1) {
String defaultValue = null;
int endName = sb.indexOf(CURLY_SUFFIX, startName);
if (endName == -1) {
// if no suffix can be found, then this variable was probably defined incorrectly
// but return what there is at this point
return sb.toString();
}
String varString = sb.substring(startName + 2, endName);
if (varString.indexOf(DEFAULT_DELIM) > -1) {
List<String> defaults = split(varString, DEFAULT_DELIM);
// get the property(s) variables that are defined left of the default delimiter.
varString = defaults.get(0);
// if the default is defined, then capture in case none of the other properties are found
if (defaults.size() == 2) {
defaultValue = defaults.get(1);
}
}
String constValue = null;
// split the property(s) based VAR_DELIM, when multiple property options are defined
List<String> vars = split(varString, VAR_DELIM);
for (final String var : vars) {
constValue = System.getenv(var);
if (constValue == null) {
constValue = propertyAccessor.getProperty(var);
}
// the first found property is the value to be substituted
if (constValue != null) {
break;
}
}
// if no property is found to substitute, then use the default value, if defined
if (constValue == null && defaultValue != null) {
constValue = defaultValue;
}
if (constValue != null) {
sb = sb.replace(startName, endName + 1, constValue);
// Checking for another constants
startName = sb.indexOf(CURLY_PREFIX);
} else {
// continue to try to substitute for other properties so that all defined variables
// are tried to be substituted for
startName = sb.indexOf(CURLY_PREFIX, endName);
}
}
return sb.toString();
}
/**
* Split a string into pieces based on delimiters. Similar to the perl function of the same name. The delimiters are not
* included in the returned strings.
*
* @param str Full string
* @param splitter Characters to split on
* @return List of String pieces from full string
*/
private static List<String> split( String str,
String splitter ) {
StringTokenizer tokens = new StringTokenizer(str, splitter);
ArrayList<String> l = new ArrayList<>(tokens.countTokens());
while (tokens.hasMoreTokens()) {
l.add(tokens.nextToken());
}
return l;
}
/**
* An implementation of {@link Document.ValueTransformer} that replaces variables in the
* field values with values from the system properties. Only string values are considered, since other types cannot contain
* variables (and since the transformers are never called on Document or List values).
* <p>
* Variables may appear anywhere within a string value, and multiple variables can be used within the same value. Variables
* take the form:
*
* <pre>
* variable := '${' variableNames [ ':' defaultValue ] '}'
*
* variableNames := variableName [ ',' variableNames ]
*
* variableName := /* any characters except ',' and ':' and '}'
*
* defaultValue := /* any characters except
* </pre>
*
* Note that <i>variableName</i> is the name used to look up a the property.
* </p>
* Notice that the syntax supports multiple <i>variables</i>. The logic will process the <i>variables</i> from let to right,
* until an existing property is found. And at that point, it will stop and will not attempt to find values for the other
* <i>variables</i>.
* <p>
*/
public static final class PropertiesTransformer implements Document.ValueTransformer {
private final PropertiesAccessor accessor;
public PropertiesTransformer( Properties properties ) {
this.accessor = new PropertiesAccessor(properties);
}
@Override
public Object transform( String name,
Object value ) {
// Only look at string values ...
if (value instanceof String) {
return getSubstitutedProperty((String)value, this.accessor);
}
return value;
}
}
/**
* An implementation of {@link Document.ValueTransformer} that replaces variables in the
* field values with values from the system properties. Only string values are considered, since other types cannot contain
* variables (and since the transformers are never called on Document or List values).
* <p>
* Variables may appear anywhere within a string value, and multiple variables can be used within the same value. Variables
* take the form:
*
* <pre>
* variable := '${' variableNames [ ':' defaultValue ] '}'
*
* variableNames := variableName [ ',' variableNames ]
*
* variableName := /* any characters except ',' and ':' and '}'
*
* defaultValue := /* any characters except
* </pre>
*
* Note that <i>variableName</i> is the name used to look up a System property via {@link System#getProperty(String)}.
* </p>
* Notice that the syntax supports multiple <i>variables</i>. The logic will process the <i>variables</i> from let to right,
* until an existing System property is found. And at that point, it will stop and will not attempt to find values for the
* other <i>variables</i>.
* <p>
*/
public static final class SystemPropertiesTransformer implements Document.ValueTransformer {
@Override
public Object transform( String name,
Object value ) {
// Only look at string values ...
if (value instanceof String) {
return getSubstitutedProperty((String)value, SystemPropertyAccessor.INSTANCE);
}
return value;
}
}
/**
* Return a copy of the supplied document that contains converted values for all of the fields (including in the nested
* documents and arrays) that have values that are of the wrong type but can be converted to be of the correct type.
* <p>
* This method does nothing and returns the original document if there are no changes to be made.
* </p>
*
* @param original the original document that contains fields with mismatched values; may not be null
* @param results the results of the {@link SchemaLibrary#validate(Document, String) JSON Schema
* validation} and which contains the {@link SchemaLibrary.MismatchedTypeProblem type mismatch errors}
* @return the document with all of the conversions made the its fields and the fields of nested documents, or the original
* document if there are no conversions to be made; never null
*/
public static Document convertValuesWithMismatchedTypes( Document original,
SchemaLibrary.Results results ) {
if (results == null || !results.hasProblems()) return original;
// Create a conversion object for each of the field values with mismatched (but convertable) types ...
LinkedList<Conversion> conversions = new LinkedList<>();
for (SchemaLibrary.Problem problem : results) {
if (problem instanceof SchemaLibrary.MismatchedTypeProblem) {
conversions.add(new Conversion((SchemaLibrary.MismatchedTypeProblem)problem));
}
}
if (conversions.isEmpty()) return original;
// Transform the original document, starting at the first level ...
return convertValuesWithMismatchedTypes(original, 0, conversions);
}
protected static Document convertValuesWithMismatchedTypes( Document original,
int level,
LinkedList<Conversion> conversions ) {
// Create a placeholder for the new field values for this document ...
Map<String, Object> changedFields = new HashMap<>();
// Now apply the changes to this document and prepare to coallesce the changes for the nested documents ...
int nextLevel = level + 1;
Map<String, LinkedList<Conversion>> nextLevelConversionsBySegment = new HashMap<>();
for (Conversion conversion : conversions) {
Path path = conversion.getPath();
assert path.size() > level;
String segment = path.get(level);
if (path.size() == nextLevel) {
// This is the last segment for this path, so change the output document's field ...
changedFields.put(segment, conversion.getConvertedValue());
} else {
// Otherwise, the path is for the nested document ...
LinkedList<Conversion> nestedConversions = nextLevelConversionsBySegment.get(segment);
if (nestedConversions == null) {
nestedConversions = new LinkedList<>();
nextLevelConversionsBySegment.put(segment, nestedConversions);
}
nestedConversions.add(conversion);
}
}
// Now apply all of the conversions for the nested documents,
// getting the results and storing them in the 'changedFields' ...
for (Map.Entry<String, LinkedList<Conversion>> entry : nextLevelConversionsBySegment.entrySet()) {
String segment = entry.getKey();
LinkedList<Conversion> nestedConversions = entry.getValue();
Document nested = original.getDocument(segment);
Document newDoc = convertValuesWithMismatchedTypes(nested, nextLevel, nestedConversions);
changedFields.put(segment, newDoc);
}
// Now create a copy of the original document but with the changed fields ...
return original.with(changedFields);
}
protected static final class Conversion implements Comparable<Conversion> {
private final SchemaLibrary.MismatchedTypeProblem problem;
protected Conversion( SchemaLibrary.MismatchedTypeProblem problem ) {
this.problem = problem;
}
@Override
public int compareTo( Conversion that ) {
if (this == that) return 0;
return this.problem.getPath().compareTo(that.problem.getPath());
}
public Path getPath() {
return this.problem.getPath();
}
public Object getConvertedValue() {
return this.problem.getConvertedValue();
}
}
}