jekyll rdf
4.2.4
Ein Jekyll -Plugin für die Aufnahme von RDF -Daten in Ihre statische Website.
Die API -Dokumentation ist unter Rubydoc.info verfügbar.
Docker Es gibt ein Docker -Bild, schauen Sie sich die Docker -Nutzung an.
Als Voraussetzung für Jekylll RDF müssen Sie natürlich Jekyll installieren. Bitte sehen Sie sich die Installationsanweisungen unter https://jekylllrb.com/docs/installation/ an.
Wenn Sie bereits über eine funktionierende Jekyll-Installation verfügen, können Sie das Jekyll-RDF-Plugin hinzufügen. Wahrscheinlich verwenden Sie bereits Bundler und in Ihrem Jekyll -Verzeichnis gibt es eine Gemfile . Fügen Sie dem Abschnitt "Plugins" Jekyll-RDF hinzu:
gem "jekyll-rdf", "~> 3.2"
Ersetzen Sie die Versionszeichenfolge durch die aktuell verfügbare stabile Version, die auf RubyGems.org aufgeführt ist. Nachdem Sie Ihr Gemfile aktualisiert haben, möchten Sie wahrscheinlich bundle install (oder bundle install --path vendor/bundle ) oder bundle update .
Wenn Sie keine Gemfile verwenden, um Ihre Jekyll/Ruby-Pakete zu verwalten, installieren Sie Jekyll-RDF mit gem :
gem install jekyll-rdf
Wenn Sie das Plugin aus der Quelle erstellen möchten, schauen Sie sich bitte unseren Entwicklungsabschnitt an.
In diesem Abschnitt wird erläutert, wie Jekyll-RDF in drei Schritten verwendet wird:
Alle Filter und Methoden, die in Vorlagen und Konfigurationsoptionen verwendet werden sollen, sind im Abschnitt „Parameter und Konfigurationsoptionen auf einen Blick“ dokumentiert.
Erstens brauchen Sie eine Jekyll -Seite. Um einen zu erstellen, tun Sie einfach:
jekyll new my_page
cd my_page
Darüber hinaus sind einige Parameter in Ihrem _config.yml für jekyll-rdf erforderlich. IE Die Parameter url und baseurl werden verwendet, um die Ressourcenseiten in die Stammfläche der Site aufzunehmen, das Plug-In muss konfiguriert und der Pfad zur RDF-Datei vorhanden sein.
baseurl : " /simpsons "
url : " http://example.org "
plugins :
- jekyll-rdf
jekyll_rdf :
path : " _data/data.ttl "
default_template : " default.html "
restriction : " SELECT ?resourceUri WHERE { ?resourceUri ?p ?o . FILTER regex(str(?resourceUri), 'http://example.org/simpsons') } "
class_template_mappings :
" http://xmlns.com/foaf/0.1/Person " : " person.html "
instance_template_mappings :
" http://example.org/simpsons/Abraham " : " abraham.html " Die url + baseurl wird von Jekyll RDF verwendet, um sich relativ zu der URL zu identifizieren, die die RDF -Ressourcenseiten erstellen sollten. Im obigen Beispiel bedeutet dies, dass eine Ressource mit dem IRI <http://example.org/simpsons/Bart> in den path /Bart.html gerendert wird. Auch andere Funktionen und Plugins für Jekyll hängen von diesen beiden Parametern ab. Wenn sich die beiden Parameter für jeden Fall vom Basispfad unterscheiden, den Jekyll RDF annehmen sollte, ist es möglich, den Parameter baseiri im Abschnitt jekyll_rdf festzulegen.
baseurl : " /simpsons "
url : " https://beispiel.com "
jekyll_rdf :
baseiri : " http://example.org/ "Es ist möglich, eine bestimmte Klasse (bzw. RDF-Typ) oder einzelne Ressourcen einer Vorlage zuzuordnen.
class_template_mappings :
" http://xmlns.com/foaf/0.1/Person " : " person.html "
instance_template_mappings :
" http://aksw.org/Team " : " team.html "Eine vorliegende Vorlage wird verwendet, um jede Instanz dieser Klasse und ihrer Unterklassen zu rendern. Jede Instanz wird mit seiner spezifischsten Klasse auf eine Vorlage zugeordnet. Wenn die Zuordnung für eine Ressource mehrdeutig ist, wird eine Warnung in Ihr Befehlsfenster ausgegeben. Achten Sie also darauf!
Es ist auch möglich, eine Standardvorlage zu definieren, die für alle Ressourcen verwendet wird, die nicht von den class_template_mappings oder instance_template_mappings abgedeckt werden.
default_template : " default.html " Sie können die ausgewählten Ressourcen einschränken, die durch Hinzufügen einer Sparql -Abfrage als restriction zu _config.yml hinzugefügt werden. Bitte verwenden Sie ?resourceUri als Platzhalter für die resultierende URIs:
restriction : " SELECT ?resourceUri WHERE { ?resourceUri <http://www.ifi.uio.no/INF3580/family#hasFather> <http://www.ifi.uio.no/INF3580/simpsons#Homer> } "Es gibt 3 vordefinierte Schlüsselwörter für Einschränkungen implementiert:
subjects laden alle Probanden -URIspredicates laden alle Prädikat -URIsobjects laden alle Objekt -URIs Da einige SparQL -Endpunkte eine integrierte Grenze für ausgewählte Abfragen haben, können Sie auch eine Liste von Ressourcen definieren, die erstellt werden sollen. Eine Datei _data/restriction.txt Cool hat den folgenden Inhalt:
<http://example.org/resourceA>
<http://example.org/resourceB>
<http://example.org/resourceC>
<http://example.org/resourceD>
<http://example.org/resourceE>
In der _config.yml geben Sie die Datei mit der restriction_file an. Wenn beide, eine restriction_file und eine restriction , werden Jekyll RDF für die Vereinigung der beiden Seiten aufgebaut.
Darüber hinaus können Sie entscheiden, ob Sie leere Knoten rendern möchten oder nicht. Sie müssen nur include_blank zu _config.yml hinzufügen:
jekyll_rdf :
include_blank : true Schließlich ist es auch möglich, eine bevorzugte Sprache für die RDF-Literale mit der language festzulegen:
jekyll_rdf :
language : " en " Durch das Ausführen von jekyll build wird die RDF -Ressourcen für das Verzeichnis _site/… verteilt. Das Ausführen von jekyll serve macht die RDF-Ressourcen und bietet Ihnen einen sofortigen HTTP-Server, der normalerweise unter http://localhost:4000/ zugänglich ist. RDF -Ressourcen, deren Iris nicht mit der konfigurierten Jekyll url und baseurl (bzw. baseiri ) beginnen, werden an das _site/rdfsites/… Sub -Verzeichnis gerendert.
Um die RDF -Daten zu verwenden, erstellen Sie eine oder mehrere Dateien (z. B. rdf_index.html oder person.html ) im _layouts -Verzeichnis. Für jede Ressource wird eine Seite gerendert. Siehe Beispiel unten:
---
layout: default
---
< div class =" home " >
< h1 class =" page-heading " > < b > {{ page.rdf.iri }} </ b > </ h1 >
< p >
< h3 > Statements in which {{ page.rdf.iri }} occurs as subject: </ h3 >
{% include statements_table.html collection=page.rdf.statements_as_subject %}
</ p >
< p >
< h3 > Statements in which {{ page.rdf.iri }} occurs as predicate: </ h3 >
{% include statements_table.html collection=page.rdf.statements_as_predicate %}
</ p >
< p >
< h3 > Statements in which {{ page.rdf.iri }} occurs as object: </ h3 >
{% include statements_table.html collection=page.rdf.statements_as_object %}
</ p >
</ div >Wir haben einige Vorlagenbeispiele bei aufgenommen
test/source/_layouts/rdf_index.htmltest/source/_layouts/person.html {{ page.rdf }}
Ist die derzeit gerenderte Ressource.
{{ page.rdf.iri }}
Gibt den IRI der derzeit gerenderten Ressource zurück.
Um auf Objekte zuzugreifen, die über ein Prädikat mit dem aktuellen Subjekt verbunden sind, können Sie unsere benutzerdefinierten Flüssigkeitsfilter verwenden. Für einzelne Objekte oder Listen von Objekten verwenden Sie den rdf_property -filter (siehe 1 und 2).
So greifen Sie auf ein Objekt zu rdf_property page.rdf . Beispiel:
Age: {{ page.rdf | rdf_property: '<http://xmlns.com/foaf/0.1/age>' }}
Um eine bestimmte Sprache auszuwählen, fügen Sie dem Filter bitte einen zweiten Parameter hinzu:
Age: {{ page.rdf | rdf_property: '<http://xmlns.com/foaf/0.1/job>','en' }}
Um mehr als ein Objekt über ein bestimmtes Prädikat mit dem aktuellen Subjekt in Verbindung zu bringen, verwenden Sie bitte den Filter rdf_property in Verbindung mit einem dritten Argument, das auf true festgelegt ist (das zweite Argument für die Sprache kann ausgelassen werden, indem es auf nil festgelegt wird):
Sisters: < br />
{% assign resultset = page.rdf | rdf_property: ' < http: //www.ifi.uio.no/INF3580/family#hasSister > ', nil, true %}
< ul >
{% for result in resultset %}
< li > {{ result }} </ li >
{% endfor %}
</ ul >Um eine bestimmte Sprache auszuwählen, fügen Sie dem Filter bitte einen zweiten Parameter hinzu:
Book titles: < br />
{% assign resultset = page.rdf | rdf_property: ' < http: //xmlns.com/foaf/0.1/currentProject > ','de' %}
< ul >
{% for result in resultset %}
< li > {{ result }} </ li >
{% endfor %}
</ ul > Um RDF -Container und RDF -Sammlungen zu unterstützen, stellen wir die Filter rdf_container und rdf_collection bereit.
In beiden Fällen die jeweilige Containerressource resp. Der Sammelkopf muss identifiziert und dann durch den jeweiligen Filter weitergegeben werden. Für Container unterstützen wir derzeit explizite Instanzen von rdf:Bag , rdf:Seq und rdf:Alt mit den mit den rdfs:ContainerMembershipProperty S: rdf:_1 , rdf:_2 , rdf:_3 …. Sammlungen werden mit rdf:first identifiziert, rdf:rest und mit L rdf:rest rdf:nil beendet. Da der Kopf einer Sammlung identifiziert werden muss, können Sie dort keinen leeren Knoten verwenden, Sie können ihn indirekt über das Prädikat identifizieren, das die Sammlung enthält.
Beispielgrafik:
@prefix ex: <http://example.org/> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
ex:Resource ex:lists ex:List ;
ex:directList ("hello" "from" "turtle") .
ex:hasContainer ex:Container .
ex:List rdf:first "hello" ;
rdf:rest ("rdf" "list") .
ex:Container a rdf:Bag ;
rdf:_1 "hello" ;
rdf:_2 "rdf" ;
rdf:_3 "container" .
Die Vorlage für ex:Resource :
{% assign list = page.rdf | rdf_collection: '<http://example.org/directList>' %}
<ol>
{% for item in list %}
<li>{{ item }}</li>
{% endfor %}
</ol>
{% assign container = page.rdf | rdf_property: '<http://example.org/hasContainer>' | rdf_container %}
<ul>
{% for item in container %}
<li>{{ item }}</li>
{% endfor %}
</ul>
Wir haben einen flüssigen Filter sparql_query implementiert, um benutzerdefinierte Sparql -Abfragen auszuführen. Jedes Auftreten von ?resourceUri wird durch die aktuelle URI ersetzt. VORSICHT: Sie müssen Anfragen und Ergebnis -Set -Variablen aufgrund von Flüssigkeitskonzepten trennen. Beispiel:
{% assign query = 'SELECT ?sub ?pre WHERE { ?sub ?pre ?resourceUri }' %}
{% assign resultset = page.rdf | sparql_query: query %}
< table >
{% for result in resultset %}
< tr >
< td > {{ result.sub }} </ td >
< td > {{ result.pre }} </ td >
</ tr >
{% endfor %}
</ table > Es ist möglich, eine Reihe von Präfixen zu deklarieren, die in den Flüssigkeitsfiltern rdf_property und sparql_query verwendet werden können. Dadurch können Sie die für jeden Flüssigkeitsfilter erforderliche Textmenge verkürzen. Die Syntax der Präfixerklärungen ist dieselbe wie für SPARQL 1.1. Fügen Sie einfach Ihre Präfixe in eine separate Datei ein und fügen Sie den wichtigsten rdf_prefix_path zusammen mit einem relativen Pfad in die YAML -Front -Angelegenheit einer Datei ein, in der Ihre Präfixe verwendet werden sollten.
Für die Präfixe gelten dieselben Regeln wie für andere in der Yaml Front Matter definierte Variablen. Diese Variablen stehen Ihnen dann zur Verfügung, um mit Flüssigkeits -Tags weiter unten in der Datei und in beliebigen Layouts zuzugreifen oder auf die Seite oder die betreffende Seite zu berücksichtigen. (Quelle: Yaml Front Materie). Dies ist insbesondere relevant, wenn Sie Präfixe in einschließlich der Includen verwenden.
Wenn die URI einer Ressource eine Fragmentkennung ( #… ) enthält, kann die Ressource zusammen mit anderen Ressourcen mit derselben Basis -URI bis zur Fragment -Identifikator auf einer einzelnen Seite gehostet werden. Die Seite wird über die Basis -URI zugänglich, während in der Vorlage die einzelnen URIs mit einer Fragmentkennung über die page.sub_rdf .
Beispiel
Im _config.yml :
' instance_template_mappings ' :
' http://www.ifi.uio.no/INF3580/simpsons ' : 'family.html' In _layouts/family.html :
{% for member in page.sub_rdf%}
{% include simPerson.html person = member%}
{% endfor %} http://www.ifi.uio.no/INF3580/simpsons Beispiel verwendet die family.html http://www.ifi.uio.no/INF3580/simpsons# http://www.ifi.uio.no/INF3580/simpsons selbst. Jekyll-rdf sammelt subResources Ressourcen mit einer superResource in ihrem URI (von hier aus als subResources ) und übergibt sie über page.sub_rdf ).
Jede Ressource, die von einem der Filter von jekyll-rdf zurückgegeben wird, ist ein Objekt, das Flüssigkeit auch wie eine Zeichenfolge verarbeiten kann. Sie alle haben die folgenden Methoden, die in Flüssigkeit verwendet werden können.
Geben Sie eine Liste von Aussagen zurück, deren Thema die aktuelle Ressource ist. Die Aussagen in der zurückgegebenen Liste können durch Statement.object Bekämpfung ihrer Positionen zugegriffen werden: Statement.subject , Statement.predicate .
Geben Sie eine Liste von Aussagen zurück, deren Prädikat die aktuelle Ressource ist. Die Aussagen in der zurückgegebenen Liste können durch Statement.object Bekämpfung ihrer Positionen zugegriffen werden: Statement.subject , Statement.predicate .
Geben Sie eine Liste von Aussagen zurück, deren Objekt die aktuelle Ressource ist. Die Aussagen in der zurückgegebenen Liste können durch Statement.object Bekämpfung ihrer Positionen zugegriffen werden: Statement.subject , Statement.predicate .
Geben Sie die URL der Seite zurück, die diese rdfresource darstellt.
Geben Sie den Pfad auf die Seite zurück, die diese rdfresource darstellt. Verwenden Sie es mit Vorsicht.
Dieses Attribut ist relevant, um Seiten für IRIs zu rendern, die eine Fragment -Kennung enthalten ( http://superresource#anchor ). Dieses Attribut gilt für die Superresource ( http://superresource ), wenn es tatsächlich in der gegebenen Wissensbasis beschrieben wird.
In diesem Attribut wird angegeben, ob die jeweilige Instanz einer Ressource im Kontext der aktuellen Site -Erzeugung gerendert wird. Nutzung: {% if resource.rendered? %}…{% endif %} .
Gibt eine ausführliche Zeichenfolge zurück, die diese Ressource darstellt.
Synopsis: <resource_iri> | rdf_get
Parameter:
<resource_iri> ist eine Zeichenfolge, die eine RDF -Ressource mit Präfix ( prefix:name ) oder einem vollständigen IRI ( <http://ex.org/name> ) darstellt. Um die Ressource der aktuellen Seite zu verweisen, verwenden Sie Seite. page.rdf , page oder nil .Beschreibung: Nimmt das bereitgestellte IRI und gibt das entsprechende RDFresource -Objekt aus Ihrer Wissensbasis zurück. Bei diesem Objekt können Sie die Methoden wie in der Abschnittsressource beschrieben aufrufen.
Beispiel:
{{'<http://www.ifi.uio.no/INF3580/simpsons>' | rdf_get }}
Ergebnis:
http://www.ifi.uio.no/INF3580/simpsons Synopsis: <rdf_resource> OR <rdf_resource_string> | rdf_property: <property>, [<lang>] OR [<lang>, <list>] OR [nil, <list>]
Parameter:
<rdf_resource> ist eine rdfresource. Um die Ressource der aktuellen Seite zu verweisen, verwenden Sie page.rdf , page oder nil .<rdf_resource_string> ist eine Zeichenfolge, die den IRI von <rdf_resource> darstellt.<property> ist eine Zeichenfolge, die ein RDF -Prädikat darstellt, mit Präfix ( prefix:name ) oder einem vollständigen IRI ( <http://ex.org/name> ).<lang> ist ein Sprach -Tag (z. B. de ). Wenn dieser Parameter weggelassen wird, ersetzen Sie ihn durch nil .<list> ist ein boolescher Wert ( true , false ). Beschreibung: Gibt das Objekt des Triple <rdf_resource> <predicate> ?object zurück. Das zurückgegebene Objekt kann durch die Art, Ressource, wörtliche oder leere Knoten.
Beispiel (Standard):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_get %}
{{ resource | rdf_property: '<http://xmlns.com/foaf/0.1/job>' }}
Ergebnis:
"unknown"Beispiel (Zeichenfolge):
{{ '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_property: '<http://xmlns.com/foaf/0.1/job>' }}
Ergebnis:
"unknown"Beispiel (mit Sprache):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_get %}
{{ resource | rdf_property: '<http://xmlns.com/foaf/0.1/job>', 'de' }}
Ergebnis:
"unbekannt"Beispiel (Rückgabe als Liste):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_get %}
{% assign resultset = resource | rdf_property: '<http://xmlns.com/foaf/0.1/job>', nil, true %}
{% for result in resultset %}
<li>{{ result }}</li>
{% endfor %}
Ergebnis:
< li > "unknown" </ li >
< li > "unbekannt" </ li >
< li > "unbekannter Job 2" </ li >
< li > "unknown Job 2" </ li > Synopsis: <rdf_resource> OR <rdf_resource_string>| rdf_inverse_property: <property>, [<list>]
Parameter:
<rdf_resource> ist eine rdfresource. Um die Ressource der aktuellen Seite zu verweisen, verwenden Sie page.rdf , page oder nil .<rdf_resource_string> ist eine Zeichenfolge, die den IRI von <rdf_resource> darstellt.<property> ist eine Zeichenfolge, die ein RDF -Prädikat darstellt, mit Präfix ( prefix:name ) oder einem vollständigen IRI ( <http://ex.org/name> ).<list> ist ein boolescher Wert ( true , false ). Beschreibung: Gleich wie rdf_property, aber in umgekehrter Richtung. Es gibt das Thema des Triple ?subject <predicate> <rdf_resource> zurück. Das zurückgegebene Objekt kann durch die Art, Ressource oder leere Knoten.
Beispiele (Standard):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_get %}
{{ page.rdf | rdf_inverse_property: '<http://www.ifi.uio.no/INF3580/family#hasFather>' }}
Ergebnis:
http://www.ifi.uio.no/INF3580/simpsons#BartBeispiele (Zeichenfolge):
{{ '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_inverse_property: '<http://www.ifi.uio.no/INF3580/family#hasFather>' }}
Ergebnis:
http://www.ifi.uio.no/INF3580/simpsons#BartBeispiel (als Liste):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_get %}
{% assign resultset = resource | rdf_property: '<http://www.ifi.uio.no/INF3580/family#hasFather>', true %}
{% for result in resultset %}
<li>{{ result }}</li>
{% endfor %}
Ergebnis:
http://www.ifi.uio.no/INF3580/simpsons#Bart
http://www.ifi.uio.no/INF3580/simpsons#Lisa
http://www.ifi.uio.no/INF3580/simpsons#Maggie Synopsis: <rdf_resource> | sparql_query: <query> oder <reference_array> | sparql_query: <query> oder <query> | sparql_query
Parameter:
<rdf_resource> Ist eine rdfresource, die in der Abfrage ?resourceUri ersetzt wird. page diesen Parameter wegzulassen oder nil die Ressource der aktuellen Seite page.rdf verweisen.<reference_array> Ein Array, das Iris als Zeichenfolgen oder rdf_resource enthält. Sie werden jeweils ?resourceUri_<index> in Ihrer Abfrage ersetzen.<query> eine Zeichenfolge mit einer Sparql -Abfrage. Beschreibung: Bewertet query in der angegebenen Wissensbasis und gibt eine Reihe von Ergebnissen zurück (Ergebnismenge). Jedes Einstiegsobjekt im Ergebnissatz (Ergebnis) enthält die ausgewählten Variablen als Ressourcen oder Literale. Sie können verwenden ?resourceUri in der Abfrage, um auf die Ressource zu verweisen, die als <rdf_resource> angegeben ist.
Beispiel (Seite)
<!--Rendering the page of resource Lisa -->
{% assign query = 'SELECT ?sub ?pre WHERE { ?sub ?pre ?resourceUri }' %}
{% assign resultset = page.rdf | sparql_query: query %}
<table>
{% for result in resultset %}
<tr><td>{{ result.sub }}</td><td>{{ result.pre }}</td></tr>
{% endfor %}
</table>
Ergebnis:
< table >
< tr > < td > http://www.ifi.uio.no/INF3580/simpsons#TheSimpsons </ td > < td > http://www.ifi.uio.no/INF3580/family#hasFamilyMember </ td > </ tr >
< tr > < td > http://www.ifi.uio.no/INF3580/simpsons#Bart </ td > < td > http://www.ifi.uio.no/INF3580/family#hasSister </ td > </ tr >
< tr > < td > http://www.ifi.uio.no/INF3580/simpsons#Maggie </ td > < td > http://www.ifi.uio.no/INF3580/family#hasSister </ td > </ tr >
...Beispiel (Array)
{% assign query = 'SELECT ?x WHERE {?resourceUri_0 ?x ?resourceUri_1}' %}
{% assign array = "<http://www.ifi.uio.no/INF3580/simpsons#Homer>,<http://www.ifi.uio.no/INF3580/simpsons#Marge>" | split: %}
{% assign resultset = array | sparql_query: query %}
<table>
{% for result in resultset %}
<tr><td>{{ result.x }}</td></tr>
{% endfor %}
</table>
Ergebnis:
<table>
<tr><td>http://www.ifi.uio.no/INF3580/family#hasSpouse</td></tr>
</table>
Beispiel (Abfrage)
{% assign query = 'SELECT ?x WHERE {<http://www.ifi.uio.no/INF3580/simpsons#Homer> ?x <http://www.ifi.uio.no/INF3580/simpsons#Marge>}' %}
{% assign resultset = query | sparql_query %}
<table>
{% for result in resultset %}
<tr><td>{{ result.x }}</td></tr>
{% endfor %}
</table>
Ergebnis:
<table>
<tr><td>http://www.ifi.uio.no/INF3580/family#hasSpouse</td></tr>
</table>
Synopsis: <rdf_container_head> **OR** <rdf_container_head_string> | rdf_container
Parameter:
<rdf_container_head> ist eine rdfresource. Um auf die Ressource der aktuellen Seite zu verweisen, verwenden Sie Seite. page.rdf , page oder nil .<rdf_container_head_string> ist eine Zeichenfolge, die den IRI von <rdf_container_head> darstellt. Beschreibung: Gibt ein Array mit Ressourcen für jedes Element im Container zurück, dessen Kopf von rdf_container_head verwiesen wird.
Beispiele:
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpson-container#Container>' | rdf_get %}
{% assign array = resource | rdf_container %}
{% for item in array %}
{{ item }}
{% endfor %}
http://www.ifi.uio.no/INF3580/simpsons#Homer
http://www.ifi.uio.no/INF3580/simpsons#Marge
http://www.ifi.uio.no/INF3580/simpsons#Bart
http://www.ifi.uio.no/INF3580/simpsons#Lisa
http://www.ifi.uio.no/INF3580/simpsons#MaggieBeispiele: (Zeichenfolge)
{% assign array = '<http://www.ifi.uio.no/INF3580/simpson-container#Container>' | rdf_container %}
{% for item in array %}
{{ item }}
{% endfor %}
http://www.ifi.uio.no/INF3580/simpsons#Homer
http://www.ifi.uio.no/INF3580/simpsons#Marge
http://www.ifi.uio.no/INF3580/simpsons#Bart
http://www.ifi.uio.no/INF3580/simpsons#Lisa
http://www.ifi.uio.no/INF3580/simpsons#Maggie Synopsis: <rdf_collection_head> OR <rdf_collection_head_string> | rdf_collection oder <rdf_resource> | rdf_collection: "<property>"
Parameter:
<rdf_collection_head> ist eine rdfresource. Um auf die Ressource der aktuellen Seite zu verweisen, verwenden Sie Seite. page.rdf , page oder nil .<rdf_collection_head_string> ist eine Zeichenfolge, die den IRI von <rdf_collection_head> darstellt.<rdf_resource> ist eine rdfresource. Um auf die Ressource der aktuellen Seite zu verweisen, verwenden Sie Seite. page.rdf , page oder nil .<property> ist eine Zeichenfolge, die ein RDF -Prädikat darstellt, mit Präfix ( prefix:name ) oder einem vollständigen IRI ( <http://ex.org/name> ). Beschreibung: Gibt ein Array mit Ressourcen für jedes Element in der Sammlung zurück, dessen Kopf von rdf_collection_head referenziert wird. Anstatt direkt auf einen Kopf zu verweisen, ist es auch möglich, die Eigenschaft anzugeben, die auf den Sammelkopf verweist.
Beispiel (Kopfressource angeben):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpson-collection#Collection>' | rdf_get %}
{% assign array = resource | rdf_collection %}
{% for item in array %}
{{ item }}
{% endfor %}
Ergebnis:
http://www.ifi.uio.no/INF3580/simpsons#Homer
http://www.ifi.uio.no/INF3580/simpsons#Marge
http://www.ifi.uio.no/INF3580/simpsons#Bart
http://www.ifi.uio.no/INF3580/simpsons#Lisa
http://www.ifi.uio.no/INF3580/simpsons#MaggieBeispiel (Kopfzeichenfolge angeben):
{% assign array = '<http://www.ifi.uio.no/INF3580/simpson-collection#Collection>' | rdf_collection %}
{% for item in array %}
{{ item }}
{% endfor %}
Ergebnis:
http://www.ifi.uio.no/INF3580/simpsons#Homer
http://www.ifi.uio.no/INF3580/simpsons#Marge
http://www.ifi.uio.no/INF3580/simpsons#Bart
http://www.ifi.uio.no/INF3580/simpsons#Lisa
http://www.ifi.uio.no/INF3580/simpsons#MaggieBeispiel (über Eigenschaft angeben):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpsons>' | rdf_get %}
{% assign array = resource | rdf_collection: "<http://www.ifi.uio.no/INF3580/simpsons#familycollection>" %}
{% for item in array %}
{{ item }}
{% endfor %}
Ergebnis:
http://www.ifi.uio.no/INF3580/simpsons#Homer
http://www.ifi.uio.no/INF3580/simpsons#Marge
http://www.ifi.uio.no/INF3580/simpsons#Bart
http://www.ifi.uio.no/INF3580/simpsons#Lisa
http://www.ifi.uio.no/INF3580/simpsons#Maggie| Name | Parameter | Standard | Beschreibung | Beispiel |
|---|---|---|---|---|
| Weg | Relativer Weg zur RDF-Datei | Kein Standard | Gibt den Pfad zur RDF -Datei an, aus der Sie die Website rendern möchten | path: "rdf-data/simpsons.ttl" |
| Fernbedienung | Abschnitt zum Angeben einer Remotedatenquelle | Kein Standard | Muss den endpoint enthalten. Der remote -Parameter überschreibt den path . | |
| Remote> Endpunkt | SparQL -Endpunkt, um die Daten aus zu erhalten | Kein Standard | Gibt die URL zum Sparql -Endpunkt an, von dem Sie die Website rendern möchten | remote: endpoint: "http://localhost:5000/sparql/" |
| Remote> default_graph | Wählen Sie im Endpunkt ein benanntes Diagramm aus | Kein Standard | Gibt den IRI für das benannte Diagramm an, um aus dem Sparql -Endpunkt auszuwählen | remote: endpoint: "http://localhost:5000/sparql/" default_graph: "http://example.org/" |
| Sprache | Sprache als Zeichenfolge | Kein Standard | Gibt die bevorzugte Sprache an, wenn Sie Objekte mit unseren Flüssigfiltern auswählen | language: "en" |
| include_blank | Boolesche Expression | FALSCH | Gibt an, ob leere Knoten ebenfalls gerendert werden sollen oder nicht | include_blank: true |
| Beschränkung | Sparql-query als Zeichenfolge oder Subjekte/Objekte/Prädikate | Kein Standard | Schränkt die Ressourcenauswahl mit einem bestimmten Sparql-Query auf die an die spezielle Variablen gebundenen ?resourceUri oder die drei subjects (nur Subjekt-URIs), objects , predicates | restriction: "SELECT ?resourceUri WHERE { ?resourceUri <http://www.ifi.uio.no/INF3580/family#hasFather> <http://www.ifi.uio.no/INF3580/simpsons#Homer> }" |
| Restriktion_file | Datei mit Ressourcen zu rendern | Kein Standard | Beschränkt die Ressourcenauswahl auf die Liste der Ressourcen in der Datei | restriction_file: _data/restriction.txt |
| default_template | Dateiname des Standard-RDF-Template im Verzeichnis _layouts | Kein Standard | Gibt die Template-Datei an, die Jekyll verwenden soll, um alle RDF-Ressourcen zu rendern | default_template: "rdf_index.html" |
| Instance_Template_Mappings | Ziel URI als Zeichenfolge: Dateiname der Vorlage als Zeichenfolge | Kein Standard | Karten gegeben URI | instance_template_mappings: "http://www.ifi.uio.no/INF3580/simpsons#Abraham": "abraham.html" |
| class_template_mappings | Ziel URI als Zeichenfolge: Dateiname der Vorlage als Zeichenfolge | Kein Standard | Karten gegeben URI | class_template_mappings: "http://xmlns.com/foaf/0.1/Person": "person.html" |
Es gibt auch ein Docker/Podman-Bild, das Jekyll und Jekyll-Rdf vorinstalliert hat. Sie können es bekommen mit:
docker pull ghcr.io/aksw/jekyll-rdf:latest
und leiten Sie es mit mit
docker run --rm --workdir /page -v $PWD:/page ghcr.io/aksw/jekyll-rdf:latest
oder die Jekyll -Ausführung mit anpassen
docker run --rm --workdir /page -v $PWD/sources:/page -v $PWD/build/jekyll:/build ghcr.io/aksw/jekyll-rdf:latest jekyll build -d /build
Der Einstiegspunkt des Bildes führt bundle install zuerst und ausgeführt dann bundle exec jekyll build oder bundle exec <your command> . Um die installierten Pakete zwischen den Läufen zu halten, geben Sie die Umgebungsvariable BUNDLE_PATH an einem Ort an, der zwischen den Läufen anhält, z -e BUNDLE_PATH=.vendor . Um das gesamte Bundler-Zeug zu deaktivieren, NO_BUNDLER auf einen nicht leeren Wert eingestellt ist, wird der Einstiegspunkt Ihren Befehl so ausgeführt, wie er ist.
| Name | Standard | Beschreibung |
|---|---|---|
BUNDLE_PATH | ungehindert | Stellen Sie den Pfad ein, auf dem Bundler die Pakete installiert. Siehe auch die Bundler -Dokumente. |
NO_BUNDLER | ungehindert | Einen nicht leeren Wert einstellen, um alle Bundlerteile im Einstiegspunkt zu deaktivieren |
Um das Projekt mit dem Git-Repository zu installieren, benötigen Sie git in Ihrem System. Der erste Schritt ist nur das Klonen des Repositorys:
git clone [email protected]:AKSW/jekyll-rdf.git
Ein Ordner namens jekyll-rdf wird automatisch generiert. Sie müssen in diesen Ordner wechseln und das Ruby -Gem zusammenstellen, um die Installation zu beenden:
cd jekyll-rdf
gem build jekyll-rdf.gemspec
gem install jekyll-rdf -*.gem
bundle exec rake test
Jedes Mal, wenn die Tests durchgeführt werden, wird die Jekyll -Seite innerhalb von test/source verarbeitet. Starten Sie einen schlanken http.server , um die Ergebnisse im Webbrowser, z SimpleHTTPServer
cd test/source/_site
python -m SimpleHTTPServer 8000
Um das API jekyll-rdf/lib DOC zu generieren
gem install yard
yardoc *
Die generierte Dokumentation wird in jekyll-rdf/lib/doc -Verzeichnis eingereicht.
Jekyll-RDF ist unter der MIT-Lizenz lizenziert.
