jekyll-rdf 2.0.0 → 2.1.0.alpha.pre.171

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb995c6b66f94be8fafd3b78c74a8bb82858c35f
-  data.tar.gz: 97ad76c5961a904d35919cab1e52ad81fe21aef1
+  metadata.gz: bf67f6f007e203e27966536bdded0e5c552acbda
+  data.tar.gz: 192c1276717719dea8f449d58113a7e05606c731
 SHA512:
-  metadata.gz: a4a626bbd804965f6e5259750ee6458ef9250cbe79f7d5b5cb7f94952b701b73bd7496ffed8296e825f2db68abd42ccfba16d5eed511d5b787d13438fcf68fbf
-  data.tar.gz: e772f781b9ff347c466baa0caa8848d832ce898415feca39d95c63066e7c7567973cdb7f98b21ff83e90dbbcc1407abca6f9b8420c7b0456892b1f450e8dfca3
+  metadata.gz: fe5f7f9cc3881a868dae0a8db88afe0df263d6b0def386921459685e59aa9bd2eecb4375a5015a90b66b4969e99cfdbc2fe87fa636f1003238f1485b2f2a939a
+  data.tar.gz: 2917ae2a2b7852e676e484d0b1c353684296186e9e6c5443551ff99d4e2fcd414369d25a8e1451120dc8ac51227de16880d92d7bb3094780772f2d1838f7d5e7

data/lib/jekyll-rdf.rb

@@ -29,6 +29,7 @@
 require 'jekyll'
 require 'linkeddata'
 require 'sparql'
+require 'set'
 
 require 'jekyll/drops/rdf_term'
 require 'jekyll/drops/rdf_statement'
@@ -38,8 +39,14 @@ require 'jekyll/drops/rdf_resource_class'
 require 'jekyll/exceptions/NoPrefixMapped'
 require 'jekyll/exceptions/NoPrefixesDefined'
 require 'jekyll/exceptions/UnMarkedUri'
+require 'jekyll/filters/rdf_resolve_prefix'
 require 'jekyll/filters/rdf_sparql_query'
 require 'jekyll/filters/rdf_property'
+require 'jekyll/filters/rdf_collection'
+require 'jekyll/filters/rdf_container'
+require 'jekyll/rdf_generator_helper'
 require 'jekyll/rdf_main_generator'
+require 'jekyll/rdf_page_helper'
 require 'jekyll/rdf_page_data'
+require 'jekyll/rdf_class_extraction'
 require 'jekyll/rdf_template_mapper'

data/lib/jekyll/drops/rdf_resource.rb

@@ -51,6 +51,33 @@ module Jekyll #:nodoc:
       #
       attr_accessor :subResources
 
+      ##
+      #
+      #
+      def initialize(term, sparql, site = nil, page = nil)
+        super(term, sparql)
+        if(site.is_a?(Jekyll::Site))
+          @site = site
+        end
+        if(page.is_a?(Jekyll::Page))
+          @page = page
+        end
+      end
+
+      def addNecessities(site, page)
+        if(site.is_a?(Jekyll::Site))
+          @site ||= site
+        end
+        if(page.is_a?(Jekyll::Page))
+          @page ||= page
+        end
+        return self
+      end
+
+      def ready?
+        return (@site.is_a?(Jekyll::Site)||@page.is_a?(Jekyll::Page))
+      end
+
       ##
       # Return a list of Jekyll::Drops::RdfStatements whose subject, predicate or object is the RDF resource represented by the receiver
       #
@@ -120,9 +147,61 @@ module Jekyll #:nodoc:
       #     Return a list of Jekyll::Drops::RdfStatements whose object is the RDF resource represented by the receiver
       #
       def statements_as(role)
