module Jekyll::JekyllRdf::Filter

Internal module to hold the medthod rdf_message

Internal module to hold the method rdf_get

Internal module to hold the medthod rdf_property

Internal module to hold the medthod sparql_query

Public Instance Methods

rdf_collection(input, predicate = nil) click to toggle source
# File lib/jekyll/filters/rdf_collection.rb, line 30
def rdf_collection(input, predicate = nil)
  input = rdf_page_to_resource(input)
  return unless valid_resource?(input)
  input = to_string_wrap(input)
  query = "SELECT ?f WHERE{ #{input} " <<
    (predicate.nil? ? "" : " #{rdf_resolve_prefix(predicate)} ?coll . ?coll ") <<
    " <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest>* ?r. ?r <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> ?f}"
  results = []
  Jekyll::JekyllRdf::Helper::RdfHelper::sparql.query(query).each{ |solution|
    results.push Jekyll::JekyllRdf::Drops::RdfTerm.build_term_drop(solution.f, Jekyll::JekyllRdf::Helper::RdfHelper::site, true).add_necessities(Jekyll::JekyllRdf::Helper::RdfHelper::site, Jekyll::JekyllRdf::Helper::RdfHelper::page)
  }
  return results
end
rdf_container(input, predicate = nil) click to toggle source
# File lib/jekyll/filters/rdf_container.rb, line 29
def rdf_container(input, predicate = nil)
  input = rdf_page_to_resource(input)
  return unless valid_resource?(input)
  sparql_client = Jekyll::JekyllRdf::Helper::RdfHelper::sparql
  n_triples = to_string_wrap(input)
  query = "SELECT ?p ?o WHERE{ #{n_triples} " <<
    (predicate.nil? ? "" : " #{rdf_resolve_prefix(predicate)} ?container . ?container ") <<
    " ?p ?o #{query_additions()}"
  solutions = sparql_client.query(query).each_with_object([]) {|solution, array|
    if(/^http:\/\/www\.w3\.org\/1999\/02\/22-rdf-syntax-ns#_\d+$/.match(solution.p.to_s))
      array << Jekyll::JekyllRdf::Drops::RdfTerm.build_term_drop(solution.o, Jekyll::JekyllRdf::Helper::RdfHelper::site, true).add_necessities(Jekyll::JekyllRdf::Helper::RdfHelper::site, Jekyll::JekyllRdf::Helper::RdfHelper::page)
    end
  }
  return solutions
end
rdf_get(request_uri) click to toggle source
# File lib/jekyll/filters/rdf_get.rb, line 34
def rdf_get(request_uri)
  return request_uri if request_uri.class <= Jekyll::JekyllRdf::Drops::RdfResource
  request_uri = to_string_wrap(rdf_page_to_resource(request_uri))
  return unless valid_resource?(request_uri) && (!request_uri[0..1].eql? "_:")
  request_uri = rdf_resolve_prefix(request_uri)
  Jekyll::JekyllRdf::Helper::RdfHelper.resources(request_uri[1..-2])
end
rdf_inverse_property(input, predicate, list = false) click to toggle source
# File lib/jekyll/filters/rdf_property.rb, line 44
def rdf_inverse_property(input, predicate, list = false)
  return map_predicate(input, predicate, nil, list, true)
end
rdf_property(input, predicate, lang = nil, list = false) click to toggle source

Computes all objects for which statements exist containing the given subject and predicate and returns any of them

  • input - is the subject of the statements to be matched

  • predicate - is the predicate of the statements to be matched

  • lang - (optional) preferred language of a the returned object. The precise implementation of choosing which object to return (both in case a language is supplied and in case is not supplied) is undefined

  • list - (optional) decides the format of the return value. If set to true it returns an array, otherwise it returns a singleton String containing a URI.

# File lib/jekyll/filters/rdf_property.rb, line 40
def rdf_property(input, predicate, lang = nil, list = false)
  return map_predicate(input, predicate, lang, list)
end
sparql_query(resource = nil, query) click to toggle source

Executes a SPARQL query. The supplied query is augmented by replacing each occurence of ‘?resourceUri’ by the URI of the context RDF resource. Returns an Array of bindings. Each binding is a Hash mapping variables to their values.

  • input - the context RDF resource

  • query - the SPARQL query

# File lib/jekyll/filters/rdf_sparql_query.rb, line 40
def sparql_query(resource = nil, query)
  query = prepare_query(resource, query)
  return if query.nil?
  begin
    result = Jekyll::JekyllRdf::Helper::RdfHelper::sparql.query(query)
    if (result.class == RDF::Graph)
      return Jekyll::JekyllRdf::Drops::RdfGraph.new(result)
    end
    result.map! do |solution|
      hsh = solution.to_h
      hsh.update(hsh){ |k,v| Jekyll::JekyllRdf::Drops::RdfTerm.build_term_drop(v, Jekyll::JekyllRdf::Helper::RdfHelper::site, true).add_necessities(Jekyll::JekyllRdf::Helper::RdfHelper::site, Jekyll::JekyllRdf::Helper::RdfHelper::page)}
      hsh.collect{|k,v| [k.to_s, v]}.to_h
    end
    return result
  rescue SPARQL::Client::ClientError => ce
    Jekyll.logger.error("client error experienced: \n #{query} \n Error Message: #{ce.message}")
    raise if Jekyll.env.eql? "development"
  rescue SPARQL::MalformedQuery => mq
    Jekyll.logger.error("malformed query found: \n #{query} \n Error Message: #{mq.message}")
    raise if Jekyll.env.eql? "development"
  rescue Exception => e
    Jekyll.logger.error("unknown Exception of class: #{e.class} in sparql_query \n Query: #{query} \nMessage: #{e.message} \nTrace #{e.backtrace.drop(1).map{|s| "\t#{s}"}.join("\n")}")
    raise if Jekyll.env.eql? "development"
  end
  return []
end

Private Instance Methods

check_solution(solution) click to toggle source

check what language and datatype the passed literal has

# File lib/jekyll/filters/rdf_property.rb, line 106
def check_solution(solution)
  result = {:lang => nil, :dataType => nil}
  if((solution.bound?(:lang)) && (!solution.lang.to_s.eql?("")))
    result[:lang] = solution.lang.to_s.to_sym
  end
  if(solution.bound? :dt)
    result[:dataType] = solution.dt
  end
  return result
end
dist_literal_resource(solution) click to toggle source

Distinguishes the solution between an Literal and a Resource

# File lib/jekyll/filters/rdf_property.rb, line 91
def dist_literal_resource(solution)
  if((solution.lit.instance_of?(RDF::Literal::Boolean) && solution.lit.true? )|| (solution.lit.instance_of?(RDF::Literal::Integer) && solution.lit.nonzero?))#TODO compatibility (to Virtuoso) shouldn't be done inline but in an external file
    check = check_solution(solution)
    object = RDF::Literal(solution.o, language: check[:lang], datatype: RDF::URI(check[:dataType]))
    result = Jekyll::JekyllRdf::Drops::RdfLiteral.new(object)
  else
    object = RDF::URI(solution.o)
    result = Jekyll::JekyllRdf::Helper::RdfHelper.resources(object)
  end
  return result
end
filter_statements(n_triples, predicate, inverse = false, lang = nil) click to toggle source
# File lib/jekyll/filters/rdf_property.rb, line 62
def filter_statements(n_triples, predicate, inverse = false, lang = nil)
  client = Jekyll::JekyllRdf::Helper::RdfHelper::sparql
  query = ""
  if (lang.eql? 'cfg')
    lang_query = "FILTER(lang(?o) = '#{Jekyll::JekyllRdf::Helper::RdfHelper::site.config['jekyll_rdf']['language']}')"
  elsif lang.nil?
    lang_query = ""
  else
    lang_query = "FILTER(lang(?o) = '#{lang}')"
  end

  if(inverse)
    query = "SELECT ?s WHERE{ ?s #{predicate} #{n_triples} }"
    result = client.query(query).map do |solution|
      subject = RDF::URI(solution.s)
      Jekyll::JekyllRdf::Helper::RdfHelper.resources(subject)
    end
  else
    query = "SELECT ?o ?dt ?lit ?lang WHERE{ #{n_triples} #{predicate} ?o BIND(datatype(?o) AS ?dt) BIND(isLiteral(?o) AS ?lit) BIND(lang(?o) AS ?lang) #{lang_query} }"
    result = client.query(query).map do |solution|
      dist_literal_resource(solution)
    end
  end
  return result
end
map_predicate(input, predicate, lang = nil, list = false, inverse = false) click to toggle source
# File lib/jekyll/filters/rdf_property.rb, line 49
def map_predicate(input, predicate, lang = nil, list = false, inverse = false)
  input = rdf_page_to_resource(input)
  return unless valid_resource?(input)
  predicate = rdf_resolve_prefix(predicate)
  result = filter_statements(to_string_wrap(input), predicate, inverse, lang)
  return unless !result.empty?
  if(list)
    return result
  else
    return result.first
  end
end
query_additions() click to toggle source
# File lib/jekyll/filters/rdf_container.rb, line 46
def query_additions()
  return "BIND((<http://www.w3.org/2001/XMLSchema#integer>(SUBSTR(str(?p), 45))) AS ?order) } ORDER BY ASC(?order)"
end