diff --git a/src/main/java/com/knowledgepixels/nanodash/template/Template.java b/src/main/java/com/knowledgepixels/nanodash/template/Template.java index 72b7b94d..2af6a9be 100644 --- a/src/main/java/com/knowledgepixels/nanodash/template/Template.java +++ b/src/main/java/com/knowledgepixels/nanodash/template/Template.java @@ -35,19 +35,8 @@ public class Template implements Serializable { */ public static final String DEFAULT_TARGET_NAMESPACE = "https://w3id.org/np/"; - // TODO Move these to the other ntemplate vocabulary terms in nanopub-java: - private static final IRI ADVANCED_STATEMENT = vf.createIRI("https://w3id.org/np/o/ntemplate/AdvancedStatement"); - - /** - * Type of a literal placeholder whose language tag is selected by the user at fill time. - */ - public static final IRI LANGUAGE_TAGGED_LITERAL_PLACEHOLDER = vf.createIRI("https://w3id.org/np/o/ntemplate/LanguageTaggedLiteralPlaceholder"); - - /** - * Predicate restricting the language tags offered by a language-tag picker. - */ - public static final IRI POSSIBLE_LANGUAGE_TAG = vf.createIRI("https://w3id.org/np/o/ntemplate/possibleLanguageTag"); - + // TODO Move this to the other ntemplate vocabulary terms in nanopub-java (added there in + // Nanopublication/nanopub-java#156; drop it once that release is picked up): /** * Type of a template whose filled content applies only to the specific nanopublication * it was published with, and is not carried over when that nanopublication is @@ -612,7 +601,7 @@ public boolean isAutoEscapePlaceholder(IRI iri) { public boolean isLiteralPlaceholder(IRI iri) { iri = transform(iri); return typeMap.containsKey(iri) && (typeMap.get(iri).contains(NTEMPLATE.LITERAL_PLACEHOLDER) || typeMap.get(iri).contains(NTEMPLATE.LONG_LITERAL_PLACEHOLDER) - || typeMap.get(iri).contains(LANGUAGE_TAGGED_LITERAL_PLACEHOLDER)); + || typeMap.get(iri).contains(NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER)); } /** @@ -623,7 +612,7 @@ public boolean isLiteralPlaceholder(IRI iri) { */ public boolean isLanguageTagSelectable(IRI iri) { iri = transform(iri); - return typeMap.containsKey(iri) && typeMap.get(iri).contains(LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); + return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); } /** @@ -744,7 +733,7 @@ public boolean isPlaceholder(IRI iri) { if (t.equals(NTEMPLATE.AGENT_PLACEHOLDER)) return true; if (t.equals(NTEMPLATE.LITERAL_PLACEHOLDER)) return true; if (t.equals(NTEMPLATE.LONG_LITERAL_PLACEHOLDER)) return true; - if (t.equals(LANGUAGE_TAGGED_LITERAL_PLACEHOLDER)) return true; + if (t.equals(NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER)) return true; if (t.equals(NTEMPLATE.SEQUENCE_ELEMENT_PLACEHOLDER)) return true; if (t.equals(NTEMPLATE.ROOT_NANOPUB_PLACEHOLDER)) return true; } @@ -809,7 +798,7 @@ private boolean matchesPlaceholderLocalName(Value value, String localName) { * @return true if the IRI is an advanced statement, false otherwise. */ public boolean isAdvancedStatement(IRI iri) { - return typeMap.containsKey(iri) && typeMap.get(iri).contains(ADVANCED_STATEMENT); + return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.ADVANCED_STATEMENT); } /** @@ -1020,7 +1009,7 @@ private void processTemplate(Nanopub templateNp) throws MalformedTemplateExcepti // picker wins so the placeholder keeps rendering as a text field. private void checkLanguageTagPlaceholders() { for (Map.Entry> e : typeMap.entrySet()) { - if (e.getValue().contains(LANGUAGE_TAGGED_LITERAL_PLACEHOLDER) && datatypeMap.containsKey(e.getKey())) { + if (e.getValue().contains(NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER) && datatypeMap.containsKey(e.getKey())) { logger.warn("Ignoring datatype {} on language-tag-selectable placeholder {}", datatypeMap.get(e.getKey()), e.getKey()); datatypeMap.remove(e.getKey()); } @@ -1150,7 +1139,7 @@ private void processNpTemplate(Nanopub templateNp) throws MalformedTemplateExcep datatypeMap.put(subj, objIri); } else if (pred.equals(NTEMPLATE.HAS_LANGUAGE_TAG) && obj instanceof Literal) { languageTagMap.put(subj, Literals.normalizeLanguageTag(objS)); - } else if (pred.equals(POSSIBLE_LANGUAGE_TAG) && obj instanceof Literal) { + } else if (pred.equals(NTEMPLATE.POSSIBLE_LANGUAGE_TAG) && obj instanceof Literal) { possibleLanguageTagMap.computeIfAbsent(subj, k -> new ArrayList<>()).add(Literals.normalizeLanguageTag(objS)); } else if (pred.equals(NTEMPLATE.HAS_PREFIX) && obj instanceof Literal) { prefixMap.put(subj, objS); @@ -1354,7 +1343,7 @@ private void processShaclTemplate(Nanopub templateNp) throws MalformedTemplateEx datatypeMap.put(subj, objIri); } else if (pred.equals(NTEMPLATE.HAS_LANGUAGE_TAG) && obj instanceof Literal) { languageTagMap.put(subj, Literals.normalizeLanguageTag(objS)); - } else if (pred.equals(POSSIBLE_LANGUAGE_TAG) && obj instanceof Literal) { + } else if (pred.equals(NTEMPLATE.POSSIBLE_LANGUAGE_TAG) && obj instanceof Literal) { possibleLanguageTagMap.computeIfAbsent(subj, k -> new ArrayList<>()).add(Literals.normalizeLanguageTag(objS)); } else if (pred.equals(NTEMPLATE.HAS_PREFIX) && obj instanceof Literal) { prefixMap.put(subj, objS); diff --git a/src/test/java/com/knowledgepixels/nanodash/component/LiteralTextfieldLangItemTest.java b/src/test/java/com/knowledgepixels/nanodash/component/LiteralTextfieldLangItemTest.java index 3c2abcd2..399b2faf 100644 --- a/src/test/java/com/knowledgepixels/nanodash/component/LiteralTextfieldLangItemTest.java +++ b/src/test/java/com/knowledgepixels/nanodash/component/LiteralTextfieldLangItemTest.java @@ -73,13 +73,13 @@ private TemplateContext contextFor(boolean selectable, String defaultTag, String creator.addAssertionStatement(st1, RDF.OBJECT, COMMENT); creator.addAssertionStatement(COMMENT, RDF.TYPE, NTEMPLATE.LITERAL_PLACEHOLDER); if (selectable) { - creator.addAssertionStatement(COMMENT, RDF.TYPE, Template.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); + creator.addAssertionStatement(COMMENT, RDF.TYPE, NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); } if (defaultTag != null) { creator.addAssertionStatement(COMMENT, NTEMPLATE.HAS_LANGUAGE_TAG, vf.createLiteral(defaultTag)); } for (String tag : possibleTags) { - creator.addAssertionStatement(COMMENT, Template.POSSIBLE_LANGUAGE_TAG, vf.createLiteral(tag)); + creator.addAssertionStatement(COMMENT, NTEMPLATE.POSSIBLE_LANGUAGE_TAG, vf.createLiteral(tag)); } creator.addAssertionStatement(COMMENT, RDFS.LABEL, vf.createLiteral("comment")); Template template = TemplateTestUtil.parseTemplate(creator.finalizeNanopub()); diff --git a/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagFillTest.java b/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagFillTest.java index 017c9d86..3146dd11 100644 --- a/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagFillTest.java +++ b/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagFillTest.java @@ -71,13 +71,13 @@ private void mockTemplate(boolean selectable, String fixedOrDefaultTag, String.. creator.addAssertionStatement(ST1, RDF.OBJECT, COMMENT); creator.addAssertionStatement(COMMENT, RDF.TYPE, NTEMPLATE.LITERAL_PLACEHOLDER); if (selectable) { - creator.addAssertionStatement(COMMENT, RDF.TYPE, Template.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); + creator.addAssertionStatement(COMMENT, RDF.TYPE, NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); } if (fixedOrDefaultTag != null) { creator.addAssertionStatement(COMMENT, NTEMPLATE.HAS_LANGUAGE_TAG, vf.createLiteral(fixedOrDefaultTag)); } for (String tag : possibleTags) { - creator.addAssertionStatement(COMMENT, Template.POSSIBLE_LANGUAGE_TAG, vf.createLiteral(tag)); + creator.addAssertionStatement(COMMENT, NTEMPLATE.POSSIBLE_LANGUAGE_TAG, vf.createLiteral(tag)); } creator.addAssertionStatement(COMMENT, RDFS.LABEL, vf.createLiteral("comment")); Template template = new Template(creator.finalizeNanopub()); diff --git a/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagPublishTest.java b/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagPublishTest.java index 288d8cef..8a6f0b20 100644 --- a/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagPublishTest.java +++ b/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagPublishTest.java @@ -81,7 +81,7 @@ private TemplateContext contextWith(boolean selectable, String fixedOrDefaultTag creator.addAssertionStatement(ST1, RDF.OBJECT, COMMENT); creator.addAssertionStatement(COMMENT, RDF.TYPE, NTEMPLATE.LITERAL_PLACEHOLDER); if (selectable) { - creator.addAssertionStatement(COMMENT, RDF.TYPE, Template.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); + creator.addAssertionStatement(COMMENT, RDF.TYPE, NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); } if (fixedOrDefaultTag != null) { creator.addAssertionStatement(COMMENT, NTEMPLATE.HAS_LANGUAGE_TAG, vf.createLiteral(fixedOrDefaultTag)); diff --git a/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagRepetitionTest.java b/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagRepetitionTest.java index 05358644..1b8bf491 100644 --- a/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagRepetitionTest.java +++ b/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagRepetitionTest.java @@ -67,7 +67,7 @@ private TemplateContext repeatableContext() throws Exception { creator.addAssertionStatement(ST1, RDF.PREDICATE, RDFS.COMMENT); creator.addAssertionStatement(ST1, RDF.OBJECT, COMMENT); creator.addAssertionStatement(COMMENT, RDF.TYPE, NTEMPLATE.LITERAL_PLACEHOLDER); - creator.addAssertionStatement(COMMENT, RDF.TYPE, Template.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); + creator.addAssertionStatement(COMMENT, RDF.TYPE, NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); creator.addAssertionStatement(COMMENT, RDFS.LABEL, vf.createLiteral("comment")); Template template = new Template(creator.finalizeNanopub()); diff --git a/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagTemplateTest.java b/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagTemplateTest.java index 7ffe98b0..ff1200b6 100644 --- a/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagTemplateTest.java +++ b/src/test/java/com/knowledgepixels/nanodash/template/LanguageTagTemplateTest.java @@ -54,7 +54,7 @@ private static NanopubCreator newCreator(IRI... placeholderTypes) throws Excepti @Test void selectablePlaceholderParses() throws Exception { - NanopubCreator creator = newCreator(NTEMPLATE.LITERAL_PLACEHOLDER, Template.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); + NanopubCreator creator = newCreator(NTEMPLATE.LITERAL_PLACEHOLDER, NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); Template t = new Template(creator.finalizeNanopub()); assertTrue(t.isLanguageTagSelectable(COMMENT_PLACEHOLDER)); assertTrue(t.isLiteralPlaceholder(COMMENT_PLACEHOLDER)); @@ -64,9 +64,9 @@ void selectablePlaceholderParses() throws Exception { @Test void possibleLanguageTagsAreNormalized() throws Exception { - NanopubCreator creator = newCreator(NTEMPLATE.LITERAL_PLACEHOLDER, Template.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); - creator.addAssertionStatement(COMMENT_PLACEHOLDER, Template.POSSIBLE_LANGUAGE_TAG, vf.createLiteral("en")); - creator.addAssertionStatement(COMMENT_PLACEHOLDER, Template.POSSIBLE_LANGUAGE_TAG, vf.createLiteral("DE-de")); + NanopubCreator creator = newCreator(NTEMPLATE.LITERAL_PLACEHOLDER, NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); + creator.addAssertionStatement(COMMENT_PLACEHOLDER, NTEMPLATE.POSSIBLE_LANGUAGE_TAG, vf.createLiteral("en")); + creator.addAssertionStatement(COMMENT_PLACEHOLDER, NTEMPLATE.POSSIBLE_LANGUAGE_TAG, vf.createLiteral("DE-de")); Template t = new Template(creator.finalizeNanopub()); List tags = t.getPossibleLanguageTags(COMMENT_PLACEHOLDER); assertEquals(2, tags.size()); @@ -76,7 +76,7 @@ void possibleLanguageTagsAreNormalized() throws Exception { @Test void defaultLanguageTagParses() throws Exception { - NanopubCreator creator = newCreator(NTEMPLATE.LITERAL_PLACEHOLDER, Template.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); + NanopubCreator creator = newCreator(NTEMPLATE.LITERAL_PLACEHOLDER, NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); creator.addAssertionStatement(COMMENT_PLACEHOLDER, NTEMPLATE.HAS_LANGUAGE_TAG, vf.createLiteral("en")); Template t = new Template(creator.finalizeNanopub()); assertEquals("en", t.getLanguageTag(COMMENT_PLACEHOLDER)); @@ -94,7 +94,7 @@ void plainLiteralPlaceholderIsNotSelectable() throws Exception { @Test void selectableTypeAloneIsLiteralPlaceholder() throws Exception { - NanopubCreator creator = newCreator(Template.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); + NanopubCreator creator = newCreator(NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); Template t = new Template(creator.finalizeNanopub()); assertTrue(t.isLiteralPlaceholder(COMMENT_PLACEHOLDER)); assertTrue(t.isPlaceholder(COMMENT_PLACEHOLDER)); @@ -103,7 +103,7 @@ void selectableTypeAloneIsLiteralPlaceholder() throws Exception { @Test void conflictingDatatypeIsDropped() throws Exception { - NanopubCreator creator = newCreator(NTEMPLATE.LITERAL_PLACEHOLDER, Template.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); + NanopubCreator creator = newCreator(NTEMPLATE.LITERAL_PLACEHOLDER, NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); creator.addAssertionStatement(COMMENT_PLACEHOLDER, NTEMPLATE.HAS_DATATYPE, XSD.DATE); Template t = new Template(creator.finalizeNanopub()); assertNull(t.getDatatype(COMMENT_PLACEHOLDER)); @@ -119,8 +119,8 @@ void datatypeIsKeptOnPlainPlaceholder() throws Exception { @Test void repetitionSuffixedLookupWorks() throws Exception { - NanopubCreator creator = newCreator(NTEMPLATE.LITERAL_PLACEHOLDER, Template.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); - creator.addAssertionStatement(COMMENT_PLACEHOLDER, Template.POSSIBLE_LANGUAGE_TAG, vf.createLiteral("en")); + NanopubCreator creator = newCreator(NTEMPLATE.LITERAL_PLACEHOLDER, NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER); + creator.addAssertionStatement(COMMENT_PLACEHOLDER, NTEMPLATE.POSSIBLE_LANGUAGE_TAG, vf.createLiteral("en")); Template t = new Template(creator.finalizeNanopub()); IRI suffixed = vf.createIRI(COMMENT_PLACEHOLDER.stringValue() + "__1"); assertTrue(t.isLanguageTagSelectable(suffixed)); diff --git a/src/test/java/com/knowledgepixels/nanodash/template/TemplateVocabularyIrisTest.java b/src/test/java/com/knowledgepixels/nanodash/template/TemplateVocabularyIrisTest.java new file mode 100644 index 00000000..983ed7ce --- /dev/null +++ b/src/test/java/com/knowledgepixels/nanodash/template/TemplateVocabularyIrisTest.java @@ -0,0 +1,34 @@ +package com.knowledgepixels.nanodash.template; + +import org.junit.jupiter.api.Test; +import org.nanopub.vocabulary.NTEMPLATE; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +/** + * The template terms Nanodash reads are the ones already published in templates out in the + * network, so their IRIs are a fixed contract rather than an implementation detail of + * whichever library declares them. These were spelled out in {@link Template} until + * nanopub-java gained them; pinning the strings here keeps a rename upstream from quietly + * turning every template that uses them into one Nanodash no longer recognises. + */ +class TemplateVocabularyIrisTest { + + @Test + void theTermsNanodashReadsKeepTheirPublishedIris() { + assertEquals("https://w3id.org/np/o/ntemplate/AdvancedStatement", + NTEMPLATE.ADVANCED_STATEMENT.stringValue()); + assertEquals("https://w3id.org/np/o/ntemplate/LanguageTaggedLiteralPlaceholder", + NTEMPLATE.LANGUAGE_TAGGED_LITERAL_PLACEHOLDER.stringValue()); + assertEquals("https://w3id.org/np/o/ntemplate/possibleLanguageTag", + NTEMPLATE.POSSIBLE_LANGUAGE_TAG.stringValue()); + } + + // Still declared in Template, pending the nanopub-java release that carries it. + @Test + void theTransientTemplateTypeKeepsItsPublishedIri() { + assertEquals("https://w3id.org/np/o/ntemplate/TransientTemplate", + Template.TRANSIENT_TEMPLATE.stringValue()); + } + +}