yowl 0.4.pre

data/lib/yowl/generator.rb

@@ -0,0 +1,96 @@
+module YOWL
+
+  class Generator
+    
+    def initialize(repository, options)
+      @options = options
+      @repository = repository
+    end
+    
+    private
+    def generateOntologyHtmlFiles()
+      @repository.schemas.values.each() do |schema|
+        generateOntologyHtmlFile(schema)
+      end
+    end
+    
+    private
+    def generateOntologyHtmlFile(schema)
+      if @options.verbose
+        puts "Generating documentation for ontology #{schema.ontology.title}"
+      end
+      
+      introduction  = @introduction
+      repository    = @repository
+      
+      b = binding
+      
+      begin
+        Dir.mkdir(@options.output_dir)
+      rescue Errno::EEXIST
+      end
+      
+      ontologyFile = File.join(@options.output_dir, "#{schema.name}.html")
+      if @options.verbose
+        puts "Generating #{ontologyFile}"
+      end
+      File.open(ontologyFile, 'w') do |file|
+        file.write(@options.templates['ontology'].result(b))
+      end
+    end
+    
+    private
+    def generateHtmlFile(templateName_)
+      
+      template = @options.templates[templateName_]
+      
+      if template.nil?
+        puts "Not generating #{templateName_}.html since #{templateName_} template could not be found."
+        return
+      end
+      fileName = File.join(@options.output_dir, "#{templateName_}.html")
+      if @options.verbose
+        puts "Generating #{fileName}"
+      end
+      
+      repository  = @repository
+      schemas     = @repository.schemas.values
+      ontologies  = @repository.ontologies()
+      
+      b = binding
+      
+      File.open(fileName, 'w') do |file|
+        file.write(template.result(b))
+      end
+    end 
+    
+    private
+    def copyTemplateDir(src_, tgt_)
+      if Dir[src_] == []
+        return
+      end
+      puts "Copying #{src_} -> #{tgt_}"
+      FileUtils.cp_r src_, tgt_ 
+    end   
+    
+    private
+    def copyTemplates()
+      
+      @options.template_dirs.each do |template_dir|
+        copyTemplateDir("#{template_dir}/js",     "#{@options.output_dir}")
+        copyTemplateDir("#{template_dir}/css",    "#{@options.output_dir}")
+        copyTemplateDir("#{template_dir}/themes", "#{@options.output_dir}")
+        copyTemplateDir("#{template_dir}/img",    "#{@options.output_dir}")
+      end
+    end
+    
+    public
+    def run()
+      copyTemplates()
+      generateHtmlFile('index')
+      generateHtmlFile('introduction')
+      generateHtmlFile('import-diagram')
+      generateOntologyHtmlFiles()
+    end
+  end  
+end

data/lib/yowl/import.rb

@@ -0,0 +1,62 @@
+require 'yowl'
+
+module YOWL
+
+  class Import < YOWL::LabelledDocObject
+    
+    attr_reader :importedSchema
+    attr_reader :importedOntology
+ 
+    def initialize(resource_, schema_)
+      super(resource_, schema_)
+      
+      @importedSchema = schema_.repository.getSchemaForImport(self)
+      @importedOntology = @importedSchema ? @importedSchema.ontology : nil
+      
+      if @importedSchema.nil?
+        puts "WARNING: #{@schema.fileName}: Created Import #{uri} but did not find schema for it "
+      end
+      if @importedOntology.nil?
+        puts "WARNING: #{@schema.fileName}: Created Import #{uri} but did not find ontology for it "
+      end
+    end
+    
+    def name
+      if @importedSchema
+        return @importedSchema.name
+      end
+      prefix, ns = @schema.prefixForNamespace(uri)
+      if prefix
+        return prefix
+      end
+      return short_name
+    end
+    
+    def resourceNameHtml
+      return "#{@name}.html"
+    end
+    
+    def imports
+      return @importedOntology ? @importedOntology.imports : []
+    end
+    
+    def isExternal?
+      return (@importedSchema.nil? and @importedOntology.nil?)
+    end
+
+    #
+    # See YOWL::Individual::classWithURI(uri)
+    #    
+    def classWithURI(uri_)
+      if isExternal?
+        return nil
+      end
+      if @importedSchema
+        return @importedSchema.classWithURI(uri_)
+      end
+      puts "WARNING: Cannot check whether class #{uri_.to_s} exists in imported ontology #{uri} as this ontology is not loaded"
+      return nil
+    end
+
+  end
+end

data/lib/yowl/individual.rb

@@ -0,0 +1,398 @@
+module YOWL
+  #
+  # Represents an Individual defined in the schema
+  #  
+  class Individual < YOWL::LabelledDocObject
+    
+    private
+    def initialize(resource, schema)
+      super(resource, schema)
+      if schema.options.verbose
+        puts "Created Individual #{short_name}"
+      end
+    end
+   
+    public
+    def Individual.withUri(resource, schema)
+      if resource.anonymous?
+        warn "WARNING: Ignoring Individual with uri #{resource.to_s}"
+        return
+      end
+      individual = schema.individuals[resource.to_s]
+      if individual
+        return individual
+      end
+      individual = Individual.new(resource, schema)
+      schema.individuals[resource.to_s] = individual
+      return individual
+    end
+        
+    public
+    #
+    # This label is a bit different than the one in the base class as this one
+    # gets its prefix stripped, if there is one.
+    #
+    def label
+      @label ||= init_label
+    end
+
+    private 
+    def init_label
+      label = get_literal(YOWL::Namespaces::RDFS.label)
+      if label
+        return label
+      end 
+      label = short_name
+      label = label.sub(/(.*)\s*:/, "")
+      label = label.gsub("_", " ")
+      
+      label.sub!(/^r29-/, "") # TODO: Make this configurable via setting in ontology
+
+      classes.each do |klass|
+        className = klass.short_name
+        label.chomp!("-#{className}")
+        className.sub!(/.*:/, '')
+        label.chomp!("-#{className}")
+      end
+
+      return label
+    end
+    
+    private
+    def gvLabel
+      tmp = label.gsub(", ", ",\n")
+      return prefix ? "#{tmp}\n(#{prefix})" : tmp
+    end
+   
+    public
+    #
+    # The prefix to be used for the URI of this Individual, if defined, nil if it isn't
+    #
+    def prefix
+      @prefix ||= init_prefix
+    end
+
+    private 
+    def init_prefix
+      name = short_name
+      return name.include?(':') ? short_name.sub(/:\s*(.*)/, "") : nil
+    end
+    
+    public
+    def types
+      if not defined?(@types)
+        init_types
+      end
+      return @types
+    end
+
+    private
+    def init_types
+      @types = []
+      @schema.model.query(
+        RDF::Query::Pattern.new(@resource, RDF.type)
+      ) do |statement|
+        if statement.object == YOWL::Namespaces::OWL.NamedIndividual
+          next
+        end
+        @types << statement.object
+        if @schema.options.verbose
+          puts "Found Type #{statement.object.to_s} for Individual #{label}"
+        end
+      end
+    end
+   
+    public
+    def classes
+      if not defined?(@classes)
+        init_classes
+      end
+      return @classes
+    end
+
+    private 
+    def init_classes
+      @classes = []
+      types.each do |type|
+        klass = @schema.classWithURI(type)
+        if klass
+          @classes << klass
+          if @schema.options.verbose
+            puts "Found Class #{klass.short_name} for Individual #{label}"
+          end
+        else
+          puts "WARNING: Could not find Class definition for URI #{type.to_s}"
+        end
+      end
+    end
+
+    public
+    def isSkosConceptScheme?
+      conceptSchemeClassURI = YOWL::Namespaces::SKOS.ConceptScheme.to_s
+      types.each do |type|
+        #puts "isSkosConceptScheme #{type.to_s} #{conceptSchemeClassURI}"
+        if type.to_s == conceptSchemeClassURI
+          return true 
+        end
+      end
+      return false
+    end
+    
+    public
+    def isSkosConcept?
+      puts "isSkosConcept #{@resource}"
+      inScheme = get_literal(YOWL::Namespaces::SKOS.inScheme)
+      if not inScheme.nil?
+        return true
+      end
+      topConceptOf = get_literal(YOWL::Namespaces::SKOS.topConceptOf)
+      if not topConceptOf.nil?
+         return true
+      end
+      return false
+    end
+    
+    public
+    def isSkosConceptInScheme?(conceptScheme_)
+      inScheme = get_literal(YOWL::Namespaces::SKOS.inScheme)
+      if inScheme and inScheme.uri == conceptScheme_.uri
+        puts "isSkosConceptInScheme #{@resource}: #{inScheme.uri}"
+        return true
+      end
+      return false
+    end
+    
+    public
+    #
+    # Return a collection of Associations representing ObjectProperties
+    # where the current class is one of the Domain classes.
+    #
+    def associatedIndividuals
+      if not defined?(@associatedIndividuals)
+        init_associatedIndividuals
+      end
+      return @associatedIndividuals
+    end
+    
+    private
+    def init_associatedIndividuals()
+      @associatedIndividuals = Hash.new
+
+      if @schema.options.verbose
+        puts "Searching for associations of Individual #{short_name}"
+      end
+
+      sparql = <<sparql
+        SELECT DISTINCT ?individual WHERE {
+          {
+            ?individual a owl:NamedIndividual .
+            ?individual ?predicateA <#{uri}> .
+          } UNION {
+            <#{uri}>
+              a owl:NamedIndividual ;
+              ?predicateB ?individual ;
+            .
+            ?individual a owl:NamedIndividual .
+          }
+        }
+sparql
+      #if @schema.options.verbose
+      #  puts " - SPARQL: #{sparql}"
+      #end
+      solutions = SPARQL.execute(sparql, @schema.model, { :prefixes => @schema.prefixes })
+      if @schema.options.verbose
+        puts " - Found #{solutions.count} associated Individuals"
+      end
+      
+      solutions.each do |solution|
+        individual = Individual.withUri(solution[:individual], @schema)
+        if @schema.options.verbose
+          puts " - Found Individual #{individual.short_name}"
+        end
+        @associatedIndividuals[individual.uri] = individual
+      end
+      return @associatedIndividuals
+    end
+    
+    #
+    # Return a collection of IndividualAssociations representing ObjectProperties
+    # where the current Individual is the subject/resource.
+    #
+    def outboundAssociations()
+      if defined?(@outboundAssociations)
+        return @outboundAssociations
+      end
+      @outboundAssociations = Set.new
+    
+      if @schema.options.verbose
+        puts "Searching for associations of individual #{short_name}"
+      end
+
+      sparql = <<sparql
+        SELECT DISTINCT ?individual ?predicate WHERE {
+          <#{uri}> 
+            a owl:NamedIndividual ;
+            ?predicate ?individual
+          .
+          ?individual a owl:NamedIndividual .
+        }
+sparql
+          
+      #if @schema.options.verbose
+      #  puts " - SPARQL: #{sparql}"
+      #end
+      solutions = SPARQL.execute(sparql, @schema.model, { :prefixes => @schema.prefixes })
+      if @schema.options.verbose
+        puts " - Found #{solutions.count} associated 'outbound' Individual Associations"
+      end
+      
+      solutions.each do |solution|
+        individual = Individual.withUri(solution[:individual], @schema)
+        predicate = solution[:predicate]
+        @outboundAssociations << IndividualAssociation.new(predicate, @schema, self, individual)
+      end
+      if @schema.options.verbose
+        puts " - Returning #{@outboundAssociations.size} associations for Individual #{short_name}"
+      end
+      return @outboundAssociations
+    end
+
+    #
+    # Return a collection of IndividualAssociations representing ObjectProperties
+    # where the current Individual is the object.
+    #
+    def inboundAssociations()
+      if defined?(@inboundAssociations)
+        return @inboundAssociations
+      end
+      @inboundAssociations = Set.new
+    
+      if @schema.options.verbose
+        puts "Searching for 'inbound' associations of individual #{short_name}"
+      end
+    
+      sparql = <<sparql
+        SELECT DISTINCT ?individual ?predicate WHERE {
+          ?individual 
+            a owl:NamedIndividual ;
+            ?predicate <#{uri}> 
+          .
+        }
+sparql
+      #if @schema.options.verbose
+      #  puts " - SPARQL: #{sparql}"
+      #end
+      solutions = SPARQL.execute(sparql, @schema.model, { :prefixes => @schema.prefixes })
+      if @schema.options.verbose
+        puts " - Found #{solutions.count} associated 'inbound' Individual Associations"
+      end
+      
+      solutions.each do |solution|
+        individual = Individual.withUri(solution[:individual], @schema)
+        predicate = solution[:predicate]
+        @inboundAssociations << IndividualAssociation.new(predicate, @schema, individual, self)
+      end
+      if @schema.options.verbose
+        puts " - Returning #{@inboundAssociations.size} associations for Individual #{short_name}"
+      end
+      return @inboundAssociations
+    end
+    
+    private
+    def labelAsGraphvizRecord
+      lbl = label.gsub("_", " ")
+      if prefix and prefix == "r29" # TODO: make configurable
+        prefix = nil
+      end
+      lbl = prefix.nil? ? lbl : "#{lbl} | #{prefix}"
+      lbl = "#{lbl} |"
+      classes.each do |klass|
+        lbl += " #{klass.short_name} |"
+      end
+      lbl.chomp!(" |")
+      #puts "---------#{lbl}------"
+      return lbl    
+    end
+    
+    public
+    #
+    # Add the current Individual as a GraphViz node to the given collection of nodes
+    # and to the given graph. Return the collection of nodes.
+    #    
+    def addAsGraphvizNode (graph_, nodes_, edges_, level_, maxLevel_ = 0)
+      if level_ < 1
+        return nodes_, edges_
+      end
+      if @schema.options.verbose
+        puts "- Processing Individual #{label}"
+      end
+      #
+      # No need to add a node twice
+      #
+      if nodes_.has_key?(uri)
+        return nodes_, edges_
+      end
+      options = {
+        :shape => :record,
+        :style => "rounded,filled",
+        :label => labelAsGraphvizRecord,
+        :tooltip => uri,
+        :peripheries => 1, 
+        :margin => "0.21,0.055",
+        :fontcolor => :black,
+        :fontsize => 8,
+        :penwidth => 0.5,
+        :color => :black,
+        :fillcolor => "#FCFCFC",
+        :href => "#individual_#{short_name}"
+      }
+      if level_ == maxLevel_
+        options[:color] = "red"
+        options[:penwidth] = 1
+      end
+      node = graph_.add_nodes(escaped_uri, options)
+      nodes_[uri] = node
+      node.URL = "#individual_#{short_name}"
+      
+      #if hasComment?
+      #  node.tooltip = comment
+      #end
+      
+      #classes.each do |klass|
+      #  nodes_, edges_ = klass.addAsGraphvizNode(graph_, nodes_, edges_)
+      #  Class.newGraphVizEdge(graph_, node, nodes_[klass.uri], false)
+      #end
+
+      inboundAssociations.each do |association|
+        nodes_, edges_ = association.addAsGraphVizEdge(graph_, nodes_, edges_, level_ - 1)
+      end
+      
+      outboundAssociations.each do |association|
+        nodes_, edges_ = association.addAsGraphVizEdge(graph_, nodes_, edges_, level_ - 1)
+      end
+
+      return nodes_, edges_
+    end    
+    
+    public
+    #
+    # Generate a diagram for each Individual
+    #
+    def asSvg
+      if @schema.options.verbose
+        puts "Generating SVG for Individual #{short_name}"
+      end
+    
+      g = GraphvizUtility.setDefaults(GraphViz.new(:G, :type => :digraph))
+      g[:rankdir] = "LR"
+      g.node[:fixedsize] = false
+      
+      nodes  = Hash.new
+      edges  = Hash.new
+
+      nodes, edges = addAsGraphvizNode(g, nodes, edges, 5, 5)
+
+      return GraphvizUtility.embeddableSvg(g)
+    end
+  end
+end

data/lib/yowl/individual_association.rb

@@ -0,0 +1,80 @@
+module YOWL
+  
+  class IndividualAssociation < YOWL::LabelledDocObject
+
+    attr_reader :domainIndividual
+    attr_reader :rangeIndividual
+    attr_reader :property
+    attr_reader :key
+    
+    def initialize(resource, schema, domainIndividual, rangeIndividual)
+      
+      if resource.nil?
+        raise "Problem"
+      end
+      super(resource, schema)
+      
+      @domainIndividual = domainIndividual
+      @rangeIndividual = rangeIndividual
+
+      @key = "#{@domainIndividual.uri},#{@rangeIndividual.uri},#{label}".hash
+      
+      #puts "Created IndividualAssociation #{@domainIndividual.uri},#{@rangeIndividual.uri}, #{uri}"
+    end
+
+    def label
+      return short_name
+    end
+
+    def hash
+      return key
+    end
+
+    def eql?(other)
+      @key.eql? other.key
+    end
+
+    #
+    # Add the current IndividualAssociation as an edge to the given GraphViz graph,
+    # but check whether the IndividualAssociation refers to a Domain and Range class in
+    # the current schema and whether the IndividualAssociation has already been added
+    # to the graph (by checking the given edges collection).
+    #
+    def addAsGraphVizEdge(graph_, nodes_, edges_, level_)
+      
+      if level_ < 1
+        return nodes_, edges_
+      end
+
+      nodes_, edges_ = @domainIndividual.addAsGraphvizNode(graph_, nodes_, edges_, level_)
+      nodes_, edges_ = @rangeIndividual.addAsGraphvizNode(graph_, nodes_, edges_, level_)
+      
+      if edges_.has_key?(@key)
+        return nodes_, edges_
+      end
+      
+      domainIndividualNode = nodes_[@domainIndividual.uri]
+      rangeIndividualNode = nodes_[@rangeIndividual.uri]
+      
+      #
+      # As the level_ parameter for the two calls to addAsGraphvizNode might have caused
+      # that one or both of these nodes are not generated, we have to check for this here.
+      #
+      if domainIndividualNode.nil? or rangeIndividualNode.nil?
+        return nodes_, edges_
+      end
+      
+      options = {
+        :label => label.sub(/.*:/, ''),
+        :tooltip => uri.to_s, 
+        :arrowhead => :open, 
+        :arrowsize => 0.5,
+        :penwidth => 0.5
+      }
+      
+      edges_[@key] = graph_.add_edges(domainIndividualNode, rangeIndividualNode, options)
+      
+      return nodes_, edges_
+    end
+  end
+end