jekyll rdf
4.2.4
Un complemento Jekyll para incluir datos RDF en su sitio estático.
La documentación de API está disponible en RubyDoc.info.
Docker Hay una imagen de Docker, consulte el uso de la sección Docker.
Como un requisito previo para Jekyll Rdf, por supuesto, debe instalar Jekyll . Eche un vistazo a las instrucciones de instalaciones en https://jekyllrb.com/docs/installation/.
Si ya tiene una instalación de Jekyll en funcionamiento, puede agregar el complemento Jekyll-Rdf. Probablemente ya uses Bundler y hay un Gemfile en tu directorio Jekyll. Agregue jekyll-rdf a la sección de complementos:
gem "jekyll-rdf", "~> 3.2"
Reemplace la cadena de versión con la versión estable disponible actualmente como se enumera en rubygems.org. Después de actualizar su Gemfile , probablemente desee ejecutar bundle install (o bundle install --path vendor/bundle ) o bundle update .
Si no está utilizando un Gemfile para administrar sus paquetes Jekyll/Ruby, instale Jekyll-Rdf usando gem :
gem install jekyll-rdf
Si desea construir el complemento a partir de la fuente, eche un vistazo a nuestra sección de desarrollo.
Esta sección explica cómo usar Jekyll-Rdf en tres pasos:
Todos los filtros y métodos para usar en plantillas y opciones de configuración se documentan en la sección "Parámetros y opciones de configuración de un vistazo".
Primero, necesitas una página de Jekyll. Para crear uno, solo haz:
jekyll new my_page
cd my_page
Además, se requieren algunos parámetros en su _config.yml para jekyll-rdf . Es decir, los parámetros url y baseurl se utilizan para incluir las páginas de recursos en la raíz del sitio, el complemento debe configurarse y la ruta al archivo RDF debe estar presente.
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 " Jekyll RDF utiliza la url + baseurl para identificar en relación con qué URL debe construir las páginas de recursos RDF. En el ejemplo anterior, esto significa que un recurso con IRI <http://example.org/simpsons/Bart> se representa a la ruta /Bart.html . También otras características y complementos para Jekyll dependen de estos dos parámetros. Si para cualquier caso los dos parámetros difieren de la ruta base que Jekyll RDF debe suponer, es posible establecer el parámetro baseiri en la sección jekyll_rdf .
baseurl : " /simpsons "
url : " https://beispiel.com "
jekyll_rdf :
baseiri : " http://example.org/ "Es posible mapear una clase específica (resp. RDF-Type) o recursos individuales a una plantilla.
class_template_mappings :
" http://xmlns.com/foaf/0.1/Person " : " person.html "
instance_template_mappings :
" http://aksw.org/Team " : " team.html "Se utilizará una plantilla asignada a una clase para representar cada instancia de esa clase y sus subclases. Cada instancia se representa con su clase más específica asignada a una plantilla. Si el mapeo es ambiguo para un recurso, se producirá una advertencia a su ventana de comando, ¡así que ten cuidado!
También es posible definir una plantilla predeterminada, que se utiliza para todos los recursos, que no están cubiertos por class_template_mappings o instance_template_mappings .
default_template : " default.html " Puede restringir los recursos seleccionados para construir agregando una consulta SPARQL como parámetro restriction a _config.yml . Por favor, use ?resourceUri como marcador de posición para los URI resultantes:
restriction : " SELECT ?resourceUri WHERE { ?resourceUri <http://www.ifi.uio.no/INF3580/family#hasFather> <http://www.ifi.uio.no/INF3580/simpsons#Homer> } "Hay 3 palabras clave predefinidas para las restricciones implementadas:
subjects cargarán todos los URI de sujetopredicates cargarán todos los URI predicadosobjects cargarán todos los objetos URI Debido a que algunos puntos finales SPARQL tienen un límite incorporado para consultas seleccionadas, también puede definir una lista de recursos que se construirán. Un archivo _data/restriction.txt cool tiene el siguiente contenido:
<http://example.org/resourceA>
<http://example.org/resourceB>
<http://example.org/resourceC>
<http://example.org/resourceD>
<http://example.org/resourceE>
En el _config.yml especifica el archivo con la restriction_file de clave_file. Si ambos, una restriction_file y una restriction se especifican que Jekyll RDF construirá páginas para la unión de ambos.
Además, puede decidir si desea representar nodos en blanco o no. Solo necesita agregar include_blank a _config.yml :
jekyll_rdf :
include_blank : true Finalmente, también es posible establecer un lenguaje preferido para los RDF-Literales con el language de opción:
jekyll_rdf :
language : " en " Ejecutar jekyll build hará los recursos RDF al directorio _site/… Ejecutar jekyll serve hará los recursos RDF y le proporcionará un servidor HTTP instantáneo que generalmente se puede acceder a http://localhost:4000/ . Los recursos de RDF cuyo iris no comienzan con la url Jekyll configurada y baseurl (resp. baseiri ) se representan al subdirector _site/rdfsites/…
Para hacer uso de los datos RDF, cree uno o más archivos (por ejemplo, rdf_index.html o person.html ) en _layouts -Directory. Para cada recurso se presentará una página. Ver ejemplo a continuación:
---
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 >Incluimos algunos ejemplos de plantillas en
test/source/_layouts/rdf_index.htmltest/source/_layouts/person.html {{ page.rdf }}
Es el recurso actualmente renderizado.
{{ page.rdf.iri }}
Devuelve el IRI del recurso actualmente renderizado.
Para acceder a objetos que están conectados al sujeto actual a través de un predicado, puede usar nuestros filtros líquidos personalizados. Para objetos o listas individuales de objetos, use el rdf_property -filter (ver 1 y 2).
Para acceder a un objeto que está conectado al sujeto actual a través de un predicado dado, filtre los datos page.rdf con el rdf_property -filter. Ejemplo:
Age: {{ page.rdf | rdf_property: '<http://xmlns.com/foaf/0.1/age>' }}
Para seleccionar un idioma específico, agregue un segundo parámetro al filtro:
Age: {{ page.rdf | rdf_property: '<http://xmlns.com/foaf/0.1/job>','en' }}
Para obtener más de un objeto conectado al sujeto actual a través de un predicado dado, utilice el filtro rdf_property junto con un tercer argumento establecido en true (el segundo argumento para el lenguaje se puede omitir configurándolo en 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 >Para seleccionar un idioma específico, agregue un segundo parámetro al filtro:
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 > Para admitir contenedores RDF y colecciones RDF, proporcionamos los filtros rdf_container y rdf_collection .
En ambos casos, el recurso de contenedor respectivo resp. El jefe de la colección debe identificarse y luego pasar a través del filtro respectivo. Para los contenedores, actualmente admitemos instancias explícitas de rdf:Bag , rdf:Seq y rdf:Alt con los miembros identificados utilizando el rdfs:ContainerMembershipProperty S: rdf:_1 , rdf:_2 , rdf:_3 ... Las colecciones se identifican utilizando rdf:first , rdf:rest y terminado con L rdf:rest rdf:nil . Dado que la cabeza de una colección debe identificarse, no puede usar un nodo en blanco allí, puede identificarlo indirectamente a través del predicado que contiene la colección.
Gráfico de ejemplo:
@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" .
La plantilla para 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>
Implementamos un filtro líquido sparql_query para ejecutar consultas SPARQL personalizadas. Cada aparición de ?resourceUri se reemplaza con el URI actual. PRECAUCIÓN: debe separar las variables de consulta y establecimiento de resultados debido a conceptos de líquidos. Ejemplo:
{% 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 posible declarar un conjunto de prefijos que se pueden usar en los filtros líquidos rdf_property y sparql_query . Esto permite acortar la cantidad de texto requerido para cada filtro líquido. La sintaxis de las declaraciones de prefijo es la misma que para SPARQL 1.1. Simplemente coloque sus prefijos en un archivo separado e incluya la clave rdf_prefix_path junto con una ruta relativa en la materia frontal Yaml de un archivo donde se deben usar sus prefijos.
Para los prefijos se aplican las mismas reglas que para otras variables definidas en la materia frontal Yaml. Estas variables estarán disponibles para que acceda a usar etiquetas líquidas, tanto hacia abajo en el archivo como en cualquier diseño o incluye en la que se basa la página o la publicación en cuestión. (Fuente: Yaml Front Matter). Esto es especialmente relevante si está utilizando prefijos en INCENDIDOS.
Si el URI de un recurso contiene un identificador de fragmentos ( #… ), el recurso se puede alojar junto con otros recursos con el mismo URI base hasta el identificador de fragmentos en una sola página. La página se puede acceder a través de la URI base, mientras que en la plantilla se puede acceder a los URI individuales con un identificador de fragmentos a través de la page.sub_rdf colección.sub_rdf.
Ejemplo
En el _config.yml :
' instance_template_mappings ' :
' http://www.ifi.uio.no/INF3580/simpsons ' : 'family.html' En _layouts/family.html :
{% for member in page.sub_rdf%}
{% include simPerson.html person = member%}
{% endfor %} El ejemplo usa la family.html Template.html para representar una sola página que contiene cada recurso cuyo URI comienza con http://www.ifi.uio.no/INF3580/simpsons# , fue así como el recurso http://www.ifi.uio.no/INF3580/simpsons . Jekyll-Rdf recoge todos los recursos con un identificador de fragmentos en su URI (a partir de aquí en subResources ) y los pasa a través de page.sub_rdf en las plantillas de su superResource (recursos cuyo URI base es lo mismo que de sus subResources excepto para la identificación de fragmentos ).
Cada recurso devuelto por uno de los filtros de jekyll-rdf es un objeto que Liquid también puede manejar como una cadena. Todos tienen los siguientes métodos utilizables en líquido.
Devuelva una lista de declaraciones cuyo tema es el recurso actual. Se puede acceder a las declaraciones en la lista devuelta abordando sus posiciones: Statement.subject , Statement.predicate , respectiva Statement.object .
Devuelva una lista de declaraciones cuyo predicado es el recurso actual. Se puede acceder a las declaraciones en la lista devuelta abordando sus posiciones: Statement.subject , Statement.predicate , respectiva Statement.object .
Devuelva una lista de declaraciones cuyo objeto es el recurso actual. Se puede acceder a las declaraciones en la lista devuelta abordando sus posiciones: Statement.subject , Statement.predicate , respectiva Statement.object .
Devuelva la URL de la página que representa este rdfresurce.
Devuelva la ruta a la página que representa este rdfresurce. Úselo con cuidado.
Este atributo es relevante para representar páginas para el IRIS que contiene un identificador de fragmentos ( http://superresource#anchor ). Este atributo es cierto para el Super Resource ( http://superresource ) si realmente se describe en la base de conocimiento dada.
Este atributo indica si la instancia respectiva de un recurso se representa dentro del contexto de la generación actual del sitio. Uso: {% if resource.rendered? %}…{% endif %} .
Devuelve una cadena detallada que representa este recurso.
Sinopsis: <resource_iri> | rdf_get
Parámetros:
<resource_iri> es una cadena que representa un recurso RDF, con prefijo ( prefix:name ) o un IRI completo ( <http://ex.org/name> ). Para hacer referencia al recurso de la página actual, use page.rdf , page o nil .Descripción: toma el IRI provisto y devuelve el objeto RDFresource correspondiente de su base de conocimiento. En este objeto puede llamar a los métodos descritos en el recurso de sección.
Ejemplo:
{{'<http://www.ifi.uio.no/INF3580/simpsons>' | rdf_get }}
Resultado:
http://www.ifi.uio.no/INF3580/simpsons Sinopsis: <rdf_resource> OR <rdf_resource_string> | rdf_property: <property>, [<lang>] OR [<lang>, <list>] OR [nil, <list>]
Parámetros:
<rdf_resource> es un rdfresource. Para hacer referencia al recurso de la página actual, use page.rdf , page o nil .<rdf_resource_string> es una cadena que representa el IRI de <rdf_resource> .<property> es una cadena que representa un predicado RDF, con prefijo ( prefix:name ) o un IRI completo ( <http://ex.org/name> ).<lang> es una etiqueta de idioma (por de ). Si este parámetro se omite, reemplácelo por nil .<list> es un valor booleano ( true , false ). Descripción: Devuelve el objeto, del <rdf_resource> <predicate> ?object El objeto devuelto puede por cualquiera de los tipos, recursos, literal o nodo en blanco.
Ejemplo (predeterminado):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_get %}
{{ resource | rdf_property: '<http://xmlns.com/foaf/0.1/job>' }}
Resultado:
"unknown"Ejemplo (cadena):
{{ '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_property: '<http://xmlns.com/foaf/0.1/job>' }}
Resultado:
"unknown"Ejemplo (con lenguaje):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_get %}
{{ resource | rdf_property: '<http://xmlns.com/foaf/0.1/job>', 'de' }}
Resultado:
"unbekannt"Ejemplo (return como lista):
{% 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 %}
Resultado:
< li > "unknown" </ li >
< li > "unbekannt" </ li >
< li > "unbekannter Job 2" </ li >
< li > "unknown Job 2" </ li > Sinopsis: <rdf_resource> OR <rdf_resource_string>| rdf_inverse_property: <property>, [<list>]
Parámetros:
<rdf_resource> es un rdfresource. Para hacer referencia al recurso de la página actual, use page.rdf , page o nil .<rdf_resource_string> es una cadena que representa el IRI de <rdf_resource> .<property> es una cadena que representa un predicado RDF, con prefijo ( prefix:name ) o un IRI completo ( <http://ex.org/name> ).<list> es un valor booleano ( true , false ). Descripción: Igual que RDF_Property, pero en dirección inversa. Devuelve el sujeto, del triple ?subject <predicate> <rdf_resource> . El objeto devuelto puede por cualquiera de los tipos, recursos o nodos en blanco.
Ejemplos (predeterminado):
{% 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>' }}
Resultado:
http://www.ifi.uio.no/INF3580/simpsons#BartEjemplos (cadena):
{{ '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_inverse_property: '<http://www.ifi.uio.no/INF3580/family#hasFather>' }}
Resultado:
http://www.ifi.uio.no/INF3580/simpsons#BartEjemplo (como lista):
{% 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 %}
Resultado:
http://www.ifi.uio.no/INF3580/simpsons#Bart
http://www.ifi.uio.no/INF3580/simpsons#Lisa
http://www.ifi.uio.no/INF3580/simpsons#Maggie Sinopsis: <rdf_resource> | sparql_query: <query> o <reference_array> | sparql_query: <query> o <query> | sparql_query
Parámetros:
<rdf_resource> es un rdfresource que reemplazará ?resourceUri en la consulta. Para omitir este parámetro o referencia al recurso de la página actual, use page.rdf , page o nil .<reference_array> Una matriz que contiene iris como cadenas o rdf_resource . Reemplazarán consecutivamente cada uno ?resourceUri_<index> en su consulta.<query> una cadena que contiene una consulta SPARQL. Descripción: Evalúa query en la base de conocimiento dada y devuelve una matriz de resultados (conjunto de resultados). Cada objeto de entrada en el conjunto de resultados (resultado) contiene las variables seleccionadas como recursos o literales. Puede usar ?resourceUri dentro de la consulta para hacer referencia al recurso que se da como <rdf_resource> .
Ejemplo (página)
<!--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>
Resultado:
< 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 >
...Ejemplo (matriz)
{% 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>
Resultado:
<table>
<tr><td>http://www.ifi.uio.no/INF3580/family#hasSpouse</td></tr>
</table>
Ejemplo (consulta)
{% 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>
Resultado:
<table>
<tr><td>http://www.ifi.uio.no/INF3580/family#hasSpouse</td></tr>
</table>
Sinopsis: <rdf_container_head> **OR** <rdf_container_head_string> | rdf_container
Parámetros:
<rdf_container_head> es un rdfresource. Para hacer referencia al recurso de la página actual, use page.rdf , page o nil .<rdf_container_head_string> es una cadena que representa el IRI de <rdf_container_head> . Descripción: Devuelve una matriz con recursos para cada elemento en el contenedor cuya cabeza es referenciada por rdf_container_head .
Ejemplos:
{% 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#MaggieEjemplos: (cadena)
{% 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 Sinopsis: <rdf_collection_head> OR <rdf_collection_head_string> | rdf_collection o <rdf_resource> | rdf_collection: "<property>"
Parámetros:
<rdf_collection_head> es un rdfresource. Para hacer referencia al recurso de la página actual, use page.rdf , page o nil .<rdf_collection_head_string> es una cadena que representa el IRI de <rdf_collection_head> .<rdf_resource> es un rdfresource. Para hacer referencia al recurso de la página actual, use page.rdf , page o nil .<property> es una cadena que representa un predicado RDF, con prefijo ( prefix:name ) o un IRI completo ( <http://ex.org/name> ). Descripción: Devuelve una matriz con recursos para cada elemento en la colección cuya cabeza es referenciada por rdf_collection_head . En lugar de hacer referencia directamente a una cabeza, también es posible especificar la propiedad que hace referencia al cabezal de recolección.
Ejemplo (especifique el recurso principal):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpson-collection#Collection>' | rdf_get %}
{% assign array = resource | rdf_collection %}
{% for item in array %}
{{ item }}
{% endfor %}
Resultado:
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#MaggieEjemplo (especificar la cadena de cabeza):
{% assign array = '<http://www.ifi.uio.no/INF3580/simpson-collection#Collection>' | rdf_collection %}
{% for item in array %}
{{ item }}
{% endfor %}
Resultado:
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#MaggieEjemplo (especificar a través de la propiedad):
{% 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 %}
Resultado:
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| Nombre | Parámetro | Por defecto | Descripción | Ejemplo |
|---|---|---|---|---|
| camino | Ruta relativa al archivo RDF | Sin incumplimiento | Especifica la ruta al archivo RDF desde donde desea representar el sitio web | path: "rdf-data/simpsons.ttl" |
| remoto | Sección para especificar una fuente de datos remoto | Sin incumplimiento | Tiene que contener la clave endpoint . El parámetro remote anula el parámetro path . | |
| remoto> punto final | Punto final SPARQL para obtener los datos de | Sin incumplimiento | Especifica la URL al punto final SPARQL desde donde desea representar el sitio web | remote: endpoint: "http://localhost:5000/sparql/" |
| remoto> default_graph | Seleccione un gráfico con nombre en el punto final para usar en lugar del gráfico predeterminado del punto final | Sin incumplimiento | Especifica el IRI al gráfico con nombre para seleccionar desde el punto final SPARQL | remote: endpoint: "http://localhost:5000/sparql/" default_graph: "http://example.org/" |
| idioma | Etiqueta de idioma como cadena | Sin incumplimiento | Especifica el lenguaje preferido cuando selecciona objetos utilizando nuestros filtros líquidos | language: "en" |
| incluir_blank | Expresión booleana | FALSO | Especifica si los nodos en blanco también se deben representar o no | include_blank: true |
| restricción | SPARQL-QUERY como cadena o sujetos/objetos/predicados | Sin incumplimiento | Restringe la selección de recursos con una cuidera SPARQL dada a los resultados vinculados a la variable especial ?resourceUri o los tres subjects de palabras clave (solo URI de sujeto), 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 | Archivo de recursos a renderizar | Sin incumplimiento | Restringe la selección de recursos a la lista de recursos en el archivo | restriction_file: _data/restriction.txt |
| default_template | Nombre de archivo del Template RDF predeterminado en el directorio _Layouts | Sin incumplimiento | Especifica el archivo de plantilla que desea que Jekyll use para representar todos los recursos RDF | default_template: "rdf_index.html" |
| instance_template_mappings | Target URI como cadena: nombre de archivo de la plantilla como cadena | Sin incumplimiento | Mapas dados URI a plantillas para presentar una instancia individual | instance_template_mappings: "http://www.ifi.uio.no/INF3580/simpsons#Abraham": "abraham.html" |
| class_template_mappings | Target URI como cadena: nombre de archivo de la plantilla como cadena | Sin incumplimiento | Mapas dados URI a plantillas archivos para hacer todas las instancias de esa clase | class_template_mappings: "http://xmlns.com/foaf/0.1/Person": "person.html" |
También hay una imagen Docker/Podman que tiene preinstalados Jekyll y Jekyll-Rdf. Puedes conseguirlo con:
docker pull ghcr.io/aksw/jekyll-rdf:latest
y ejecutarlo eg con
docker run --rm --workdir /page -v $PWD:/page ghcr.io/aksw/jekyll-rdf:latest
o personalizar la ejecución de Jekyll con
docker run --rm --workdir /page -v $PWD/sources:/page -v $PWD/build/jekyll:/build ghcr.io/aksw/jekyll-rdf:latest jekyll build -d /build
El punto de entrada de la imagen ejecuta bundle install primero y luego ejecuta bundle exec jekyll build o bundle exec <your command> . Para mantener los paquetes instalados entre ejecuciones, especifique la variable de entorno BUNDLE_PATH en una ubicación que persiste entre ejecuciones, por ejemplo -e BUNDLE_PATH=.vendor . Para deshabilitar todo el Bundler Stuff Set NO_BUNDLER en un valor no vacío, el punto de entrada ejecutará su comando tal como está.
| Nombre | Por defecto | Descripción |
|---|---|---|
BUNDLE_PATH | desacio | Establezca la ruta donde Bundler instala los paquetes. Ver también los documentos de Bundler. |
NO_BUNDLER | desacio | Establecer en un valor no vacío para deshabilitar todas las piezas de Bundler en el punto de entrada |
Para instalar el proyecto con el repositorio GIT, necesitará git en su sistema. El primer paso es clonando el repositorio:
git clone [email protected]:AKSW/jekyll-rdf.git
Se generará automáticamente una carpeta llamada jekyll-rdf . Debe cambiar a esta carpeta y compilar la gema Ruby para finalizar la instalación:
cd jekyll-rdf
gem build jekyll-rdf.gemspec
gem install jekyll-rdf -*.gem
bundle exec rake test
Cada vez que se ejecutan las pruebas, la página Jekyll dentro de test/source se procesa. Inicie un servidor web delgado para ver los resultados en el navegador web, por ejemplo, Pythons SimpleHTTPServer (Python 2, para Python 3 es http.server ):
cd test/source/_site
python -m SimpleHTTPServer 8000
Para generar el Doc API, navegue al directorio jekyll-rdf/lib y ejecute
gem install yard
yardoc *
La documentación generada se coloca en el directorio jekyll-rdf/lib/doc .
Jekyll-Rdf tiene licencia bajo la licencia MIT.
