sparql-client 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42303e20768dba6ca714f7203a71ae45de154d41
-  data.tar.gz: 7c30be238f6ad8752e8f146337c88f88b3d5b8f7
+  metadata.gz: 04a17f253c88990873cd961f8d53c71c3634e5e7
+  data.tar.gz: 6c8734ce71831639979568cc2a82738f25dc0039
 SHA512:
-  metadata.gz: 49ef463d9894b382fe2ace2b28ee68140cc0877c834598f1466076579451b03e79e7c9b2d922ba35365e5501205023b3ec6ef8887cfd0b3f3c9ec13e7f0dccc4
-  data.tar.gz: 657acc7375b86f3e8d977fb6b5f63f9ce3173115ae9db04f9bd12ed7e958c56b53e4c6b77b90e0a99df038334bea59f4c693a0f2fb21389e1a26d9a564586426
+  metadata.gz: 5e45a58edc5c8165e948938e82e6653fb19d9f0ec28f954bc8deba8e299ff816f9c167f344f71a436702273f1daadc703e5edaccf2ba9e57b9d52127a914b9b9
+  data.tar.gz: 0b80f8de6e6926d3535b9ed0bbbb63fe86d33e826526f0ffbbdbe4e47337b48e7882f205186f3dfe00c367afae6cbfdfaf147b6213d93950c4c8d55fd29b3fbe

data/VERSION

@@ -1 +1 @@
-1.1.2
+1.1.3

data/lib/sparql/client/query.rb

@@ -241,6 +241,12 @@ module SPARQL; class Client
       self
     end
 
+    ##
+    # @return expects_statements?
+    def expects_statements?
+      [:construct, :describe].include?(form)
+    end
+
     ##
     # @private
     def build_patterns(patterns)

data/lib/sparql/client/repository.rb

@@ -32,8 +32,9 @@ module SPARQL; class Client
     # @see    RDF::Queryable#query
     # @see    RDF::Query#execute
     def query_execute(query, options = {}, &block)
+      return nil unless block_given?
       q = SPARQL::Client::Query.select(query.variables).where(*query.patterns)
-       client.query(q, options).each do |solution|
+      client.query(q, options).each do |solution|
         yield solution
       end
     end
@@ -252,16 +253,11 @@ module SPARQL; class Client
     # @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
+      constant = statements.all? do |value|
+        # needs to be flattened... urgh
+        !value.respond_to?(:each_statement) && begin
+          statement = RDF::Statement.from(value)
+          statement.constant? && !statement.has_blank_nodes?
         end
       end
 

data/lib/sparql/client/update.rb

@@ -36,6 +36,14 @@ class SPARQL::Client
         end
       end
 
+      ##
+      # Generic Update always returns statements
+      #
+      # @return expects_statements?
+      def expects_statements?
+        true
+      end
+
       def silent
         self.options[:silent] = true
         self
@@ -57,6 +65,14 @@ class SPARQL::Client
         self
       end
 
+      ##
+      # InsertData always returns result set
+      #
+      # @return expects_statements?
+      def expects_statements?
+        false
+      end
+
       def to_s
         query_text = 'INSERT DATA {'
         query_text += ' GRAPH ' + SPARQL::Client.serialize_uri(self.options[:graph]) + ' {' if self.options[:graph]
@@ -119,19 +135,19 @@ class SPARQL::Client
           buffer << SPARQL::Client.serialize_uri(self.options[:graph])
         end
         if delete_graph and !delete_graph.empty?
-          serialized_delete = SPARQL::Client.serialize_patterns delete_graph
+          serialized_delete = SPARQL::Client.serialize_patterns delete_graph, true
           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 += SPARQL::Client.serialize_patterns insert_graph, true
           buffer << "}\n"
         end
           buffer << "WHERE {\n"
         if where_graph
-          buffer += SPARQL::Client.serialize_patterns where_graph
+          buffer += SPARQL::Client.serialize_patterns where_graph, true
         elsif serialized_delete
           buffer += serialized_delete
         end
@@ -193,6 +209,14 @@ class SPARQL::Client
         self
       end
 
+      ##
+      # Clear always returns statements
+      #
+      # @return expects_statements?
+      def expects_statements?
+        false
+      end
+
       def to_s
         query_text = 'CLEAR '
         query_text += 'SILENT ' if self.options[:silent]

data/lib/sparql/client.rb

@@ -31,11 +31,26 @@ module SPARQL
     RESULT_TSV  = 'text/tab-separated-values'.freeze
     RESULT_BOOL = 'text/boolean'.freeze                           # Sesame-specific
     RESULT_BRTR = 'application/x-binary-rdf-results-table'.freeze # Sesame-specific
-    ACCEPT_JSON = {'Accept' => RESULT_JSON}.freeze
-    ACCEPT_XML  = {'Accept' => RESULT_XML}.freeze
-    ACCEPT_CSV  = {'Accept' => RESULT_CSV}.freeze
-    ACCEPT_TSV  = {'Accept' => RESULT_TSV}.freeze
-    ACCEPT_BRTR = {'Accept' => RESULT_BRTR}.freeze
+    RESULT_ALL  = [
+      RESULT_JSON,
+      RESULT_XML,
+      RESULT_BOOL,
+      "#{RESULT_TSV};p=0.8",
+      "#{RESULT_CSV};p=0.2",
+      '*/*;p=0.1'
+    ].join(', ').freeze
+    GRAPH_ALL  = (
+      RDF::Format.content_types.keys + 
+      ['*/*;p=0.1']
+    ).join(', ').freeze
+
+    ACCEPT_JSON    = {'Accept' => RESULT_JSON}.freeze
+    ACCEPT_XML     = {'Accept' => RESULT_XML}.freeze
+    ACCEPT_CSV     = {'Accept' => RESULT_CSV}.freeze
+    ACCEPT_TSV     = {'Accept' => RESULT_TSV}.freeze
+    ACCEPT_BRTR    = {'Accept' => RESULT_BRTR}.freeze
+    ACCEPT_RESULTS = {'Accept' => RESULT_ALL}.freeze
+    ACCEPT_GRAPH   = {'Accept' => GRAPH_ALL}.freeze
 
     DEFAULT_PROTOCOL = 1.0
     DEFAULT_METHOD   = :post
@@ -78,9 +93,7 @@ module SPARQL
         @url, @options = url, options.dup
       else
         @url, @options = RDF::URI.new(url.to_s), options.dup
-        @headers = {
-          'Accept' => [RESULT_JSON, RESULT_XML, "#{RESULT_TSV};p=0.8", "#{RESULT_CSV};p=0.2", RDF::Format.content_types.keys.map(&:to_s)].join(', ')
-        }.merge(@options.delete(:headers) || {})
+        @headers = @options.delete(:headers) || {}
         @http = http_klass(@url.scheme)
       end
 
@@ -291,12 +304,14 @@ module SPARQL
     #
     # @param  [String, #to_s]          query
     # @param  [Hash{Symbol => Object}] options
+    # @option options [String] :endpoint
     # @option options [String] :content_type
     # @option options [Hash] :headers
     # @return [void] `self`
     # @see    http://www.w3.org/TR/sparql11-protocol/#update-operation
     def update(query, options = {})
       @op = :update
+      @alt_endpoint = options[:endpoint] unless options[:endpoint].nil?
       case @url
       when RDF::Queryable
         require 'sparql' unless defined?(::SPARQL::Grammar)
@@ -322,11 +337,11 @@ module SPARQL
       request(query, headers) do |response|
         case response
           when Net::HTTPBadRequest  # 400 Bad Request
-            raise MalformedQuery.new(response.body)
+            raise MalformedQuery.new(response.body + " Processing query #{query}")
           when Net::HTTPClientError # 4xx
-            raise ClientError.new(response.body)
+            raise ClientError.new(response.body + " Processing query #{query}")
           when Net::HTTPServerError # 5xx
-            raise ServerError.new(response.body)
+            raise ServerError.new(response.body + " Processing query #{query}")
           when Net::HTTPSuccess     # 2xx
             response
         end
@@ -378,6 +393,7 @@ module SPARQL
     ##
     # @param  [Hash{String => String}] value
     # @return [RDF::Value]
+    # @see    http://www.w3.org/TR/sparql11-results-json/#select-encode-terms
     # @see    http://www.w3.org/TR/rdf-sparql-json-res/#variable-binding-results
     def self.parse_json_value(value, nodes = {})
       case value['type'].to_sym
@@ -386,7 +402,7 @@ module SPARQL
         when :uri
           RDF::URI.new(value['value'])
         when :literal
-          RDF::Literal.new(value['value'], :language => value['xml:lang'])
+          RDF::Literal.new(value['value'], :datatype => value['datatype'], :language => value['xml:lang'])
         when :'typed-literal'
           RDF::Literal.new(value['value'], :datatype => value['datatype'])
         else nil
@@ -538,14 +554,16 @@ module SPARQL
     # Serializes an `RDF::Value` into SPARQL syntax.
     #
     # @param  [RDF::Value] value
+    # @param  [Boolean] use_vars (false) Use variables in place of BNodes
     # @return [String]
     # @private
-    def self.serialize_value(value)
+    def self.serialize_value(value, use_vars = false)
       # 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.nil?      then RDF::Query::Variable.new.to_s
         when value.variable? then value.to_s
+        when value.node?     then (use_vars ? RDF::Query::Variable.new(value.id) : value)
         else RDF::NTriples.serialize(value)
       end
     end
@@ -559,6 +577,8 @@ module SPARQL
     # @private
     def self.serialize_predicate(value,rdepth=0)
       case value
+        when nil
+          RDF::Query::Variable.new.to_s
         when String then value
         when Array
           s = value.map{|v|serialize_predicate(v,rdepth+1)}.join
@@ -573,15 +593,16 @@ module SPARQL
     # Serializes a SPARQL graph
     #
     # @param [RDF::Enumerable] patterns
+    # @param  [Boolean] use_vars (false) Use variables in place of BNodes
     # @return [String]
     # @private
-    def self.serialize_patterns(patterns)
+    def self.serialize_patterns(patterns, use_vars = false)
       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)
+            SPARQL::Client.serialize_value(v, use_vars)
           end
         end
         serialized_pattern.join(' ') + ' .'
@@ -639,6 +660,16 @@ module SPARQL
     # @see    http://www.w3.org/TR/sparql11-protocol/#query-operation
     def request(query, headers = {}, &block)
       method = (self.options[:method] || DEFAULT_METHOD).to_sym
+
+      # Make sure an appropriate Accept header is present
+      headers['Accept'] ||= if (query.respond_to?(:expects_statements?) ?
+                                query.expects_statements? :
+                                (query =~ /CONSTRUCT|DESCRIBE|DELETE|CLEAR/))
+        GRAPH_ALL
+      else
+        RESULT_ALL
+      end
+
       request = send("make_#{method}_request", query, headers)
 
       request.basic_auth(url.user, url.password) if url.user && !url.user.empty?
@@ -674,7 +705,12 @@ module SPARQL
     # @see    http://www.w3.org/TR/sparql11-protocol/#query-via-post-direct
     # @see    http://www.w3.org/TR/sparql11-protocol/#query-via-post-urlencoded
     def make_post_request(query, headers = {})
-      request = Net::HTTP::Post.new(self.url.request_uri, self.headers.merge(headers))
+      if @alt_endpoint.nil?
+        endpoint = url.request_uri 
+      else
+        endpoint = @alt_endpoint
+      end
+      request = Net::HTTP::Post.new(endpoint, self.headers.merge(headers))
       case (self.options[:protocol] || DEFAULT_PROTOCOL).to_s
         when '1.1'
           request['Content-Type'] = 'application/sparql-' + (@op || :query).to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sparql-client
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Arto Bendiken
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-30 00:00:00.000000000 Z
+date: 2014-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf