yowl 0.4.pre

data/lib/yowl/ontology.rb

@@ -0,0 +1,197 @@
+module YOWL
+
+  class Ontology < YOWL::LabelledDocObject
+    
+    def initialize(resource, schema)
+      super(resource, schema)  
+    end
+    
+    def resourceNameHtml
+      return "#{@schema.name}.html"
+    end
+    
+    def title()
+      dctermsTitle = get_literal(YOWL::Namespaces::DCTERMS.title)
+      if dctermsTitle
+        return dctermsTitle
+      end 
+      dcTitle = get_literal(YOWL::Namespaces::DC.title)
+      if dcTitle
+        return dcTitle
+      end
+      return short_name() # We have to have a title
+    end
+    
+    def ns()
+      @ns ||= init_ns()
+      return @ns
+    end
+    
+    def init_ns()
+      _uri = @resource.to_s
+      @schema.prefixes.each do |prefix, namespace|
+        if _uri == namespace
+          return namespace
+        end
+        _tmp = "#{_uri}/"
+        if _tmp == namespace
+          return _tmp
+        end
+        _tmp = "#{_uri}#"
+        if "#{_uri}#" == namespace
+          return _tmp
+        end
+      end
+      if _uri[-1..1] == '/' or _uri[-1..1] == '#'
+        return _uri
+      end
+      #
+      # Basically make up a namespace... Don't know if this is such a good plan..
+      #
+      return "#{_uri}#"
+    end
+    
+    def short_name()
+      return @schema.name
+    end
+    
+    def comment()
+      dctermsAbstract = get_literal(YOWL::Namespaces::DCTERMS.abstract)
+      if dctermsAbstract
+        return dctermsAbstract
+      end
+      return super
+    end
+    
+    def definition()
+      return get_literal(YOWL::Namespaces::SKOS.definition)
+    end
+
+    def created()
+      dctermsCreated = get_literal(YOWL::Namespaces::DCTERMS.created)
+      if dctermsCreated
+        return dctermsCreated
+      end
+      return get_literal(YOWL::Namespaces::DC.date)
+    end
+
+    def modified()
+      return get_literal(YOWL::Namespaces::DCTERMS.modified)
+    end
+    
+    def rights()
+      return get_literal(YOWL::Namespaces::DC.rights)
+    end
+    
+    public
+    def authors
+      @authors ||= init_authors
+    end
+    
+    private
+    def init_authors()      
+      authors = []
+      #
+      # First find the Authors by searching for foaf:maker
+      #
+      @schema.model.query( 
+        RDF::Query::Pattern.new(@resource, YOWL::Namespaces::FOAF.maker)
+      ) do |statement|
+        uri = statement.object
+        if (uri and uri.uri?)
+          authors << Person.new(uri, @schema)
+        end
+      end
+      #
+      # Also scan for dc:creator and dc:contributor
+      #         
+      @schema.model.query( 
+        RDF::Query::Pattern.new(@resource, YOWL::Namespaces::DC.creator)
+      ) do |statement|
+        person = Person.new(RDF::URI.new("#{ns}#{statement.object.to_s}"), @schema)
+        person.setName(statement.object)
+        authors << person
+      end         
+      @schema.model.query( 
+        RDF::Query::Pattern.new(@resource, YOWL::Namespaces::DC.contributor)
+      ) do |statement|
+        person = Person.new(RDF::URI.new("#{ns}#{statement.object.to_s}"), @schema)
+        person.setName(statement.object)
+        authors << person
+      end 
+      return authors        
+    end
+    
+    public
+    def hasAuthors?
+      return ! authors.empty?
+    end
+    
+    def numberOfClasses()
+      return @schema.classes.size()
+    end
+    
+    def numberOfProperties()
+      return @schema.properties.size()
+    end
+    
+    def numberOfIndividuals()
+      return @schema.individuals.size()
+    end
+    
+    public
+    def imports
+      @imports ||= init_imports
+    end
+    
+    private
+    def init_imports
+      imports = {}
+      @schema.model.query( 
+        RDF::Query::Pattern.new(@resource, YOWL::Namespaces::OWL.imports)
+      ) do |statement|
+        importUri = statement.object.to_s
+        if importUri != uri
+          imports[importUri] = Import.new(statement.object, @schema)
+        end
+      end
+      return imports.values
+    end
+    
+    public
+    def see_alsos
+      @see_alsos ||= init_see_alsos
+    end
+    
+    private
+    def init_see_alsos()
+       links = []
+       @schema.model.query(
+         RDF::Query::Pattern.new(@resource, YOWL::Namespaces::RDFS.seeAlso)
+       ) do |statement|
+         links << statement.object.to_s
+       end       
+       return links
+    end
+    
+    public
+    #
+    # See YOWL::Individual::classWithURI(uri)
+    #
+    def classWithURI(uri_)
+      klass = @schema.classInSchemaWithURI(uri_)
+      if klass
+        return klass
+      end
+      imports.each do |import|
+        klass = import.classWithURI(uri_)
+        if klass
+          return klass
+        end
+      end
+      return nil
+    end
+    
+  end
+
+end

data/lib/yowl/options.rb

@@ -0,0 +1,116 @@
+module YOWL
+  #
+  # Utility class representing all specified command line options
+  #
+  class Options
+    
+    attr_accessor :ontology_file_names
+    attr_accessor :output_dir
+    attr_accessor :template_dirs
+    attr_accessor :noVann
+    
+    attr_reader :templates
+    
+    attr_accessor :verbose
+    attr_accessor :quiet
+
+    
+    def initialize()
+      @verbose = false
+      @quiet = false
+      @ontology_file_names = []
+      @output_dir = Dir.pwd()
+      @template_dirs = []
+      @templates = Hash.new
+      @noVann = false
+    end
+    
+    def validate()
+      if not @quiet
+        puts "Output will be generated in this directory: #{output_dir.to_s}"
+      end
+      if ! validate_ontology_file_names()
+        return false
+      end
+      if ! validate_template_dirs()
+        return false
+      end
+      if ! validate_templates()
+        return false
+      end
+      return true
+    end
+    
+    private
+    def validate_ontology_file_names
+      if @ontology_file_names.empty?
+        return false
+      end
+      @ontology_file_names.each() do |filename|
+        if ! File.exists?(filename)
+          warn "File does not exist: " + filename
+          return false
+        end
+        if not @quiet
+          puts "Will process input file: #{filename}"
+        end
+      end
+      return true
+    end
+    
+    private
+    def validate_template_dirs
+      @template_dirs << File.join(ontology_dir(), "yowl/template")
+      @template_dirs << File.join(File.dirname(__FILE__), "template")
+      @template_dirs = @template_dirs.find_all do |dir|
+        Dir[dir]
+      end
+      return ! @template_dirs.empty?()
+    end
+    
+    #
+    # TODO: Either we support one template per ontology or
+    # we support one template per input directory. That would
+    # then be the only way to specify input ontologies: by directory.
+    #
+    private
+    def ontology_dir()
+      return File.dirname(@ontology_file_names[0])
+    end
+    
+    private
+    def load_template(templateName_, required_ = true)
+      @template_dirs.each do |template_dir|
+        templateFileName = File.join(template_dir, "#{templateName_}.erb")
+        if verbose()
+          puts "Checking template #{templateFileName}"
+        end
+        if File.exists?(templateFileName)
+          File.open(templateFileName) do |file|
+            @templates[templateName_] = ERB.new(file.read)
+          end
+          if verbose()
+            puts "Loaded template #{templateFileName}"
+          end
+          return
+        end
+      end
+      if required_
+        raise "ERROR: #{templateName_} could not be found"
+      end
+    end
+    
+    private
+    def validate_templates()
+      
+      load_template('index');
+      #load_template('overview');
+      load_template('introduction', false);
+      load_template('import-diagram');
+      load_template('ontology');
+      
+      return true
+    end
+    
+  end # End of class Options
+end # End of module YOWL

data/lib/yowl/optionsparser.rb

@@ -0,0 +1,75 @@
+module YOWL
+  
+  class OptionsParser
+  
+    def self.parse(args_)
+      
+      options = Options.new
+  
+      opts = OptionParser.new do |opts|
+        #
+        # Set a banner, displayed at the top of the help screen.
+        #
+        opts.banner = "Usage: YOWL [<options>]"
+  
+        opts.separator ""
+        opts.separator "Specific options:"
+  
+        opts.on('-i', '--ontology FILES', String, 'Read input FILES') do |ontology|
+          options.ontology_file_names << ontology
+          if args_.size > 0
+            for index in 0..(args_.size - 1)
+              arg = args_[index]
+              if arg[0,1] == '-'
+                break
+              end
+              options.ontology_file_names << arg
+            end
+          end
+        end
+   
+        opts.on('-o', '--output DIR', 'Write HTML output to DIR') do |dir|
+          options.output_dir = dir
+        end
+
+        opts.on('-t', '--template DIR', 'Use ERB templates in DIR') do |dir|
+          options.template_dir = dir
+        end
+        
+        opts.on('--no-vann', 'Skip looking for vann:preferedNamespacePrefix') do |value|
+          options.noVann = true
+        end
+
+        opts.separator ""
+        opts.separator "Common options:"
+  
+        opts.on_tail("-?", "-h", "--help", "Show this message") do
+          puts opts
+          return nil
+        end
+  
+        opts.on_tail("-V", "--version", "Show version") do
+          puts OptionParser::Version.join('.')
+          exit
+        end
+
+        opts.on_tail("-v", "--verbose", "Show verbose logging") do
+          options.verbose = true
+        end
+
+        opts.on_tail("-q", "--quiet", "Suppress most logging") do
+          options.quiet = true
+        end
+        
+      end
+  
+      opts.parse!(args_)
+      
+      if ! options.validate()
+        puts opts
+        return nil
+      end
+      return options
+    end  # parse()
+  end  # class OptionParser
+end

