All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • org.apache.maven.project.interpolation.StringSearchModelInterpolator Maven / Gradle / Ivy

    There is a newer version: 4.0.0-rc-2
    Show newest version
    /*
 * 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.project.interpolation;

import javax.inject.Named;
import javax.inject.Singleton;

import java.io.File;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;

import org.apache.maven.model.Model;
import org.apache.maven.project.ProjectBuilderConfiguration;
import org.apache.maven.project.path.PathTranslator;
import org.codehaus.plexus.interpolation.InterpolationPostProcessor;
import org.codehaus.plexus.interpolation.Interpolator;
import org.codehaus.plexus.interpolation.StringSearchInterpolator;
import org.codehaus.plexus.interpolation.ValueSource;
import org.codehaus.plexus.logging.Logger;

/**
 * StringSearchModelInterpolator
 */
@Deprecated
@Named
@Singleton
public class StringSearchModelInterpolator extends AbstractStringBasedModelInterpolator {

    private static final Map, Field[]> FIELDS_BY_CLASS = new WeakHashMap<>();
    private static final Map, Boolean> PRIMITIVE_BY_CLASS = new WeakHashMap<>();

    public StringSearchModelInterpolator() {}

    public StringSearchModelInterpolator(PathTranslator pathTranslator) {
        super(pathTranslator);
    }

    public Model interpolate(Model model, File projectDir, ProjectBuilderConfiguration config, boolean debugEnabled)
            throws ModelInterpolationException {
        interpolateObject(model, model, projectDir, config, debugEnabled);

        return model;
    }

    protected void interpolateObject(
            Object obj, Model model, File projectDir, ProjectBuilderConfiguration config, boolean debugEnabled)
            throws ModelInterpolationException {
        try {
            List valueSources = createValueSources(model, projectDir, config);
            List postProcessors = createPostProcessors(model, projectDir, config);

            InterpolateObjectAction action =
                    new InterpolateObjectAction(obj, valueSources, postProcessors, debugEnabled, this, getLogger());

            ModelInterpolationException error = AccessController.doPrivileged(action);

            if (error != null) {
                throw error;
            }
        } finally {
            getInterpolator().clearAnswers();
        }
    }

    protected Interpolator createInterpolator() {
        StringSearchInterpolator interpolator = new StringSearchInterpolator();
        interpolator.setCacheAnswers(true);

        return interpolator;
    }

    private static final class InterpolateObjectAction implements PrivilegedAction {

        private final boolean debugEnabled;
        private final LinkedList interpolationTargets;
        private final StringSearchModelInterpolator modelInterpolator;
        private final Logger logger;
        private final List valueSources;
        private final List postProcessors;

        InterpolateObjectAction(
                Object target,
                List valueSources,
                List postProcessors,
                boolean debugEnabled,
                StringSearchModelInterpolator modelInterpolator,
                Logger logger) {
            this.valueSources = valueSources;
            this.postProcessors = postProcessors;
            this.debugEnabled = debugEnabled;

            this.interpolationTargets = new LinkedList<>();
            interpolationTargets.add(target);

            this.modelInterpolator = modelInterpolator;
            this.logger = logger;
        }

        public ModelInterpolationException run() {
            while (!interpolationTargets.isEmpty()) {
                Object obj = interpolationTargets.removeFirst();

                try {
                    traverseObjectWithParents(obj.getClass(), obj);
                } catch (ModelInterpolationException e) {
                    return e;
                }
            }

            return null;
        }

        @SuppressWarnings({"unchecked", "checkstyle:methodlength"})
        private void traverseObjectWithParents(Class cls, Object target) throws ModelInterpolationException {
            if (cls == null) {
                return;
            }

            if (cls.isArray()) {
                evaluateArray(target);
            } else if (isQualifiedForInterpolation(cls)) {
                Field[] fields = FIELDS_BY_CLASS.computeIfAbsent(cls, k -> cls.getDeclaredFields());

                for (Field field : fields) {
                    Class type = field.getType();
                    if (isQualifiedForInterpolation(field, type)) {
                        boolean isAccessible = field.isAccessible();
                        field.setAccessible(true);
                        try {
                            try {
                                if (String.class == type) {
                                    String value = (String) field.get(target);
                                    if (value != null) {
                                        String interpolated = modelInterpolator.interpolateInternal(
                                                value, valueSources, postProcessors, debugEnabled);

                                        if (!interpolated.equals(value)) {
                                            field.set(target, interpolated);
                                        }
                                    }
                                } else if (Collection.class.isAssignableFrom(type)) {
                                    Collection c = (Collection) field.get(target);
                                    if (c != null && !c.isEmpty()) {
                                        List originalValues = new ArrayList<>(c);
                                        try {
                                            c.clear();
                                        } catch (UnsupportedOperationException e) {
                                            if (debugEnabled && logger != null) {
                                                logger.debug("Skipping interpolation of field: " + field + " in: "
                                                        + cls.getName()
                                                        + "; it is an unmodifiable collection.");
                                            }
                                            continue;
                                        }

                                        for (Object value : originalValues) {
                                            if (value != null) {
                                                if (String.class == value.getClass()) {
                                                    String interpolated = modelInterpolator.interpolateInternal(
                                                            (String) value, valueSources, postProcessors, debugEnabled);

                                                    if (!interpolated.equals(value)) {
                                                        c.add(interpolated);
                                                    } else {
                                                        c.add(value);
                                                    }
                                                } else {
                                                    c.add(value);
                                                    if (value.getClass().isArray()) {
                                                        evaluateArray(value);
                                                    } else {
                                                        interpolationTargets.add(value);
                                                    }
                                                }
                                            } else {
                                                // add the null back in...not sure what else to do...
                                                c.add(value);
                                            }
                                        }
                                    }
                                } else if (Map.class.isAssignableFrom(type)) {
                                    Map m = (Map) field.get(target);
                                    if (m != null && !m.isEmpty()) {
                                        for (Map.Entry entry : m.entrySet()) {
                                            Object value = entry.getValue();

                                            if (value != null) {
                                                if (String.class == value.getClass()) {
                                                    String interpolated = modelInterpolator.interpolateInternal(
                                                            (String) value, valueSources, postProcessors, debugEnabled);

                                                    if (!interpolated.equals(value)) {
                                                        try {
                                                            entry.setValue(interpolated);
                                                        } catch (UnsupportedOperationException e) {
                                                            if (debugEnabled && logger != null) {
                                                                logger.debug("Skipping interpolation of field: " + field
                                                                        + " (key: " + entry.getKey() + ") in: "
                                                                        + cls.getName()
                                                                        + "; it is an unmodifiable collection.");
                                                            }
                                                        }
                                                    }
                                                } else {
                                                    if (value.getClass().isArray()) {
                                                        evaluateArray(value);
                                                    } else {
                                                        interpolationTargets.add(value);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                } else {
                                    Object value = field.get(target);
                                    if (value != null) {
                                        if (field.getType().isArray()) {
                                            evaluateArray(value);
                                        } else {
                                            interpolationTargets.add(value);
                                        }
                                    }
                                }
                            } catch (IllegalArgumentException | IllegalAccessException e) {
                                throw new ModelInterpolationException(
                                        "Failed to interpolate field: " + field + " on class: " + cls.getName(), e);
                            }
                        } finally {
                            field.setAccessible(isAccessible);
                        }
                    }
                }

                traverseObjectWithParents(cls.getSuperclass(), target);
            }
        }

        private boolean isQualifiedForInterpolation(Class cls) {
            return !cls.getPackage().getName().startsWith("java")
                    && !cls.getPackage().getName().startsWith("sun.nio.fs");
        }

        private boolean isQualifiedForInterpolation(Field field, Class fieldType) {
            if (!PRIMITIVE_BY_CLASS.containsKey(fieldType)) {
                PRIMITIVE_BY_CLASS.put(fieldType, fieldType.isPrimitive());
            }

            if (PRIMITIVE_BY_CLASS.get(fieldType)) {
                return false;
            }

            //            if ( fieldType.isPrimitive() )
            //            {
            //                return false;
            //            }

            return !"parent".equals(field.getName());
        }

        private void evaluateArray(Object target) throws ModelInterpolationException {
            int len = Array.getLength(target);
            for (int i = 0; i < len; i++) {
                Object value = Array.get(target, i);
                if (value != null) {
                    if (String.class == value.getClass()) {
                        String interpolated = modelInterpolator.interpolateInternal(
                                (String) value, valueSources, postProcessors, debugEnabled);

                        if (!interpolated.equals(value)) {
                            Array.set(target, i, interpolated);
                        }
                    } else {
                        interpolationTargets.add(value);
                    }
                }
            }
        }
    }
}
    
    
    
    

    




    
    
    © 2015 - 2024 Weber Informatics LLC | Privacy Policy