• Home
• com.github.jsonld-java
• jsonld-java
• 0.1
• source code
• JSONLDProcessor.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.github.jsonldjava.core.JSONLDProcessor Maven / Gradle / Ivy

package com.github.jsonldjava.core;

import java.net.URI;
import java.net.URISyntaxException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.github.jsonldjava.utils.JSONUtils;
import com.github.jsonldjava.utils.Obj;
import com.github.jsonldjava.utils.URL;

import static com.github.jsonldjava.core.JSONLDConsts.*;
import static com.github.jsonldjava.core.JSONLDUtils.*;
import static com.github.jsonldjava.core.RDFDatasetUtils.*;

public class JSONLDProcessor {

    private static final Logger LOG = LoggerFactory.getLogger(JSONLDProcessor.class);
	
    Options opts;

    public JSONLDProcessor() {
        opts = new Options("");
    }

    public JSONLDProcessor(Options opts) {
        if (opts == null) {
            opts = new Options("");
        } else {
            this.opts = opts;
        }
    }

    /**
     * Processes a local context and returns a new active context.
     *
     * @param activeCtx the current active context.
     * @param localCtx the local context to process.
     * @param options the context processing options.
     *
     * @return the new active context.
     */
    ActiveContext processContext(ActiveContext activeCtx, Object localCtx) throws JSONLDProcessingError {
    	
    	// TODO: get context from cache if available
    	
    	// initialize the resulting context
        ActiveContext rval = activeCtx.clone();

        // normalize local context to an array of @context objects
        if (localCtx instanceof Map && ((Map) localCtx).containsKey("@context") && ((Map) localCtx).get("@context") instanceof List) {
            localCtx = ((Map) localCtx).get("@context");
        }

        List> ctxs;
        if (localCtx instanceof List) {
            ctxs = (List>) localCtx;
        } else {
            ctxs = new ArrayList>();
            ctxs.add((Map) localCtx);
        }

        // process each context in order
        for (Object ctx : ctxs) {
        	if (ctx == null) {
        		// reset to initial context
        		rval = new ActiveContext(opts);
        		continue;
            }
        	
        	// context must be an object by now, all URLs resolved before this call
        	if (ctx instanceof Map) {
        		// dereference @context key if present
                if (((Map) ctx).containsKey("@context")) {
                    ctx = (Map) ((Map) ctx).get("@context");
                }
            } else {
            	// context must be an object by now, all URLs resolved before this call
                throw new JSONLDProcessingError("@context must be an object")
                	.setType(JSONLDProcessingError.Error.SYNTAX_ERROR)
                	.setDetail("context", ctx);
            }
        	
        	// define context mappings for keys in local context
            Map defined = new LinkedHashMap();
            
            // helper for access to ctx as a map
            Map ctxm = (Map)ctx;
            // handle @base
            if (ctxm.containsKey("@base")) {
            	Object base = ctxm.get("@base");
            	
            	// reset base
            	if (base == null) {
            		base = opts.base;
            	}
            	else if (!isString(base)) {
            		throw new JSONLDProcessingError(
            				"Invalid JSON-LD syntax; the value of \"@base\" in a " +
            				"@context must be a string or null.")
            			.setType(JSONLDProcessingError.Error.SYNTAX_ERROR)
            			.setDetail("context", ctx);
            	} 
            	else if (!"".equals(base) && !isAbsoluteIri((String)base)) {
            		throw new JSONLDProcessingError(
            				"Invalid JSON-LD syntax; the value of \"@base\" in a " +
            				"@context must be an absolute IRI or the empty string.")
            			.setType(JSONLDProcessingError.Error.SYNTAX_ERROR)
            			.setDetail("context", ctx);
            	}
            	
            	base = URL.parse((String)base);
            	rval.put("@base", base);
            	defined.put("@base", true);
            }
            
            // handle @vocab
            if (ctxm.containsKey("@vocab")) {
            	Object value = ctxm.get("@vocab");
            	if (value == null) {
            		rval.remove("@vocab");
            	}
            	else if (!isString(value)) {
            		throw new JSONLDProcessingError(
            				"Invalid JSON-LD syntax; the value of \"@vocab\" in a " +
            				"@context must be a string or null.")
            			.setType(JSONLDProcessingError.Error.SYNTAX_ERROR)
            			.setDetail("context", ctx);
            	}
        		else if (!isAbsoluteIri((String)value)) {
            		throw new JSONLDProcessingError(
            				"Invalid JSON-LD syntax; the value of \"@vocab\" in a " +
            				"@context must be an absolute IRI.")
            			.setType(JSONLDProcessingError.Error.SYNTAX_ERROR)
            			.setDetail("context", ctx);
            	}
        		else {
        			rval.put("@vocab", value);
        		}
            	defined.put("@vocab", true);
            }
            
            // handle @language
            if (ctxm.containsKey("@language")) {
            	Object value = ctxm.get("@language");
            	if (value == null) {
            		rval.remove("@language");
            	}
            	else if (!isString(value)) {
            		throw new JSONLDProcessingError(
            				"Invalid JSON-LD syntax; the value of \"@language\" in a " +
            				"@context must be a string or null.")
            			.setType(JSONLDProcessingError.Error.SYNTAX_ERROR)
            			.setDetail("context", ctx);
            	}
            	else {
            		rval.put("@language", ((String)value).toLowerCase());
            	}
            	defined.put("@language", true);
            }
            
            // process all other keys
            for (String key : ctxm.keySet()) {
            	createTermDefinition(rval, ctxm, key, defined);
            }
        }
        
        // TODO: cache results

        return rval;
    }
   
    /**
     * Recursively expands an element using the given context. Any context in
     * the element will be removed. All context URLs must have been retrieved
     * before calling this method.
     *
     * @param activeCtx the context to use.
     * @param activeProperty the property for the element, null for none.
     * @param element the element to expand.
     * @param options the expansion options.
     * @param insideList true if the element is a list, false if not.
     *
     * @return the expanded value.
     * 
     * TODO:
     *  - does this function always return a map, or can it also return a list, the expandedValue variable below seems to assume a map, but in javascript, `in` will just return false if the result is a list
     */
    public Object expand(ActiveContext activeCtx, String activeProperty, Object element, Boolean insideList) throws JSONLDProcessingError {
    	// nothing to expand
    	if (element == null) {
    		return null;
    	}

    	// recursively expand array
    	if (element instanceof List) {
    		List