jekyll-rdf 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66d828ef6b4898af8b9ddc0811421af2d96e41ee
-  data.tar.gz: fc7354fc326c9e36728b769e79d81e26ee5b4532
+  metadata.gz: bb995c6b66f94be8fafd3b78c74a8bb82858c35f
+  data.tar.gz: 97ad76c5961a904d35919cab1e52ad81fe21aef1
 SHA512:
-  metadata.gz: 7c8d64c1c9329ca1ad5e8a85f120f305df6db31efc9d8a9dc7365bc53c6ab93292561c6d0e6c33971e7baa0379ef95c24680b1505f62998d11457a1556519a62
-  data.tar.gz: 21977963369705d6aa26501f024fd3568737f2d6cfe90da764e3385557f7d840369e8ff3c73f6d6c7a7f3430d523802e3f0ab4e666b60e2bc808a75cf6905cb1
+  metadata.gz: a4a626bbd804965f6e5259750ee6458ef9250cbe79f7d5b5cb7f94952b701b73bd7496ffed8296e825f2db68abd42ccfba16d5eed511d5b787d13438fcf68fbf
+  data.tar.gz: e772f781b9ff347c466baa0caa8848d832ce898415feca39d95c63066e7c7567973cdb7f98b21ff83e90dbbcc1407abca6f9b8420c7b0456892b1f450e8dfca3

data/lib/jekyll-rdf.rb

@@ -30,14 +30,16 @@ require 'jekyll'
 require 'linkeddata'
 require 'sparql'
 
-
 require 'jekyll/drops/rdf_term'
 require 'jekyll/drops/rdf_statement'
 require 'jekyll/drops/rdf_literal'
 require 'jekyll/drops/rdf_resource'
+require 'jekyll/drops/rdf_resource_class'
+require 'jekyll/exceptions/NoPrefixMapped'
+require 'jekyll/exceptions/NoPrefixesDefined'
+require 'jekyll/exceptions/UnMarkedUri'
 require 'jekyll/filters/rdf_sparql_query'
 require 'jekyll/filters/rdf_property'
-require 'jekyll/filters/rdf_property_list'
 require 'jekyll/rdf_main_generator'
 require 'jekyll/rdf_page_data'
 require 'jekyll/rdf_template_mapper'

data/lib/jekyll/drops/rdf_literal.rb

@@ -34,7 +34,7 @@ module Jekyll
       ##
       # Return a user-facing string representing this RdfLiteral
       #
-      def name
+      def literal
         term.to_s
       end
 

data/lib/jekyll/drops/rdf_resource.rb

@@ -1,6 +1,6 @@
 ##
 # MIT License
-# 
+#
 # Copyright (c) 2016 Elias Saalmann, Christian Frommert, Simon Jakobi,
 # Arne Jonas Präger, Maxi Bornmann, Georg Hackel, Eric Füg
 #
@@ -41,6 +41,16 @@ module Jekyll #:nodoc:
       #
       attr_accessor :page
 
+      ##
+      # The relative path to the location on the disk where this resource is rendered to
+      #
+      attr_reader :render_path
+
+      ##
+      #
+      #
+      attr_accessor :subResources
+
       ##
       # Return a list of Jekyll::Drops::RdfStatements whose subject, predicate or object is the RDF resource represented by the receiver
       #
@@ -76,52 +86,20 @@ module Jekyll #:nodoc:
         @filename ||= generate_file_name(domain_name, baseurl)
       end
 
-      ##
-      # types finds the type and superclasses of the resource
-      #
-      def types
-        @types ||= begin
-          types = [ term.to_s ]
+      def directClasses
+        @directClasses ||= begin
+          classes=[]
           selection = statements_as(:subject).select{ |s| s.predicate.term.to_s=="http://www.w3.org/1999/02/22-rdf-syntax-ns#type" }
           unless selection.empty?
-            t = selection.first
-            if selection.count > 1
-              Jekyll.logger.warn "Resource #{name} has multiple RDFS types. Will use #{t.object.term.to_s} for template mapping.  "
-            end
-            types << t.object.term.to_s
-            t = t.object
-            s = t.super_class
-            while s
-              types << s.term.to_s
-              s = s.super_class
-            end
+            selection.each{|s| classes << s.object.term.to_s}
           end
-          types
+          classes.uniq!
+          classes
         end
       end
 