-        graph.query(role.to_sym => term).map do |statement|
-          RdfStatement.new(statement, graph, site)
+        if(!term.to_s[0..1].eql? "_:")
+          inputURI = "<#{term.to_s}>"
+        elsif(:predicate.eql? role)
+          return []
+        else
+          inputURI = term.to_s
+        end
+
+        case role
+          when :subject
+            query = "SELECT ?p ?o ?dt ?lit ?lang WHERE{ #{inputURI} ?p ?o BIND(datatype(?o) AS ?dt) BIND(isLiteral(?o) AS ?lit) BIND(lang(?o) AS ?lang)}"
+            sparql.query(query).map do |solution|
+              check = checkSolution(solution)
+              createStatement(term.to_s, solution.p, solution.o, solution.lit, check[:lang], check[:dataType])
+            end
+          when :predicate
+            query = "SELECT ?s ?o ?dt ?lit ?lang WHERE{ ?s #{inputURI} ?o BIND(datatype(?o) AS ?dt) BIND(isLiteral(?o) AS ?lit) BIND(lang(?o) AS ?lang)}"
+            sparql.query(query).map do |solution|
+              check = checkSolution(solution)
+              createStatement(solution.s, term.to_s, solution.o, solution.lit, check[:lang], check[:dataType])
+            end
+          when :object
+            query = "SELECT ?s ?p WHERE{ ?s ?p #{inputURI}}"
+            sparql.query(query).map do |solution|
+              createStatement( solution.s, solution.p, term.to_s)
+            end
+          else
+            Jekyll.logger.error "Not existing role found in #{term.to_s}"
+            return
+        end
+      end
+
+      #checks if a query solution contains a language or type tag and returns those in a hash
+      private
+      def checkSolution(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
+
+      private
+      def createStatement(subjectString, predicateString, objectString, isLit = nil, lang = nil, dataType = nil)
+        subject = RDF::URI(subjectString)
+        predicate = RDF::URI(predicateString)
+        if(!isLit.nil?&&isLit.true?)
+          object = RDF::Literal(objectString, language: lang, datatype: RDF::URI(dataType))
+        else
+          object = RDF::URI(objectString)
         end
+        return RdfStatement.new(RDF::Statement( subject, predicate, object), @sparql, @site)
       end
 
       private
@@ -131,38 +210,43 @@ module Jekyll #:nodoc:
       # * +domain_name+
       #
       def generate_file_name(domain_name, baseurl)
-        begin
-          uri = URI::split(term.to_s)
-          file_name = "rdfsites/" # in this directory all external RDF sites are stored
-          if (uri[2] == domain_name)
-            file_name = ""
-            uri[0] = nil
-            uri[2] = nil
-            if(uri[5].length > baseurl.length)
-              if(uri[5][0..(baseurl.length)].eql? (baseurl + "/"))
-                uri[5] = uri[5][(baseurl.length)..-1]
+        if(term.to_s[0..1].eql? "_:")
+          file_name = "rdfsites/blanknode/#{term.to_s}/"
+        else
+          begin
+            uri = URI::split(term.to_s)
+            file_name = "rdfsites/" # in this directory all external RDF sites are stored
+            if (uri[2] == domain_name)
+              file_name = ""
+              uri[0] = nil
+              uri[2] = nil
+              if(uri[5].length > baseurl.length)
+                if(uri[5][0..(baseurl.length)].eql? (baseurl + "/"))
+                  uri[5] = uri[5][(baseurl.length)..-1]
+                end
+              elsif(uri[5].eql?(baseurl))
+                uri[5] = nil
               end
-            elsif(uri[5].eql?(baseurl))
-              uri[5] = nil
             end
-          end
-          (0..8).each do |i|
-            if !(uri[i].nil?)
-              case i
-              when 5
-                file_name += "#{uri[i][1..-1]}/"
-              when 8
-                file_name += "#/#{uri[i]}"
-              else
-               file_name += "#{uri[i]}/"
+            (0..8).each do |i|
+              if !(uri[i].nil?)
+                case i
+                when 5
+                  file_name += "#{uri[i][1..-1]}/"
+                when 8
+                  file_name += "#/#{uri[i]}"
+                else
+                  file_name += "#{uri[i]}/"
+                end
               end
             end
+            unless file_name[-1] == '/'
+              file_name += '/'
+            end
+          rescue URI::InvalidURIError #unclean coding: blanknodes are recognized through errors
+            file_name = "invalids/#{term.to_s}"
+            Jekyll.logger.error("Invalid resource found: #{term.to_s} is not a proper uri")
           end
-          unless file_name[-1] == '/'
-            file_name += '/'
-          end
-        rescue URI::InvalidURIError #unclean coding: blanknodes are recognized through errors
-          file_name = "rdfsites/blanknode/#{term.to_s}/"
         end
         file_name = file_name.gsub('_','_u')
         file_name = file_name.gsub('//','/') # needs a better regex to include /// ////...

data/lib/jekyll/drops/rdf_resource_class.rb

@@ -39,8 +39,8 @@ module Jekyll #:nodoc:
       attr_accessor :subClasses
       attr_accessor :subClassHierarchyValue
 
-      def initialize(term, graph)
-        super(term, graph)
+      def initialize(term, sparql)
+        super(term, sparql)
         @subClasses = []
         @lock = -1
         @subClassHierarchyValue = 0
@@ -52,7 +52,13 @@ module Jekyll #:nodoc:
       end
 
       def findDirectSubClasses
-        selection = statements_as(:object).select{ |s| s.predicate.term.to_s=="http://www.w3.org/2000/01/rdf-schema#subClassOf" }
+        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}}"
+        selection = @sparql.query(query).map{ |solution| solution.s.to_s}
         return selection
       end
 

data/lib/jekyll/drops/rdf_statement.rb

@@ -50,12 +50,12 @@ module Jekyll
       # Create a new Jekyll::Drops::RdfStatement
       #
       # * +statement+ - The statement to be represented
-      # * +graph+ - The RDF::Graph which contains the +statement+
+      # * +sparql+ - The SPARQL::Client which contains the +statement+
       # * +site+ - The Jekyll::Site to be enriched
-      def initialize(statement, graph, site)
-        @subject ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.subject, graph, site)
-        @predicate ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.predicate, graph, site)
-        @object ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.object, graph, site)
+      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)
       end
     end
   end

data/lib/jekyll/drops/rdf_term.rb

@@ -37,19 +37,33 @@ module Jekyll
       attr_reader :term
 
       ##
-      # The RDF::Graph which contains the represented +term+
+      # The SPARQL::Client which contains the represented +term+
       #
-      attr_reader :graph
+      attr_reader :sparql
 
       ##
       # Create a new Jekyll::Drops::RdfTerm
       #
       # * +term+ - The term to be represented
-      # * +graph+ - The RDF::Graph which contains the represented +term+
+      # * +sparql+ - The SPARQL::Client which contains the represented +term+
       #
-      def initialize(term, graph)
+      def initialize(term, sparql)
         @term  ||= term
-        @graph ||= graph
+        @sparql ||= sparql
+      end
+
+      ##
+      # Funktion stub with no funktionality. Its purpose is to keep RdfResource compatible.
+      #
+      def addNecessities (site, page)
+        return self
+      end
+
+      ##
+      # Funktion stub with no funktionality. Its purpose is to keep RdfResource compatible.
+      #
+      def ready?
+        return true;
       end
 
       ##
@@ -66,18 +80,15 @@ module Jekyll
       # Convert an RDF term into a new Jekyll::Drops::RdfTerm
       #
       # * +term+ - The term to be represented
-      # * +graph+ - The RDF::Graph which contains the represented +term+
+      # * +sparql+ - The SPARQL::Client which contains the represented +term+
       # * +site+ - The Jekyll::Site to be enriched
       #
-      def self.build_term_drop(term, graph, site)
+      def self.build_term_drop(term, sparql, site)
         case term
         when RDF::URI, RDF::Node
-          if site
-            resource = site.data['resources'].find{ |r| r.term == term }
-          end
-          resource ? resource : RdfResource.new(term, graph)
+          return RdfResource.new(term, sparql)
         when RDF::Literal
-          return RdfLiteral.new(term, graph)
+          return RdfLiteral.new(term, sparql)
         else
           return nil
         end

data/lib/jekyll/filters/rdf_collection.rb

@@ -0,0 +1,57 @@
+##
+# MIT License
+#
+# Copyright (c) 2016 Elias Saalmann, Christian Frommert, Simon Jakobi,
+# Arne Jonas Präger, Maxi Bornmann, Georg Hackel, Eric Füg
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+
+module Jekyll
+  module RdfCollection
+    def rdf_collection(input)
+      if(input.statements_as_subject.any?{ |statement|
+        statement.predicate.to_s.eql? "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest"
+      })
+        finalizedContainer = Set.new #avoid loops
+        nodeSequence = [input.iri]
+        nextSequence = []
+        results = []
+        sparqlClient = input.sparql
+        while(!nodeSequence.empty?)
+          currentContainer = nodeSequence.pop
+          query = "SELECT ?f ?r WHERE{ <#{currentContainer}> <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> ?r. <#{currentContainer}> <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> ?f}"
+          solutions = sparqlClient.query(query).each { |solution|
+            if((!solution.r.to_s.eql? "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil") && (finalizedContainer.add? solution.r))
+              nextSequence.push solution.r.to_s
+            end
+            results.push Jekyll::Drops::RdfTerm.build_term_drop(solution.f, input.sparql, input.site).addNecessities(input.site, input.page)
+            if(nodeSequence.empty?)
+              nodeSequence = nextSequence
+              nextSequence = []
+            end
+          }
+          end
+        return results
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::RdfCollection)

data/lib/jekyll/filters/rdf_container.rb

@@ -0,0 +1,51 @@
+##
+# MIT License
+#
+# Copyright (c) 2016 Elias Saalmann, Christian Frommert, Simon Jakobi,
+# Arne Jonas Präger, Maxi Bornmann, Georg Hackel, Eric Füg
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+
+module Jekyll
+  module RdfContainer
+    include Jekyll::RdfPrefixResolver
+    def rdf_container(input, type = nil)
+      sparqlClient = input.sparql
+      if(!(validContainer?(input, sparqlClient, type)))
+        Jekyll.logger.error "<#{input.iri}> is not recognized as a container"
+        return []
+      end
+      query = "SELECT ?p ?o WHERE{ <#{input.iri}> ?p ?o }"
+      solutions = sparqlClient.query(query).each_with_object([]) {|solution, array|
+        if((solution.p.to_s[0..43].eql? "http://www.w3.org/1999/02/22-rdf-syntax-ns#_") && (solution.p.to_s[44..-1] !~ /\D/))
+          array << Jekyll::Drops::RdfTerm.build_term_drop(solution.o, input.sparql, input.site).addNecessities(input.site, input.page)
+        end
+      }
+      return solutions
+    end
+    def validContainer?(input, sparqlClient, type = nil)
+      askQuery1 = "ASK WHERE {VALUES ?o {<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.iri}> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?o}"
+      askQuery2 = "ASK WHERE {<#{input.iri}> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?o. ?o <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/01/rdf-schema#Container>}"
+      return (sparqlClient.query(askQuery1).true?) || (sparqlClient.query(askQuery2).true?)
+    end
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::RdfContainer)

