rdf-virtuoso 0.0.11

data/lib/active_rdf/reflections.rb

@@ -0,0 +1,19 @@
+require 'active_rdf/association_reflection'
+
+module ActiveRDF
+  module Reflections
+    # Returns a hash containing all AssociationReflection objects for the current class
+    # Example:
+    #
+    #   Invoice.reflections
+    #   Account.reflections
+    #
+    def reflections
+      read_inheritable_attribute(:reflections) || write_inheritable_attribute(:reflections, {})
+    end
+
+    def reflect_on_association(association)
+      reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+    end
+  end    
+end

data/lib/active_rdf/version.rb

@@ -0,0 +1,10 @@
+module ActiveRDF
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 10
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
+end

data/lib/rdf/virtuoso.rb

@@ -0,0 +1,8 @@
+module RDF
+  module Virtuoso
+    autoload :Repository,  'rdf/virtuoso/repository'
+    autoload :Query,       'rdf/virtuoso/query'
+    autoload :Prefixes,    'rdf/virtuoso/prefixes'
+    autoload :Parser,      'rdf/virtuoso/parser'
+  end
+end

data/lib/rdf/virtuoso/parser.rb

@@ -0,0 +1,42 @@
+module RDF
+  module Virtuoso
+    module Parser
+      class JSON
+
+        def self.call(response)
+          parse_json_bindings(response)
+        end
+
+        def self.parse_json_bindings(response)
+          case
+          when response['boolean']
+            response['boolean']
+          when response['results']
+            solutions = response['results']['bindings'].map do |row|
+              row = row.inject({}) do |cols, (name, value)|
+                cols.merge(name.to_sym => parse_json_value(value))
+              end
+              RDF::Query::Solution.new(row)
+            end
+            RDF::Query::Solutions.new(solutions)
+          end
+        end
+
+        def self.parse_json_value(value, nodes = {})
+          case value['type'].to_sym
+          when :bnode
+            nodes[id = value['value']] ||= RDF::Node.new(id)
+          when :uri
+            RDF::URI.new(value['value'])
+          when :literal
+            RDF::Literal.new(value['value'], :language => value['xml:lang'])
+          when :'typed-literal'
+            RDF::Literal.new(value['value'], :datatype => value['datatype'])
+          else nil
+          end
+        end    
+
+      end
+    end
+  end
+end

data/lib/rdf/virtuoso/prefixes.rb

@@ -0,0 +1,54 @@
+module RDF::Virtuoso
+  require 'uri'
+
+  class UnProcessable; end
+  class Prefixes
+
+    PREFIXES = {
+      dc:    'http://purl.org/dc/terms/',
+      bibo:  'http://purl.org/ontology/bibo/',
+      fabio: 'http://purl.org/spar/fabio/',
+      rev:   'http://purl.org/stuff/rev#',
+      foaf:  'http://xmlns.com/foaf/0.1/',
+      lang:  'http://lexvo.org/id/iso639-3/'
+    }
+
+    class << self
+      def parse(uri_or_array)
+        prefixes = case uri_or_array
+                   when String then [uri_or_array]
+                   when Array  then uri_or_array
+                   else return UnProcessable.new
+                   end
+        result = Set.new
+        prefixes.each do |prefix|
+          uri = URI(prefix)
+          str = ""
+          str << uri.host.split('.')[-2]
+          /^(?<iri>.*[\/|#]).+$/ =~ uri.to_s
+          str << ": <%s>" % iri
+          result << str
+        end
+        result.to_a
+      end
+    end
+
+    def initialize(prefixes={})
+      @prefixes = prefixes
+    end
+
+    def to_a
+      ary = []
+      @prefixes.each_pair do |key, value|
+        ary << "#{key}: <#{value}>"
+      end
+      ary
+    end
+
+    def to_s
+      @prefixes.inspect
+    end
+
+  end
+
+end

data/lib/rdf/virtuoso/query.rb

@@ -0,0 +1,632 @@
+module RDF::Virtuoso
+
+  ##
+  # A SPARQL query builder.
+  #
+  # @example Iterating over all found solutions
+  #   query.each_solution { |solution| puts solution.inspect }
+  #
+  class Query < RDF::Query
+    ##
+    # @return [Symbol]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#QueryForms
+    attr_reader :form
+
+    ##
+    # @return [Hash{Symbol => Object}]
+    attr_reader :options
+
+    ##
+    # @return [Array<[key, RDF::Value]>]
+    attr_reader :values
+
+
+    attr_reader :data_values
+
+    ##
+    # Creates a boolean `ASK` query.
+    #
+    # @param  [Hash{Symbol => Object}] options
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#ask
+    def self.ask(options = {})
+      self.new(:ask, options)
+    end
+
+    ##
+    # Creates a tuple `SELECT` query.
+    #
+    # @param  [Array<Symbol>]          variables
+    # @param  [Hash{Symbol => Object}] options
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#select
+    def self.select(*variables)
+      options = variables.last.is_a?(Hash) ? variables.pop : {}
+      self.new(:select, options).select(*variables)
+    end
+
+    ##
+    # Creates a `DESCRIBE` query.
+    #
+    # @param  [Array<Symbol, RDF::URI>] variables
+    # @param  [Hash{Symbol => Object}]  options
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#describe
+    def self.describe(*variables)
+      options = variables.last.is_a?(Hash) ? variables.pop : {}
+      self.new(:describe, options).describe(*variables)
+    end
+
+    ##
+    # Creates a graph `CONSTRUCT` query.
+    #
+    # @param  [Array<RDF::Query::Pattern, Array>] patterns
+    # @param  [Hash{Symbol => Object}]            options
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#construct
+    def self.construct(*patterns)
+      options = patterns.last.is_a?(Hash) ? patterns.pop : {}
+      self.new(:construct, options).construct(*patterns) # FIXME
+    end
+
+    ##
+    # Creates an `UPDATE` query.
+    #
+    # @param  [Array<RDF::Query::Pattern, Array>] patterns
+    # @param  [Hash{Symbol => Object}]            options
+    # @return [Query]
+    # @see    http://www.w3.org/Submission/SPARQL-Update/
+    def self.insert_data(*patterns)
+      # options = variables.last.is_a?(Hash) ? variables.pop : {}
+      options = patterns.last.is_a?(Hash) ? patterns.pop : {}
+      self.new(:insert_data, options).insert_data(*patterns) 
+    end
+
+    def self.insert(*patterns)
+      # options = variables.last.is_a?(Hash) ? variables.pop : {}
+      options = patterns.last.is_a?(Hash) ? patterns.pop : {}
+      self.new(:insert, options).insert(*patterns) 
+    end
+
+    def self.delete_data(*patterns)
+      options = patterns.last.is_a?(Hash) ? patterns.pop : {}
+      self.new(:delete_data, options).delete_data(*patterns)
+    end
+
+    def self.delete(*patterns)
+      options = patterns.last.is_a?(Hash) ? patterns.pop : {}
+      self.new(:delete, options).delete(*patterns) 
+    end
+    
+    def self.create(*variables)
+      options = variables.last.is_a?(Hash) ? variables.pop : {}
+      self.new(:create, options).create(variables.first)
+    end
+
+    def self.drop(*variables)
+      options = variables.last.is_a?(Hash) ? variables.pop : {}
+      self.new(:drop, options).drop(variables.first)
+    end
+
+    def self.clear(*variables)
+      options = variables.last.is_a?(Hash) ? variables.pop : {}
+      self.new(:clear, options).clear(variables.first)
+    end
+
+    ##
+    # @param  [Symbol, #to_s]          form
+    # @param  [Hash{Symbol => Object}] options
+    # @yield  [query]
+    # @yieldparam [Query]
+    def initialize(form = :ask, options = {}, &block)
+      @form = form.respond_to?(:to_sym) ? form.to_sym : form.to_s.to_sym
+      super([], options, &block)
+    end
+
+    ##
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#ask
+    def ask
+      @form = :ask
+      self
+    end
+
+    ##
+    # @param  [Array<Symbol>] variables
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#select
+    def select(*variables)
+      @values = variables.map { |var| [var, RDF::Query::Variable.new(var)] }
+      self
+    end
+
+    ##
+    # @param  [Array<Symbol>] variables
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#describe
+    def describe(*variables)
+      @values = variables.map { |var|
+        [var, var.is_a?(RDF::URI) ? var : RDF::Query::Variable.new(var)]
+      }
+      self
+    end
+
+    ##
+    # @param  [Array<RDF::Query::Pattern, Array>] patterns
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#construct
+    def construct(*patterns)
+      new_patterns = []
+      patterns.each do |pattern|
+        new_patterns << pattern.map do |value|
+          if value.is_a?(Symbol)
+            value = RDF::Query::Variable.new(value)
+          elsif value.is_a?(RDF::URI) 
+            value = value
+          else
+            value = RDF::Literal.new(value)
+          end
+        end
+      end
+      @data_values = build_patterns(new_patterns)
+      self
+    end
+
+
+    ##
+    # @param  [Array<RDF::Query::Pattern, Array>] patterns
+    # @return [Query]
+    # @see    http://www.w3.org/Submission/SPARQL-Update/
+    def insert_data(*patterns)
+      new_patterns = []
+      patterns.each do |values|
+        new_patterns << values.map { |var| [var, var.is_a?(RDF::URI) ? var : var] }
+      end
+      @data_values = new_patterns #build_patterns(new_patterns)
+      self
+    end
+
+    def insert(*patterns)
+      new_patterns = []
+      patterns.each do |pattern|
+        new_patterns << pattern.map do |value|
+          if value.is_a?(Symbol)
+            value = RDF::Query::Variable.new(value)
+          elsif value.is_a?(RDF::URI) 
+            value = value
+          else
+            value = RDF::Literal.new(value)
+          end
+        end
+      end
+      @data_values = build_patterns(new_patterns)
+      self
+    end
+    
+    def delete_data(*patterns)
+      new_patterns = []
+      patterns.each do |values|
+        new_patterns << values.map { |var| [var, var.is_a?(RDF::URI) ? var : var] }
+      end
+      @data_values = new_patterns #build_patterns(new_patterns)
+      self
+    end
+
+    def delete(*patterns)
+      new_patterns = []
+      patterns.each do |pattern|
+        new_patterns << pattern.map do |value|
+          if value.is_a?(Symbol)
+            value = RDF::Query::Variable.new(value)
+          elsif value.is_a?(RDF::URI) 
+            value = value
+          else
+            value = RDF::Literal.new(value)
+          end
+        end
+      end
+      @data_values = build_patterns(new_patterns)
+      self
+    end
+    
+#    def delete(*variables)
+#      @values = variables.map { |var|
+#        [var, var.is_a?(RDF::URI) ? var : RDF::Query::Variable.new(var)]
+#      }
+#      self
+#    end
+
+    def create(uri)
+      options[:graph] = uri
+      self
+    end
+
+    def drop(uri)
+      options[:graph] = uri
+      self
+    end
+
+    def clear(uri)
+      options[:graph] = uri
+      self
+    end
+
+    # @param RDF::URI uri
+    # @return [Query]
+    # @see http://www.w3.org/TR/rdf-sparql-query/#specDataset
+    def from(uri)
+      options[:from] = uri
+      self
+    end
+
+    # @param RDF::URI uri
+    # @return [Query]
+    def graph(uri)
+      options[:graph] = uri
+      self
+    end
+
+    ##
+    # @param  [Array<RDF::Query::Pattern, Array>] patterns
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#GraphPattern
+    def where(*patterns)
+      @patterns += build_patterns(patterns)
+      self
+    end
+
+    alias_method :whether, :where
+
+    ##
+    # @param  [Array<Symbol, String>] variables
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#modOrderBy
+    def order(*variables)
+      options[:order_by] = variables
+      self
+    end
+
+    alias_method :order_by, :order
+
+    ##
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#modDistinct
+    def distinct(state = true)
+      options[:distinct] = state
+      self
+    end
+
+    ##
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#modReduced
+    def reduced(state = true)
+      options[:reduced] = state
+      self
+    end
+    
+    ## SPARQL 1.1 Aggregates
+    # @return [Query]
+    # @see    http://www.w3.org/TR/sparql11-query/#defn_aggCount
+   # def count(*variables)
+   #   options[:count] = variables
+   #   self
+   # end
+    AGG_METHODS  = %w(count min max sum avg sample group_concat group_digest)
+    
+    AGG_METHODS.each do |m|
+      define_method m do |*variables|
+        options[m.to_sym] = variables
+        self
+      end
+    end
+          
+    ##
+    # @param  [Integer, #to_i] start
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#modOffset
+    def offset(start)
+      slice(start, nil)
+    end
+
+    ##
+    # @param  [Integer, #to_i] length
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#modResultLimit
+    def limit(length)
+      slice(nil, length)
+    end
+
+    ##
+    # @param  [Integer, #to_i] start
+    # @param  [Integer, #to_i] length
+    # @return [Query]
+    def slice(start, length)
+      options[:offset] = start.to_i if start
+      options[:limit] = length.to_i if length
+      self
+    end
+
+    ##
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#prefNames
+    def prefix(string)
+      (options[:prefixes] ||= []) << string
+      self
+    end
+
+    ##
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#prefNames
+    def prefixes(prefixes = nil)
+      options[:prefixes] ||= []
+      options[:prefixes] += prefixes.to_a
+      self
+    end
+
+    ##
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#optionals
+    def optional(*patterns)
+      (options[:optionals] ||= []) << build_patterns(patterns)
+      self
+    end
+
+    ##
+    # @return [Query]
+    # @see    http://www.w3.org/TR/rdf-sparql-query/#minus
+    def minus(*patterns)
+      (options[:minuses] ||= []) << build_patterns(patterns)
+      self
+    end
+    
+    def union(*patterns)
+      (options[:unions] ||= []) << build_patterns(patterns)
+      self
+    end
+
+    ##
+    # @private
+    def build_patterns(patterns)
+      patterns.map do |pattern|
+        case pattern
+        when RDF::Query::Pattern then pattern
+        else RDF::Query::Pattern.new(*pattern.to_a)
+        end
+      end
+    end
+
+    ##
+    # @private
+    def filter(string)
+      (options[:filters] ||= []) << string
+      self
+    end
+
+    def filters(filters = nil)
+      options[:filters] ||= []
+      options[:filters] += filters.to_a
+      self
+    end
+    
+    ##
+    # @return [Boolean]
+    def true?
+      case result
+      when TrueClass, FalseClass then result
+      when Enumerable then !result.empty?
+      else false
+      end
+    end
+
+    ##
+    # @return [Boolean]
+    def false?
+      !true?
+    end
+
+    ##
+    # @return [Enumerable<RDF::Query::Solution>]
+    def solutions
+      result
+    end
+
+    ##
+    # @yield  [statement]
+    # @yieldparam [RDF::Statement]
+    # @return [Enumerator]
+    def each_statement(&block)
+      result.each_statement(&block)
+    end
+
+    ##
+    # @return [Object]
+    def result
+      @result ||= execute
+    end
+
+    ##
+    # @return [Object]
+    def execute
+      #query
+      #raise NotImplementedError
+    end
+
+    ##
+    # Returns the string representation of this query.
+    #
+    # @return [String]
+    def to_s
+      buffer = [form.to_s.gsub('_', ' ').upcase]
+      case form
+      when :select, :describe
+        buffer << 'DISTINCT' if options[:distinct]
+        buffer << 'REDUCED'  if options[:reduced]
+        # Aggregates in select/describe
+        aggregates = [:count, :min, :max, :avg, :sum, :sample, :group_concat, :group_digest]
+        if (options.keys & aggregates).any?
+          (options.keys & aggregates).each do |agg|
+            case agg
+            when :sample
+              buffer << '(sql:' + agg.to_s.upcase
+              buffer << options[agg].map { |var| var.is_a?(String) ? var : "(?#{var})" }
+            when :group_concat, :group_digest
+              buffer << '(sql:' + agg.to_s.upcase
+              buffer << options[agg].map { |var| var.is_a?(Symbol) ? "(?#{var}" : "'#{var}'"}.join(', ')
+              buffer << ')'
+            else  
+              buffer << '(' + agg.to_s.gsub('_', ' ').upcase
+              buffer << options[agg].map { |var| var.is_a?(String) ? var : "(?#{var})" }
+            end
+            
+            buffer << 'AS ?' + agg.to_s + ')'
+          end
+        else
+          buffer << (values.empty? ? '*' : values.map { |v| serialize_value(v[1]) }.join(' '))
+        end
+      when :construct
+        buffer << '{'
+        buffer += serialize_patterns(@data_values)
+        buffer << '}'
+        
+        # for virtuoso inserts
+      when :insert_data
+        buffer << "INTO GRAPH #{serialize_value(options[:graph])}" if options[:graph]
+        buffer << '{'
+        @data_values.each do |triple|
+          if triple.first.first.is_a?(RDF::Statement)
+            buffer << triple.map { |v| serialize_value(v[1])}
+          else
+            buffer << triple.map { |v| serialize_value(v[1])}.join(' ') + " ."
+          end
+        end
+        buffer << '}'          
+        
+      when :insert
+        buffer << "INTO GRAPH #{serialize_value(options[:graph])}" if options[:graph]
+        # buffer += serialize_patterns(options[:template])
+        # (@data_values.map { |v| puts v[1].inspect; puts 'xxx ' } )
+        buffer << '{'
+        buffer += serialize_patterns(@data_values)
+        buffer << '}'          
+        
+      when :delete_data
+        buffer << "FROM #{serialize_value(options[:graph])}" #if options[:graph]
+        buffer << '{'
+        @data_values.each do |triple|
+          if triple.first.first.is_a?(RDF::Statement)
+            buffer << triple.map { |v| serialize_value(v[1])}
+          else
+            buffer << triple.map { |v| serialize_value(v[1])}.join(' ') + " ."
+          end
+        end
+        buffer << '}'          
+
+      when :delete
+        buffer << "FROM #{serialize_value(options[:graph])}" if options[:graph]
+        buffer << '{'
+        buffer += serialize_patterns(@data_values)
+        buffer << '}'           
+
+      when :create, :drop
+        buffer << 'SILENT' if options[:silent]
+        buffer << "GRAPH #{serialize_value(options[:graph])}"
+
+      when :clear
+        buffer << "GRAPH #{serialize_value(options[:graph])}"
+
+      end
+
+      buffer << "FROM #{serialize_value(options[:from])}" if options[:from]
+
+      unless patterns.empty? && ([:describe, :insert_data, :delete_data, :create, :clear, :drop].include?(form))
+        buffer << 'WHERE {'
+
+        buffer << '{' if options[:unions]
+
+        buffer += serialize_patterns(patterns)
+        if options[:optionals]
+          options[:optionals].each do |patterns|
+            buffer << 'OPTIONAL {'
+            buffer += serialize_patterns(patterns)
+            buffer << '}'
+          end
+        end
+
+        if options[:minuses]
+          options[:minuses].each do |patterns|
+            buffer << 'MINUS {'
+            buffer += serialize_patterns(patterns)
+            buffer << '}'
+          end
+        end
+                
+        if options[:filters]
+          buffer += options[:filters].map { |filter| "FILTER(#{filter})" }
+        end
+        buffer << '}'
+
+        if options[:unions]
+          options[:unions].each do |patterns|
+            buffer << 'UNION {'
+            buffer += serialize_patterns(patterns)
+            buffer << '}'
+          end
+          buffer << '}'
+        end
+
+      end
+
+      if options[:order_by]
+        buffer << 'ORDER BY'
+        buffer += options[:order_by].map { |var| var.is_a?(String) ? var : "?#{var}" }
+      end
+
+      buffer << "OFFSET #{options[:offset]}" if options[:offset]
+      buffer << "LIMIT #{options[:limit]}"   if options[:limit]
+      options[:prefixes].reverse.each {|e| buffer.unshift("PREFIX #{e}") } if options[:prefixes]
+
+      buffer.join(' ')
+    end
+
+    ##
+    # @private
+    def serialize_patterns(patterns)
+      patterns.map do |p|
+        p.to_triple.map { |v| serialize_value(v) }.join(' ') << " ."
+      end
+    end
+
+    ##
+    # Outputs a developer-friendly representation of this query to `stderr`.
+    #
+    # @return [void]
+    def inspect!
+      warn(inspect)
+      self
+    end
+
+    ##
+    # Returns a developer-friendly representation of this query.
+    #
+    # @return [String]
+    def inspect
+      sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, to_s)
+    end
+
+    ##
+    # Serializes an RDF::Value into a format appropriate for select, construct, and where clauses
+    #
+    # @param  [RDF::Value]
+    # @return [String]
+    # @private
+    def serialize_value(value)
+      # SPARQL queries are UTF-8, but support ASCII-style Unicode escapes, so
+      # the N-Triples serializer is fine unless it's a variable:
+      case
+        when value.is_a?(String) then value.inspect
+        when value.variable? then value.to_s
+        else RDF::NTriples.serialize(value)
+      end
+    end
+  end
+end