activerubic 0.8.0 → 0.8.1

data/lib/active_rubinstein/jena_query.rb

@@ -0,0 +1,175 @@
+module ActiveRubinstein
+  ## A DRb object to jRubinstein#JeanLuc::Picard
+  class JenaEndpoint < DRb::DRbObject
+
+    attr_reader :uri
+
+    # adds a JenaEndpoint to the server pool.
+    def initialize
+#       jdrb_servers.each do |uri|
+#         STDERR.puts " * jRubinstein client @ " + uri
+#         jrubinstein = Rubinstein::JenaEndpoint.new( DRbObject.new_with_uri( uri ) )
+#       end
+#       return nil
+      @uri = ['druby','//' + JDRB_SERVER, JDRB_PORT].join(':')
+      begin
+        @@log.rubinstein " * initializing JenaEndpoint: " + @uri
+        server = DRbObject.new_with_uri( @uri )
+        @@log.debug server.inspect
+        if server.ping then
+          @@log.debug " => reply from server: " + server.hello
+          return server
+        else
+          raise ConnectionFailedError, $!.message
+        end
+
+      rescue
+        raise ConnectionFailedError, $!.message
+      end
+    end
+  end
+
+  #############################################################################
+  # JenaQuery translates an ActiveRubic query to JeanLuc::Picard over the DRb via method_missing.
+  #
+  # execute accepts these actions:
+  # - :instances_of
+  #   :class => getInstances
+  # - :parents
+  #   the same method is used for both instances and classes, but the actual method in Java is different
+  #   :class || :subject
+  #      is_class? => getParents
+  #      is_subject? => getInstanceClass
+  # - :ancestors
+  #   :class => getAncestors
+  # - :children
+  #   :class => getChildren
+  # - :descendants
+  #   :class => getDescendants
+  # - :roots
+  #   :ontology => getRoot
+  # - :classes_within
+  #   :class, :radius => getClassesWithin
+  # - :inverse
+  #   :property => getInverse
+  # 
+  #############################################################################
+  class JenaQuery < ActiveRubinstein::Base
+
+    # allow to set query language
+    attr_accessor :language
+
+    # picks a JenaEndpoint from the server pool.
+    def initialize
+      server = $serverPool[ :jena ].first
+      unless server.ping
+        raise ConnectionFailedError, $!.message
+      else
+        @@jena = server
+        @@log.rubinstein "@@jena = #{server.inspect}"
+      end
+    end
+
+    class << self
+
+    public
+
+      # analyzes the query to find the correct method to execute
+      def execute( query, options )
+        if query.is_a? Symbol or query.is_a? RDFS::Resource
+          case query
+          when :instances_of
+            subject = options[ :class ]
+            if subject
+              # 2nd parameter sets the reasoner
+              self.getInstances( subject, false )
+            end
+          when :parents
+            # the same method is used for both instances and classes,
+            # but the actual method in Java is different
+            subject = options[ :subject ]
+            if subject.is_class? then
+              self.getParents( subject )
+            else
+              self.getInstanceClass( subject )
+            end
+          when :ancestors
+            subject = options[ :subject ]
+            if subject.is_class? then
+              self.getAncestors( subject )
+            elsif subject.is_a? RDFS::Resource then
+              ancestors = Array.new
+              subject.parents.each do |parent|
+                ancestors << parent
+                ancestors << self.getAncestors( parent )
+              end
+              return ancestors.flatten
+            end
+          when :children
+            subject = options[ :class ]
+            if subject
+              self.getChildren( subject )
+            end
+          when :descendants
+            subject = options[ :class ]
+            if subject
+              self.getDescendants( subject )
+            end
+          when :roots
+            ontology = options[ :ontology ]
+            if ontology
+              self.getRoot( ontology )
+            end
+          when :classes_within
+            subject = options[ :class ]
+            radius = options[ :radius ] || 0.2
+            if subject
+              # 2nd parameter sets the reasoner
+              self.getClassesWithin( subject, radius )
+            end
+          when :properties then
+            subject = options[ :subject ]
+            if subject
+              self.getProperties( subject )
+            end
+          when :inverse
+            property = options[ :property ]
+            if property
+              self.getInverse( property )
+            end
+
+          else # construct common SPARQL
+            sparql = ActiveRubinstein::SparqlFormulator.construct( query, options )
+            return self.query( sparql, options ) if sparql
+          end
+
+        elsif query.is_a? Query then
+          @@log.query query.to_sp
+          return self.query( query, options )
+        end
+      end
+
+      # returns the server object
+      def server
+        @@jena
+      end
+
+    private
+
+      # sends the request to Rubinstein's DRb server.
+      def method_missing(method, *args, &block) # :dodoc:
+        @@log.rubinstein "sending the request to DRb server, method #{method}"
+        begin
+          return @@jena.send( method, *args, &block )
+        rescue
+          raise ConnectionFailedError, $!.message
+        end
+      end
+
+      def do_log(*args)
+        super
+      end
+      
+    end
+  end
+end

data/lib/active_rubinstein/joseki_query.rb

@@ -0,0 +1,82 @@
+module ActiveRubinstein
+
+#############################################################################
+# Joseki backend
+#
+# Copyright (c) 2007 Savonia University of Applied Sciences
+#                    Mikael Lammentausta
+#
+#############################################################################
+
+  # A DRb object to jRubinstein#Joseki
+  class ActiveRubinstein::JosekiEndpoint < DRb::DRbObject
+
+    attr_reader :uri
+
+    # connects to the Rubinstein server and adds a server to the server pool.
+    def initialize
+
+#       drb_servers.each do |uri|
+#         STDERR.puts " * cRubinstein client @ " + uri
+#         rubinstein = Rubinstein::SparqlEndpoint.new( DRbObject.new_with_uri( uri ) )
+#       end
+
+      @uri = ['druby','//' + DRB_SERVER, DRB_PORT].join(':')
+      @@log.debug " * initializing SparqlEndpoint: " + @uri
+      server = DRbObject.new_with_uri( @uri )
+      begin
+        @@log.debug " => reply from server: " + server.hello
+        return server
+      rescue
+        @@log.error $!
+        return nil
+      end
+    end
+  end
+
+
+  # Picks a server from the server pool and opens up the interface for queries.
+  class ActiveRubinstein::JosekiQuery < ActiveRubinstein::Base
+    def initialize
+      server = $serverPool[ :joseki ].first
+      @@log.debug $serverPool[ :joseki ].inspect
+      if server.nil?
+        @@log.error $!.message
+      else
+        @@joseki = server
+        @@log.rubinstein "@@joseki = #{server.inspect}"
+      end
+    end
+
+    class << self
+
+    public
+
+      # analyzes the query to find the correct method to execute
+      def execute( query, options={} )
+        # construct common SPARQL
+        query = ActiveRubinstein::SparqlFormulator.construct( query, options )
+        results = self.query( query, options ) if query
+      end
+
+      # returns the server object
+      def server
+        @@joseki
+      end
+
+    private
+
+      # pretty much the most important method of all :)
+      # this method sends the request to Rubinstein's DRb server.
+      def method_missing(method, *args, &block)
+        @@log.rubinstein "sending the request to DRb server, method #{method}"
+        return @@joseki.send( method, *args, &block )
+      end
+
+      def do_log(*args)
+        super
+      end
+      
+    end
+  end
+end

data/lib/active_rubinstein/lucene_searcher.rb

