rdf-virtuoso 0.1.3 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 222f972acee18d8fad63ec6b94becb2e2445223e50d0acf316e699b7e2b94907
+  data.tar.gz: 020ff0b1c11585f10499276d44b34807543a456714fa9933f87634e26cd9d57c
+SHA512:
+  metadata.gz: 75ebb9442251821a9ca108471de85da3b7f24d3b447ebc7502052da32f31fe74e424cd054883ff76ed3fb5b09d3d882f3c18dbdf647fafc30b5ede72cea6ce37
+  data.tar.gz: 88fbf45edf0705530d76b935db348131e5c9beb3656bf7fe22837b6af47fd4d99ae0804e677c1eb8655b54e5aeec7fd9807bc96fafcbded938bbfc07334bbe0f

data/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <https://unlicense.org/>

data/README.md

@@ -1,9 +1,14 @@
 # rdf-virtuoso: Ruby Virtuoso adapter for RDF.rb
+
 The intent of this class is to act as an abstraction for clients wishing to connect and manipulate linked data stored in a Virtuoso Quad store.
 
+[![Gem Version](https://badge.fury.io/rb/rdf-virtuoso.png)](https://badge.fury.io/rb/rdf-virtuoso)
+[![Build Status](https://github.com/ruby-rdf/rdf-virtuoso/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/rdf-virtuoso/actions?query=workflow%3ACI)
+[![Gitter chat](https://badges.gitter.im/ruby-rdf/rdf.png)](https://gitter.im/ruby-rdf/rdf)
+
 ## How?
-RDF::Virtuoso::Repository subclasses RDF::Repository built on RDF.rb and is the main connection class built on top of APISmith to establish the read and write methods to a Virtuoso store SPARQL endpoint.
-RDF::Virtuoso::Query subclasses RDF::Query and adds SPARQL 1.1. update methods (insert, delete, aggregates, etc.).
+`RDF::Virtuoso::Repository` subclasses `RDF::Repository` built on [RDF.rb][] and is the main connection class built on top of APISmith to establish the read and write methods to a Virtuoso store SPARQL endpoint.
+`RDF::Virtuoso::Query` subclasses `RDF::Query` and adds SPARQL 1.1. update methods (insert, delete, aggregates, etc.).
 
 For examples on use, please read:
      ./spec/repository_spec.rb 
@@ -19,10 +24,10 @@ This example assumes you have a local installation of Virtoso running at standar
     uri        = "http://localhost:8890/sparql"
     update_uri = "http://localhost:8890/sparql-auth"
     repo       = RDF::Virtuoso::Repository.new(uri, 
-                    :update_uri => update_uri, 
-                    :username => 'admin', 
-                    :password => 'secret', 
-                    :auth_method => 'digest')
+                    update_uri: update_uri, 
+                    username: 'admin', 
+                    password: 'secret', 
+                    auth_method: 'digest')
 
 :auth_method can be 'digest' or 'basic'. a repository connection without auth requires only uri
 
@@ -64,3 +69,30 @@ or you can dynamically add RDF::Vocabulary objects
 Results will be an array of RDF::Query::Solution that can be accessed by bindings or iterated
 
     count = result.first[:count].to_i
+
+## Contributing
+
+This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange development and release activity. All submissions _must_ be on a feature branch based on the _develop_ branch to ease staging and integration.
+
+* Do your best to adhere to the existing coding conventions and idioms.
+* Don't use hard tabs, and don't leave trailing whitespace on any line.
+  Before committing, run `git diff --check` to make sure of this.
+* Do document every method you add using [YARD][] annotations. Read the
+  [tutorial][YARD-GS] or just look at the existing code for examples.
+* Don't touch the `.gemspec` or `VERSION` files. If you need to change them,
+  do so on your private branch only.
+* Do note that in order for us to merge any non-trivial changes (as a rule
+  of thumb, additions larger than about 15 lines of code), we need an
+  explicit [public domain dedication][PDD] on record from you,
+  which you will be asked to agree to on the first commit to a repo within the organization.
+  Note that the agreement applies to all repos in the [Ruby RDF](https://github.com/ruby-rdf/) organization.
+
+## License
+
+This is free and unencumbered public domain software. For more information,
+see <https://unlicense.org/> or the accompanying {file:LICENSE} file.
+
+[PDD]:              https://unlicense.org/#unlicensing-contributions
+[YARD]:             https://yardoc.org/
+[YARD-GS]:          https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[RDF.rb]:       https://rubydoc.info/github/ruby-rdf/rdf

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/rdf/virtuoso.rb

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

data/lib/rdf/virtuoso/parser.rb

@@ -29,9 +29,9 @@ module RDF
           when :uri
             RDF::URI.new(value['value'])
           when :literal
-            RDF::Literal.new(value['value'], :language => value['xml:lang'])
+            RDF::Literal.new(value['value'], language: value['xml:lang'])
           when :'typed-literal'
-            RDF::Literal.new(value['value'], :datatype => value['datatype'])
+            RDF::Literal.new(value['value'], datatype: value['datatype'])
           else nil
           end
         end    

data/lib/rdf/virtuoso/query.rb

@@ -29,8 +29,8 @@ module RDF::Virtuoso
     # @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)
+    def self.ask(**options)
+      self.new(:ask, **options)
     end
 
     ##
@@ -40,9 +40,8 @@ module RDF::Virtuoso
     # @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)
+    def self.select(*variables, **options)
+      self.new(:select, **options).select(*variables)
     end
 
     ##
@@ -52,9 +51,8 @@ module RDF::Virtuoso
     # @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)
+    def self.describe(*variables, **options)
+      self.new(:describe, **options).describe(*variables)
     end
 
     ##
@@ -64,9 +62,8 @@ module RDF::Virtuoso
     # @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
+    def self.construct(*patterns, **options)
+      self.new(:construct, **options).construct(*patterns) # FIXME
     end
 
     ##
@@ -76,40 +73,32 @@ module RDF::Virtuoso
     # @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) 
+    def self.insert_data(*patterns, **options)
+      self.new(:insert_data, **options).insert_data(*patterns) 
     end
 
-    def self.insert(*patterns)
-      options = patterns.last.is_a?(Hash) ? patterns.pop : {}
-      self.new(:insert, options).insert(*patterns) 
+    def self.insert(*patterns, **options)
+      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)
+    def self.delete_data(*patterns, **options)
+      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) 
+    def self.delete(*patterns, **options)
+      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)
+    def self.create(*variables, **options)
+      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)
+    def self.drop(*variables, **options)
+      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)
+    def self.clear(*variables, **options)
+      self.new(:clear, **options).clear(variables.first)
     end
 
     ##
@@ -117,9 +106,9 @@ module RDF::Virtuoso
     # @param  [Hash{Symbol => Object}] options
     # @yield  [query]
     # @yieldparam [Query]
-    def initialize(form = :ask, options = {}, &block)
+    def initialize(form = :ask, **options, &block)
       @form = form.respond_to?(:to_sym) ? form.to_sym : form.to_s.to_sym
-      super([], options, &block)
+      super([], **options, &block)
     end
 
     ##
@@ -228,13 +217,6 @@ module RDF::Virtuoso
       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
@@ -271,8 +253,6 @@ module RDF::Virtuoso
     def from_named(uri)
       (options[:from_named] ||= []) << uri
       self
-      #options[:from_named] = uri
-      #self
     end
 
     # @param RDF::URI uri
@@ -350,7 +330,6 @@ module RDF::Virtuoso
     
     AGG_METHODS.each do |m|
       define_method m do |*variables|
-        #options[m.to_sym] = variables
         options[m.to_sym] ||= []
         options[m.to_sym] += variables
         self
@@ -424,7 +403,7 @@ module RDF::Virtuoso
     ##
     # @private 
     # make RDF::Query::Pattern from triple array if not already done
-    # include :context in Statement
+    # include :graph_name in Statement
     # @return [RDF::Query::Pattern]
     def build_patterns(patterns)
       patterns.map do |pattern|
@@ -486,10 +465,10 @@ module RDF::Virtuoso
 
     ##
     # @return [Object]
-    def execute
+    # def execute
       #query
       #raise NotImplementedError
-    end
+    # end
 
     ##
     # Returns the string representation of this query.
@@ -507,7 +486,6 @@ module RDF::Virtuoso
         aggregates = [:count, :min, :max, :avg, :sum, :sample, :group_concat, :group_digest]
         if (options.keys & aggregates).any?
           (options.keys & aggregates).each do |agg|
-#p options[agg]
             case agg
             when :sample
               # multiple samples splits to individual sample expressions
@@ -614,10 +592,10 @@ module RDF::Virtuoso
         buffer << '{' if options[:unions]
 
         # iterate patterns
-        # does patterns have :context hash? build with GRAPH statement
+        # does patterns have :graph_name hash? build with GRAPH statement
         patterns.each do | pattern|
-          if pattern.context
-            buffer << "GRAPH #{serialize_value(RDF::URI(pattern.context))}"
+          if pattern.graph_name
+            buffer << "GRAPH #{serialize_value(RDF::URI(pattern.graph_name))}"
             buffer << '{'
             buffer << serialize_patterns(pattern)
             buffer << '}'
@@ -631,8 +609,8 @@ module RDF::Virtuoso
             buffer << 'OPTIONAL {'
 
 	        patterns.each do | pattern|
-          if pattern.context
-            buffer << "GRAPH #{serialize_value(RDF::URI(pattern.context))}"
+          if pattern.graph_name
+            buffer << "GRAPH #{serialize_value(RDF::URI(pattern.graph_name))}"
             buffer << '{'
             buffer << serialize_patterns(pattern)
             buffer << '}'
@@ -650,8 +628,8 @@ module RDF::Virtuoso
             buffer << 'MINUS {'
 
 	        patterns.each do | pattern|
-          if pattern.context
-            buffer << "GRAPH #{serialize_value(RDF::URI(pattern.context))}"
+          if pattern.graph_name
+            buffer << "GRAPH #{serialize_value(RDF::URI(pattern.graph_name))}"
             buffer << '{'
             buffer << serialize_patterns(pattern)
             buffer << '}'

data/lib/rdf/virtuoso/repository.rb

@@ -1,10 +1,11 @@
 require 'api_smith'
 require 'rdf'
 require 'uri'
+require 'timeout'
 
 module RDF
   module Virtuoso
-    class Repository < RDF::Repository
+    class Repository < ::RDF::Repository
       include APISmith::Client
 
       RESULT_JSON = 'application/sparql-results+json'.freeze
@@ -19,28 +20,28 @@ module RDF
       class NotAuthorized < ClientError; end
       class ServerError < StandardError; end
 
-      # TODO: Look at issues with HTTParty Connection reset
       #persistent
       maintain_method_across_redirects true
 
       attr_reader :uri, :update_uri, :username, :password, :auth_method
 
-      def initialize(uri, opts={})
+      def initialize(uri, opts={}, &block)
         @uri             = URI.parse(uri)
         @update_uri      = URI.parse(opts[:update_uri]) if opts[:update_uri]
         @base_uri        = "#{@uri.scheme}://#{@uri.host}"
         @base_uri       += ":" + @uri.port.to_s if @uri.port
-        @username        = opts[:username]    || nil 
+        @username        = opts[:username]    || nil
         @password        = opts[:password]    || nil
         @auth_method     = opts[:auth_method] || 'digest'
+        @timeout         = opts[:timeout]     || 5 # default timeout 5 seconds
 
         @sparql_endpoint = @uri.request_uri
         @sparul_endpoint = @update_uri.nil? ? @sparql_endpoint : @update_uri.request_uri
         self.class.base_uri @base_uri
       end
 
-      READ_METHODS  = %w(select ask construct describe)
-      WRITE_METHODS = %w(query insert insert_data update delete delete_data create drop clear)
+      READ_METHODS  = %w(query select ask construct describe)
+      WRITE_METHODS = %w(insert insert_data update delete delete_data create drop clear)
 
       READ_METHODS.each do |m|
         define_method m do |*args|
@@ -53,7 +54,7 @@ module RDF
           response = api_post *args
         end
       end
-
+      
       private
 
       def check_response_errors(response)
@@ -72,46 +73,53 @@ module RDF
       end
 
       def base_query_options
-        { :format => 'json' }
+        { format: RESULT_JSON }
       end
 
       def base_request_options
-        { :headers => headers }
+        { headers: headers }
       end
 
       def extra_request_options
         case @auth_method
         when 'basic'
-          { :basic_auth => auth }
+          { basic_auth: auth }
         when 'digest'
-          { :digest_auth => auth }
+          { digest_auth: auth }
         end
       end
-      
+
       def auth
-        { :username => @username, :password => @password }
+        { username: @username, password: @password }
       end
-      
+
       def api_get(query, options = {})
         # prefer sparul endpoint with auth if present to allow SELECT/CONSTRUCT access to protected graphs
         if @sparul_endpoint
           self.class.endpoint @sparul_endpoint
-          get '/', :extra_query => { :query => query }.merge(options),
-                   :extra_request => extra_request_options,
-                   :transform => RDF::Virtuoso::Parser::JSON
+          Timeout::timeout(@timeout) {
+            get '/', extra_query: { query: query }.merge(options),
+                     extra_request: extra_request_options,
+                     transform: RDF::Virtuoso::Parser::JSON
+          }
         else
           self.class.endpoint @sparql_endpoint
-          get '/', :extra_query => { :query => query }.merge(options), 
-                   :transform => RDF::Virtuoso::Parser::JSON
+          Timeout::timeout(@timeout) {
+          puts self.inspect
+            get '/', extra_query: { query: query }.merge(options),
+                     transform: RDF::Virtuoso::Parser::JSON
+          }
         end
       end
 
       def api_post(query, options = {})
         self.class.endpoint @sparul_endpoint
-        post '/', :extra_body => { :query => query }.merge(options), 
-                  :extra_request => extra_request_options,
-                  :response_container => [
-                    "results", "bindings", 0, "callret-0", "value"]
+        Timeout::timeout(@timeout) {
+          post '/', extra_body: { query: query }.merge(options),
+                    extra_request: extra_request_options,
+                    response_container: [
+                      "results", "bindings", 0, "callret-0", "value"]
+        }
       end
 
     end

data/lib/rdf/virtuoso/version.rb

@@ -1,5 +1,18 @@
-module RDF
-  module Virtuoso
-    VERSION = "0.1.3"
-  end
+module RDF::Virtuoso::VERSION
+  VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
+  MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chop.split(".")
+
+  STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+  ##
+  # @return [String]
+  def self.to_s()   STRING end
+
+  ##
+  # @return [String]
+  def self.to_str() STRING end
+
+  ##
+  # @return [Array(Integer, Integer, Integer)]
+  def self.to_a() STRING.split(".") end
 end

metadata

@@ -1,137 +1,138 @@
 --- !ruby/object:Gem::Specification
 name: rdf-virtuoso
 version: !ruby/object:Gem::Version
-  version: 0.1.3
-  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors:
 - Benjamin Rokseth
 - Peter Kordel
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-03-06 00:00:00.000000000 Z
+date: 2021-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rdf
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.13.0
-  type: :development
+        version: '3.1'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.13.0
+        version: '3.1'
 - !ruby/object:Gem::Dependency
-  name: rdf-spec
+  name: httparty
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :development
+        version: 0.18.1
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 0.18.1
 - !ruby/object:Gem::Dependency
-  name: rdf
+  name: api_smith
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.3
+        version: 1.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.3
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
-  name: httparty
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.2
-  type: :runtime
+        version: '3.10'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.2
+        version: '3.10'
 - !ruby/object:Gem::Dependency
-  name: api_smith
+  name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
-  type: :runtime
+        version: '3.1'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rdf-vocab
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
-description: An RDF.rb extension library for interacting with a Virtuoso rdf store
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: An RDF.rb extension library for interacting with a Virtuoso rdf store.\nSupports
+  SPARQL 1.1 UPDATE extensions and some Virtuoso specific commands.
 email:
 - benjamin.rokseth@kul.oslo.kommune.no
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
+- VERSION
 - lib/rdf/virtuoso.rb
-- lib/rdf/virtuoso/version.rb
 - lib/rdf/virtuoso/parser.rb
 - lib/rdf/virtuoso/prefixes.rb
-- lib/rdf/virtuoso/repository.rb
 - lib/rdf/virtuoso/query.rb
-- spec/repository_spec.rb
-- spec/query_spec.rb
-- spec/spec_helper.rb
-- spec/prefixes_spec.rb
-homepage: https://github.com/digibib/rdf-virtuoso
-licenses: []
-post_install_message: 
+- lib/rdf/virtuoso/repository.rb
+- lib/rdf/virtuoso/version.rb
+homepage: https://github.com/ruby-rdf/rdf-virtuoso
+licenses:
+- Unlicense
+metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: rdf-virtuoso
-rubygems_version: 1.8.24
-signing_key: 
-specification_version: 3
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
 summary: An RDF.rb extension library for interacting with a Virtuoso rdf store
 test_files: []

data/spec/prefixes_spec.rb

@@ -1,48 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-require_relative '../lib/rdf/virtuoso/prefixes'
-
-describe RDF::Virtuoso::Prefixes do
-  subject { RDF::Virtuoso::Prefixes.new(foo: 'bar', baz: 'quux') }
-
-  it "takes a hash when initialized" do
-    subject.should be_a RDF::Virtuoso::Prefixes
-  end
-
-  it "responds to to_a" do
-    subject.should respond_to :to_a
-  end
-
-  it "returns a nice array" do
-    subject.to_a.should == ["foo: <bar>", "baz: <quux>"]
-  end
-
-  it "presents itself nicely" do
-    subject.to_s.should == "{:foo=>\"bar\", :baz=>\"quux\"}"
-  end
-
-  context "when creating prefixes" do
-    let(:uris) { [RDF::DC.title.to_s, "http://example.org/foo/bar", "http://hash.org/foo#bar"] }
-
-    it "creates prefixes from uris" do
-      RDF::Virtuoso::Prefixes.parse(uris).should == [
-        "purl: <http://purl.org/dc/terms/>", 
-        "example: <http://example.org/foo/>", 
-        "hash: <http://hash.org/foo#>"
-      ]
-    end
-
-    it "only creates unique prefixes from uris" do
-      uris << 'http://example.org/foo/baz'
-      RDF::Virtuoso::Prefixes.parse(uris).should == [
-        "purl: <http://purl.org/dc/terms/>", 
-        "example: <http://example.org/foo/>", 
-        "hash: <http://hash.org/foo#>"
-      ]
-    end
-
-    it "returns an error object if a disallowed param is sent" do
-      RDF::Virtuoso::Prefixes.parse({}).should be_a RDF::Virtuoso::UnProcessable
-    end
-
-  end
-end

data/spec/query_spec.rb

@@ -1,384 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe RDF::Virtuoso::Query do
-  before :each do
-    @query = RDF::Virtuoso::Query
-  end
-
-  context "when building queries" do
-    it "should support ASK queries" do
-      @query.should respond_to(:ask)
-    end
-
-    it "should support SELECT queries" do
-      @query.should respond_to(:select)
-    end
-
-    it "should support DESCRIBE queries" do
-      @query.should respond_to(:describe)
-    end
-
-    it "should support CONSTRUCT queries" do
-      @query.should respond_to(:construct)
-    end
-
-    it "should support INSERT DATA queries" do
-      @query.should respond_to(:insert_data)
-    end
-
-    it "should support INSERT WHERE queries" do
-      @query.should respond_to(:insert)
-    end
-    
-    it "should support DELETE DATA queries" do
-      @query.should respond_to(:delete_data)
-    end
-
-    it "should support DELETE WHERE queries" do
-      @query.should respond_to(:delete)
-    end
-
-    it "should support CREATE GRAPH queries" do
-      @query.should respond_to(:create)
-    end
-
-  end
-
-  context "when building update queries" do
-    before :each do
-      @graph = "http://example.org/"
-      @uri = RDF::Vocabulary.new "http://example.org/"
-    end
-    # TODO add support for advanced inserts (moving copying between different graphs)
-    it "should support INSERT DATA queries" do
-      @query.insert_data([@uri.ola, @uri.type, @uri.something]).graph(RDF::URI.new(@graph)).to_s.should == "INSERT DATA INTO GRAPH <#{@graph}> { <#{@graph}ola> <#{@graph}type> <#{@graph}something> . }"
-      @query.insert_data([@uri.ola, @uri.name, "two words"]).graph(RDF::URI.new(@graph)).to_s.should == "INSERT DATA INTO GRAPH <#{@graph}> { <#{@graph}ola> <#{@graph}name> \"two words\" . }"
-    end
-
-    it "should support INSERT DATA queries with arrays" do
-      @query.insert_data([@uri.ola, @uri.type, @uri.something],[@uri.ola, @uri.type, @uri.something_else]).graph(RDF::URI.new(@graph)).to_s.should == "INSERT DATA INTO GRAPH <#{@graph}> { <#{@graph}ola> <#{@graph}type> <#{@graph}something> . <#{@graph}ola> <#{@graph}type> <#{@graph}something_else> . }"
-    end
-    
-    it "should support INSERT DATA queries with RDF::Statements" do
-      statements = [RDF::Statement.new(RDF::URI('http://test'), RDF.type, RDF::URI('http://type')), RDF::Statement.new(RDF::URI('http://test'), RDF.type, RDF::URI('http://type2'))]
-      @query.insert_data(statements).graph(RDF::URI.new(@graph)).to_s.should == "INSERT DATA INTO GRAPH <#{@graph}> { <http://test> <#{RDF.type}> <http://type> .\n <http://test> <#{RDF.type}> <http://type2> .\n }"
-    end
-    
-    it "should support INSERT WHERE queries with symbols and patterns" do
-      @query.insert([:s, :p, :o]).graph(RDF::URI.new(@graph)).where([:s, :p, :o]).to_s.should == "INSERT INTO GRAPH <#{@graph}> { ?s ?p ?o . } WHERE { ?s ?p ?o . }"
-      @query.insert([:s, @uri.newtype, :o]).graph(RDF::URI.new(@graph)).where([:s, @uri.type, :o]).to_s.should == "INSERT INTO GRAPH <#{@graph}> { ?s <#{@graph}newtype> ?o . } WHERE { ?s <#{@graph}type> ?o . }"
-    end
-
-    it "should support DELETE DATA queries" do
-      @query.delete_data([@uri.ola, @uri.type, @uri.something]).graph(RDF::URI.new(@graph)).to_s.should == "DELETE DATA FROM <#{@graph}> { <#{@graph}ola> <#{@graph}type> <#{@graph}something> . }"  
-      @query.delete_data([@uri.ola, @uri.name, RDF::Literal.new("myname")]).graph(RDF::URI.new(@graph)).to_s.should == "DELETE DATA FROM <#{@graph}> { <#{@graph}ola> <#{@graph}name> \"myname\" . }"  
-    end
-
-    it "should support DELETE DATA queries with arrays" do
-      @query.delete_data([@uri.ola, @uri.type, @uri.something],[@uri.ola, @uri.type, @uri.something_else]).graph(RDF::URI.new(@graph)).to_s.should == "DELETE DATA FROM <#{@graph}> { <#{@graph}ola> <#{@graph}type> <#{@graph}something> . <#{@graph}ola> <#{@graph}type> <#{@graph}something_else> . }"
-    end
-    
-    it "should support DELETE DATA queries with RDF::Statements" do
-      statements = [RDF::Statement.new(RDF::URI('http://test'), RDF.type, RDF::URI('http://type')), RDF::Statement.new(RDF::URI('http://test'), RDF.type, RDF::URI('http://type2'))]
-      @query.delete_data(statements).graph(RDF::URI.new(@graph)).to_s.should == "DELETE DATA FROM <#{@graph}> { <http://test> <#{RDF.type}> <http://type> .\n <http://test> <#{RDF.type}> <http://type2> .\n }"
-    end
-
-    it "should support DELETE DATA queries with appendable objects" do
-      statements = []
-      statements << RDF::Statement.new(RDF::URI('http://test'), RDF.type, RDF::URI('http://type'))
-      statements << RDF::Statement.new(RDF::URI('http://test'), RDF.type, RDF::URI('http://type2'))
-      @query.delete_data(statements).graph(RDF::URI.new(@graph)).to_s.should == "DELETE DATA FROM <#{@graph}> { <http://test> <#{RDF.type}> <http://type> .\n <http://test> <#{RDF.type}> <http://type2> .\n }"
-    end
-        
-    it "should support DELETE WHERE queries with symbols and patterns" do
-      @query.delete([:s, :p, :o]).graph(RDF::URI.new(@graph)).where([:s, :p, :o]).to_s.should == "DELETE FROM <#{@graph}> { ?s ?p ?o . } WHERE { ?s ?p ?o . }"
-      @query.delete([:s, @uri.newtype, :o]).graph(RDF::URI.new(@graph)).where([:s, @uri.newtype, :o]).to_s.should == "DELETE FROM <#{@graph}> { ?s <#{@graph}newtype> ?o . } WHERE { ?s <#{@graph}newtype> ?o . }"
-    end
-
-    it "should support CREATE GRAPH queries" do
-      @query.create(RDF::URI.new(@graph)).to_s.should == "CREATE GRAPH <#{@graph}>"
-      @query.create(RDF::URI.new(@graph), :silent => true).to_s.should == "CREATE SILENT GRAPH <#{@graph}>"
-    end
-
-    it "should support DROP GRAPH queries" do
-      @query.drop(RDF::URI.new(@graph)).to_s.should == "DROP GRAPH <#{@graph}>"
-      @query.drop(RDF::URI.new(@graph), :silent => true).to_s.should == "DROP SILENT GRAPH <#{@graph}>"
-
-    end
-
-  end
-
-  context "when building ASK queries" do
-    it "should support basic graph patterns" do
-      @query.ask.where([:s, :p, :o]).to_s.should == "ASK WHERE { ?s ?p ?o . }"
-      @query.ask.whether([:s, :p, :o]).to_s.should == "ASK WHERE { ?s ?p ?o . }"
-    end
-  end
-
-  context "when building SELECT queries" do
-    it "should support basic graph patterns" do
-      @query.select.where([:s, :p, :o]).to_s.should == "SELECT * WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support projection" do
-      @query.select(:s).where([:s, :p, :o]).to_s.should == "SELECT ?s WHERE { ?s ?p ?o . }"
-      @query.select(:s, :p).where([:s, :p, :o]).to_s.should == "SELECT ?s ?p WHERE { ?s ?p ?o . }"
-      @query.select(:s, :p, :o).where([:s, :p, :o]).to_s.should == "SELECT ?s ?p ?o WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support SELECT FROM" do
-      @graph = RDF::URI("http://example.org/")
-      @query.select(:s).where([:s, :p, :o]).from(@graph).to_s.should == "SELECT ?s FROM <#{@graph}> WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support SELECT FROM and FROM NAMED" do
-      @graph1 = RDF::URI("a")
-      @graph2 = RDF::URI("b")
-      @query.select(:s).where([:s, :p, :o, :context => @graph2]).from(@graph1).from_named(@graph2).to_s.should ==
-        "SELECT ?s FROM <#{@graph1}> FROM NAMED <#{@graph2}> WHERE { GRAPH <#{@graph2}> { ?s ?p ?o . } }"
-    end
-
-    it "should support one SELECT FROM and multiple FROM NAMED" do
-      @graph1 = RDF::URI("a")
-      @graph2 = RDF::URI("b")
-      @graph3 = RDF::URI("c")
-      @query.select(:s).where([:s, :p, :o, :context => @graph2], [:s, :p, :o, :context => @graph3]).from(@graph1).from_named(@graph2).from_named(@graph3).to_s.should ==
-        "SELECT ?s FROM <#{@graph1}> FROM NAMED <#{@graph2}> FROM NAMED <#{@graph3}> WHERE { GRAPH <#{@graph2}> { ?s ?p ?o . } GRAPH <#{@graph3}> { ?s ?p ?o . } }"
-    end
-
-    it "should support SELECT with complex WHERE patterns" do
-      @query.select.where(
-      [:s, :p, :o],
-      [:s, RDF.type, RDF::DC.Document]
-      ).to_s.should ==
-        "SELECT * WHERE { ?s ?p ?o . ?s <#{RDF.type}> <#{RDF::DC.Document}> . }"
-    end
-
-    it "should support SELECT WHERE patterns from different GRAPH contexts" do
-      @graph1 = "http://example1.org/"
-      @graph2 = "http://example2.org/"
-      @query.select.where([:s, :p, :o, :context => @graph1],[:s, RDF.type, RDF::DC.Document, :context => @graph2]).to_s.should ==
-        "SELECT * WHERE { GRAPH <#{@graph1}> { ?s ?p ?o . } GRAPH <#{@graph2}> { ?s <#{RDF.type}> <#{RDF::DC.Document}> . } }"
-    end
-
-    it "should support string objects in SPARQL queries" do
-      @query.select.where([:s, :p, "dummyobject"]).to_s.should == "SELECT * WHERE { ?s ?p \"dummyobject\" . }"
-    end
-
-    #it "should support raw string SPARQL queries" do
-    #  q = "SELECT * WHERE { ?s <#{RDF.type}> ?o . }"
-    #  @query.query(q).should == "SELECT * WHERE { ?s <#{RDF.type}> ?o . }"
-    #end
-
-    it "should support FROM" do
-      uri = "http://example.org/dft.ttl"
-      @query.select.from(RDF::URI.new(uri)).where([:s, :p, :o]).to_s.should ==
-        "SELECT * FROM <#{uri}> WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support DISTINCT" do
-      @query.select(:s, :distinct => true).where([:s, :p, :o]).to_s.should == "SELECT DISTINCT ?s WHERE { ?s ?p ?o . }"
-      @query.select(:s).distinct.where([:s, :p, :o]).to_s.should == "SELECT DISTINCT ?s WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support REDUCED" do
-      @query.select(:s, :reduced => true).where([:s, :p, :o]).to_s.should == "SELECT REDUCED ?s WHERE { ?s ?p ?o . }"
-      @query.select(:s).reduced.where([:s, :p, :o]).to_s.should == "SELECT REDUCED ?s WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support aggregate COUNT" do
-      @query.select.where([:s, :p, :o]).count(:s).to_s.should == "SELECT (COUNT (?s) AS ?s) WHERE { ?s ?p ?o . }"
-      @query.select.count(:s).where([:s, :p, :o]).to_s.should == "SELECT (COUNT (?s) AS ?s) WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support aggregates SUM, MIN, MAX, AVG, SAMPLE, GROUP_CONCAT, GROUP_DIGEST" do
-      @query.select.where([:s, :p, :o]).sum(:s).to_s.should == "SELECT (SUM (?s) AS ?s) WHERE { ?s ?p ?o . }"
-      @query.select.where([:s, :p, :o]).min(:s).to_s.should == "SELECT (MIN (?s) AS ?s) WHERE { ?s ?p ?o . }"
-      @query.select.where([:s, :p, :o]).max(:s).to_s.should == "SELECT (MAX (?s) AS ?s) WHERE { ?s ?p ?o . }"
-      @query.select.where([:s, :p, :o]).avg(:s).to_s.should == "SELECT (AVG (?s) AS ?s) WHERE { ?s ?p ?o . }"
-      @query.select.where([:s, :p, :o]).sample(:s).to_s.should == "SELECT (sql:SAMPLE (?s) AS ?s) WHERE { ?s ?p ?o . }"
-      @query.select.where([:s, :p, :o]).group_concat(:s, '_').to_s.should == "SELECT (sql:GROUP_CONCAT (?s, '_' ) AS ?s) WHERE { ?s ?p ?o . }"
-      @query.select.where([:s, :p, :o]).group_digest(:s, '_', 1000, 1).to_s.should == "SELECT (sql:GROUP_DIGEST (?s, '_', 1000, 1 ) AS ?s) WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support multiple instances of SAMPLE" do
-      @query.select.where([:s, :p, :o]).sample(:s).sample(:p).to_s.should == "SELECT (sql:SAMPLE (?s) AS ?s) (sql:SAMPLE (?p) AS ?p) WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support multiple instances of MIN/MAX/AVG/SUM" do
-      @query.select.where([:s, :p, :o]).min(:s).min(:p).to_s.should == "SELECT (MIN (?s) AS ?s) (MIN (?p) AS ?p) WHERE { ?s ?p ?o . }"
-      @query.select.where([:s, :p, :o]).max(:s).max(:p).to_s.should == "SELECT (MAX (?s) AS ?s) (MAX (?p) AS ?p) WHERE { ?s ?p ?o . }"
-      @query.select.where([:s, :p, :o]).avg(:s).avg(:p).to_s.should == "SELECT (AVG (?s) AS ?s) (AVG (?p) AS ?p) WHERE { ?s ?p ?o . }"      
-      @query.select.where([:s, :p, :o]).sum(:s).sum(:p).to_s.should == "SELECT (SUM (?s) AS ?s) (SUM (?p) AS ?p) WHERE { ?s ?p ?o . }"      
-    end
-    
-    it "should support multiple instances of GROUP_CONCAT" do
-      @query.select.where([:s, :p, :o]).group_concat(:s, '_').group_concat(:p, '-').to_s.should == "SELECT (sql:GROUP_CONCAT (?s, '_' ) AS ?s) (sql:GROUP_CONCAT (?p, '-' ) AS ?p) WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support multiple instances of GROUP_DIGEST" do
-      @query.select.where([:s, :p, :o]).group_digest(:s, '_', 1000, 1).group_digest(:p, '-', 1000, 1).to_s.should == "SELECT (sql:GROUP_DIGEST (?s, '_', 1000, 1 ) AS ?s) (sql:GROUP_DIGEST (?p, '-', 1000, 1 ) AS ?p) WHERE { ?s ?p ?o . }"
-    end
-            
-    it "should support aggregates in addition to SELECT variables" do
-      @query.select(:s).where([:s, :p, :o]).group_digest(:o, '_', 1000, 1).to_s.should == "SELECT (sql:GROUP_DIGEST (?o, '_', 1000, 1 ) AS ?o) ?s WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support multiple instances of aggregates AND select variables" do
-      @query.select(:s).where([:s, :p, :o]).sample(:p).sample(:o).to_s.should == "SELECT (sql:SAMPLE (?p) AS ?p) (sql:SAMPLE (?o) AS ?o) ?s WHERE { ?s ?p ?o . }"
-    end
-        
-    it "should support ORDER BY" do
-      @query.select.where([:s, :p, :o]).order_by(:o).to_s.should == "SELECT * WHERE { ?s ?p ?o . } ORDER BY ?o"
-      @query.select.where([:s, :p, :o]).order_by('?o').to_s.should == "SELECT * WHERE { ?s ?p ?o . } ORDER BY ?o"
-      # @query.select.where([:s, :p, :o]).order_by(:o => :asc).to_s.should == "SELECT * WHERE { ?s ?p ?o . } ORDER BY ?o ASC"
-      @query.select.where([:s, :p, :o]).order_by('ASC(?o)').to_s.should == "SELECT * WHERE { ?s ?p ?o . } ORDER BY ASC(?o)"
-      # @query.select.where([:s, :p, :o]).order_by(:o => :desc).to_s.should == "SELECT * WHERE { ?s ?p ?o . } ORDER BY ?o DESC"
-      @query.select.where([:s, :p, :o]).order_by('DESC(?o)').to_s.should == "SELECT * WHERE { ?s ?p ?o . } ORDER BY DESC(?o)"
-    end
-
-    it "should support OFFSET" do
-      @query.select.where([:s, :p, :o]).offset(100).to_s.should == "SELECT * WHERE { ?s ?p ?o . } OFFSET 100"
-    end
-
-    it "should support LIMIT" do
-      @query.select.where([:s, :p, :o]).limit(10).to_s.should == "SELECT * WHERE { ?s ?p ?o . } LIMIT 10"
-    end
-
-    it "should support OFFSET with LIMIT" do
-      @query.select.where([:s, :p, :o]).offset(100).limit(10).to_s.should == "SELECT * WHERE { ?s ?p ?o . } OFFSET 100 LIMIT 10"
-      @query.select.where([:s, :p, :o]).slice(100, 10).to_s.should == "SELECT * WHERE { ?s ?p ?o . } OFFSET 100 LIMIT 10"
-    end
-
-#  DEPRECATED - USE RDF::Vocabulary instead
-=begin
-    it "should support PREFIX" do
-      prefixes = ["dc: <http://purl.org/dc/elements/1.1/>", "foaf: <http://xmlns.com/foaf/0.1/>"]
-      @query.select.prefix(prefixes[0]).prefix(prefixes[1]).where([:s, :p, :o]).to_s.should ==
-        "PREFIX #{prefixes[0]} PREFIX #{prefixes[1]} SELECT * WHERE { ?s ?p ?o . }"
-    end
-
-    it "constructs PREFIXes" do
-      prefixes = RDF::Virtuoso::Prefixes.new dc: RDF::DC, foaf: RDF::FOAF
-      @query.select.prefixes(prefixes).where([:s, :p, :o]).to_s.should ==
-        "PREFIX dc: <#{RDF::DC}> PREFIX foaf: <#{RDF::FOAF}> SELECT * WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support custom PREFIXes in hash array" do
-      prefixes = RDF::Virtuoso::Prefixes.new foo: "http://foo.com/", bar: "http://bar.net"
-      @query.select.prefixes(prefixes).where([:s, :p, :o]).to_s.should ==
-        "PREFIX foo: <http://foo.com/> PREFIX bar: <http://bar.net> SELECT * WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support accessing custom PREFIXes in SELECT" do
-      prefixes = RDF::Virtuoso::Prefixes.new foo: "http://foo.com/"
-      @query.select.where(['foo:bar', :p, :o]).prefixes(prefixes).to_s.should ==
-        "PREFIX foo: <http://foo.com/bar> SELECT * WHERE { ?s ?p ?o . }"
-    end
-=end  
-
-    it "should support using custom RDF::Vocabulary prefixes" do
-      BIBO = RDF::Vocabulary.new("http://purl.org/ontology/bibo/")
-      @query.select.where([:s, :p, BIBO.Document]).to_s.should ==
-        "SELECT * WHERE { ?s ?p <http://purl.org/ontology/bibo/Document> . }"
-    end
-    
-    it "should support OPTIONAL" do
-      @query.select.where([:s, :p, :o]).optional([:s, RDF.type, :o], [:s, RDF::DC.abstract, :o]).to_s.should ==
-        "SELECT * WHERE { ?s ?p ?o . OPTIONAL { ?s <#{RDF.type}> ?o . ?s <#{RDF::DC.abstract}> ?o . } }"
-    end
-
-    it "should support OPTIONAL with GRAPH contexts" do
-      @graph1 = "http://example1.org/"
-      @graph2 = "http://example2.org/"
-      @query.select.where([:s, :p, :o, :context => @graph1]).optional([:s, RDF.type, RDF::DC.Document, :context => @graph2]).to_s.should == 
-        "SELECT * WHERE { GRAPH <#{@graph1}> { ?s ?p ?o . } OPTIONAL { GRAPH <#{@graph2}> { ?s <#{RDF.type}> <#{RDF::DC.Document}> . } } }"
-    end
-    
-    it "should support multiple OPTIONALs" do
-      @query.select.where([:s, :p, :o]).optional([:s, RDF.type, :o]).optional([:s, RDF::DC.abstract, :o]).to_s.should ==
-        "SELECT * WHERE { ?s ?p ?o . OPTIONAL { ?s <#{RDF.type}> ?o . } OPTIONAL { ?s <#{RDF::DC.abstract}> ?o . } }"
-    end
-
-    it "should support MINUS, also with an array pattern" do
-      @query.select.where([:s, :p, :o]).minus([:s, RDF.type, :o], [:s, RDF::DC.abstract, :o]).to_s.should ==
-        "SELECT * WHERE { ?s ?p ?o . MINUS { ?s <#{RDF.type}> ?o . ?s <#{RDF::DC.abstract}> ?o . } }"
-    end
-
-    it "should support multiple MINUSes" do
-      @query.select.where([:s, :p, :o]).minus([:s, RDF.type, :o]).minus([:s, RDF::DC.abstract, :o]).to_s.should ==
-        "SELECT * WHERE { ?s ?p ?o . MINUS { ?s <#{RDF.type}> ?o . } MINUS { ?s <#{RDF::DC.abstract}> ?o . } }"
-    end
-
-    it "should support MINUS with a GRAPH context" do
-      @graph1 = "http://example1.org/"
-      @query.select.where([:s, :p, :o]).minus([:s, RDF.type, :o, :context => @graph1]).to_s.should ==
-        "SELECT * WHERE { ?s ?p ?o . MINUS { GRAPH <#{@graph1}> { ?s <#{RDF.type}> ?o . } } }"
-    end
-        
-    it "should support UNION" do
-      @query.select.where([:s, RDF::DC.abstract, :o]).union([:s, RDF.type, :o]).to_s.should ==
-      "SELECT * WHERE { { ?s <#{RDF::DC.abstract}> ?o . } UNION { ?s <#{RDF.type}> ?o . } }"
-    end
-
-    it "should support FILTER" do
-      @query.select.where([:s, RDF::DC.abstract, :o]).filter('lang(?text) != "nb"').to_s.should ==
-      "SELECT * WHERE { ?s <#{RDF::DC.abstract}> ?o . FILTER(lang(?text) != \"nb\") }"
-    end
-
-    it "should support multiple FILTERs" do
-      filters = ['lang(?text) != "nb"', 'regex(?uri, "^https")']
-      @query.select.where([:s, RDF::DC.abstract, :o]).filters(filters).to_s.should ==
-      "SELECT * WHERE { ?s <#{RDF::DC.abstract}> ?o . FILTER(lang(?text) != \"nb\") FILTER(regex(?uri, \"^https\")) }"
-    end
-
-    it "should support DEFINE headers in queries" do
-      define = 'sql:select-option "ORDER"'
-      @query.select.where([:s, RDF::DC.abstract, :o]).define(define).to_s.should ==
-      "DEFINE #{define} SELECT * WHERE { ?s <#{RDF::DC.abstract}> ?o . }"
-    end
-
-    it "should support grouping graph patterns within brackets" do
-      @query.select.where.group([:s, :p, :o],[:s2, :p2, :o2]).
-        where([:s3, :p3, :o3]).to_s.should ==
-      "SELECT * WHERE { { ?s ?p ?o . ?s2 ?p2 ?o2 . } ?s3 ?p3 ?o3 . }"
-    end
-
-    it "should support grouping with several graph statements" do
-      @query.select.where.graph2(RDF::URI.new("a")).group([:s, :p, :o],[:s2, :p2, :o2]).
-        where.graph2(RDF::URI.new("b")).group([:s3, :p3, :o3]).to_s.should ==
-        "SELECT * WHERE { GRAPH <a> { ?s ?p ?o . ?s2 ?p2 ?o2 . } GRAPH <b> { ?s3 ?p3 ?o3 . } }"
-    end
-
-  end
-
-  context "when building DESCRIBE queries" do
-    it "should support basic graph patterns" do
-      @query.describe.where([:s, :p, :o]).to_s.should == "DESCRIBE * WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support projection" do
-      @query.describe(:s).where([:s, :p, :o]).to_s.should == "DESCRIBE ?s WHERE { ?s ?p ?o . }"
-      @query.describe(:s, :p).where([:s, :p, :o]).to_s.should == "DESCRIBE ?s ?p WHERE { ?s ?p ?o . }"
-      @query.describe(:s, :p, :o).where([:s, :p, :o]).to_s.should == "DESCRIBE ?s ?p ?o WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support RDF::URI arguments" do
-      uris = ['http://www.bbc.co.uk/programmes/b007stmh#programme', 'http://www.bbc.co.uk/programmes/b00lg2xb#programme']
-      @query.describe(RDF::URI.new(uris[0]),RDF::URI.new(uris[1])).to_s.should ==
-        "DESCRIBE <#{uris[0]}> <#{uris[1]}>"
-    end
-  end
-
-  context "when building CONSTRUCT queries" do
-    it "should support basic graph patterns" do
-      @query.construct([:s, :p, :o]).where([:s, :p, :o]).to_s.should == "CONSTRUCT { ?s ?p ?o . } WHERE { ?s ?p ?o . }"
-    end
-
-    it "should support complex constructs" do
-      @query.construct([:s, :p, :o], [:s, :q, RDF::Literal.new("new")]).where([:s, :p, :o], [:s, :q, "old"]).to_s.should == "CONSTRUCT { ?s ?p ?o . ?s ?q \"new\" . } WHERE { ?s ?p ?o . ?s ?q \"old\" . }"
-    end    
-          
-
-  end
-end

data/spec/repository_spec.rb

@@ -1,36 +0,0 @@
-$:.unshift "."
-require 'spec_helper'
-require 'rdf/spec/repository'
-#require_relative '../lib/rdf/virtuoso/repository'
-describe RDF::Virtuoso::Repository do
-
-  before(:each) do
-    @uri = "http://localhost:8890/sparql"
-    @update_uri = "http://localhost:8890/sparql-auth"
-  end
-  
-    it "should mixin RDF::Repository" do
-      @repository = RDF::Virtuoso::Repository.new(@uri)
-      #it_should_behave_like RDF_Repository # not working!
-    end
-    
-    it "should support connecting to a Virtuoso SPARQL endpoint" do
-      repo = RDF::Virtuoso::Repository.new(@uri)
-      repo.instance_variable_get("@sparul_endpoint").should == "/sparql"
-    end
-
-    it "should support accept port in repository endpoint" do
-      repo = RDF::Virtuoso::Repository.new(@uri)
-      repo.instance_variable_get("@base_uri").should == "http://localhost:8890"
-    end
-        
-    it "should support connecting to a Virtuoso SPARUL endpoint with BASIC AUTH" do
-      repo = RDF::Virtuoso::Repository.new(@uri, :update_uri => @update_uri, :username => 'admin', :password => 'secret', :auth_method => 'basic')
-      repo.instance_variable_get("@auth_method").should == "basic"
-    end
-    
-    it "should support connecting to a Virtuoso SPARUL endpoint with DIGEST AUTH" do
-      repo = RDF::Virtuoso::Repository.new(@uri, :update_uri => @update_uri, :username => 'admin', :password => 'secret', :auth_method => 'digest')
-      repo.instance_variable_get("@sparul_endpoint").should == "/sparql-auth"
-    end
-end

data/spec/spec_helper.rb

@@ -1,6 +0,0 @@
-require 'bundler/setup'
-require 'rspec'
-require 'rdf'
-require 'rdf/spec'
-require 'rdf/virtuoso'
-require 'rdf/spec/repository'