activerubic 0.8.0 → 0.8.1

data/lib/objectmanager/namespace.rb

@@ -0,0 +1,170 @@
+# Manages namespace abbreviations and expansions. Extends the ActiveRDF namespace by self.protocol, self.prefix and self.ancestors. Forked from ActiveRDF-1.6.6, patch offered upstream, but rejected.
+class Namespace
+  @@namespaces = Hash.new
+  @@inverted_namespaces = Hash.new
+  # occurrence of # or / (heuristical namespace delimitor)
+  @@delimitor = /#|\//
+
+  # registers a namespace prefix and its associated expansion (full URI)
+  # e.g. :rdf and 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+  def self.register(prefix, fullURI)
+    raise ActiveRdfError, 'prefix nor uri can be empty' if (prefix.to_s.empty? or fullURI.to_s.empty?)
+    raise ActiveRdfError, "namespace uri should end with # or /" unless /\/|#/ =~ fullURI.to_s[-1..-1]
+		$activerdflog.info "Namespace: registering #{fullURI} to #{prefix}"
+    @@namespaces[prefix.to_sym] = fullURI.to_s
+    @@inverted_namespaces[fullURI.to_s] = prefix.to_sym
+
+    # enable namespace lookups through FOAF::name
+    # if FOAF defined, add to it
+    if Object.const_defined?(prefix.to_s.upcase)
+      ns = Object.const_get(prefix.to_s.upcase)
+    else
+      # otherwise create a new module for it
+      ns = Module.new  
+      Object.const_set(prefix.to_s.upcase, ns)
+    end
+
+    # catch FOAF::name or all other lookups 
+    class << ns
+      def method_missing(method, *args)
+        Namespace.lookup(self.to_s.downcase.to_sym, method)
+      end
+
+      def const_missing(klass)
+        Namespace.lookup(self.to_s.downcase.to_sym, klass)
+      end
+
+      # make some builtin methods private because lookup doesn't work otherwise 
+      # on e.g. RDF::type and FOAF::name
+      [:type, :name, :id].each {|m| private(m) }
+    end
+
+    # return the namespace proxy object
+    ns
+  end
+
+  # returns a resource whose URI is formed by concatenation of prefix and localname
+  def self.lookup(prefix, localname)
+    full_resource = expand(prefix, localname)
+    RDFS::Resource.new(expand(prefix, localname))
+  end
+
+  # returns URI (string) formed by concatenation of prefix and localname
+  def self.expand(prefix, localname)
+    # do not die with nil.to_sym
+    if prefix
+      @@namespaces[prefix.to_sym].to_s + localname.to_s
+    else
+      return nil
+    end
+  end
+
+  # returns the protocol part of the URI
+  def self.protocol(resource)
+    # get string representation of resource uri
+    uri = case resource
+    when RDFS::Resource: resource.uri
+    else resource.to_s
+    end
+
+    ( /^.*:\/\//.match uri ).to_s  # do not return MatchData, but a String
+    #     uri.scan( /^.*:\/\// ).to_s # alternative method
+  end
+
+  # returns prefix (if known) for the non-local part of the URI,
+  # or nil if the prefix is not registered.
+  # finds the longest match in registered URIs, so the namespace can have
+  # several URIs that have the same beginning but vary later in the path
+  def self.prefix(resource)
+    # get string representation of resource uri
+    uri = case resource
+    when RDFS::Resource: resource.uri
+    # uri.to_s gives us the uri of the resource (if resource given)
+    else resource.to_s
+    end
+#     STDERR.puts resource
+
+    # get the protocol to a variable since it is used later
+    protocol = self.protocol( uri )
+
+    # strip the protocol and localname from the URI,
+    # so the resource_prefix can be scanned without them interfering
+    stripped_uri = uri.gsub( protocol, '' ).gsub( self.localname(uri), '' )
+
+    # scan the number of path elements in the procol-less uri
+    elements = stripped_uri.scan( @@delimitor ).size
+
+    # for each possible prefix path (number of elements) until match,
+    # check @@inverted_namespaces
+    # start with one, since it is the index count for match()
+    nominees = Array.new
+
+    # reverse the Range, as Ruby does not handle ( 3 .. 1 ).each properly
+    range = Array.new
+    ( 1 .. elements ).each { |index| range << index }
+    range.reverse.each do |index|
+      # allow the regexp to pass #{index} times before matching
+      # TODO: use @@delimitor, keep it DRY
+      nominees << stripped_uri.match( /([^#|\/]*(#|\/)){#{index}}/ ).to_s
+    end
+
+    # if nominee matches an entry in @@inverted_namespaces, return match
+    nominees.each do |partial_prefix|
+      possible_match = protocol + partial_prefix
+      # STDERR.puts "comparing #{possible_match}"
+      match = @@inverted_namespaces[ possible_match ]
+#       STDERR.puts match
+      return match if match
+      # else descend one level in the path..
+    end
+
+    # ..until hit rock bottom (no matching keys in @@inverted_namespaces)
+    return nil
+  end
+
+  # return the portion in the URI between the prefix and localname as string.
+  # this function returns an Array of Strings when there is something
+  # between matching prefix and the last delimitor, after which is the localname.
+  # TODO: return the OWL::Class(es) as [ RDFS::Resource(s) ]
+  def self.ancestors(resource)
+    # get string representation of resource uri
+    uri = case resource
+    when RDFS::Resource: resource.uri
+    # uri.to_s gives us the uri of the resource (if resource given)
+    else resource.to_s
+    end
+
+    prefix = self.expand(self.prefix(uri),nil)
+    localname = self.localname(uri)
+
+    # remove the prefix and localname
+    if prefix and localname
+      klasses = uri.gsub( prefix, '' ).gsub( localname, '' )
+      return klasses.split( @@delimitor )
+    else
+      return nil
+    end
+  end
+
+  # returns local-part of URI
+  def self.localname(resource)
+    # get string representation of resource uri
+    uri = case resource
+    when RDFS::Resource: resource.uri
+    else resource.to_s
+    end
+
+    delimiter = uri.rindex(/#|\//)
+    if delimiter.nil? or delimiter == uri.size-1
+      uri
+    else
+      uri[delimiter+1..-1]
+    end
+  end
+
+  # returns currently registered namespace abbreviations (e.g. :foaf, :rdf)
+  def self.abbreviations
+    @@namespaces.keys
+  end
+end
+

data/lib/objectmanager/owl/class.rb

@@ -0,0 +1,150 @@
+# Introduces OWL into the namespace.
+#
+# See also: RDFS
+module OWL
+  # Resembles a class in OWL context.
+  class OWL::Class < RDFS::Resource
+
+    # adding accessor to the class uri:
+    # the uri of the rdf resource being represented by this class
+    class << self
+      attr_accessor :class_uri
+    end
+
+    # uri of the resource (for instances of this class: rdf resources)
+    attr_reader :uri
+
+    # Creates a new OWL::Class.
+    #
+    # parameters:
+    #  1  resource ( RDFS::Resource or URI )
+    #  2  options ( Hash; )
+    def initialize( resource, options={} )
+      @@log.deep "Formulating new OWL::Class #{resource} from #{resource.class}"
+      @uri = case resource
+      when OWL::Class
+        @@log.warn "Redundant new OWL::Class, resource already was one."
+        resource.uri
+      when RDFS::Resource
+        resource.uri
+      when String
+        resource
+      else
+        raise ActiveRdfError, "Resource #{resource} (#{resource.class}) is improperly formulated"
+        return nil
+      end
+
+#       @data_stores = options[ :from ] || RUBIC_DATASTORES
+#       @predicates = Hash.new
+    end
+
+    # setting our own class uri to owl:class
+    # (has to be done after defining our OWL::Class.new
+    # because it cannot be found in Namespace.lookup otherwise)
+    self.class_uri = Namespace.lookup(:owl, :Class)
+
+    def self.uri; class_uri.uri; end
+    def self.==(other)
+      other.respond_to?(:uri) ? other.uri == self.uri : false
+    end
+
+    #####                        ######
+    ##### start of instance-level code
+    #####                        ######
+
+
+    ##############################################################
+    ## Tree model operations
+    ##############################################################
+
+    # find the child classes
+    def children
+      begin
+        # the class variable is set if this query has been executed already
+        if @children.nil? then
+          @children = ActiveRubic::Base.find( :children, :class => self )
+        end
+        return @children
+      rescue
+        return Array.new
+      end
+    end
+  
+    # find the descendant classes
+    def descendants
+      begin
+        # the class variable is set if this query has been executed already
+        if @descendants.nil? then
+          @descendants = ActiveRubic::Base.find( :descendants, :class => self )
+        end
+        return @descendants
+      rescue
+        return Array.new
+      end
+    end
+  
+    def instances
+      begin
+        # the class variable is set if this query has been executed already
+        if @instances.nil? then
+          @instances = ActiveRubic::Base.find( :instances_of, :class => self )
+        end
+        return @instances
+      rescue
+        return Array.new
+      end
+    end
+
+    ##############################################################
+
+    # returns the instances of this class that have latitude and longitude
+    def markers( options={} )
+      limit = options[ :limit ] || nil
+      begin
+        if @markers.nil? then
+          @markers = ActiveRubic::Base.find( :markers, :class => self, :limit => limit )
+
+            # sort alphabetically by label
+#             @markers = @markers.sort_by { |i| i.labelize }
+
+          @@log.debug "#{@markers.size} markers found"
+  
+        end
+        return @markers
+      rescue
+        @@log.error $!
+        return Array.new
+      end
+    end
+    alias :geopoints :markers
+
+    # Examines all instances of this class, breaks when first mappable resource is found, and returns true. If no mappable instances are found, returns false.
+    def is_mappable?
+      begin
+#         STDERR.puts "studying #{self}"
+        if @is_mappable.nil?
+          self.instances.each do |resource|
+#             STDERR.puts "examinining #{resource}"
+            if resource.is_mappable?
+#               STDERR.puts "yes"
+              @is_mappable = true
+              break;
+            else
+#               STDERR.puts "no"
+              @is_mappable = false
+              break;
+            end
+          end
+        end
+#         STDERR.puts "fine"
+        return @is_mappable
+      rescue
+        @@log.error $!
+        return false
+      end
+    end
+    alias :has_markers? :is_mappable?  # :nodoc:
+    alias :has_coordinates? :is_mappable?  # :nodoc:
+
+  end # OWL::Class
+end # module

data/lib/objectmanager/owl/object_property.rb

@@ -0,0 +1,89 @@
+module OWL
+  # Resembles a property in OWL context.
+  class OWL::ObjectProperty < RDFS::Resource
+
+    # adding accessor to the class uri:
+    # the uri of the rdf resource being represented by this class
+    class << self
+      attr_accessor :class_uri
+    end
+
+    # uri of the resource (for instances of this class: rdf resources)
+    attr_reader :uri
+
+    # Creates a new OWL::Class.
+    #
+    # parameters:
+    #  1  resource ( RDFS::Resource or URI )
+    #  2  options ( Hash; )
+    def initialize( resource, options={} )
+      @@log.deep "Formulating new OWL::ObjectProperty #{resource} from #{resource.class}"
+      @uri = case resource
+      when OWL::ObjectProperty
+        @@log.warn "Redundant new OWL::ObjectProperty, resource already was one."
+        resource.uri
+      when RDFS::Resource
+        resource.uri
+      when String
+        resource
+      else
+        raise ActiveRdfError, "Resource #{resource} (#{resource.class}) is improperly formulated"
+        return nil
+      end
+
+#       @data_stores = options[ :from ] || RUBIC_DATASTORES
+#       @predicates = Hash.new
+    end
+
+    # setting our own class uri to owl:ObjectProperty
+    # (has to be done after defining our OWL::ObjectProperty.new
+    # because it cannot be found in Namespace.lookup otherwise)
+    self.class_uri = Namespace.lookup(:owl, :ObjectProperty)
+
+    def self.uri; class_uri.uri; end
+    def self.==(other)
+      other.respond_to?(:uri) ? other.uri == self.uri : false
+    end
+
+    #####                        ######
+    ##### start of instance-level code
+    #####                        ######
+
+    # returns the inverse of the given bidirectional ObjectProperty
+    def inverse
+      if @inverse.nil?
+        # ActiveRubic always returns values in an Array, but a property
+        # can have only one inverse values.
+        @inverse = ActiveRubic::Base.find( :inverse, :property => self ).first
+      end
+      return @inverse
+    end
+    alias :inverse_of :inverse
+
+    # returns the resources that are a domain for the given ObjectProperty
+    def domain
+      begin
+        if @domain.nil?
+          @domain = ActiveRubic::Base.query(
+            Query.new.distinct( :domain ).where( :domain, self, :any ) )
+        end
+        return @domain
+      rescue
+        @@log.error $!
+      end
+    end
+
+    # returns the resources that are in the range of the given ObjectProperty
+    def range
+      begin
+        if @range.nil?
+          @range = ActiveRubic::Base.find( :within_range, :property => self )
+        end
+        return @range
+      rescue
+        @@log.error $!
+      end
+    end
+
+  end # class
+end # module

data/lib/objectmanager/owl/thing.rb

@@ -0,0 +1,78 @@
+# Introduces OWL into the namespace.
+#
+# See also: RDFS
+module OWL
+  # Resembles the ontology root.
+  class OWL::Thing < RDFS::Resource
+
+    # adding accessor to the class uri:
+    # the uri of the rdf resource being represented by this class
+    class << self
+      attr_accessor :class_uri
+    end
+
+    # uri of the resource (for instances of this class: rdf resources)
+    attr_reader :uri
+
+    # Creates a new OWL::Thing.
+    #
+    # parameters:
+    #  1  resource ( RDFS::Resource or URI String )
+    def initialize( resource, options={} )
+      @@log.deep "Formulating new Owl::Thing #{resource} from #{resource.class}"
+      @uri = case resource
+      when OWL::Thing
+        @@log.warn "Redundant new OWL::Thing, resource already was one."
+        resource.uri
+      when RDFS::Resource
+        resource.uri
+      when String
+        resource
+      else
+        raise ActiveRdfError, "Resource #{resource} (#{resource.class}) is improperly formulated"
+        return nil
+      end
+
+#       @data_stores = options[ :from ] || RUBIC_DATASTORES
+#       @predicates = Hash.new
+    end
+
+    # setting our own class uri to owl:class
+    # (has to be done after defining our OWL::Class.new
+    # because it cannot be found in Namespace.lookup otherwise)
+    self.class_uri = Namespace.lookup(:owl, :Thing)
+
+    def self.uri; class_uri.uri; end
+    def self.==(other)
+      other.respond_to?(:uri) ? other.uri == self.uri : false
+    end
+
+    #####                        ######
+    ##### start of instance-level code
+    #####                        ######
+
+    # return the localname as label
+    def label
+      @label = Namespace.localname( self.uri ).capitalize
+      return @label
+    end
+    alias :labelize :label
+  
+    # the roots of the ontology (only available from Jena)
+    def roots
+      begin
+        if @roots.nil? then
+          @roots = Array.new
+          ActiveRubic::Base.find( :roots, :ontology => self.uri ).each do |root|
+            @roots << OwlClass.new( root )
+          end
+        end
+        return @roots
+  
+      rescue
+        return Array.new
+      end
+    end
+  
+  end
+end