rdf-sesame 0.3.0 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e40256223226ea6aca7ac314a678ebe951af0782
+  data.tar.gz: 9f1e93a0eb52901a3881c50fd93f9a03c27ad715
+SHA512:
+  metadata.gz: a92457e1ba0067058fa2c23480c66d692adfdba488cabcfb2a5bb4c1025acc8835fe56ee38e56f8b0d47d743656d7bde37f58a398fdfe64a091326c9a7bd1eef
+  data.tar.gz: 3fcf0943353f42ef7981ca80416e93c7014a8412123cd9eb2bf8de2028f138055f9aed76488be131e92e8e95d8b40a7bc8ae47ccb4d3807668b1733b0afb6df0

data/README

@@ -82,7 +82,8 @@ Author
 Contributors
 ------------
 
-Refer to the accompanying {file:CREDITS} file.
+* [Aymeric Brisse](http://github.com/abrisse)
+* [Slava Kravchenko](http://github.com/cordawyn)
 
 License
 -------

data/VERSION

@@ -1 +1 @@
-0.3.0
+1.1.0

data/lib/rdf/sesame.rb

@@ -1,4 +1,12 @@
 require 'rdf'
+require 'rdf/sesame/exceptions'
+require 'rdf/sesame/connection'
+require 'rdf/sesame/repository'
+require 'rdf/sesame/server'
+require 'rdf/sesame/version'
+
+require 'pathname'
+require 'addressable/uri'
 
 module RDF
   ##
@@ -13,9 +21,5 @@ module RDF
   #
   # @author [Arto Bendiken](http://ar.to/)
   module Sesame
-    autoload :Connection, 'rdf/sesame/connection'
-    autoload :Repository, 'rdf/sesame/repository'
-    autoload :Server,     'rdf/sesame/server'
-    autoload :VERSION,    'rdf/sesame/version'
   end
 end

data/lib/rdf/sesame/connection.rb

@@ -21,13 +21,13 @@ module RDF::Sesame
   # call {#close} explicitly.
   #
   # @example Opening a connection to a Sesame server (1)
-  #   url  = RDF::URI("http://localhost:8080/openrdf-sesame")
+  #   url  = URI.parse("http://localhost:8080/openrdf-sesame")
   #   conn = RDF::Sesame::Connection.open(url)
   #   ...
   #   conn.close
   #
   # @example Opening a connection to a Sesame server (2)
-  #   url = RDF::URI("http://localhost:8080/openrdf-sesame")
+  #   url = URI.parse("http://localhost:8080/openrdf-sesame")
   #   RDF::Sesame::Connection.open(url) do |conn|
   #     ...
   #   end
@@ -41,8 +41,17 @@ module RDF::Sesame
   #
   # @see http://ruby-doc.org/core/classes/Net/HTTP.html
   class Connection
-    # @return [RDF::URI]
-    attr_reader :url
+    # @return [String]
+    attr_reader :user
+
+    # @return [String]
+    attr_reader :pass
+
+    # @return [String]
+    attr_reader :proxy_host
+
+    # @return [Number]
+    attr_reader :proxy_port
 
     # @return [Hash{Symbol => Object}]
     attr_reader :options
@@ -67,7 +76,7 @@ module RDF::Sesame
       self.new(url, options) do |conn|
         if conn.open(options) && block_given?
           case block.arity
-            when 1 then block.call(conn)
+            when 1 then yield conn
             else conn.instance_eval(&block)
           end
         else
@@ -83,24 +92,27 @@ module RDF::Sesame
     # @param  [Hash{Symbol => Object}] options
     # @yield  [connection]
     # @yieldparam [Connection]
-    def initialize(url, options = {}, &block)
-      require 'addressable/uri' unless defined?(Addressable)
-      @url = case url
-        when Addressable::URI then url
-        else Addressable::URI.parse(url.to_s)
-      end
+    def initialize(url = nil, options = {}, &block)
+      url ||= "http://localhost:8080/openrdf-sesame"
+      parsed = URI.parse(url.to_s)
+
+      @user = options.delete(:user) || parsed.user || nil
+      @pass = options.delete(:pass) || parsed.password || nil
 
       # Preserve only those URI components that we actually require for
       # establishing a connection to the HTTP server in question:
-      @url = RDF::URI.new(to_hash)
+      parsed.user = parsed.password = nil
+      @url = parsed
 
+      @proxy_host = options.delete(:proxy_host) || nil
+      @proxy_port = options.delete(:proxy_port) || nil
       @headers   = options.delete(:headers) || {}
       @options   = options
       @connected = false
 
       if block_given?
         case block.arity
-          when 1 then block.call(self)
+          when 1 then yield self
           else instance_eval(&block)
         end
       end
@@ -128,7 +140,7 @@ module RDF::Sesame
     #
     # @return [Symbol]
     def scheme
-      url.scheme.to_s.to_sym
+      @url.scheme.to_s.to_sym
     end
 
     ##
@@ -137,7 +149,7 @@ module RDF::Sesame
     #
     # @return [Boolean]
     def userinfo?
-      !url.userinfo.nil?
+      !@url.userinfo.nil?
     end
 
     ##
@@ -145,7 +157,7 @@ module RDF::Sesame
     #
     # @return [String] "username:password"
     def userinfo
-      url.userinfo
+      @url.userinfo
     end
 
     ##
@@ -153,15 +165,7 @@ module RDF::Sesame
     #
     # @return [Boolean]
     def user?
-      !url.user.nil?
-    end
-
-    ##
-    # Returns any user name information for this connection.
-    #
-    # @return [String]
-    def user
-      url.user
+      !user.nil?
     end
 
     ##
@@ -169,15 +173,7 @@ module RDF::Sesame
     #
     # @return [Boolean]
     def password?
-      !url.password.nil?
-    end
-
-    ##
-    # Returns any password information for this connection.
-    #
-    # @return [String]
-    def password
-      url.password
+      !password.nil?
     end
 
     ##
@@ -185,7 +181,7 @@ module RDF::Sesame
     #
     # @return [String]
     def host
-      url.host.to_s
+      @url.host.to_s
     end
 
     alias_method :hostname, :host
@@ -196,7 +192,7 @@ module RDF::Sesame
     #
     # @return [Boolean]
     def port?
-      !url.port.nil? && url.port != (insecure? ? 80 : 443)
+      !@url.port.nil? && @url.port != (insecure? ? 80 : 443)
     end
 
     ##
@@ -204,20 +200,7 @@ module RDF::Sesame
     #
     # @return [Integer]
     def port
-      url.port
-    end
-
-    ##
-    # Returns a `Hash` representation of this connection.
-    #
-    # @return [Hash{Symbol => Object}]
-    def to_hash
-      {
-        :scheme   => url.scheme,
-        :userinfo => url.userinfo,
-        :host     => url.host,
-        :port     => url.port,
-      }
+      @url.port
     end
 
     ##
@@ -225,7 +208,7 @@ module RDF::Sesame
     #
     # @return [RDF::URI]
     def to_uri
-      url
+      @url
     end
 
     ##
@@ -233,7 +216,7 @@ module RDF::Sesame
     #
     # @return [String]
     def to_s
-      url.to_s
+      @url.to_s
     end
 
     ##
@@ -252,14 +235,14 @@ module RDF::Sesame
     # @yieldparam [Connection] connection
     # @raise  [TimeoutError] if the connection could not be opened
     # @return [Connection]
-    def open(options = {}, &block)
+    def open(options = {})
       unless connected?
         # TODO: support persistent connections
         @connected = true
       end
 
       if block_given?
-        result = block.call(self)
+        result = yield self
         close
         result
       else
@@ -292,11 +275,13 @@ module RDF::Sesame
     # @yield  [response]
     # @yieldparam [Net::HTTPResponse] response
     # @return [Net::HTTPResponse]
-    def get(path, headers = {}, &block)
-      Net::HTTP.start(host, port) do |http|
-        response = http.get(path.to_s, @headers.merge(headers))
+    def get(path, headers = {})
+      Net::HTTP::Proxy(@proxy_host, @proxy_port).start(host, port, :use_ssl => self.secure?) do |http|
+        request = Net::HTTP::Get.new(url(path.to_s), @headers.merge(headers))
+        request.basic_auth @user, @pass unless @user.nil? || @pass.nil?
+        response = http.request(request)
         if block_given?
-          block.call(response)
+          yield response
         else
           response
         end
@@ -312,11 +297,14 @@ module RDF::Sesame
     # @yield  [response]
     # @yieldparam [Net::HTTPResponse] response
     # @return [Net::HTTPResponse]
-    def post(path, data, headers = {}, &block)
-      Net::HTTP.start(host, port) do |http|
-        response = http.post(path.to_s, data.to_s, @headers.merge(headers))
+    def post(path, data, headers = {})
+     Net::HTTP::Proxy(@proxy_host, @proxy_port).start(host, port, :use_ssl => self.secure?) do |http|
+        request = Net::HTTP::Post.new(url(path.to_s), @headers.merge(headers))
+        request.body = data.to_s
+        request.basic_auth @user, @pass unless @user.nil? || @pass.nil?
+        response = http.request(request)
         if block_given?
-          block.call(response)
+          yield response
         else
           response
         end
@@ -331,8 +319,20 @@ module RDF::Sesame
     # @yield  [response]
     # @yieldparam [Net::HTTPResponse] response
     # @return [Net::HTTPResponse]
-    def put(path, headers = {}, &block)
-      raise NotImplementedError, "#{self.class}#put" # TODO
+    def put(path, data, headers = {})
+      Net::HTTP::Proxy(@proxy_host, @proxy_port).start(host, port, :use_ssl => self.secure?) do |http|
+        request = Net::HTTP::Put.new(url(path.to_s), @headers.merge(headers))
+        request.body = data.to_s
+        request.basic_auth @user, @pass unless @user.nil? || @pass.nil?
+        response = http.request(request)
+        http.request(request) do |response|
+          if block_given?
+            yield response
+          else
+            response
+          end
+        end
+      end
     end
 
     ##
@@ -343,15 +343,25 @@ module RDF::Sesame
     # @yield  [response]
     # @yieldparam [Net::HTTPResponse] response
     # @return [Net::HTTPResponse]
-    def delete(path, headers = {}, &block)
-      Net::HTTP.start(host, port) do |http|
-        response = http.delete(path.to_s, @headers.merge(headers))
+    def delete(path, headers = {})
+      Net::HTTP::Proxy(@proxy_host, @proxy_port).start(host, port, :use_ssl => self.secure?) do |http|
+        request = Net::HTTP::Delete.new(url(path.to_s), @headers.merge(headers))
+        request.basic_auth @user, @pass unless @user.nil? || @pass.nil?
+        response = http.request(request)
         if block_given?
-          block.call(response)
+          yield response
         else
           response
         end
       end
     end
+
+    def url(path)
+      if path
+        "#{@url}/#{path}"
+      else
+        @url.to_s
+      end
+    end
   end # class Connection
 end # module RDF::Sesame

data/lib/rdf/sesame/exceptions.rb

@@ -0,0 +1,5 @@
+module RDF::Sesame
+  class ClientError < StandardError; end
+  class MalformedQuery < ClientError; end
+  class ServerError < StandardError; end
+end

data/lib/rdf/sesame/repository.rb

@@ -26,10 +26,6 @@ module RDF::Sesame
   # @see http://www.openrdf.org/doc/sesame2/system/ch08.html
   # @see http://rdf.rubyforge.org/RDF/Repository.html
   class Repository < RDF::Repository
-    # @return [RDF::URI]
-    attr_reader  :url
-    alias_method :uri, :url
-
     # @return [String]
     attr_reader :id
 
@@ -39,11 +35,20 @@ module RDF::Sesame
     # @return [Server]
     attr_reader :server
 
+    # @return [String]
+    attr_reader :readable
+
+    # @return [String]
+    attr_reader :writeble
+
+    # @return [String,Array]
+    attr_reader :context
+
     ##
     # Initializes this `Repository` instance.
     #
     # @overload initialize(url)
-    #   @param  [String, RDF::URI] url
+    #   @param  [String, URI, RDF::URI] url
     #   @yield  [repository]
     #   @yieldparam [Repository]
     #
@@ -56,73 +61,80 @@ module RDF::Sesame
     #   @yieldparam [Repository]
     #
     def initialize(url_or_options, &block)
+      options = {}
       case url_or_options
-        when String
-          initialize(RDF::URI.new(url_or_options), &block)
-
-        when RDF::URI
-          require 'pathname' unless defined?(Pathname)
-          @uri     = url_or_options
-          @server  = Server.new(RDF::URI.new({
-            :scheme   => @uri.scheme,
-            :userinfo => @uri.userinfo,
-            :host     => @uri.host,
-            :port     => @uri.port,
-            :path     => Pathname.new(@uri.path).parent.parent.to_s, # + '../..'
-          }))
-          @options = {}
+        when String, RDF::URI, URI
+          pathname = Pathname.new(url_or_options.to_s)
+          @server = Server.new(pathname.parent.parent.to_s)
+          @id = pathname.basename.to_s
 
         when Hash
           raise ArgumentError, "missing options[:server]" unless url_or_options.has_key?(:server)
           raise ArgumentError, "missing options[:id]"     unless url_or_options.has_key?(:id)
-          @options = url_or_options.dup
-          @server  = @options.delete(:server)
-          @id      = @options.delete(:id)
-          @uri     = @options.delete(:uri) || server.url("repositories/#{@id}")
-          @title   = @options.delete(:title)
+          options    = url_or_options.dup
+          @server    = options.delete(:server)
+          @id        = options.delete(:id)
+          @readable  = options.delete(:readable)
+          @writable  = options.delete(:writable)
 
         else
           raise ArgumentError, "expected String, RDF::URI or Hash, but got #{url_or_options.inspect}"
       end
 
-      if block_given?
-        case block.arity
-          when 1 then block.call(self)
-          else instance_eval(&block)
-        end
-      end
+      super(options)
+    end
+
+    #
+    # Returns the URL for the given server-relative `path`.
+    #
+    # @example Getting a Sesame server's URL
+    #   server.url            #=> "http://localhost:8080/openrdf-sesame"
+
+    # @example Getting a Sesame server's protocol URL
+    #   server.url(:protocol) #=> "http://localhost:8080/openrdf-sesame/protocol"
+    #
+    # @param  [String, #to_s] path
+    # @return [String]
+    def url(relative_path = nil)
+      self.server.url(path(relative_path))
     end
 
     ##
-    # Returns the URL for the given repository-relative `path`.
+    # Returns the server-relative path for the given repository-relative `path`.
     #
     # @param  [String, #to_s]        path
     # @param  [Hash, RDF::Statement] query
-    # @return [RDF::URI]
-    def url(path = nil, query = {})
-      url = path ? RDF::URI.new("#{@uri}/#{path}") : @uri.dup # FIXME
+    # @return [String]
+    def path(path = nil, query = {})
+      url =  RDF::URI.new(path ? "repositories/#{@id}/#{path}" : "repositories/#{@id}")
       unless query.nil?
         case query
           when RDF::Statement
             writer = RDF::NTriples::Writer.new
-            query  = {
+            q  = {
               :subj    => writer.format_value(query.subject),
               :pred    => writer.format_value(query.predicate),
-              :obj     => writer.format_value(query.object),
-              :context => query.has_context? ? writer.format_value(query.context) : 'null',
+              :obj     => writer.format_value(query.object)
             }
-            url.query_values = query
+            q.merge!(:context => writer.format_value(query.context)) if query.has_context?
+            url.query_values = q
           when Hash
             url.query_values = query unless query.empty?
         end
       end
-      return url
+      return url.to_s
     end
 
     alias_method :uri, :url
 
     ##
+    # A mapping of blank node results for this client
     # @private
+    def nodes
+      @nodes ||= {}
+    end
+
+    ##
     # @see RDF::Repository#supports?
     def supports?(feature)
       case feature.to_sym
@@ -132,80 +144,94 @@ module RDF::Sesame
     end
 
     ##
-    # @private
     # @see RDF::Durable#durable?
     def durable?
       true # TODO: would need to query the SYSTEM repository for this information
     end
 
     ##
-    # @private
     # @see RDF::Countable#empty?
     def empty?
       count.zero?
     end
 
     ##
-    # @private
     # @see RDF::Countable#count
     # @see http://www.openrdf.org/doc/sesame2/system/ch08.html#d0e569
     def count
-      server.get(url(:size)) do |response|
-        case response
-          when Net::HTTPSuccess
-            size = response.body
-            size.to_i rescue 0
-          else -1 # FIXME: raise error
-        end
+      response = server.get(path(:size, statements_options))
+      begin
+        size = response.body
+        size.to_i
+      rescue
+        0
       end
     end
 
     ##
-    # @private
     # @see RDF::Enumerable#has_triple?
     def has_triple?(triple)
       has_statement?(RDF::Statement.from(triple))
     end
 
     ##
-    # @private
     # @see RDF::Enumerable#has_quad?
     def has_quad?(quad)
       has_statement?(RDF::Statement.new(quad[0], quad[1], quad[2], :context => quad[3]))
     end
 
     ##
-    # @private
     # @see RDF::Enumerable#has_statement?
     # @see http://www.openrdf.org/doc/sesame2/system/ch08.html#d0e304
     def has_statement?(statement)
-      server.get(url(:statements, statement), 'Accept' => 'text/plain') do |response|
-        case response
-          when Net::HTTPSuccess
-            !response.body.empty?
-          else false
-        end
-      end
+      response = server.get(path(:statements, statement), 'Accept' => 'text/plain')
+      !response.body.empty?
+    end
+
+    ##
+    # Returns `true` if `self` contains the given RDF subject term.
+    #
+    # @param  [RDF::Resource] value
+    # @return [Boolean]
+    def has_subject?(value)
+      !first([value, nil, nil]).nil?
+    end
+
+    ##
+    # Returns `true` if `self` contains the given RDF predicate term.
+    #
+    # @param  [RDF::URI] value
+    # @return [Boolean]
+    def has_predicate?(value)
+      !first([nil, value, nil]).nil?
+    end
+
+    ##
+    # Returns `true` if `self` contains the given RDF object term.
+    #
+    # @param  [RDF::Term] value
+    # @return [Boolean]
+    def has_object?(value)
+      !first([nil, nil, value]).nil?
     end
 
     ##
-    # @private
     # @see RDF::Enumerable#each_statement
     # @see http://www.openrdf.org/doc/sesame2/system/ch08.html#d0e304
-    def each_statement(&block)
+    def each_statement
       return enum_statement unless block_given?
 
-      [nil, *enum_context].uniq.each do |context|
-        ctxt = context ? RDF::NTriples.serialize(context) : 'null'
-        server.get(url(:statements, :context => ctxt), 'Accept' => 'text/plain') do |response|
-          case response
-            when Net::HTTPSuccess
-              reader = RDF::NTriples::Reader.new(response.body)
-              reader.each_statement do |statement|
-                statement.context = context
-                block.call(statement)
-              end
-          end
+      # Each context will trigger a query that will be parsed with a NTriples::Reader.
+      # This is for performance. Otherwise only one query with TriG::Reader will be
+      # necessary
+
+      ['null', *enum_context].uniq.each do |context|
+        query = {}
+        query.merge!(:context => serialize_context(context)) if context
+        response = server.get(path(:statements, query), 'Accept' => 'text/plain')
+        RDF::NTriples::Reader.new(response.body).each_statement do |statement|
+          statement.context = context
+          yield statement
         end
       end
     end
@@ -213,25 +239,120 @@ module RDF::Sesame
     alias_method :each, :each_statement
 
     ##
-    # @private
     # @see RDF::Enumerable#each_context
-    def each_context(&block)
+    def each_context
       return enum_context unless block_given?
 
       require 'json' unless defined?(::JSON)
-      server.get(url(:contexts), Server::ACCEPT_JSON) do |response|
-        case response
-          when Net::HTTPSuccess
-            json = ::JSON.parse(response.body)
-            json['results']['bindings'].map { |binding| binding['contextID'] }.each do |context_id|
-              context = case context_id['type'].to_s.to_sym
-                when :bnode then RDF::Node.new(context_id['value'])
-                when :uri   then RDF::URI.new(context_id['value'])
-              end
-              block.call(context) if context
-            end
-        end
+      response = server.get(path(:contexts), Server::ACCEPT_JSON)
+      json = ::JSON.parse(response.body)
+      json['results']['bindings'].map { |binding| binding['contextID'] }.each do |context_id|
+        context = case context_id['type'].to_s.to_sym
+                  when :bnode then RDF::Node.new(context_id['value'])
+                  when :uri   then RDF::URI.new(context_id['value'])
+                  else
+                    nil
+                  end
+        yield context if context
+      end
+    end
+
+    # Run a raw SPARQL query.
+    #
+    # @overload sparql_query(query) {|solution| ... }
+    #   @yield solution
+    #   @yieldparam [RDF::Query::Solution] solution
+    #   @yieldreturn [void]
+    #   @return [void]
+    #
+    # @overload sparql_query(pattern)
+    #   @return [Enumerator<RDF::Query::Solution>]
+    #
+    # @param [String] query The query to run.
+    # @param [Hash{Symbol => Object}] options
+    #   The query options (see build_query).
+    # @return [void]
+    #
+    # @see #build_query
+    def sparql_query(query, options={}, &block)
+      raw_query(query, 'sparql', options, &block)
+    end
+
+    ##
+    # Returns all statements of the given query.
+    #
+    # @private
+    # @param  [String, #to_s]        query
+    # @param  [String, #to_s]        queryLn
+    # @return [RDF::Enumerator]
+    def raw_query(query, queryLn = 'sparql', options={}, &block)
+      options = { infer: true }.merge(options)
+
+      response = if query =~ /\b(delete|insert)\b/i
+        write_query(query, queryLn, options)
+      else
+        read_query(query, queryLn, options)
+      end
+    end
+
+    def read_query(query, queryLn, options)
+      if queryLn == 'sparql' and options[:format].nil? and query =~ /\bconstruct\b/i
+        options[:format] = Server::ACCEPT_NTRIPLES
+      end
+
+      options[:format] = Server::ACCEPT_JSON unless options[:format]
+
+      params = Addressable::URI.form_encode({ :query => query, :queryLn => queryLn, :infer => options[:infer] }).gsub("+", "%20").to_s
+      url = Addressable::URI.parse(path)
+      unless url.normalize.query.nil?
+        url.query = [url.query, params].compact.join('&')
+      else
+        url.query = [url.query, params].compact.join('?')
+      end
+      response = server.get(url, options[:format])
+
+      results = parse_response(response)
+      if block_given?
+        results.each {|s| yield s }
+      else
+        results
+      end
+    end
+
+    def write_query(query, queryLn, options)
+      parameters = {}
+      parameters[:update] = query
+      response = server.post(path(:statements), Addressable::URI.form_encode(parameters), 'Content-Type' => 'application/x-www-form-urlencoded')
+      response.code == "204"
+    end
+
+    # Set a global context that will be used for any statements request
+    #
+    # @param context the context(s) to use
+    def set_context(*context)
+      options||={}
+      @context = serialize_context(context)
+    end
+
+    ##
+    # # Clear all statements from the repository.
+    # @see RDF::Mutable#clear
+    # @see http://www.openrdf.org/doc/sesame2/system/ch08.html#d0e304
+    #
+    # @param [Hash] options
+    # @option options [String] :subject Match a specific subject
+    # @option options [String] :predicate Match a specific predicate
+    # @option options [String] :object Match a specific object
+    # @option options [String] :context Match a specific graph name.
+    # @return [void]
+    def clear(options={})
+      parameters = {}
+      { :subject => :subj, :predicate => :pred, :object => :obj, :context => :context }.each do |option_key, parameter_key|
+        value = options[option_key]
+        parameters.merge! parameter_key => RDF::NTriples.serialize(RDF::URI.new(value)) if value
       end
+      response = server.delete(path(:statements, statements_options.merge(parameters)))
+      response.code == "204"
     end
 
   protected
@@ -239,23 +360,39 @@ module RDF::Sesame
     ##
     # @private
     # @see RDF::Queryable#query
-    def query_pattern(pattern, &block)
-      super # TODO
+    def query_pattern(pattern)
+      writer = RDF::NTriples::Writer.new
+      query = {}
+      query.merge!(:context => writer.format_value(pattern.context)) if pattern.has_context?
+      query.merge!(:subj => writer.format_value(pattern.subject)) unless pattern.subject.is_a?(RDF::Query::Variable) || pattern.subject.nil?
+      query.merge!(:pred => writer.format_value(pattern.predicate)) unless pattern.predicate.is_a?(RDF::Query::Variable) || pattern.predicate.nil?
+      query.merge!(:obj => writer.format_value(pattern.object)) unless pattern.object.is_a?(RDF::Query::Variable) || pattern.object.nil?
+      response = server.get(path(:statements, query), Server::ACCEPT_NTRIPLES)
+      RDF::NTriples::Reader.new(response.body).each_statement do |statement|
+        statement.context = pattern.context
+        yield statement
+      end
     end
 
+    #--------------------------------------------------------------------
+    # @group RDF::Mutable methods
+
     ##
     # @private
     # @see RDF::Mutable#insert
     # @see http://www.openrdf.org/doc/sesame2/system/ch08.html#d0e304
     def insert_statement(statement)
-      ctxt = statement.has_context? ? RDF::NTriples.serialize(statement.context) : 'null'
-      data = RDF::NTriples.serialize(statement)
-      server.post(url(:statements, :context => ctxt), data, 'Content-Type' => 'text/plain') do |response|
-        case response
-          when Net::HTTPSuccess then true
-          else false
-        end
-      end
+      insert_statements([statement])
+    end
+
+    ##
+    # @private
+    # @see RDF::Mutable#insert
+    # @see http://www.openrdf.org/doc/sesame2/system/ch08.html#d0e304
+    def insert_statements(statements)
+      data = statements_to_text_plain(statements)
+      response = server.post(path(:statements, statements_options), data, 'Content-Type' => 'text/plain')
+      response.code == "204"
     end
 
     ##
@@ -263,25 +400,165 @@ module RDF::Sesame
     # @see RDF::Mutable#delete
     # @see http://www.openrdf.org/doc/sesame2/system/ch08.html#d0e304
     def delete_statement(statement)
-      server.delete(url(:statements, statement)) do |response|
-        case response
-          when Net::HTTPSuccess then true
-          else false
-        end
+      response = server.delete(path(:statements, statement))
+      response.code == "204"
+    end
+
+  private
+
+    # Convert a list of statements to a text-plain-compatible text.
+    def statements_to_text_plain(statements)
+      graph = RDF::Repository.new
+      statements.each do |s|
+        graph << s
       end
+      RDF::NTriples::Writer.dump(graph, nil, :encoding => Encoding::ASCII)
     end
 
     ##
+    # @param [Net::HTTPSuccess] response
+    # @param [Hash{Symbol => Object}] options
+    # @return [Object]
+    def parse_response(response, options = {})
+      case content_type = options[:content_type] || response.content_type
+        when Server::RESULT_BOOL
+          response.body == 'true'
+        when Server::RESULT_JSON
+          self.class.parse_json_bindings(response.body, nodes)
+        when Server::RESULT_XML
+          self.class.parse_xml_bindings(response.body, nodes)
+        else
+          parse_rdf_serialization(response, options)
+      end
+    end
+
+    ##
+    # @param [String, Hash] json
+    # @return [<RDF::Query::Solutions>]
+    # @see http://www.w3.org/TR/rdf-sparql-json-res/#results
+    def self.parse_json_bindings(json, nodes = {})
+      require 'json' unless defined?(::JSON)
+      json = JSON.parse(json.to_s) unless json.is_a?(Hash)
+
+      case
+        when json['boolean']
+          json['boolean']
+        when json['results']
+          solutions = RDF::Query::Solutions()
+          json['results']['bindings'].each do |row|
+            row = row.inject({}) do |cols, (name, value)|
+              cols.merge(name.to_sym => parse_json_value(value))
+            end
+            solutions << RDF::Query::Solution.new(row)
+          end
+          solutions
+      end
+    end
+
+    ##
+    # @param [Hash{String => String}] value
+    # @return [RDF::Value]
+    # @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
+        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
+
+    ##
+    # @param [String, REXML::Element] xml
+    # @return [<RDF::Query::Solutions>]
+    # @see http://www.w3.org/TR/rdf-sparql-json-res/#results
+    def self.parse_xml_bindings(xml, nodes = {})
+      xml.force_encoding(::Encoding::UTF_8) if xml.respond_to?(:force_encoding)
+      require 'rexml/document' unless defined?(::REXML::Document)
+      xml = REXML::Document.new(xml).root unless xml.is_a?(REXML::Element)
+
+      case
+        when boolean = xml.elements['boolean']
+          boolean.text == 'true'
+        when results = xml.elements['results']
+          solutions = RDF::Query::Solutions()
+          results.elements.each do |result|
+            row = {}
+            result.elements.each do |binding|
+              name = binding.attributes['name'].to_sym
+              value = binding.select { |node| node.kind_of?(::REXML::Element) }.first
+              row[name] = parse_xml_value(value, nodes)
+            end
+            solutions << RDF::Query::Solution.new(row)
+          end
+          solutions
+      end
+    end
+
+    ##
+    # @param [REXML::Element] value
+    # @return [RDF::Value]
+    # @see http://www.w3.org/TR/rdf-sparql-json-res/#variable-binding-results
+    def self.parse_xml_value(value, nodes = {})
+      case value.name.to_sym
+        when :bnode
+          nodes[id = value.text] ||= RDF::Node.new(id)
+        when :uri
+          RDF::URI.new(value.text)
+        when :literal
+          RDF::Literal.new(value.text, {
+            :language => value.attributes['xml:lang'],
+            :datatype => value.attributes['datatype'],
+          })
+        else nil
+      end
+    end
+
+    ##
+    # @param [Net::HTTPSuccess] response
+    # @param [Hash{Symbol => Object}] options
+    # @return [RDF::Enumerable]
+    def parse_rdf_serialization(response, options = {})
+      options = {:content_type => response.content_type} if options.empty?
+      if reader_for = RDF::Reader.for(options)
+        reader_for.new(response.body) do |reader|
+          reader # FIXME
+        end
+      end
+    end
+
     # @private
-    # @see RDF::Mutable#clear
-    # @see http://www.openrdf.org/doc/sesame2/system/ch08.html#d0e304
-    def clear_statements
-      server.delete(url(:statements)) do |response|
-        case response
-          when Net::HTTPSuccess then true
-          else false
+    #
+    # Serialize the context
+    def serialize_context(context)
+      context = [context] unless context.is_a?(Enumerable)
+      serialization = context.map do |c|
+        if c == 'null' or !c
+          c
+        else
+          RDF::NTriples.serialize(RDF::URI.new(c))
         end
       end
+
+      if serialization.size == 1
+        serialization.first
+      else
+        serialization
+      end
+    end
+
+    # @private
+    #
+    # Construct the statements options list
+    def statements_options
+      options = {}
+      options[:context] = @context if @context
+      options
     end
   end # class Repository
 end # module RDF::Sesame