ripple 0.5.1 → 0.6.0

data/spec/riak/walk_spec_spec.rb

@@ -127,7 +127,7 @@ describe Riak::WalkSpec do
 
     describe "matching links" do
       before :each do
-        @link = Riak::Link.new("/raw/foo/bar", "next")
+        @link = Riak::Link.new("/riak/foo/bar", "next")
       end
 
       it "should match a link when the bucket and tag are not specified" do

data/spec/ripple/finders_spec.rb

@@ -37,7 +37,7 @@ describe Ripple::Document::Finders do
 
   describe "finding single documents" do
     it "should find a single document by key and assign its attributes" do
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
       box = Box.find("square")
       box.should be_kind_of(Box)
       box.shape.should == "square"
@@ -47,21 +47,21 @@ describe Ripple::Document::Finders do
     end
 
     it "should return nil when no object exists at that key" do
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "square", {}, {}).and_raise(Riak::FailedRequest.new(:get, 200, 404, {}, "404 not found"))
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "square", {}, {}).and_raise(Riak::FailedRequest.new(:get, 200, 404, {}, "404 not found"))
       box = Box.find("square")
       box.should be_nil
     end
 
     it "should re-raise the failed request exception if not a 404" do
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "square", {}, {}).and_raise(Riak::FailedRequest.new(:get, 200, 500, {}, "500 internal server error"))
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "square", {}, {}).and_raise(Riak::FailedRequest.new(:get, 200, 500, {}, "500 internal server error"))
       lambda { Box.find("square") }.should raise_error(Riak::FailedRequest)
     end
   end
 
   describe "finding multiple documents" do
     it "should find multiple documents by the keys" do
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "rectangle", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"rectangle"}'})
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "rectangle", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"rectangle"}'})
       boxes = Box.find("square", "rectangle")
       boxes.should have(2).items
       boxes.first.shape.should == "square"
@@ -69,8 +69,8 @@ describe Ripple::Document::Finders do
     end
 
     it "should return nil for documents that no longer exist" do
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "rectangle", {}, {}).and_raise(Riak::FailedRequest.new(:get, 200, 404, {}, "404 not found"))
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "rectangle", {}, {}).and_raise(Riak::FailedRequest.new(:get, 200, 404, {}, "404 not found"))
       boxes = Box.find("square", "rectangle")
       boxes.should have(2).items
       boxes.first.shape.should == "square"
@@ -81,8 +81,8 @@ describe Ripple::Document::Finders do
   describe "finding all documents in the bucket" do
     it "should load all objects in the bucket" do
       @bucket.should_receive(:keys).and_return(["square", "rectangle"])
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "rectangle", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"rectangle"}'})
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "rectangle", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"rectangle"}'})
       boxes = Box.all
       boxes.should have(2).items
       boxes.first.shape.should == "square"
@@ -91,17 +91,17 @@ describe Ripple::Document::Finders do
 
     it "should exclude objects that are not found" do
       @bucket.should_receive(:keys).and_return(["square", "rectangle"])
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "rectangle", {}, {}).and_raise(Riak::FailedRequest.new(:get, 200, 404, {}, "404 not found"))
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "rectangle", {}, {}).and_raise(Riak::FailedRequest.new(:get, 200, 404, {}, "404 not found"))
       boxes = Box.all
       boxes.should have(1).item
       boxes.first.shape.should == "square"
     end
 
     it "should yield found objects to the passed block and return an empty array" do
-      @bucket.should_receive(:keys).and_yield("square").and_yield("rectangle")
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "rectangle", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"rectangle"}'})
+      @bucket.should_receive(:keys).and_yield(["square"]).and_yield(["rectangle"])
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "rectangle", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"rectangle"}'})
       @block = mock()
       @block.should_receive(:ping).twice
       Box.all do |box|
@@ -111,9 +111,9 @@ describe Ripple::Document::Finders do
     end
 
     it "should yield found objects to the passed block, excluding missing objects, and return an empty array" do
