sparql-client 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 251df215fdb211b37f325950b2d6f64d37639558
-  data.tar.gz: f07ba6ef756c9bf6306b496a0626661638ee6af3
+  metadata.gz: 42303e20768dba6ca714f7203a71ae45de154d41
+  data.tar.gz: 7c30be238f6ad8752e8f146337c88f88b3d5b8f7
 SHA512:
-  metadata.gz: 281f97c225fc2a75aadd4483699043562a784aee163ebb899c8baa57e7118852950706ea939456c9c13f8d01e887d13517b3e14dc4de3b1d01c7b7e21a7ff431
-  data.tar.gz: c6c0b441502b862d6abde67a6933aa2eb4633b1cba6c2685eae3eca2a42a1f6829218d9fa1f6c91a16bdcf58bdb76263c941ecc53bb0df0de13d150f3ecd8375
+  metadata.gz: 49ef463d9894b382fe2ace2b28ee68140cc0877c834598f1466076579451b03e79e7c9b2d922ba35365e5501205023b3ec6ef8887cfd0b3f3c9ec13e7f0dccc4
+  data.tar.gz: 657acc7375b86f3e8d977fb6b5f63f9ce3173115ae9db04f9bd12ed7e958c56b53e4c6b77b90e0a99df038334bea59f4c693a0f2fb21389e1a26d9a564586426

data/CREDITS

@@ -1,4 +1,5 @@
 * Christoph Badura <bad@bsd.de>
+* Thomas Feron <tho.feron@gmail.com>
 * James Hetherington <jamespjh@googlemail.com>
 * Gabriel Horner <gabriel.horner@gmail.com>
 * Nicholas Humfrey <njh@aelius.com>
@@ -7,4 +8,4 @@
 * Thamaraiselvan Poomalai <p.thamarai@gmail.com>
 * Michael Sokol <mikaa123@gmail.com>
 * Yves Raimond <yves.raimond@bbc.co.uk>
-* Thomas Feron <tho.feron@gmail.com>
+* Danny Tran <dannybtran@gmail.com>

data/README

@@ -18,8 +18,8 @@ This is a [Ruby][] implementation of a [SPARQL][] client for [RDF.rb][].
   the preferred default for content-negotiation purposes.
 * Supports graph results in any RDF serialization format understood by RDF.rb.
 * Returns results using the [RDF.rb object model][RDF.rb model].
-* Supports accessing endpoints as read-only [`RDF::Repository`][RDF::Repository]
-  instances.
+* Supports accessing endpoints as read/write [`RDF::Repository`][RDF::Repository]
+  instances {SPARQL::Client::Repository}.
 
 ##Examples
 

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.1.2

data/lib/sparql/client.rb

@@ -149,7 +149,7 @@ module SPARQL
     # @example Inserting data into a named graph
     #   client.insert_data(data, :graph => "http://example.org/")
     #
-    # @param  [RDF::Graph] data
+    # @param  [RDF::Enumerable] data
     # @param  [Hash{Symbol => Object}] options
     # @option options [RDF::URI, String] :graph
     # @return [void] `self`
@@ -170,7 +170,7 @@ module SPARQL
     # @example Deleting data from a named graph
     #   client.delete_data(data, :graph => "http://example.org/")
     #
-    # @param  [RDF::Graph] data
+    # @param  [RDF::Enumerable] data
     # @param  [Hash{Symbol => Object}] options
     # @option options [RDF::URI, String] :graph
     # @return [void] `self`
@@ -179,6 +179,22 @@ module SPARQL
       self.update(Update::DeleteData.new(data, options))
     end
 
+    ##
+    # Executes a `DELETE/INSERT` operation.
+    #
+    # This requires that the endpoint support SPARQL 1.1 Update.
+    #
+    # @param  [RDF::Enumerable] delete_graph
+    # @param  [RDF::Enumerable] insert_graph
+    # @param  [RDF::Enumerable] where_graph
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [RDF::URI, String] :graph
+    # @return [void] `self`
+    # @see    http://www.w3.org/TR/sparql11-update/#deleteInsert
+    def delete_insert(delete_graph, insert_graph = nil, where_graph = nil, options = {})
+      self.update(Update::DeleteInsert.new(delete_graph, insert_graph, where_graph, options))
+    end
+
     ##
     # Executes a `CLEAR GRAPH` operation.
     #
