jekyll-rdf 3.0.0.pre.develop.334 → 3.0.0.pre.develop.343

data/lib/jekyll/filters/rdf_property.rb

@@ -24,97 +24,96 @@
 #
 
 module Jekyll
-
-  ##
-  # Internal module to hold the medthod #rdf_property
-  #
-  module RdfProperty
-    include Jekyll::RdfPrefixResolver
+  module JekyllRdf
     ##
-    # 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.
+    # Internal module to hold the medthod #rdf_property
     #
-    def rdf_property(input, predicate, lang = nil, list = false)
-      return map_predicate(input, predicate, lang, list)
-    end
-
-    def rdf_inverse_property(input, predicate, list = false)
-      return map_predicate(input, predicate, nil, list, true)
-    end
+    module Filter
+      ##
+      # 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.
+      #
+      def rdf_property(input, predicate, lang = nil, list = false)
+        return map_predicate(input, predicate, lang, list)
+      end
 
-    private
-    def map_predicate(input, predicate, lang = nil, list = false, inverse = false)
-      input = Jekyll::RdfHelper::page.data['rdf'] if(input.nil? ||  input.class <= (Jekyll::RdfPageData))
-      return input unless input.is_a?(Jekyll::Drops::RdfResource)
-      predicate = rdf_resolve_prefix(predicate)
-      result = filter_statements(input.term.to_ntriples, predicate, inverse, lang)
-      return unless !result.empty?
-      if(list)
-        return result
-      else
-        return result.first
+      def rdf_inverse_property(input, predicate, list = false)
+        return map_predicate(input, predicate, nil, list, true)
       end
-    end
 
-    def filter_statements(n_triples, predicate, inverse = false, lang = nil)
-      client = Jekyll::RdfHelper::sparql
-      query = ""
-      if (lang.eql? 'cfg')
-        lang_query = "FILTER(lang(?o) = '#{Jekyll::RdfHelper::site.config['jekyll_rdf']['language']}')"
-      elsif lang.nil?
-        lang_query = ""
-      else
-        lang_query = "FILTER(lang(?o) = '#{lang}')"
+      private
+      def map_predicate(input, predicate, lang = nil, list = false, inverse = false)
+        input = Jekyll::JekyllRdf::Helper::RdfHelper::page.data['rdf'] if(input.nil? ||  input.class <= (Jekyll::RdfPageData))
+        return input unless input.is_a?(Jekyll::JekyllRdf::Drops::RdfResource)
+        predicate = rdf_resolve_prefix(predicate)
+        result = filter_statements(input.term.to_ntriples, predicate, inverse, lang)
+        return unless !result.empty?
+        if(list)
+          return result
+        else
+          return result.first
+        end
       end
 
-      if(inverse)
-        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, Jekyll::RdfHelper::site, Jekyll::RdfHelper::page, true)
+      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
-      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)
+
+        if(inverse)
+          query = "SELECT ?s WHERE{ ?s <#{predicate}> #{n_triples} }"
+          result = client.query(query).map do |solution|
+            subject = RDF::URI(solution.s)
+            Jekyll::JekyllRdf::Drops::RdfResource.new(subject, Jekyll::JekyllRdf::Helper::RdfHelper::site, Jekyll::JekyllRdf::Helper::RdfHelper::page, true)
+          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
-      return result
-    end
 
-    ##
-    # Distinguishes the solution between an Literal and a Resource
-    #
-    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)
-      else
-        object = RDF::URI(solution.o)
-        result = Jekyll::Drops::RdfResource.new(object, Jekyll::RdfHelper::site, Jekyll::RdfHelper::page, true)
+      ##
+      # Distinguishes the solution between an Literal and a Resource
+      #
+      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::JekyllRdf::Drops::RdfLiteral.new(object)
+        else
+          object = RDF::URI(solution.o)
+          result = Jekyll::JekyllRdf::Drops::RdfResource.new(object, Jekyll::JekyllRdf::Helper::RdfHelper::site, Jekyll::JekyllRdf::Helper::RdfHelper::page, true)
+        end
+        return result
       end
-      return result
-    end
 