-      @bucket.should_receive(:keys).and_yield("square").and_yield("rectangle")
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "rectangle", {}, {}).and_raise(Riak::FailedRequest.new(:get, 200, 404, {}, "404 not found"))
+      @bucket.should_receive(:keys).and_yield(["square"]).and_yield(["rectangle"])
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "rectangle", {}, {}).and_raise(Riak::FailedRequest.new(:get, 200, 404, {}, "404 not found"))
       @block = mock()
       @block.should_receive(:ping).once
       Box.all do |box|
@@ -129,8 +129,8 @@ describe Ripple::Document::Finders do
     end
 
     it "should instantiate as the proper type if defined in the document" do
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
-      @http.should_receive(:get).with(200, "/raw/", "boxes", "rectangle", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"rectangle", "_type":"CardboardBox"}'})
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "square", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"square"}'})
+      @http.should_receive(:get).with(200, "/riak/", "boxes", "rectangle", {}, {}).and_return({:code => 200, :headers => {"content-type" => ["application/json"]}, :body => '{"shape":"rectangle", "_type":"CardboardBox"}'})
       boxes = Box.find("square", "rectangle")
       boxes.should have(2).items
       boxes.first.should_not be_kind_of(CardboardBox)

data/spec/ripple/persistence_spec.rb

@@ -35,7 +35,7 @@ describe Ripple::Document::Persistence do
 
   it "should save a new object to Riak" do
     json = @widget.attributes.merge("_type" => "Widget").to_json
-    @http.should_receive(:post).with(201, "/raw/", "widgets", an_instance_of(Hash), json, hash_including("Content-Type" => "application/json")).and_return(:code => 201, :headers => {'location' => ["/raw/widgets/new_widget"]})
+    @http.should_receive(:post).with(201, "/riak/", "widgets", an_instance_of(Hash), json, hash_including("Content-Type" => "application/json")).and_return(:code => 201, :headers => {'location' => ["/riak/widgets/new_widget"]})
     @widget.save
     @widget.key.should == "new_widget"
     @widget.should_not be_new_record
@@ -44,7 +44,7 @@ describe Ripple::Document::Persistence do
 
   it "should reload a saved object" do
     json = @widget.attributes.merge("_type" => "Widget").to_json
-    @http.should_receive(:post).with(201, "/raw/", "widgets", an_instance_of(Hash), json, hash_including("Content-Type" => "application/json")).and_return(:code => 201, :headers => {'location' => ["/raw/widgets/new_widget"]})
+    @http.should_receive(:post).with(201, "/riak/", "widgets", an_instance_of(Hash), json, hash_including("Content-Type" => "application/json")).and_return(:code => 201, :headers => {'location' => ["/riak/widgets/new_widget"]})
     @widget.save
     @http.should_receive(:get).and_return(:code => 200, :headers => {'content-type' => ["application/json"]}, :body => '{"name":"spring","size":10}')
     @widget.reload
@@ -54,7 +54,7 @@ describe Ripple::Document::Persistence do
   end
 
   it "should destroy a saved object" do
-    @http.should_receive(:post).and_return(:code => 201, :headers => {'location' => ["/raw/widgets/new_widget"]})
+    @http.should_receive(:post).and_return(:code => 201, :headers => {'location' => ["/riak/widgets/new_widget"]})
     @widget.save
     @http.should_receive(:delete).and_return(:code => 204, :headers => {})
     @widget.destroy.should be_true
@@ -78,7 +78,7 @@ describe Ripple::Document::Persistence do
 
     it "should store the _type field as the class name" do
       json = @cog.attributes.merge("_type" => "Cog").to_json
-      @http.should_receive(:post).and_return(:code => 201, :headers => {'location' => ["/raw/widgets/new_widget"]})
+      @http.should_receive(:post).and_return(:code => 201, :headers => {'location' => ["/riak/widgets/new_widget"]})
       @cog.save
       @cog.should_not be_new_record
     end

data/spec/ripple/ripple_spec.rb

@@ -39,5 +39,6 @@ describe Ripple do
     c = Ripple.client
     Ripple.config = {:port => 9000}
     Ripple.client.should_not == c
+    Ripple.client.port.should == 9000
   end
 end