@@ -0,0 +1,170 @@
+module ActiveRubinstein
+
+#############################################################################
+# Lucene backend queries for ActiveRubinstein
+#
+# NOTE: standard Lucene uses JenaEndPoint, geoLucene GeoLuceneEndpoint
+#
+# Copyright:: 2007 Savonia University of Applied Sciences
+# Author:: Mikael Lammentausta
+#
+#############################################################################
+
+  ## A DRb object to jRubinstein#JeanLuc::GeoLucene
+  class GeoLuceneEndpoint < DRb::DRbObject
+
+    attr_reader :uri
+
+    # connects to the Rubinstein server and adds a server to the server pool.
+    def initialize
+      @uri = ['druby','//' + GEOLUCENE_SERVER, GEOLUCENE_PORT].join(':')
+      begin
+        @@log.rubinstein " * initializing GeoLuceneEndpoint: " + @uri
+        server = DRbObject.new_with_uri( @uri )
+        @@log.debug server.inspect
+        if server.ping then
+          @@log.debug " => reply from server: " + server.hello
+          return server
+        else
+          @@log.error $!.message
+          return nil
+        end
+
+      rescue
+        @@log.error $!.message
+        return nil
+      end
+    end
+  end
+
+  # A DRb object to jRubinstein#JenaLuc::Lucene or JenaLuc::GeoLucene
+  class LuceneSearcher < ActiveRubinstein::Base
+
+    attr_accessor :language
+
+    # adds a Lucene engine to the server pool;
+    # the Lucene branch can be selected by the option
+    #   lucene_branch => :standard || :geolucene
+    #
+    # currently GeoLucene is not used, as it fails to parse fuzzy searches.
+    def initialize( lucene_branch = :standard )
+      case lucene_branch
+
+      when :standard
+        server = $serverPool[ :jena ].first
+        unless server.ping
+          @@log.error $!.message
+        else
+          @@lucene = server
+          @@log.rubinstein "@@lucene = #{server.inspect}"
+        end
+
+      when :geolucene
+        server = $serverPool[ :geolucene ].first
+        unless server.ping
+          @@log.error $!.message
+        else
+          @@geolucene = server
+          @@log.rubinstein "@@geolucene = #{server.inspect}"
+        end
+      end
+    end
+
+    class << self
+
+      public
+
+      # analyzes the query to find the correct method to execute. accepts queries of type Symbol, RDFS::Resource and String.
+      #
+      # Parameters:
+      # - 1 query (Symbol, RDFS::Resource or String)
+      # - 2 options (Hash; ...)
+      def execute( query, options )
+
+        @lucene = options[ :lucene_branch ] || :standard
+
+        if query.is_a? Symbol or query.is_a? RDFS::Resource
+          case query
+
+          # look for geographically nearby resources
+          when :nearby
+            lat = options[ :lat ]
+            long = options[ :long ]
+            radius = options[ :radius ] || 1000
+            resource = options[ :resource ]
+
+            if resource # quick hack
+              resource = RdfAbout.new( resource ) unless resource.is_a? RdfAbout
+              lat = resource.lat
+              long = resource.long
+            end
+
+            lat = lat.to_f unless lat.is_a? Float
+            long = long.to_f unless long.is_a? Float
+            radius = radius.to_i unless radius.is_a? Fixnum
+
+            if lat and long
+              return self.getNearbyTargets( lat, long, radius, options )
+            end
+          end
+
+        elsif query.is_a? String
+          options.update :indices => :full unless options.has_key? :indices
+          return self.search( query, options )
+
+        elsif query.is_a? Query
+          @@log.info "Lucene cannot handle SPARQL queries yet."
+          return nil
+
+        else
+          @@log.warn "Unfamiliar query (#{query}) to Lucene"
+          return nil
+        end
+      end
+
+#       def lucene_query( search_string, options={} )
+#         begin
+#           @@log.rubinstein "  => Querying Lucene, search string: #{search_string}"
+#           # NOTE: the query actually goes to Lucene on the Rubinstein server,
+#           # it's actually somewhat misleading that the variable is @@jena..
+#   #         return @@jena.searchText( search_string )
+#           return @@jena.search( search_string, options={} )
+#         rescue
+#           Array.new
+#         end
+#       end
+#       alias :query_from_lucene :lucene_query
+#       alias :searchText :lucene_query
+
+      # returns the server object
+      def server
+        if @@lucene
+          return @@lucene
+        elsif @@geolucene
+          return @@geolucene
+        end
+      end
+
+      # pretty much the most important method of all :)
+      # this method sends the request to Rubinstein's DRb server.
+      def method_missing(method, *args, &block)
+        @@log.rubinstein "sending the request to #{@@lucene}, method #{method}"
+
+        @lucene ||= :standard
+        case @lucene
+        when :standard
+          return @@lucene.send( method, *args, &block )
+        when :geolucene
+          return @@geolucene.send( method, *args, &block )
+        else
+          @@log.error "Unknown Lucene branch #{@lucene}"
+          return Array.new
+        end
+      end
+
+      def do_log(*args) # :nodoc:
+        super
+      end
+    end
+  end
+end

data/lib/active_rubinstein/sparql_formulator.rb

@@ -0,0 +1,133 @@
+module ActiveRubinstein
+  # constructs SPARQL from abstract ActiveRubic queries
+  class SparqlFormulator
+
+      # Parameters:
+      # - 1  action  (Symbol; :all, :images_of, :properties etc) -- see RDFS::Resource and the child objects for possible actions.
+      # - 2  options (Hash)
+      def self.construct( action, options={} )
+        @@log.rubinstein "Constructing SPARQL, options: #{options}"
+        # todo: insert limit into sparql
+        #             if limit then
+        # BUG: Jena doesn't process .limit in SPARQL
+        subject = options[ :subject ]
+        predicate = options[ :predicate ] || options[ :property ]
+        object = options[ :object ]
+        owlclass = options[ :class ]
+        @@log.debug "  => constructing Query to find #{action}"
+
+#         subject = RDFS::Resource.new( subject.uri ) if subject.is_a? RdfAbout
+#         predicate = RDFS::Resource.new( predicate.uri ) if predicate.is_a? Property or predicate.is_a? RdfAbout
+#         object = RDFS::Resource.new( object.uri ) if object.is_a? RdfAbout
+#         owlclass = RDFS::Resource.new( owlclass.uri ) if owlclass.is_a? OwlClass
+# 
+#         subject = RDFS::Resource.new( subject ) if subject.is_a? String
+#         predicate = RDFS::Resource.new( predicate ) if predicate.is_a? String
+#         object = RDFS::Resource.new( object ) if object.is_a? String
+#         owlclass = RDFS::Resource.new( owlclass ) if owlclass.is_a? String
+
+
+# ActiveRubic::Base.find :images_of, :subject => KUOPIO::kuopion_museo
+        if action.is_a? Symbol
+          case action
+          when :all then # BROKEN
+  #               query = Query.new.distinct( :resource ).where( :resource, :x, :y )
+            q = Query.new.distinct( :image ).where( :image, RDF::type, RDFS::Resource.new("media://image") )
+
+          when :images_of then
+            unless defined? subject
+              @@log.error " ! No subject defined for action #{action}, cannot formulate SPARQL"
+            else
+              @@log.rubinstein "Find images of #{subject}"
+              q = Query.new.select( :image ).
+                where( :image, RDF::subject, subject ).
+                where( :image, RDF::type, RDFS::Resource.new("media://image") )
+
+              # select by image rating
+              if options[ :rating ] # can be only 0 to 5
+                q.where( :image, IPTC::Rating, options[ :rating ] )
+              end
+            end
+
+          # not used!!!!
+          when :random_image_of
+            unless subject
+              @@log.error " ! No subject defined for query #{action}, cannot formulate SPARQL"
+            else
+              # FIXME: Randomizing is not handled here, it's hacked into RDFS::Resource
+              q = Query.new.select( :image ).
+                where( :image, RDF::subject, subject ).
+                where( :image, RDF::type, RDFS::Resource.new("media://image") )
+
+              # select by image rating
+              if options[ :rating ] # can be only 0 to 5
+                q.where( :image, IPTC::Rating, options[ :rating ] )
+              end
+            end
+
+          when :markers
+            unless owlclass
+              @@log.error " ! No class defined for query #{action}"
+            else
+              # Query for all instances that belong to this class and have GEO::lat and GEO::long defined
+              q = Query.new.select( :markers ). \
+                  where( :markers, RDF::type, owlclass ). \
+                  where( :markers, GEO::lat, :lat ).where( :markers, GEO::long, :long )
+
+            end
+
+            # property handling moved to jena_query, since the objects should
+            # be transformed to OWL::ObjectProperty and generic SPARQL returns
+            # only RDFS::Resource objects
+#           when :properties then
+#             unless defined? subject
+#               @@log.error " ! No subject defined for action #{action}, cannot formulate SPARQL"
+#             else
+#               @@log.deep "Querying for properties of #{subject}"
+#               q = Query.new.select( :property ) \
+#                 .where( :property, :any, OWL::ObjectProperty ) \
+#                 .where( RDFS::Resource.new( subject ), :property, :within_range )
+#             end
+
+          when :within_range then
+            unless subject
+              @@log.debug "Subject not defined, using Symbol"
+              subject = :subject
+#                 @@log.error " ! No subject defined for action #{action}, cannot formulate SPARQL"
+            end
+
+            if ! defined? predicate
+              @@log.error " ! No predicate defined for action #{action}, cannot formulate SPARQL"
+            else
+              @@log.deep "Querying for #{subject} #{predicate} ?"
+              q = Query.new.select( :within_range ) \
+                .where( subject, predicate, :within_range )
+#                   .where( RDFS::Resource.new( subject ), :property, :within_range )
+            end
+
+          end
+
+          # insert LIMIT into SPARQL
+          limit = options[ :limit ]
+          if !limit.nil? and !limit.is_a? Fixnum
+            @@log.warn "Limit must be a Fixnum, got #{limit} (#{limit.class})"
+          elsif !limit.nil?
+            @@log.rubinstein " => Limit: #{limit}"
+            q.limit( limit )
+          end
+  
+          return q
+
+        else # expect the action variable is a RDFS::Resource predicate
+          unless defined? subject
+            @@log.error " ! No subject defined to query #{action}, cannot formulate SPARQL"
+          else
+            @@log.deep "Constructing SPARQL #{subject} #{action} ?"
+            return Query.new.distinct( :object ). \
+            where( subject, action, :object )
+          end
+        end
+      end
+
+  end
+end