-    ##
-    # check what language and datatype the passed literal has
-    #
-    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
+      ##
+      # check what language and datatype the passed literal has
+      #
+      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
-      return result
     end
   end
 end
 
-Liquid::Template.register_filter(Jekyll::RdfProperty)

data/lib/jekyll/filters/rdf_resolve_prefix.rb

@@ -24,24 +24,26 @@
 #
 
 module Jekyll
-  module RdfPrefixResolver
-    private
-    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, 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]])
+  module JekyllRdf
+    module Filter
+      private
+      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, Jekyll::JekyllRdf::Helper::RdfHelper::page.data['template'])
+        end
+        if(!Jekyll::JekyllRdf::Helper::RdfHelper::page.data["rdf_prefixes"].nil?)
+          if(!Jekyll::JekyllRdf::Helper::RdfHelper::page.data["rdf_prefix_map"][arr[0]].nil?)
+            return arr[1].prepend(Jekyll::JekyllRdf::Helper::RdfHelper::page.data["rdf_prefix_map"][arr[0]])
+          else
+            raise NoPrefixMapped.new(predicate, Jekyll::JekyllRdf::Helper::RdfHelper::page.data['template'], arr[0])
+          end
         else
-          raise NoPrefixMapped.new(predicate, Jekyll::RdfHelper::page.data['template'], arr[0])
+          raise NoPrefixesDefined.new(predicate, Jekyll::JekyllRdf::Helper::RdfHelper::page.data['template'])
         end
-      else
-        raise NoPrefixesDefined.new(predicate, Jekyll::RdfHelper::page.data['template'])
       end
     end
   end

data/lib/jekyll/filters/rdf_sparql_query.rb

@@ -24,54 +24,53 @@
 #
 
 module Jekyll
-
-  ##
-  # Internal module to hold the medthod #sparql_query
-  #
-  module RdfSparqlQuery
-    include Jekyll::RdfPrefixResolver
+  module JekyllRdf
     ##
-    # 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
+    # Internal module to hold the medthod #sparql_query
     #
-    def sparql_query(resource = nil, query)
-      if(resource.nil? || resource.class <= (Jekyll::RdfPageData))
-        query.gsub!('?resourceUri', "<#{Jekyll::RdfHelper::page.data['rdf'].term}>")
-      elsif(resource.class <= Array)
-        resource.each_with_index do |uri, index|
-          if(uri.class <= Jekyll::Drops::RdfResource)
-            query.gsub!("?resourceUri_#{index}", uri.term.to_ntriples)
-          else
-            query.gsub!("?resourceUri_#{index}", "<#{rdf_resolve_prefix(uri.to_s)}>")
+    module Filter
+
+      ##
+      # 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
+      #
+      def sparql_query(resource = nil, query)
+        if(resource.nil? || resource.class <= (Jekyll::RdfPageData))
+          query.gsub!('?resourceUri', "<#{Jekyll::JekyllRdf::Helper::RdfHelper::page.data['rdf'].term}>")
+        elsif(resource.class <= Array)
+          resource.each_with_index do |uri, index|
+            if(uri.class <= Jekyll::JekyllRdf::Drops::RdfResource)
+              query.gsub!("?resourceUri_#{index}", uri.term.to_ntriples)
+            else
+              query.gsub!("?resourceUri_#{index}", "<#{rdf_resolve_prefix(uri.to_s)}>")
+            end
           end
+        else
+          query.gsub!('?resourceUri', "<#{resource}>")
         end
-      else
-        query.gsub!('?resourceUri', "<#{resource}>")
-      end
-      if(!Jekyll::RdfHelper::page.data["rdf_prefixes"].nil?)
-        query = query.prepend(" ").prepend(Jekyll::RdfHelper::page.data["rdf_prefixes"])
-      end
-      begin
-        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, Jekyll::RdfHelper::site, true).add_necessities(Jekyll::RdfHelper::site, Jekyll::RdfHelper::page)}
-          hsh.collect{|k,v| [k.to_s, v]}.to_h
+        if(!Jekyll::JekyllRdf::Helper::RdfHelper::page.data["rdf_prefixes"].nil?)
+          query = query.prepend(" ").prepend(Jekyll::JekyllRdf::Helper::RdfHelper::page.data["rdf_prefixes"])
         end
