com.metaeffekt.artifact.analysis.spdxbom.config.AssembledConfig Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ae-artifact-analysis Show documentation
There is a newer version: 0.132.0
/*
 * Copyright 2021-2024 the original author or authors.
 *
 * 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 com.metaeffekt.artifact.analysis.spdxbom.config;

import com.metaeffekt.artifact.analysis.spdxbom.mapper.ArtifactMapper;
import org.metaeffekt.core.inventory.processor.model.Artifact;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * Assembled configuration that will be used to decide which artifact mapper to run.
 */
public class AssembledConfig {
    /**
     * Maps artifact key to Regex patterns. If all patterns match the artifact, this config applies.
     */
    protected final Map mustMatch;

    /**
     * The mapper that will be used if this config applies.
     */
    protected final ArtifactMapper mapperToUse;

    /**
     * Might be useful for assigning priorities if multiple MapperConfigs match an artifact. More specific is "better".
     */
    protected final int specificity;

    /**
     * Creates a new MapperConfig.
     * @param mustMatchPatterns Artifact attribute key to regex pattern to be matched. Config matches if all match.
     * @param mapperToUse Name of the Mapper that will be used if this config applies.
     * @param specificity Specificity assigned to this config. Specific configs will be preferred over generic ones.
     */
    public AssembledConfig(Map mustMatchPatterns, ArtifactMapper mapperToUse, int specificity) {

        // check mapperToUse
        if (mapperToUse == null) {
            throw new IllegalArgumentException("mapperToUse may not be null.");
        }

        this.mustMatch = Collections.unmodifiableMap(new HashMap<>(mustMatchPatterns));
        this.mapperToUse = mapperToUse;
        this.specificity = specificity;
    }

    /**
     * Checks whether this config's mustMatch matches this artifact.
     * @param artifact Artifact to check.
     * @return True if mustMatch matches.
     */
    public boolean isApplicable(Artifact artifact) {
        // if none must match, it's always applicable
        if (mustMatch == null) {
            return true;
        }

        for (Map.Entry requiredMatchEntry : mustMatch.entrySet()) {
            String attrValue = artifact.get(requiredMatchEntry.getKey());
            attrValue = attrValue == null ? "" : attrValue;

            try {
                if (!requiredMatchEntry.getValue().matcher(attrValue).matches()) {
                    return false;
                }
            } catch( NullPointerException e) {
                throw new RuntimeException(e);
            }
        }

        return true;
    }

    public Map getMustMatch() {
        return mustMatch;
    }

    public ArtifactMapper getMapperToUse() {
        return mapperToUse;
    }

    public int getSpecificity() {
        return specificity;
    }
}