sparql-client 0.0.0.pre → 0.0.1

data/README

@@ -0,0 +1,99 @@
+SPARQL Client for RDF.rb
+========================
+
+This is a pure-Ruby implementation of a [SPARQL][] client for [RDF.rb][].
+
+* <http://github.com/bendiken/sparql-client>
+
+Features
+--------
+
+* Queries SPARQL HTTP endpoints.
+
+Examples
+--------
+
+    require 'sparql/client'
+    
+    sparql = SPARQL::Client.new('http://dbpedia.org/sparql')
+
+### Executing a boolean query
+
+    result = sparql.query('ASK WHERE { ?s ?p ?o }')
+    
+    puts result.inspect   #=> true or false
+
+### Executing a tuple query
+
+    result = sparql.query('SELECT * WHERE { ?s ?p ?o } LIMIT 10')
+    
+    result.each do |bindings|
+      puts bindings.inspect
+    end
+
+### Executing a graph query
+
+    result = sparql.query('CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o } LIMIT 10')
+    
+    result.each_statement do |statement|
+      puts statement.inspect
+    end
+
+Documentation
+-------------
+
+<http://sparql.rubyforge.org/>
+
+* {SPARQL::Client}
+
+Dependencies
+------------
+
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.1.5)
+* [JSON](http://rubygems.org/gems/json_pure) (>= 1.2.3)
+
+Installation
+------------
+
+The recommended installation method is via [RubyGems](http://rubygems.org/).
+To install the latest official release of the `SPARQL::Client` gem, do:
+
+    % [sudo] gem install sparql-client
+
+Download
+--------
+
+To get a local working copy of the development repository, do:
+
+    % git clone git://github.com/bendiken/sparql-client.git
+
+Alternatively, you can download the latest development version as a tarball
+as follows:
+
+    % wget http://github.com/bendiken/sparql-client/tarball/master
+
+Resources
+---------
+
+* <http://sparql.rubyforge.org/>
+* <http://github.com/bendiken/sparql-client>
+* <http://rubygems.org/gems/sparql-client>
+* <http://rubyforge.org/projects/sparql/>
+* <http://raa.ruby-lang.org/project/sparql-client/>
+* <http://www.ohloh.net/p/rdf>
+
+Authors
+-------
+
+* [Arto Bendiken](mailto:arto.bendiken@gmail.com) - <http://ar.to/>
+* [Ben Lavender](mailto:blavender@gmail.com) - <http://bhuga.net/>
+
+License
+-------
+
+`SPARQL::Client` is free and unencumbered public domain software. For more
+information, see <http://unlicense.org/> or the accompanying UNLICENSE file.
+
+[RDF]:      http://www.w3.org/RDF/
+[SPARQL]:   http://en.wikipedia.org/wiki/SPARQL
+[RDF.rb]:   http://rdf.rubyforge.org/

data/VERSION

@@ -1 +1 @@
-0.0.0.pre
+0.0.1

data/lib/sparql/client.rb

@@ -1,8 +1,201 @@
+require 'net/http'
+require 'rdf'
+require 'rdf/ntriples'
 require 'sparql/version'
 
 module SPARQL
   ##
+  # A SPARQL client for RDF.rb.
   class Client
-    # TODO
+    RESULT_BOOL = 'text/boolean'.freeze # Sesame-specific
+    RESULT_JSON = 'application/sparql-results+json'.freeze
+    RESULT_XML  = 'application/sparql-results+xml'.freeze
+    ACCEPT_JSON = {'Accept' => RESULT_JSON}.freeze
+    ACCEPT_XML  = {'Accept' => RESULT_XML}.freeze
+
+    attr_reader :url
+    attr_reader :options
+
+    ##
+    # @param  [String, #to_s]          url
+    # @param  [Hash{Symbol => Object}] options
+    def initialize(url, options = {}, &block)
+      @url, @options = RDF::URI.new(url.to_s), options
+      @headers = {'Accept' => "#{RESULT_XML}, #{RESULT_JSON}, text/plain"}
+
+      if block_given?
+        case block.arity
+          when 1 then block.call(self)
+          else instance_eval(&block)
+        end
+      end
+    end
+
+    ##
+    # Executes a SPARQL query.
+    #
+    # @param  [String, #to_s]          url
+    # @param  [Hash{Symbol => Object}] options
+    def query(query, options = {})
+      get(query.to_s) do |response|
+        case response
+          when Net::HTTPClientError
+            abort response.inspect # FIXME
+          when Net::HTTPServerError
+            abort response.inspect # FIXME
+          when Net::HTTPSuccess
+            parse_response(response)
+        end
+      end
+    end
+
+    ##
+    # @param  [Net::HTTPSuccess] response
+    # @return [Object]
+    def parse_response(response)
+      case content_type = response.content_type
+        when RESULT_BOOL # Sesame-specific
+          response.body == 'true'
+        when RESULT_JSON
+          parse_json_bindings(response.body)
+        when RESULT_XML
+          parse_xml_bindings(response.body)
+        else
+          parse_rdf_serialization(response)
+      end
+    end
+
+    ##
+    # @param  [String, Hash] json
+    # @return [Enumerable<RDF::Query::Solution>]
+    # @see    http://www.w3.org/TR/rdf-sparql-json-res/#results
+    def parse_json_bindings(json)
+      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']
+          json['results']['bindings'].map do |row|
+            row = row.inject({}) do |cols, (name, value)|
+              cols.merge(name => parse_json_value(value))
+            end
+            RDF::Query::Solution.new(row)
+          end
+      end
+    end
+
+    ##
+    # @param  [Hash{String => String}] value
+    # @return [RDF::Value]
+    # @see    http://www.w3.org/TR/rdf-sparql-json-res/#variable-binding-results
+    def parse_json_value(value)
+      case value['type'].to_sym
+        when :bnode
+          @nodes ||= {}
+          @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 [Enumerable<RDF::Query::Solution>]
+    # @see    http://www.w3.org/TR/rdf-sparql-json-res/#results
+    def parse_xml_bindings(xml)
+      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']
+          results.elements.map 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)
+            end
+            RDF::Query::Solution.new(row)
+          end
+      end
+    end
+
+    ##
+    # @param  [REXML::Element] value
+    # @return [RDF::Value]
+    # @see    http://www.w3.org/TR/rdf-sparql-json-res/#variable-binding-results
+    def parse_xml_value(value)
+      case value.name.to_sym
+        when :bnode
+          @nodes ||= {}
+          @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
+    # @return [RDF::Enumerable]
+    def parse_rdf_serialization(response)
+      if reader = RDF::Reader.for(:content_type => response.content_type)
+        reader.new(response.body)
+      end
+    end
+
+    ##
+    # Outputs a developer-friendly representation of this object to `stderr`.
+    #
+    # @return [void]
+    def inspect!
+      warn(inspect)
+    end
+
+    ##
+    # Returns a developer-friendly representation of this object.
+    #
+    # @return [String]
+    def inspect
+      sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, url.to_s)
+    end
+
+    protected
+
+    ##
+    # Performs an HTTP GET request against the SPARQL endpoint.
+    #
+    # @param  [String, #to_s]          query
+    # @param  [Hash{String => String}] headers
+    # @yield  [response]
+    # @yieldparam [Net::HTTPResponse] response
+    # @return [Net::HTTPResponse]
+    def get(query, headers = {}, &block)
+      url = self.url.dup
+      url.query_values = {:query => query.to_s}
+
+      Net::HTTP.start(url.host, url.port) do |http|
+        response = http.get(url.path + "?#{url.query}", @headers.merge(headers))
+        if block_given?
+          block.call(response)
+        else
+          response
+        end
+      end
+    end
   end
 end

data/lib/sparql/version.rb

@@ -2,8 +2,8 @@ module SPARQL; class Client
   module VERSION
     MAJOR = 0
     MINOR = 0
-    TINY  = 0
-    EXTRA = :pre
+    TINY  = 1
+    EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY].join('.')
     STRING << ".#{EXTRA}" if EXTRA

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: sparql-client
 version: !ruby/object:Gem::Version 
-  prerelease: true
+  prerelease: false
   segments: 
   - 0
   - 0
-  - 0
-  - pre
-  version: 0.0.0.pre
+  - 1
+  version: 0.0.1
 platform: ruby
 authors: 
 - Arto Bendiken
@@ -125,13 +124,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.8.2
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version 
       segments: 
-      - 1
-      - 3
-      - 1
-      version: 1.3.1
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: sparql