data/spec/ripple/timestamps_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Ripple::Document::Timestamps do
+  
+  before :all do
+    Object.module_eval { class Box; include Ripple::Document; property :shape, String; timestamps! end }
+  end
+  
+  before :each do
+    response = {:headers => {"content-type" => ["application/json"]}, :body => "{}"}
+    @client = Ripple.client
+    @http = mock("HTTP Backend", :get => response, :put => response, :post => response, :delete => response)
+    @client.stub!(:http).and_return(@http)
+    @box = Box.new
+  end
+  
+  it "should add a created_at property" do
+    @box.should respond_to(:created_at)
+  end
+  
+  it "should add an updated_at property" do
+    @box.should respond_to(:updated_at)
+  end
+  
+  it "should set the created_at timestamp when the object is initialized" do
+    @box.created_at.should_not be_nil
+  end
+  
+  it "should not set the updated_at timestamp when the object is initialized" do
+    @box.updated_at.should be_nil
+  end
+  
+  it "should set the updated_at timestamp when the object is created" do
+    @box.save
+    @box.updated_at.should_not be_nil
+  end
+  
+  it "should update the updated_at timestamp when the object is updated" do
+    @box.save
+    start = @box.updated_at
+    @box.save
+    @box.updated_at.should > start
+  end
+  
+  after :all do
+    Object.send(:remove_const, :Box)
+  end
+  
+end

data/spec/support/http_backend_implementation_examples.rb

@@ -14,52 +14,52 @@
 shared_examples_for "HTTP backend" do
   describe "HEAD requests" do
     before :each do
-      setup_http_mock(:head, @backend.path("/raw/","foo").to_s, :body => "")
+      setup_http_mock(:head, @backend.path("/riak/","foo").to_s, :body => "")
     end
 
     it "should return only the headers when the request succeeds" do
-      response = @backend.head(200, "/raw/","foo")
+      response = @backend.head(200, "/riak/","foo")
       response.should_not have_key(:body)
       response[:headers].should be_kind_of(Hash)
       response[:code].should == 200
     end
 
     it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.head(301, "/raw/", "foo") }.should raise_error(Riak::FailedRequest)
+      lambda { @backend.head(301, "/riak/", "foo") }.should raise_error(Riak::FailedRequest)
     end
 
     it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.head(200, "/raw/") }.should raise_error(ArgumentError)
+      lambda { @backend.head(200, "/riak/") }.should raise_error(ArgumentError)
     end
 
     it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.head([200, 301], "/raw/", "foo") }.should_not raise_error(Riak::FailedRequest)
+      lambda { @backend.head([200, 301], "/riak/", "foo") }.should_not raise_error(Riak::FailedRequest)
     end
   end
 
   describe "GET requests" do
     before :each do
-      setup_http_mock(:get, @backend.path("/raw/","foo").to_s, :body => "Success!")
+      setup_http_mock(:get, @backend.path("/riak/","foo").to_s, :body => "Success!")
     end
 
     it "should return the response body and headers when the request succeeds" do
-      response = @backend.get(200, "/raw/","foo")
+      response = @backend.get(200, "/riak/","foo")
       response[:body].should == "Success!"
       response[:headers].should be_kind_of(Hash)
       response[:code].should == 200
     end
 
     it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.get(304, "/raw/","foo") }.should raise_error(Riak::FailedRequest)
+      lambda { @backend.get(304, "/riak/","foo") }.should raise_error(Riak::FailedRequest)
     end
 
     it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.get([200, 301], "/raw/","foo") }.should_not raise_error(Riak::FailedRequest)
+      lambda { @backend.get([200, 301], "/riak/","foo") }.should_not raise_error(Riak::FailedRequest)
     end
     
     it "should yield successive chunks of the response to the given block but not return the entire body" do
       chunks = ""
-      response = @backend.get(200, "/raw/","foo") do |chunk|
+      response = @backend.get(200, "/riak/","foo") do |chunk|
         chunks << chunk
       end
       chunks.should == "Success!"
@@ -69,32 +69,32 @@ shared_examples_for "HTTP backend" do
     end
 
     it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.get(200, "/raw/") }.should raise_error(ArgumentError)
+      lambda { @backend.get(200, "/riak/") }.should raise_error(ArgumentError)
     end
   end
 
   describe "DELETE requests" do
     before :each do
