yowl 0.4.pre

data/lib/yowl/schema.rb

@@ -0,0 +1,519 @@
+require 'rexml/document'
+
+module YOWL
+
+  #
+  # Utility class providing access to information about the schema, e.g. its description, lists of classes, etc
+  #
+  class Schema
+
+    @@PredefinedNamespaces = Hash.new
+    @@PredefinedNamespaces["http://protege.stanford.edu/plugins/owl/dc/protege-dc.owl"] = "http://purl.org/dc/elements/1.1/"
+      
+    @@LastUsedOntologyNumber = 0
+    
+    attr_reader :options
+    attr_reader :repository
+    attr_reader :model
+    attr_reader :base
+    attr_reader :fileName
+    attr_reader :prefixes
+    attr_reader :name
+    attr_reader :introduction
+    attr_reader :datatype_properties
+    attr_reader :object_properties
+    attr_reader :classes
+    attr_reader :dir
+    attr_reader :ontology
+    
+    private
+    def initialize(repository_, model_, prefixes_, base_, fileName_)
+
+      @repository = repository_
+      @options = repository_.options
+      @model = model_
+      @prefixes = prefixes_
+      @base = base_
+      @fileName = fileName_
+      
+      if options.verbose
+        @prefixes.each_pair do |prefix, namespace|
+          puts "#{fileName_}: PREFIX #{prefix}: #{namespace}"
+        end
+      end
+
+      @classes = Hash.new
+      
+      init_classes(YOWL::Namespaces::OWL.Class)
+      init_classes(YOWL::Namespaces::RDFS.Class)
+      
+      @datatype_properties = init_properties(YOWL::Namespaces::OWL.DatatypeProperty)      
+      @object_properties = init_properties(YOWL::Namespaces::OWL.ObjectProperty)
+      
+      init_ontology()
+      init_name()
+
+      if not @options.quiet
+        puts "***********************************"
+        puts "* Instantiated Schema"
+        puts "* File: #{@fileName}"
+        puts "* URI : #{uri}"
+        puts "* Base: #{@base}"
+        puts "* Name: #{@name}"
+        puts "***********************************"
+      end
+    end
+    
+    public
+    def Schema.fromFile(ontology_file_name_, repository_)
+      
+      if repository_.options.verbose
+        puts "Read Schema #{ontology_file_name_}"
+      end
+      prefixes, base = Schema::read_prefixes(ontology_file_name_, repository_.options)
+      
+      format = RDF::Format.for(ontology_file_name_)
+      if format.nil?()
+        format = RDF::Format.for(:file_extension => "rdf")
+      end
+      begin
+        model = RDF::Graph.load(ontology_file_name_, { :format => format.to_sym, :prefixes => prefixes })
+      rescue Addressable::URI::InvalidURIError => e
+        warn "ERROR: Invalid URI Error while parsing #{ontology_file_name_}: #{e.to_s}"
+        return nil
+      rescue Exception => e
+        warn "ERROR: #{e.class.to_s} Error while parsing #{ontology_file_name_}: #{e}"
+        return nil
+      end
+      
+      return Schema.new(repository_, model, prefixes, base, ontology_file_name_)
+    end
+
+    #
+    # Read the prefixes from the XML file using REXML
+    #
+    private
+    def Schema.read_prefixes(ontology_file_name_, options_)
+      prefixes = {}
+      xmldoc = nil
+      base = nil
+      begin
+        xmldoc = REXML::Document.new(IO.read(ontology_file_name_))
+      rescue REXML::ParseException => bang
+        if not options_.quiet
+          warn "WARNING: Could not parse prefixes from #{ontology_file_name_} (only works for RDF/XML format)"
+        end
+        return prefixes
+      end
+      if xmldoc.doctype
+        xmldoc.doctype.entities.each() do |prefix, entity|
+          namespace = entity.normalized()
+          if namespace.include?('://')
+            prefixes[prefix.to_sym] = Schema.isValidNamespace?(namespace, prefix, ontology_file_name_)
+          end
+        end
+      end
+      if xmldoc.root
+        xmldoc.root.namespaces.each() do |prefix, namespace|
+          #
+          # Ignore the default namespace until we know what to do with it
+          #
+          if prefix != "xmlns"
+            #puts "@@@@@@@@@@@@ #{prefix} #{namespace}"
+            prefixes[prefix.to_sym] = Schema.isValidNamespace?(namespace, prefix, ontology_file_name_)
+          end
+        end
+        base = xmldoc.root.attribute('base')
+        if base
+          base = base.to_s
+        end
+      end
+      
+      return prefixes, base
+    end
+    
+    private
+    def Schema.isValidNamespace?(ns_, prefix_, fileName_)
+      #puts "prefix #{prefix_}: #{ns_}"
+      if ns_[-1..-1] != '#' and ns_[-1..-1] != '/'
+        raise "ERROR: Namespace for prefix #{prefix_} in @prefixes of #{fileName_} without trailing hash or slash: #{ns_}"
+      end
+      return ns_
+    end
+    
+    public
+    def uri
+      return @ontology ? @ontology.uri : @base
+      #return @ontology.nil? ? @base : @ontology.uri
+    end
+
+    private 
+    def testIsNamespace?(ns1_, ns2_)
+      ns1 = ns1_.chomp('#').chomp('/')
+      ns2 = ns2_.chomp('#').chomp('/')
+      #puts "testIsNamespace #{ns1} == #{ns2}"
+      return ns1 == ns2
+    end
+    
+    #
+    # Return the prefix and the corresponding namespace for the given namespace,
+    # where various forms of the given namespace are tried, like <ns>, <ns>/ and <ns>#.
+    # When no namespace could be found, return two nils.
+    public
+    def prefixForNamespace(namespace_)
+      _ns = @@PredefinedNamespaces.include?(namespace_) ? @@PredefinedNamespaces[namespace_] : namespace_
+      @prefixes.each() do |prefix, namespace|
+        if testIsNamespace?(namespace, _ns)
+          return prefix, namespace
+        end
+      end
+      return nil, nil
+    end
+    
+    private
+    def init_classes(type)
+      @model.query(RDF::Query::Pattern.new(nil, RDF.type, type)) do |statement|
+        Class.withUri(statement.subject, self)                    
+      end      
+    end
+    
+    private
+    def init_properties(type)
+      properties = Hash.new
+      @model.query(RDF::Query::Pattern.new(nil, RDF.type, type)) do |statement|
+        properties[statement.subject.to_s] = YOWL::Property.new(statement.subject, self)
+      end      
+      return properties      
+    end
+    
+    public
+    def properties()
+      return @datatype_properties.merge( @object_properties )     
+    end
+    
+    public
+    def list_properties()
+      return properties().sort { |x,y| x[1] <=> y[1] }          
+    end
+    
+    public
+    def list_datatype_properties()
+      return datatype_properties().sort { |x,y| x[1] <=> y[1] }
+    end
+    
+    public
+    def hasClasses?
+      return ! @classes.empty?
+    end 
+    
+    public
+    def list_object_properties()
+      return object_properties().sort { |x,y| x[1] <=> y[1] }
+    end    
+    
+    #Return sorted, nested array
+    public
+    def list_classes()
+      sorted = classes().sort { |x,y| x[1] <=> y[1] }
+      return sorted      
+    end
+    
+    public
+    #
+    # Return the class with the given URI as it is defined in this schema.
+    # Do not check the imported ontologies.
+    #
+    def classInSchemaWithURI(uri_)
+      return classes[uri_.to_s]
+    end
+    
+    public
+    #
+    # See YOWL::Individual::classWithURI(uri)
+    #
+    def classWithURI(uri)
+      if @ontology
+        return @ontology.classWithURI(uri)
+      end
+      klass = classInSchemaWithURI(uri)
+      if klass
+        return klass
+      end
+      return nil
+    end    
+    
+    public
+    def root_classes()
+      allClasses = classes().collect() do |uri,klass|
+        klass
+      end
+      return allClasses.to_set.delete_if() do |klass|
+        klass.hasSuperClassesInSchema?
+      end
+    end
+
+    private
+    def init_ontology()
+      ontology = @model.first_subject(RDF::Query::Pattern.new(nil, RDF.type, YOWL::Namespaces::OWL.Ontology))
+      if ontology
+        @ontology = Ontology.new(ontology, self)
+      else
+        raise "ERROR: Ontology not found in schema"
+      end
+    end
+    
+    private
+    def init_name()
+      @name = nil    
+      if @ontology
+        prefix, ns = prefixForNamespace(@ontology.uri())
+        if prefix
+          @name = prefix.to_s
+        end
+      end
+      if @name.nil? and @ontology and not @options.noVann
+        #
+        # Searching for vann:preferredNamespacePrefix to use as the name for the schema
+        #
+        prefix = @ontology.get_literal(YOWL::Namespaces::VANN.preferredNamespacePrefix)
+        if prefix
+          @name = prefix.to_s
+          if @options.verbose
+            puts "Found vann:preferredNamespacePrefix: #{prefix}"
+          end
+          #
+          # Add the found prefix to the collection of prefixes/namespaces
+          # (perhaps we should search for vann:preferredNamespaceUri to make it complete)
+          #
+          ns = @ontology.get_literal(YOWL::Namespaces::VANN.preferredNamespaceUri)
+          if ns
+            @prefixes[@name.to_sym] = Schema.isValidNamespace?(ns, prefix, @fileName)
+          else
+            @prefixes[@name.to_sym] = Schema.isValidNamespace?(@ontology.ns, prefix, @fileName)
+          end
+        else
+          warn "WARNING: vann:preferredNamespacePrefix not found in #{@fileName}"
+        end
+      end
+      if @name.nil? and @ontology
+        @name = File.basename(@fileName, File.extname(@fileName))
+        #@name = @ontology.escaped_short_name()
+      end
+      #puts "Schema #{@fileName} gets name #{@name} #{uri}"
+      if (@name.nil? or @name.empty?())
+        raise "ERROR: No name found for the schema"
+      end
+      if @options.verbose
+        puts "Schema has name #{name}"
+      end
+    end
+    
+    #
+    # Replace the namespace in the given uri with the corresponding prefix, if defined
+    #
+    public
+    def prefixedUri(uri)
+      if uri.nil?
+        raise "ERROR: Passed nil to Schema:prefixedUri()"
+      end
+      uri = uri.to_s()
+      if uri.empty?
+        raise "ERROR: Passed empty string to Schema:prefixedUri()"
+      end
+      uri = uri.gsub(",", "_")
+      @prefixes.each() do |prefix, namespace|
+        if uri == namespace
+          return prefix.to_s
+        end
+        if "#{uri}/" == namespace
+          return prefix.to_s
+        end
+        if "#{uri}#" == namespace
+          return prefix.to_s
+        end
+        if namespace[-1..-1] != '#' and namespace[-1..-1] != '/'
+          @prefixes.each_pair do |prefix, namespace|
+            puts "#{@fileName}: PREFIX #{prefix}: #{namespace}"
+          end
+          raise "ERROR: Namespace in @prefixes of #{@fileName} without trailing hash or slash: #{namespace}"
+        end
+        if uri.include?(namespace)
+          if @ontology and namespace == @ontology.ns
+            return uri.gsub(namespace, '')
+          end
+          return uri.gsub(namespace, "#{prefix.to_s}:")
+        end
+      end
+=begin
+      #
+      # First look up in the import hierarchy to see if we can find a prefix definition
+      # there that we can use...
+      #
+      if @ontology
+        @ontology.imports.each do |import|
+          if import.importedSchema and import.importedSchema != self
+            uri = import.importedSchema.prefixedUri(uri)
+            if uri
+              return uri
+            end
+          end
+        end
+      end
+      #
+      # If all else failed, lets scan all schema's for a usable prefix
+      #
+      @repository.schemas.values.each do |otherSchema|
+        if otherSchema != self
+          uri = otherSchema.prefixedUri(uri)
+          if uri
+            return uri
+          end
+        end
+      end
+=end
+      if @ontology
+        ontology_uri = @ontology.uri
+        if ontology_uri == uri
+          return uri
+        end
+        uri = uri.gsub(ontology_uri + '#', '')
+        uri = uri.gsub(ontology_uri + '/', '')
+      end
+      return uri
+    end
+
+    public
+    #
+    # Generate the main Class Diagram
+    #
+    def classDiagramAsSvg
+      if @options.verbose
+        puts "Generating SVG Class Diagram for #{name}"
+      end
+
+      g = GraphvizUtility.setDefaults(GraphViz.new(:G, :type => :digraph))
+      g[:rankdir] = "LR"
+      sg = g.subgraph() { |sg|
+        sg[:rank => "same"]
+      }
+      
+      nodes = Hash.new
+      edges = Hash.new
+      allClasses = classes.values.to_set
+      nonRootClasses = allClasses
+      rootClasses = root_classes.to_set
+      
+      #
+      # Add the GraphViz nodes for each class, but do the 
+      # root classes in a subgraph to keep them at top level
+      #
+      rootClasses.each() do |klass|
+        nonRootClasses.delete(klass)
+        nodes, edges = klass.addAsGraphvizNode(sg, nodes, edges)
+      end
+      nonRootClasses.each() do |klass|
+        nodes, edges = klass.addAsGraphvizNode(g, nodes, edges)
+      end
+      #
+      # Process edges to super classes, we can ignore the root classes here
+      #
+      nonRootClasses.each() do |klass|
+        if @options.verbose
+          puts "- Processing class #{klass.short_name}"
+        end
+        superClasses = klass.super_classes() 
+        superClasses.each() do |superClass|
+          superClassNode = nodes[superClass.uri]
+          if superClassNode
+            if @options.verbose
+              puts "  - Processing super class #{superClass.short_name}"
+            end
+            Class.newGraphVizEdge(g, nodes[klass.uri], superClassNode)
+          else
+            if @options.verbose
+              puts "  - Processing super class #{superClass.short_name}, not found"
+            end
+          end
+        end
+      end
+      #
+      # Process the other associations here
+      #
+      allClasses.each() do |domainClass|
+        domainClassNode = nodes[domainClass.uri]
+        if @options.verbose
+          puts "  - Processing associations of class #{domainClass.short_name}:"
+        end
+        domainClass.associations().each() do |association|
+          if @options.verbose
+            puts "    - Adding edge #{association.rangeClass.short_name}, #{association.label}"
+          end
+          nodes, edges = association.addAsGraphVizEdge(g, nodes, edges)
+        end
+      end
+      
+      return GraphvizUtility.embeddableSvg(g)
+    end
+    
+    public
+    def skosConceptSchemes
+      return individuals.values.find_all do |individual|
+        individual.isSkosConceptScheme?
+      end
+    end
+
+    public
+    def skosConceptsInScheme(conceptScheme)
+      return individuals.values.find_all do |individual|
+        individual.isSkosConceptInScheme?(conceptScheme)
+      end
+    end
+
+    public
+    def individualsNotSkosConcepts
+      return individuals.values.find_all do |individual|
+        not individual.isSkosConceptScheme?
+      end
+    end
+    
+    public
+    def individuals
+      if not defined?(@individuals)
+        init_individuals
+      end
+      return @individuals
+    end
+    
+    private
+    def init_individuals
+     
+      @individuals = Hash.new
+ 
+      if @options.verbose
+        puts "Searching for Individuals in schema #{@name}"
+      end
+      
+      #   FILTER (?type != owl:NamedIndividual && regex(str(?resource), "r29-.*"))
+      sparql = <<sparql
+        SELECT DISTINCT * WHERE { 
+          ?resource a owl:NamedIndividual .
+          ?resource a ?type .
+          FILTER (?type != owl:NamedIndividual)
+          }
+sparql
+      solutions = SPARQL.execute(sparql, @model, { :prefixes => @prefixes })
+      if @options.verbose
+        puts " - Found #{solutions.count} Individuals"
+      end
+ 
+      solutions.each do |solution|
+        Individual.withUri(solution[:resource], self)
+      end
+      if @options.verbose
+        puts "Initialized All Individuals in #{@name}"
+      end
+    end
+    
+  end  
+  
+end

data/lib/yowl/template/css/jquery.ui.all.css

@@ -0,0 +1,11 @@
+/*!
+ * jQuery UI CSS Framework 1.8.23
+ *
+ * Copyright 2012, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Theming
+ */
+@import "jquery.ui.base.css";
+@import "jquery.ui.theme.css";