redlander 0.4.0 → 0.5.0

data/ChangeLog

@@ -1,3 +1,11 @@
+redlander (0.5.0)
+
+  * Model#query for queries in SPARQL (and other supported languages)
+  * model.statements.size is obsolete, use model.size or model.statements.count
+  * model.statements.delete_all accepts a pattern to delete only matching statements
+  * added "model.statements.exist?" checker, with a pattern
+  * bugfixes
+
 redlander (0.4.0)
 
   * deprecated Parser, Serializer, Storage, Stream and related classes and modules

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redlander (0.4.0)
+    redlander (0.5.0)
       ffi (~> 1.1)
       xml_schema (~> 0.1.0)
 

data/README.rdoc

@@ -59,6 +59,20 @@ You can access the subject, predicate or object of a statement:
 
 Please refer to Redlander::Node API doc for details.
 
+You can also use different query languages supported by librdf ("SPARQL 1.0" being a default):
+
+  $ m.query("SELECT ?s ?p ?o WHERE {}")  # => [{"s" => ..., "p" => ..., "o" => ...}, ...]
+
+"ASK" queries return true/false, "SELECT" queries return arrays of binding hashes,
+"CONSTRUCT" queries return an instance of a new memory-based model comprised from
+the statements constructed by the query.
+You can also supply a block to Model#query, which is ignored by ASK queries, but
+yields the statements constructed by CONSTRUCT queries and yields the binding
+hash for SELECT queries. Binding hash values are instances of Redlander::Node.
+
+For query options and available query languages refer to Model#query documentation.
+
+
 == Parsing Input
 
 You can fill your model with statements by parsing some external sources like plain or streamed data.
@@ -72,7 +86,7 @@ If the input is too large, you may prefer streaming it:
   $ m.from(source, :format => "ntriples")
 
 If you want to get the data from a local file, you can use "file://" schema for your URI
-(or Redlander::Uri) or use "from_file" method with a local file name (without schema):
+or use "from_file" method with a local file name (without schema):
 
   $ m.from_file("../data.ttl", :format => "turtle")
 

data/lib/redland.rb

@@ -27,10 +27,12 @@ module Redland
   attach_function :librdf_model_size, [:pointer], :int
   attach_function :librdf_model_find_statements, [:pointer, :pointer], :pointer
   attach_function :librdf_model_add_statement, [:pointer, :pointer], :int
+  attach_function :librdf_model_add_statements, [:pointer, :pointer], :int
   attach_function :librdf_model_remove_statement, [:pointer, :pointer], :int
   attach_function :librdf_model_transaction_start, [:pointer], :int
   attach_function :librdf_model_transaction_commit, [:pointer], :int
   attach_function :librdf_model_transaction_rollback, [:pointer], :int
+  attach_function :librdf_model_query_execute, [:pointer, :pointer], :pointer
 
   # Statement
   attach_function :librdf_free_statement, [:pointer], :void
@@ -85,4 +87,25 @@ module Redland
   attach_function :librdf_free_uri, [:pointer], :void
   attach_function :librdf_uri_to_string, [:pointer], :string
   attach_function :librdf_uri_equals, [:pointer, :pointer], :int
+
+  # Query
+  attach_function :librdf_new_query, [:pointer, :string, :pointer, :string, :pointer], :pointer
+  attach_function :librdf_free_query, [:pointer], :void
+  attach_function :librdf_query_get_limit, [:pointer], :int
+  attach_function :librdf_query_set_limit, [:pointer, :int], :int
+  attach_function :librdf_query_get_offset, [:pointer], :int
+  attach_function :librdf_query_set_limit, [:pointer, :int], :int
+  attach_function :librdf_query_results_is_bindings, [:pointer], :int
+  attach_function :librdf_query_results_is_boolean, [:pointer], :int
+  attach_function :librdf_query_results_is_graph, [:pointer], :int
+  attach_function :librdf_query_results_is_syntax, [:pointer], :int
+  attach_function :librdf_query_results_get_binding_name, [:pointer, :int], :string
+  attach_function :librdf_query_results_get_binding_value, [:pointer, :int], :pointer
+  attach_function :librdf_query_results_get_binding_value_by_name, [:pointer, :string], :pointer
+  attach_function :librdf_query_results_get_bindings_count, [:pointer], :int
+  attach_function :librdf_query_results_get_boolean, [:pointer], :int
+  attach_function :librdf_query_results_as_stream, [:pointer], :pointer
+  attach_function :librdf_query_results_next, [:pointer], :int
+  attach_function :librdf_query_results_finished, [:pointer], :int
+  attach_function :librdf_free_query_results, [:pointer], :void
 end

data/lib/redlander/model.rb

@@ -1,6 +1,7 @@
 require 'redlander/parsing'
 require 'redlander/serializing'
 require 'redlander/model_proxy'
+require "redlander/query/results"
 
 module Redlander
   # The core object incorporating the repository of RDF statements.
@@ -66,6 +67,60 @@ module Redlander
       ModelProxy.new(self)
     end
 
+    # Size of the model, in statements.
+    #
+    # @return [Fixnum]
+    def size
+      s = Redland.librdf_model_size(@rdf_model)
+      s < 0 ? statements.count : s
+    end
+
+    # Query the model RDF graph using a query language
+    #
+    # @param [String] q the text of the query
+    # @param [Hash<Symbol => [String, URI]>] options options for the query
+    # @option options [String] :language language of the query, one of:
+    #   - "sparql10" SPARQL 1.0 W3C RDF Query Language (default)
+    #   - "sparql" SPARQL 1.1 (DRAFT) Query and Update Languages
+    #   - "sparql11-query" SPARQL 1.1 (DRAFT) Query Language
+    #   - "sparql11-update" SPARQL 1.1 (DRAFT) Update Language
+    #   - "laqrs" LAQRS adds to Querying RDF in SPARQL
+    #   - "rdql" RDF Data Query Language (RDQL)
+    # @option options [String] :language_uri URI of the query language, if applicable
+    # @option options [String] :base_uri base URI of the query, if applicable
+    # @return [void]
+    # @note
+    #   The returned value is determined by the type of the query:
+    #   - [Boolean] for SPARQL ASK queries (ignores block, if given)
+    #   - [Redlander::Model] for SPARQL CONSTRUCT queries
+    #     if given a block, yields the constructed statements to it instead
+    #   - [Array<Hash>] for SPARQL SELECT queries
+    #     where hash values are Redlander::Node instances;
+    #     if given a block, yields each binding hash to it
+    #   - nil, if query fails
+    # @raise [RedlandError] if fails to create a query
+    def query(q, options = {})
+      query = Query::Results.new(q, options)
+      query.process(self)
+    end
+
+    # Merge statements from another model
+    # (duplicates and invalid statements are skipped)
+    #
+    # @param [Redlander::Model] model
+    # @return [self]
+    def merge(model)
+      rdf_stream = Redland.librdf_model_as_stream(model.rdf_model)
+      raise RedlandError, "Failed to convert model to a stream" if rdf_stream.null?
+
+      begin
+        Redland.librdf_model_add_statements(@rdf_model, rdf_stream)
+        self
+      ensure
+        Redland.librdf_free_stream(rdf_stream)
+      end
+    end
+
     # Wrap changes to the given model in a transaction.
     # If an exception is raised in the block, the transaction is rolled back.
     #

data/lib/redlander/model_proxy.rb

@@ -44,12 +44,15 @@ module Redlander
       Redland.librdf_model_remove_statement(@model.rdf_model, statement.rdf_statement).zero?
     end
 
-    # Delete all statements from the model.
+    # Delete all statements from the model,
+    # matching the given pattern
     #
-    # @todo Fix this extremely ineffective (slow) implementation
+    # @param [Statement, Hash] pattern (see {#find})
     # @return [Boolean]
-    def delete_all
-      each { |st| delete(st) }
+    def delete_all(pattern = {})
+      result = true
+      each(pattern) { |st| result &&= delete(st) }
+      result
     end
 
     # Create a statement and add it to the model.
@@ -72,21 +75,13 @@ module Redlander
       size.zero?
     end
 
-    # Size of the model in statements.
+    # Checks the existence of statements in the model
+    # matching the given criteria
     #
-    # @note
-    #   While #count must iterate across all statements in the model,
-    #   {#size} tries to use a more efficient C implementation.
-    #   So {#size} should be preferred to #count in terms of performance.
-    #   However, for non-countable storages, {#size} falls back to
-    #   using #count. Also, {#size} is not available for enumerables
-    #   (e.g. produced from {#each} (without a block) or otherwise) and
-    #   thus cannot be used to count "filtered" results.
-    #
-    # @return [Fixnum]
-    def size
-      s = Redland.librdf_model_size(@model.rdf_model)
-      s < 0 ? count : s
+    # @param [Hash, Statement] pattern (see {#find})
+    # @return [Boolean]
+    def exist?(pattern)
+      !first(pattern).nil?
     end
 
     # Enumerate (and filter) model statements.
@@ -94,7 +89,7 @@ module Redlander
     #
     # @param [Statement, Hash, void] args
     #   if given Statement or Hash, filter the model statements
-    #   according to the specified pattern (see {#find} options).
+    #   according to the specified pattern (see {#find} pattern).
     # @yieldparam [Statement]
     # @return [void]
     def each(*args)
@@ -103,7 +98,7 @@ module Redlander
           if args.empty?
             Redland.librdf_model_as_stream(@model.rdf_model)
           else
-            pattern = args.first.is_a?(Statement) ? args.first.rdf_statement : Statement.new(args.first)
+            pattern = args.first.is_a?(Statement) ? args.first : Statement.new(args.first)
             Redland.librdf_model_find_statements(@model.rdf_model, pattern.rdf_statement)
           end
         raise RedlandError, "Failed to create a new stream" if rdf_stream.null?
@@ -125,37 +120,37 @@ module Redlander
     # Find statements satisfying the given criteria.
     #
     # @param [:first, :all] scope find just one or all matches
-    # @param [Hash, Statement] options matching pattern made of:
+    # @param [Hash, Statement] pattern matching pattern made of:
     #   - Hash with :subject, :predicate or :object nodes, or
     #   - "patternized" Statement (nil nodes are matching anything).
     # @return [Statement, Array, nil]
-    def find(scope, options = {})
+    def find(scope, pattern = {})
       case scope
       when :first
-        each(options).first
+        each(pattern).first
       when :all
-        each(options).to_a
+        each(pattern).to_a
       else
         raise RedlandError, "Invalid search scope '#{scope}' specified."
       end
     end
 
     # Find a first statement matching the given criteria.
-    # (Shortcut for {#find}(:first, options)).
+    # (Shortcut for {#find}(:first, pattern)).
     #
-    # @param [Hash] options (see {#find})
+    # @param [Statement, Hash] pattern (see {#find})
     # @return [Statement, nil]
-    def first(options = {})
-      find(:first, options)
+    def first(pattern = {})
+      find(:first, pattern)
     end
 
     # Find all statements matching the given criteria.
-    # (Shortcut for {#find}(:all, options)).
+    # (Shortcut for {#find}(:all, pattern)).
     #
-    # @param [Hash] options (see {#find})
+    # @param [Statement, Hash] pattern (see {#find})
     # @return [Array<Statement>]
-    def all(options = {})
-      find(:all, options)
+    def all(pattern = {})
+      find(:all, pattern)
     end
   end
 end

data/lib/redlander/query/results.rb

@@ -0,0 +1,118 @@
+module Redlander
+  module Query
+    # @api private
+    class Results
+      include Enumerable
+
+      # (see Model#query)
+      def initialize(q, options = {})
+        language = options[:language] || "sparql10"
+        language_uri = options[:language_uri] && options[:language_uri].to_s
+        base_uri = options[:base_uri] && options[:base_uri].to_s
+
+        @rdf_query = Redland.librdf_new_query(Redlander.rdf_world, language, language_uri, q, base_uri)
+        raise RedlandError, "Failed to create a #{language.upcase} query from '#{q}'" if @rdf_query.null?
+
+        ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_query(@rdf_query) })
+      end
+
+      def process(model)
+        @rdf_results = Redland.librdf_model_query_execute(model.rdf_model, @rdf_query)
+
+        if @rdf_results.null?
+          return nil
+        else
+          case
+          when bindings?
+            if block_given?
+              each { yield process_bindings }
+            else
+              map { process_bindings }
+            end
+          when boolean?
+            process_boolean
+          when graph?
+            if block_given?
+              process_graph { |statement| yield statement }
+            else
+              process_graph
+            end
+          when syntax?
+            process_syntax
+          else
+            raise RedlandError, "Cannot determine the type of query results"
+          end
+        end
+      ensure
+        Redland.librdf_free_query_results(@rdf_results)
+      end
+
+      def each
+        if block_given?
+          while Redland.librdf_query_results_finished(@rdf_results).zero?
+            yield self
+            Redland.librdf_query_results_next(@rdf_results)
+          end
+        else
+          enum_for(:each)
+        end
+      end
+
+      def bindings?
+        !Redland.librdf_query_results_is_bindings(@rdf_results).zero?
+      end
+
+      def boolean?
+        !Redland.librdf_query_results_is_boolean(@rdf_results).zero?
+      end
+
+      def graph?
+        !Redland.librdf_query_results_is_graph(@rdf_results).zero?
+      end
+
+      def syntax?
+        !Redland.librdf_query_results_is_syntax(@rdf_results).zero?
+      end
+
+      private
+
+      def process_bindings
+        {}.tap do |bindings|
+          n = Redland.librdf_query_results_get_bindings_count(@rdf_results)
+          while n > 0
+            name = Redland.librdf_query_results_get_binding_name(@rdf_results, n-1)
+            value = Redland.librdf_query_results_get_binding_value(@rdf_results, n-1)
+            bindings[name] = Node.new(value) unless value.null?
+            n -= 1
+          end
+        end
+      end
+
+      def process_boolean
+        value = Redland.librdf_query_results_get_boolean(@rdf_results)
+        return value >= 0 ? !value.zero? : nil
+      end
+
+      def process_graph
+        rdf_stream = Redland.librdf_query_results_as_stream(@rdf_results)
+        if block_given?
+          while Redland.librdf_stream_end(rdf_stream).zero?
+            statement = Statement.new(Redland.librdf_stream_get_object(rdf_stream))
+            yield statement
+            Redland.librdf_stream_next(rdf_stream)
+          end
+        else
+          Model.new.tap do |model|
+            Redland.librdf_model_add_statements(model.rdf_model, rdf_stream)
+          end
+        end
+      ensure
+        Redland.librdf_free_stream(rdf_stream)
+      end
+
+      def process_syntax
+        raise NotImplementedError, "Don't know how to handle syntax type results"
+      end
+    end
+  end
+end

data/lib/redlander/version.rb

@@ -1,4 +1,4 @@
 module Redlander
   # Redlander version number
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec/lib/redlander/model_spec.rb

@@ -4,21 +4,111 @@ describe Model do
   let(:model) { described_class.new }
   subject { model }
 
-  describe "statements" do
-    subject { model.statements }
-
-    it { should be_an_instance_of(ModelProxy) }
+  describe "size" do
+    subject { model.size }
 
     context "for a non-countable storage" do
       before do
-        subject.create(statement_attributes)
+        model.statements.create(statement_attributes)
         Redland.stub(:librdf_model_size => -1)
       end
 
       it "should return size derived from count" do
-        subject.size.should eql subject.count
+        subject.should eql model.statements.count
+      end
+    end
+  end
+
+  describe "query" do
+    before { model.from_file(Redlander.fixture_path("doap.ttl"), :format => "turtle") }
+    subject { model.query(q) }
+
+    describe "SPARQL" do
+      describe "SELECT" do
+        let(:q) { "PREFIX doap: <http://usefulinc.com/ns/doap#> SELECT ?name WHERE { <http://rubygems.org/gems/rdf> doap:name ?name }" }
+
+        it { should be_a Enumerable }
+
+        it "should return an array of binding hashes" do
+          expect(subject.size).to eql 1
+          expect(subject.first["name"]).to be_a Redlander::Node
+          expect(subject.first["name"].value).to eql "RDF.rb"
+        end
+
+        context "with a block" do
+          it "should yield a binding hash" do
+            subject do |binding|
+              expect(binding).to be_a Hash
+              expect(binding["name"]).to be_a Redlander::Node
+              expect(binding["name"].value).to eql "RDF.rb"
+            end
+          end
+        end
+      end
+
+      describe "ASK" do
+        let(:q) { "PREFIX doap: <http://usefulinc.com/ns/doap#> ASK { <http://rubygems.org/gems/rdf> doap:homepage <http://rdf.rubyforge.org/> }" }
+
+        it { should be_true }
+      end
+
+      describe "CONSTRUCT" do
+        let(:q) { "PREFIX doap: <http://usefulinc.com/ns/doap#> CONSTRUCT { ?project doap:framework 'RDF'^^<http://www.w3.org/2001/XMLSchema#string> } WHERE { ?project a doap:Project }" }
+
+        it { should be_a Redlander::Model }
+
+        it "should return a model made from the constructed statements" do
+          statement = Redlander::Statement.new(:subject => URI("http://rubygems.org/gems/rdf"),
+                                               :predicate => URI("http://usefulinc.com/ns/doap#framework"),
+                                               :object => "RDF")
+          expect(subject.statements.count).to eql 1
+          expect(subject.statements.exist?(statement)).to be_true
+        end
+      end
+
+      describe "DESCRIBE" do
+        let(:q) { "PREFIX doap: <http://usefulinc.com/ns/doap#> DESCRIBE ?gem WHERE { ?gem a doap:Project }" }
+
+        it { pending "Not implemented. See: http://bugs.librdf.org/mantis/view.php?id=135" }
       end
     end
+  end
+
+  describe "merge" do
+    before do
+      @model2 = Redlander::Model.new
+      @model3 = Redlander::Model.new
+      @statement1 = Redlander::Statement.new(:subject => URI("http://rubygems.org/gems/rdf"),
+                                             :predicate => URI("http://usefulinc.com/ns/doap#framework"),
+                                             :object => "RDF")
+      model.statements.add(@statement1)
+      @statement2 = Redlander::Statement.new(:subject => URI("http://rubygems.org/gems/rdfs"),
+                                             :predicate => URI("http://usefulinc.com/ns/doap#framework"),
+                                             :object => "RDFS")
+      @model2.statements.add(@statement2)
+      @model3.statements.add(@statement1)
+    end
+
+    it "should return model" do
+      expect(model.merge(@model2)).to eql model
+    end
+
+    it "should add different model statements" do
+      expect { model.merge(@model2) }.to change(model, :size).by(1)
+      expect(model.statements).to include(@statement1)
+      expect(model.statements).to include(@statement2)
+    end
+
+    it "should add same model statements" do
+      expect { model.merge(@model3) }.not_to change(model, :size)
+      expect(model.statements).to include(@statement1)
+    end
+  end
+
+  describe "statements" do
+    subject { model.statements }
+
+    it { should be_an_instance_of(ModelProxy) }
 
     context "when enumerated" do
       context "without a block" do
@@ -36,7 +126,7 @@ describe Model do
         it "should be iterated over" do
           expect {
             subject.each { |s| @statements << s }
-          }.to change(@statements, :size).by(1)
+          }.to change(@statements, :count).by(1)
           expect(@statements).to include @statement
         end
       end
@@ -44,7 +134,6 @@ describe Model do
 
     context "when searched" do
       subject { model.statements.find(:first, @conditions) }
-
       before { @statement = model.statements.create(statement_attributes) }
 
       context "with empty conditions" do
@@ -66,16 +155,33 @@ describe Model do
       end
     end
 
+    context "when checked for existance" do
+      subject { model.statements.exist?(@conditions) }
+      before { @statement = model.statements.create(statement_attributes) }
+
+      context "with matching conditions" do
+        before { @conditions = {:object => @statement.object} }
+
+        it { should be_true }
+      end
+
+      context "with non-matching conditions" do
+        before { @conditions = {:object => "another object"} }
+
+        it { should be_false }
+      end
+    end
+
     context "when adding" do
       context "via #create" do
         it "should be created in the model" do
-          expect { subject.create(statement_attributes) }.to change(subject, :size).by(1)
+          expect { subject.create(statement_attributes) }.to change(subject, :count).by(1)
         end
 
         it "should not add duplicate statements" do
           expect {
             2.times { subject.create(statement_attributes) }
-          }.to change(subject, :size).by(1)
+          }.to change(subject, :count).by(1)
         end
       end
 
@@ -83,14 +189,14 @@ describe Model do
         before { @statement = Statement.new(statement_attributes) }
 
         it "should be added to the model" do
-          expect { subject.add(@statement) }.to change(subject, :size).by(1)
+          expect { subject.add(@statement) }.to change(subject, :count).by(1)
           subject.should include(@statement)
         end
 
         it "should not add duplicate statements" do
           expect {
             2.times { subject.add(@statement) }
-          }.to change(subject, :size).by(1)
+          }.to change(subject, :count).by(1)
         end
       end
     end
