20990415403

Committed 14 Jan 2026 10:13AM UTC coverage: 14.11% (-1.1%) from 15.173%

Build # 20990415403

Build Type

push

github

Committed by

tkuhn

Commit Message

fix(AjaxZonedDateTimePicker): Avoid NullPointerException when optional

Run Details

540 of 5062 branches covered (10.67%)

Branch coverage included in aggregate %.

1484 of 9282 relevant lines covered (15.99%)

2.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

50.0

src/main/java/com/knowledgepixels/nanodash/MaintainedResource.java

package com.knowledgepixels.nanodash;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.rdf4j.model.IRI;
import org.nanopub.Nanopub;
import org.nanopub.extra.services.ApiResponse;
import org.nanopub.extra.services.ApiResponseEntry;
import org.nanopub.extra.services.QueryRef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MaintainedResource extends ProfiledResource {

    private static final Logger logger = LoggerFactory.getLogger(MaintainedResource.class);

    private static List<MaintainedResource> resourceList;
    private static Map<String, MaintainedResource> resourcesById;
    private static Map<String, MaintainedResource> resourcesByNamespace;
    private static Map<Space, List<MaintainedResource>> resourcesBySpace;
    private static boolean loaded = false;
    private static Long runRootUpdateAfter = null;

    public static synchronized void refresh(ApiResponse resp) {
        resourceList = new ArrayList<>();
        Map<String, MaintainedResource> previousResourcesById = resourcesById;
        resourcesById = new HashMap<>();
        resourcesBySpace = new HashMap<>();
        resourcesByNamespace = new HashMap<>();
        for (ApiResponseEntry entry : resp.getData()) {
            Space space = Space.get(entry.get("space"));
            if (space == null) continue;
            MaintainedResource resource = null;
            if (previousResourcesById != null) {
                resource = previousResourcesById.get(entry.get("resource"));
            }
            if (resource == null) {
                resource = new MaintainedResource(entry, space);
            }
            if (resourcesById.containsKey(resource.getId())) continue;
            resourceList.add(resource);
            resourcesById.put(resource.getId(), resource);
            resourcesBySpace.computeIfAbsent(space, k -> new ArrayList<>()).add(resource);
            if (resource.getNamespace() != null) {
                // TODO Handle conflicts when two resources claim the same namespace:
                resourcesByNamespace.put(resource.getNamespace(), resource);
            }
        }
        loaded = true;
    }

    /**
     * Check if the resources have been loaded.
     *
     * @return true if loaded, false otherwise.
     */
    public static boolean isLoaded() {
        return loaded;
    }

    /**
     * Ensure that the resources are loaded, fetching them from the API if necessary.
     */
    public static void ensureLoaded() {
        if (resourceList == null) {
            try {
                if (runRootUpdateAfter != null) {
                    while (System.currentTimeMillis() < runRootUpdateAfter) {
                        Thread.sleep(100);
                    }
                    runRootUpdateAfter = null;
                }
            } catch (InterruptedException ex) {
                logger.error("Interrupted", ex);
            }
            refresh(ApiCache.retrieveResponseSync(new QueryRef("get-maintained-resources"), true));
        }
    }

    public static void forceRootRefresh(long waitMillis) {
        resourceList = null;
        runRootUpdateAfter = System.currentTimeMillis() + waitMillis;
    }

    /**
     * Get the list of all maintained resources.
     *
     * @return List of resources.
     */
    public static List<MaintainedResource> getResourceList() {
        ensureLoaded();
        return resourceList;
    }

    public static List<MaintainedResource> getResourcesBySpace(Space space) {
        return resourcesBySpace.computeIfAbsent(space, k -> new ArrayList<>());
    }

    /**
     * Get a maintained resource by its id.
     *
     * @param id The id of the resource.
     * @return The corresponding MaintainedResource object, or null if not found.
     */
    public static MaintainedResource get(String id) {
        ensureLoaded();
        return resourcesById.get(id);
    }

    public static MaintainedResource getByNamespace(String namespace) {
        return resourcesByNamespace.get(namespace);
    }

    public static String getNamespace(Object stringOrIri) {
        return stringOrIri.toString().replaceFirst("([#/])[^#/]+$", "$1");
    }

    public static void refresh() {
        refresh(ApiCache.retrieveResponseSync(new QueryRef("get-maintained-resources"), true));
        for (MaintainedResource resource : resourceList) {
            resource.setDataNeedsUpdate();
        }
    }

    private String label, nanopubId, namespace;
    private Nanopub nanopub;

    private MaintainedResource(ApiResponseEntry resp, Space space) {
        super(resp.get("resource"));
        initialize(resp, space);
    }

    private void initialize(ApiResponseEntry resp, Space space) {
        initSpace(space);
        this.label = resp.get("label");
        this.nanopubId = resp.get("np");
        this.namespace = resp.get("namespace");
        if (namespace != null && namespace.isBlank()) namespace = null;
        this.nanopub = Utils.getAsNanopub(nanopubId);
    }

    @Override
    public String getNanopubId() {
        return nanopubId;
    }

    @Override
    public Nanopub getNanopub() {
        return nanopub;
    }

    public String getLabel() {
        return label;
    }

    @Override
    public String getNamespace() {
        return namespace;
    }

    public boolean appliesTo(String elementId, Set<IRI> classes) {
        triggerDataUpdate();
        for (ViewDisplay v : getViewDisplays()) {
            if (v.appliesTo(elementId, classes)) return true;
        }
        return false;
    }

}

