activerubic 0.8.0 → 0.8.1

data/lib/active_rubic/cacher.rb

@@ -0,0 +1,76 @@
+module ActiveRubic
+  class Cacher < MysqlCache::Base # :nodoc:
+    def version
+      MysqlCache::Base.version
+    end
+    def create
+      MysqlCache::Base.create_db_index
+    end
+    def set_options( options={} )
+      if options[ :use_rubic ]
+        MysqlCache::Base.use_rubic options[ :use_rubic ]
+      end
+    end
+
+    class << self
+
+      def read( query, options={} )
+
+        case query
+        when :all
+
+        db_result = @@rails_db.connection.execute("SELECT * FROM #{table}s")
+
+        results = Array.new
+        db_result.each_hash do |h|
+          uri = h[ 'uri' ]
+          results << RDFS::Resource.new( uri ) if uri
+        end
+
+        when RDFS::label
+
+          return [ "my label from mysql" ]
+
+        when :images
+
+          @@rails_db.connection.execute("SELECT i.full, i.preview, i.thumb, i.original, i.license, i.photographer, i.date, l.fi AS label_fi, l.en AS label_en, d.fi AS description_fi, d.en AS description_en, g.lat, g.lon FROM images AS i LEFT JOIN (labels AS l, descriptions AS d, geopoints AS g) ON (i.label=l.id AND i.description=d.id AND i.geopoint=g.id), (SELECT id, uri FROM rdf_resources) AS rdf_r, (SELECT image_id, rdf_resource_id FROM image_rdf_resource) AS i_rdf_r WHERE rdf_r.uri = 'http://testi/uri3' AND i_rdf_r.image_id = i.id AND i_rdf_r.rdf_resource_id = rdf_r.id;")
+
+          return [ "my images from mysql" ]
+
+        when :random_image
+
+          @@rails_db.connection.execute("SELECT i.full, i.preview, i.thumb, i.original, i.license, i.photographer, i.date, l.fi AS label_fi, l.en AS label_en, d.fi AS description_fi, d.en AS description_en, g.lat, g.lon FROM images AS i LEFT JOIN (labels AS l, descriptions AS d, geopoints AS g) ON (i.label=l.id AND i.description=d.id AND i.geopoint=g.id), (SELECT id, uri FROM rdf_resources) AS rdf_r, (SELECT image_id, rdf_resource_id FROM image_rdf_resource) AS i_rdf_r WHERE rdf_r.uri = 'http://testi/uri3' AND i_rdf_r.image_id = i.id AND i_rdf_r.rdf_resource_id = rdf_r.id ORDER BY RAND() LIMIT 1;")
+
+        when :properties
+
+          @@rails_db.connection.execute("p.uri, l.fi AS label_fi, l.en AS label_en FROM property AS p LEFT JOIN (labels AS l) ON (p.label=l.id) WHERE p.uri = 'http://testi/property';");
+
+          return [ "my properties from mysql" ]
+
+        when :parents
+
+          @@rails_db.connection.execute("SELECT sc.uri FROM rdf_resources AS sc, (SELECT id, uri FROM rdf_resources) as rdf_r, (SELECT * FROM rdf_resource_superclass_rdf_resource) AS schelp WHERE rdf_r.uri = 'http://testi/uri2' AND rdf_r.id = schelp.rdf_resource_id AND sc.id = schelp.superclass_rdf_resource_id")
+
+        when :instances_of
+
+          @@rails_db.connection.execute("SELECT inst.uri FROM rdf_resources AS inst, (SELECT id, uri FROM rdf_resources) as rdf_r, (SELECT * FROM rdf_resource_instance_rdf_resource) AS insthelp WHERE rdf_r.uri = 'http://testi/uri2' AND rdf_r.id = insthelp.rdf_resource_id AND inst.id = insthelp.instance_rdf_resource_id;")
+
+        when :range
+
+          @@rails_db.connection.execute("SELECT rdf_r.uri FROM rdf_resources AS rdf_r, (SELECT id, uri FROM property) as p, (SELECT * FROM rdf_resource_range) AS rangehelp WHERE p.uri = 'http://testi/property' AND rdf_r.id = rangehelp.rdf_resource_id AND p.id = rangehelp.property_id;")
+
+        when :domain
+
+          @@rails_db.connection.execute("SELECT rdf_r.uri FROM rdf_resources AS rdf_r, (SELECT id, uri FROM property) as p, (SELECT * FROM rdf_resource_domain) AS domainhelp WHERE p.uri = 'http://testi/property' AND rdf_r.id = domainhelp.rdf_resource_id AND p.id = domainhelp.property_id;")
+
+        end
+
+      end
+    end
+  end
+end
+
+
+
+
+

data/lib/active_rubinstein/base.rb

@@ -0,0 +1,226 @@
+# require 'yaml'
+require 'drb/drb'
+
+#############################################################################
+# ActiveRubinstein provides connection to Rubinstein, a DRb server with libraries written in native C Ruby, JRuby and Java. The CRuby backend provides access to SPARQL data stores with the ActiveRDF_sparql adapter whereas the JRuby part uses the JRuby for direct exchange of data via the CombinedJenaLuc JAR with Jena and Lucene.
+#
+# Copyright:: Copyright (c) 2007 Savonia University of Applied Sciences
+# Authors:: Mikael Lammentausta, Lauri Miettinen
+#
+# == Rubinstein backend
+# Copyright:: Copyright (c) 2007 Savonia University of Applied Sciences
+# Authors:: Mikael Lammentausta, Pasi Tiirikainen
+#
+# == CombinedJenaLuc JAR
+# Copyright:: Copyright (c) 2007 Savonia University of Applied Sciences
+# Author:: Pasi Tiirikainen
+#
+#############################################################################
+module ActiveRubinstein
+  class ActiveRubinsteinError < StandardError #:nodoc:
+  end
+  class AdapterNotSpecifiedError < ActiveRubinsteinError # :nodoc:
+  end
+  class AdapterNotFoundError < ActiveRubinsteinError # :nodoc:
+  end
+  class ConnectionNotEstablishedError < ActiveRubinsteinError #:nodoc:
+  end
+  class ConnectionFailedError < ActiveRubinsteinError #:nodoc:
+  end
+  class EmptyServerPoolError < ActiveRubinsteinError #:nodoc:
+  end
+  class RubinsteinNotFoundError < ActiveRubinsteinError #:nodoc:
+  end
+
+  # The serverpool is initialized here. The actual query methods are in these classes:
+  # - ActiveRubinstein::JenaQuery
+  # - ActiveRubinstein::LuceneSearcher
+  # - ActiveRubinstein::JosekiQuery
+  #
+  # The SPARQL is created by ActiveRubinstein::SparqlFormulator
+  #
+  class Base
+    # the default language for xml:lang matches
+    @@language = 'fi'
+
+    ### load submodules
+    RUBIC_DATASTORES.to_a.each do |engine|
+      case engine
+      when :mysql
+        @@log.rubic " => loading ActiveRecord"
+        require 'active_record'
+        @@log.rubic " => loading MysqlCache"
+        require RUBINSTEIN_HOME + '/lib/mysql_cache'
+        require RUBIC_HOME + '/active_rubic/cacher'
+
+        ### adds an accessor RailsDB when working outside of Rails
+        unless defined? RAILS_ROOT
+          require RUBINSTEIN_HOME + '/lib/rails_database'
+        end
+
+      when :jena
+        require RUBIC_HOME + '/active_rubinstein/sparql_formulator'
+        require RUBIC_HOME + '/active_rubinstein/jena_query'
+
+      when :joseki
+        # NOTE!! might be broken, hasn't been tested since 0.70 changes
+        require RUBIC_HOME + '/active_rubinstein/sparql_formulator'
+        require RUBIC_HOME + '/active_rubinstein/joseki_query'
+
+      when :lucene
+        require RUBIC_HOME + '/active_rubinstein/lucene_searcher'
+
+      end
+    end
+
+    # creates the server pool and starts the DRb client
+    def initialize
+      self.shuffle #unless defined? $serverPool
+      self.roll
+
+      unless $serverPool.any? then
+        raise EmptyServerPoolError, "No servers in the pool"
+
+      else # pick a server from the pool
+        RUBIC_DATASTORES.to_a.each do |adapter|
+          begin
+            # instantiate the server for the class
+            case adapter
+            when :jena
+              ActiveRubinstein::JenaQuery.new
+
+            when :joseki
+              ActiveRubinstein::JosekiQuery.new
+
+            when :lucene
+              ActiveRubinstein::LuceneSearcher.new
+
+            when :geolucene
+              ActiveRubinstein::LuceneSearcher.new( :geolucene )
+
+            else
+              raise AdapterNotFoundError, adapter
+            end
+          rescue
+            raise ConnectionNotEstablishedError, $!
+          end
+        end
+      end
+    end
+
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+    # starts the DRb client
+    def roll
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+      # the daemon also includes this class, so do not attemp to start
+      # the DRb client then.
+      if @@in_daemon_mode then
+        # TODO: check first if any of the servers are online and continue
+        # pinging for..ever?
+        @@log.rubinstein " * starting the DRb client"
+        DRb.start_service
+      end
+    end
+
+      ### #####  ###### #### #### ######     ###### ##### #   #####
+
+    ### ##### ####### ######### ################# ###############
+
+    # initializes the server pool
+    def shuffle
+
+    ################ ############################## ###########   
+
+                ####### #####         ##  #  ######### #### # ####   
+
+      unless RUBIC_DATASTORES.any? then
+        raise AdapterNotSpecifiedError, "No adapters specified"
+
+      else
+        $serverPool = {} unless defined? $serverPool
+
+        RUBIC_DATASTORES.to_a.each do |adapter|
+          begin
+            case adapter
+            when :jena
+              server = JenaEndpoint.new
+              if server.ping
+                $serverPool.update :jena => [ server ]
+                @@log.info " => added #{server.inspect} to pool"
+              end
+
+            when :joseki
+              server = JosekiEndpoint.new
+              if server.ping
+                $serverPool.update :joseki => [ server ]
+                @@log.info " => added #{server.inspect} to pool"
+              end
+
+            when :geolucene
+              server = GeoLuceneEndpoint.new
+              if server.ping
+                $serverPool.update :geolucene => [ server ]
+                @@log.info " => added #{server.inspect} to pool"
+              end
+            end
+          rescue
+            raise ConnectionFailedError, $!.message
+          end
+        end
+      end
+    end
+
+
+    class << self # Class methods
+
+    public
+
+      # propagates the xml:lang preference to all submodules
+      def set_language( lang )
+        @@language = lang
+        ActiveRubinstein::JenaQuery.language = lang
+      end
+
+    private
+
+    protected
+
+      def do_log( results ) # :nodoc:
+        @@log.boulderdash results.inspect
+        results.to_a! unless results.is_a? Array
+        if results.size < 3
+          @@log.rubinstein "  => #{results.size} results: #{results}"
+        else
+          @@log.rubinstein "  => #{results.size} results"
+        end
+      end
+
+    end # class << self
+
+    # gets a greeting message from one or all of the servers in the pool
+    #
+    # parameters:
+    # -  1  server (Symbol) -- by default query all servers in the server pool
+    def hello( server=nil )
+      begin
+        if server.nil? then # try all
+          $serverPool.each_pair do |store, url|
+            @@log.debug "Store: #{store.inspect}, url: #{url.inspect}"
+
+            server = url.first
+            @@log.rubinstein server.hello
+          end
+        else
+          return server.hello
+        end
+      rescue
+        @@log.error $!
+      end
+    end
+
+  end # Base
+end # Module

data/lib/active_rubinstein/deprecated/base.rb

@@ -0,0 +1,208 @@
+# DEPRECATED methods
+# originally written due to poor understanding of the Ruby language
+
+# jena_query #
+# Pass an unadultered query to Rubinstein daemon
+#
+# this may be called from several places,
+# mostly from the models.
+#
+# Parameters:
+#  1  Query
+def jena_query( query, options={}, &block )
+  begin
+    # @language might be set here
+    unless options[ :lang ]
+      options.update :lang => @language if @language
+    end
+
+    @@log.rubinstein "  => Querying Jena, options: #{options.values.join(' ')}"
+    @@log.debug " * Sparql: #{query.to_sp}"
+    @@log.debug "@@jena = #{@@jena.inspect}"
+    results = @@jena.query( query, options )
+    do_log( results )
+    return results
+  rescue
+    @@log.error $!
+    return Array.new
+  end
+end
+alias :query_from_jena :jena_query
+
+
+# constructs a common triplet-query
+def find_from_jena( s, p, o )
+  begin
+#       STDERR.puts "find: #{s}, #{p}, #{o}"
+    lang = @language || nil
+    # using the lang tag slows the queries down really bad..
+    # so we better use it only when necessary
+    @@jena.find( s, p, o )
+    # @@joseki.find( s, p, o, lang )
+  rescue
+    Array.new
+  end
+end
+alias :find :find_from_jena
+
+
+    ########################################################
+    ### Jena graph handling
+    ########################################################
+
+    # Returns the roots of the ontology
+    # parameters:
+    #  1 subject (OwlThing, RDFS::Resource or URI string)
+    def getRoot( ontology=nil )
+      begin
+        @@log.rubinstein "getRoot of #{ontology}"
+        @@jena.getRoot( ontology )
+      rescue
+        @@log.error $!
+      end
+    end
+
+    # Returns the descendants of the subject
+    # parameters:
+    #  1 subject (RdfAbout, OwlThing, RDFS::Resource or URI string)
+    def getDescendants( subject )
+      @@log.rubinstein( "getDescendants: #{subject}" )
+      begin
+        @@jena.getDescendants( subject )
+      end
+    end
+
+    # Returns the children of the subject
+    # parameters:
+    #  1 subject (RdfAbout, OwlClass, RDFS::Resource or URI string)
+    def getChildren( subject )
+      begin
+        @@jena.getChildren( subject, false )
+      end
+    end
+
+    # Returns the parents of the subject
+    # parameters:
+    #  1 subject (RdfAbout, OwlClass, RDFS::Resource or URI string)
+    def getParents( subject )
+      begin
+        @@jena.getParents( subject, false )
+      end
+    end
+
+    # Returns the ancestors of the subject
+    # parameters:
+    #  1 subject (RdfAbout, OwlClass, RDFS::Resource or URI string)
+    def getAncestors( subject )
+      begin
+        x = @@jena.getAncestors( subject )
+        # do not return the RDFS::Resource object
+        x.delete( RDFS::Resource )
+        return x
+      end
+    end
+
+    # getInstances #
+    # Returns the instances of a specific class
+    # Parameters:
+    #  1  subject (RdfAbout, OwlClass, RDFS::Resource or URI string)
+    #  2  reasoner (boolean)
+    def getInstances( subject, reasoner=true )
+      @@log.rubinstein " * getInstances of #{subject}, reasoner: #{reasoner}"
+      begin
+        x = @@jena.getInstances( subject, reasoner )
+        @@log.deep "  => #{x.size} results: #{x}"
+        return x
+      end
+    end
+
+    ####################
+    # getInstanceClass #
+    # gets the immediate RDF::type of an instance
+    # Parameters:
+    #  1 subject (RdfAbout, OwlClass, RDFS::Resource or URI string)
+    def getInstanceClass( subject )
+      @@log.rubinstein " * getInstanceClass for #{subject}"
+      begin
+        results = @@jena.getInstanceClass( subject )
+        do_log( results )
+        return results
+      end
+    end
+
+
+    ##############
+    # getInverse #
+    # returns the inverse of the given property
+    #  eg.  getInverse: KUOPIO::isLocatedIn => KUOPIO::isLocationOf
+    # Parameters:
+    #  1  Property ( Property, RDFS::Resource or URI string )
+    def getInverse( property )
+      @@log.rubinstein " * getInverse of #{property}"
+      begin
+        results = @@jena.getInverse( property )
+        do_log( results ) # crashes
+        return results
+      end
+    end
+
+
+    # returns the classes from the semantic circle, around a certain uri, within a certain radius
+    #  1 subject (RdfAbout, OwlClass, RDFS::Resource or URI string)
+    #  2 radius (Float)
+    def getClassesWithin( subject, radius=0.2 )
+      begin
+        @@jena.getClassesWithin( subject, radius )
+      end
+    end
+
+    # returns the full graph path in RDFS::Resource Array
+    #  1 subject (RdfAbout, OwlClass, RDFS::Resource or URI string)
+    def getFullPath( subject )
+      begin
+
+        # this uses the Java function
+        @@jena.getFullPath( subject )
+
+        # this uses the Ruby function
+#         @@jena.getFullPath_( subject )
+      end
+    end
+
+
+    def getNearbyTargets( lat, long, radius )
+      begin
+        @@jena.getNearbyTargets( lat, long, radius )
+      end
+    end
+
+    ###########################################################
+
+
+
+    def joseki_query( query, options={}, &block )
+      begin
+        @@log.rubinstein "  => Querying Joseki, options: #{options}"
+        @@log.debug " * Sparql: #{query.to_sp}"
+        results = @@joseki.query( query )
+        do_log( results )
+        return results
+      rescue
+        @@log.error $!
+        return Array.new
+      end
+    end
+    alias :query_from_joseki :joseki_query
+
+    def find_from_joseki( s, p, o )
+      begin
+#       STDERR.puts "find: #{s}, #{p}, #{o}"
+        lang = @language || nil
+        # using the lang tag slows the queries down really bad..
+        # so we better use it only when necessary
+        @@joseki.find( s, p, o )
+        # @@joseki.find( s, p, o, lang )
+      rescue
+        Array.new
+      end
+    end