activerubic 0.8.0

data/History.txt

@@ -0,0 +1,41 @@
+== 0.8.0 / 2007-12-31
+
+* This release supports Jena ja Lucene and operates with Rubinstein-0.88. Joseki support has been working reliably, but due to poor performance the model is left unmaintained.
+
+* Only Ruby-1.8.6 and Rails-1.2.6 have been tested.
+* See Rubinstein README for notes on JRuby versions.
+
+== Earlier history:
+  0.78  changed library loading paths, rake is successful
+  0.77  raise errors when connection is not established
+  0.76  removed methods that contained schema data from objectmanager
+  0.75  compatibility with ActiveRDF-1.6.8; including the Namespace patch
+  0.74  cleanup and bug fixes
+  0.73  switch to RDFS::Resource model from sandbox wrapper RdfAbout
+  0.72  cleanup and bug fixes
+  0.71  including enhanced ActiveRubic children models.
+  0.70  major changes; introduction of method_missing, which deprecates
+        around 50% of the existing code while making it more efficient.
+        the code is now cleaner and easier to understand.
+        introduction of ActiveRubinstein::JenaQuery, ::JosekiQuery and
+        ::LuceneSearcher with ActiveRubic::Cacher
+  0.60  getNearbyTargets to Lucene methods
+  0.59  getInverse method for properties
+  0.58  start ActiveRubinstein only in client mode
+  0.57  include MysqlCache + some bug fixes
+  0.56  model cleanup
+  0.55  fixed a major bug in Rubic; returned a Hash with an empty resultset.
+        the return value should be an empty Array in this case.
+  0.54  dropped the connection dependency if it is not within RUBIC_DATASTORES
+  0.53  markers from Jena honor the :limit parameter, but Jena cannot handle
+        limit in SPARQL. is this a bug in Jena or EVO from our side?
+  0.52  languages are read correctly from Jena
+  0.51  more coherent structure, rubic-debug is working. logging is improved.
+  0.50  much tweaking to get Jena working properly :)
+  0.43  basic jena-joseki connectivity in Rails
+  0.42  initial work to integrate into Rails. not working yet.
+  0.41  reading selectively from jena, joseki and mysql.
+  0.40  Molding app/models/rubic.rb into ActiveRubic and ActiveRubinstein
+  0.30  Relatively stable version -- sparql and graph handling, no proper logging
+  0.20  Rubic model
+  0.10  ActiveRubinstein model

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/active_rubic
+lib/active_rubic.rb
+test/test_active_rubic.rb

data/README.txt

@@ -0,0 +1,56 @@
+ActiveRubic
+    by Mikael Lammentausta
+    activerubic.rubyforge.org
+
+== DESCRIPTION:
+ActiveRubic is a Ruby module, written for the Rails web platform. The motivation in making this module was to replace ActiveRecord as the primary data source to be operated with the MVC model.
+
+With this module it is possible to use semantic data stores instead of relational database on web sites. The module supports plug-in submodules for additional data stores.
+
+All of them are used via the ActiveRubinstein submodule. Stub for MySQL run-time cache has been made but not yet written. The benefit would be to speed up performance.
+
+ActiveRubinstein requires the Rubinstein backend server. The server IP address and the TCP port are configurable from Rails' configuration files. 
+
+ActiveRubic has been factored to use submodules. ActiveRubinstein is a module similar to ActiveRecord, which connects to the Rubinstein DRb server to run SPARQL queries from Jena. MySQL-cacher would use the ActiveRecord ORM.
+
+== FEATURES/PROBLEMS:
+Currently supported backends are:
+
+*    Jena
+*    Lucene
+*    Joseki
+
+== SYNOPSIS:
+See the actual documentation.
+
+== REQUIREMENTS:
+*    ActiveRDF-1.6.8
+*    Rubinstein-0.88
+
+*    FIX update
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+Copyright (c) 2007 Savonia University of Applied Sciences
+
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,35 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/active_rubic.rb'
+
+Hoe.new('ActiveRubic', ActiveRubic::VERSION) do |p|
+  p.rubyforge_name = 'activerubic'
+  # p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  # p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+
+  p.name = "activerubic"
+  p.version = "0.8.0"
+  p.author = "Mikael Lammentausta"
+  p.email = "mikael.lammentausta( at )gmail.com"
+  #p.homepage = "http://openlab.savonia-amk.fi/wiki/index.php/ActiveRubic"
+  #p.rubyforge_project = "activerubic"
+  #p.platform = Gem::Platform::RUBY
+  p.summary = "ActiveRubic is a C/JRuby connector to semantic data stores, such as Jena and Joseki, using ActiveRDF."
+  #p.add_dependency("activerdf", ">= 1.6.8")
+
+  #p.files = FileList["lib/**/*"].to_a
+  #p.require_path = "lib"
+  #p.autorequire = "name"
+  p.test_files = FileList["{test}/**/*test.rb"].to_a
+
+  #p.has_rdoc = true
+  #p.extra_rdoc_files = ["README.txt"]
+  p.remote_rdoc_dir = '' # Release to root
+
+
+end
+
+# vim: syntax=Ruby