-      setup_http_mock(:delete, @backend.path("/raw/","foo").to_s, :body => "Success!")
+      setup_http_mock(:delete, @backend.path("/riak/","foo").to_s, :body => "Success!")
     end
 
     it "should return the response body and headers when the request succeeds" do
-      response = @backend.delete(200, "/raw/","foo")
+      response = @backend.delete(200, "/riak/","foo")
       response[:body].should == "Success!"
       response[:headers].should be_kind_of(Hash)
     end
 
     it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.delete(304, "/raw/","foo") }.should raise_error(Riak::FailedRequest)
+      lambda { @backend.delete(304, "/riak/","foo") }.should raise_error(Riak::FailedRequest)
     end
     
     it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.delete([200, 301], "/raw/","foo") }.should_not raise_error(Riak::FailedRequest)
+      lambda { @backend.delete([200, 301], "/riak/","foo") }.should_not raise_error(Riak::FailedRequest)
     end
     
     it "should yield successive chunks of the response to the given block but not return the entire body" do
       chunks = ""
-      response = @backend.delete(200, "/raw/","foo") do |chunk|
+      response = @backend.delete(200, "/riak/","foo") do |chunk|
         chunks << chunk
       end
       chunks.should == "Success!"
@@ -104,34 +104,34 @@ shared_examples_for "HTTP backend" do
     end
 
     it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.delete(200, "/raw/") }.should raise_error(ArgumentError)
+      lambda { @backend.delete(200, "/riak/") }.should raise_error(ArgumentError)
     end
   end
 
   describe "PUT requests" do
     before :each do
-      setup_http_mock(:put, @backend.path("/raw/","foo").to_s, :body => "Success!")
+      setup_http_mock(:put, @backend.path("/riak/","foo").to_s, :body => "Success!")
     end
 
     it "should return the response body, headers, and code when the request succeeds" do
-      response = @backend.put(200, "/raw/","foo", "This is the body.")
+      response = @backend.put(200, "/riak/","foo", "This is the body.")
       response[:body].should == "Success!"
       response[:headers].should be_kind_of(Hash)
       response[:code].should == 200
     end
 
     it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.put(204, "/raw/","foo", "This is the body.") }.should raise_error(Riak::FailedRequest)
+      lambda { @backend.put(204, "/riak/","foo", "This is the body.") }.should raise_error(Riak::FailedRequest)
     end
     
     it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.put([200, 204], "/raw/","foo", "This is the body.") }.should_not raise_error(Riak::FailedRequest)
+      lambda { @backend.put([200, 204], "/riak/","foo", "This is the body.") }.should_not raise_error(Riak::FailedRequest)
     end
     
     
     it "should yield successive chunks of the response to the given block but not return the entire body" do
       chunks = ""
-      response = @backend.put(200, "/raw/","foo", "This is the body.") do |chunk|
+      response = @backend.put(200, "/riak/","foo", "This is the body.") do |chunk|
         chunks << chunk
       end
       chunks.should == "Success!"
@@ -141,41 +141,41 @@ shared_examples_for "HTTP backend" do
     end
 
     it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.put(200, "/raw/") }.should raise_error(ArgumentError)
+      lambda { @backend.put(200, "/riak/") }.should raise_error(ArgumentError)
     end
 
     it "should raise an error if no body data is given" do
-      lambda { @backend.put(200, "/raw/","foo") }.should raise_error(ArgumentError)
+      lambda { @backend.put(200, "/riak/","foo") }.should raise_error(ArgumentError)
     end
 
     it "should raise an error if the body is not a string" do
-      lambda { @backend.put(200, "/raw/","foo", 123) }.should raise_error(ArgumentError)
+      lambda { @backend.put(200, "/riak/","foo", 123) }.should raise_error(ArgumentError)
     end
   end
 
   describe "POST requests" do
     before :each do
-      setup_http_mock(:post, @backend.path("/raw/","foo").to_s, :body => "Success!")
+      setup_http_mock(:post, @backend.path("/riak/","foo").to_s, :body => "Success!")
     end
 
     it "should return the response body, headers, and code when the request succeeds" do
-      response = @backend.post(200, "/raw/","foo", "This is the body.")
+      response = @backend.post(200, "/riak/","foo", "This is the body.")
       response[:body].should == "Success!"
       response[:headers].should be_kind_of(Hash)
       response[:code].should == 200
     end
 
     it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.post(204, "/raw/", "foo", "This is the body.") }.should raise_error(Riak::FailedRequest)
+      lambda { @backend.post(204, "/riak/", "foo", "This is the body.") }.should raise_error(Riak::FailedRequest)
     end
 
     it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.post([200, 204], "/raw/", "foo", "This is the body.") }.should_not raise_error(Riak::FailedRequest)
+      lambda { @backend.post([200, 204], "/riak/", "foo", "This is the body.") }.should_not raise_error(Riak::FailedRequest)
     end
 
     it "should yield successive chunks of the response to the given block but not return the entire body" do
       chunks = ""
-      response = @backend.post(200, "/raw/", "foo", "This is the body.") do |chunk|
+      response = @backend.post(200, "/riak/", "foo", "This is the body.") do |chunk|
         chunks << chunk
       end
       chunks.should == "Success!"
@@ -185,15 +185,15 @@ shared_examples_for "HTTP backend" do
     end
 
     it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.post(200, "/raw/") }.should raise_error(ArgumentError)
+      lambda { @backend.post(200, "/riak/") }.should raise_error(ArgumentError)
     end
 
     it "should raise an error if no body data is given" do
-      lambda { @backend.post(200, "/raw/", "foo") }.should raise_error(ArgumentError)
+      lambda { @backend.post(200, "/riak/", "foo") }.should raise_error(ArgumentError)
     end
 
     it "should raise an error if the body is not a string" do
-      lambda { @backend.post(200, "/raw/", "foo", 123) }.should raise_error(ArgumentError)
+      lambda { @backend.post(200, "/riak/", "foo", 123) }.should raise_error(ArgumentError)
     end
   end
 
@@ -201,11 +201,11 @@ shared_examples_for "HTTP backend" do
     [204, 205, 304].each do |code|
       [:get, :post, :put, :delete].each do |method|
         it "should not return a body on #{method.to_s.upcase} for #{code}" do
-          setup_http_mock(method, @backend.path("/raw/","foo").to_s, :status => code)
+          setup_http_mock(method, @backend.path("/riak/","foo").to_s, :status => code)
           response = if method == :post || method == :put
-                       @backend.send(method, code,"/raw/","foo", "This is the body")
+                       @backend.send(method, code,"/riak/","foo", "This is the body")
                      else
-                       @backend.send(method, code, "/raw/", "foo")
+                       @backend.send(method, code, "/riak/", "foo")
                      end
           response.should_not have_key(:body)
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ripple
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors: 
 - Sean Cribbs
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-22 00:00:00 -07:00
+date: 2010-03-05 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -114,6 +114,7 @@ files:
 - lib/riak/map_reduce.rb
 - lib/riak/map_reduce_error.rb
 - lib/riak/robject.rb
+- lib/riak/util/fiber1.8.rb
 - lib/riak/util/headers.rb
 - lib/riak/util/multipart.rb
 - lib/riak/util/translation.rb
@@ -131,6 +132,7 @@ files:
 - lib/ripple/document/persistence.rb
 - lib/ripple/document/persistence/callbacks.rb
 - lib/ripple/document/properties.rb
+- lib/ripple/document/timestamps.rb
 - lib/ripple/document/validations.rb
 - lib/ripple/embedded_document.rb
 - lib/ripple/embedded_document/persistence.rb
@@ -162,6 +164,7 @@ files:
 - spec/ripple/persistence_spec.rb
 - spec/ripple/properties_spec.rb
 - spec/ripple/ripple_spec.rb
+- spec/ripple/timestamps_spec.rb
 - spec/ripple/validations_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -216,6 +219,7 @@ test_files:
 - spec/ripple/persistence_spec.rb
 - spec/ripple/properties_spec.rb
 - spec/ripple/ripple_spec.rb
+- spec/ripple/timestamps_spec.rb
 - spec/ripple/validations_spec.rb
 - spec/spec_helper.rb
 - spec/support/http_backend_implementation_examples.rb