-      ##
-      # Return the first super class resource of the receiver or nil, if no super class resource can be found
-      #
-      def super_class
-        selection = statements_as(:subject).select{ |s| s.predicate.term.to_s=="http://www.w3.org/2000/01/rdf-schema#subClassOf" }
-        unless selection.empty?
-          super_class = selection.first
-          if selection.count > 1
-            Jekyll.logger.warn "Type #{name} has multiple RDFS super classes. Will use #{super_class.object.term.to_s} for template mapping.  "
-          end
-          super_class.object
-        end
-      end
-
-      ##
-      # Return a user-facing string representing this RdfResource
-      #
-      def name
-        @name ||= begin
-          n = statements_as(:subject).find{ |s| s.predicate.term.to_s=="http://xmlns.com/foaf/0.1/name" }
-          n ? n.object.name : term.to_s
-        end
+      def iri
+        term.to_s
       end
 
       ##
@@ -160,29 +138,42 @@ module Jekyll #:nodoc:
             file_name = ""
             uri[0] = nil
             uri[2] = nil
-            uri[5] = uri[5].sub(baseurl,'')
+            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
           end
           (0..8).each do |i|
-            if uri[i]
+            if !(uri[i].nil?)
               case i
-              when 2
-                file_name += "#{uri[i].gsub('.','/')}/"
+              when 5
+                file_name += "#{uri[i][1..-1]}/"
               when 8
-                file_name = file_name[0..-2]
-                file_name += "##{uri[i]}"
+                file_name += "#/#{uri[i]}"
               else
-                file_name += "#{uri[i]}/"
+               file_name += "#{uri[i]}/"
               end
             end
           end
           unless file_name[-1] == '/'
             file_name += '/'
           end
-          file_name += 'index.html'
-          file_name.gsub('//','/')
-        rescue URI::InvalidURIError
-          file_name = "rdfsites/blanknode/#{term.to_s}/index.html"
+        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 /// ////...
+        file_name = file_name.gsub(':','_D')
+        file_name = file_name.strip
+        if(file_name[-2..-1] == "#/")
+          file_name = file_name[0..-3]
         end
+        file_name += 'index.html'
+        @render_path = file_name
+        file_name
       end
 
     end

data/lib/jekyll/drops/rdf_resource_class.rb

@@ -0,0 +1,83 @@
+##
+# 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 #:nodoc:
+  module Drops #:nodoc:
+
+    ##
+    # Represents an RDF resource class to the Liquid template engine
+    #
+    class RdfResourceClass < RdfResource
+      @subClasses = []
+      @lock = -1
+      @subClassHierarchyValue = 0
+      attr_accessor :lock
+      attr_accessor :template
+      attr_accessor :alternativeTemplates
+      attr_accessor :subClasses
+      attr_accessor :subClassHierarchyValue
+
+      def initialize(term, graph)
+        super(term, graph)
+        @subClasses = []
+        @lock = -1
+        @subClassHierarchyValue = 0
+        @alternativeTemplates = []
+      end
+
+      def multipleTemplates?
+        !@alternativeTemplates.empty?
+      end
+
+      def findDirectSubClasses
+        selection = statements_as(:object).select{ |s| s.predicate.term.to_s=="http://www.w3.org/2000/01/rdf-schema#subClassOf" }
+        return selection
+      end
+
+      def addSubClass(resource)
+        @subClasses << resource
+      end
+
+      def propagateTemplate(template, lock)
+        if(@lock>lock||@lock==-1)
+          @lock=lock
+          @template=template
+          @alternativeTemplates.clear()
+          subClasses.each{|sub| sub.propagateTemplate(template ,lock+1)}
+        elsif(@lock==lock)
+          @alternativeTemplates.push(template)
+          subClasses.each{|sub| sub.propagateTemplate(template ,lock+1)}
+        end
+      end
+
+      def traverseHierarchyValue(predecessorHierarchyValue)
+        if(@subClassHierarchyValue + 1 >= predecessorHierarchyValue)  #avoid loops
+          @subClassHierarchyValue += 1
+          subClasses.each{|sub| sub.traverseHierarchyValue(@subClassHierarchyValue)}
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/drops/rdf_term.rb

@@ -53,10 +53,13 @@ module Jekyll
       end
 
       ##
-      # Convert this RdfTerm into a human-readable string
+      # Convert this RdfTerm into a string
+      # This should be:
+      # - for resoruces: the IRI
+      # - for literals: the literal representation e.g. "Hallo"@de or "123"^^<http://www.w3.org/2001/XMLSchema#integer>
       #
       def to_s
-        name
+        term.to_s
       end
 
       ##

data/lib/jekyll/exceptions/NoPrefixMapped.rb