@@ -528,11 +544,50 @@ module SPARQL
       # 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.nil? then RDF::Query::Variable.new.to_s
         when value.variable? then value.to_s
         else RDF::NTriples.serialize(value)
       end
     end
 
+    ##
+    # Serializes a SPARQL predicate
+    #
+    # @param [RDF::Value, Array, String] value
+    # @param [Fixnum] rdepth
+    # @return [String]
+    # @private
+    def self.serialize_predicate(value,rdepth=0)
+      case value
+        when String then value
+        when Array
+          s = value.map{|v|serialize_predicate(v,rdepth+1)}.join
+          rdepth > 0 ? "(#{s})" : s
+        when RDF::Value
+          # abbreviate RDF.type in the predicate position per SPARQL grammar
+          value.equal?(RDF.type) ? 'a' : serialize_value(value)
+      end
+    end
+
+    ##
+    # Serializes a SPARQL graph
+    #
+    # @param [RDF::Enumerable] patterns
+    # @return [String]
+    # @private
+    def self.serialize_patterns(patterns)
+      patterns.map do |pattern|
+        serialized_pattern = RDF::Statement.from(pattern).to_triple.each_with_index.map do |v, i|
+          if i == 1
+            SPARQL::Client.serialize_predicate(v)
+         else
+            SPARQL::Client.serialize_value(v)
+          end
+        end
+        serialized_pattern.join(' ') + ' .'
+      end
+    end
+
     ##
     # Outputs a developer-friendly representation of this object to `stderr`.
     #

data/lib/sparql/client/query.rb

@@ -321,7 +321,7 @@ module SPARQL; class Client
 
       case form
         when :select, :describe
-          only_count = values.empty? and options[:count]
+          only_count = values.empty? && options[:count]
           buffer << 'DISTINCT' if options[:distinct] and not only_count
           buffer << 'REDUCED'  if options[:reduced]
           buffer << ((values.empty? and not options[:count]) ? '*' : values.map { |v| SPARQL::Client.serialize_value(v[1]) }.join(' '))
@@ -333,7 +333,7 @@ module SPARQL; class Client
           end
         when :construct
           buffer << '{'
-          buffer += serialize_patterns(options[:template])
+          buffer += SPARQL::Client.serialize_patterns(options[:template])
           buffer << '}'
       end
 
@@ -351,11 +351,11 @@ module SPARQL; class Client
           buffer << "{ #{sq.to_s} } ."
         end
 
-        buffer += serialize_patterns(patterns)
+        buffer += SPARQL::Client.serialize_patterns(patterns)
         if options[:optionals]
           options[:optionals].each do |patterns|
             buffer << 'OPTIONAL {'
-            buffer += serialize_patterns(patterns)
+            buffer += SPARQL::Client.serialize_patterns(patterns)
             buffer << '}'
           end
         end
@@ -386,22 +386,6 @@ module SPARQL; class Client
       buffer.join(' ')
     end
 
-    ##
-    # @private
-    def serialize_patterns(patterns)
-      rdf_type = RDF.type
-      patterns.map do |pattern|
-        serialized_pattern = pattern.to_triple.each_with_index.map do |v, i|
-          if i == 1 && v.equal?(rdf_type)
-            'a' # abbreviate RDF.type in the predicate position per SPARQL grammar
-          else
-            SPARQL::Client.serialize_value(v)
-          end
-        end
-        serialized_pattern.join(' ') + ' .'
-      end
-    end
-
     ##
     # Outputs a developer-friendly representation of this query to `stderr`.
     #

data/lib/sparql/client/repository.rb

@@ -15,18 +15,49 @@ module SPARQL; class Client
       @client  = SPARQL::Client.new(endpoint, options)
     end
 
+    ##
+    # Queries `self` using the given basic graph pattern (BGP) query,
+    # yielding each matched solution to the given block.
+    #
+    # Overrides Queryable::query_execute to use SPARQL::Client::query
+    #
+    # @param  [RDF::Query] query
+    #   the query to execute
+    # @param  [Hash{Symbol => Object}] options ({})
+    #   Any other options passed to `query.execute`
+    # @yield  [solution]
+    # @yieldparam  [RDF::Query::Solution] solution
+    # @yieldreturn [void] ignored
+    # @return [void] ignored
+    # @see    RDF::Queryable#query
+    # @see    RDF::Query#execute
+    def query_execute(query, options = {}, &block)
+      q = SPARQL::Client::Query.select(query.variables).where(*query.patterns)
+       client.query(q, options).each do |solution|
+        yield solution
+      end
+    end
+
     ##
     # Enumerates each RDF statement in this repository.
     #
     # @yield  [statement]
     # @yieldparam [RDF::Statement] statement
-    # @return [Enumerator]
     # @see    RDF::Repository#each
     def each(&block)
-      unless block_given?
-        RDF::Enumerator.new(self, :each)
-      else
-        client.construct([:s, :p, :o]).where([:s, :p, :o]).each_statement(&block)
+      client.construct([:s, :p, :o]).where([:s, :p, :o]).each_statement(&block)
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#supports?
+    def supports?(feature)
+      case feature.to_sym
+        # statement contexts / named graphs
+        when :context   then false
+        when :inference then false  # forward-chaining inference
+        when :validity  then false
+        else false
       end
     end
 
@@ -68,11 +99,10 @@ module SPARQL; class Client
     # @return [Enumerator]
     # @see    RDF::Repository#each_subject?
     def each_subject(&block)
-      unless block_given?
-        RDF::Enumerator.new(self, :each_subject)
-      else
-        client.select(:s, :distinct => true).where([:s, :p, :o]).each { |solution| block.call(solution[:s]) }
+      if block_given?
+        client.select(:s, :distinct => true).where([:s, :p, :o]).each_solution { |solution| block.call(solution[:s]) }
       end
+      enum_subject
     end
 
     ##
@@ -83,11 +113,10 @@ module SPARQL; class Client
     # @return [Enumerator]
     # @see    RDF::Repository#each_predicate?
     def each_predicate(&block)
-      unless block_given?
-        RDF::Enumerator.new(self, :each_predicate)
-      else
-        client.select(:p, :distinct => true).where([:s, :p, :o]).each { |solution| block.call(solution[:p]) }
+      if block_given?
+        client.select(:p, :distinct => true).where([:s, :p, :o]).each_solution { |solution| block.call(solution[:p]) }
       end
+      enum_predicate
     end
 
     ##
@@ -98,11 +127,10 @@ module SPARQL; class Client
     # @return [Enumerator]
     # @see    RDF::Repository#each_object?
     def each_object(&block)
-      unless block_given?
-        RDF::Enumerator.new(self, :each_object)
-      else
-        client.select(:o, :distinct => true).where([:s, :p, :o]).each { |solution| block.call(solution[:o]) }
+      if block_given?
+        client.select(:o, :distinct => true).where([:s, :p, :o]).each_solution { |solution| block.call(solution[:o]) }
       end
+      enum_object
     end
 
     ##
@@ -161,6 +189,8 @@ module SPARQL; class Client
     #     repository.query([nil, RDF::DOAP.developer, nil])
     #     repository.query(:predicate => RDF::DOAP.developer)
     #
+    # @fixme This should use basic SPARQL query mechanism.
+    #
     # @param  [Pattern] pattern
     # @see    RDF::Queryable#query_pattern
     # @yield  [statement]
@@ -187,7 +217,80 @@ module SPARQL; class Client
     # @return [Boolean]
     # @see    RDF::Mutable#mutable?
     def writable?
-      false
+      true
     end
+
+    ##
+    # @private
+    # @see RDF::Mutable#clear
+    def clear_statements
+      client.clear(:all)
+    end
+
+    ##
+    # Deletes RDF statements from `self`.
+    # If any statement contains a {Query::Variable}, it is
+    # considered to be a pattern, and used to query
+    # self to find matching statements to delete.
+    #
+    # @param  [Enumerable<RDF::Statement>] statements
+    # @raise  [TypeError] if `self` is immutable
+    # @return [Mutable]
+    def delete(*statements)
+      delete_statements(statements) unless statements.empty?
+      return self
+    end
+
+    protected
+
+    ##
+    # Deletes the given RDF statements from the underlying storage.
+    #
+    # Overridden here to use SPARQL/UPDATE
+    #
+    # @param  [RDF::Enumerable] statements
+    # @return [void]
+    def delete_statements(statements)
+
+      constant = true
+      statements.each do |value|
+        case
+          when value.respond_to?(:each_statement)
+          # needs to be flattened... urgh
+            nil
+          when (statement = RDF::Statement.from(value)).constant?
+            # constant
+          else
+          constant = false
+        end
+      end
+
+      if constant
+        client.delete_data(statements)
+      else
+        client.delete_insert(statements)
+      end
+    end
+
+    ##
+    # Inserts the given RDF statements into the underlying storage or output
+    # stream.
+    #
+    # Overridden here to use SPARQL/UPDATE
+    #
+    # @param  [RDF::Enumerable] statements
+    # @return [void]
+    # @since  0.1.6
+    def insert_statements(statements)
+      client.insert_data(statements)
+    end
+
+    ##
+    # @private
+    # @see RDF::Mutable#insert
+    def insert_statement(statement)
+      client.insert_data([statement])
+    end
+
   end
 end; end

data/lib/sparql/client/update.rb

@@ -61,7 +61,7 @@ class SPARQL::Client
         query_text = 'INSERT DATA {'
         query_text += ' GRAPH ' + SPARQL::Client.serialize_uri(self.options[:graph]) + ' {' if self.options[:graph]
         query_text += "\n"
-        query_text += RDF::NTriples::Writer.buffer { |writer| writer << @data }
+        query_text += RDF::NTriples::Writer.buffer { |writer| @data.each { |d| writer << d } }
         query_text += '}' if self.options[:graph]
         query_text += "}\n"
       end
@@ -86,7 +86,7 @@ class SPARQL::Client
         query_text = 'DELETE DATA {'
         query_text += ' GRAPH ' + SPARQL::Client.serialize_uri(self.options[:graph]) + ' {' if self.options[:graph]
         query_text += "\n"
-        query_text += RDF::NTriples::Writer.buffer { |writer| writer << @data }
+        query_text += RDF::NTriples::Writer.buffer { |writer| @data.each { |d| writer << d } }
         query_text += '}' if self.options[:graph]
         query_text += "}\n"
       end
@@ -95,9 +95,50 @@ class SPARQL::Client
     ##
     # @see http://www.w3.org/TR/sparql11-update/#deleteInsert
     class DeleteInsert < Operation
+      attr_reader :insert_graph
+      attr_reader :delete_graph
+      attr_reader :where_graph
+
+      def initialize(_delete_graph, _insert_graph = nil, _where_graph = nil, options = {})
+        @delete_graph = _delete_graph
+        @insert_graph = _insert_graph
+        @where_graph = _where_graph
+        super(options)
+      end
+
+      def graph(uri)
+        self.options[:graph] = uri
+        self
+      end
+
       def to_s
-        # TODO
+        buffer = []
+
+        if self.options[:graph]
+          buffer << "WITH"
+          buffer << SPARQL::Client.serialize_uri(self.options[:graph])
+        end
+        if delete_graph and !delete_graph.empty?
+          serialized_delete = SPARQL::Client.serialize_patterns delete_graph
+          buffer << "DELETE {\n"
+          buffer += serialized_delete
+          buffer << "}\n"
+        end
+        if insert_graph and !insert_graph.empty?
+          buffer << "INSERT {\n"
+          buffer += SPARQL::Client.serialize_patterns insert_graph
+          buffer << "}\n"
+        end
+          buffer << "WHERE {\n"
+        if where_graph
+          buffer += SPARQL::Client.serialize_patterns where_graph
+        elsif serialized_delete
+          buffer += serialized_delete
+        end
+        buffer << "}\n"
+        buffer.join(' ')
       end
+
     end
 
     ##

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sparql-client
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Arto Bendiken
@@ -10,123 +10,125 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-19 00:00:00.000000000 Z
+date: 2014-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
   name: net-http-persistent
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
 - !ruby/object:Gem::Dependency
-  name: json
+  name: sparql
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
-  type: :runtime
+        version: '1.1'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: sparql
+  name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: rdf-spec
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rspec-its
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.15'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.15'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
 description: |-
   Executes SPARQL queries and updates against a remote SPARQL 1.0 or 1.1 endpoint,
                               or against a local repository. Generates SPARQL queries using a simple DSL.
+                              Includes SPARQL::Client::Repository, which allows any endpoint supporting
+                              SPARQL Update to be used as an RDF.rb repository.
 email: public-rdf-ruby@w3.org
 executables: []
 extensions: []
@@ -137,11 +139,11 @@ files:
 - README
 - UNLICENSE
 - VERSION
+- lib/sparql/client.rb
 - lib/sparql/client/query.rb
 - lib/sparql/client/repository.rb
 - lib/sparql/client/update.rb
 - lib/sparql/client/version.rb
-- lib/sparql/client.rb
 homepage: http://ruby-rdf.github.com/sparql-client/
 licenses:
 - Public Domain
@@ -152,17 +154,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: sparql-client
-rubygems_version: 2.1.11
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: SPARQL client for RDF.rb.