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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce8e81b3aea49215c65e58422e36b970864e8a9153dee42925f613a61177e96c
-  data.tar.gz: 7177863c59f5b96c0315f24b47b5b0a6ef49fd22fc891e23cd9803c4891a0652
+  metadata.gz: e9255ac5d8912fd3200919a85fa010e84ea40ba9b8c47e8fcca1ad66788387ed
+  data.tar.gz: 5a8c256c0d62129f3ec4cafa6fca75abb207660a29ace1b8e60825d4aa22b8a0
 SHA512:
-  metadata.gz: 511e8c2eaebbf388f504fea3931bb7ae5d9dbc0d0ad9bef851b52821fa7155552c4ff2500c724ffe8d8963b6a3027892d41b133f088e5bef7b84623859169a63
-  data.tar.gz: 6030083f2482f27450c8823a9bfb34bd7a2b4110261a7ee4e8ff85c3eca816b68096b445c8781385397f7e95580623e1a238c14ce017a7043fa82903fdb0077d
+  metadata.gz: 4cd76f82301aa6628f57b5787b5f5b0ca1cdacf4ae5f3e1277e9526b80a0a05e5206e6d8e60311e48cc8f3738ce225981817695c42ae1aa09033eb0909f1359c
+  data.tar.gz: fca2156b0169d18b5e9ce248b145cc8deec6eb52357937d70ed6924f9f604ee491997badf2d52d73128376c1d5acb8e490a28464d556a70e7f4f5f2ed1bffd47

data/lib/jekyll-rdf.rb

@@ -42,6 +42,9 @@ require 'jekyll/exceptions/NoPrefixMapped'
 require 'jekyll/exceptions/NoPrefixesDefined'
 require 'jekyll/exceptions/UnMarkedUri'
 require 'jekyll/helper/rdf_general_helper'
+require 'jekyll/helper/rdf_class_extraction'
+require 'jekyll/helper/rdf_page_helper'
+require 'jekyll/helper/rdf_generator_helper'
 require 'jekyll/hooks/rdf_page_pointer'
 require 'jekyll/filters/rdf_resolve_prefix'
 require 'jekyll/filters/rdf_sparql_query'
@@ -49,9 +52,8 @@ require 'jekyll/filters/rdf_property'
 require 'jekyll/filters/rdf_collection'
 require 'jekyll/filters/rdf_container'
 require 'jekyll/filters/rdf_get'
-require 'jekyll/rdf_generator_helper'
+
+Liquid::Template.register_filter(Jekyll::JekyllRdf::Filter)
 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_literal.rb

@@ -24,20 +24,22 @@
 #
 
 module Jekyll
-  module Drops
-
-    ##
-    # Represents an RDF literal to the Liquid template engine
-    #
-    class RdfLiteral < RdfTerm
+  module JekyllRdf
+    module Drops
 
       ##
-      # Return a user-facing string representing this RdfLiteral
+      # Represents an RDF literal to the Liquid template engine
       #
-      def literal
-        term.to_s
-      end
+      class RdfLiteral < RdfTerm
 
+        ##
+        # Return a user-facing string representing this RdfLiteral
+        #
+        def literal
+          term.to_s
+        end
+
+      end
     end
   end
 end

data/lib/jekyll/drops/rdf_resource.rb

@@ -24,275 +24,278 @@
 #
 
 module Jekyll #:nodoc:
-  module Drops #:nodoc:
-
-    ##
-    # Represents an RDF resource to the Liquid template engine
-    #
-    class RdfResource < RdfTerm
+  module JekyllRdf #:nodoc:
+    module Drops #:nodoc:
 
       ##
-      # The Jekyll::Site of this Jekyll::Drops::RdfResource
+      # Represents an RDF resource to the Liquid template engine
       #
-      attr_accessor :site
+      class RdfResource < RdfTerm
 
-      ##
-      # The Jekyll::RdfPageData of this Jekyll::Drops::RdfResource
-      #
-      attr_accessor :page
+        ##
+        # The Jekyll::Site of this Jekyll::JekyllRdf::Drops::RdfResource
+        #
+        attr_accessor :site
 
-      ##
-      #
-      #
-      attr_accessor :subResources
+        ##
+        # The Jekyll::RdfPageData of this Jekyll::JekyllRdf::Drops::RdfResource
+        #
+        attr_accessor :page
 
-      ##
-      #
-      #
-      attr_reader :covered
+        ##
+        #
+        #
+        attr_reader :covered
 