data/lib/yowl/person.rb

@@ -0,0 +1,26 @@
+module YOWL
+  
+  class Person < YOWL::LabelledDocObject
+    
+    def initialize(resource, schema)
+      super(resource, schema)
+      @name = nil
+    end
+     
+    def setName(name_)
+      @name = name_
+    end
+     
+    def name()
+      name = get_literal(YOWL::Namespaces::FOAF.name)
+      if name.nil? or name.empty?
+        name = short_name()
+      end
+      return name
+    end
+     
+    def <=>(other)
+      return name() <=> other.name()
+    end
+  end
+end

data/lib/yowl/property.rb

@@ -0,0 +1,190 @@
+require 'yowl'
+
+module YOWL
+  
+  class Property < YOWL::LabelledDocObject
+    
+    def initialize(resource, schema)
+      super(resource, schema)
+    end
+    
+    def see_alsos()
+       links = []
+       @schema.model.query(
+         RDF::Query::Pattern.new(@resource, YOWL::Namespaces::RDFS.seeAlso)
+       ) do |statement|
+         links << statement.object.to_s
+       end       
+       return links
+    end
+        
+    def sub_property_of()
+      parent = @schema.model.first_value(
+        RDF::Query::Pattern.new(@resource, YOWL::Namespaces::RDFS.subPropertyOf)
+      )
+      if parent
+        uri = parent.to_s
+        if @schema.properties[uri]
+          return @schema.properties[uri]
+        else
+          return uri
+        end
+      end
+      return nil
+    end
+        
+    def range()
+      ranges = []
+      @schema.model.query(
+        RDF::Query::Pattern.new(@resource, YOWL::Namespaces::RDFS.range)
+      ) do |statement|
+        ranges << statement.object
+      end  
+      classes = []
+      ranges.each do |o|
+        if o.resource?
+          uri = o.to_s        
+          if @schema.classes[uri]
+            classes << @schema.classes[uri]
+          else
+            classes << uri
+          end
+        end
+      end
+      return classes
+    end
+
+    def domain()
+      domains = []
+      @schema.model.query(
+        RDF::Query::Pattern.new(@resource, YOWL::Namespaces::RDFS.domain)
+      ) do |statement|
+        domains << statement.object
+      end  
+      classes = []
+      domains.each do |o|
+        if o.resource?
+          uri = o.to_s         
+          if @schema.classes[uri]
+            classes << @schema.classes[uri]
+          else
+            classes << uri
+          end
+        end
+        #TODO union
+      end
+      return classes
+    end
+    
+    def sub_properties()
+      list = []
+      @schema.model.query(
+        RDF::Query::Pattern.new(nil, YOWL::Namespaces::RDFS.subPropertyOf, @resource)
+      ) do |statement|
+        list << YOWL::Property.new(statement.subject, @schema)
+      end
+      return list
+    end           
+
+    public
+    #
+    # Add the current class 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_)
+      name = short_name
+      if @schema.options.verbose
+        puts "- Processing property #{name}"
+      end
+      #
+      # No need to add a node twice
+      #
+      if nodes_.has_key? uri
+        return nodes_, edges_
+      end
+      node = graph_.add_nodes(escaped_uri)
+      node.URL = "#prop_#{short_name}"
+      
+      if name.include?(':')
+        prefix = name.sub(/:\s*(.*)/, "")
+        name = name.sub(/(.*)\s*:/, "")
+        #
+        # Can't get HTML labels to work
+        #
+        #node.label = "<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\"><TR><TD>#{name}</TD></TR><TR><TD><I>(#{prefix})</I></TD></TR></TABLE>"
+        node.label = "#{name}\n(#{prefix})"
+      else
+        node.label = name
+      end 
+      if hasComment?
+        node.tooltip = comment
+      end
+      nodes_[uri] = node
+      return nodes_, edges_
+    end
+    
+    public
+    #
+    # Generate a diagram for each Property, the "per property diagram"
+    #
+    def perPropertyDiagramAsSvg
+      #if @schema.options.verbose
+      #  puts "Generating SVG Per Property Diagram for #{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)
+      
+      #
+      # Do the "outbound" associations first
+      #
+      #associations.each do |association|
+      #  nodes, edges = association.rangeClass.addAsGraphvizNode(g, nodes, edges)
+      #  nodes, edges = association.addAsGraphVizEdge(g, nodes, edges)
+      #end
+      
+      #
+      # Then do the "inbound" associations
+      #
+      #@schema.classes.values.to_set.each do |klass|
+      #  klass.associations.each do |association|
+      #    if self == association.rangeClass
+      #      nodes, edges = association.rangeClass.addAsGraphvizNode(g, nodes, edges)
+      #      nodes, edges = association.addAsGraphVizEdge(g, nodes, edges)
+      #    end
+      #  end
+      #end
+      
+      return GraphvizUtility.embeddableSvg(g)
+    end
+    
+    #
+    # Create the GraphVis Edge for all "is a" (rdf:type) associations from a node
+    # (representing a Class) to another node (always representing a Property)
+    #
+    def Property.newGraphVizEdge(graph_, domainNode_, rangeNode_, constraint_ = true)
+      options = {
+        :arrowhead => "empty", 
+        :dir => "back",
+        :label => "is a", 
+        :arrowsize => 0.5,
+        :penwidth => 0.5,
+        :constraint => constraint_
+      }
+      if not constraint_
+        options[:style] = :dashed
+      end
+      return graph_.add_edges(
+        rangeNode_,
+        domainNode_,
+        options
+      )
+    end
+ 
+  end
+end