@@ -99,32 +205,22 @@ describe Model do
       before { @statement = subject.create(statement_attributes) }
 
       it "should be removed from the model" do
-        expect { subject.delete(@statement) }.to change(subject, :size).by(-1)
+        expect { subject.delete(@statement) }.to change(subject, :count).by(-1)
         subject.should_not include(@statement)
       end
 
       describe "all statements" do
         before { subject.create(statement_attributes.merge(:object => "another one")) }
 
+        it "should selectively delete statements" do
+          expect { subject.delete_all(:object => "another one") }.to change(subject, :count).by(-1)
+        end
+
         it "should completely wipe the model" do
-          expect { subject.delete_all }.to change(subject, :size).from(2).to(0)
+          expect { subject.delete_all }.to change(subject, :count).from(2).to(0)
         end
       end
     end
-
-
-    private
-
-    def statement_attributes
-      s = URI.parse('http://example.com/concepts#subject')
-      p = URI.parse('http://example.com/concepts#label')
-      o = "subject!"
-      {
-        :subject => s,
-        :predicate => p,
-        :object => o
-      }
-    end
   end
 
   describe "serialization" do
@@ -200,13 +296,13 @@ describe Model do
       it "should parse from string" do
         expect {
           subject.from_rdfxml File.read(@filename), :base_uri => "http://rubygems.org/gems/rdf"
-        }.to change(subject.statements, :size).by(62)
+        }.to change(subject.statements, :count).by(62)
       end
 
       it "should parse from URI/file" do
         expect {
           subject.from_rdfxml URI("file://" + @filename), :base_uri => "http://rubygems.org/gems/rdf"
-        }.to change(subject.statements, :size).by(62)
+        }.to change(subject.statements, :count).by(62)
       end
 
       it "should filter statements" do
@@ -215,7 +311,7 @@ describe Model do
           subject.from_rdfxml URI("file://" + @filename), :base_uri => "http://rubygems.org/gems/rdf" do |st|
             st.object.resource? ? st.object.uri != filter_object : true
           end
-        }.to change(subject.statements, :size).by(57)
+        }.to change(subject.statements, :count).by(57)
       end
     end
 
@@ -225,13 +321,13 @@ describe Model do
       it "should parse from string" do
         expect {
           subject.from_ntriples File.read(@filename)
-        }.to change(subject.statements, :size).by(62)
+        }.to change(subject.statements, :count).by(62)
       end
 
       it "should parse from URI/file" do
         expect {
           subject.from_ntriples URI("file://" + @filename)
-        }.to change(subject.statements, :size).by(62)
+        }.to change(subject.statements, :count).by(62)
       end
     end
 
@@ -241,13 +337,13 @@ describe Model do
       it "should parse from string" do
         expect {
           subject.from_turtle File.read(@filename), :base_uri => "http://rubygems.org/gems/rdf"
-        }.to change(subject.statements, :size).by(62)
+        }.to change(subject.statements, :count).by(62)
       end
 
       it "should parse from URI/file" do
         expect {
           subject.from_turtle URI("file://" + @filename), :base_uri => "http://rubygems.org/gems/rdf"
-        }.to change(subject.statements, :size).by(62)
+        }.to change(subject.statements, :count).by(62)
       end
     end
   end
@@ -301,4 +397,18 @@ describe Model do
       end
     end
   end
+
+
+  private
+
+  def statement_attributes
+    s = URI.parse('http://example.com/concepts#subject')
+    p = URI.parse('http://example.com/concepts#label')
+    o = "subject!"
+    {
+      :subject => s,
+      :predicate => p,
+      :object => o
+    }
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redlander
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-23 00:00:00.000000000 Z
+date: 2012-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xml_schema
@@ -87,6 +87,7 @@ files:
 - lib/redlander/model_proxy.rb
 - lib/redlander/node.rb
 - lib/redlander/parsing.rb
+- lib/redlander/query/results.rb
 - lib/redlander/serializing.rb
 - lib/redlander/statement.rb
 - lib/redlander/uri.rb
@@ -116,7 +117,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3614393653179496496
+      hash: -3720732623496571962
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -125,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3614393653179496496
+      hash: -3720732623496571962
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24