activerdf_net7 1.6.11

data/activerdf-sparql/README

@@ -0,0 +1,10 @@
+== ActiveRDF SPARQL adapter
+This is the ActiveRDF adapter to a SPARQL endpoint serving RDF.
+See http://www.activerdf.org/ for more information.
+
+== License
+This adapter is distributed under the LGPL license.
+
+== Authors
+* Eyal Oren
+* Sebastian Gerke

data/activerdf-sparql/Rakefile

@@ -0,0 +1,78 @@
+require 'meta_project'
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/xforge'
+require 'rubygems'
+require 'fileutils'
+require '../tools/rakehelp'
+
+$version  = IO.read('VERSION').strip
+$name     = 'activerdf_sparql'
+$project  = MetaProject::Project::XForge::RubyForge.new('activerdf')
+$distdir  = "#$name-#$version"
+
+# setup tests
+setup_tests
+setup_clean ["pkg", "lib/*.bundle", "*.gem", ".config"]
+
+# setup rdoc 
+Rake::RDocTask.new do |rdoc|
+	rdoc.rdoc_dir = 'doc/rdoc'
+	rdoc.options << '--line-numbers'
+	rdoc.rdoc_files.add ['README', 'LICENSE', 'lib/**/*.rb', 'doc/**/*.rdoc']
+end
+
+desc "Does a full compile, test run"
+task :default => [:test, :package]
+
+setup_gem($name, $version) do |spec|
+  spec.summary = "ActiveRDF adapter to SPARQL endpoint" 
+  spec.description = spec.summary
+  spec.author="Eyal Oren <eyal.oren@deri.org"
+  spec.add_dependency('gem_plugin', '>= 0.2.1')
+  spec.add_dependency('activerdf', '>= 1.6.4')
+  spec.add_dependency('json', '>= 1.1.1')
+#  if RUBY_PLATFORM =~ /java/
+#    # require json_pure which has no native c extensions when running under jruby
+#    spec.add_dependency('json_pure', '>= 1.1.1')
+#  else
+#    spec.add_dependency('json', '>= 1.1.1')
+#  end
+end
+
+task :verify_rubyforge do
+  raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
+  raise "RUBYFORGE_PASSWORD environment variable not set!" unless ENV['RUBYFORGE_PASSWORD']
+end
+
+desc "release #$name-#$version gem on RubyForge"
+task :release => [:clean, :verify_rubyforge, :package ] do
+  release_files = FileList["pkg/#$distdir.gem"]
+
+  Rake::XForge::Release.new($project) do |release|
+    release.user_name     = ENV['RUBYFORGE_USER']
+    release.password      = ENV['RUBYFORGE_PASSWORD']
+    release.files         = release_files.to_a
+    release.release_name  = "#$name #$version"
+    release.package_name  = "activerdf-sparql"
+		release.release_notes = ""
+
+    changes = []
+    File.open("CHANGELOG") do |file|
+      current = true
+
+      file.each do |line|
+        line.chomp!
+				if current and line =~ /^==/
+					current = false; next 
+				end
+        break if line.empty? and not current
+        changes << line
+      end
+    end
+    release.release_changes = changes.join("\n")
+  end
+end

data/activerdf-sparql/VERSION

@@ -0,0 +1 @@
+1.3.6

data/activerdf-sparql/lib/activerdf_sparql/init.rb

@@ -0,0 +1,10 @@
+# add the directory in which this file is located to the ruby loadpath
+file =
+if File.symlink?(__FILE__)
+  File.readlink(__FILE__)
+else
+  __FILE__
+end
+$: << File.dirname(File.expand_path(file))
+
+require 'sparql'

data/activerdf-sparql/lib/activerdf_sparql/sparql.rb