@@ -0,0 +1,7 @@
+class NoPrefixMapped < StandardError
+  attr_accessor :prefix, :property
+  def initialize property, layout, prefix
+    @prefix, @property = prefix, property
+    super("Their is no mapping defined for #{prefix} in context to #{property}\n in layout: '#{layout}'.")
+  end
+end

data/lib/jekyll/exceptions/NoPrefixesDefined.rb

@@ -0,0 +1,5 @@
+class NoPrefixesDefined < StandardError
+  def initialize x, layout
+    super("No Prefixes are defined when #{x} gets passed in \n layout: '#{layout}'.")
+  end
+end

data/lib/jekyll/exceptions/UnMarkedUri.rb

@@ -0,0 +1,5 @@
+class UnMarkedUri < StandardError
+  def initialize uri, layout
+    super("The URI #{uri} is not correctly marked. Pls use the form <#{uri}> instead.\nFound in layout: '#{layout}'.")
+  end
+end

data/lib/jekyll/filters/rdf_property.rb

@@ -29,28 +29,61 @@ module Jekyll
   # Internal module to hold the medthod #rdf_property
   #
   module RdfProperty
-
     ##
     # 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 returned (both in case a language is supplied and in case is not supplied) is undefined
+    # * +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)
+    def rdf_property(input, predicate, lang = nil, list = false)
       return input unless input.is_a?(Jekyll::Drops::RdfResource)
       begin
-        results = input.page.data['rdf'].statements_as_subject.select{ |s| s.predicate.term.to_s == predicate }
-        lang ||= input.site.config['jekyll_rdf']['language']
-        if results.count > 1 && results.first.object.term.is_a?(RDF::Term) && lang != nil
-          p = results.find{ |s| s.object.term.language == lang.to_sym }
+        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
-        p = results.first unless p
-        return unless p
-        (p.object.name).to_s
       end
     end
 
+    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

@@ -40,14 +40,25 @@ module Jekyll
     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"])
+      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) }
           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}")
       end
+      return []
     end
 
   end

data/lib/jekyll/rdf_main_generator.rb

@@ -39,7 +39,26 @@ module Jekyll
     # * +site+ - The Jekyll::Site whose #data is to be enriched
     #
     def generate(site)
-      config = site.config.fetch('jekyll_rdf')
+
+      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
+      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")
+        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
+      end
 
       graph = RDF::Graph.load(config['path'])
       sparql = SPARQL::Client.new(graph)
@@ -50,13 +69,50 @@ module Jekyll
       site.data['sparql'] = sparql
       site.data['resources'] = []
 
-      mapper = Jekyll::RdfTemplateMapper.new(config['template_mappings'], config['default_template'])
-
-      # create RDF pages for each URI
+      #parse resources
+      pageResources={};
+      blanknodes=[]
       resources.each do |uri|
         resource = Jekyll::Drops::RdfResource.new(uri, graph)
-        site.pages << RdfPageData.new(site, site.source, resource, mapper)
+        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
+      }
+
+      blanknodes.each{|resource|
+        site.pages << RdfPageData.new(site, site.source, resource, mapper, global_config)
+      }
     end
 
     ##

data/lib/jekyll/rdf_page_data.rb

@@ -37,19 +37,37 @@ module Jekyll
     # * +resource+ - The RDF resource for which the page is rendered
     # * +mapper+ - The layout-mapping
     #
-    def initialize(site, base, resource, mapper)
+    def initialize(site, base, resource, mapper, config)
       @site = site
       @base = base
       @dir = ""
-      @name = resource.filename(URI::split(site.config['url'])[2], site.config['baseurl'])
+      @name = resource.filename(URI::split(config['url'])[2], config['baseurl'])
       self.process(@name)
 
       template = mapper.map(resource)
       self.read_yaml(File.join(base, '_layouts'), template)
-
-      self.data['title'] = resource.name
+      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
+      end
       resource.page = self
       resource.site = site
       site.data['resources'] << resource

data/lib/jekyll/rdf_template_mapper.rb

@@ -31,21 +31,53 @@ module Jekyll
   class RdfTemplateMapper
 
     ##
-    # A Hash mapping a type resource to a template name
+    # A Hash mapping a resource to a template name
     attr_accessor :resources_to_templates
 
     ##
     # Default template name
     attr_accessor :default_template
 
+    ##
+    # A Hash mapping a type resource to a template name
+    attr_accessor :classes_to_templates
+
+    attr_accessor :classResources
+
     ##
     # 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, default_template)
+    def initialize(resources_to_templates, classes_to_templates, default_template, graph, 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
     end
 
     ##
@@ -53,13 +85,39 @@ module Jekyll
     #
     # Returns the template name of one of the +resource+'s types, if available. Returns the default template name otherwise.
     def map(resource)
-      resource.types.each do |type|
-        tmpl = resources_to_templates ? resources_to_templates[type] : nil
-        return tmpl unless tmpl.nil?
+      tmpl = resources_to_templates ? resources_to_templates[resource.term.to_s] : nil
+      lock = -1
+      hier = -1
+      warnMultTempl = false
+      duplicateLevelTempl = []
+      if(tmpl.nil?)
+        resource.directClasses.each do |classUri|
+          classRes = classResources[classUri]
+          if((classRes.lock <= lock || lock == -1) && !classRes.template.nil?)
+            if(classRes.subClassHierarchyValue > hier)
+              Jekyll.logger.info("classMapped: #{classUri} : #{resource.term.to_s} : #{classResources[classUri].template}")
+              lock = classRes.lock
+              tmpl = classRes.template
+              hier = classRes.subClassHierarchyValue
+              warnMultTempl = false
+              duplicateLevelTempl.clear.push(tmpl)
+              if(classRes.multipleTemplates?)
+                warnMultTempl = true
+                duplicateLevelTempl.concat(classRes.alternativeTemplates)
+              end
+            elsif(classRes.subClassHierarchyValue == hier)
+              warnMultTempl = true
+              duplicateLevelTempl.push(classRes.template)
+            end
+          end unless classRes.nil?
+        end
+        if(warnMultTempl)
+          Jekyll.logger.warn("Warning: multiple possible templates for #{resource.term.to_s}: #{duplicateLevelTempl.uniq.join(', ')}")
+        end
       end
+      return tmpl unless tmpl.nil?
       return default_template
     end
-
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-rdf
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Elias Saalmann
@@ -11,10 +11,12 @@ authors:
 - Maxi Bornmann
 - Georg Hackel
 - Eric Füg
+- Sebastian Zänker
+- Natanael Arndt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-10 00:00:00.000000000 Z
+date: 2017-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: linkeddata
@@ -64,14 +66,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '10.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '10.4'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -143,7 +145,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.4'
 description: Generate static sites with Jekyll based on RDF data
-email: mail@esaalmann.de
+email: arndt@informatik.uni-leipzig.de
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -151,15 +153,18 @@ files:
 - lib/jekyll-rdf.rb
 - lib/jekyll/drops/rdf_literal.rb
 - lib/jekyll/drops/rdf_resource.rb
+- lib/jekyll/drops/rdf_resource_class.rb
 - lib/jekyll/drops/rdf_statement.rb
 - lib/jekyll/drops/rdf_term.rb
+- lib/jekyll/exceptions/NoPrefixMapped.rb
+- lib/jekyll/exceptions/NoPrefixesDefined.rb
+- lib/jekyll/exceptions/UnMarkedUri.rb
 - lib/jekyll/filters/rdf_property.rb
-- lib/jekyll/filters/rdf_property_list.rb
 - lib/jekyll/filters/rdf_sparql_query.rb
 - lib/jekyll/rdf_main_generator.rb
 - lib/jekyll/rdf_page_data.rb
 - lib/jekyll/rdf_template_mapper.rb
-homepage: http://pcai042.informatik.uni-leipzig.de/~dtp16/
+homepage: https://github.com/white-gecko/jekyll-rdf
 licenses:
 - MIT
 metadata: {}
@@ -179,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Hypertext Publication System for Templates Resource Rendering

data/lib/jekyll/filters/rdf_property_list.rb

@@ -1,58 +0,0 @@
-##
-# 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
-
-  ##
-  # Internal module to hold the method #rdf_property
-  #
-  module RdfPropertyList
-
-    ##
-    # Computes all objects for which statements exist containing the given subject and predicate and returns an Array 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 the returned objects. If 'cfg' is specified the preferred language is provides by the site configuration _config.yml
-    #
-    def rdf_property_list(input, predicate, lang = nil)
-      return input unless input.is_a?(Jekyll::Drops::RdfResource)
-      begin
-        result = input.page.data['rdf'].statements_as_subject.select{ |s| s.predicate.term.to_s == predicate } # select all matching statements with given predicate
-        if lang != nil
-          if lang == 'cfg'
-            lang = input.site.config['jekyll_rdf']['language']
-          end
-          result = result.select{ |s| s.object.term.language == lang.to_sym } # select all statements with matching language
-        end
-        return unless result
-        result.map{|p| p.object.name}
-      end
-    end
-
-  end
-end
-
-Liquid::Template.register_filter(Jekyll::RdfPropertyList)