jekyll-rdf 3.0.0.pre.develop.302 → 3.0.0.pre.develop.303

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93494a2df03d541c5a01c95fc7758cc9e26d87ac
-  data.tar.gz: 75b976cea3f11059fd86cb237121950756cf6240
+  metadata.gz: 8f346de2c6991c2ec71e1592c5d25930d1687248
+  data.tar.gz: f2d2d7e7df296643875ed1e60bc96379f2ae90f6
 SHA512:
-  metadata.gz: 80dd23d5d88f43c1c458121d4e3628c533c8108f8f8cdf47f58e6e630dae365ad417ac0065024ea869ca2b12a73e5bd6b4e09d65663fb09f9d8c4f313e26f008
-  data.tar.gz: 0e96bed4c96ee9882dae25c6d8e3ebfc984990bee53590ac8e9c2aaec2f1a9aaba07d992c3cff1c496127e7b4b4e431dcfcb39353e7cf328f6c77ca67945a86e
+  metadata.gz: 2bb9da378c60da2e41c1569a9a7df198538f33c450f53e68883a6b9dda3b6d18e827a603363243407600c556b3734fc98ada7e78cf456cb4043e535a3f346ced
+  data.tar.gz: 006da3873315523c57ef25bce40203888755a90a56d433cd3fb3cb307587b5964ca4fdcf4f1e9a78d531a5d2efa8d88886c7b3459332db909004ec61cac81d59

data/lib/jekyll/drops/rdf_resource.rb

@@ -49,8 +49,8 @@ module Jekyll #:nodoc:
       ##
       #
       #
-      def initialize(term, sparql, site = nil, page = nil)
-        super(term, sparql)
+      def initialize(term, site = nil, page = nil)
+        super(term)
         if(site.is_a?(Jekyll::Site))
           @site = site
         end
@@ -161,19 +161,19 @@ module Jekyll #:nodoc:
         case role
           when :subject
             query = "SELECT ?p ?o ?dt ?lit ?lang WHERE{ #{input_uri} ?p ?o BIND(datatype(?o) AS ?dt) BIND(isLiteral(?o) AS ?lit) BIND(lang(?o) AS ?lang)}"
-            sparql.query(query).map do |solution|
+            Jekyll::RdfHelper::sparql.query(query).map do |solution|
               check = check_solution(solution)
               create_statement(term.to_s, solution.p, solution.o, solution.lit, check[:lang], check[:data_type])
             end
           when :predicate
             query = "SELECT ?s ?o ?dt ?lit ?lang WHERE{ ?s #{input_uri} ?o BIND(datatype(?o) AS ?dt) BIND(isLiteral(?o) AS ?lit) BIND(lang(?o) AS ?lang)}"
-            sparql.query(query).map do |solution|
+            Jekyll::RdfHelper::sparql.query(query).map do |solution|
               check = check_solution(solution)
               create_statement(solution.s, term.to_s, solution.o, solution.lit, check[:lang], check[:data_type])
             end
           when :object
             query = "SELECT ?s ?p WHERE{ ?s ?p #{input_uri}}"
-            sparql.query(query).map do |solution|
+            Jekyll::RdfHelper::sparql.query(query).map do |solution|
               create_statement( solution.s, solution.p, term.to_s)
             end
           else
@@ -209,7 +209,7 @@ module Jekyll #:nodoc:
         else
           object = RDF::URI(object_string)
         end
-        return RdfStatement.new(RDF::Statement( subject, predicate, object), @sparql, @site)
+        return RdfStatement.new(RDF::Statement( subject, predicate, object), @site)
       end
 
       private

data/lib/jekyll/drops/rdf_resource_class.rb

@@ -38,13 +38,15 @@ module Jekyll #:nodoc:
       attr_accessor :alternativeTemplates
       attr_accessor :subClasses
       attr_accessor :subClassHierarchyValue
+      attr_reader :sparql
 
       def initialize(term, sparql)
-        super(term, sparql)
+        super(term)
         @subClasses = []
         @lock = -1
         @subClassHierarchyValue = 0
         @alternativeTemplates = []
+        @sparql = sparql
       end
 
       def multiple_templates?
@@ -52,12 +54,7 @@ module Jekyll #:nodoc:
       end
 
       def find_direct_subclasses
-        if(!@term.to_s[0..1].eql? "_:")
-          term_uri = "<#{@term.to_s}>"
-        else
-          term_uri = @term.to_s
-        end
-        query = "SELECT ?s WHERE{ ?s <http://www.w3.org/2000/01/rdf-schema#subClassOf> #{term_uri}}"
+        query = "SELECT ?s WHERE{ ?s <http://www.w3.org/2000/01/rdf-schema#subClassOf> #{@term.to_ntriples}}"
         selection = @sparql.query(query).map{ |solution| solution.s.to_s}
         return selection
       end

data/lib/jekyll/drops/rdf_statement.rb

@@ -52,10 +52,10 @@ module Jekyll
       # * +statement+ - The statement to be represented
       # * +sparql+ - The SPARQL::Client which contains the +statement+
       # * +site+ - The Jekyll::Site to be enriched
-      def initialize(statement, sparql, site)
-        @subject ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.subject, sparql, site)
-        @predicate ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.predicate, sparql, site)
-        @object ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.object, sparql, site)
+      def initialize(statement, site)
+        @subject ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.subject, site)
+        @predicate ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.predicate, site)
+        @object ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.object, site)
       end
 
       def inspect

data/lib/jekyll/drops/rdf_term.rb

@@ -36,31 +36,24 @@ module Jekyll
       #
       attr_reader :term
 
-      ##
-      # The SPARQL::Client which contains the represented +term+
-      #
-      attr_reader :sparql
-
       ##
       # Create a new Jekyll::Drops::RdfTerm
       #
       # * +term+ - The term to be represented
-      # * +sparql+ - The SPARQL::Client which contains the represented +term+
       #
-      def initialize(term, sparql)
+      def initialize(term)
         @term  ||= term
-        @sparql ||= sparql
       end
 
       ##
-      # Funktion stub with no funktionality. Its purpose is to keep RdfResource compatible.
+      # Function stub with no functionality. Its purpose is to keep RdfResource compatible.
       #
       def add_necessities (site, page)
         return self
       end
 
       ##
-      # Funktion stub with no funktionality. Its purpose is to keep RdfResource compatible.
+      # Function stub with no functionality. Its purpose is to keep RdfResource compatible.
       #
       def ready?
         return true;
@@ -69,7 +62,7 @@ module Jekyll
       ##
       # Convert this RdfTerm into a string
       # This should be:
-      # - for resoruces: the IRI
+      # - for resources: the IRI
       # - for literals: the literal representation e.g. "Hallo"@de or "123"^^<http://www.w3.org/2001/XMLSchema#integer>
       #
       def to_s
@@ -91,15 +84,14 @@ module Jekyll
       # Convert an RDF term into a new Jekyll::Drops::RdfTerm
       #
       # * +term+ - The term to be represented
-      # * +sparql+ - The SPARQL::Client which contains the represented +term+
       # * +site+ - The Jekyll::Site to be enriched
       #
-      def self.build_term_drop(term, sparql, site)
+      def self.build_term_drop(term, site)
         case term
         when RDF::URI, RDF::Node
-          return RdfResource.new(term, sparql, site)
+          return RdfResource.new(term, site)
         when RDF::Literal
-          return RdfLiteral.new(term, sparql)
+          return RdfLiteral.new(term,)
         else
           return nil
         end

data/lib/jekyll/filters/rdf_collection.rb

@@ -27,16 +27,12 @@
 module Jekyll
   module RdfCollection
     def rdf_collection(input, predicate = nil)
-      sparql_query = input.sparql
-      unless predicate.nil?
-        predicate = rdf_resolve_prefix(input, predicate)
-      end
       query = "SELECT ?f WHERE{ #{input.term.to_ntriples} " <<