data/lib/active_rubic.rb

@@ -0,0 +1,365 @@
+#############################################################################
+# ActiveRubic emulates ActiveRecord and provides connections to several data stores with the objective to abstract the semantic data from various engines.
+#
+# The engines are also attempted to be drop-in replaceable by offering an abstraction method find(). see ActiveRubic::Base for the API reference.
+# - some of it is still undocumented!!
+
+
+# The supported backends currently include:
+#
+# - ActiveRecord
+# - ActiveRubinstein
+#
+# This module abstracts the query methods (SPARQL, graph handling, SQL, Lucene index)
+# to parameters so that different storages can be "hot-replaced" without the need to make changes to the request.
+#
+# ActiveRubinstein::Base is the API which translates queries to the servers
+# which are supported by the Rubinstein backend, which replies to queries
+# over the DRb bridge. This also makes possible to use Java-based repositories
+# with JRuby without running the whole Rails stack on JRuby.
+# 
+# http://openlab.savonia-amk.fi/wiki/images/1/12/Rubics_cube.png
+# 
+# Authors:: Mikael Lammentausta, Lauri Miettinen
+# Copyright:: Copyright (c) 2007 Savonia University of Applied Sciences
+# License:: MIT
+#
+# = Examples
+# In this example we'll inspect the instance of the Museum of natural history of Kuopio, Finland. Launch up the Rails console:
+# 
+#     $ ./script/console
+#     Loading development environment.
+#       RUBIC log/irb:  * Initializing ActiveRubic, version 0.76
+#       RUBIC log/irb:  => loading ActiveRubinstein
+#       RUBIC log/irb:  => loading ActiveRubic
+#       RUBIC log/irb:  * Rails environment already initialized
+#       DEBUG log/irb:  => including ActiveRubinstein to ActiveRubic::Base
+#       RUBIC log/irb:  * loading ActiveRDF extensions
+#        DEEP log/irb: Formulating new RDFS::Resource http://www.w3.org/2000/01/rdf-schema#Resource from String
+#        DEEP log/irb: Formulating new RDFS::Resource http://openlab/media#image from String
+#        DEEP log/irb: Formulating new RDFS::Resource http://www.w3.org/2002/07/owl#Class from String
+#        DEEP log/irb: Formulating new RDFS::Resource http://www.w3.org/2002/07/owl#Thing from String
+#        DEEP log/irb: Formulating new RDFS::Resource http://www.w3.org/2002/07/owl#ObjectProperty from String
+#  RUBINSTEIN log/irb:  * initializing JenaEndpoint: druby://192.168.0.11:2002
+#       DEBUG log/irb: #<DRb::DRbObject:0xb6e0ed0c @ref=nil, @uri="druby://192.168.0.11:2002">
+#       DEBUG log/irb:  => reply from server: Greetings -- this is jRubinstein#JenaLuc/Picard 0.84 on 192.168.0.11:2002, PID 20471808
+#  RUBINSTEIN log/irb:  => added #<ActiveRubinstein::JenaEndpoint:0xb6e0edfc @uri="druby://192.168.0.11:2002"> to pool
+#        INFO log/irb: @@jena = #<ActiveRubinstein::JenaEndpoint:0xb6e0edfc @uri="druby://192.168.0.11:2002">
+#        INFO log/irb: @@lucene = #<ActiveRubinstein::JenaEndpoint:0xb6e0edfc @uri="druby://192.168.0.11:2002">
+# 
+# If everything is fine, fire up a simple query for label:
+# 
+#  resource = KUOPIO::kuopion_museo
+#   => #<RDFS::Resource:0xb6ef1fa8 @uri="http://openlab/kuopio#kuopion_museo">
+#
+#  resource.label
+#   => ["Kuopion museo"]
+# 
+# How does this data get from Jena to Rails' console? Let's inspect the entire data passage.
+# 
+# First of all, the label method looks like this:
+# 
+#   class class RDFS::Resource
+#     def label
+#       if @label.nil?
+#         @label = my( RDFS::label )
+#       end
+#       return @label
+#     end
+#   end
+# 
+# It calls the private 'my' method within the model:
+# 
+#   private
+#   ### helper
+#   def my( predicate )
+#     if predicate.is_a? String then
+#       predicate = RDFS::Resource.new( predicate )
+#     end
+#     begin
+#       @@log.debug " => find #{self.uri} #{predicate} ?"
+#       ActiveRubic::Base.find( predicate, :subject => self.uri, 
+#         :from => RUBIC_DATASTORES, 
+#         :lang => @language
+#       ) || Array.new
+# 
+#     rescue
+#       @@log.error $!
+#       return Array.new
+#     end
+#   end
+# 
+# Which calls the ActiveRubic::Base find() method with the subject, required predicate, and options for used data stores as well as the desired language. The find() method and the following data flow, many lines are removed to simplify the logic behind the module:
+# 
+#   module ActiveRubic #:nodoc:
+#     class Base
+#       class << self # Class methods
+#         def find(*args)
+#           # options:
+#           #  :data_stores = Array
+#           #  :suffice_to = Array of data_stores that are trusted to return sufficient results. By default all data stores are untrusted to be complete, and the results of each are combined. The results of servers given in the array
+#           #  :combine = Array of data stores that are queried and the results combined. If the trusted server returns results, trust that the contents is sufficient.
+#           options = extract_options_from_args!(args)
+# 
+#           serial_query_handler( args.first, options )
+#         end
+# 
+#         private
+#           # runs a query on data stores sequentially
+#           def serial_query_handler(query, options)
+#             begin
+#               data_stores.each do |storage|
+#                 my_results = run_query( storage, query, options )
+#               end
+#             end
+#             # merge and return results
+#           end
+# 
+#           # constructs the actual queries and receives the result
+#           def run_query( storage, query, options )
+#             case storage
+#             when :jena
+#               ActiveRubinstein::JenaQuery.execute( query, options )
+#             end
+#           end
+#         end
+#       end
+#     end
+#   end
+# 
+# The ActiveRubinstein::JenaQuery class, and ActiveRubic in general, accepts three types of 'query' objects:
+# - Symbol for actions, eg. :parents, :children, :nearby, :properties etc.
+# - RDFS::Resource (predicate) with the option :subject => uri, to fetch the object, as in the RDFS::label example
+# - Query, an ActiveRDF object, as a block without the .execute call
+# 
+# Let's examine the JenaQuery class:
+# 
+#   module ActiveRubinstein #:nodoc:
+#     class JenaQuery < ActiveRubinstein::Base
+#       class << self
+# 
+#       public
+# 
+#         def execute( query, options )
+#           if query.is_a? Symbol or query.is_a? RDFS::Resource
+#             case query
+#               # ... process some symbols
+#             else # construct common SPARQL
+#               sparql = ActiveRubinstein::Base.construct_sparql( query, options )
+#               self.query( sparql, options ) if sparql
+#             end
+#           end
+#         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}"
+#           @@jena.send( method, *args, &block )
+#         end
+#       end
+#     end
+#   end
+# 
+# @@jena variable is instantiated in ActiveRubinstein::Base:
+# 
+#   module ActiveRubinstein #:nodoc:
+#     class Base
+#       def shuffle    # Initialization of servers
+# 
+#           $serverPool = {} unless defined? $serverPool
+# 
+#           RUBIC_DATASTORES.each do |adapter|
+#               case adapter
+#               when :jena
+#                 server = JenaEndpoint.new
+#                 if server.ping
+#                   $serverPool.update :jena => [ server ]
+#                   @@log.rubinstein " => added #{server.inspect} to pool"
+#                 end
+#               end
+#           end
+#         end
+#       end
+# 
+#       # create the server pool, start the DRb service, and
+#       # init the required submodules, so that the correct service is
+#       # accessible as a class variable
+#       def initialize
+#         self.shuffle unless defined? $serverPool
+#         DRb.start_service
+# 
+#           RUBIC_DATASTORES.each do |adapter|
+#               case adapter
+#               ##############################
+#               when :jena
+#                 # instantiate the server for the JenaQuery class
+#                 ActiveRubinstein::JenaQuery.new
+#               end
+#           end
+#         end
+#       end
+#     end
+#   end
+# 
+#   module ActiveRubinstein #:nodoc:
+#     class JenaQuery < ActiveRubinstein::Base
+#       def initialize
+#         server = $serverPool[ :jena ].first
+#         unless server.ping
+#           @@log.error $!.message
+#         else
+#           @@jena = server
+#           @@log.info "@@jena = #{server.inspect}"
+#         end
+#       end
+#     end
+#   end
+# 
+# Finally, here is the log of the query:
+#
+#        DEEP log/irb: Formulating new RDFS::Resource http://www.w3.org/2000/01/rdf-schema#label from String
+#       DEBUG log/irb:  => find http://openlab/kuopio#kuopion_museo <http://www.w3.org/2000/01/rdf-schema#label> ?
+#       RUBIC log/irb:  * Find: <http://www.w3.org/2000/01/rdf-schema#label>, fromjenalucenesubject<http://openlab/kuopio#kuopion_museo>lang
+#        DEEP log/irb:   => Querying data stores: jena, lucene
+#        DEEP log/irb:  - Will suffice to data from lucene
+#       RUBIC log/irb:    => query: <http://www.w3.org/2000/01/rdf-schema#label> (RDFS::Resource)
+#  RUBINSTEIN log/irb: Constructing SPARQL, options: data_storesjenalucenefromjenalucenesubject<http://openlab/kuopio#kuopion_museo>lang
+#       DEBUG log/irb:   => constructing Query to find <http://www.w3.org/2000/01/rdf-schema#label>
+#        DEEP log/irb: Constructing SPARQL <http://openlab/kuopio#kuopion_museo> <http://www.w3.org/2000/01/rdf-schema#label> ?
+#  RUBINSTEIN log/irb: sending the request to DRb server, method query
+#       RUBIC log/irb:    => Got 1 results from jena in 0.00976 sec
+#       RUBIC log/irb:    => query: <http://www.w3.org/2000/01/rdf-schema#label> (RDFS::Resource)
+#       RUBIC log/irb:    => No results from lucene in 0.00015 sec
+#        DEEP log/irb:   => 1 altogether
+#       RUBIC log/irb:   => TOTAL: 1 unique results
+#        DEEP log/irb:  => Returning all 1, no limit
+#  => ["Kuopion museo"]
+#
+############################################################################
+
+RUBIC_VERSION = '0.8.0'
+
+module ActiveRubic
+  VERSION = RUBIC_VERSION
+  class ActiveRubicError < StandardError #:nodoc:
+  end
+  class AdapterNotSpecifiedError < ActiveRubicError # :nodoc:
+  end
+  class AdapterNotFoundError < ActiveRubicError # :nodoc:
+  end
+  class ConnectionNotEstablishedError < ActiveRubicError #:nodoc:
+  end
+  class ConnectionFailedError < ActiveRubicError #:nodoc:
+  end
+  class RubicNotFoundError < ActiveRubicError #:nodoc:
+  end
+end
+
+
+### the data sources that will be queried
+RUBIC_DATASTORES = [ :jena, :joseki, :mysql, :lucene, :geolucene ] unless defined? RUBIC_DATASTORES
+
+# unused
+RUBIC_CONNECTION_ADAPTERS = [ :rubinstein ] unless defined?(RUBIC_CONNECTION_ADAPTERS)
+
+### set environment
+if defined? RAILS_ROOT
+  RUBINSTEIN_HOME = RAILS_ROOT + '/lib/rubinstein' unless defined? RUBINSTEIN_HOME
+  RUBIC_HOME = RAILS_ROOT + '/lib/active_rubic/lib/' unless defined? RUBIC_HOME
+else
+  unless defined? RUBINSTEIN_HOME
+    if ENV['RUBINSTEIN_HOME'] then
+      RUBINSTEIN_HOME = ENV['RUBINSTEIN_HOME']
+    else
+      # using File.dirname causes /usr/bin/rake to break the system.
+      RUBINSTEIN_HOME = File.dirname($0)
+    end
+  end
+
+  unless defined? RUBIC_HOME
+    if ENV['RUBIC_HOME'] then
+      RUBIC_HOME = ENV['RUBIC_HOME']
+    else
+      RUBIC_HOME = RUBINSTEIN_HOME + '/lib/active_rubic/'
+    end
+  end
+end
+
+### load logger + Rubinstein libraries
+unless (( defined? @@log ) || ( defined? logger ))
+  require RUBINSTEIN_HOME + '/lib/logger'
+  load_logger
+end
+
+require 'rubygems'
+
+### load the DRb server functions
+require 'drb/drb'
+#   require 'thread'
+#   require 'gen'
+
+require 'active_rdf'
+# load the namespace patch to ActiveRDF
+require RUBIC_HOME + '/lib/objectmanager/namespace'
+
+# Namespace configuration
+require RUBINSTEIN_HOME + '/config/namespaces'
+
+### load helper methods
+require RUBINSTEIN_HOME + '/lib/helpers'
+
+### start ActiveRubic
+begin
+
+  @@log.rubic " * Initializing ActiveRubic, version #{RUBIC_VERSION}"
+  @@in_daemon_mode = false unless defined? @@in_daemon_mode
+
+  RUBIC_CONNECTION_ADAPTERS.each do |adapter|
+    case adapter
+    when :rubinstein
+      ## ActiveRubinstein client talks with the Jena/Lucene/Joseki DRb server
+
+      ### load the base
+      @@log.rubic " => loading ActiveRubinstein"
+      require RUBIC_HOME + '/lib/active_rubinstein/base'
+
+      @@log.rubic " => loading ActiveRubic"
+      require RUBIC_HOME + '/lib/active_rubic/base'
+
+      @@log.debug " => including ActiveRubinstein to ActiveRubic::Base"
+      ActiveRubic::Base.class_eval do
+        include ActiveRubinstein
+      end
+      #       ActiveRubic::Base.class_eval do
+      #         include MysqlCache
+      #       end
+
+      ### load models
+      @@log.rubic " * loading ActiveRDF extensions"
+      require RUBIC_HOME + '/lib/objectmanager/rdfs/resource'
+      require RUBIC_HOME + '/lib/objectmanager/rdfs/image' # should be in the schema
+      require RUBIC_HOME + '/lib/objectmanager/owl/class'
+      require RUBIC_HOME + '/lib/objectmanager/owl/thing'
+      require RUBIC_HOME + '/lib/objectmanager/owl/object_property'
+
+      ### load the backend libraries only when required
+      unless @@in_daemon_mode then
+        begin
+          # initialize the server pool
+          ActiveRubinstein::Base.new()
+        rescue
+          raise ActiveRubic::ConnectionFailedError, $!
+        end
+      end
+
+    end
+  end
+
+rescue
+#   raise ActiveRubic::ActiveRubicError, $!
+end
+
+# EOF

data/test/test_active_rubic.rb

@@ -0,0 +1,305 @@
+# Author:: Mikael Lammentausta
+
+require 'test/unit'
+require 'active_rdf'
+
+RUBINSTEIN_HOME = "/home/mikael/sematorio/trunk/Seamfora/Rubinstein"
+RUBIC_HOME = "#{File.dirname(__FILE__)}/../lib/"
+LOGDIR = "#{File.dirname(__FILE__)}/log/"
+
+JDRB_SERVER = '192.168.0.11'
+JDRB_PORT = '2002'
+
+GEOLUCENE_SERVER = '192.168.0.11'
+GEOLUCENE_PORT = '2003'
+
+RUBIC_DATASTORES = :jena
+
+require RUBINSTEIN_HOME + '/config/namespaces'
+require RUBIC_HOME + 'active_rubic'
+
+@@log.level = INFO
+
+
+# require "/common"
+# require 'federation/federation_manager'
+# require 'queryengine/query'
+# require "#{File.dirname(__FILE__)}/common"
+
+class TestConnection < Test::Unit::TestCase
+  def test_jena
+    greeting = ActiveRubinstein::JenaQuery.hello
+    assert greeting.is_a?( String )
+  end
+  def test_truth
+    assert true
+  end
+end
+
+class TestModels < Test::Unit::TestCase
+  @@resources = [
+    KUOPIO::kuopion_museo,
+    TOIMIJAT::snellman_j_v
+    ]
+  @@classes = [
+    OWL::Class.new( KUOPIO::museot ),
+#     OWL::Class.new( KUOPIO::rakennukset ),
+    OWL::Class.new( KUOPIO::rautatieasemat ),
+    OWL::Class.new( KUOPIO::kulkuvaylat ),
+    OWL::Class.new( KUOPIO::leikkipaikat )
+  ]
+
+#   def test_uri
+#     ( @@resources + @@classes ).each do |resource|
+#       assert !resource.uri.nil?
+#       assert resource.uri.is_a?( String )
+#     end
+#   end
+# 
+#   def test_label
+#     ( @@resources + @@classes ).flatten.each do |resource|
+#       assert resource.label.is_a?( Array )
+#       assert resource.labelize.is_a?( String )
+#     end
+#   end
+# 
+#   def test_types
+#     @@resources.each do |resource|
+#       assert !resource.is_class?
+#       assert !resource.is_property?
+#       types = resource.types
+#       assert types.is_a?( Array )
+#       types.each do |type|
+#         assert type.is_a?( RDFS::Resource )
+#       end
+#     end
+#     @@classes.each do |resource|
+#       assert resource.is_class?
+#       assert !resource.is_property?
+#     end
+#   end
+# 
+#   def test_properties
+#     ( @@resources + @@classes ).each do |resource|
+#       properties = resource.properties
+#       assert properties.is_a?( Array )
+# 
+#       # test a specific instance
+#       properties << KUOPIO::kuopion_museo.properties
+#       properties.flatten!
+#       assert !properties.empty?
+# 
+#       properties.each do |property|
+#         assert !property.uri.nil?
+#         assert property.is_a?( OWL::ObjectProperty )
+# 
+#         # test inverse
+#         inverse = property.inverse
+#         assert property.inverse.is_a?( OWL::ObjectProperty )
+# 
+#         # assert that the inverse of the inverse is the same
+#         # as the original property
+#         assert property.inverse.inverse.uri == property.uri
+#       end
+#     end
+#   end
+# 
+#   def test_property_domain_and_range
+#     # test cases:
+#     # TOIMIJAT::stromberg_johan KUOPIO::isDesignerOf KUOPIO::kuopion_museo
+# 
+#     test_designer = TOIMIJAT::stromberg_johan
+#     test_property = OWL::ObjectProperty.new( KUOPIO::isDesignerOf )
+#     assert test_property.is_a?( OWL::ObjectProperty )
+#     assert test_property.is_property?
+#     designers = test_property.domain
+# 
+#     # do a hard-coded check on the test_designer
+#     assert test_designer.range( test_property ).include?( KUOPIO::kuopion_museo )
+# 
+#     # all resources that are in the range of this property
+#     property_range = test_property.range
+# 
+#     # test that the designers are RDFS::Resources
+#     # and that the test_property is included in their properties
+#     designers.each do |designer|
+# #       STDERR.puts designer
+#       assert designer.is_a?( RDFS::Resource )
+#       assert designer.labelize.is_a?( String )
+#       assert designer.properties.include?( test_property )
+# 
+#       # check that the resources this designer has designed is included
+#       # in the property_range
+#       designer.range( test_property ).each do |designed_object|
+#         assert designed_object.is_a?( RDFS::Resource )
+# 
+#         # assert that the designed_object has the inverse property to
+#         # the test_property ( isDesignedBy )
+#         assert designed_object.properties.include?( test_property.inverse )
+# 
+#         # assert that this designer is actually the designer of this object
+#         object_designers = designed_object.range( test_property.inverse )
+#         assert object_designers.is_a?( Array )
+#         assert !object_designers.empty?
+#         assert object_designers.include?( designer )
+# 
+#       end
+#     end
+#   end
+
+  def test_recommendation_by_properties
+
+
+  
+  end
+# 
+# 
+#   def test_images
+#     @@resources.each do |resource|
+#       images = resource.images
+#       assert images.is_a?( Array )
+#       if images.any?
+#         STDERR.puts "images found for #{resource}"
+#         images.each do |image|
+#           assert image.is_a?( Image )
+#           assert image.url.grep(/^http/).any?
+#           assert image.subjects.include?( resource )
+#         end
+#       end
+#     end
+#   end
+
+#   def test_geopoints
+#     @@resources.each do |resource|
+# #       STDERR.puts resource
+#       geopoint = resource.geopoint
+#       if geopoint
+# #         STDERR.puts "..is mappable"
+#         assert resource.is_mappable?
+#         assert geopoint.is_a?( RDFS::Resource )
+#         assert geopoint.lat != 0.0
+#         assert geopoint.long != 0.0
+#       else
+# #         STDERR.puts "..is not mappable"
+#         assert !resource.is_mappable?
+#       end
+#     end
+# 
+#     # test a specific instance that has a geopoint
+#     geopoint = KUOPIO::kuopion_museo
+#     STDERR.puts geopoint.labelize
+#     assert geopoint.is_mappable?
+#     assert geopoint.lat != 0.0
+#     assert geopoint.long != 0.0
+# 
+#     # test a specific instance, that gets the geopoint
+#     # through a property
+#     resource = TOIMIJAT::isa_camillo
+#     STDERR.puts resource.labelize
+#     assert resource.is_mappable?
+#     assert resource.lat != 0.0
+#     assert resource.long != 0.0
+# 
+#     # test a specific class
+#     owlclass = OWL::Class.new( KUOPIO::museot )
+#     assert owlclass.is_mappable?
+#     assert !owlclass.geopoints.empty?
+# 
+#     @@classes.each do |resource|
+#       STDERR.puts resource
+#       geopoints = resource.geopoints
+#       assert geopoints.is_a?( Array )
+#       if geopoints.any?
+#         STDERR.puts "..is mappable"
+#         assert resource.is_mappable?
+#         geopoints.each do |geopoint|
+#           assert geopoint.is_a?( RDFS::Resource )
+#           assert geopoint.labelize.is_a?( String )
+#           assert geopoint.lat != 0.0
+#           assert geopoint.long != 0.0
+#           assert geopoint.ancestors.include?( resource )
+#         end
+#       else
+#         STDERR.puts "..is not mappable"
+#         assert !resource.is_mappable?
+#       end
+#     end
+#   end
+
+#   def test_ancestors
+#     ( @@resources + @@classes ).each do |resource|
+#       ancestors = resource.ancestors
+#       assert ancestors.is_a?( Array )
+#       assert !ancestors.empty?
+#       ancestors.each do |ancestor|
+#         assert !ancestor.uri.nil?
+#         assert ancestor.is_a?( OWL::Class )
+# #         assert ancestor.is_class?
+#       end
+#     end
+#   end
+# 
+#   def test_parents
+#     ( @@resources + @@classes ).each do |resource|
+#       parents = resource.parents
+#       assert parents.is_a?( Array )
+#       assert !parents.empty?
+#       parents.each do |parent|
+#         assert !parent.uri.nil?
+#         assert parent.is_a?( OWL::Class )
+#         assert parent.is_class?
+#         assert resource.ancestors.include?( parent )
+#       end
+#     end
+#   end
+# 
+#   def test_children
+#     # add a specific class that definitely has children
+#     ( @@classes + [ OWL::Class.new( KUOPIO::rakennukset ) ] ).each do |resource|
+#       children = resource.children
+#       assert children.is_a?( Array )
+#       if children.any?
+#         children.each do |child|
+#           #STDERR.puts child
+#           assert !child.uri.nil?
+#           assert child.is_a?( OWL::Class )
+#           assert child.is_class?
+#           assert resource.descendants.include?( child )
+#         end
+#       end
+#     end
+#   end
+# 
+#   def test_descendants
+#     ( @@classes + [ OWL::Class.new( KUOPIO::rakennukset ) ] ).each do |resource|
+#       descendants = resource.descendants
+#       assert descendants.is_a?( Array )
+#       if descendants.any?
+#         descendants.each do |descendant|
+# #           STDERR.puts descendant
+#           assert !descendant.uri.nil?
+#           assert descendant.is_a?( OWL::Class )
+#           assert descendant.is_class?
+#         end
+#       end
+#     end
+#   end
+# 
+#   def test_class_instances
+#     @@classes.each do |resource|
+#       instances = resource.instances
+#       assert instances.is_a?( Array )
+#       assert !instances.empty?
+#       instances.each do |instance|
+#         assert !instance.uri.nil?
+#         assert instance.is_a?( RDFS::Resource )
+#         assert !instance.is_class?
+#         assert instance.ancestors.include?( resource )
+#       end
+#     end
+#   end
+
+
+end
+
+

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: activerubic
+version: !ruby/object:Gem::Version 
+  version: 0.8.0
+date: 2008-01-01 00:00:00 +02:00
+summary: ActiveRubic is a C/JRuby connector to semantic data stores, such as Jena and Joseki, using ActiveRDF.
+require_paths: 
+- lib
+email: mikael.lammentausta( at )gmail.com
+homepage: http://www.zenspider.com/ZSS/Products/ActiveRubic/
+rubyforge_project: activerubic
+description: The author was too lazy to write a description
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Mikael Lammentausta
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/active_rubic
+- lib/active_rubic.rb
+- test/test_active_rubic.rb
+test_files: 
+- test/test_active_rubic.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: 
+- active_rubic
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+    version: