activerdf_net7 1.6.16 → 1.7.0

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

@@ -5,208 +5,207 @@ require 'cgi'
 require 'rexml/document'
 require "#{File.dirname(__FILE__)}/sparql_result_parser"
 
-# SPARQL adapter
-class SparqlAdapter < ActiveRdfAdapter
+module ActiveRDF
+  # SPARQL adapter
+  class SparqlAdapter < ActiveRdfAdapter
   ActiveRdfLogger::log_info "Loading SPARQL adapter", self
-  ConnectionPool.register_adapter(:sparql, self)
+    ConnectionPool.register_adapter(:sparql, self)
 
-  attr_reader :engine
-  attr_reader :caching
+    attr_reader :engine
+    attr_reader :caching
 
-  @@sparql_cache = {}
+    @@sparql_cache = {}
 
-  def SparqlAdapter.get_cache
-    return @@sparql_cache
-  end
+    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
+    # 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
+    end
 
-  def size
-    query(Query.new.select(:s,:p,:o).where(:s,:p,:o)).size
-  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)
+    # query datastore with query string (SPARQL), returns array with query results
+    # may be called with a block
+    def execute(query, &block)
+      qs = Query2SPARQL.translate(query)
     ActiveRdfLogger::log_debug(self) { "Executing sparql query #{query}" }
 
-    if @caching
-      result = query_cache(qs)
-      if result.nil?
+      if @caching
+         result = query_cache(qs)
+         if result.nil?
         ActiveRdfLogger.log_debug(self) { "Cache miss for query #{qs}" }
-      else
+         else
         ActiveRdfLogger.log_debug(self) { "Cache hit for query #{qs}" }
-        return result
+           return result
+         end
       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
+      add_to_cache(qs, result) if @caching
+      result = [] if result == "timeout"
+      return result
+    end
 
-  # do the real work of executing the sparql query
+    # 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)}"
+      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
+          timeout(@timeout) do
+            open(url, header) do |f|
+              response = f.read
+            end
           end
-        end
-      when :post
+        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 
+          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
+                when :xml, :sparql_xml
       parse_xml(response, resource_type)
-    end
+                end
 
-    if block_given?
-      results.each do |*clauses|
-        yield(*clauses)
+      if block_given?
+        results.each do |*clauses|
+          yield(*clauses)
+        end
+      else
+        results
       end
-    else
-      results
     end
-  end
 
-  def close
-    ConnectionPool.remove_data_source(self)
-  end
+    def close
+      ConnectionPool.remove_data_source(self)
+    end
 
-  private
+    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 
+    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) 
+          @@sparql_cache.store(query_string, result)
+        end
       end
     end
-  end
 
 
-  def query_cache(query_string)
-    if @@sparql_cache.include?(query_string)
-      return @@sparql_cache.fetch(query_string)
-    else
-      return nil
+    def query_cache(query_string)
+      if @@sparql_cache.include?(query_string)
+        return @@sparql_cache.fetch(query_string)
+      else
+        return nil
+      end
     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
+    # 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
-  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'
+      require 'json'
 
-    parsed_object = JSON.parse(s)
-    return [] if parsed_object.nil?
+      parsed_object = JSON.parse(s)
+      return [] if parsed_object.nil?
 
-    results = []    
-    vars = parsed_object['head']['vars']
-    objects = parsed_object['results']['bindings']
+      results = []
+      vars = parsed_object['head']['vars']
+      objects = parsed_object['results']['bindings']
 
-    objects.each do |obj|
-      result = []
-      vars.each do |v|
+      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 << result
-    end
 
-    results
-  end
+      results
+    end
 
-  # parse xml stream result into array
+    # 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
+      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'
+      case type
+      when 'uri'
       resource_type.new(value)
-    when 'bnode'
-      BNode.new(value)
-    when 'literal','typed-literal'
-      value.to_s
+      when 'bnode'
+        BNode.new(value)
+      when 'literal','typed-literal'
+        value.to_s
+      end
     end
   end
-
-
-
-end
+end

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

@@ -9,7 +9,7 @@ class SparqlResultParser
     @current_type = nil
     @resource_type = resource_type
   end
-  
+
   def tag_start(name, attrs)
     case name
     when 'variable'
@@ -22,7 +22,7 @@ class SparqlResultParser
       @current_type = name
     end
   end
-  
+
   def tag_end(name)
     if name == "result"
       @result << @current_result
@@ -31,10 +31,10 @@ class SparqlResultParser
     elsif name == "sparql"
     end
   end
-  
+
   def text(text)
     if !@current_type.nil?
-      @current_result[@index] = create_node(@current_type, text)  
+      @current_result[@index] = create_node(@current_type, text)
     end
   end
 
@@ -49,7 +49,7 @@ class SparqlResultParser
       value.to_s
     end
   end
-  
+
   def method_missing (*args)
   end
 end

data/activerdf-sparql/test/test_sparql_adapter.rb

@@ -10,6 +10,8 @@ require 'queryengine/query'
 
 
 class TestSparqlAdapter < Test::Unit::TestCase
+  include ActiveRDF
+
   def setup
     ConnectionPool.clear
     @adapter = ConnectionPool.add(:type => :sparql, :url => 'http://dbpedia.org/sparql', :engine => :virtuoso)

data/activerdf-yars/lib/activerdf_yars/jars2.rb

@@ -9,111 +9,113 @@ require 'cgi'
 
 # Read-only adapter to jars2
 # (experimental YARS branch for SWSE engine)
-class Jars2Adapter < ActiveRdfAdapter
+module ActiveRDF
+  class Jars2Adapter < ActiveRdfAdapter
   ActiveRdfLogger::log_info "Loading Jars2 adapter", self
-  ConnectionPool.register_adapter(:jars2, self)
-
-  # initialises connection to jars2 datastore
-  # available parameters are:
-  # * :host (default 'm3pe.org')
-  # * :port (default 2020)
-  def initialize(params = {})
-    super()
-    @reads = true
-    @writes = false
-
-    @host = params[:host] || 'm3pe.org'
-    @port = params[:port] || 2020
+    ConnectionPool.register_adapter(:jars2, self)
+
+    # initialises connection to jars2 datastore
+    # available parameters are:
+    # * :host (default 'm3pe.org')
+    # * :port (default 2020)
+    def initialize(params = {})
+      super()
+      @reads = true
+      @writes = false
+
+      @host = params[:host] || 'm3pe.org'
+      @port = params[:port] || 2020
     ActiveRdfLogger::log_info(self) { "Initializing new instance with host: #{@host} port: #{@port}" }
-    @yars = Net::HTTP.new(@host, @port)
-  end
+      @yars = Net::HTTP.new(@host, @port)
+    end
 
-  def translate query
-    Query2Jars2.translate(query)
-  end
+    def translate query
+      Query2Jars2.translate(query)
+    end
 
-  # executes query on jars2 datastore
-  def query(query)
-    qs = Query2Jars2.translate(query)
-    header = { 'Accept' => 'application/rdf+n3' }
+    # executes query on jars2 datastore
+    def execute(query)
+      qs = Query2Jars2.translate(query)
+      header = { 'Accept' => 'application/rdf+n3' }
 
-    # querying Jars2, adding 'eyal' parameter to get all variable bindings in 
-    # the result
-    response = @yars.get("/?q=#{CGI.escape(qs)}&eyal", header)
+      # querying Jars2, adding 'eyal' parameter to get all variable bindings in
+      # the result
+      response = @yars.get("/?q=#{CGI.escape(qs)}&eyal", header)
 
     ActiveRdfLogger::log_debug(self) { "Jars2Adapter: query executed: #{qs}" }
 
-    # return empty array if no content
-    return [] if response.is_a?(Net::HTTPNoContent)
+      # return empty array if no content
+      return [] if response.is_a?(Net::HTTPNoContent)
 
-    # return false unless HTTP OK returned
-    return false unless response.is_a?(Net::HTTPOK)
+      # return false unless HTTP OK returned
+      return false unless response.is_a?(Net::HTTPOK)
 
-    # parse the result
-    results = parse_result(response.body, query)
+      # parse the result
+      results = parse_result(response.body, query)
 
-    # remove duplicates if asked for distinct results
-    if query.distinct?
-      final_results = results.uniq
-    else
-      final_results = results
-    end
+      # remove duplicates if asked for distinct results
+      if query.distinct?
+        final_results = results.uniq
+      else
+        final_results = results
+      end
 
     ActiveRdfLogger::log_debug_pp "Query returned %s", final_results if ActiveRdfLogger::log_level == Logger::DEBUG
-    final_results
-  end
+      final_results
+    end
 
-  private
-  Resource = /<[^>]*>/
-  Literal = /"[^"]*"/
-  Node = Regexp.union(Resource,Literal)
-
-  # parses Jars2 results into array of ActiveRDF objects
-  def parse_result(response, query)
-    # Jars2 responses contain one result per line
-    results = response.split("\n")
-
-    # the first line of the response contains the variable bindings of the 
-    # results: we look at that line to figure out which column contains the 
-    # data we are looking for (which is the variables mentioned in the select 
-    # clauses of the query
-    bindings = results[0].split(' ')
-
-    # array of found answers, will be filled by iterating over the results and 
-    # only including the requested (i.e. selected) clauses
-    answers = []
-
-    # we iterate over the real results, and extract the clauses that we're 
-    # looking for (i.e. the select clauses from the query)
-    results[1..-1].each do |result|
-
-      # scan row for occurence of nodes (either resources or literals)
-      row = result.scan(Node)
-
-      # for each select clause, we find its index, and add the value at that 
-      # location in the result row to our answer
-      row = query.select_clauses.collect do |clause|
-        clause_index = bindings.index(clause)
+    private
+    Resource = /<[^>]*>/
+    Literal = /"[^"]*"/
+    Node = Regexp.union(Resource,Literal)
+
+    # parses Jars2 results into array of ActiveRDF objects
+    def parse_result(response, query)
+      # Jars2 responses contain one result per line
+      results = response.split("\n")
+
+      # the first line of the response contains the variable bindings of the
+      # results: we look at that line to figure out which column contains the
+      # data we are looking for (which is the variables mentioned in the select
+      # clauses of the query
+      bindings = results[0].split(' ')
+
+      # array of found answers, will be filled by iterating over the results and
+      # only including the requested (i.e. selected) clauses
+      answers = []
+
+      # we iterate over the real results, and extract the clauses that we're
+      # looking for (i.e. the select clauses from the query)
+      results[1..-1].each do |result|
+
+        # scan row for occurence of nodes (either resources or literals)
+        row = result.scan(Node)
+
+        # for each select clause, we find its index, and add the value at that
+        # location in the result row to our answer
+        row = query.select_clauses.collect do |clause|
+          clause_index = bindings.index(clause)
         convert_into_activerdf(row[clause_index], query.resource_class)
+        end
+        answers << row
       end
-      answers << row
-    end
 
-    answers
-  end
+      answers
+    end
 
   # converts ntriples serialisation of resource or literal into ActiveRDF object.
   #
   # resource_type is the class to be used for "resource" objects.
   def convert_into_activerdf(string, resource_type)
-    case string
-    when /<(.*)>/
-      # <http://foaf/Person> is a resource
+      case string
+      when /<(.*)>/
+        # <http://foaf/Person> is a resource
       resource_type.new($1)
-    when /"(.*)"/
-      # "30" is a literal
-      # TODO: handle datatypes
-      String.new($1)
+      when /"(.*)"/
+        # "30" is a literal
+        # TODO: handle datatypes
+        String.new($1)
+      end
     end
   end
-end
+end