data/lib/jekyll/filters/rdf_property.rb

@@ -29,6 +29,7 @@ module Jekyll
   # Internal module to hold the medthod #rdf_property
   #
   module RdfProperty
+    include Jekyll::RdfPrefixResolver
     ##
     # Computes all objects for which statements exist containing the given subject and predicate and returns any of them
     #
@@ -38,51 +39,88 @@ module Jekyll
     # * +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.
     #
     def rdf_property(input, predicate, lang = nil, list = false)
+      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)
+    end
+
+    private
+    def map_predicate(input, predicate, lang = nil, list = false, inverse = false)
       return input unless input.is_a?(Jekyll::Drops::RdfResource)
-      begin
-        predicate = rdf_resolve_prefix(input, predicate)
-        result = input.statements_as_subject.select{ |s| s.predicate.term.to_s == predicate }
-        if lang != nil
-          if lang == 'cfg'
-            lang = input.site.config['jekyll_rdf']['language']
-          end
-          result = result.select{ |s|
-            if(s.object.term.is_a?(RDF::Literal))
-              s.object.term.language == lang.to_sym
-            else
-              false
-            end
-          }
-        end
-        return unless !result.empty?
-        if(list)
-          return result.map{|p|
-            p.object.to_s
-          }
-        else
-          return (result.first.object).to_s
-        end
+      predicate = rdf_resolve_prefix(input, predicate)
+      result = filter_statements(input, predicate, inverse, lang)
+      return unless !result.empty?
+      if(list)
+        return result
+      else
+        return result.first
       end
     end
 
     private
-    def rdf_resolve_prefix(input, predicate)
-      if(predicate[0] == "<" && predicate[-1] == ">")
-        return predicate[1..-2]
+    def filter_statements(input, predicate, inverse = false, lang = nil)
+      client = input.sparql
+      query = ""
+      if (lang.eql? 'cfg')
+        lang_query = "FILTER(lang(?o) = '#{input.site.config['jekyll_rdf']['language']}')"
+      elsif lang.nil?
+        lang_query = ""
+      else
+        lang_query = "FILTER(lang(?o) = '#{lang}')"
       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'])
+
+      if(!input.to_s[0..1].eql? "_:")
+        input_uri = "<#{input.to_s}>"
+      else
+        input_uri = input.to_s
       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]])
-        else
-          raise NoPrefixMapped.new(predicate, input.page.data['template'], arr[0])
+
+      if(inverse)
+        query = "SELECT ?s WHERE{ ?s <#{predicate}> #{input_uri} }"
+        result = client.query(query).map do |solution|
+          subject = RDF::URI(solution.s)
+          Jekyll::Drops::RdfResource.new(subject, input.sparql, input.site, input.page)
         end
       else
-        raise NoPrefixesDefined.new(predicate, input.page.data['template'])
+        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} }"
+        result = client.query(query).map do |solution|
+          dist_literal_resource(input, solution)
+        end
       end
+      return result
+    end
+
+    ##
+    # Distinguishes the solution between an Literal and a Resource
+    #
+    private
+    def dist_literal_resource(input, 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)
+      else
+        object = RDF::URI(solution.o)
+        result = Jekyll::Drops::RdfResource.new(object, input.sparql, input.site, input.page)
+      end
+      return result
+    end
+
+    ##
+    # 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
     end
   end
 end

data/lib/jekyll/filters/rdf_resolve_prefix.rb

@@ -0,0 +1,48 @@
+##
+# MIT License
+#
+# Copyright (c) 2016 Elias Saalmann, Christian Frommert, Simon Jakobi,
+# Arne Jonas Präger, Maxi Bornmann, Georg Hackel, Eric Füg
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+
+module Jekyll
+  module RdfPrefixResolver
+    private
+    def rdf_resolve_prefix(input, 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'])
+      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]])
+        else
+          raise NoPrefixMapped.new(predicate, input.page.data['template'], arr[0])
+        end
+      else
+        raise NoPrefixesDefined.new(predicate, input.page.data['template'])
+      end
+    end
+  end
+end

data/lib/jekyll/filters/rdf_sparql_query.rb

@@ -44,10 +44,9 @@ module Jekyll
         query = query.prepend(" ").prepend(input.page.data["rdf_prefixes"])
       end
       begin
-        input.site.data['sparql']
-        result = input.site.data['sparql'].query(query).map do |solution|
-          hsh = solution.to_hash
-          hsh.update(hsh){ |k,v| Jekyll::Drops::RdfTerm.build_term_drop(v, input.graph, input.site) }
+        result = input.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).addNecessities(input.site, input.page)}
           hsh.collect{|k,v| [k.to_s, v]}.to_h
         end
         return result
@@ -56,7 +55,7 @@ module Jekyll
       rescue SPARQL::MalformedQuery => mq
         Jekyll.logger.error("malformed query found: \n #{query} \n Error Message: #{mq.message}")
       rescue Exception => e
-        Jekyll.logger.error("unknown Exception of class: #{e.class} in sparql_query \n Query: #{query} \nMessage: #{e.message}")
+        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")}")
       end
       return []
     end

data/lib/jekyll/rdf_class_extraction.rb

@@ -0,0 +1,35 @@
+module Jekyll
+  module RdfClassExtraction
+    private
+      def search_for_classes(sparql)
+        class_recognition_query = "SELECT DISTINCT ?resourceUri WHERE{ {?resourceUri <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?o} UNION{ ?s <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?resourceUri} UNION{ ?s <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?resourceUri}}"
+        class_search_results = sparql.query(class_recognition_query).map{ |sol| sol[:resourceUri] }.reject do |s|  # Reject literals
+          s.class <= RDF::Literal
+        end.select do |s|  # Select URIs and blank nodes in case of include_blank
+          s.class <=RDF::Node || s.class <= RDF::URI
+        end
+        return class_search_results
+      end
+
+      def create_resource_class(class_search_results, sparql)
+	      class_search_results.each do |uri|
+	        @classResources[uri.to_s]=Jekyll::Drops::RdfResourceClass.new(uri, sparql)
+	      end
+
+        @classResources.each{|key, value|
+          value.findDirectSubClasses.each{|s|
+            value.addSubClass(@classResources[s])
+          }
+        }
+      end
+
+      def assign_class_templates(classes_to_templates)
+        if(classes_to_templates.is_a?(Hash))
+          classes_to_templates.each{|key, value|
+            @classResources[key].propagateTemplate(value,0)
+            @classResources[key].traverseHierarchyValue(0);
+          }
+        end
+      end
+  end
+end

data/lib/jekyll/rdf_generator_helper.rb

@@ -0,0 +1,119 @@
+module Jekyll
+  module RdfGeneratorHelper
+    private
+      def prepare_pages (site, mapper)
+        @pageResources.each{|uri, entry|
+          if(entry['./'].nil?)
+            if(@config['render_orphaned_uris'])
+              entry.each{|name, resource|
+                createPage(site, resource, mapper, @global_config)
+              }
+            end
+          else
+            resource = entry.delete('./')
+            resource.subResources = entry
+            createPage(site, resource, mapper, @global_config)
+          end
+        }
+
+        @blanknodes.each{|resource|
+          createPage(site, resource, mapper, @global_config)
+        }
+      end
+
+      def parse_resources (resources, sparql)
+        @pageResources={};
+        @blanknodes=[]
+        resources.each do |uri|
+          resource = Jekyll::Drops::RdfResource.new(uri, sparql)
+          if(uri.instance_of? RDF::URI)
+            uriString = uri.to_s
+            if((uriString.include? "#") && (uriString.index("#") < (uriString.length - 1)))   #sorting in uris with a #
+              preSufUri = uriString.split("#")
+              if(!@pageResources.key? preSufUri[0])
+                @pageResources[preSufUri[0]] = {}
+              end
+              @pageResources[preSufUri[0]][preSufUri[1]] = resource
+            else                                  #sorting in uris without a #
+              if(!@pageResources.key? uriString)
+                @pageResources[uriString]={}
+              end
+              @pageResources[uriString]['./'] = resource
+            end
+          elsif(uri.instance_of? RDF::Node)
+            @blanknodes << resource
+          end
+        end
+      end
+
+      def load_config (site)
+        begin
+         @config = site.config.fetch('jekyll_rdf')
+        rescue KeyError => e
+          Jekyll.logger.error("You've included Jekyll-RDF, but it is not configured. Aborting the jekyll-rdf plugin.")
+          return false
+        end
+
+        @global_config = Jekyll.configuration({})
+
+        #small fix because global_config doesn't work in a test enviorment
+        if(!@global_config.key? "url")
+          @global_config["url"] = site.config["url"]
+          @global_config["baseurl"] = site.config["baseurl"]
+        end
+        return true
+      end
+      ##
+      # #extract_resources returns resources from an RDF Sparql endpoint.
+      #
+      # Literals are omitted.
+      # Blank nodes are only returned if +include_blank+ is true.
+      # Duplicate nodes are removed.
+      #
+      # * +selection+ - choose any of the following:
+      #   nil ::
+      #     no restrictions, return subjects, predicates, objects
+      #   "subjects" ::
+      #     return only subjects
+      #   "predicates" ::
+      #     return only predicates
+      #   "objects" ::
+      #     return only objects
+      #   Otherwise ::
+      #     consider +selection+ to be a SPARQL query and return answer set to this SPARQL query
+      # * +include_blank+ - If true, blank nodes are also returned, otherwise blank nodes are omitted
+      # * +sparql+ - The SPARQL client to run queries against
+      #
+      def extract_resources(selection, include_blank, sparql)
+
+        case selection
+        when nil  # Config parameter not present
+          object_resources    = extract_resources("objects",    include_blank, sparql)
+          subject_resources   = extract_resources("subjects",   include_blank, sparql)
+          predicate_resources = extract_resources("predicates", include_blank, sparql)
+          return object_resources.concat(subject_resources).concat(predicate_resources).uniq
+        when "objects"
+          query = "SELECT ?resourceUri WHERE{?s ?p ?resourceUri}"
+        when "subjects"
+          query = "SELECT ?resourceUri WHERE{?resourceUri ?p ?o}"
+        when "predicates"
+          query = "SELECT ?resourceUri WHERE{?s ?resourceUri ?o}"
+        else
+          # Custom query
+          query = selection
+        end
+        sparql.query(query).map{ |sol| sol[:resourceUri] }.reject do |s|  # Reject literals
+          s.class <= RDF::Literal
+        end.select do |s|  # Select URIs and blank nodes in case of include_blank
+          include_blank || s.class == RDF::URI
+        end.uniq
+      end
+
+      def createPage(site, resource, mapper, global_config)
+        page = RdfPageData.new(site, site.source, resource, mapper, global_config)
+        if(page.complete)
+          site.pages << page
+        end
+      end
+  end
+end

data/lib/jekyll/rdf_main_generator.rb

@@ -32,6 +32,7 @@ module Jekyll
   class RdfMainGenerator < Jekyll::Generator
     safe true
     priority :highest
+    include Jekyll::RdfGeneratorHelper
 
     ##
     # #generate performs the enrichment of a Jekyll::Site with rdf triples
@@ -40,127 +41,28 @@ module Jekyll
     #
     def generate(site)
 
-      begin
-        config = site.config.fetch('jekyll_rdf')
-      rescue Exception
-        Jekyll.logger.error("You've included Jekyll-RDF, but it is not configured. Aborting the jekyll-rdf plugin.")
-        return
+      if(!load_config(site))
+        return false#in case of error, exit routine
       end
-
-      global_config = Jekyll.configuration({})
-
-      #small fix because global_config doesn't work in a test enviorment
-      if(!global_config.key? "url")
-        global_config["url"] = site.config["url"]
-        global_config["baseurl"] = site.config["baseurl"]
-      end
-
-      if(config.key? "template_mapping")
+      if(@config.key? "template_mapping")
         Jekyll.logger.error("Outdated format in _config.yml:\n  'template_mapping' detected but the following keys must be used now instead:\n    instance_template_mappings -> maps single resources to single layouts\n    class_template_mappings -> maps entire classes of resources to layouts\nJekyll-RDF wont render any pages for #{site.source}")
-        return
+        return false
       end
 
-      graph = RDF::Graph.load(config['path'])
+      graph = RDF::Graph.load(@config['path'])
       sparql = SPARQL::Client.new(graph)
 
       # restrict RDF graph with restriction
-      resources = extract_resources(config['restriction'], config['include_blank'], graph, sparql)
-
+      resources = extract_resources(@config['restriction'], @config['include_blank'], sparql)
       site.data['sparql'] = sparql
       site.data['resources'] = []
 
-      #parse resources
-      pageResources={};
-      blanknodes=[]
-      resources.each do |uri|
-        resource = Jekyll::Drops::RdfResource.new(uri, graph)
-        if(uri.instance_of? RDF::URI)
-          uriString = uri.to_s
-          if((uriString.include? "#") && (uriString.index("#") < (uriString.length - 1)))   #sorting in uris with a #
-            preSufUri = uriString.split("#")
-            if(!pageResources.key? preSufUri[0])
-              pageResources[preSufUri[0]] = {}
-            end
-            pageResources[preSufUri[0]][preSufUri[1]] = resource
-          elsif                                  #sorting in uris without a #
-            if(!pageResources.key? uriString)
-              pageResources[uriString]={}
-            end
-            pageResources[uriString]['./'] = resource
-          end
-        elsif(uri.instance_of? RDF::Node)
-          blanknodes << resource
-        end
-      end
-
-      mapper = Jekyll::RdfTemplateMapper.new(config['instance_template_mappings'], config['class_template_mappings'], config['default_template'], graph, sparql)
-
-      # create RDF pages for each URI
-      pageResources.each{|uri, entry|
-        if(entry['./'].nil?)
-          if(config['render_orphaned_uris'])
-            entry.each{|name, resource|
-              site.pages << RdfPageData.new(site, site.source, resource, mapper, global_config)
-            }
-          end
-        else
-          resource = entry.delete('./')
-          resource.subResources = entry
-          site.pages << RdfPageData.new(site, site.source, resource, mapper, global_config)
-        end
-      }
+      parse_resources(resources, sparql)
 
-      blanknodes.each{|resource|
-        site.pages << RdfPageData.new(site, site.source, resource, mapper, global_config)
-      }
-    end
-
-    ##
-    # #extract_resources returns resources from an RDF graph.
-    #
-    # Literals are omitted.
-    # Blank nodes are only returned if +include_blank+ is true.
-    # Duplicate nodes are removed.
-    #
-    # * +selection+ - choose any of the following:
-    #   nil ::
-    #     no restrictions, return subjects, predicates, objects
-    #   "subjects" ::
-    #     return only subjects
-    #   "predicates" ::
-    #     return only predicates
-    #   "objects" ::
-    #     return only objects
-    #   Otherwise ::
-    #     consider +selection+ to be a SPARQL query and return answer set to this SPARQL query
-    # * +include_blank+ - If true, blank nodes are also returned, otherwise blank nodes are omitted
-    # * +graph+ - The RDF graph to restrict
-    # * +sparql+ - The SPARQL client to run queries against
-    #
-    def extract_resources(selection, include_blank, graph, sparql)
+      mapper = Jekyll::RdfTemplateMapper.new(@config['instance_template_mappings'], @config['class_template_mappings'], @config['default_template'], sparql)
 
-      case selection
-      when nil  # Config parameter not present
-        object_resources    = extract_resources("objects",    include_blank, graph, sparql)
-        subject_resources   = extract_resources("subjects",   include_blank, graph, sparql)
-        predicate_resources = extract_resources("predicates", include_blank, graph, sparql)
-        return object_resources.concat(subject_resources).concat(predicate_resources).uniq
-      when "objects"
-        graph.objects
-      when "subjects"
-        graph.subjects
-      when "predicates"
-        graph.predicates
-      else
-        # Custom query
-        sparql.query(selection).map{ |sol| sol[:resourceUri] }
-      end.reject do |s|  # Reject literals
-        s.class <= RDF::Literal
-      end.select do |s|  # Select URIs and blank nodes in case of include_blank
-        include_blank || s.class == RDF::URI
-      end.uniq
+      prepare_pages(site, mapper)
+      return true
     end
-
   end
-
 end

data/lib/jekyll/rdf_page_data.rb

@@ -29,6 +29,8 @@ module Jekyll
   # JekyllRdf::RdfPageData creates pages for each RDF resource using a given template
   #
   class RdfPageData < Jekyll::Page
+    include Jekyll::RdfPageHelper
+    attr_reader :complete
 
     ##
     # initialize initializes the page
@@ -42,37 +44,24 @@ module Jekyll
       @base = base
       @dir = ""
       @name = resource.filename(URI::split(config['url'])[2], config['baseurl'])
+      @resource = resource
+      if(base.nil?)
+        Jekyll.logger.warn "Resource #{resource} not rendered: no base url found."
+        @complete = false   #TODO: set a return here and adapt the test for displaying a warning for rendering a page without template
+      else
+        @complete = true
+      end
       self.process(@name)
+      map_template(resource, mapper)
 
-      template = mapper.map(resource)
-      self.read_yaml(File.join(base, '_layouts'), template)
-      self.data['title'] = resource.iri
-      self.data['rdf'] = resource
-      self.data['template'] = template
-      if(!resource.subResources.nil?)
-        self.data['sub_rdf'] = resource.subResources.values
-        self.data['sub_rdf'].each { |res|
-          res.page = self
-          res.site = site
-        }
-      end
-      if !self.data["rdf_prefix_path"].nil?
-        begin
-          prefixFile=File.new(File.join(base, 'rdf-data', self.data["rdf_prefix_path"].strip)).readlines
-          self.data["rdf_prefixes"] = prefixFile.join(" ")
-          self.data["rdf_prefix_map"] = Hash[ *(prefixFile.collect { |v|
-            arr = v.split(":",2)
-            [arr[0][7..-1].strip, arr[1].strip[1..-2]]
-          }.flatten)]
-        rescue Errno::ENOENT => ex
-          Jekyll.logger.error("context: #{resource}  template: #{template}  file not found: #{File.join(base, 'rdf-data', self.data["rdf_prefix_path"])}")
-        end
+      if(!@complete)
+        return        #return if something went wrong
       end
+      load_data(site)
+      load_prefixes()
       resource.page = self
       resource.site = site
       site.data['resources'] << resource
     end
-
   end
-
-end
+end

data/lib/jekyll/rdf_page_helper.rb