data/lib/yowl/repository.rb

@@ -0,0 +1,100 @@
+module YOWL
+  
+  class Repository
+    
+    attr_reader :schemas
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+      
+      init_schemas()
+    end
+    
+    private
+    def init_schemas()
+      @schemas = {}
+        
+      @options.ontology_file_names.each() do | ontology_file_name |
+        if options.verbose
+          puts "Parsing #{ontology_file_name}"
+        end
+        schema = Schema.fromFile(ontology_file_name, self)
+        if schema
+          @schemas[schema.uri] = schema
+          #puts "Registered schema with URI #{schema.uri}"
+        end
+      end
+    end  
+    
+    public
+    def ontologies()
+      ontologies = @schemas.values.collect() { |schema|
+        schema.ontology
+      }
+      return ontologies.sort { |x,y| x.short_name <=> y.short_name }
+    end
+ 
+    public
+    def getSchemaForImport(import_)
+      begin
+        return @schemas[import_.uri]
+      rescue => exception
+        puts exception.backtrace
+      end
+    end
+       
+    public
+    def knowsImport(import_)
+      return ! getSchemaForImport(import_).nil?
+    end
+    
+    public
+    def getSchemaNameForImport(import_)
+      schema = getSchemaForImport(import_)
+      return schema.nil? ? '' : schema.name
+    end
+    
+    public
+    def ontologiesAsSvg
+      if @options.verbose
+        puts "Generating SVG for Ontology Import Diagram"
+      end
+
+      g = GraphvizUtility.setDefaults(GraphViz.new(:G, :type => :digraph))
+        
+      nodes = {}
+      ontologies.each() do |ontology|
+        nodeID = ontology.escaped_uri
+        node = g.add_nodes(nodeID)
+        node.URL = ontology.resourceNameHtml
+        node.label = ontology.short_name
+        node.tooltip = ontology.commentOrLabel
+        nodes[nodeID] = node
+      end
+     
+      ontologies.each() do |ontology|
+        if @options.verbose
+          puts "- Processing ontology #{ontology.escaped_uri}"
+        end
+        ontology.imports.each() do |import|
+          importNode = nodes[import.name]
+          if importNode
+            if @options.verbose
+              puts "  - Processing import #{import.name}"
+            end
+            g.add_edges(nodes[ontology.short_name], importNode)
+          else
+            if @options.verbose
+              puts "  - Processing import #{import.name}, not found"
+            end
+          end
+        end
+      end
+
+      #puts g.to_dot()
+      return GraphvizUtility.embeddableSvg(g)
+    end
+    
+  end
+end