jekyll rdf
4.2.4
Un plugin Jekyll pour inclure des données RDF dans votre site statique.
La documentation de l'API est disponible sur rubydoc.info.
Docker Il y a une image Docker, consultez l'utilisation de Docker de la section.
En tant que condition préalable pour Jekyll RDF, vous devez bien sûr installer Jekyll . Veuillez jeter un œil aux instructions d'installations sur https://jekyllrb.com/docs/installation/.
Si vous avez déjà une installation Jekyll fonctionnelle, vous pouvez ajouter le plugin Jekyll-RDF. Vous utilisez probablement déjà Bundler et il y a un Gemfile dans votre répertoire Jekyll. Ajouter Jekyll-RDF à la section Plugins:
gem "jekyll-rdf", "~> 3.2"
Remplacez la chaîne de version par la version stable actuellement disponible comme indiqué sur rubygems.org. Après la mise à jour de votre Gemfile , vous souhaitez probablement exécuter bundle install (ou bundle install --path vendor/bundle ) ou bundle update .
Si vous n'utilisez pas de Gemfile pour gérer vos packages Jekyll / Ruby Installez Jekyll-RDF à l'aide gem :
gem install jekyll-rdf
Si vous souhaitez construire le plugin à partir de Source, veuillez consulter notre section de développement.
Cette section explique comment utiliser Jekyll-RDF en trois étapes:
Tous les filtres et méthodes à utiliser dans les modèles et les options de configuration sont documentés dans la section «Paramètres et options de configuration en un coup d'œil».
Tout d'abord, vous avez besoin d'une page Jekyll. Afin d'en créer un, faites-le:
jekyll new my_page
cd my_page
De plus, certains paramètres sont requis dans votre _config.yml pour jekyll-rdf . IE Les paramètres url et baseurl sont utilisés pour inclure les pages de ressources dans la racine du site, le plug-in doit être configuré et le chemin d'accès au fichier RDF doit être présent.
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 " L' url + baseurl est utilisée par Jekyll RDF pour identifier par rapport à l'URL elle devrait créer les pages de ressources RDF. Dans l'exemple ci-dessus, cela signifie qu'une ressource avec l'IRI <http://example.org/simpsons/Bart> est rendue sur le chemin /Bart.html . D'autres fonctionnalités et plugins pour Jekyll dépendent également de ces deux paramètres. Si, pour tout cas, les deux paramètres diffèrent du chemin de base que Jekyll RDF doit supposer, il est possible de définir le paramètre baseiri dans la section jekyll_rdf .
baseurl : " /simpsons "
url : " https://beispiel.com "
jekyll_rdf :
baseiri : " http://example.org/ "Il est possible de cartographier une classe spécifique (resp. RDF-type) ou des ressources individuelles sur un modèle.
class_template_mappings :
" http://xmlns.com/foaf/0.1/Person " : " person.html "
instance_template_mappings :
" http://aksw.org/Team " : " team.html "Un modèle mappé à une classe sera utilisé pour rendre chaque instance de cette classe et ses sous-classes. Chaque instance est rendue avec sa classe la plus spécifique mappée sur un modèle. Si le mappage est ambigu pour une ressource, un avertissement sera sorti de votre fenêtre de commande, alors faites attention!
Il est également possible de définir un modèle par défaut, qui est utilisé pour toutes les ressources, qui ne sont pas couvertes par la class_template_mappings ou instance_template_mappings .
default_template : " default.html " Vous pouvez restreindre les ressources sélectionnées pour être construites en ajoutant une requête SPARQL comme paramètre restriction à _config.yml . Veuillez utiliser ?resourceUri comme espace réservé pour les URI résultants:
restriction : " SELECT ?resourceUri WHERE { ?resourceUri <http://www.ifi.uio.no/INF3580/family#hasFather> <http://www.ifi.uio.no/INF3580/simpsons#Homer> } "Il existe 3 mots clés prédéfinis pour les restrictions implémentées:
subjects chargeront tous les urispredicates chargeront tous les uris prédicatsobjects chargeront tous les uris d'objet Étant donné que certains points de terminaison SPARQL ont une limite intégrée pour certaines requêtes, vous pouvez également définir une liste de ressources à construire. Un fichier _data/restriction.txt cool a le contenu suivant:
<http://example.org/resourceA>
<http://example.org/resourceB>
<http://example.org/resourceC>
<http://example.org/resourceD>
<http://example.org/resourceE>
Dans le _config.yml vous spécifiez le fichier avec la clé restriction_file . Si les deux, une restriction_file et une restriction , sont spécifiées Jekyll RDF créeront des pages pour l'Union des deux.
De plus, vous pouvez décider si vous souhaitez rendre ou non les nœuds vierges. Vous avez juste besoin d'ajouter include_blank à _config.yml :
jekyll_rdf :
include_blank : true Enfin, il est également possible de définir une langue préférée pour les litres RDF avec la language d'option:
jekyll_rdf :
language : " en " L'exécution jekyll build rendra les ressources RDF au répertoire _site/… . L'exécution jekyll serve servira les ressources RDF et vous fournira un serveur http instantané généralement accessible sur http://localhost:4000/ . Les ressources RDF dont l'iris ne commence pas par l' url Jekyll configurée et baseurl (resp. baseiri ) sont rendues au répertoire _site/rdfsites/… .
Pour utiliser les données RDF, créez un ou plusieurs fichiers (par exemple rdf_index.html ou person.html ) dans le _layouts -directory. Pour chaque ressource, une page sera rendue. Voir l'exemple ci-dessous:
---
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 >Nous avons inclus quelques exemples de modèle à
test/source/_layouts/rdf_index.htmltest/source/_layouts/person.html {{ page.rdf }}
Est la ressource actuellement rendue.
{{ page.rdf.iri }}
Renvoie l'IRI de la ressource actuellement rendue.
Pour accéder aux objets connectés au sujet actuel via un prédicat, vous pouvez utiliser nos filtres liquides personnalisés. Pour les objets uniques ou les listes d'objets, utilisez le rdf_property -filter (voir 1 et 2).
Pour accéder à un objet qui est connecté au sujet actuel via un prédicat donné, veuillez filtrer page.rdf Données avec le Filter rdf_property . Exemple:
Age: {{ page.rdf | rdf_property: '<http://xmlns.com/foaf/0.1/age>' }}
Pour sélectionner une langue spécifique, veuillez ajouter un deuxième paramètre au filtre:
Age: {{ page.rdf | rdf_property: '<http://xmlns.com/foaf/0.1/job>','en' }}
Pour obtenir plus d'un objet connecté au sujet actuel via un prédicat donné, veuillez utiliser le filtre rdf_property en conjonction avec un troisième argument défini sur true (le deuxième argument pour la langue peut être omis en le définissant sur nil ):
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 >Pour sélectionner une langue spécifique, veuillez ajouter un deuxième paramètre au filtre:
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 > Pour prendre en charge les conteneurs RDF et les collections RDF, nous fournissons les filtres rdf_container et rdf_collection .
Dans les deux cas, la ressource de conteneur respectif resp. Le chef de la collection doit être identifié puis traversé le filtre respectif. Pour les conteneurs, nous prenons actuellement en charge les instances explicites de rdf:Bag , rdf:Seq et rdf:Alt avec les membres identifiés à l'aide du rdfs:ContainerMembershipProperty S: rdf:_1 , rdf:_2 , rdf:_3 …. Les collections sont identifiées à l'aide de rdf:first , rdf:rest et terminée avec L rdf:rest rdf:nil . Étant donné que la tête d'une collection doit être identifiée, vous ne pouvez pas utiliser un nœud vide là-bas, vous pouvez l'identifier indirectement via le prédicat qui contient la collection.
Exemple de graphique:
@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" .
Le modèle pour 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>
Nous avons implémenté un filtre liquide sparql_query pour exécuter des requêtes SPARQL personnalisées. Chaque occurrence de ?resourceUri est remplacée par l'URI actuel. ATTENTION: Vous devez séparer les variables de requête et de résultats en raison des concepts de liquides. Exemple:
{% 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 > Il est possible de déclarer un ensemble de préfixes qui peuvent être utilisés dans les filtres liquides rdf_property et sparql_query . Cela permet de raccourcir la quantité de texte requise pour chaque filtre à liquide. La syntaxe des déclarations du préfixe est la même que pour SPARQL 1.1. Mettez simplement vos préfixes dans un fichier séparé et incluez la clé rdf_prefix_path avec un chemin relatif dans la question frontale YAML d'un fichier où vos préfixes doivent être utilisés.
Pour les préfixes, les mêmes règles s'appliquent que pour les autres variables définies dans le front de YAML. Ces variables seront ensuite à votre disposition pour accéder à l'utilisation de balises liquides à la fois plus bas dans le fichier et également dans toutes les mises en page ou incluent que la page ou la publication en question repose. (Source: Front Yaml). Ceci est particulièrement pertinent si vous utilisez des préfixes inclut.
Si l'URI d'une ressource contient un identifiant de fragment ( #… ), la ressource peut être hébergée avec d'autres ressources avec le même URI de base jusqu'à l'identifiant de fragment sur une seule page. La page sera accessible via l'URI de base, tandis que dans le modèle, les URI individuels avec un identifiant de fragment sont accessibles via la page.sub_rdf de collection.SUB_RDF.
Exemple
Dans le _config.yml :
' instance_template_mappings ' :
' http://www.ifi.uio.no/INF3580/simpsons ' : 'family.html' Dans _layouts/family.html :
{% for member in page.sub_rdf%}
{% include simPerson.html person = member%}
{% endfor %} L'exemple utilise le modèle family.html pour rendre une seule page contenant toutes les ressources dont l'URI commence par http://www.ifi.uio.no/INF3580/simpsons# #, était ainsi que la ressource http://www.ifi.uio.no/INF3580/simpsons lui-même. Jekyll-RDF collecte toutes les ressources avec un identifiant de fragment dans leur URI (à partir d'ici à l'appel des subResources subResources ) et les transmet via page.sub_rdf dans les modèles de sa superResource ).
Chaque ressource renvoyée par l'un des filtres jekyll-rdf est un objet que Liquid peut également gérer comme une chaîne. Ils ont tous les méthodes suivantes utilisables dans le liquide.
Renvoie une liste d'instructions dont le sujet est la ressource actuelle. Les instructions de la liste renvoyée sont accessibles en s'adressant à leurs positions: Statement.subject , Statement.predicate , respect Statement.object .
Renvoie une liste d'instructions dont le prédicat est la ressource actuelle. Les instructions de la liste renvoyée sont accessibles en s'adressant à leurs positions: Statement.subject , Statement.predicate , respect Statement.object .
Renvoie une liste d'instructions dont l'objet est la ressource actuelle. Les instructions de la liste renvoyée sont accessibles en s'adressant à leurs positions: Statement.subject , Statement.predicate , respect Statement.object .
Renvoie l'URL de la page représentant ce rdfresource.
Renvoyez le chemin à paraître sur la page représentant ce rdfresource. Utilisez-le avec soin.
Cet attribut est pertinent pour le rendu des pages pour l'iris contenant un identifiant de fragment ( http://superresource#anchor ). Cet attribut est vrai pour le super-ressource ( http://superresource ) s'il est réellement décrit dans la base de connaissances donnée.
Cet attribut indique si l'instance respective d'une ressource est rendue dans le contexte de la génération de site actuelle. Utilisation: {% if resource.rendered? %}…{% endif %} .
Renvoie une chaîne verbale représentant cette ressource.
Synopsis: <resource_iri> | rdf_get
Paramètres:
<resource_iri> est une chaîne représentant une ressource RDF, avec préfixe ( prefix:name ) ou un IRI complet ( <http://ex.org/name> ). Pour référencer la ressource de la page actuelle Utiliser page.rdf , page ou nil .Description: prend l'IRI fourni et renvoie l'objet RDFResource correspondant de votre base de connaissances. Sur cet objet, vous pouvez appeler les méthodes décrites dans la ressource de la section.
Exemple:
{{'<http://www.ifi.uio.no/INF3580/simpsons>' | rdf_get }}
Résultat:
http://www.ifi.uio.no/INF3580/simpsons Synopsis: <rdf_resource> OR <rdf_resource_string> | rdf_property: <property>, [<lang>] OR [<lang>, <list>] OR [nil, <list>]
Paramètres:
<rdf_resource> est un rdfresource. Pour référencer la ressource de la page actuelle Utiliser page.rdf , page ou nil .<rdf_resource_string> est une chaîne représentant l'IRI de <rdf_resource> .<property> est une chaîne représentant un prédicat RDF, avec préfixe ( prefix:name ) ou IRI complet ( <http://ex.org/name> ).<lang> est une balise linguistique (par exemple de ). Si ce paramètre est omis, remplacez-le par nil .<list> est une valeur booléenne ( true , false ). Description: Renvoie l'objet, de l' <rdf_resource> <predicate> ?object L'objet retourné peut par n'importe quel nœud type, ressource, littéral ou blanc.
Exemple (par défaut):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_get %}
{{ resource | rdf_property: '<http://xmlns.com/foaf/0.1/job>' }}
Résultat:
"unknown"Exemple (chaîne):
{{ '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_property: '<http://xmlns.com/foaf/0.1/job>' }}
Résultat:
"unknown"Exemple (avec langue):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_get %}
{{ resource | rdf_property: '<http://xmlns.com/foaf/0.1/job>', 'de' }}
Résultat:
"unbekannt"Exemple (retour en 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 %}
Résultat:
< 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>]
Paramètres:
<rdf_resource> est un rdfresource. Pour référencer la ressource de la page actuelle Utiliser page.rdf , page ou nil .<rdf_resource_string> est une chaîne représentant l'IRI de <rdf_resource> .<property> est une chaîne représentant un prédicat RDF, avec préfixe ( prefix:name ) ou IRI complet ( <http://ex.org/name> ).<list> est une valeur booléenne ( true , false ). Description: Identique à rdf_property, mais dans une direction inverse. Il renvoie le sujet, du triple ?subject <predicate> <rdf_resource> . L'objet retourné peut par n'importe quel nœud type, ressource ou blanc.
Exemples (par défaut):
{% 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>' }}
Résultat:
http://www.ifi.uio.no/INF3580/simpsons#BartExemples (chaîne):
{{ '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_inverse_property: '<http://www.ifi.uio.no/INF3580/family#hasFather>' }}
Résultat:
http://www.ifi.uio.no/INF3580/simpsons#BartExemple (comme 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 %}
Résultat:
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> ou <reference_array> | sparql_query: <query> ou <query> | sparql_query
Paramètres:
<rdf_resource> est un rdfresource qui remplacera ?resourceUri dans la requête. Pour omettre ce paramètre ou référence à la ressource de la page actuelle Utiliser page.rdf , page ou nil .<reference_array> Un tableau contenant des iris sous forme de chaînes ou rdf_resource . Ils remplaceront consécutivement chaque ?resourceUri_<index> dans votre requête.<query> Une chaîne contenant une requête SPARQL. Description: Évalue query sur la base de connaissances donnée et renvoie un tableau de résultats (ensemble de résultats). Chaque objet d'entrée dans l'ensemble de résultats (résultat) contient les variables sélectionnées sous forme de ressources ou de littéraux. Vous pouvez utiliser ?resourceUri à l'intérieur de la requête pour référencer la ressource qui est donnée sous le nom de <rdf_resource> .
Exemple (page)
<!--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>
Résultat:
< 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 >
...Exemple (tableau)
{% 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>
Résultat:
<table>
<tr><td>http://www.ifi.uio.no/INF3580/family#hasSpouse</td></tr>
</table>
Exemple (requête)
{% 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>
Résultat:
<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
Paramètres:
<rdf_container_head> est un rdfresource. Pour référencer la ressource de la page actuelle Utiliser page.rdf , page ou nil .<rdf_container_head_string> est une chaîne représentant l'IRI de <rdf_container_head> . Description: Renvoie un tableau avec des ressources pour chaque élément du conteneur dont la tête est référencée par rdf_container_head .
Exemples:
{% 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#MaggieExemples: (String)
{% 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 ou <rdf_resource> | rdf_collection: "<property>"
Paramètres:
<rdf_collection_head> est un rdfresource. Pour référencer la ressource de la page actuelle Utiliser page.rdf , page ou nil .<rdf_collection_head_string> est une chaîne représentant l'IRI de <rdf_collection_head> .<rdf_resource> est un rdfresource. Pour référencer la ressource de la page actuelle Utiliser page.rdf , page ou nil .<property> est une chaîne représentant un prédicat RDF, avec préfixe ( prefix:name ) ou IRI complet ( <http://ex.org/name> ). Description: Renvoie un tableau avec des ressources pour chaque élément de la collection dont la tête est référencée par rdf_collection_head . Au lieu de référencer directement une tête, il est également possible de spécifier la propriété faisant référence à la tête de collection.
Exemple (spécifiez la ressource de tête):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpson-collection#Collection>' | rdf_get %}
{% assign array = resource | rdf_collection %}
{% for item in array %}
{{ item }}
{% endfor %}
Résultat:
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#MaggieExemple (spécifiez la chaîne de tête):
{% assign array = '<http://www.ifi.uio.no/INF3580/simpson-collection#Collection>' | rdf_collection %}
{% for item in array %}
{{ item }}
{% endfor %}
Résultat:
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#MaggieExemple (Spécifiez via la propriété):
{% 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 %}
Résultat:
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| Nom | Paramètre | Défaut | Description | Exemple |
|---|---|---|---|---|
| chemin | Chemin relatif vers le fichier RDF | pas de défaut | Spécifie le chemin d'accès au fichier RDF à partir de l'endroit où vous souhaitez rendre le site Web | path: "rdf-data/simpsons.ttl" |
| télécommande | Section pour spécifier une source de données distante | pas de défaut | Doit contenir la touche de endpoint . Le paramètre remote remplace le paramètre path . | |
| Remote> point final | SPARQL Point de terminaison pour obtenir les données de | pas de défaut | Spécifie l'URL au point de terminaison SPARQL d'où vous souhaitez rendre le site Web | remote: endpoint: "http://localhost:5000/sparql/" |
| distant> default_graph | Sélectionnez un graphique nommé sur le point de terminaison à utiliser à la place du graphique par défaut du point de terminaison | pas de défaut | Spécifie l'IRI au graphique nommé pour sélectionner parmi le point de terminaison Sparql | remote: endpoint: "http://localhost:5000/sparql/" default_graph: "http://example.org/" |
| langue | Tag langue comme chaîne | pas de défaut | Spécifie la langue préférée lorsque vous sélectionnez des objets à l'aide de nos filtres liquides | language: "en" |
| include_blank | Expression booléenne | FAUX | Spécifie si les nœuds vierges doivent également être rendus ou non | include_blank: true |
| restriction | SPARQL-QUERY comme chaîne ou sujets / objets / prédicats | pas de défaut | Restreint la sélection des ressources avec une quête SPARQL donnée aux résultats liés à la variable spéciale ?resourceUri ou les trois subjects de mots clés (seuls les uris de sujet), objects , predicates | restriction: "SELECT ?resourceUri WHERE { ?resourceUri <http://www.ifi.uio.no/INF3580/family#hasFather> <http://www.ifi.uio.no/INF3580/simpsons#Homer> }" |
| restriction_file | Dossier de ressources à rendre | pas de défaut | Restreint la sélection des ressources à la liste des ressources dans le fichier | restriction_file: _data/restriction.txt |
| default_template | Nom de fichier du template RDF par défaut dans le répertoire _layouts | pas de défaut | Spécifie le modèle de modèle que vous voulez que Jekyll utilise pour rendre toutes les ressources RDF | default_template: "rdf_index.html" |
| instance_template_mappings | URI cible comme chaîne: nom de fichier du modèle en tant que chaîne | pas de défaut | Cartes données URI aux fichiers de modèles pour rendre une instance individuelle | instance_template_mappings: "http://www.ifi.uio.no/INF3580/simpsons#Abraham": "abraham.html" |
| class_template_mappings | URI cible comme chaîne: nom de fichier du modèle en tant que chaîne | pas de défaut | Cartes données d'uris aux fichiers de modèles pour rendre toutes les instances de cette classe | class_template_mappings: "http://xmlns.com/foaf/0.1/Person": "person.html" |
Il existe également une image Docker / Podman qui a un préinstallé Jekyll et Jekyll-RDF. Vous pouvez l'obtenir avec:
docker pull ghcr.io/aksw/jekyll-rdf:latest
et exécutez-le par exemple avec
docker run --rm --workdir /page -v $PWD:/page ghcr.io/aksw/jekyll-rdf:latest
ou personnaliser l'exécution de Jekyll avec
docker run --rm --workdir /page -v $PWD/sources:/page -v $PWD/build/jekyll:/build ghcr.io/aksw/jekyll-rdf:latest jekyll build -d /build
Le point d'entrée de l'image exécute bundle install d'abord et l'exécute alors bundle exec jekyll build ou bundle exec <your command> . Pour garder les packages installés entre les analyses, spécifiez la variable d'environnement BUNDLE_PATH à un emplacement qui persiste entre les exécutions, par exemple -e BUNDLE_PATH=.vendor . Pour désactiver l'intégralité de Bundler Stuff NO_BUNDLER sur une valeur non vide, le point d'entrée exécutera votre commande telle qu'elle est.
| Nom | Défaut | Description |
|---|---|---|
BUNDLE_PATH | décollé | Définissez le chemin où Bundler installe les packages. Voir aussi The Bundler Docs. |
NO_BUNDLER | décollé | Définir sur une valeur non vide pour désactiver toutes les pièces de bundler dans le point d'entrée |
Pour installer le projet avec le Git-Repository, vous aurez besoin git sur votre système. La première étape consiste à cloner le référentiel:
git clone [email protected]:AKSW/jekyll-rdf.git
Un dossier nommé jekyll-rdf sera généré automatiquement. Vous devez basculer dans ce dossier et compiler le Ruby Gem pour terminer l'installation:
cd jekyll-rdf
gem build jekyll-rdf.gemspec
gem install jekyll-rdf -*.gem
bundle exec rake test
Chaque fois que les tests sont exécutés, la page Jekyll à l'intérieur du test/source est traitée. Démarrez un serveur Web mince pour regarder les résultats dans le navigateur Web, par exemple Pythons SimpleHTTPServer (Python 2, pour Python 3 c'est http.server ):
cd test/source/_site
python -m SimpleHTTPServer 8000
Pour générer l'API Doc, veuillez accéder au répertoire jekyll-rdf/lib et exécuter
gem install yard
yardoc *
La documentation générée est placée dans le répertoire jekyll-rdf/lib/doc .
Jekyll-RDF est sous licence sous la licence du MIT.