@@ -0,0 +1,54 @@
+module Jekyll
+  module RdfPageHelper
+    private
+      ##
+      # sets @template to the path of a fitting layout
+      # it will set @complete to false if no fitting template is found
+      # * +resource+ - the resource that will be mapped to a template
+      # * +mapper+ - the mapper that provides the resource mappings
+      def map_template(resource, mapper)
+        @template = mapper.map(resource)
+        if(@template.nil?)
+          Jekyll.logger.warn("Resource #{resource} not rendered: No fitting template or default template found.")
+          @complete = false
+        end
+      end
+
+      ##
+      # loads the data from the yaml-frontmatter and extends page.data with three key value pairs:
+      # -title -> contains the resource.iri
+      # -rdf -> contains the resource itself
+      # -template -> contains the path to the currenly used template
+      def load_data(site)
+        self.read_yaml(File.join(@base, '_layouts'), @template)
+        self.data['title'] = @resource.iri
+        self.data['rdf'] = @resource
+        self.data['template'] = @template
+        if(!@resource.subResources.nil?)
+          self.data['sub_rdf'] = @resource.subResources.values
+          self.data['sub_rdf'].each { |res|
+            res.page = self
+            res.site = site
+          }
+        end
+      end
+
+      ##
+      # loads the prefix data passed in the layout yaml-frontmatter into page.data["rdf_prefixes"] and page.data["rdf_prefix_map"]
+      def load_prefixes
+        if !self.data["rdf_prefix_path"].nil?
+          begin
+            prefixFile=File.new(File.join(@base, 'rdf-data', self.data["rdf_prefix_path"].strip)).readlines
+            self.data["rdf_prefixes"] = prefixFile.join(" ")
+            self.data["rdf_prefix_map"] = Hash[ *(prefixFile.collect { |v|
+              arr = v.split(":",2)
+              [arr[0][7..-1].strip, arr[1].strip[1..-2]]
+            }.flatten)]
+          rescue Errno::ENOENT => ex
+            Jekyll.logger.error("context: #{@resource}  template: #{@template}  file not found: #{File.join(@base, 'rdf-data', self.data["rdf_prefix_path"])}")
+          end
+        end
+      end
+  end
+end
+

data/lib/jekyll/rdf_template_mapper.rb

@@ -44,40 +44,20 @@ module Jekyll
 
     attr_accessor :classResources
 
+    include Jekyll::RdfClassExtraction
+
     ##
     # Create a new Jekyll::RdfTemplateMapper
     #
     # * +resources_to_templates+ - A Hash mapping a type resource to a template name
     # * +default_template+ - Default template name
-    def initialize(resources_to_templates, classes_to_templates, default_template, graph, sparql)
+    def initialize(resources_to_templates, classes_to_templates, default_template, sparql)
       @resources_to_templates = resources_to_templates
       @default_template = default_template
       @classes_to_templates = classes_to_templates
-
       @classResources = {}
-      classRecognitionQuery = "SELECT DISTINCT ?resourceUri WHERE{ {?resourceUri <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?o} UNION{ ?s <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?resourceUri} UNION{ ?s <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?resourceUri}}"
-      classSearchResults = sparql.query(classRecognitionQuery).map{ |sol| sol[:resourceUri] }.reject do |s|  # Reject literals
-        s.class <= RDF::Literal
-      end.select do |s|  # Select URIs and blank nodes in case of include_blank
-        true || s.class == RDF::URI
-      end
-
-	  classSearchResults.each do |uri|
-	    classResources[uri.to_s]=Jekyll::Drops::RdfResourceClass.new(uri, graph)
-	  end
-
-      classResources.each{|key, value|
-        value.findDirectSubClasses.each{|s|
-          value.addSubClass(classResources[s.subject.term.to_s])
-        }
-      }
-
-      if(classes_to_templates.is_a?(Hash))
-        classes_to_templates.each{|key, value|
-          classResources[key].propagateTemplate(value,0)
-          classResources[key].traverseHierarchyValue(0);
-        }
-      end
+      create_resource_class(search_for_classes(sparql), sparql)
+      assign_class_templates(classes_to_templates)
     end
 
     ##

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-rdf
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0.alpha.pre.171
 platform: ruby
 authors:
 - Elias Saalmann
@@ -16,7 +16,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-29 00:00:00.000000000 Z
+date: 2017-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: linkeddata
@@ -24,28 +24,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.99'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.99'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: sparql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.99'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.99'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: jekyll
   requirement: !ruby/object:Gem::Requirement
@@ -67,7 +67,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.4'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -81,7 +81,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -95,7 +95,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -109,7 +109,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -159,10 +159,16 @@ files:
 - lib/jekyll/exceptions/NoPrefixMapped.rb
 - lib/jekyll/exceptions/NoPrefixesDefined.rb
 - lib/jekyll/exceptions/UnMarkedUri.rb
+- lib/jekyll/filters/rdf_collection.rb
+- lib/jekyll/filters/rdf_container.rb
 - lib/jekyll/filters/rdf_property.rb
+- lib/jekyll/filters/rdf_resolve_prefix.rb
 - lib/jekyll/filters/rdf_sparql_query.rb
+- lib/jekyll/rdf_class_extraction.rb
+- lib/jekyll/rdf_generator_helper.rb
 - lib/jekyll/rdf_main_generator.rb
 - lib/jekyll/rdf_page_data.rb
+- lib/jekyll/rdf_page_helper.rb
 - lib/jekyll/rdf_template_mapper.rb
 homepage: https://github.com/white-gecko/jekyll-rdf
 licenses:
@@ -179,13 +185,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
-summary: Hypertext Publication System for Templates Resource Rendering
+summary: Hypertext Publication System for Templated Resource Rendering
 test_files: []