-        return result
-      rescue SPARQL::Client::ClientError => ce
-        Jekyll.logger.error("client error experienced: \n #{query} \n Error Message: #{ce.message}")
-      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} \nTrace #{e.backtrace.drop(1).map{|s| "\t#{s}"}.join("\n")}")
+        begin
+          result = Jekyll::JekyllRdf::Helper::RdfHelper::sparql.query(query).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}")
+        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} \nTrace #{e.backtrace.drop(1).map{|s| "\t#{s}"}.join("\n")}")
+        end
+        return []
       end
-      return []
-    end
 
+    end
   end
 end
-
-Liquid::Template.register_filter(Jekyll::RdfSparqlQuery)

data/lib/jekyll/helper/rdf_class_extraction.rb

@@ -0,0 +1,51 @@
+module Jekyll
+  module JekyllRdf
+    module Helper
+      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::JekyllRdf::Drops::RdfResourceClass.new(uri, sparql)
+          end
+
+          @classResources.each{|key, value|
+            value.find_direct_subclasses.each{|s|
+              value.add_subclass(@classResources[s])
+            }
+          }
+        end
+
+        def assign_class_templates(classes_to_templates)
+          if(classes_to_templates.is_a?(Hash))
+            @classResources.default = StopObject.new
+            classes_to_templates.each{|key, value|
+              @classResources[key].propagate_template(value,0)
+              @classResources[key].traverse_hierarchy_value(0);
+            }
+            @classResources.default = nil
+          end
+        end
+
+        class StopObject #unfortunately next does not work in this setup, it avoids to have "if" in every iteration
+          def propagate_template(template, lock)
+            return
+          end
+
+          def traverse_hierarchy_value(predecessorHierarchyValue)
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/helper/rdf_general_helper.rb

@@ -23,33 +23,37 @@
 #
 
 module Jekyll
+  module JekyllRdf
+    module Helper
+      ##
+      # Internal module to hold support for functionalities like submitting sparql queries
+      #
+      module RdfHelper
+        def self.sparql= sparql
+          @@sparql = sparql
+        end
 
-  ##
-  # Internal module to hold the medthod #rdf_get
-  #
-  module RdfHelper
-    def self.sparql= sparql
-      @@sparql = sparql
-    end
-
-    def self.sparql
-      @@sparql
-    end
+        def self.sparql
+          @@sparql
+        end
 
-    def self.site= site
-      @@site = site
-    end
+        def self.site= site
+          @@site = site
+        end
 
-    def self.site
-      @@site
-    end
+        def self.site
+          @@site
+        end
 
-    def self.page= page
-      @@page = page
-    end
+        def self.page= page
+          @@page = page
+        end
 
-    def self.page
-      @@page
+        def self.page
+          @@page
+        end
+      end
     end
+    
   end
 end

data/lib/jekyll/helper/rdf_generator_helper.rb

@@ -0,0 +1,124 @@
+module Jekyll
+  module JekyllRdf
+    module Helper
+      module RdfGeneratorHelper
+        private
+        def prepare_pages (site, mapper)
+          @pageResources.each{|uri, entry|
+            resource = entry.delete('./')
+            resource.subResources = entry
+            create_page(site, resource, mapper, @global_config)
+          }
+
+          @blanknodes.each{|resource|
+            create_page(site, resource, mapper, @global_config)
+          }
+        end
+
+        def parse_resources (resources)
+          @pageResources={};
+          @blanknodes=[]
+          resources.each do |uri|
+            resource = Jekyll::JekyllRdf::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 #
+                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
+          # give parents to orphaned resources
+          @pageResources.each_key{|key|
+            @pageResources[key]['./'] = Jekyll::JekyllRdf::Drops::RdfResource.new(RDF::URI(key)) if @pageResources[key]['./'].nil?
+          }
+        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 create_page(site, resource, mapper, global_config)
+          page = RdfPageData.new(site, site.source, resource, mapper, global_config)
+          if(page.complete)
+            site.pages << page
+            resource.add_necessities(site, page)
+            resource.subResources.each {|key, value|
+              value.add_necessities(site, page)
+            } unless resource.subResources.nil?
+          end
+        end
+      end
+
+    end
+  end
+end