-              (predicate.nil?? "" : " <#{predicate}> ?coll . ?coll ") <<
+              (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 = []
-      sparql_query.query(query).each{ |solution|
-        results.push Jekyll::Drops::RdfTerm.build_term_drop(solution.f, input.sparql, input.site).add_necessities(input.site, input.page)
+      Jekyll::RdfHelper::sparql.query(query).each{ |solution|
+        results.push Jekyll::Drops::RdfTerm.build_term_drop(solution.f, Jekyll::RdfHelper::site).add_necessities(Jekyll::RdfHelper::site, Jekyll::RdfHelper::page)
       }
       return results
     end

data/lib/jekyll/filters/rdf_container.rb

@@ -27,28 +27,29 @@ module Jekyll
   module RdfContainer
     include Jekyll::RdfPrefixResolver
     def rdf_container(input, type = nil)
-      sparql_client = input.sparql
-      if(!(valid_container?(input, sparql_client, type)))
-        Jekyll.logger.error "#{input.term.to_ntriples} is not recognized as a container"
+      sparql_client = Jekyll::RdfHelper::sparql
+      n_triples = input.term.to_ntriples
+      if(!(valid_container?(n_triples, type)))
+        Jekyll.logger.error "#{n_triples} is not recognized as a container"
         return []
       end
-      query = "SELECT ?p ?o WHERE{ #{input.term.to_ntriples} ?p ?o #{query_additions(input, sparql_client)}"
+      query = "SELECT ?p ?o WHERE{ #{n_triples} ?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::Drops::RdfTerm.build_term_drop(solution.o, input.sparql, input.site).add_necessities(input.site, input.page)
+          array << Jekyll::Drops::RdfTerm.build_term_drop(solution.o, Jekyll::RdfHelper::site).add_necessities(Jekyll::RdfHelper::site, Jekyll::RdfHelper::page)
         end
       }
       return solutions
     end
 
-    def query_additions(input, sparql_client)
+    def query_additions()
       return "BIND((<http://www.w3.org/2001/XMLSchema#integer>(SUBSTR(str(?p), 45))) AS ?order) } ORDER BY ASC(?order)"
     end
 
-    def valid_container?(input, sparql_client, type = nil)
-      ask_query1 = "ASK WHERE {VALUES ?o {<http://www.w3.org/2000/01/rdf-schema#Container> <http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq> <http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag> <http://www.w3.org/1999/02/22-rdf-syntax-ns#Alt>} #{input.term.to_ntriples} <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?o}"
-      ask_query2 = "ASK WHERE {#{input.term.to_ntriples} <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?o. ?o <http://www.w3.org/2000/01/rdf-schema#subClassOf>* <http://www.w3.org/2000/01/rdf-schema#Container>}"
-      return (sparql_client.query(ask_query1).true?) || (sparql_client.query(ask_query2).true?)
+    def valid_container?(n_triples, type = nil)
+      ask_query1 = "ASK WHERE {VALUES ?o {<http://www.w3.org/2000/01/rdf-schema#Container> <http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq> <http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag> <http://www.w3.org/1999/02/22-rdf-syntax-ns#Alt>} #{n_triples} <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?o}"
+      ask_query2 = "ASK WHERE {#{ n_triples } <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?o. ?o <http://www.w3.org/2000/01/rdf-schema#subClassOf>* <http://www.w3.org/2000/01/rdf-schema#Container>}"
+      return (Jekyll::RdfHelper::sparql.query(ask_query1).true?) || (Jekyll::RdfHelper::sparql.query(ask_query2).true?)
     end
   end
 end

data/lib/jekyll/filters/rdf_get.rb

@@ -29,32 +29,12 @@ module Jekyll
   # Internal module to hold the medthod #rdf_get
   #
   module RdfGet
+    include Jekyll::RdfPrefixResolver
     def rdf_get(request_uri)
-      request_uri = rdf_resolve_prefix_temp(request_uri)
+      request_uri = rdf_resolve_prefix(request_uri)
       ask_exist = "ASK WHERE {{<#{request_uri}> ?p ?o}UNION{?s <#{request_uri}> ?o}UNION{?s ?p <#{request_uri}>}} "
       return unless (Jekyll::RdfHelper::sparql.query(ask_exist).true?)
-      Jekyll::Drops::RdfResource.new(RDF::URI(request_uri), Jekyll::RdfHelper::sparql, Jekyll::RdfHelper::site, Jekyll::RdfHelper::page)
-    end
-
-    #this is only temporary, we will use Jekyll::RdfPrefixResolver -> rdf_resolve_prefix when we fixed it to 3.0.0
-    private
-    def rdf_resolve_prefix_temp(predicate)
-      if(predicate[0] == "<" && predicate[-1] == ">")
-        return predicate[1..-2]
-      end
-      arr=predicate.split(":",2)  #bad regex, would also devide 'http://example....' into 'http' and '//example....',even though it is already a complete URI; if 'PREFIX http: <http://...> is defined, 'http' in 'http://example....' could be mistaken for a prefix
-      if((arr[1].include? (":")) || (arr[1][0..1].eql?("//")))
-        raise UnMarkedUri.new(predicate, Jekyll::RdfHelper::page.data['template'])
-      end
-      if(!Jekyll::RdfHelper::page.data["rdf_prefixes"].nil?)
-        if(!Jekyll::RdfHelper::page.data["rdf_prefix_map"][arr[0]].nil?)
-          return arr[1].prepend(Jekyll::RdfHelper::page.data["rdf_prefix_map"][arr[0]])
-        else
-          raise NoPrefixMapped.new(predicate, Jekyll::RdfHelper::page.data['template'], arr[0])
-        end
-      else
-        raise NoPrefixesDefined.new(predicate, Jekyll::RdfHelper::page.data['template'])
-      end
+      Jekyll::Drops::RdfResource.new(RDF::URI(request_uri), Jekyll::RdfHelper::site, Jekyll::RdfHelper::page)
     end
   end
 end

data/lib/jekyll/filters/rdf_property.rb

@@ -42,15 +42,15 @@ module Jekyll
       return map_predicate(input, predicate, lang, list)
     end
 
-    def rdf_inverse_property(input, predicate, lang = nil, list = false)
-      return map_predicate(input, predicate, lang, list, true)
+    def rdf_inverse_property(input, predicate, list = false)
+      return map_predicate(input, predicate, nil, list, true)
     end
 
     private
     def map_predicate(input, predicate, lang = nil, list = false, inverse = false)
       return input unless input.is_a?(Jekyll::Drops::RdfResource)
-      predicate = rdf_resolve_prefix(input, predicate)
-      result = filter_statements(input, predicate, inverse, lang)
+      predicate = rdf_resolve_prefix(predicate)
+      result = filter_statements(input.term.to_ntriples, predicate, inverse, lang)
       return unless !result.empty?
       if(list)
         return result
@@ -59,34 +59,27 @@ module Jekyll
       end
     end
 
-    private
-    def filter_statements(input, predicate, inverse = false, lang = nil)
-      client = input.sparql
+    def filter_statements(n_triples, predicate, inverse = false, lang = nil)
+      client = Jekyll::RdfHelper::sparql
       query = ""
       if (lang.eql? 'cfg')
-        lang_query = "FILTER(lang(?o) = '#{input.site.config['jekyll_rdf']['language']}')"
+        lang_query = "FILTER(lang(?o) = '#{Jekyll::RdfHelper::site.config['jekyll_rdf']['language']}')"
       elsif lang.nil?
         lang_query = ""
       else
         lang_query = "FILTER(lang(?o) = '#{lang}')"
       end
 
-      if(!input.to_s[0..1].eql? "_:")
-        input_uri = "<#{input.to_s}>"
-      else
-        input_uri = input.to_s
-      end
-
       if(inverse)
-        query = "SELECT ?s WHERE{ ?s <#{predicate}> #{input_uri} }"
+        query = "SELECT ?s WHERE{ ?s <#{predicate}> #{n_triples} }"
         result = client.query(query).map do |solution|
           subject = RDF::URI(solution.s)
-          Jekyll::Drops::RdfResource.new(subject, input.sparql, input.site, input.page)
+          Jekyll::Drops::RdfResource.new(subject, Jekyll::RdfHelper::site, Jekyll::RdfHelper::page)
         end
       else
-        query = "SELECT ?o ?dt ?lit ?lang WHERE{ #{input_uri} <#{predicate}> ?o BIND(datatype(?o) AS ?dt) BIND(isLiteral(?o) AS ?lit) BIND(lang(?o) AS ?lang) #{lang_query} }"
+        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(input, solution)
+          dist_literal_resource(solution)
         end
       end
       return result
@@ -95,15 +88,14 @@ module Jekyll
     ##
     # Distinguishes the solution between an Literal and a Resource
     #
-    private
-    def dist_literal_resource(input, solution)
+    def dist_literal_resource(solution)
       if solution.lit.true?
         check = check_solution(solution)
         object = RDF::Literal(solution.o, language: check[:lang], datatype: RDF::URI(check[:dataType]))
-        result = Jekyll::Drops::RdfLiteral.new(object, input.sparql)
+        result = Jekyll::Drops::RdfLiteral.new(object)
       else
         object = RDF::URI(solution.o)
-        result = Jekyll::Drops::RdfResource.new(object, input.sparql, input.site, input.page)
+        result = Jekyll::Drops::RdfResource.new(object, Jekyll::RdfHelper::site, Jekyll::RdfHelper::page)
       end
       return result
     end
@@ -111,16 +103,15 @@ module Jekyll
     ##
     # check what language and datatype the passed literal has
     #
-    private
     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
+      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
   end
 end

data/lib/jekyll/filters/rdf_resolve_prefix.rb

@@ -26,22 +26,22 @@
 module Jekyll
   module RdfPrefixResolver
     private
-    def rdf_resolve_prefix(input, predicate)
+    def rdf_resolve_prefix(predicate)
       if(predicate[0] == "<" && predicate[-1] == ">")
         return predicate[1..-2]
       end
       arr=predicate.split(":",2)  #bad regex, would also devide 'http://example....' into 'http' and '//example....',even though it is already a complete URI; if 'PREFIX http: <http://...> is defined, 'http' in 'http://example....' could be mistaken for a prefix
       if((arr[1].include? (":")) || (arr[1][0..1].eql?("//")))
-        raise UnMarkedUri.new(predicate, input.page.data['template'])
+        raise UnMarkedUri.new(predicate, Jekyll::RdfHelper::page.data['template'])
       end
-      if(!input.page.data["rdf_prefixes"].nil?)
-        if(!input.page.data["rdf_prefix_map"][arr[0]].nil?)
-          return arr[1].prepend(input.page.data["rdf_prefix_map"][arr[0]])
+      if(!Jekyll::RdfHelper::page.data["rdf_prefixes"].nil?)
+        if(!Jekyll::RdfHelper::page.data["rdf_prefix_map"][arr[0]].nil?)
+          return arr[1].prepend(Jekyll::RdfHelper::page.data["rdf_prefix_map"][arr[0]])
         else
-          raise NoPrefixMapped.new(predicate, input.page.data['template'], arr[0])
+          raise NoPrefixMapped.new(predicate, Jekyll::RdfHelper::page.data['template'], arr[0])
         end
       else
-        raise NoPrefixesDefined.new(predicate, input.page.data['template'])
+        raise NoPrefixesDefined.new(predicate, Jekyll::RdfHelper::page.data['template'])
       end
     end
   end

data/lib/jekyll/filters/rdf_sparql_query.rb

@@ -37,16 +37,15 @@ module Jekyll
     # * +input+ - the context RDF resource
     # * +query+ - the SPARQL query
     #
-    def sparql_query(input, query)
-      return input unless input.is_a?(Jekyll::Drops::RdfResource)
-      query.gsub!('?resourceUri', "<#{input.term.to_s}>")
-      if(!input.page.data["rdf_prefixes"].nil?)
-        query = query.prepend(" ").prepend(input.page.data["rdf_prefixes"])
+    def sparql_query(query)
+      query.gsub!('?resourceUri', "<#{Jekyll::RdfHelper::page.data['rdf'].term}>") #maybe use this part as optional parameter
+      if(!Jekyll::RdfHelper::page.data["rdf_prefixes"].nil?)
+        query = query.prepend(" ").prepend(Jekyll::RdfHelper::page.data["rdf_prefixes"])
       end
       begin
-        result = input.sparql.query(query).map do |solution|
+        result = Jekyll::RdfHelper::sparql.query(query).map do |solution|
           hsh = solution.to_h
-          hsh.update(hsh){ |k,v| Jekyll::Drops::RdfTerm.build_term_drop(v, input.sparql, input.site).add_necessities(input.site, input.page)}
+          hsh.update(hsh){ |k,v| Jekyll::Drops::RdfTerm.build_term_drop(v, Jekyll::RdfHelper::site).add_necessities(Jekyll::RdfHelper::site, Jekyll::RdfHelper::page)}
           hsh.collect{|k,v| [k.to_s, v]}.to_h
         end
         return result

data/lib/jekyll/rdf_generator_helper.rb

@@ -21,11 +21,11 @@ module Jekyll
         }
       end
 
-      def parse_resources (resources, sparql)
+      def parse_resources (resources)
         @pageResources={};
         @blanknodes=[]
         resources.each do |uri|
-          resource = Jekyll::Drops::RdfResource.new(uri, sparql)
+          resource = Jekyll::Drops::RdfResource.new(uri)
           if(uri.instance_of? RDF::URI)
             uriString = uri.to_s
             if((uriString.include? "#") && (uriString.index("#") < (uriString.length - 1)))   #sorting in uris with a #

data/lib/jekyll/rdf_main_generator.rb

@@ -60,7 +60,7 @@ module Jekyll
       site.data['sparql'] = sparql
       site.data['resources'] = []
 
-      parse_resources(resources, sparql)
+      parse_resources(resources)
 
       mapper = Jekyll::RdfTemplateMapper.new(@config['instance_template_mappings'], @config['class_template_mappings'], @config['default_template'], sparql)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-rdf
 version: !ruby/object:Gem::Version
-  version: 3.0.0.pre.develop.302
+  version: 3.0.0.pre.develop.303
 platform: ruby
 authors:
 - Elias Saalmann