mess about with html rendering of shtrove api

Author: aaxelb

trove/render/_html.py

@@ -7,7 +7,6 @@
     SubElement,
     tostring as etree_tostring,
 )
-from typing import Any
 
 from primitive_metadata import primitive_rdf as rdf
 
@@ -39,18 +38,16 @@ def _current_element(self) -> Element:
     # html-building helper methods
 
     @contextlib.contextmanager
-    def nest_h_tag(self, **kwargs: Any) -> Generator[Element]:
+    def deeper_heading(self) -> Generator[str]:
         _outer_heading_depth = self._heading_depth
         if not _outer_heading_depth:
             self._heading_depth = 1
         elif _outer_heading_depth < 6:  # h6 deepest
             self._heading_depth += 1
-        _h_tag = f'h{self._heading_depth}'
-        with self.nest(_h_tag, **kwargs) as _nested:
-            try:
-                yield _nested
-            finally:
-                self._heading_depth = _outer_heading_depth
+        try:
+            yield f'h{self._heading_depth}'
+        finally:
+            self._heading_depth = _outer_heading_depth
 
     @contextlib.contextmanager
     def nest(self, tag_name: str, attrs: dict | None = None) -> Generator[Element]:

trove/render/html_browse.py

@@ -1,7 +1,4 @@
-from collections.abc import (
-    Iterator,
-    Generator,
-)
+from collections.abc import Generator
 import contextlib
 import dataclasses
 import datetime
@@ -26,7 +23,8 @@
 from trove.util.iris import get_sufficiently_unique_iri
 from trove.util.randomness import shuffled
 from trove.vocab import mediatypes
-from trove.vocab.namespaces import RDF, RDFS, SKOS, DCTERMS, FOAF, DC
+from trove.vocab import jsonapi
+from trove.vocab.namespaces import RDF, RDFS, SKOS, DCTERMS, FOAF, DC, OSFMAP
 from trove.vocab.static_vocab import combined_thesaurus__suffuniq
 from trove.vocab.trove import trove_browse_link
 from ._base import BaseRenderer
@@ -49,11 +47,16 @@
     DCTERMS.title,
     DC.title,
     FOAF.name,
+    OSFMAP.fileName,
 )
 _IMPLICIT_DATATYPES = frozenset((
     RDF.string,
     RDF.langString,
 ))
+_PREDICATES_RENDERED_SPECIAL = frozenset((
+    RDF.type,
+))
+_PRIMITIVE_LITERAL_TYPES = (float, int, datetime.date)
 
 _QUERYPARAM_SPLIT_RE = re.compile(r'(?=[?&])')
 
@@ -81,11 +84,13 @@ def is_data_blended(self) -> bool | None:
     def simple_render_document(self) -> str:
         self.__hb = HtmlBuilder()
         self.render_html_head()
-        _body_attrs = {
-            'class': 'BrowseWrapper',
-            'style': self._hue_turn_css(),
-        }
-        with self.__hb.nest('body', attrs=_body_attrs):
+        with (
+            self._hue_turn_css() as _hue_turn_style,
+            self.__hb.nest('body', attrs={
+                'class': 'BrowseWrapper',
+                'style': _hue_turn_style,
+            }),
+        ):
             self.render_nav()
             self.render_main()
             self.render_footer()
@@ -147,51 +152,64 @@ def __mediatype_link(self, mediatype: str) -> None:
                 with self.__hb.nest('a', attrs={'href': reverse('trove:docs')}) as _link:
                     _link.text = _('(stable for documented use)')
 
-    def __render_subj(self, subj_iri: str, *, start_collapsed: bool | None = None) -> None:
+    def __render_subj(self, subj_iri: str, *, should_link_details: bool = False) -> None:
         _twopledict = self.__current_data.get(subj_iri, {})
-        with self.__visiting(subj_iri):
+        _is_focus = (subj_iri in self.response_focus.iris)
+        with self.__visiting(subj_iri) as _h_tag:
             with self.__nest_card('article'):
                 with self.__hb.nest('header'):
                     _compact = self.iri_shorthand.compact_iri(subj_iri)
                     _is_compactable = (_compact != subj_iri)
-                    _should_link = (subj_iri not in self.response_focus.iris)
-                    with self.__hb.nest_h_tag(attrs={'id': quote(subj_iri)}) as _h:
-                        if _should_link:
+                    with self.__hb.nest(_h_tag, attrs={'id': quote(subj_iri)}) as _h:
+                        if _is_focus:
+                            if _is_compactable:
+                                _h.text = _compact
+                            else:
+                                self.__split_iri_pre(subj_iri)
+                        else:
                             with self.__nest_link(subj_iri) as _link:
                                 if _is_compactable:
                                     _link.text = _compact
                                 else:
                                     self.__split_iri_pre(subj_iri)
-                        else:
-                            if _is_compactable:
-                                _h.text = _compact
-                            else:
-                                self.__split_iri_pre(subj_iri)
                     self.__iri_subheaders(subj_iri)
-                if _twopledict:
-                    with self.__hb.nest('details') as _details:
-                        _detail_depth = sum((_el.tag == 'details') for _el in self.__hb._nested_elements)
-                        _should_open = (
-                            _detail_depth < 3
-                            if start_collapsed is None
-                            else not start_collapsed
-                        )
-                        if _should_open:
-                            _details.set('open', '')
+                    if _is_compactable:
+                        self.__hb.leaf('pre', text=subj_iri)
+                if should_link_details:
+                    with self.__nest_link(subj_iri) as _link:
+                        _link.text = _('more details...')
+                elif _twopledict:
+                    _details_attrs = (
+                        {'open': ''}
+                        if (_is_focus or _is_local_url(subj_iri))
+                        else {}
+                    )
+                    with self.__hb.nest('details', _details_attrs):
                         self.__hb.leaf('summary', text=_('more details...'))
                         self.__twoples(_twopledict)
 
     def __twoples(self, twopledict: rdf.RdfTwopleDictionary) -> None:
         with self.__hb.nest('dl', {'class': 'Browse__twopleset'}):
-            for _pred, _obj_set in shuffled(twopledict.items()):
+            for _pred, _obj_set in self.__order_twopledict(twopledict):
                 with self.__hb.nest('dt', attrs={'class': 'Browse__predicate'}):
                     self.__compact_link(_pred)
                     for _text in self.__iri_thesaurus_labels(_pred):
                         self.__literal(_text)
                 with self.__hb.nest('dd'):
-                    for _obj in shuffled(_obj_set):
+                    for _obj in _obj_set:
                         self.__obj(_obj)
 
+    def __order_twopledict(self, twopledict: rdf.RdfTwopleDictionary) -> Generator[tuple[str, list[rdf.RdfObject]]]:
+        _items_with_sorted_objs = (
+            (_pred, sorted(_obj_set, key=_obj_ordering_key))
+            for _pred, _obj_set in twopledict.items()
+            if _pred not in _PREDICATES_RENDERED_SPECIAL
+        )
+        yield from sorted(
+            _items_with_sorted_objs,
+            key=lambda _item: _obj_ordering_key(_item[1][0]),
+        )
+
     def __obj(self, obj: rdf.RdfObject) -> None:
         if isinstance(obj, str):  # iri
             # TODO: detect whether indexcard?
@@ -201,13 +219,15 @@ def __obj(self, obj: rdf.RdfObject) -> None:
                 with self.__hb.nest('article', attrs={'class': 'Browse__object'}):
                     self.__iri_link_and_labels(obj)
         elif isinstance(obj, frozenset):  # blanknode
-            if (RDF.type, RDF.Seq) in obj:
+            if _is_jsonapi_link_obj(obj):
+                self.__jsonapi_link_obj(obj)
+            elif _is_sequence_obj(obj):
                 self.__sequence(obj)
             else:
                 self.__blanknode(obj)
         elif isinstance(obj, rdf.Literal):
             self.__literal(obj, is_rdf_object=True)
-        elif isinstance(obj, (float, int, datetime.date)):
+        elif isinstance(obj, _PRIMITIVE_LITERAL_TYPES):
             self.__literal(rdf.literal(obj), is_rdf_object=True)
         elif isinstance(obj, rdf.QuotedGraph):
             self.__quoted_graph(obj)
@@ -250,31 +270,52 @@ def __sequence(self, sequence_twoples: frozenset[rdf.RdfTwople]) -> None:
 
     def __quoted_graph(self, quoted_graph: rdf.QuotedGraph) -> None:
         with self.__quoted_data(quoted_graph.tripledict):
-            self.__render_subj(quoted_graph.focus_iri)  # , start_collapsed=True)
+            self.__render_subj(
+                quoted_graph.focus_iri,
+                should_link_details=(quoted_graph.focus_iri not in self.response_focus.iris)
+            )
 
     def __blanknode(self, blanknode: rdf.RdfTwopleDictionary | frozenset) -> None:
         _twopledict = (
             blanknode
             if isinstance(blanknode, dict)
             else rdf.twopledict_from_twopleset(blanknode)
         )
-        with self.__hb.nest('details', attrs={
-            'open': '',
-            'class': 'Browse__blanknode Browse__object',
-            'style': self._hue_turn_css(),
-        }):
-            self.__hb.leaf('summary', text='(blank node)')
+        with (
+            self._hue_turn_css() as _hue_turn_style,
+            self.__hb.nest('details', attrs={
+                'open': '',
+                'class': 'Browse__blanknode Browse__object',
+                'style': _hue_turn_style,
+            }),
+        ):
+            with self.__hb.nest('summary'):
+                for _type_iri in _twopledict.get(RDF.type, ()):
+                    self.__compact_link(_type_iri)
             self.__twoples(_twopledict)
 
+    def __jsonapi_link_obj(self, twopleset: frozenset[rdf.RdfTwople]) -> None:
+        _iri = next(
+            (str(_obj) for (_pred, _obj) in twopleset if _pred == RDF.value),
+            '',
+        )
+        _text = next(
+            (_obj.unicode_value for (_pred, _obj) in twopleset if _pred == jsonapi.JSONAPI_MEMBERNAME),
+            '',
+        )
+        with self.__nest_link(_iri, attrs={'class': 'Browse__blanknode Browse__object'}) as _a:
+            _a.text = _('link: %(linktext)s') % {'linktext': _text}
+
     def __split_iri_pre(self, iri: str) -> None:
         self.__hb.leaf('pre', text='\n'.join(self.__iri_lines(iri)))
 
     @contextlib.contextmanager
-    def __visiting(self, iri: str) -> Iterator[None]:
+    def __visiting(self, iri: str) -> Generator[str]:
         assert iri not in self.__visiting_iris
         self.__visiting_iris.add(iri)
         try:
-            yield
+            with self.__hb.deeper_heading() as _h_tag:
+                yield _h_tag
         finally:
             self.__visiting_iris.remove(iri)
 
@@ -295,27 +336,35 @@ def __iri_link_and_labels(self, iri: str) -> None:
         for _text in self.__iri_thesaurus_labels(iri):
             self.__literal(_text)
 
-    def __nest_link(self, iri: str) -> contextlib.AbstractContextManager[Element]:
+    def __nest_link(self, iri: str, attrs: dict[str, str] | None = None) -> contextlib.AbstractContextManager[Element]:
         _href = (
             iri
             if _is_local_url(iri)
             else trove_browse_link(iri)
         )
-        return self.__hb.nest('a', attrs={'href': _href})
+        return self.__hb.nest('a', attrs={**(attrs or {}), 'href': _href})
 
     def __compact_link(self, iri: str) -> Element:
         with self.__nest_link(iri) as _a:
-            _a.text = self.iri_shorthand.compact_iri(iri)
+            _shorthanded = self.iri_shorthand.compact_iri(iri)
+            if (_shorthanded == iri) and _is_local_url(iri):
+                _shorthanded = f'/{iri.removeprefix(settings.SHARE_WEB_URL)}'
+            _a.text = _shorthanded
         return _a
 
-    def __nest_card(self, tag: str) -> contextlib.AbstractContextManager[Element]:
-        return self.__hb.nest(
-            tag,
-            attrs={
-                'class': 'Browse__card',
-                'style': self._hue_turn_css(),
-            },
-        )
+    @contextlib.contextmanager
+    def __nest_card(self, tag: str) -> Generator[Element]:
+        with (
+            self._hue_turn_css() as _hue_turn_style,
+            self.__hb.nest(
+                tag,
+                attrs={
+                    'class': 'Browse__card',
+                    'style': _hue_turn_style,
+                },
+            ) as _element,
+        ):
+            yield _element
 
     def __iri_thesaurus_labels(self, iri: str) -> list[str]:
         # TODO: consider requested language
@@ -331,10 +380,15 @@ def __iri_thesaurus_labels(self, iri: str) -> list[str]:
                 _labels.update(_twoples.get(_pred, ()))
         return shuffled(_labels)
 
-    def _hue_turn_css(self) -> str:
-        _hue_turn = (self.__last_hue_turn + _PHI) % 1.0
+    @contextlib.contextmanager
+    def _hue_turn_css(self) -> Generator[str]:
+        _prior_turn = self.__last_hue_turn
+        _hue_turn = (_prior_turn + _PHI) % 1.0
         self.__last_hue_turn = _hue_turn
-        return f'--hue-turn: {_hue_turn}turn;'
+        try:
+            yield f'--hue-turn: {_hue_turn}turn;'
+        finally:
+            self.__last_hue_turn = _prior_turn
 
     def _queryparam_href(self, param_name: str, param_value: str | None) -> str:
         _base_url = self.response_focus.single_iri()
@@ -367,7 +421,7 @@ def __iri_subheaders(self, iri: str) -> None:
             for _label in _labels:
                 self.__literal(_label)
 
-    def __iri_lines(self, iri: str) -> Iterator[str]:
+    def __iri_lines(self, iri: str) -> Generator[str]:
         (_scheme, _netloc, _path, _query, _fragment) = urlsplit(iri)
         yield (
             f'://{_netloc}{_path}'
@@ -389,3 +443,25 @@ def _append_class(el: Element, element_class: str) -> None:
 
 def _is_local_url(iri: str) -> bool:
     return iri.startswith(settings.SHARE_WEB_URL)
+
+
+def _is_sequence_obj(obj: rdf.RdfObject) -> bool:
+    return (
+        isinstance(obj, frozenset)
+        and (RDF.type, RDF.Seq) in obj
+    )
+
+
+def _is_jsonapi_link_obj(obj: rdf.RdfObject) -> bool:
+    return (
+        isinstance(obj, frozenset)
+        and (RDF.type, jsonapi.JSONAPI_LINK_OBJECT) in obj
+    )
+
+
+def _obj_ordering_key(obj: rdf.RdfObject) -> tuple[bool, ...]:
+    return (
+        not isinstance(obj, (rdf.Literal, *_PRIMITIVE_LITERAL_TYPES)),  # literal values first
+        not isinstance(obj, str),  # iris next
+        _is_jsonapi_link_obj(obj),  # jsonapi link objects last
+    )

trove/static/css/browse.css

@@ -65,9 +65,12 @@
 .Browse__card > header {
     display: flex;
     flex-direction: row;
-    gap: var(--gutter-2);
+    flex-wrap: wrap;
+    gap: var(--gutter-3);
     align-items: baseline;
     border-bottom: solid 1px rgba(0,0,0,0.382);
+    padding-bottom: var(--gutter-3);
+    padding-left: var(--gutter-3);
     margin-bottom: var(--gutter-3);
 }
 

trove/trovebrowse_gathering.py

@@ -39,14 +39,21 @@
 def gather_cards_focused_on(focus: gather.Focus, *, blend_cards: bool) -> GathererGenerator:
     _identifier_qs = trove_db.ResourceIdentifier.objects.queryset_for_iris(focus.iris)
     _indexcard_qs = trove_db.Indexcard.objects.filter(focus_identifier_set__in=_identifier_qs)
+    _lrd_qs = (
+        trove_db.LatestResourceDescription.objects
+        .filter(indexcard__in=_indexcard_qs)
+        .select_related('indexcard')
+    )
     if blend_cards:
-        for _latest_resource_description in trove_db.LatestResourceDescription.objects.filter(indexcard__in=_indexcard_qs):
-            yield from rdf.iter_tripleset(_latest_resource_description.as_rdf_tripledict())
+        for _resource_description in _lrd_qs:
+            yield from rdf.iter_tripleset(_resource_description.as_rdf_tripledict())
+            yield (ns.FOAF.isPrimaryTopicOf, _resource_description.indexcard.get_iri())
     else:
-        for _indexcard in _indexcard_qs:
-            _card_iri = _indexcard.get_iri()
+        for _resource_description in _lrd_qs:
+            _card_iri = _resource_description.indexcard.get_iri()
             yield (ns.FOAF.isPrimaryTopicOf, _card_iri)
             yield (_card_iri, ns.RDF.type, ns.TROVE.Indexcard)
+            yield (_card_iri, ns.TROVE.resourceMetadata, _resource_description.as_quoted_graph())
 
 
 @trovebrowse.gatherer(ns.TROVE.thesaurusEntry)