jekyll-rdf 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 110cb3800452fb5622a7f01dd39c367ed6d4a181
+  data.tar.gz: d7bd153e3055b51569e85fcaae039db8b44e60ad
+SHA512:
+  metadata.gz: 8ace2caa161e8103fdb6d2de6f60fb570a0103fba2c9e6a16e571e68fbab0ba67d7a6d865d97aa5fa470d851998edaa60853015278824b74660c60dc7596c2ee
+  data.tar.gz: eeef2100f84e9d3b2272ed15e41f95f8386d8319e87068102ea29d50dd529c1ab35cbea5c48e0a4761511b0aef64fa98e6f082389a48bf8ac67deca61cdbb08c

data/lib/jekyll-rdf.rb

@@ -0,0 +1,19 @@
+##
+# JekyllRdf converts RDF data into static websites
+#
+#
+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/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

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

data/lib/jekyll/drops/rdf_resource.rb

@@ -0,0 +1,153 @@
+module Jekyll
+  module Drops
+    class RdfResource < RdfTerm
+      
+      ##
+      # The Jekyll::Site of this Jekyll::Drops::RdfResource
+      #
+      attr_accessor :site
+      
+      ##
+      # The Jekyll::RdfPageData of this Jekyll::Drops::RdfResource
+      #
+      attr_accessor :page
+
+      ##
+      # 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::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::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
+
+      ##
+      # types finds the type and superclasses of the resource
+      #
+      def types
+        @types ||= begin
+          types = [ term.to_s ]
+          t = statements_as(:subject).find{ |s| s.predicate.term.to_s=="http://www.w3.org/1999/02/22-rdf-syntax-ns#type" }
+          if t
+            types << t.object.term.to_s
+            t = t.object
+            while t.super_class
+              s = t.super_class
+              types << s.term.to_s
+              t = s
+            end
+          end
+          types
+        end
+      end
+
+      ##
+      # Return the first super class resource of the receiver or nil, if no super class resource can be found
+      #
+      def super_class
+        s = statements_as(:subject).find{ |s| s.predicate.term.to_s=="http://www.w3.org/2000/01/rdf-schema#subClassOf" }
+        if s
+          s.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
+      end
+      
+      ##
+      # Return the URL of the page representing this RdfResource
+      #
+      def page_url
+        page ? page.url.chomp('index.html') : term.to_s
+      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)
+        graph.query(role.to_sym => term).map do |statement|
+          RdfStatement.new(statement, graph, site)
+        end
+      end
+
+      private
+      ##
+      # 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)
+        begin
+          uri = URI::split(term.to_s)
+          file_name = "rdfsites/" # in this directory all external RDF sites are stored
+          if (uri[2] == domain_name)
+            file_name = ""
+            uri[0] = nil
+            uri[2] = nil
+            uri[5] = uri[5].sub(baseurl,'')
+          end
+          (0..8).each do |i|
+            if uri[i]
+              case i
+              when 2
+                file_name += "#{uri[i].gsub('.','/')}/"
+              when 8
+                file_name = file_name[0..-2]
+                file_name += "##{uri[i]}"
+              else
+                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"
+        end
+      end
+
+    end
+  end
+end

data/lib/jekyll/drops/rdf_statement.rb

@@ -0,0 +1,37 @@
+module Jekyll
+  module Drops
+    
+    ##
+    # Represents an RDF statement to the Liquid template engine
+    #
+    class RdfStatement < Liquid::Drop
+      
+      ##
+      # The subject RdfTerm of this RDF statement
+      #
+      attr_reader :subject
+      
+      ##
+      # The predicate RdfTerm of this RDF statement
+      #
+      attr_reader :predicate
+      
+      ##
+      # The object RdfTerm of this RDF statement
+      #
+      attr_reader :object
+
+      ##
+      # Create a new Jekyll::Drops::RdfStatement
+      #
+      # * +statement+ - The statement to be represented
+      # * +graph+ - The RDF::Graph which contains the +statement+ 
+      # * +site+ - The Jekyll::Site to be enriched 
+      def initialize(statement, graph, site)
+        @subject ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.subject, graph, site)
+        @predicate ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.predicate, graph, site)
+        @object ||= Jekyll::Drops::RdfTerm.build_term_drop(statement.object, graph, site)
+      end
+    end
+  end
+end

data/lib/jekyll/drops/rdf_term.rb

@@ -0,0 +1,60 @@
+module Jekyll
+  module Drops
+  
+    ##
+    # Represents an RDF term to the Liquid template engine 
+    #
+    class RdfTerm < Liquid::Drop
+      
+      ##
+      # The represented RDF term
+      #
+      attr_reader :term
+
+      ##
+      # The RDF::Graph which contains the represented +term+
+      #
+      attr_reader :graph
+
+      ##
+      # Create a new Jekyll::Drops::RdfTerm
+      # 
+      # * +term+ - The term to be represented
+      # * +graph+ - The RDF::Graph which contains the represented +term+
+      #
+      def initialize(term, graph)
+        @term  ||= term
+        @graph ||= graph
+      end
+      
+      ##
+      # Convert this RdfTerm into a human-readable string
+      #
+      def to_s
+        name
+      end
+
+      ##
+      # Convert an RDF term into a new Jekyll::Drops::RdfTerm
+      #
+      # * +term+ - The term to be represented
+      # * +graph+ - The RDF::Graph which contains the represented +term+
+      # * +site+ - The Jekyll::Site to be enriched
+      #
+      def self.build_term_drop(term, graph, site)
+        case term
+        when RDF::URI, RDF::Node
+          if site
+            resource = site.data['resources'].find{ |r| r.term == term }
+          end
+          resource ? resource : RdfResource.new(term, graph)
+        when RDF::Literal
+          return RdfLiteral.new(term, graph)
+        else
+          return nil
+        end
+      end
+
+    end
+  end
+end

data/lib/jekyll/filters/rdf_property.rb

@@ -0,0 +1,22 @@
+module Jekyll
+  module RdfProperty
+
+    def rdf_property(input, params)
+      return input unless input.is_a?(Jekyll::Drops::RdfResource)
+      begin
+        params = params.split(",")
+        results = input.page.data['rdf'].statements_as_subject.select{ |s| s.predicate.term.to_s == params[0] }
+        lang = params[1] || input.site.config['language']
+        if results.count > 1 && results.first.object.term.is_a?(RDF::Term)
+          p = results.find{ |s| s.object.term.language == lang }
+        end
+        p = results.first unless p
+        return unless p
+        (p.object.name).to_s
+      end
+    end
+
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::RdfProperty)

data/lib/jekyll/filters/rdf_property_list.rb

@@ -0,0 +1,16 @@
+module Jekyll
+  module RdfPropertyList
+
+    def rdf_property_list(input, property)
+      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 == property }.map{|p| p.object.name}
+        return unless result
+        result
+      end
+    end
+
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::RdfPropertyList)

data/lib/jekyll/filters/rdf_sparql_query.rb

@@ -0,0 +1,20 @@
+module Jekyll
+  module RdfSparqlQuery
+
+    def sparql_query(input, query)
+      return input unless input.is_a?(Jekyll::Drops::RdfResource)
+      query.gsub!('?resourceUri', "<#{input.term.to_s}>")
+      begin
+        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
+      end
+    end
+
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::RdfSparqlQuery)

data/lib/jekyll/rdf_main_generator.rb

