17678939499

Committed 12 Sep 2025 03:28PM UTC coverage: 13.777% (-0.01%) from 13.79%

Build # 17678939499

Build Type

push

github

Committed by

tkuhn

Commit Message

fix: Refreshing of Spaces

Run Details

433 of 3982 branches covered (10.87%)

Branch coverage included in aggregate %.

1112 of 7232 relevant lines covered (15.38%)

0.68 hits per line

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

0.0

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

package com.knowledgepixels.nanodash;

import static com.knowledgepixels.nanodash.Utils.vf;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Literal;
import org.eclipse.rdf4j.model.Statement;
import org.eclipse.rdf4j.model.vocabulary.DCTERMS;
import org.nanopub.Nanopub;
import org.nanopub.extra.services.ApiResponse;
import org.nanopub.extra.services.ApiResponseEntry;
import org.nanopub.vocabulary.NTEMPLATE;

import com.github.jsonldjava.shaded.com.google.common.collect.Ordering;
import com.knowledgepixels.nanodash.template.Template;
import com.knowledgepixels.nanodash.template.TemplateData;

/**
 * Class representing a "Space", which can be any kind of collaborative unit, like a project, group, or event.
 */
public class Space implements Serializable {

    /**
     * The predicate for the owner of the space.
     */
    public static final IRI HAS_OWNER = vf.createIRI("https://w3id.org/kpxl/gen/terms/hasOwner");

    /**
     * The predicate for pinned templates in the space.
     */
    public static final IRI HAS_PINNED_TEMPLATE = vf.createIRI("https://w3id.org/kpxl/gen/terms/hasPinnedTemplate");

    /**
     * The predicate for pinned queries in the space.
     */
    public static final IRI HAS_PINNED_QUERY = vf.createIRI("https://w3id.org/kpxl/gen/terms/hasPinnedQuery");

    private static List<Space> spaceList;
    private static Map<String,Space> spacesByCoreInfo = new HashMap<>();
    private static Map<String,Space> spacesById;
    private static Map<Space,Set<Space>> subspaceMap;
    private static Map<Space,Set<Space>> superspaceMap;

    public static synchronized void refresh(ApiResponse resp) {
        spaceList = new ArrayList<>();
        Map<String,Space> prevSpacesByCoreInfoPrev = spacesByCoreInfo;
        spacesByCoreInfo = new HashMap<>();
        spacesById = new HashMap<>();
        subspaceMap = new HashMap<>();
        superspaceMap = new HashMap<>();
        for (ApiResponseEntry entry : resp.getData()) {
            Space space = new Space(entry);
            Space prevSpace = prevSpacesByCoreInfoPrev.get(space.getCoreInfoString());
            if (prevSpace != null) space = prevSpace;
            spaceList.add(space);
            spacesByCoreInfo.put(space.getCoreInfoString(), space);
            spacesById.put(space.getId(), space);
        }
        for (Space space : spaceList) {
            Space superSpace = space.getIdSuperspace();
            if (superSpace == null) continue;
            subspaceMap.computeIfAbsent(superSpace, k -> new HashSet<>()).add(space);
            superspaceMap.computeIfAbsent(space, k -> new HashSet<>()).add(superSpace);
        }
    }

    public static void ensureLoaded() {
        if (spaceList == null) {
            refresh(QueryApiAccess.forcedGet("get-spaces"));
        }
    }

    public static List<Space> getSpaceList() {
        ensureLoaded();
        return spaceList;
    }

    public static Space get(String id) {
        ensureLoaded();
        return spacesById.get(id);
    }

    public static void refresh() {
        ensureLoaded();
        for (Space space : spaceList) {
            space.dataNeedsUpdate = true;
        }
    }

    private String id, label, rootNanopubId, type;
    private Nanopub rootNanopub = null;
    private SpaceData data = new SpaceData();

    private static class SpaceData implements Serializable {
        String description = null;
        IRI defaultProvenance = null;
        List<IRI> owners = new ArrayList<>();
        List<IRI> members = new ArrayList<>();
        Map<String,IRI> ownerPubkeyMap = new HashMap<>();
        List<Serializable> pinnedResources = new ArrayList<>();
        Set<String> pinGroupTags = new HashSet<>();
        Map<String, List<Serializable>> pinnedResourceMap = new HashMap<>();

        void addOwner(IRI owner) {
            // TODO This isn't efficient for long owner lists:
            if (owners.contains(owner)) return;
            owners.add(owner);
            UserData ud = User.getUserData();
            for (String pubkeyhash : ud.getPubkeyhashes(owner, true)) {
                ownerPubkeyMap.put(pubkeyhash, owner);
            }
        }
    }

    private boolean dataInitialized = false;
    private boolean dataNeedsUpdate = true;

    private Space(ApiResponseEntry resp) {
        this.id = resp.get("space");
        this.label = resp.get("label");
        this.type = resp.get("type");
        this.rootNanopubId = resp.get("np");
        this.rootNanopub = Utils.getAsNanopub(rootNanopubId);
        setCoreData(data);
    }

    public String getId() {
        return id;
    }

    public String getRootNanopubId() {
        return rootNanopubId;
    }

    public String getCoreInfoString() {
        return id + " " + rootNanopubId;
    }

    public Nanopub getRootNanopub() {
        return rootNanopub;
    }

    public String getLabel() {
        return label;
    }

    public String getType() {
        return type;
    }

    public String getTypeLabel() {
        return type.replaceFirst("^.*/", "");
    }

    public String getDescription() {
        return data.description;
    }

    public boolean isDataInitialized() {
        triggerDataUpdate();
        return dataInitialized;
    }

    public List<IRI> getOwners() {
        triggerDataUpdate();
        return data.owners;
    }

    public List<IRI> getMembers() {
        triggerDataUpdate();
        return data.members;
    }

    public List<Serializable> getPinnedResources() {
        triggerDataUpdate();
        return data.pinnedResources;
    }

    public Set<String> getPinGroupTags() {
        triggerDataUpdate();
        return data.pinGroupTags;
    }

    public Map<String, List<Serializable>> getPinnedResourceMap() {
        triggerDataUpdate();
        return data.pinnedResourceMap;
    }

    public IRI getDefaultProvenance() {
        return data.defaultProvenance;
    }

    public String getSuperId() {
        return null;
    }

    public Space getIdSuperspace() {
        if (!id.matches("https?://[^/]+/.*/[^/]*/?")) return null;
        String superId = id.replaceFirst("(https?://[^/]+/.*)/[^/]*/?", "$1");
        if (spacesById.containsKey(superId)) {
            return spacesById.get(superId);
        }
        return null;
    }

    public List<Space> getSuperspaces() {
        if (superspaceMap.containsKey(this)) {
            List<Space> superspaces = new ArrayList<>(superspaceMap.get(this));
            Collections.sort(superspaces, Ordering.usingToString());
            return superspaces;
        }
        return new ArrayList<>();
    }

    public List<Space> getSubspaces() {
        if (subspaceMap.containsKey(this)) {
            List<Space> subspaces = new ArrayList<>(subspaceMap.get(this));
            Collections.sort(subspaces, Ordering.usingToString());
            return subspaces;
        }
        return new ArrayList<>();
    }

    private synchronized void triggerDataUpdate() {
        if (dataNeedsUpdate) {
            new Thread(() -> {
                SpaceData newData = new SpaceData();
                setCoreData(newData);

                for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-owners", "unit", id).getData()) {
                    String pubkeyhash = r.get("pubkeyhash");
                    if (newData.ownerPubkeyMap.containsKey(pubkeyhash)) {
                        newData.addOwner(Utils.vf.createIRI(r.get("owner")));
                    }
                }
                newData.members = new ArrayList<>();
                for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-members", "unit", id).getData()) {
                    IRI memberId = Utils.vf.createIRI(r.get("member"));
                    // TODO These checks are inefficient for long member lists:
                    if (newData.owners.contains(memberId)) continue;
                    if (newData.members.contains(memberId)) continue;
                    newData.members.add(memberId);
                }
                newData.owners.sort(User.getUserData().userComparator);
                newData.members.sort(User.getUserData().userComparator);

                for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-pinned-templates", "space", id).getData()) {
                    if (!newData.ownerPubkeyMap.containsKey(r.get("pubkey"))) continue;
                    Template t = TemplateData.get().getTemplate(r.get("template"));
                    if (t == null) continue;
                    newData.pinnedResources.add(t);
                    String tag = r.get("tag");
                    if (tag != null && !tag.isEmpty()) {
                        newData.pinGroupTags.add(r.get("tag"));
                        newData.pinnedResourceMap.computeIfAbsent(tag, k -> new ArrayList<>()).add(TemplateData.get().getTemplate(r.get("template")));
                    }
                }
                for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-pinned-queries", "space", id).getData()) {
                    if (!newData.ownerPubkeyMap.containsKey(r.get("pubkey"))) continue;
                    GrlcQuery query = GrlcQuery.get(r.get("query"));
                    if (query == null) continue;
                    newData.pinnedResources.add(query);
                    String tag = r.get("tag");
                    if (tag != null && !tag.isEmpty()) {
                        newData.pinGroupTags.add(r.get("tag"));
                        newData.pinnedResourceMap.computeIfAbsent(tag, k -> new ArrayList<>()).add(query);
                    }
                }
                data = newData;
                dataInitialized = true;
            }).start();
            dataNeedsUpdate = false;
        }
    }

    private void setCoreData(SpaceData data) {
        for (Statement st : rootNanopub.getAssertion()) {
            if (st.getSubject().stringValue().equals(getId())) {
                if (st.getPredicate().equals(DCTERMS.DESCRIPTION)) {
                    data.description = st.getObject().stringValue();
                } else if (st.getPredicate().equals(HAS_OWNER) && st.getObject() instanceof IRI obj) {
                    data.addOwner(obj);
                } else if (st.getPredicate().equals(HAS_PINNED_TEMPLATE) && st.getObject() instanceof IRI obj) {
                    data.pinnedResources.add(TemplateData.get().getTemplate(obj.stringValue()));
                } else if (st.getPredicate().equals(HAS_PINNED_QUERY) && st.getObject() instanceof IRI obj) {
                    data.pinnedResources.add(GrlcQuery.get(obj.stringValue()));
                } else if (st.getPredicate().equals(NTEMPLATE.HAS_DEFAULT_PROVENANCE) && st.getObject() instanceof IRI obj) {
                    data.defaultProvenance = obj;
                }
            } else if (st.getPredicate().equals(NTEMPLATE.HAS_TAG) && st.getObject() instanceof Literal l) {
                data.pinGroupTags.add(l.stringValue());
                List<Serializable> list = data.pinnedResourceMap.get(l.stringValue());
                if (list == null) {
                    list = new ArrayList<>();
                    data.pinnedResourceMap.put(l.stringValue(), list);
                }
                list.add(TemplateData.get().getTemplate(st.getSubject().stringValue()));
            }
        }
    }

    @Override
    public String toString() {
        return id;
    }

}

1	package com.knowledgepixels.nanodash;
2
3	import static com.knowledgepixels.nanodash.Utils.vf;
4
5	import java.io.Serializable;
6	import java.util.ArrayList;
7	import java.util.Collections;
8	import java.util.HashMap;
9	import java.util.HashSet;
10	import java.util.List;
11	import java.util.Map;
12	import java.util.Set;
13
14	import org.eclipse.rdf4j.model.IRI;
15	import org.eclipse.rdf4j.model.Literal;
16	import org.eclipse.rdf4j.model.Statement;
17	import org.eclipse.rdf4j.model.vocabulary.DCTERMS;
18	import org.nanopub.Nanopub;
19	import org.nanopub.extra.services.ApiResponse;
20	import org.nanopub.extra.services.ApiResponseEntry;
21	import org.nanopub.vocabulary.NTEMPLATE;
22
23	import com.github.jsonldjava.shaded.com.google.common.collect.Ordering;
24	import com.knowledgepixels.nanodash.template.Template;
25	import com.knowledgepixels.nanodash.template.TemplateData;
26
27	/**
28	* Class representing a "Space", which can be any kind of collaborative unit, like a project, group, or event.
29	*/
30	public class Space implements Serializable {
31
32	/**
33	* The predicate for the owner of the space.
34	*/
35	public static final IRI HAS_OWNER = vf.createIRI("https://w3id.org/kpxl/gen/terms/hasOwner");	×
36
37	/**
38	* The predicate for pinned templates in the space.
39	*/
40	public static final IRI HAS_PINNED_TEMPLATE = vf.createIRI("https://w3id.org/kpxl/gen/terms/hasPinnedTemplate");	×
41
42	/**
43	* The predicate for pinned queries in the space.
44	*/
45	public static final IRI HAS_PINNED_QUERY = vf.createIRI("https://w3id.org/kpxl/gen/terms/hasPinnedQuery");	×
46
47	private static List<Space> spaceList;
48	private static Map<String,Space> spacesByCoreInfo = new HashMap<>();	×
49	private static Map<String,Space> spacesById;
50	private static Map<Space,Set<Space>> subspaceMap;
51	private static Map<Space,Set<Space>> superspaceMap;
52
53	public static synchronized void refresh(ApiResponse resp) {
54	spaceList = new ArrayList<>();	×
55	Map<String,Space> prevSpacesByCoreInfoPrev = spacesByCoreInfo;	×
56	spacesByCoreInfo = new HashMap<>();	×
57	spacesById = new HashMap<>();	×
58	subspaceMap = new HashMap<>();	×
59	superspaceMap = new HashMap<>();	×
60	for (ApiResponseEntry entry : resp.getData()) {	×
61	Space space = new Space(entry);	×
62	Space prevSpace = prevSpacesByCoreInfoPrev.get(space.getCoreInfoString());	×
63	if (prevSpace != null) space = prevSpace;	×
64	spaceList.add(space);	×
65	spacesByCoreInfo.put(space.getCoreInfoString(), space);	×
66	spacesById.put(space.getId(), space);	×
67	}	×
68	for (Space space : spaceList) {	×
69	Space superSpace = space.getIdSuperspace();	×
70	if (superSpace == null) continue;	×
71	subspaceMap.computeIfAbsent(superSpace, k -> new HashSet<>()).add(space);	×
72	superspaceMap.computeIfAbsent(space, k -> new HashSet<>()).add(superSpace);	×
73	}	×
74	}	×
75
76	public static void ensureLoaded() {
77	if (spaceList == null) {	×
78	refresh(QueryApiAccess.forcedGet("get-spaces"));	×
79	}
80	}	×
81
82	public static List<Space> getSpaceList() {
83	ensureLoaded();	×
84	return spaceList;	×
85	}
86
87	public static Space get(String id) {
88	ensureLoaded();	×
89	return spacesById.get(id);	×
90	}
91
92	public static void refresh() {
93	ensureLoaded();	×
94	for (Space space : spaceList) {	×
95	space.dataNeedsUpdate = true;	×
96	}	×
97	}	×
98
99	private String id, label, rootNanopubId, type;
100	private Nanopub rootNanopub = null;	×
101	private SpaceData data = new SpaceData();	×
102
103	private static class SpaceData implements Serializable {	×
104	String description = null;	×
105	IRI defaultProvenance = null;	×
106	List<IRI> owners = new ArrayList<>();	×
107	List<IRI> members = new ArrayList<>();	×
108	Map<String,IRI> ownerPubkeyMap = new HashMap<>();	×
109	List<Serializable> pinnedResources = new ArrayList<>();	×
110	Set<String> pinGroupTags = new HashSet<>();	×
111	Map<String, List<Serializable>> pinnedResourceMap = new HashMap<>();	×
112
113	void addOwner(IRI owner) {
114	// TODO This isn't efficient for long owner lists:
115	if (owners.contains(owner)) return;	×
116	owners.add(owner);	×
117	UserData ud = User.getUserData();	×
118	for (String pubkeyhash : ud.getPubkeyhashes(owner, true)) {	×
119	ownerPubkeyMap.put(pubkeyhash, owner);	×
120	}	×
121	}	×
122	}
123
124	private boolean dataInitialized = false;	×
125	private boolean dataNeedsUpdate = true;	×
126
127	private Space(ApiResponseEntry resp) {	×
128	this.id = resp.get("space");	×
129	this.label = resp.get("label");	×
130	this.type = resp.get("type");	×
131	this.rootNanopubId = resp.get("np");	×
132	this.rootNanopub = Utils.getAsNanopub(rootNanopubId);	×
133	setCoreData(data);	×
134	}	×
135
136	public String getId() {
137	return id;	×
138	}
139
140	public String getRootNanopubId() {
141	return rootNanopubId;	×
142	}
143
144	public String getCoreInfoString() {
145	return id + " " + rootNanopubId;	×
146	}
147
148	public Nanopub getRootNanopub() {
149	return rootNanopub;	×
150	}
151
152	public String getLabel() {
153	return label;	×
154	}
155
156	public String getType() {
157	return type;	×
158	}
159
160	public String getTypeLabel() {
161	return type.replaceFirst("^.*/", "");	×
162	}
163
164	public String getDescription() {
165	return data.description;	×
166	}
167
168	public boolean isDataInitialized() {
169	triggerDataUpdate();	×
170	return dataInitialized;	×
171	}
172
173	public List<IRI> getOwners() {
174	triggerDataUpdate();	×
175	return data.owners;	×
176	}
177
178	public List<IRI> getMembers() {
179	triggerDataUpdate();	×
180	return data.members;	×
181	}
182
183	public List<Serializable> getPinnedResources() {
184	triggerDataUpdate();	×
185	return data.pinnedResources;	×
186	}
187
188	public Set<String> getPinGroupTags() {
189	triggerDataUpdate();	×
190	return data.pinGroupTags;	×
191	}
192
193	public Map<String, List<Serializable>> getPinnedResourceMap() {
194	triggerDataUpdate();	×
195	return data.pinnedResourceMap;	×
196	}
197
198	public IRI getDefaultProvenance() {
199	return data.defaultProvenance;	×
200	}
201
202	public String getSuperId() {
203	return null;	×
204	}
205
206	public Space getIdSuperspace() {
207	if (!id.matches("https?://[^/]+/./[^/]/?")) return null;	×
208	String superId = id.replaceFirst("(https?://[^/]+/.)/[^/]/?", "$1");	×
209	if (spacesById.containsKey(superId)) {	×
210	return spacesById.get(superId);	×
211	}
212	return null;	×
213	}
214
215	public List<Space> getSuperspaces() {
216	if (superspaceMap.containsKey(this)) {	×
217	List<Space> superspaces = new ArrayList<>(superspaceMap.get(this));	×
218	Collections.sort(superspaces, Ordering.usingToString());	×
219	return superspaces;	×
220	}
221	return new ArrayList<>();	×
222	}
223
224	public List<Space> getSubspaces() {
225	if (subspaceMap.containsKey(this)) {	×
226	List<Space> subspaces = new ArrayList<>(subspaceMap.get(this));	×
227	Collections.sort(subspaces, Ordering.usingToString());	×
228	return subspaces;	×
229	}
230	return new ArrayList<>();	×
231	}
232
233	private synchronized void triggerDataUpdate() {
234	if (dataNeedsUpdate) {	×
235	new Thread(() -> {	×
236	SpaceData newData = new SpaceData();	×
237	setCoreData(newData);	×
238
239	for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-owners", "unit", id).getData()) {	×
240	String pubkeyhash = r.get("pubkeyhash");	×
241	if (newData.ownerPubkeyMap.containsKey(pubkeyhash)) {	×
242	newData.addOwner(Utils.vf.createIRI(r.get("owner")));	×
243	}
244	}	×
245	newData.members = new ArrayList<>();	×
246	for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-members", "unit", id).getData()) {	×
247	IRI memberId = Utils.vf.createIRI(r.get("member"));	×
248	// TODO These checks are inefficient for long member lists:
249	if (newData.owners.contains(memberId)) continue;	×
250	if (newData.members.contains(memberId)) continue;	×
251	newData.members.add(memberId);	×
252	}	×
253	newData.owners.sort(User.getUserData().userComparator);	×
254	newData.members.sort(User.getUserData().userComparator);	×
255
256	for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-pinned-templates", "space", id).getData()) {	×
257	if (!newData.ownerPubkeyMap.containsKey(r.get("pubkey"))) continue;	×
258	Template t = TemplateData.get().getTemplate(r.get("template"));	×
259	if (t == null) continue;	×
260	newData.pinnedResources.add(t);	×
261	String tag = r.get("tag");	×
262	if (tag != null && !tag.isEmpty()) {	×
263	newData.pinGroupTags.add(r.get("tag"));	×
264	newData.pinnedResourceMap.computeIfAbsent(tag, k -> new ArrayList<>()).add(TemplateData.get().getTemplate(r.get("template")));	×
265	}
266	}	×
267	for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-pinned-queries", "space", id).getData()) {	×
268	if (!newData.ownerPubkeyMap.containsKey(r.get("pubkey"))) continue;	×
269	GrlcQuery query = GrlcQuery.get(r.get("query"));	×
270	if (query == null) continue;	×
271	newData.pinnedResources.add(query);	×
272	String tag = r.get("tag");	×
273	if (tag != null && !tag.isEmpty()) {	×
274	newData.pinGroupTags.add(r.get("tag"));	×
275	newData.pinnedResourceMap.computeIfAbsent(tag, k -> new ArrayList<>()).add(query);	×
276	}
277	}	×
278	data = newData;	×
279	dataInitialized = true;	×
280	}).start();	×
281	dataNeedsUpdate = false;	×
282	}
283	}	×
284
285	private void setCoreData(SpaceData data) {
286	for (Statement st : rootNanopub.getAssertion()) {	×
287	if (st.getSubject().stringValue().equals(getId())) {	×
288	if (st.getPredicate().equals(DCTERMS.DESCRIPTION)) {	×
289	data.description = st.getObject().stringValue();	×
290	} else if (st.getPredicate().equals(HAS_OWNER) && st.getObject() instanceof IRI obj) {	×
291	data.addOwner(obj);	×
292	} else if (st.getPredicate().equals(HAS_PINNED_TEMPLATE) && st.getObject() instanceof IRI obj) {	×
293	data.pinnedResources.add(TemplateData.get().getTemplate(obj.stringValue()));	×
294	} else if (st.getPredicate().equals(HAS_PINNED_QUERY) && st.getObject() instanceof IRI obj) {	×
295	data.pinnedResources.add(GrlcQuery.get(obj.stringValue()));	×
296	} else if (st.getPredicate().equals(NTEMPLATE.HAS_DEFAULT_PROVENANCE) && st.getObject() instanceof IRI obj) {	×
297	data.defaultProvenance = obj;	×
298	}
299	} else if (st.getPredicate().equals(NTEMPLATE.HAS_TAG) && st.getObject() instanceof Literal l) {	×
300	data.pinGroupTags.add(l.stringValue());	×
301	List<Serializable> list = data.pinnedResourceMap.get(l.stringValue());	×
302	if (list == null) {	×
303	list = new ArrayList<>();	×
304	data.pinnedResourceMap.put(l.stringValue(), list);	×
305	}
306	list.add(TemplateData.get().getTemplate(st.getSubject().stringValue()));	×
307	}
308	}	×
309	}	×
310
311	@Override
312	public String toString() {
313	return id;	×
314	}
315
316	}

knowledgepixels / nanodash / 17678939499

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