-      ##
-      #
-      #
-      def initialize(term, site = nil, page = nil, covered = false)
-        super(term)
-        if(site.is_a?(Jekyll::Site))
-          @site = site
-        end
-        if(page.is_a?(Jekyll::Page))
-          @page = page
-        end
-        @subResources = {}
-        @covered = covered
-      end
+        ##
+        #
+        #
+        attr_accessor :subResources
 
-      def add_necessities(site, page)
-        if(site.is_a?(Jekyll::Site))
-          @site ||= site
+        ##
+        #
+        #
+        def initialize(term, site = nil, page = nil, covered = false)
+          super(term)
+          if(site.is_a?(Jekyll::Site))
+            @site = site
+          end
+          if(page.is_a?(Jekyll::Page))
+            @page = page
+          end
+          @subResources = {}
+          @covered = covered
         end
-        if(page.is_a?(Jekyll::Page))
-          @page ||= page
+
+        def add_necessities(site, page)
+          if(site.is_a?(Jekyll::Site))
+            @site ||= site
+          end
+          if(page.is_a?(Jekyll::Page))
+            @page ||= page
+          end
+          return self
         end
-        return self
-      end
 
-      def ready?
-        return (@site.is_a?(Jekyll::Site)||@page.is_a?(Jekyll::Page))
-      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
-      #
-      def statements
-        @statements ||= statements_as_subject + statements_as_predicate + statements_as_object
-      end
+        ##
+        # Return a list of Jekyll::JekyllRdf::Drops::RdfStatements whose subject, predicate or object is the RDF resource represented by the receiver
+        #
+        def statements
+          @statements ||= statements_as_subject + statements_as_predicate + statements_as_object
+        end
 
-      ##
-      # Return a list of Jekyll::Drops::RdfStatements whose subject is the RDF resource represented by the receiver
-      #
-      def statements_as_subject
-        @statements_as_subject ||= statements_as :subject
-      end
+        ##
+        # Return a list of Jekyll::JekyllRdf::Drops::RdfStatements whose subject is the RDF resource represented by the receiver
+        #
+        def statements_as_subject
+          @statements_as_subject ||= statements_as :subject
+        end
 
-      ##
-      # Return a list of Jekyll::Drops::RdfStatements whose predicate is the RDF resource represented by the receiver
-      #
-      def statements_as_predicate
-        @statements_as_predicate ||= statements_as :predicate
-      end
+        ##
+        # Return a list of Jekyll::JekyllRdf::Drops::RdfStatements whose predicate is the RDF resource represented by the receiver
+        #
+        def statements_as_predicate
+          @statements_as_predicate ||= statements_as :predicate
+        end
 
-      ##
-      # Return a list of Jekyll::Drops::RdfStatements whose object is the RDF resource represented by the receiver
-      #
-      def statements_as_object
-        @statements_as_object ||= statements_as :object
-      end
+        ##
+        # Return a list of Jekyll::JekyllRdf::Drops::RdfStatements whose object is the RDF resource represented by the receiver
+        #
+        def statements_as_object
+          @statements_as_object ||= statements_as :object
+        end
 
-      ##
-      # Return a filename corresponding to the RDF resource represented by the receiver. The mapping between RDF resources and filenames should be bijective.
-      #
-      def filename(domain_name, baseurl)
-        @filename ||= generate_file_name(domain_name, baseurl)
-      end
+        ##
+        # Return a filename corresponding to the RDF resource represented by the receiver. The mapping between RDF resources and filenames should be bijective.
+        #
+        def filename(domain_name, baseurl)
+          @filename ||= generate_file_name(domain_name, baseurl)
+        end
 
-      def direct_classes
-        @direct_classes ||= 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?
-            selection.each{|s| classes << s.object.term.to_s}
+        def direct_classes
+          @direct_classes ||= 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?
+              selection.each{|s| classes << s.object.term.to_s}
+            end
+            classes.uniq!
+            classes
           end
-          classes.uniq!
-          classes
         end
-      end
-
-      def iri
-        term.to_s
-      end
 
-      ##
-      # Return the URL of the page representing this RdfResource
-      #
-      def page_url
-        return @page_url unless @page_url.nil?
-        generate_file_name(@site.config["url"], @site.config["baseurl"])
-        @page_url
-      end
+        ##
+        # Return the URL of the page representing this RdfResource
+        #
+        def page_url
+          return @page_url unless @page_url.nil?
+          generate_file_name(@site.config["url"], @site.config["baseurl"])
+          @page_url
+        end
 
-      ##
-      # Return the path to the page representing this RdfResource
-      #
-      def render_path
-        return @render_path unless @page_url.nil?
-        generate_file_name(@site.config["url"], @site.config["baseurl"])
-        @render_path
-      end
+        ##
+        # Return the path to the page representing this RdfResource
+        #
+        def render_path
+          return @render_path unless @page_url.nil?
+          generate_file_name(@site.config["url"], @site.config["baseurl"])
+          @render_path
+        end
 
-      ##
-      # Return a list of RDF statements where the represented RDF resource plays a role
-      # * +role+ - which role the represented RDF resource should play:
-      #   :subject ::
-      #     Return a list of Jekyll::Drops::RdfStatements whose subject is the RDF resource represented by the receiver
-      #   :predicate ::
-      #     Return a list of Jekyll::Drops::RdfStatements whose predicate is the RDF resource represented by the receiver
-      #   :object ::
-      #     Return a list of Jekyll::Drops::RdfStatements whose object is the RDF resource represented by the receiver
-      #
-      def statements_as(role)
-        if(!term.to_s[0..1].eql? "_:")
-          input_uri = "<#{term.to_s}>"
-        elsif(:predicate.eql? role)
-          return []
-        else
-          input_uri = term.to_s
+        def iri
+          term.to_s
         end
 
-        case role
+        ##
+        # Return a list of RDF statements where the represented RDF resource plays a role
+        # * +role+ - which role the represented RDF resource should play:
+        #   :subject ::
+        #     Return a list of Jekyll::JekyllRdf::Drops::RdfStatements whose subject is the RDF resource represented by the receiver
+        #   :predicate ::
+        #     Return a list of Jekyll::JekyllRdf::Drops::RdfStatements whose predicate is the RDF resource represented by the receiver
+        #   :object ::
+        #     Return a list of Jekyll::JekyllRdf::Drops::RdfStatements whose object is the RDF resource represented by the receiver
+        #
+        def statements_as(role)
+          if(!term.to_s[0..1].eql? "_:")
+            input_uri = "<#{term.to_s}>"
+          elsif(:predicate.eql? role)
+            return []
+          else
+            input_uri = term.to_s
+          end
+
+          case role
           when :subject
             query = "SELECT ?p ?o ?dt ?lit ?lang WHERE{ #{input_uri} ?p ?o BIND(datatype(?o) AS ?dt) BIND(isLiteral(?o) AS ?lit) BIND(lang(?o) AS ?lang)}"
-            Jekyll::RdfHelper::sparql.query(query).map do |solution|
+            Jekyll::JekyllRdf::Helper::RdfHelper::sparql.query(query).map do |solution|
               check = check_solution(solution)
               create_statement(term.to_s, solution.p, solution.o, solution.lit, check[:lang], check[:data_type])
             end
           when :predicate
             query = "SELECT ?s ?o ?dt ?lit ?lang WHERE{ ?s #{input_uri} ?o BIND(datatype(?o) AS ?dt) BIND(isLiteral(?o) AS ?lit) BIND(lang(?o) AS ?lang)}"
-            Jekyll::RdfHelper::sparql.query(query).map do |solution|
+            Jekyll::JekyllRdf::Helper::RdfHelper::sparql.query(query).map do |solution|
               check = check_solution(solution)
               create_statement(solution.s, term.to_s, solution.o, solution.lit, check[:lang], check[:data_type])
             end
           when :object
             query = "SELECT ?s ?p WHERE{ ?s ?p #{input_uri}}"
-            Jekyll::RdfHelper::sparql.query(query).map do |solution|
+            Jekyll::JekyllRdf::Helper::RdfHelper::sparql.query(query).map do |solution|
               create_statement( solution.s, solution.p, term.to_s)
             end
           else
             Jekyll.logger.error "Not existing role found in #{term.to_s}"
             return
+          end
         end
-      end
 
-      def inspect
-        obj_id = ('%x' % (self.object_id << 1)).to_s
-        return "#<RdfResource:0x#{"0"*(14 - obj_id.length)}#{obj_id} @iri=#{iri} @subResources=[#{subResources.map { |x| x.inspect}.join(", ")}]>"
-      end
-
-      #checks if a query solution contains a language or type tag and returns those in a hash
-      private
-      def check_solution(solution)
-        result = {:lang => nil, :data_type => nil}
-        if((solution.bound?(:lang)) && (!solution.lang.to_s.eql?("")))
-          result[:lang] = solution.lang.to_s.to_sym
+        def inspect
+          obj_id = ('%x' % (self.object_id << 1)).to_s
+          return "#<RdfResource:0x#{"0"*(14 - obj_id.length)}#{obj_id} @iri=#{iri} @subResources=[#{subResources.map { |x| x.inspect}.join(", ")}]>"
         end
-        if(solution.bound? :dt)
-          result[:data_type] = solution.dt
+
+        #checks if a query solution contains a language or type tag and returns those in a hash
+        private
+        def check_solution(solution)
+          result = {:lang => nil, :data_type => nil}
+          if((solution.bound?(:lang)) && (!solution.lang.to_s.eql?("")))
+            result[:lang] = solution.lang.to_s.to_sym
+          end
+          if(solution.bound? :dt)
+            result[:data_type] = solution.dt
+          end
+          return result
         end
-        return result
-      end
 
-      def create_statement(subject_string, predicate_string, object_string, is_lit = nil, lang = nil, data_type = nil)
-        subject = RDF::URI(subject_string)
-        predicate = RDF::URI(predicate_string)
-        if(!is_lit.nil?&&is_lit.true?)
-          object = RDF::Literal(object_string, language: lang, datatype: RDF::URI(data_type))
-        else
-          object = RDF::URI(object_string)
+        def create_statement(subject_string, predicate_string, object_string, is_lit = nil, lang = nil, data_type = nil)
+          subject = RDF::URI(subject_string)
+          predicate = RDF::URI(predicate_string)
+          if(!is_lit.nil?&&is_lit.true?)
+            object = RDF::Literal(object_string, language: lang, datatype: RDF::URI(data_type))
+          else
+            object = RDF::URI(object_string)
+          end
+          return RdfStatement.new(RDF::Statement( subject, predicate, object), @site)
         end
-        return RdfStatement.new(RDF::Statement( subject, predicate, object), @site)
-      end
 
-      ##
-      # Generate a filename corresponding to the RDF resource represented by the receiver. The mapping between RDF resources and filenames should be bijective. If the url of the rdf is the same as of the hosting site it will be omitted.
-      # * +domain_name+
-      #
-      def generate_file_name(domain_name, baseurl)
-        fragment_holder = nil
-        domain_name = domain_name.to_s
-        baseurl = baseurl.to_s
-        (("/".eql? baseurl[-1]) || (baseurl.empty? && ("/".eql? domain_name[-1]))) ? rdfsites="rdfsites/": rdfsites="/rdfsites/"
-        if(term.to_s[0..1].eql? "_:")
-          file_name = "#{rdfsites}blanknode/#{term.to_s.gsub('_:','blanknode_')}/" # ':' can not be used on windows
-        else
-          begin
-            uri = Addressable::URI.parse(term.to_s).to_hash
-            file_name = rdfsites # in this directory all external RDF sites are stored
-            if((uri[:host].eql? domain_name) || ("#{uri[:scheme]}://#{uri[:host]}".eql? domain_name))
-              if((baseurl.length == 0))       #Special cases like baseurl == path or non-existent baseurl
-                uri[:scheme] = nil
-                uri[:host] = nil
-                file_name = ""
-              elsif(uri[:path].eql?(baseurl))
-                uri[:path] = nil
-                uri[:scheme] = nil
-                uri[:host] = nil
-                file_name = ""
-              elsif(uri[:path].length > baseurl.length)                   #baseurl might be the first part of :path
-                if(uri[:path][0..(baseurl.length - 1)].eql? baseurl)
-                  uri[:path] = uri[:path][(baseurl.length)..-1]
+        ##
+        # Generate a filename corresponding to the RDF resource represented by the receiver. The mapping between RDF resources and filenames should be bijective. If the url of the rdf is the same as of the hosting site it will be omitted.
+        # * +domain_name+
+        #
+        def generate_file_name(domain_name, baseurl)
+          fragment_holder = nil
+          domain_name = domain_name.to_s
+          baseurl = baseurl.to_s
+          (("/".eql? baseurl[-1]) || (baseurl.empty? && ("/".eql? domain_name[-1]))) ? rdfsites="rdfsites/": rdfsites="/rdfsites/"
+          if(term.to_s[0..1].eql? "_:")
+            file_name = "#{rdfsites}blanknode/#{term.to_s.gsub('_:','blanknode_')}/" # ':' can not be used on windows
+          else
+            begin
+              uri = Addressable::URI.parse(term.to_s).to_hash
+              file_name = rdfsites # in this directory all external RDF sites are stored
+              if((uri[:host].eql? domain_name) || ("#{uri[:scheme]}://#{uri[:host]}".eql? domain_name))
+                if((baseurl.length == 0))       #Special cases like baseurl == path or non-existent baseurl
+                  uri[:scheme] = nil
+                  uri[:host] = nil
+                  file_name = ""
+                elsif(uri[:path].eql?(baseurl))
+                  uri[:path] = nil
                   uri[:scheme] = nil
                   uri[:host] = nil
                   file_name = ""
+                elsif(uri[:path].length > baseurl.length)                   #baseurl might be the first part of :path
+                  if(uri[:path][0..(baseurl.length - 1)].eql? baseurl)
+                    uri[:path] = uri[:path][(baseurl.length)..-1]
+                    uri[:scheme] = nil
+                    uri[:host] = nil
+                    file_name = ""
+                  end
                 end
               end
+              #An URI consists of these fields [:scheme, :userinfo, :host, :port, :registry, :path, :opaque, :query, :fragment]
+              file_name << "#{uri[:scheme]}/" unless uri[:scheme].nil?
+              file_name << "#{uri[:userinfo]}@" unless uri[:userinfo].nil?
+              file_name << "#{uri[:host]}/" unless uri[:host].nil?
+              file_name << "#{uri[:port]}/" unless uri[:port].nil?
+              # registry purpose unknown
+              file_name << "#{uri[:path][0..-1]}" unless uri[:path].nil?
+              fragment_holder = "##{uri[:fragment]}" unless uri[:fragment].nil?
+              # opaque jekyll produces static pages, so we do not dereferencing
+              # query queries do not address resources
+              # file_name << "#/#{uri[:fragment]}" unless uri[:fragment].nil? fragments are not evaluated by browsers, only by clients
+            rescue Addressable::URI::InvalidURIError => x
+              file_name = "invalids/#{term.to_s}"
+              Jekyll.logger.error("Invalid resource found: #{term.to_s} is not a proper uri")
+              Jekyll.logger.error("URI parser exited with message: #{x.message}")
             end
-            #An URI consists of these fields [:scheme, :userinfo, :host, :port, :registry, :path, :opaque, :query, :fragment]
-            file_name << "#{uri[:scheme]}/" unless uri[:scheme].nil?
-            file_name << "#{uri[:userinfo]}@" unless uri[:userinfo].nil?
-            file_name << "#{uri[:host]}/" unless uri[:host].nil?
-            file_name << "#{uri[:port]}/" unless uri[:port].nil?
-            # registry purpose unknown
-            file_name << "#{uri[:path][0..-1]}" unless uri[:path].nil?
-            fragment_holder = "##{uri[:fragment]}" unless uri[:fragment].nil?
-            # opaque jekyll produces static pages, so we do not dereferencing
-            # query queries do not address resources
-            # file_name << "#/#{uri[:fragment]}" unless uri[:fragment].nil? fragments are not evaluated by browsers, only by clients
-          rescue Addressable::URI::InvalidURIError => x
-            file_name = "invalids/#{term.to_s}"
-            Jekyll.logger.error("Invalid resource found: #{term.to_s} is not a proper uri")
-            Jekyll.logger.error("URI parser exited with message: #{x.message}")
           end
-        end
-        file_name = file_name.gsub('//','/') # needs a better regex to include /// ////...
-        file_name = file_name.strip
-        if(file_name[-2..-1] == "#/")
-          file_name = file_name[0..-3]
-        end
-        if(file_name[-1] == '/')
-          file_name << "index.html"
-        else
-          last_slash = file_name.rindex('/')
-          last_slash = 0 if last_slash.nil?
-          ending = ""
-          if(file_name[-5..-1].eql? ".html")
-            ending = ".html" #in case .html is already contained by the term.url
+          file_name = file_name.gsub('//','/') # needs a better regex to include /// ////...
+          file_name = file_name.strip
+          if(file_name[-2..-1] == "#/")
+            file_name = file_name[0..-3]
+          end
+          if(file_name[-1] == '/')
+            file_name << "index.html"
           else
-            file_name[last_slash..-1] = "#{file_name[last_slash..-1]}.html"
+            last_slash = file_name.rindex('/')
+            last_slash = 0 if last_slash.nil?
+            ending = ""
+            if(file_name[-5..-1].eql? ".html")
+              ending = ".html" #in case .html is already contained by the term.url
+            else
+              file_name[last_slash..-1] = "#{file_name[last_slash..-1]}.html"
+            end
           end
+          @render_path = file_name
+          @page_url = "#{file_name.chomp('index.html').chomp('.html')}#{ending}#{fragment_holder}"
+          file_name
         end
-        @render_path = file_name
-        @page_url = "#{file_name.chomp('index.html').chomp('.html')}#{ending}#{fragment_holder}"
-        file_name
       end
+
     end
   end
 end