@@ -0,0 +1,85 @@
+module Jekyll
+
+  ##
+  #
+  # Jekyll::RdfMainGenerator enriches a Jekyll::Site with RDF triples
+  #
+  class RdfMainGenerator < Jekyll::Generator
+    safe true
+    priority :highest
+
+    ##
+    # #generate performs the enrichment of a Jekyll::Site with rdf triples
+    #
+    # * +site+ - The Jekyll::Site whose #data is to be enriched
+    #
+    def generate(site)
+      config = site.config.fetch('jekyll_rdf')
+
+      graph = RDF::Graph.load(config['path'])
+      sparql = SPARQL::Client.new(graph)
+
+      # restrict RDF graph with restriction
+      resources = extract_resources(config['restriction'], config['include_blank'], graph, sparql)
+
+      site.data['sparql'] = sparql
+      site.data['resources'] = []
+
+      mapper = Jekyll::RdfTemplateMapper.new(config['template_mappings'], config['default_template'])
+
+      # create RDF pages for each URI
+      resources.each do |uri|
+        resource = Jekyll::Drops::RdfResource.new(uri, graph)
+        site.pages << RdfPageData.new(site, site.source, resource, mapper)
+      end
+    end
+
+    ##
+    # #extract_resources returns resources from an RDF graph.
+    #
+    # Literals are omitted.
+    # Blank nodes are only returned if +include_blank+ is true.
+    # Duplicate nodes are removed.
+    #
+    # * +selection+ - choose any of the following:
+    #   nil ::
+    #     no restrictions, return subjects, predicates, objects
+    #   "subjects" ::
+    #     return only subjects
+    #   "predicates" ::
+    #     return only predicates
+    #   "objects" ::
+    #     return only objects
+    #   Otherwise ::
+    #     consider +selection+ to be a SPARQL query and return answer set to this SPARQL query
+    # * +include_blank+ - If true, blank nodes are also returned, otherwise blank nodes are omitted
+    # * +graph+ - The RDF graph to restrict
+    # * +sparql+ - The SPARQL client to run queries against
+    #
+    def extract_resources(selection, include_blank, graph, sparql)
+
+      case selection
+      when nil  # Config parameter not present
+        object_resources    = extract_resources("objects",    include_blank, graph, sparql)
+        subject_resources   = extract_resources("subjects",   include_blank, graph, sparql)
+        predicate_resources = extract_resources("predicates", include_blank, graph, sparql)
+        return object_resources.concat(subject_resources).concat(predicate_resources).uniq
+      when "objects"
+        graph.objects
+      when "subjects"
+        graph.subjects
+      when "predicates"
+        graph.predicates
+      else
+        # Custom query
+        sparql.query(selection).map{ |sol| sol[:resourceUri] }
+      end.reject do |s|  # Reject literals
+        s.class <= RDF::Literal
+      end.select do |s|  # Select URIs and blank nodes in case of include_blank
+        include_blank || s.class == RDF::URI
+      end.uniq
+    end
+
+  end
+
+end

data/lib/jekyll/rdf_page_data.rb

@@ -0,0 +1,35 @@
+module Jekyll
+
+  ##
+  # JekyllRdf::RdfPageData creates pages for each RDF resource using a given template
+  #
+  class RdfPageData < Jekyll::Page
+
+    ##
+    # initialize initializes the page
+    # * +site+ - The Jekyll site we want to enrich with RDF data
+    # * +base+ - The base of the site
+    # * +resource+ - The RDF resource for which the page is rendered
+    # * +mapper+ - The layout-mapping
+    #
+    def initialize(site, base, resource, mapper)
+      @site = site
+      @base = base
+      @dir = ""
+      @name = resource.filename(URI::split(site.config['url'])[2], site.config['baseurl'])
+      self.process(@name)
+
+      template = mapper.map(resource)
+      self.read_yaml(File.join(base, '_layouts'), template)
+
+      self.data['title'] = resource.name
+      self.data['rdf'] = resource
+
+      resource.page = self
+      resource.site = site
+      site.data['resources'] << resource
+    end
+
+  end
+
+end

data/lib/jekyll/rdf_template_mapper.rb

@@ -0,0 +1,40 @@
+module Jekyll
+
+  ##
+  # Jekyll::RdfTemplateMapper maps resources to templates
+  #
+  class RdfTemplateMapper
+    
+    ##
+    # A Hash mapping a type resource to a template name
+    attr_accessor :resources_to_templates
+    
+    ##
+    # Default template name
+    attr_accessor :default_template
+
+    ##
+    # 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)
+      @resources_to_templates = resources_to_templates
+      @default_template = default_template
+    end
+
+    ##
+    # Maps a resource to a template name. 
+    #
+    # 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[type]
+        return tmpl unless tmpl.nil?
+      end
+      return default_template
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-rdf
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Elias Saalmann
+- Christian Frommert
+- Simon Jakobi
+- Arne Jonas Präger
+- Maxi Bornmann
+- Georg Hackel
+- Eric Füg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: linkeddata
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.99'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.99'
+- !ruby/object:Gem::Dependency
+  name: sparql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.99'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.99'
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: Generate static sites with Jekyll based on RDF data
+email: mail@esaalmann.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/jekyll-rdf.rb
+- lib/jekyll/drops/rdf_literal.rb
+- lib/jekyll/drops/rdf_resource.rb
+- lib/jekyll/drops/rdf_statement.rb
+- lib/jekyll/drops/rdf_term.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/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Hypertext Publication System for Templates Resource Rendering
+test_files: []