1	package com.knowledgepixels.nanodash;
2
3	import java.util.ArrayList;
4	import java.util.HashMap;
5	import java.util.List;
6	import java.util.Map;
7	import java.util.Set;
8
9	import org.eclipse.rdf4j.model.IRI;
10	import org.nanopub.Nanopub;
11	import org.nanopub.extra.services.ApiResponse;
12	import org.nanopub.extra.services.ApiResponseEntry;
13	import org.nanopub.extra.services.QueryRef;
14	import org.slf4j.Logger;
15	import org.slf4j.LoggerFactory;
16
17	public class MaintainedResource extends ProfiledResource {
18
19	private static final Logger logger = LoggerFactory.getLogger(MaintainedResource.class);	12✔
20
21	private static List<MaintainedResource> resourceList;
22	private static Map<String, MaintainedResource> resourcesById;
23	private static Map<String, MaintainedResource> resourcesByNamespace;
24	private static Map<Space, List<MaintainedResource>> resourcesBySpace;
25	private static boolean loaded = false;	8✔
26	private static Long runRootUpdateAfter = null;	12✔
27
28	public static synchronized void refresh(ApiResponse resp) {
29	resourceList = new ArrayList<>();	16✔
30	Map<String, MaintainedResource> previousResourcesById = resourcesById;	8✔
31	resourcesById = new HashMap<>();	16✔
32	resourcesBySpace = new HashMap<>();	16✔
33	resourcesByNamespace = new HashMap<>();	16✔
34	for (ApiResponseEntry entry : resp.getData()) {	44!
35	Space space = Space.get(entry.get("space"));	20✔
36	if (space == null) continue;	8!
37	MaintainedResource resource = null;	8✔
38	if (previousResourcesById != null) {	8!
39	resource = previousResourcesById.get(entry.get("resource"));	×
40	}
41	if (resource == null) {	8!
42	resource = new MaintainedResource(entry, space);	24✔
43	}
44	if (resourcesById.containsKey(resource.getId())) continue;	24✔
45	resourceList.add(resource);	16✔
46	resourcesById.put(resource.getId(), resource);	24✔
47	resourcesBySpace.computeIfAbsent(space, k -> new ArrayList<>()).add(resource);	48✔
48	if (resource.getNamespace() != null) {	12✔
49	// TODO Handle conflicts when two resources claim the same namespace:
50	resourcesByNamespace.put(resource.getNamespace(), resource);	24✔
51	}
52	}	4✔
53	loaded = true;	×
54	}	×
55
56	/**
57	* Check if the resources have been loaded.
58	*
59	* @return true if loaded, false otherwise.
60	*/
61	public static boolean isLoaded() {
62	return loaded;	×
63	}
64
65	/**
66	* Ensure that the resources are loaded, fetching them from the API if necessary.
67	*/
68	public static void ensureLoaded() {
69	if (resourceList == null) {	8!
70	try {
71	if (runRootUpdateAfter != null) {	×
72	while (System.currentTimeMillis() < runRootUpdateAfter) {	×
73	Thread.sleep(100);	×
74	}
75	runRootUpdateAfter = null;	×
76	}
77	} catch (InterruptedException ex) {	×
78	logger.error("Interrupted", ex);	×
79	}	×
80	refresh(ApiCache.retrieveResponseSync(new QueryRef("get-maintained-resources"), true));	×
81	}
82	}	4✔
83
84	public static void forceRootRefresh(long waitMillis) {
85	resourceList = null;	×
86	runRootUpdateAfter = System.currentTimeMillis() + waitMillis;	×
87	}	×
88
89	/**
90	* Get the list of all maintained resources.
91	*
92	* @return List of resources.
93	*/
94	public static List<MaintainedResource> getResourceList() {
95	ensureLoaded();	×
96	return resourceList;	×
97	}
98
99	public static List<MaintainedResource> getResourcesBySpace(Space space) {
100	return resourcesBySpace.computeIfAbsent(space, k -> new ArrayList<>());	×
101	}
102
103	/**
104	* Get a maintained resource by its id.
105	*
106	* @param id The id of the resource.
107	* @return The corresponding MaintainedResource object, or null if not found.
108	*/
109	public static MaintainedResource get(String id) {
110	ensureLoaded();	4✔
111	return resourcesById.get(id);	20✔
112	}
113
114	public static MaintainedResource getByNamespace(String namespace) {
115	return resourcesByNamespace.get(namespace);	×
116	}
117
118	public static String getNamespace(Object stringOrIri) {
119	return stringOrIri.toString().replaceFirst("([#/])[^#/]+$", "$1");	×
120	}
121
122	public static void refresh() {
123	refresh(ApiCache.retrieveResponseSync(new QueryRef("get-maintained-resources"), true));	×
124	for (MaintainedResource resource : resourceList) {	×
125	resource.setDataNeedsUpdate();	×
126	}	×
127	}	×
128
129	private String label, nanopubId, namespace;
130	private Nanopub nanopub;
131
132	private MaintainedResource(ApiResponseEntry resp, Space space) {
133	super(resp.get("resource"));	20✔
134	initialize(resp, space);	16✔
135	}	4✔
136
137	private void initialize(ApiResponseEntry resp, Space space) {
138	initSpace(space);	12✔
139	this.label = resp.get("label");	20✔
140	this.nanopubId = resp.get("np");	20✔
141	this.namespace = resp.get("namespace");	20✔
142	if (namespace != null && namespace.isBlank()) namespace = null;	40!
143	this.nanopub = Utils.getAsNanopub(nanopubId);	20✔
144	}	4✔
145
146	@Override
147	public String getNanopubId() {
148	return nanopubId;	×
149	}
150
151	@Override
152	public Nanopub getNanopub() {
153	return nanopub;	×
154	}
155
156	public String getLabel() {
157	return label;	×
158	}
159
160	@Override
161	public String getNamespace() {
162	return namespace;	12✔
163	}
164
165	public boolean appliesTo(String elementId, Set<IRI> classes) {
166	triggerDataUpdate();	×
167	for (ViewDisplay v : getViewDisplays()) {	×
168	if (v.appliesTo(elementId, classes)) return true;	×
169	}	×
170	return false;	×
171	}
172
173	}

knowledgepixels / nanodash / 20990415403

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous