Design system port: replace Bootstrap 2 with the LinkedDataHub design system

http-tests/language/content-language-by-reader.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Content-Language names the language the page was composed in, which is the first of the reader's accepted languages that
+# the UI translation bundle actually has - not the reader's top preference. The bundle ships English and Spanish, so a
+# Lithuanian or German reader gets an honest en rather than their own request echoed back at them. What is published is the
+# shortest tag the bundle justifies: its keys are en-US and es-ES, but neither region distinguishes anything.
+
+purge_cache "$END_USER_VARNISH_SERVICE"
+purge_cache "$FRONTEND_VARNISH_SERVICE"
+
+response()
+{
+    curl -i -k -s \
+      -E "$OWNER_CERT_FILE":"$OWNER_CERT_PWD" \
+      -H "Accept: text/html" \
+      "$@" \
+      "$END_USER_BASE_URL" \
+    | tr -d '\r'
+}
+
+assert_language()
+{
+    local accept_language="$1"
+    local expected="$2"
+    local response actual
+
+    if [ -n "$accept_language" ]; then
+        response=$(response -H "Accept-Language: $accept_language")
+    else
+        response=$(response)
+    fi
+
+    # an error page is rendered through the same stylesheet and carries a Content-Language of its own, so every probe
+    # confirms this is the document rather than a failure that happens to be labelled
+    echo "$response" | grep -qE "^HTTP/[0-9.]+ 200"
+
+    actual=$(echo "$response" | grep -i "^Content-Language:" | sed 's/^Content-Language: *//i' || true)
+
+    [ "$actual" = "$expected" ]
+}
+
+# the bundle keys are region-qualified while browsers send primary subtags, so matching is RFC 4647 Basic
+# Filtering - but the published tag drops a region that distinguishes nothing, per BCP 47
+
+assert_language "en-US,en;q=0.9,da;q=0.8,lt;q=0.7" "en"
+assert_language "en" "en"
+assert_language "es" "es"
+
+# preference order decides between two languages the bundle has, rather than bundle order
+
+assert_language "es,en;q=0.9" "es"
+assert_language "en,es;q=0.9" "en"
+
+# the bundle has no Lithuanian, so the page is composed in the next language it does have
+
+assert_language "lt,en-US;q=0.9,en;q=0.8" "en"
+
+# none of the reader's languages are available: fall back rather than claim a language the page is not in
+
+assert_language "de,fr;q=0.9" "en"
+
+# no preference expressed at all
+
+assert_language "" "en"

http-tests/language/content-language-media-type.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Only a representation whose rendering depends on language gets labelled with one. An RDF representation is byte-identical
+# for every reader - its literals carry their own tags and none is dropped - so it is intended for all language audiences,
+# which RFC 9110 spells as no Content-Language at all.
+
+purge_cache "$END_USER_VARNISH_SERVICE"
+purge_cache "$FRONTEND_VARNISH_SERVICE"
+
+headers()
+{
+    curl -i -k -s \
+      -E "$OWNER_CERT_FILE":"$OWNER_CERT_PWD" \
+      -H "Accept: $1" \
+      -H "Accept-Language: en" \
+      "$END_USER_BASE_URL" \
+    | tr -d '\r'
+}
+
+assert_labelled()
+{
+    local response actual
+
+    response=$(headers "$1")
+
+    # an error page is rendered through the same stylesheet and carries a Content-Language of its own, so every probe
+    # confirms this is the representation rather than a failure that happens to be labelled
+    echo "$response" | grep -qE "^HTTP/[0-9.]+ 200"
+
+    actual=$(echo "$response" | grep -i "^Content-Language:" | sed 's/^Content-Language: *//i' || true)
+
+    [ "$actual" = "en" ]
+}
+
+assert_unlabelled()
+{
+    local response
+
+    response=$(headers "$1")
+
+    echo "$response" | grep -qE "^HTTP/[0-9.]+ 200"
+
+    ! echo "$response" | grep -qi "^Content-Language:"
+}
+
+# both HTML flavours are rendered through the translation bundle and so are composed in one language
+
+assert_labelled "text/html"
+assert_labelled "application/xhtml+xml"
+
+assert_unlabelled "application/rdf+xml"
+assert_unlabelled "text/turtle"
+assert_unlabelled "application/n-triples"
+assert_unlabelled "application/ld+json"

http-tests/language/etag-varies-by-language.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Two readers get two different HTML representations of the same document, so the two must not share an entity tag: a
+# Spanish reader arriving with the English reader's tag would be told 304 and shown a page in a language they never asked
+# for. The RDF representation is the same bytes for both, so its tag has to stay stable across them.
+
+purge_cache "$END_USER_VARNISH_SERVICE"
+purge_cache "$FRONTEND_VARNISH_SERVICE"
+
+etag()
+{
+    curl -i -k -s \
+      -E "$OWNER_CERT_FILE":"$OWNER_CERT_PWD" \
+      -H "Accept: $1" \
+      -H "Accept-Language: $2" \
+      "$END_USER_BASE_URL" \
+    | tr -d '\r' \
+    | grep -i "^ETag:" \
+    | sed 's/^ETag: *//i' || true
+}
+
+html_en=$(etag "text/html" "en")
+html_es=$(etag "text/html" "es")
+
+[ -n "$html_en" ]
+
+# two languages must not share one entity tag, or a conditional request would serve the wrong language
+
+[ "$html_en" != "$html_es" ]
+
+# the tag is still stable for one reader, otherwise conditional requests never revalidate
+
+[ "$html_en" = "$(etag "text/html" "en")" ]
+
+status()
+{
+    curl -k -w "%{http_code}" -o /dev/null -s \
+      -E "$OWNER_CERT_FILE":"$OWNER_CERT_PWD" \
+      -H "Accept: text/html" \
+      -H "Accept-Language: $1" \
+      -H "If-None-Match: $2" \
+      "$END_USER_BASE_URL"
+}
+
+# the reader's own tag revalidates, another reader's does not
+
+[ "$(status "en" "$html_en")" = "$STATUS_NOT_MODIFIED" ]
+[ "$(status "es" "$html_en")" = "$STATUS_OK" ]
+
+# RDF carries every language at once, so language is not part of its identity
+
+[ "$(etag "application/n-triples" "en")" = "$(etag "application/n-triples" "es")" ]

http-tests/language/html-lang-matches-content-language.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# The header and the document have to agree about what language the page is in. They do because both read the same
+# computation: the stylesheet takes the root lang straight from Content-Language rather than from the request. A reader whose
+# language the bundle lacks is the case that used to disagree - the header said nothing while the document claimed lt.
+
+purge_cache "$END_USER_VARNISH_SERVICE"
+purge_cache "$FRONTEND_VARNISH_SERVICE"
+
+assert_agrees()
+{
+    local expected="$2"
+    local headers body header document
+
+    headers=$(mktemp)
+
+    # XHTML is the same rendering as text/html but well-formed, so the document can be queried with XPath rather than
+    # matched as text - attribute order is a serialization detail and nothing here depends on it
+    body=$(curl -k -s \
+      -D "$headers" \
+      -E "$OWNER_CERT_FILE":"$OWNER_CERT_PWD" \
+      -H "Accept: application/xhtml+xml" \
+      -H "Accept-Language: $1" \
+      "$END_USER_BASE_URL")
+
+    # an error page is rendered through the same stylesheet and agrees with itself just as happily, so confirm this is the
+    # document before comparing the two
+    head -1 "$headers" | grep -qE "^HTTP/[0-9.]+ 200"
+
+    header=$(tr -d '\r' < "$headers" | grep -i "^Content-Language:" | sed 's/^Content-Language: *//i' || true)
+    rm -f "$headers"
+
+    document=$(echo "$body" | xmllint --xpath 'string(/*[local-name() = "html"]/@lang)' - 2> /dev/null || true)
+
+    [ "$header" = "$expected" ] && [ "$document" = "$expected" ]
+}
+
+assert_agrees "en" "en"
+assert_agrees "es" "es"
+
+# the bundle has no Lithuanian and no German: the root must not claim a language the page is not written in
+
+assert_agrees "lt,en;q=0.9" "en"
+assert_agrees "de" "en"

http-tests/language/literal-lang-attributes.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# RDF carries language per literal, HTML per element, so every rendered value declares its own rather than inheriting the
+# document's. A property renders every language it has, side by side, and the root value is wrong for at least one of them:
+# without this a screen reader says "Square" with Lithuanian phonetics and "Aikštė" with an English voice. An untagged
+# literal makes no language claim at all, which HTML spells lang="" - the exact counterpart of RDF's absent tag - while a
+# number is not prose and inherits, so it is read out in the reader's own language.
+
+purge_cache "$END_USER_VARNISH_SERVICE"
+purge_cache "$FRONTEND_VARNISH_SERVICE"
+
+slug=$(uuidgen | tr '[:upper:]' '[:lower:]')
+doc_url="${END_USER_BASE_URL}${slug}/"
+
+# the properties belong to the document's primary topic: a document describing nothing but itself renders its title and
+# an empty body, so the values would never reach a dd
+
+echo "<${doc_url}> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://www.w3.org/ns/ldt/document-hierarchy#Item> .
+<${doc_url}> <http://purl.org/dc/terms/title> \"Language marking\" .
+<${doc_url}> <http://xmlns.com/foaf/0.1/primaryTopic> <${doc_url}#this> .
+<${doc_url}#this> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <https://example.org/test#Thing> .
+<${doc_url}#this> <https://example.org/test#tagged> \"Aikštė\"@lt .
+<${doc_url}#this> <https://example.org/test#tagged> \"Square\"@en .
+<${doc_url}#this> <https://example.org/test#plain> \"Untagged value\" .
+<${doc_url}#this> <https://example.org/test#typed> \"42\"^^<http://www.w3.org/2001/XMLSchema#integer> ." | \
+  ldh put \
+    -f "$OWNER_CERT_KEYSTORE" \
+    -p "$OWNER_CERT_PWD" \
+    -t "application/n-triples" \
+    "$doc_url"
+
+purge_cache "$END_USER_VARNISH_SERVICE"
+purge_cache "$FRONTEND_VARNISH_SERVICE"
+
+# XHTML is the same rendering as text/html but well-formed, so the values can be queried with XPath rather than matched as
+# text. Attribute order is a serialization detail - the build inlines entities through an XML round trip that alphabetizes
+# literal-result-element attributes, while xsl:attribute instructions append in execution order - and nothing here depends
+# on it
+body=$(curl -k -s \
+  -E "$OWNER_CERT_FILE":"$OWNER_CERT_PWD" \
+  -H "Accept: application/xhtml+xml" \
+  -H "Accept-Language: en" \
+  "$doc_url")
+
+count()
+{
+    echo "$body" | xmllint --xpath "count($1)" - 2> /dev/null || echo "0"
+}
+
+# the page is in English and both values are on it: each says which language it is in
+
+[ "$(count "//*[local-name() = 'dd'][@property = 'https://example.org/test#tagged'][@lang = 'lt']")" = "1" ]
+[ "$(count "//*[local-name() = 'dd'][@property = 'https://example.org/test#tagged'][@lang = 'en']")" = "1" ]
+
+# an untagged literal claims no language rather than inheriting the document's
+
+[ "$(count "//*[local-name() = 'dd'][@property = 'https://example.org/test#plain'][@lang = '']")" = "1" ]
+
+# a number is not prose - it inherits, so it is read out in whatever language the reader is in
+
+[ "$(count "//*[local-name() = 'dd'][@property = 'https://example.org/test#typed']")" = "1" ]
+[ "$(count "//*[local-name() = 'dd'][@property = 'https://example.org/test#typed'][@lang]")" = "0" ]
+
+# both languages of the property survive to the page - suppressing one is the defect this marking exists to make safe
+
+[ "$(count "//*[local-name() = 'span'][@class = 'chip-inline']")" = "2" ]
+
+ldh delete \
+  -f "$OWNER_CERT_KEYSTORE" \
+  -p "$OWNER_CERT_PWD" \
+  "$doc_url" > /dev/null

http-tests/language/vary-accept-language.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# An HTML representation differs by the reader's language, so the response has to say so or a shared cache will hand one
+# reader's page to another. This is the header the caches downstream key on, and the reason two readers can be served from
+# the same URL at all.
+
+purge_cache "$END_USER_VARNISH_SERVICE"
+purge_cache "$FRONTEND_VARNISH_SERVICE"
+
+curl -i -k -s \
+  -E "$OWNER_CERT_FILE":"$OWNER_CERT_PWD" \
+  -H "Accept: text/html" \
+  -H "Accept-Language: en" \
+  "$END_USER_BASE_URL" \
+| tr -d '\r' \
+| grep -i "^Vary:" \
+| grep -qi "Accept-Language"
+
+# the same URL must survive two readers in sequence through the caches in front of it
+
+purge_cache "$END_USER_VARNISH_SERVICE"
+purge_cache "$FRONTEND_VARNISH_SERVICE"
+
+fetch_language()
+{
+    curl -i -k -s \
+      -E "$OWNER_CERT_FILE":"$OWNER_CERT_PWD" \
+      -H "Accept: text/html" \
+      -H "Accept-Language: $1" \
+      "$END_USER_BASE_URL" \
+    | tr -d '\r' \
+    | grep -i "^Content-Language:" \
+    | sed 's/^Content-Language: *//i' || true
+}
+
+[ "$(fetch_language "en")" = "en" ]
+[ "$(fetch_language "es")" = "es" ]
+[ "$(fetch_language "en")" = "en" ]

http-tests/misc/cors-static.sh

@@ -6,7 +6,7 @@ set -euo pipefail
 
 response=$(curl -i -k -s \
   -H "Origin: https://example.com" \
-  "${END_USER_BASE_URL}static/com/atomgraph/linkeddatahub/css/bootstrap.css")
+  "${END_USER_BASE_URL}static/com/atomgraph/linkeddatahub/css/ldh.css")
 
 # Verify Access-Control-Allow-Origin header is present
 if ! echo "$response" | grep -q "Access-Control-Allow-Origin: \*"; then
@@ -26,7 +26,7 @@ preflight=$(curl -i -k -s \
   -X OPTIONS \
   -H "Origin: https://example.com" \
   -H "Access-Control-Request-Method: GET" \
-  "${END_USER_BASE_URL}static/com/atomgraph/linkeddatahub/css/bootstrap.css")
+  "${END_USER_BASE_URL}static/com/atomgraph/linkeddatahub/css/ldh.css")
 
 # Verify preflight response has CORS headers
 if ! echo "$preflight" | grep -q "Access-Control-Allow-Origin: \*"; then

http-tests/run.sh

@@ -284,6 +284,8 @@ run_tests "sparql-protocol" $(find ./sparql-protocol/ -type f -name '*.sh')
 (( error_count += $? ))
 run_tests "versioning" $(find ./versioning/ -type f -name '*.sh')
 (( error_count += $? ))
+run_tests "language" $(find ./language/ -type f -name '*.sh')
+(( error_count += $? ))
 
 end_time=$(date +%s)
 runtime=$((end_time-start_time))

pom.xml

@@ -169,13 +169,13 @@
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>client</artifactId>
-            <version>5.0.3</version>
+            <version>5.0.4-SNAPSHOT</version>
             <classifier>classes</classifier>
         </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>client</artifactId>
-            <version>5.0.3</version>
+            <version>5.0.4-SNAPSHOT</version>
             <type>war</type>
         </dependency>
         <dependency>