org.spdx.rdfparser.model.SpdxElementFactory Maven / Gradle / Ivy
/**
* Copyright (c) 2015 Source Auditor Inc.
*
* 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.spdx.rdfparser.model;
import java.util.Map;
import org.spdx.rdfparser.IModelContainer;
import org.spdx.rdfparser.InvalidSPDXAnalysisException;
import org.spdx.rdfparser.SpdxDocumentContainer;
import org.spdx.rdfparser.SpdxRdfConstants;
import com.google.common.collect.Maps;
import org.apache.jena.graph.Node;
import org.apache.jena.graph.Triple;
import org.apache.jena.util.iterator.ExtendedIterator;
/**
* Factory for creating SpdxElements from a Jena Model
* @author Gary O'Neall
*
*/
public class SpdxElementFactory {
/**
* Add to a cache of created elements
* @param modelContainer
* @param node
* @param element
*/
static synchronized void addToCreatedElements(IModelContainer modelContainer,
Node node, SpdxElement element) {
Map containerNodes = createdElements.get(modelContainer);
if (containerNodes == null) {
containerNodes = Maps.newHashMap();
createdElements.put(modelContainer, containerNodes);
}
containerNodes.put(node, element);
}
/**
* Keep track of all nodes created both for performance and to prevent
* an infinite recursion from continually creating the same objects.
*/
private static Map> createdElements = Maps.newHashMap();
public static synchronized SpdxElement createElementFromModel(IModelContainer modelContainer,
Node node) throws InvalidSPDXAnalysisException {
Map containerNodes = createdElements.get(modelContainer);
if (containerNodes == null) {
containerNodes = Maps.newHashMap();
createdElements.put(modelContainer, containerNodes);
}
SpdxElement retval = containerNodes.get(node);
if (retval != null) {
return retval;
}
if (node.isBlank() ||
(node.isURI() && node.getURI().startsWith(modelContainer.getDocumentNamespace()))) {
// SPDX element local to this document
retval = getElementByType(modelContainer, node);
if (retval == null) {
retval = guessElementByProperties(modelContainer, node);
if (retval == null) {
throw(new InvalidSPDXAnalysisException("Unable to determine the SPDX element type from the model"));
}
}
containerNodes.put(node, retval);
return retval;
} else if (node.isURI()) {
if (SpdxNoneElement.NONE_ELEMENT_URI.equals(node.getURI())) {
return new SpdxNoneElement();
} else if (SpdxNoAssertionElement.NOASSERTION_ELEMENT_URI.equals(node.getURI())) {
return new SpdxNoAssertionElement();
} else {
// assume this is an external document reference
String[] uriParts = node.getURI().split("#");
if (uriParts.length != 2) {
throw(new InvalidSPDXAnalysisException("Invalid element URI: "+node.getURI()));
}
String docId = modelContainer.documentNamespaceToId(uriParts[0]);
if (docId == null) {
throw(new InvalidSPDXAnalysisException("No external document reference was found for URI "+node.getURI()));
}
String externalId = docId + ":" + uriParts[1];
return new ExternalSpdxElement(externalId);
}
} else {
throw(new InvalidSPDXAnalysisException("Can not create an SPDX Element from a literal node"));
}
}
/**
* Guesses the element type based on the properties associated with that element.
* @param modelContainer
* @param node
* @return
* @throws InvalidSPDXAnalysisException
*/
private static SpdxElement guessElementByProperties(
IModelContainer modelContainer, Node node) throws InvalidSPDXAnalysisException {
// Look for required SPDX Item properties
if (propertyExists(modelContainer, node, SpdxRdfConstants.SPDX_NAMESPACE,
SpdxRdfConstants.PROP_LICENSE_CONCLUDED) &&
propertyExists(modelContainer, node, SpdxRdfConstants.SPDX_NAMESPACE,
SpdxRdfConstants.PROP_COPYRIGHT_TEXT)) {
return guessSpdxItemByProperties(modelContainer, node);
} else {
return new SpdxElement(modelContainer, node);
}
}
/**
* Guess an SPDX Item based on the properties
* @param modelContainer
* @param node
* @return
* @throws InvalidSPDXAnalysisException
*/
private static SpdxElement guessSpdxItemByProperties(
IModelContainer modelContainer, Node node) throws InvalidSPDXAnalysisException {
// Look for required file properties
if (propertyExists(modelContainer, node, SpdxRdfConstants.SPDX_NAMESPACE,
SpdxRdfConstants.PROP_FILE_CHECKSUM) &&
propertyExists(modelContainer, node, SpdxRdfConstants.SPDX_NAMESPACE,
SpdxRdfConstants.PROP_FILE_TYPE)) {
return new SpdxFile(modelContainer, node);
} else if (propertyExists(modelContainer, node, SpdxRdfConstants.SPDX_NAMESPACE,
SpdxRdfConstants.PROP_FILE_CHECKSUM) &&
propertyExists(modelContainer, node, SpdxRdfConstants.SPDX_NAMESPACE,
SpdxRdfConstants.PROP_PACKAGE_DOWNLOAD_URL) &&
propertyExists(modelContainer, node, SpdxRdfConstants.SPDX_NAMESPACE,
SpdxRdfConstants.PROP_PACKAGE_LICENSE_INFO_FROM_FILES) &&
propertyExists(modelContainer, node, SpdxRdfConstants.SPDX_NAMESPACE,
SpdxRdfConstants.PROP_PACKAGE_VERIFICATION_CODE)) {
return new SpdxPackage(modelContainer, node);
} else if (propertyExists(modelContainer, node, SpdxRdfConstants.SPDX_NAMESPACE,
SpdxRdfConstants.PROP_SNIPPET_FROM_FILE)) {
return new SpdxSnippet(modelContainer, node);
} else {
return new SpdxItem(modelContainer, node);
}
}
/**
* Returns true if a value for a property exists for the subject node
* @param modelContainer
* @param node
* @param namespace
* @param propertyName
* @return
*/
private static boolean propertyExists(IModelContainer modelContainer,
Node node, String namespace, String propertyName) {
Node p = modelContainer.getModel().getProperty(namespace, propertyName).asNode();
Triple m = Triple.createMatch(node, p, null);
ExtendedIterator tripleIter = modelContainer.getModel().getGraph().find(m);
return tripleIter.hasNext();
}
/**
* @param modelContainer
* @param node
* @return
* @throws InvalidSPDXAnalysisException
*/
private static SpdxElement getElementByType(IModelContainer modelContainer,
Node node) throws InvalidSPDXAnalysisException {
Node rdfTypePredicate = modelContainer.getModel().getProperty(SpdxRdfConstants.RDF_NAMESPACE,
SpdxRdfConstants.RDF_PROP_TYPE).asNode();
Triple m = Triple.createMatch(node, rdfTypePredicate, null);
ExtendedIterator tripleIter = modelContainer.getModel().getGraph().find(m); // find the type(s)
if (tripleIter.hasNext()) {
Triple triple = tripleIter.next();
if (tripleIter.hasNext()) {
throw(new InvalidSPDXAnalysisException("More than one type associated with an SPDX Element"));
}
Node typeNode = triple.getObject();
if (!typeNode.isURI()) {
throw(new InvalidSPDXAnalysisException("Invalid type for an SPDX Element - not a URI"));
}
// need to parse the URI
String typeUri = typeNode.getURI();
if (!typeUri.startsWith(SpdxRdfConstants.SPDX_NAMESPACE)) {
throw(new InvalidSPDXAnalysisException("Invalid type for an SPDX Element - not an SPDX type"));
}
String type = typeUri.substring(SpdxRdfConstants.SPDX_NAMESPACE.length());
if (type.equals(SpdxRdfConstants.CLASS_SPDX_FILE)) {
return new SpdxFile(modelContainer, node);
} else if (type.equals(SpdxRdfConstants.CLASS_SPDX_PACKAGE)) {
return new SpdxPackage(modelContainer, node);
} else if (type.equals(SpdxRdfConstants.CLASS_SPDX_SNIPPET)) {
return new SpdxSnippet(modelContainer, node);
} else if (type.equals(SpdxRdfConstants.CLASS_SPDX_ITEM)) {
return new SpdxItem(modelContainer, node);
} else if (type.equals(SpdxRdfConstants.CLASS_SPDX_ELEMENT)) {
return new SpdxElement(modelContainer, node);
} else if (type.equals(SpdxRdfConstants.CLASS_SPDX_DOCUMENT)) {
return new SpdxDocumentContainer(modelContainer.getModel()).getSpdxDocument();
} else {
throw(new InvalidSPDXAnalysisException("Invalid type for element '"+type+"'"));
}
} else {
return null;
}
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy