17666363500

Committed 12 Sep 2025 06:20AM UTC coverage: 13.781% (+0.03%) from 13.751%

Build # 17666363500

Build Type

push

github

Committed by

tkuhn

Commit Message

feat: Identify sub-spaces based on ID hierarchy, and show them

Run Details

433 of 3974 branches covered (10.9%)

Branch coverage included in aggregate %.

1111 of 7230 relevant lines covered (15.37%)

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.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

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.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,List<Space>> subspaceMap;

    public static synchronized void refresh(ApiResponse resp) {
        spaceList = new ArrayList<>();
        Map<String,Space> prevSpacesByCoreInfoPrev = spacesByCoreInfo;
        spacesByCoreInfo = new HashMap<>();
        spacesById = new HashMap<>();
        subspaceMap = 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.getSuperspace();
            if (superSpace == null) continue;
            subspaceMap.computeIfAbsent(superSpace, k -> new ArrayList<>()).add(space);
        }
    }

    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 String description = null;
    private List<IRI> owners = new ArrayList<>();
    private List<IRI> members = new ArrayList<>();
    private ConcurrentMap<String,IRI> ownerPubkeyMap = new ConcurrentHashMap<>();
    private List<Template> templates = new ArrayList<>();
    private Set<String> templateTags = new HashSet<>();
    private ConcurrentMap<String, List<Template>> templatesPerTag = new ConcurrentHashMap<>();
    private List<IRI> queryIds = new ArrayList<>();
    private IRI defaultProvenance = null;

    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);

        for (Statement st : rootNanopub.getAssertion()) {
            if (st.getSubject().stringValue().equals(getId())) {
                if (st.getPredicate().equals(DCTERMS.DESCRIPTION)) {
                    description = st.getObject().stringValue();
                } else if (st.getPredicate().equals(HAS_OWNER) && st.getObject() instanceof IRI obj) {
                    addOwner(obj);
                } else if (st.getPredicate().equals(HAS_PINNED_TEMPLATE) && st.getObject() instanceof IRI obj) {
                    templates.add(TemplateData.get().getTemplate(obj.stringValue()));
                } else if (st.getPredicate().equals(HAS_PINNED_QUERY) && st.getObject() instanceof IRI obj) {
                    queryIds.add(obj);
                } else if (st.getPredicate().equals(NTEMPLATE.HAS_DEFAULT_PROVENANCE) && st.getObject() instanceof IRI obj) {
                    defaultProvenance = obj;
                }
            } else if (st.getPredicate().equals(NTEMPLATE.HAS_TAG) && st.getObject() instanceof Literal l) {
                templateTags.add(l.stringValue());
                List<Template> list = templatesPerTag.get(l.stringValue());
                if (list == null) {
                    list = new ArrayList<>();
                    templatesPerTag.put(l.stringValue(), list);
                }
                list.add(TemplateData.get().getTemplate(st.getSubject().stringValue()));
            }
        }
    }

    private 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);
        }
    }

    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 description;
    }

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

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

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

    public List<Template> getTemplates() {
        triggerDataUpdate();
        return templates;
    }

    public Set<String> getTemplateTags() {
        return templateTags;
    }

    public ConcurrentMap<String, List<Template>> getTemplatesPerTag() {
        return templatesPerTag;
    }

    public List<IRI> getQueryIds() {
        return queryIds;
    }

    public IRI getDefaultProvenance() {
        return defaultProvenance;
    }

    public String getSuperId() {
        return null;
    }

    public Space getSuperspace() {
        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> getSubspaces() {
        if (subspaceMap.containsKey(this)) {
            return subspaceMap.get(this);
        }
        return new ArrayList<>();
    }

    private synchronized void triggerDataUpdate() {
        if (dataNeedsUpdate) {
            new Thread(() -> {
                for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-owners", "unit", id).getData()) {
                    String pubkeyhash = r.get("pubkeyhash");
                    if (ownerPubkeyMap.containsKey(pubkeyhash)) {
                        addOwner(Utils.vf.createIRI(r.get("owner")));
                    }
                }
                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 (owners.contains(memberId)) continue;
                    if (members.contains(memberId)) continue;
                    members.add(memberId);
                }
                owners.sort(User.getUserData().userComparator);
                members.sort(User.getUserData().userComparator);

                for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-pinned-templates", "space", id).getData()) {
                    Template t = TemplateData.get().getTemplate(r.get("template"));
                    if (t == null) continue;
                    // Check pubkey with space owners
                    templates.add(t);
                    String tag = r.get("tag");
                    if (tag != null && !tag.isEmpty()) {
                        templateTags.add(r.get("tag"));
                        List<Template> list = templatesPerTag.get(r.get("tag"));
                        if (list == null) {
                            list = new ArrayList<>();
                            templatesPerTag.put(r.get("tag"), list);
                        }
                        list.add(TemplateData.get().getTemplate(r.get("template")));
                    }
                }
                dataInitialized = true;
            }).start();
            dataNeedsUpdate = false;
        }
    }

    @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.HashMap;
8	import java.util.HashSet;
9	import java.util.List;
10	import java.util.Map;
11	import java.util.Set;
12	import java.util.concurrent.ConcurrentHashMap;
13	import java.util.concurrent.ConcurrentMap;
14
15	import org.eclipse.rdf4j.model.IRI;
16	import org.eclipse.rdf4j.model.Literal;
17	import org.eclipse.rdf4j.model.Statement;
18	import org.eclipse.rdf4j.model.vocabulary.DCTERMS;
19	import org.nanopub.Nanopub;
20	import org.nanopub.extra.services.ApiResponse;
21	import org.nanopub.extra.services.ApiResponseEntry;
22	import org.nanopub.vocabulary.NTEMPLATE;
23
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,List<Space>> subspaceMap;
51
52	public static synchronized void refresh(ApiResponse resp) {
53	spaceList = new ArrayList<>();	×
54	Map<String,Space> prevSpacesByCoreInfoPrev = spacesByCoreInfo;	×
55	spacesByCoreInfo = new HashMap<>();	×
56	spacesById = new HashMap<>();	×
57	subspaceMap = new HashMap<>();	×
58	for (ApiResponseEntry entry : resp.getData()) {	×
59	Space space = new Space(entry);	×
60	Space prevSpace = prevSpacesByCoreInfoPrev.get(space.getCoreInfoString());	×
61	if (prevSpace != null) space = prevSpace;	×
62	spaceList.add(space);	×
63	spacesByCoreInfo.put(space.getCoreInfoString(), space);	×
64	spacesById.put(space.getId(), space);	×
65	}	×
66	for (Space space : spaceList) {	×
67	Space superSpace = space.getSuperspace();	×
68	if (superSpace == null) continue;	×
69	subspaceMap.computeIfAbsent(superSpace, k -> new ArrayList<>()).add(space);	×
70	}	×
71	}	×
72
73	public static void ensureLoaded() {
74	if (spaceList == null) {	×
75	refresh(QueryApiAccess.forcedGet("get-spaces"));	×
76	}
77	}	×
78
79	public static List<Space> getSpaceList() {
80	ensureLoaded();	×
81	return spaceList;	×
82	}
83
84	public static Space get(String id) {
85	ensureLoaded();	×
86	return spacesById.get(id);	×
87	}
88
89	public static void refresh() {
90	ensureLoaded();	×
91	for (Space space : spaceList) {	×
92	space.dataNeedsUpdate = true;	×
93	}	×
94	}	×
95
96	private String id, label, rootNanopubId, type;
97	private Nanopub rootNanopub = null;	×
98
99	private String description = null;	×
100	private List<IRI> owners = new ArrayList<>();	×
101	private List<IRI> members = new ArrayList<>();	×
102	private ConcurrentMap<String,IRI> ownerPubkeyMap = new ConcurrentHashMap<>();	×
103	private List<Template> templates = new ArrayList<>();	×
104	private Set<String> templateTags = new HashSet<>();	×
105	private ConcurrentMap<String, List<Template>> templatesPerTag = new ConcurrentHashMap<>();	×
106	private List<IRI> queryIds = new ArrayList<>();	×
107	private IRI defaultProvenance = null;	×
108
109	private boolean dataInitialized = false;	×
110	private boolean dataNeedsUpdate = true;	×
111
112	private Space(ApiResponseEntry resp) {	×
113	this.id = resp.get("space");	×
114	this.label = resp.get("label");	×
115	this.type = resp.get("type");	×
116	this.rootNanopubId = resp.get("np");	×
117	this.rootNanopub = Utils.getAsNanopub(rootNanopubId);	×
118
119	for (Statement st : rootNanopub.getAssertion()) {	×
120	if (st.getSubject().stringValue().equals(getId())) {	×
121	if (st.getPredicate().equals(DCTERMS.DESCRIPTION)) {	×
122	description = st.getObject().stringValue();	×
123	} else if (st.getPredicate().equals(HAS_OWNER) && st.getObject() instanceof IRI obj) {	×
124	addOwner(obj);	×
125	} else if (st.getPredicate().equals(HAS_PINNED_TEMPLATE) && st.getObject() instanceof IRI obj) {	×
126	templates.add(TemplateData.get().getTemplate(obj.stringValue()));	×
127	} else if (st.getPredicate().equals(HAS_PINNED_QUERY) && st.getObject() instanceof IRI obj) {	×
128	queryIds.add(obj);	×
129	} else if (st.getPredicate().equals(NTEMPLATE.HAS_DEFAULT_PROVENANCE) && st.getObject() instanceof IRI obj) {	×
130	defaultProvenance = obj;	×
131	}
132	} else if (st.getPredicate().equals(NTEMPLATE.HAS_TAG) && st.getObject() instanceof Literal l) {	×
133	templateTags.add(l.stringValue());	×
134	List<Template> list = templatesPerTag.get(l.stringValue());	×
135	if (list == null) {	×
136	list = new ArrayList<>();	×
137	templatesPerTag.put(l.stringValue(), list);	×
138	}
139	list.add(TemplateData.get().getTemplate(st.getSubject().stringValue()));	×
140	}
141	}	×
142	}	×
143
144	private void addOwner(IRI owner) {
145	// TODO This isn't efficient for long owner lists:
146	if (owners.contains(owner)) return;	×
147	owners.add(owner);	×
148	UserData ud = User.getUserData();	×
149	for (String pubkeyhash : ud.getPubkeyhashes(owner, true)) {	×
150	ownerPubkeyMap.put(pubkeyhash, owner);	×
151	}	×
152	}	×
153
154	public String getId() {
155	return id;	×
156	}
157
158	public String getRootNanopubId() {
159	return rootNanopubId;	×
160	}
161
162	public String getCoreInfoString() {
163	return id + " " + rootNanopubId;	×
164	}
165
166	public Nanopub getRootNanopub() {
167	return rootNanopub;	×
168	}
169
170	public String getLabel() {
171	return label;	×
172	}
173
174	public String getType() {
175	return type;	×
176	}
177
178	public String getTypeLabel() {
179	return type.replaceFirst("^.*/", "");	×
180	}
181
182	public String getDescription() {
183	return description;	×
184	}
185
186	public boolean isDataInitialized() {
187	triggerDataUpdate();	×
188	return dataInitialized;	×
189	}
190
191	public List<IRI> getOwners() {
192	triggerDataUpdate();	×
193	return owners;	×
194	}
195
196	public List<IRI> getMembers() {
197	triggerDataUpdate();	×
198	return members;	×
199	}
200
201	public List<Template> getTemplates() {
202	triggerDataUpdate();	×
203	return templates;	×
204	}
205
206	public Set<String> getTemplateTags() {
207	return templateTags;	×
208	}
209
210	public ConcurrentMap<String, List<Template>> getTemplatesPerTag() {
211	return templatesPerTag;	×
212	}
213
214	public List<IRI> getQueryIds() {
215	return queryIds;	×
216	}
217
218	public IRI getDefaultProvenance() {
219	return defaultProvenance;	×
220	}
221
222	public String getSuperId() {
223	return null;	×
224	}
225
226	public Space getSuperspace() {
227	if (!id.matches("https?://[^/]+/./[^/]/?")) return null;	×
228	String superId = id.replaceFirst("(https?://[^/]+/.)/[^/]/?", "$1");	×
229	if (spacesById.containsKey(superId)) {	×
230	return spacesById.get(superId);	×
231	}
232	return null;	×
233	}
234
235	public List<Space> getSubspaces() {
236	if (subspaceMap.containsKey(this)) {	×
237	return subspaceMap.get(this);	×
238	}
239	return new ArrayList<>();	×
240	}
241
242	private synchronized void triggerDataUpdate() {
243	if (dataNeedsUpdate) {	×
244	new Thread(() -> {	×
245	for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-owners", "unit", id).getData()) {	×
246	String pubkeyhash = r.get("pubkeyhash");	×
247	if (ownerPubkeyMap.containsKey(pubkeyhash)) {	×
248	addOwner(Utils.vf.createIRI(r.get("owner")));	×
249	}
250	}	×
251	members = new ArrayList<>();	×
252	for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-members", "unit", id).getData()) {	×
253	IRI memberId = Utils.vf.createIRI(r.get("member"));	×
254	// TODO These checks are inefficient for long member lists:
255	if (owners.contains(memberId)) continue;	×
256	if (members.contains(memberId)) continue;	×
257	members.add(memberId);	×
258	}	×
259	owners.sort(User.getUserData().userComparator);	×
260	members.sort(User.getUserData().userComparator);	×
261
262	for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-pinned-templates", "space", id).getData()) {	×
263	Template t = TemplateData.get().getTemplate(r.get("template"));	×
264	if (t == null) continue;	×
265	// Check pubkey with space owners
266	templates.add(t);	×
267	String tag = r.get("tag");	×
268	if (tag != null && !tag.isEmpty()) {	×
269	templateTags.add(r.get("tag"));	×
270	List<Template> list = templatesPerTag.get(r.get("tag"));	×
271	if (list == null) {	×
272	list = new ArrayList<>();	×
273	templatesPerTag.put(r.get("tag"), list);	×
274	}
275	list.add(TemplateData.get().getTemplate(r.get("template")));	×
276	}
277	}	×
278	dataInitialized = true;	×
279	}).start();	×
280	dataNeedsUpdate = false;	×
281	}
282	}	×
283
284	@Override
285	public String toString() {
286	return id;	×
287	}
288
289	}

knowledgepixels / nanodash / 17666363500

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