jekyll rdf
4.2.4
Um plug -in Jekyll para incluir dados RDF no seu site estático.
A documentação da API está disponível em rubydoc.info.
Docker Há uma imagem do Docker Confira o uso do Docker da seção.
Como um pré -requisito para Jekyll Rdf, é claro que precisa instalar Jekyll . Dê uma olhada nas instruções de instalação em https://jekyllrb.com/docs/installation/.
Se você já possui uma instalação Jekyll em funcionamento, pode adicionar o plug-in Jekyll-RDF. Provavelmente você já está usando o Bundler e há um Gemfile no seu diretório Jekyll. Adicione Jekyll-rdf à seção Plugins:
gem "jekyll-rdf", "~> 3.2"
Substitua a string de versão pelo lançamento estável atualmente disponível, conforme listado no rubygems.org. Depois de atualizar o seu Gemfile , você provavelmente deseja executar bundle install (ou bundle install --path vendor/bundle ) ou bundle update .
Se você não estiver usando um Gemfile para gerenciar seus pacotes Jekyll/Ruby, instale Jekyll-Rdf usando gem :
gem install jekyll-rdf
Se você deseja construir o plug -in da fonte, dê uma olhada na nossa seção de desenvolvimento.
Esta seção explica como usar o jekyll-rdf em três etapas:
Todos os filtros e métodos a serem usados em modelos e opções de configuração estão documentados na seção "Parâmetros e opções de configuração rapidamente".
Primeiro, você precisa de uma página Jekyll. Para criar um, basta fazer:
jekyll new my_page
cd my_page
Além disso, existem alguns parâmetros necessários no seu _config.yml para jekyll-rdf . Ou seja, os parâmetros url e baseurl são usados para incluir as páginas de recursos na raiz do site, o plug-in deve ser configurado e o caminho para o arquivo RDF deve 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 " O url + baseurl é usado pelo Jekyll RDF para identificar em relação a qual URL deve criar as páginas de recursos RDF. No exemplo acima, isso significa que um recurso com o IRI <http://example.org/simpsons/Bart> é renderizado no caminho /Bart.html . Outros recursos e plugins para Jekyll dependem desses dois parâmetros. Se, por qualquer caso, os dois parâmetros diferirem do caminho base que o Jekyll RDF deve assumir, é possível definir o parâmetro baseiri na seção jekyll_rdf .
baseurl : " /simpsons "
url : " https://beispiel.com "
jekyll_rdf :
baseiri : " http://example.org/ "É possível mapear uma classe específica (resp. RDF-Type) ou recursos individuais para um modelo.
class_template_mappings :
" http://xmlns.com/foaf/0.1/Person " : " person.html "
instance_template_mappings :
" http://aksw.org/Team " : " team.html "Um modelo mapeado para uma classe será usado para renderizar cada instância dessa classe e suas subclasses. Cada instância é renderizada com sua classe mais específica mapeada para um modelo. Se o mapeamento for ambíguo para um recurso, um aviso será emitido para a janela de comando, então cuidado!
Também é possível definir um modelo padrão, usado para todos os recursos, que não são cobertos pelo class_template_mappings ou instance_template_mappings .
default_template : " default.html " Você pode restringir os recursos selecionados a serem construídos adicionando uma consulta SPARQL como parâmetro restriction para _config.yml . Por favor, use ?resourceUri como espaço reservado para os URIs resultantes:
restriction : " SELECT ?resourceUri WHERE { ?resourceUri <http://www.ifi.uio.no/INF3580/family#hasFather> <http://www.ifi.uio.no/INF3580/simpsons#Homer> } "Existem 3 palavras -chave predefinidas para restrições implementadas:
subjects carregarão todos os URIs de assuntopredicates carregarão todos os URIs predicadosobjects carregarão todos os URIs de objeto Como alguns pontos de extremidade SPARQL têm um limite integrado para consultas selecionadas, você também pode definir uma lista de recursos a serem construídos. Um arquivo _data/restriction.txt cool tem o seguinte conteúdo:
<http://example.org/resourceA>
<http://example.org/resourceB>
<http://example.org/resourceC>
<http://example.org/resourceD>
<http://example.org/resourceE>
No _config.yml você especifica o arquivo com a chave restriction_file . Se ambos, uma restriction_file e uma restriction são especificados Jekyll Rdf criarão páginas para a união dos dois.
Além disso, você pode decidir se deseja renderizar nós em branco ou não. Você só precisa adicionar include_blank a _config.yml :
jekyll_rdf :
include_blank : true Finalmente, também é possível definir um idioma preferido para os Literais RDF com o language da opção:
jekyll_rdf :
language : " en " jekyll build , em execução, renderizará os recursos RDF para o diretório _site/… . A execução jekyll serve tornará os recursos RDF e fornecerá um HTTP-Server instantâneo geralmente acessível em http://localhost:4000/ . Os recursos RDF cuja íris não começam com o url Jekyll e baseurl configurado (resp. baseiri ) são renderizados para o Sub Diretório _site/rdfsites/… .
Para fazer uso dos dados RDF, crie um ou mais arquivos (por exemplo, rdf_index.html ou person.html ) no _layouts -Directory. Para cada recurso, uma página será renderizada. Veja o exemplo abaixo:
---
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 >Incluímos alguns exemplos de modelo em
test/source/_layouts/rdf_index.htmltest/source/_layouts/person.html {{ page.rdf }}
É o recurso atualmente renderizado.
{{ page.rdf.iri }}
Retorna o IRI do recurso atualmente renderizado.
Para acessar objetos conectados ao assunto atual por meio de um predicado, você pode usar nossos filtros líquidos personalizados. Para objetos únicos ou listas de objetos, use o rdf_property -filter (consulte 1 e 2).
Para acessar um objeto que está conectado ao assunto atual por meio de um determinado predicado, filtre page.rdf Dados com o rdf_property -filter. Exemplo:
Age: {{ page.rdf | rdf_property: '<http://xmlns.com/foaf/0.1/age>' }}
Para selecionar um idioma específico, adicione um segundo parâmetro ao filtro:
Age: {{ page.rdf | rdf_property: '<http://xmlns.com/foaf/0.1/job>','en' }}
Para obter mais de um objeto conectado ao assunto atual por meio de um determinado predicado, use o filtro rdf_property em conjunto com um terceiro argumento definido como true (o segundo argumento para o idioma pode ser omitido definindo -o como 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 selecionar um idioma específico, adicione um segundo parâmetro ao 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 oferecer suporte a contêineres RDF e coleções RDF, fornecemos os filtros rdf_container e rdf_collection .
Nos dois casos, o respectivo recurso de contêiner resp. O chefe da coleção precisa ser identificado e depois passado pelo respectivo filtro. Para contêineres, atualmente suportamos instâncias explícitas de rdf:Bag , rdf:Seq e rdf:Alt com os membros identificados usando o rdfs:ContainerMembershipProperty S: rdf:_1 , rdf:_2 , rdf:_3 …. As coleções são identificadas usando rdf:first , rdf:rest e terminado com L rdf:rest rdf:nil . Como o chefe de uma coleção precisa ser identificado, você não pode usar um nó em branco lá, você pode identificá -lo indiretamente através do predicado que contém a coleção.
Exemplo de gráfico:
@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" .
O modelo 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 um filtro líquido sparql_query para executar consultas SPARQL personalizadas. Cada ocorrência de ?resourceUri é substituída pelo URI atual. CUIDADO: Você precisa separar as variáveis de consulta e resultados devido a conceitos de líquidos. Exemplo:
{% 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 > É possível declarar um conjunto de prefixos que podem ser usados nos filtros líquidos rdf_property e sparql_query . Isso permite reduzir a quantidade de texto necessária para cada filtro de líquido. A sintaxe das declarações de prefixo é a mesma que para o SPARQL 1.1. Basta colocar seus prefixos em um arquivo separado e incluir a chave rdf_prefix_path juntamente com um caminho relativo na matéria frontal da YAML de um arquivo em que seus prefixos devem ser usados.
Para os prefixos, as mesmas regras se aplicam a outras variáveis definidas na matéria frontal da YAML. Essas variáveis estarão disponíveis para você acessar o uso de tags líquidas mais abaixo no arquivo e também em qualquer layouts ou inclui que a página ou a postagem em questão depende. (Fonte: YAML Front Matter). Isso é especialmente relevante se você estiver usando prefixos em incluir.
Se o URI de um recurso contiver um identificador de fragmento ( #… ), o recurso poderá ser hospedado junto com outros recursos com o mesmo URI base até o identificador de fragmento em uma única página. A página acessível através do URI base, enquanto no modelo os URIs individuais com um identificador de fragmento são acessíveis através da page.sub_rdf de coleta.sub_rdf.
Exemplo
No _config.yml :
' instance_template_mappings ' :
' http://www.ifi.uio.no/INF3580/simpsons ' : 'family.html' Em _layouts/family.html :
{% for member in page.sub_rdf%}
{% include simPerson.html person = member%}
{% endfor %} O exemplo usa o modelo family.html para renderizar uma única página que contém todos os recursos cujo URI começa com http://www.ifi.uio.no/INF3580/simpsons# , foi bem como o recurso http://www.ifi.uio.no/INF3580/simpsons . O Jekyll-RDF coleta todos os recursos com um identificador de fragmento em seu URI (daqui chamado subResources ) e os passa através da page.sub_rdf para os modelos de seu superResource (recursos cujo URI base é o mesmo que de seu subResources exceto o identificador de fragmento ).
Todo recurso devolvido por um dos filtros jekyll-rdf é um objeto que o líquido também pode lidar como uma string. Todos eles têm os seguintes métodos utilizáveis em líquido.
Retorne uma lista de declarações cujo assunto é o recurso atual. As declarações na lista devolvida podem ser acessadas abordando suas posições: Statement.subject , Statement.predicate , respectivo Statement.object .
Retorne uma lista de declarações cujo predicado é o recurso atual. As declarações na lista devolvida podem ser acessadas abordando suas posições: Statement.subject , Statement.predicate , respectivo Statement.object .
Retorne uma lista de declarações cujo objeto é o recurso atual. As declarações na lista devolvida podem ser acessadas abordando suas posições: Statement.subject , Statement.predicate , respectivo Statement.object .
Retorne o URL da página que representa este RDFRESOURCE.
Retorne o caminho para a página que representa este RDFRESOURCE. Use -o com cuidado.
Este atributo é relevante para renderizar páginas para a íris contendo um identificador de fragmento ( http://superresource#anchor ). Esse atributo é verdadeiro para o super-resistência ( http://superresource ) se for realmente descrito na base de conhecimento especificada.
Este atributo informa se a respectiva instância de um recurso é renderizada no contexto da geração atual do site. Uso: {% if resource.rendered? %}…{% endif %} .
Retorna uma string detalhada representando este recurso.
Sinopse: <resource_iri> | rdf_get
Parâmetros:
<resource_iri> é uma string que representa um recurso RDF, com prefixo ( prefix:name ) ou um IRI completo ( <http://ex.org/name> ). Para fazer referência ao recurso da página atual de uso page.rdf , page ou nil .Descrição: pega o IRI fornecido e retorna o objeto RDFRESource correspondente da sua base de conhecimento. Neste objeto, você pode chamar os métodos conforme descrito no recurso da seção.
Exemplo:
{{'<http://www.ifi.uio.no/INF3580/simpsons>' | rdf_get }}
Resultado:
http://www.ifi.uio.no/INF3580/simpsons Sinopse: <rdf_resource> OR <rdf_resource_string> | rdf_property: <property>, [<lang>] OR [<lang>, <list>] OR [nil, <list>]
Parâmetros:
<rdf_resource> é um rdfresource. Para fazer referência ao recurso da página atual de uso page.rdf , page ou nil .<rdf_resource_string> é uma string representando o IRI de <rdf_resource> .<property> é uma sequência que representa um predicado RDF, com prefixo ( prefix:name ) ou um IRI completo ( <http://ex.org/name> ).<lang> é uma etiqueta de idioma (por exemplo de . Se este parâmetro for omitido, substitua -o por nil .<list> é um valor booleano ( true , false ). Descrição: Retorna o objeto, do triplo <rdf_resource> <predicate> ?object . O objeto retornado pode por qualquer um dos nó do tipo, recurso, literal ou em branco.
Exemplo (padrão):
{% assign resource = '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_get %}
{{ resource | rdf_property: '<http://xmlns.com/foaf/0.1/job>' }}
Resultado:
"unknown"Exemplo (String):
{{ '<http://www.ifi.uio.no/INF3580/simpsons#Homer>' | rdf_property: '<http://xmlns.com/foaf/0.1/job>' }}
Resultado:
"unknown"Exemplo (com linguagem):
{% 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"Exemplo (retornar 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 > Sinopse: <rdf_resource> OR <rdf_resource_string>| rdf_inverse_property: <property>, [<list>]
Parâmetros:
<rdf_resource> é um rdfresource. Para fazer referência ao recurso da página atual de uso page.rdf , page ou nil .<rdf_resource_string> é uma string representando o IRI de <rdf_resource> .<property> é uma sequência que representa um predicado RDF, com prefixo ( prefix:name ) ou um IRI completo ( <http://ex.org/name> ).<list> é um valor booleano ( true , false ). Descrição: O mesmo que RDF_Property, mas em direção inversa. Ele retorna o assunto, do triplo ?subject <predicate> <rdf_resource> O objeto retornado pode por qualquer um dos nó, ou nó em branco.
Exemplos (padrão):
{% 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#BartExemplos (string):
{{ '<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#BartExemplo (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 Sinopse: <rdf_resource> | sparql_query: <query> ou <reference_array> | sparql_query: <query> ou <query> | sparql_query
Parâmetros:
<rdf_resource> é um rdfresource que substituirá ?resourceUri na consulta. Para omitir este parâmetro ou referenciar o recurso da página atual de uso page.rdf , page ou nil .<reference_array> Uma matriz contendo íris como strings ou rdf_resource . Eles substituirão consecutivamente cada um ?resourceUri_<index> em sua consulta.<query> Uma string contendo uma consulta SPARQL. Descrição: Avalia query sobre a base de conhecimento fornecida e retorna uma variedade de resultados (conjunto de resultados). Cada objeto de entrada no conjunto de resultados (resultado) contém as variáveis selecionadas como recursos ou literais. Você pode usar ?resourceUri dentro da consulta para fazer referência ao recurso que é dado como <rdf_resource> .
Exemplo (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 >
...Exemplo (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>
Resultado:
<table>
<tr><td>http://www.ifi.uio.no/INF3580/family#hasSpouse</td></tr>
</table>
Exemplo (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>
Sinopse: <rdf_container_head> **OR** <rdf_container_head_string> | rdf_container
Parâmetros:
<rdf_container_head> é um rdfresource. Para fazer referência ao recurso da página atual de uso page.rdf , page ou nil .<rdf_container_head_string> é uma string representando o IRI de <rdf_container_head> . Descrição: Retorna uma matriz com recursos para cada elemento no contêiner cuja cabeça é referenciada por rdf_container_head .
Exemplos:
{% 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#MaggieExemplos: (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 Sinopse: <rdf_collection_head> OR <rdf_collection_head_string> | rdf_collection ou <rdf_resource> | rdf_collection: "<property>"
Parâmetros:
<rdf_collection_head> é um rdfresource. Para fazer referência ao recurso da página atual de uso page.rdf , page ou nil .<rdf_collection_head_string> é uma string representando o IRI de <rdf_collection_head> .<rdf_resource> é um rdfresource. Para fazer referência ao recurso da página atual de uso page.rdf , page ou nil .<property> é uma sequência que representa um predicado RDF, com prefixo ( prefix:name ) ou um IRI completo ( <http://ex.org/name> ). Descrição: Retorna uma matriz com recursos para cada elemento da coleção cuja cabeça é referenciada por rdf_collection_head . Em vez de referenciar diretamente uma cabeça, também é possível especificar a propriedade que refere -se à cabeça da coleção.
Exemplo (especifique o recurso da cabeça):
{% 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#MaggieExemplo (especifique a string de cabeça):
{% 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#MaggieExemplo (especifique via propriedade):
{% 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| Nome | Parâmetro | Padrão | Descrição | Exemplo |
|---|---|---|---|---|
| caminho | Caminho relativo para o arquivo RDF | sem padrão | Especifica o caminho para o arquivo RDF de onde você deseja renderizar o site | path: "rdf-data/simpsons.ttl" |
| remoto | Seção para especificar uma fonte de dados remota | sem padrão | Tem que conter a tecla de endpoint . O parâmetro remote substitui o parâmetro path . | |
| remoto> endpoint | Endpoint sparql para obter os dados de | sem padrão | Especifica o URL para o terminal Sparql de onde você deseja renderizar o site | remote: endpoint: "http://localhost:5000/sparql/" |
| Remoto> Default_graph | Selecione um gráfico nomeado no terminal para usar no lugar do gráfico padrão do terminal | sem padrão | Especifica o IRI para o gráfico nomeado para selecionar no terminal SPARQL | remote: endpoint: "http://localhost:5000/sparql/" default_graph: "http://example.org/" |
| linguagem | Margem de idioma como string | sem padrão | Especifica o idioma preferido quando você seleciona objetos usando nossos filtros líquidos | language: "en" |
| incluir_blank | Expressão booleana | falso | Especifica se os nós em branco também devem ser renderizados ou não | include_blank: true |
| restrição | Sparql-query como string ou sujeitos/objetos/predicados | sem padrão | Restringe a seleção de recursos com um determinado sparql-query aos resultados vinculados à variável especial ?resourceUri ou aos três subjects das palavras-chave (apenas URIs sujeitos), objects , predicates | restriction: "SELECT ?resourceUri WHERE { ?resourceUri <http://www.ifi.uio.no/INF3580/family#hasFather> <http://www.ifi.uio.no/INF3580/simpsons#Homer> }" |
| restrição_file | Arquivo de recursos a serem renderizados | sem padrão | Restringe a seleção de recursos à lista de recursos no arquivo | restriction_file: _data/restriction.txt |
| default_template | Nome do arquivo do padrão de rdf padrão no diretório _layouts | sem padrão | Especifica o arquivo de modelo que você deseja que Jekyll use para renderizar todos os recursos RDF | default_template: "rdf_index.html" |
| Instância_template_mappings | URI alvo como string: nome do arquivo do modelo como string | sem padrão | Mapas dados URIs para arquivos de modelo para renderizar uma instância individual | instance_template_mappings: "http://www.ifi.uio.no/INF3580/simpsons#Abraham": "abraham.html" |
| Class_template_mappings | URI alvo como string: nome do arquivo do modelo como string | sem padrão | Mapas dados URIs para arquivos de modelos para renderizar todas as instâncias dessa aula | class_template_mappings: "http://xmlns.com/foaf/0.1/Person": "person.html" |
Há também uma imagem do Docker/Podman que tem Jekyll e Jekyll-RDF pré-instalados. Você pode obtê -lo com:
docker pull ghcr.io/aksw/jekyll-rdf:latest
e executá -lo, por exemplo, com
docker run --rm --workdir /page -v $PWD:/page ghcr.io/aksw/jekyll-rdf:latest
ou personalizar a execução de Jekyll com
docker run --rm --workdir /page -v $PWD/sources:/page -v $PWD/build/jekyll:/build ghcr.io/aksw/jekyll-rdf:latest jekyll build -d /build
O ponto de entrada da imagem executa bundle install primeiro e depois executa bundle exec jekyll build ou bundle exec <your command> . Para manter os pacotes instalados entre as execuções, especifique a variável de ambiente BUNDLE_PATH em um local que persiste entre as execuções, por exemplo -e BUNDLE_PATH=.vendor . Para desativar todo o material do Putentler definido NO_BUNDLER como um valor não vazio, o ponto de entrada executará seu comando como é.
| Nome | Padrão | Descrição |
|---|---|---|
BUNDLE_PATH | desmembrado | Defina o caminho em que o Bundler instala os pacotes. Veja também os documentos do Matingler. |
NO_BUNDLER | desmembrado | Defina como um valor não vazio para desativar todas |
Para instalar o projeto com o Git-Repository, você precisará git no seu sistema. O primeiro passo é apenas clonar o repositório:
git clone [email protected]:AKSW/jekyll-rdf.git
Uma pasta chamada jekyll-rdf será gerada automaticamente. Você precisa mudar para esta pasta e compilar a gema Ruby para terminar a instalação:
cd jekyll-rdf
gem build jekyll-rdf.gemspec
gem install jekyll-rdf -*.gem
bundle exec rake test
Toda vez que os testes são executados, a página Jekyll dentro do test/source é processada. Inicie um servidor slim da Web para assistir aos resultados do navegador da web, por exemplo, Pythons SimpleHTTPServer (Python 2, para Python 3 é http.server ):
cd test/source/_site
python -m SimpleHTTPServer 8000
Para gerar o documento da API, navegue para o diretório jekyll-rdf/lib e execute
gem install yard
yardoc *
A documentação gerada é colocada no diretório jekyll-rdf/lib/doc .
O Jekyll-RDF está licenciado sob a licença do MIT.
