jekyll-rdf 3.1.1.pre.develop.671 → 3.1.1.pre.develop.688

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e644173660dce44ea5adcd7d489f66da2b9cd6a804295d79903b9d8211563dd5
-  data.tar.gz: 0fabea66148c249ce5cb87b06b4cd58293c24ef0d6f37af904737517eb7b5235
+  metadata.gz: df5e7aac5e8663115d1b4bb44af2118aaf039e6811f092eaecaffaac288894a7
+  data.tar.gz: 272573d89b48aca124e020ffff44bf413f32b080ea3a3bbe0f48506b86e207ac
 SHA512:
-  metadata.gz: b683353a2f5663a263e1965eaedda0080a55c30d755173c1047ed31aae86740b7c02e661991c8f2156b2d29ca09ad25651ac0a78e42b38dcc77cfa55a0f45b1a
-  data.tar.gz: 887d68dc9f7bb560cbf0ca2e938b58202961944ef241dae9d22c6d9042a005a9108aad8fc911740517d38949f65a6d9d923ae51a19d24872270effed5d5b9d66
+  metadata.gz: a52a3d34008e4bdaf2ed2920829958b5931c07d40302cb571d086f6b8db940a2e5bcb21478767dc8e64632319e33311f5bbe60143a1f28b4581a8709e424f493
+  data.tar.gz: 02d6617ec2837a621d0d351e73020389c8f2bd2c935b07d6cea97249a05162e49841285eaa23f46865f5dd59d4c8ce9da68668949568eaa7683bff3923fff6e5

data/lib/jekyll/drops/rdf_resource_class.rb

@@ -31,58 +31,68 @@ module Jekyll #:nodoc:
       # Represents an RDF resource class to the Liquid template engine
       #
       class RdfResourceClass < RdfResource
-        @subClasses = []
-        @lock = -1
-        @subClassHierarchyValue = 0
         attr_accessor :lock
+        attr_reader :distance #distance to next class with template
         attr_accessor :template
-        attr_accessor :alternativeTemplates
-        attr_accessor :subClasses
-        attr_accessor :subClassHierarchyValue
-        attr_reader :sparql
+        attr_accessor :path
+        attr_accessor :base       # important for template mapping
+                                  # true if _config.yml assigned this class a template
 
-        def initialize(term, sparql)
+        def initialize(term, base = false)
           super(term)
-          @subClasses = []
+          @base = base
           @lock = -1
-          @subClassHierarchyValue = 0
-          @alternativeTemplates = []
-          @sparql = sparql
+          @lockNumber = 0
+          @distance = 0
         end
 
-        def multiple_templates?
-          !@alternativeTemplates.empty?
-        end
-
-        def find_direct_subclasses
-          query = "SELECT ?s WHERE{ ?s <http://www.w3.org/2000/01/rdf-schema#subClassOf> #{@term.to_ntriples}}"
-          selection = @sparql.query(query).map{ |solution| solution.s.to_s}
+        ##
+        # Returns all classes from which +term+ directly inherited
+        #
+        def find_direct_superclasses
+          return @superclasses unless @superclasses.nil?
+          query = "SELECT ?s WHERE{ #{@term.to_ntriples} <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?s }"
+          selection = Jekyll::JekyllRdf::Helper::RdfHelper::sparql.
+            query(query).map{ |solution| solution.s.to_s}
+          @superclasses = selection
           return selection
         end
 
-        def add_subclass(resource)
-          @subClasses << resource
+        ##
+        # Propagate the current template to the parent of the breadth-first search
+        # in RdfClassExtraction.request_class_template.
+        #
+        def propagate_template(distance)
+          @distance = distance
+          return if @path.nil?
+          return unless @path.template.nil?
+          @path.template = @template
+          @path.propagate_template(distance +1)
         end
 
-        def propagate_template(template, lock)
-          if(@lock>lock||@lock==-1)
-            @lock=lock
-            @template=template
-            @alternativeTemplates.clear()
-            subClasses.each{|sub| sub.propagate_template(template ,lock+1)}
-          elsif(@lock==lock)
-            @alternativeTemplates.push(template)
-            subClasses.each{|sub| sub.propagate_template(template ,lock+1)}
-          end
+        ##
+        # Returns the beginning of the path leading to the found template
+        #
+        def get_path_root
+          return self if @path.nil?
+          @path.get_path_root
         end
 
-        def traverse_hierarchy_value(predecessorHierarchyValue)
-          if(@subClassHierarchyValue + 1 >= predecessorHierarchyValue)  #avoid loops
-            @subClassHierarchyValue += 1
-            subClasses.each{|sub| sub.traverse_hierarchy_value(@subClassHierarchyValue)}
+        ##
+        # Checks if this instance was already added to the breadth-first search
+        # in RdfClassExtraction.request_class_template.
+        #
+        def add? lock_number
+          if @lock_number != lock_number
+            # used to recognize different searchpasses of request_class_template
+            @lock_number = lock_number
+            @lock = -1
+            true
+          else
+            false
           end
         end
-      end
+      end #RdfResourceClass
     end
   end
 end

data/lib/jekyll/helper/rdf_class_extraction.rb

@@ -2,47 +2,161 @@ 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
+
+        ##
+        # Instantiate all rdf:class'es with an template mapped in +classes_to_templates+.
+        # +classes_to_templates+ A hash that contains string representations of class resources
+        #  as keys and maps these to a template.
+        #
+        def create_resource_class(classes_to_templates)
+          if(classes_to_templates.is_a?(Hash))
+            classes_to_templates.each{|uri, template|
+              @classResources[uri] = Jekyll::JekyllRdf::Drops::
+              RdfResourceClass.new(RDF::URI(uri), true)
+              @classResources[uri].template = template
+            }
           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
+        ##
+        # Returns to a RdfResource a template through its rdf:type
+        # +resource+ the resource a template is searched for.
+        #
+        def request_class_template resource
+          return nil if resource.direct_classes.empty?
+          direct_classes = resource.direct_classes
+          #hash template and determine if we used these classes before
+          hash_str = direct_classes.sort!.join(", ")
+          return @template_cache[hash_str] unless @template_cache[hash_str].nil?
+          #start searching
+          lock = -1
+          count = 0
+          next_increase = -1
+          lock_number = rand
+          min_template_lock = @stop_object    #ruby does not have MAX_VALUE
+          min_class = nil
+          class_list = direct_classes.map{|uri|
+            @classResources[uri] ||= Jekyll::JekyllRdf::Drops::RdfResourceClass.new(RDF::URI(uri))
+            @classResources[uri].path = nil
+            @classResources[uri]
+          }
+          alternatives = []
+          class_list.each{|class_resource|
+            if(next_increase <= count)     # the next level of the breadth-first search
+              if ((min_template_lock <= lock) && (lock >= 0))  # if (distance to next template is smaller than current search radius) && (we checked all immediate classes)
+                return extract_template(find_highlevel_inheritance(min_class, alternatives, resource), hash_str)
+              end
+              alternatives.clear()
+              lock += 1
+              next_increase = class_list.length
+            end
 
-          @classResources.each{|key, value|
-            value.find_direct_subclasses.each{|s|
-              value.add_subclass(@classResources[s])
+            if !class_resource.template.nil? && min_template_lock > lock - 1 + class_resource.distance
+              min_template_lock = lock - 1
+              min_class = class_resource
+            end
+
+            class_resource.find_direct_superclasses.each{ |uri|
+              @classResources[uri] ||= Jekyll::JekyllRdf::Drops::RdfResourceClass.new(RDF::URI(uri))
+              if(!@classResources[uri].template.nil?) # do not search in paths you previously found
+                if @classResources[uri].base
+                  if(!min_class.nil? && min_template_lock == lock)    #min_class could contain a previously found class with equal distance
+                    alternatives.push @classResources[uri] unless min_class.eql? @classResources[uri]
+                  else
+                    min_template_lock = lock
+                    min_class = @classResources[uri]
+                  end
+                  @classResources[uri].path = class_resource  # <- this might be valnuable to cyclic inheritance in the graph
+                elsif min_template_lock > (lock + @classResources[uri].distance) # you found a branch that was used earlier
+                                                                                 # note template but search further unitl (min_template_lock <= lock) && (lock >= 1) is satisfied
+                  @classResources[uri].path = class_resource  # <- this might be valnuable to cyclic inheritance in the graph
+                  min_template_lock = lock + @classResources[uri].distance
+                  min_class = @classResources[uri]
+                elsif min_template_lock == (lock + @classResources[uri].distance)
+                  alternatives.push @classResources[uri] unless min_class.eql? @classResources[uri]
+                end
+              elsif(@classResources[uri].add?(lock_number)) # not a previously searched resource without a template
+                @classResources[uri].path = class_resource  # <- this might be valnuable to cyclic inheritance in the graph
+                class_list.push(@classResources[uri])
+                @classResources[uri].lock = lock
+              end
             }
+            count += 1
           }
+
+          unless min_class.nil?
+            return extract_template(find_highlevel_inheritance(min_class, alternatives, resource), hash_str)
+          end
+          return nil
         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
+        ##
+        # Returns the template stored in the input resource +class_resource+
+        #  and caches it with +hash_str+ as key.
+        #
+        def extract_template class_resource, hash_str
+          class_resource.propagate_template(class_resource.distance)
+          return (@template_cache[hash_str] = class_resource.get_path_root.template)
+        end
+
+        ##
+        # Returns the most specific class resource from +class_list+ based on
+        # +current_best+.
+        # +resource+ is the original input of request_class_template.
+        #
+        def find_highlevel_inheritance current_best, class_list, resource   #check at the end of the search for direct inheritance on highest level
+          class_list.each{|resource|
+            resource.find_direct_superclasses.each{|uri|
+              @classResources[uri] ||= Jekyll::JekyllRdf::Drops::RdfResourceClass.new(RDF::URI(uri))
+              @classResources[uri].path = resource
+            } if resource.base
+          }
+          # this is valnuable to cyclic inheritance
+          while(class_list.include?(current_best.path))
+            slice = class_list.index(current_best)
+            # parent alternatives are no real alternatives
+            class_list.slice!(slice) unless slice.nil?
+            current_best = current_best.path
           end
+          return consistence_templates(current_best, class_list, resource) unless class_list.empty?
+          return current_best
+        end
+
+        ##
+        # Add a warning for a class having multiple possible templates
+        # The warnings are then later displayed with print_warnings
+        # +classRes+ and +alternatives+ make up a list of class resources which
+        #     are all equally valid choices for request_class_template
+        # +resource+ is the original input of request_class_template.
+        #
+        def consistence_templates(classRes, alternatives, resource)
+          hash_str = alternatives.push(classRes).
+            map {|x|
+              x.template
+            }.
+            sort!.join(", ")
+          begin
+            @consistence[hash_str] = []
+            @consistence[hash_str].push(classRes)
+            @consistence[hash_str].push([])
+          end if @consistence[hash_str].nil?
+          @consistence[hash_str][1].push(resource)  # using a hash ensures that a warning is printed only once for each combination of templates
+                                                    # and for each resource at most once
+          @consistence[hash_str][0]
         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
+        ##
+        # used to escape loops without an if-statement
+        #
+        class StopObject
+          def > object
+            true
           end
 
-          def traverse_hierarchy_value(predecessorHierarchyValue)
-            return
+          def <= object
+            false
           end
         end
       end

data/lib/jekyll/rdf_main_generator.rb

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

data/lib/jekyll/rdf_template_mapper.rb

@@ -37,14 +37,15 @@ module Jekyll
     #
     # * +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, sparql)
+    def initialize(resources_to_templates, classes_to_templates, default_template)
       @resources_to_templates = resources_to_templates
       @default_template = default_template
-      @classes_to_templates = classes_to_templates
       @classResources = {}
-      @warnings = {}
-      create_resource_class(search_for_classes(sparql), sparql)
-      assign_class_templates(classes_to_templates)
+      @consistence = {}    #ensures that the same template is chosen for each combination of templates
+      @template_cache = {}
+      @stop_object = StopObject.new
+
+      create_resource_class(classes_to_templates)
     end
 
     ##
@@ -53,45 +54,17 @@ module Jekyll
     # Returns the template name of one of the +resource+'s types, if available. Returns the default template name otherwise.
     def map(resource)
       tmpl = @resources_to_templates ? @resources_to_templates[resource.term.to_s] : nil
-      lock = -1
-      hier = -1
-      duplicate_level_templ = []
-      resource.direct_classes.each do |classUri|
-        classRes = @classResources[classUri]
-        if((classRes.lock <= lock || lock == -1) && !classRes.template.nil?)
-          if(classRes.subClassHierarchyValue > hier)
-            lock = classRes.lock
-            tmpl = classRes.template
-            hier = classRes.subClassHierarchyValue
-            duplicate_level_templ.clear.push(tmpl)
-            if(classRes.multiple_templates?)
-              duplicate_level_templ.concat(classRes.alternativeTemplates)
-            end
-          elsif(classRes.subClassHierarchyValue == hier)
-            duplicate_level_templ.push(classRes.template)
-          end
-        end unless classRes.nil?
-      end if(tmpl.nil?)
-      add_warning(duplicate_level_templ.uniq, resource.iri) if (duplicate_level_templ.length > 1) && (Jekyll.env.eql? "development")
+      tmpl = request_class_template(resource) if tmpl.nil?
       return tmpl unless tmpl.nil?
       return @default_template
     end
 
     ##
-    # Add a warning for a resource having multiple possible templates
-    # The warnings are then later displayed with print_warnings
+    # outputs all warnings prepared by RdfClassExtraction.consistence_templates
     #
-    def add_warning(keys, iri)
-      keys.sort!
-      key = keys.join(', ')
-      @warnings[key] = [] if @warnings[key].nil?  # using a hash ensures that a warning is printed only once for each combination of templates
-                                                  # and for each resource at most once
-      @warnings[key].push(iri) unless @warnings[key].include? iri
-    end
-
     def print_warnings
-      @warnings.delete_if{ |key, iris|
-        Jekyll.logger.warn("Warning: multiple possible templates for resources #{iris.join(", ")}\nPossible Templates: #{key}")
+      @consistence.each{ |key, template_class_store|
+        Jekyll.logger.warn("Warning: multiple possible templates for resources #{template_class_store[1].join(", ")}\nPossible Templates: #{key}")
         true
       }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-rdf
 version: !ruby/object:Gem::Version
-  version: 3.1.1.pre.develop.671
+  version: 3.1.1.pre.develop.688
 platform: ruby
 authors:
 - Elias Saalmann
@@ -18,7 +18,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-12 00:00:00.000000000 Z
+date: 2019-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-http-persistent