@@ -0,0 +1,212 @@
+# require 'active_rdf'
+require 'queryengine/query2sparql'
+require 'open-uri'
+require 'cgi'
+require 'rexml/document'
+require "#{File.dirname(__FILE__)}/sparql_result_parser"
+
+# SPARQL adapter
+class SparqlAdapter < ActiveRdfAdapter
+  ActiveRdfLogger::log_info "Loading SPARQL adapter", self
+  ConnectionPool.register_adapter(:sparql, self)
+
+  attr_reader :engine
+  attr_reader :caching
+
+  @@sparql_cache = {}
+
+  def SparqlAdapter.get_cache
+    return @@sparql_cache
+  end
+
+  # Instantiate the connection with the SPARQL Endpoint.
+  # available parameters:
+  # * :url => url: endpoint location e.g. "http://m3pe.org:8080/repositories/test-people"
+  # * :results => one of :xml, :json, :sparql_xml
+  # * :request_method => :get (default) or :post
+  # * :timeout => timeout in seconds to wait for endpoint response
+  # * :auth => [user, pass]
+  def initialize(params = {})	
+    super()
+    @reads = true
+    @writes = false
+
+    @url = params[:url] || ''
+    @caching = params[:caching] || false
+    @timeout = params[:timeout] || 50
+    @auth = params[:auth] || nil
+
+    @result_format = params[:results] || :json
+    raise ActiveRdfError, "Result format unsupported" unless [:xml, :json, :sparql_xml].include? @result_format
+
+    @engine = params[:engine]
+    raise ActiveRdfError, "SPARQL engine unsupported" unless [:yars2, :sesame2, :joseki, :virtuoso].include? @engine
+
+    @request_method = params[:request_method] || :get
+    raise ActiveRdfError, "Request method unsupported" unless [:get,:post].include? @request_method
+    ActiveRdfLogger::log_info(self) { "Sparql adapter initialised #{inspect}" }
+  end
+
+  def size
+    query(Query.new.select(:s,:p,:o).where(:s,:p,:o)).size
+  end
+
+  # query datastore with query string (SPARQL), returns array with query results
+  # may be called with a block
+  def query(query, &block)
+    qs = Query2SPARQL.translate(query)
+    ActiveRdfLogger::log_debug(self) { "Executing sparql query #{query}" }
+
+    if @caching
+      result = query_cache(qs)
+      if result.nil?
+        ActiveRdfLogger.log_debug(self) { "Cache miss for query #{qs}" }
+      else
+        ActiveRdfLogger.log_debug(self) { "Cache hit for query #{qs}" }
+        return result
+      end
+    end
+
+    result = execute_sparql_query(qs, query.resource_class, header(query), &block)
+    add_to_cache(qs, result) if @caching
+    result = [] if result == "timeout"
+    return result
+  end
+
+  # do the real work of executing the sparql query
+  def execute_sparql_query(qs, resource_type, header=nil, &block)
+    ActiveRdfLogger::log_debug(self) { "Executing query #{qs} on url #@url" }
+    header = header(nil) if header.nil?
+
+    # querying sparql endpoint
+    require 'timeout'
+    response = ''
+    begin 
+      case @request_method
+      when :get
+        # encoding query string in URL
+        url = "#@url?query=#{CGI.escape(qs)}"
+        ActiveRdfLogger.log_debug(self) { "GET #{url}" }
+        timeout(@timeout) do
+          open(url, header) do |f|
+            response = f.read
+          end
+        end
+      when :post
+        ActiveRdfLogger.log_debug(self) { "POST #@url with #{qs}" }
+        response = Net::HTTP.post_form(URI.parse(@url),{'query'=>qs}).body
+      end
+    rescue Timeout::Error
+      raise ActiveRdfError, "timeout on SPARQL endpoint"
+    rescue OpenURI::HTTPError => e
+      raise ActiveRdfError, "error on SPARQL endpoint, server said: \n%s:\n%s" % [e,e.io.read]
+    rescue Errno::ECONNREFUSED
+      raise ActiveRdfError, "connection refused on SPARQL endpoint #@url"
+    end
+
+    # we parse content depending on the result format
+    results = case @result_format
+    when :json 
+      parse_json(response, resource_type)
+    when :xml, :sparql_xml
+      parse_xml(response, resource_type)
+    end
+
+    if block_given?
+      results.each do |*clauses|
+        yield(*clauses)
+      end
+    else
+      results
+    end
+  end
+
+  def close
+    ConnectionPool.remove_data_source(self)
+  end
+
+  private
+  # FIXME: Cache not primed for handling res classes!
+  def add_to_cache(query_string, result)
+    unless result.nil? or result.empty?
+      if result == "timeout"
+        @@sparql_cache.store(query_string, [])
+      else 
+        ActiveRdfLogger.log_debug(self) { "Adding to sparql cache - query: #{query_string}" }
+        @@sparql_cache.store(query_string, result) 
+      end
+    end
+  end
+
+
+  def query_cache(query_string)
+    if @@sparql_cache.include?(query_string)
+      return @@sparql_cache.fetch(query_string)
+    else
+      return nil
+    end
+  end
+
+  # constructs correct HTTP header for selected query-result format
+  def header(query)
+    header = case @result_format
+    when :json
+      { 'accept' => 'application/sparql-results+json' }
+    when :xml
+      { 'accept' => 'application/rdf+xml' }
+    when :sparql_xml
+      { 'accept' => 'application/sparql-results+xml' }
+    end
+    if @auth
+      header.merge( :http_basic_authentication => @auth )
+    else
+      header
+    end
+  end
+
+  # parse json query results into array. resource_type is the type to be used
+  # for "resource" objects.
+  def parse_json(s, resource_type)
+    require 'json'
+
+    parsed_object = JSON.parse(s)
+    return [] if parsed_object.nil?
+
+    results = []    
+    vars = parsed_object['head']['vars']
+    objects = parsed_object['results']['bindings']
+
+    objects.each do |obj|
+      result = []
+      vars.each do |v|
+        result << create_node( obj[v]['type'], obj[v]['value'], resource_type)
+      end
+      results << result
+    end
+
+    results
+  end
+
+  # parse xml stream result into array
+  def parse_xml(s, resource_type)
+    parser = SparqlResultParser.new(resource_type)
+    REXML::Document.parse_stream(s, parser)
+    parser.result
+  end
+
+  # create ruby objects for each RDF node. resource_type is the class to be used
+  # for "resource" objects.
+  def create_node(type, value, resource_type)
+    case type
+    when 'uri'
+      resource_type.new(value)
+    when 'bnode'
+      BNode.new(value)
+    when 'literal','typed-literal'
+      value.to_s
+    end
+  end
+
+
+
+end

data/activerdf-sparql/lib/activerdf_sparql/sparql_result_parser.rb

@@ -0,0 +1,55 @@
+# Parser for SPARQL XML result set.
+class SparqlResultParser
+  attr_reader :result
+
+  # The resource_type is the class that 
+  def initialize(resource_type)
+    @result = []
+    @vars = []
+    @current_type = nil
+    @resource_type = resource_type
+  end
+  
+  def tag_start(name, attrs)
+    case name
+    when 'variable'
+      @vars << attrs['name']
+    when 'result'
+      @current_result = []
+    when 'binding'
+      @index = @vars.index(attrs['name'])
+    when 'bnode', 'literal', 'typed-literal', 'uri'
+      @current_type = name
+    end
+  end
+  
+  def tag_end(name)
+    if name == "result"
+      @result << @current_result
+    elsif name == 'bnode' || name == 'literal' || name == 'typed-literal' || name == 'uri'
+      @current_type = nil
+    elsif name == "sparql"
+    end
+  end
+  
+  def text(text)
+    if !@current_type.nil?
+      @current_result[@index] = create_node(@current_type, text)  
+    end
+  end
+
+  # create ruby objects for each RDF node
+  def create_node(type, value)
+    case type
+    when 'uri'
+      @resource_type.new(value)
+    when 'bnode'
+      BNode.new(value)
+    when 'literal','typed-literal'
+      value.to_s
+    end
+  end
+  
+  def method_missing (*args)
+  end
+end

data/activerdf-sparql/test/test_sparql_adapter.rb

@@ -0,0 +1,108 @@
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+
+require "rubygems"
+require 'active_rdf'
+require 'test/unit'
+require 'federation/federation_manager'
+require 'queryengine/query'
+
+
+class TestSparqlAdapter < Test::Unit::TestCase
+  def setup
+    ConnectionPool.clear
+    @adapter = ConnectionPool.add(:type => :sparql, :url => 'http://dbpedia.org/sparql', :engine => :virtuoso)
+  end
+
+  def teardown
+  end
+
+  def test_registration
+    assert_instance_of SparqlAdapter, @adapter
+  end
+
+  def test_language
+    sunset = RDFS::Resource.new("http://dbpedia.org/resource/77_Sunset_Strip")
+    abstract = RDFS::Resource.new("http://dbpedia.org/property/abstract")
+
+    german = Query.new.distinct(:o).where(sunset,abstract,:o).limit(1).lang(:o,'de').execute.first
+    english = Query.new.distinct(:o).where(sunset,abstract,:o).limit(1).lang(:o,'en').execute.first
+
+    assert english =~ /^77 Sunset Strip is the first hour-length private detective series in American television history/
+    assert german =~ /^77 Sunset Strip ist ein Serienklassiker aus den USA um das gleichnamige, in Los Angeles am Sunset Boulevard angesiedelte Detektivbüro/
+  end
+
+  def test_limit_offset
+    one = Query.new.select(:s).where(:s,:p,:o).limit(10).execute
+    assert_equal 10, one.size
+
+    one.all? do |r|
+      assert_instance_of RDFS::Resource, r
+    end
+
+    two = Query.new.select(:s).where(:s,:p,:o).limit(10).offset(1).execute
+    assert_equal 10, two.size
+    assert_equal one[1], two[0]
+
+    three = Query.new.select(:s).where(:s,:p,:o).limit(10).offset(0).execute
+    assert_equal one, three
+  end
+
+  def test_regex_filter
+    Namespace.register :yago, 'http://dbpedia.org/class/yago/'
+    Namespace.register :dbpedia, 'http://dbpedia.org/property/'
+    Namespace.register :dbresource, 'http://dbpedia.org/resource/'
+
+    movies = Query.new.
+      distinct(:title).
+      where(DBRESOURCE::Kill_Bill, RDFS.label, :title).
+      filter_regex(:title, /^Kill/).limit(10).execute
+
+    assert !movies.empty?, "regex query returns empty results"
+    assert movies.all? {|m| m =~ /^Kill/ }, "regex query returns wrong results"
+  end
+
+  def test_query_with_block
+    reached_block = false
+    Query.new.select(:s, :p).where(:s,:p,:o).limit(1).execute do |s, p|
+      reached_block = true
+      assert_equal RDFS::Resource, s.class
+      assert_equal RDFS::Resource, p.class
+    end
+    assert reached_block, "querying with a block does not work"
+
+    reached_block = false
+    Query.new.select(:s, :p).where(:s,:p,:o).limit(3).execute do |s, p|
+      reached_block = true
+      assert_equal RDFS::Resource, s.class
+      assert_equal RDFS::Resource, p.class
+    end
+    assert reached_block, "querying with a block does not work"
+
+    reached_block = false
+    Query.new.select(:s).where(:s,:p,:o).limit(3).execute do |s|
+      reached_block = true
+      assert_equal RDFS::Resource, s.class
+    end
+
+    assert reached_block, "querying with a block does not work"
+  end
+
+  def test_refuse_to_write
+    eyal = RDFS::Resource.new 'http://activerdf.org/test/eyal'
+    age = RDFS::Resource.new 'foaf:age'
+    test = RDFS::Resource.new 'test'
+
+    # NameError gets thown if the method is unknown
+    assert_raises NoMethodError do
+      @adapter.add(eyal, age, test)
+    end
+  end
+
+  def test_literal_conversion
+    # test literal conversion
+    label = Query.new.distinct(:label).where(:s, RDFS::label, :label).limit(1).execute(:flatten)
+    assert_instance_of String, label
+  end
+end