demetriusnunes-clouder 0.5.1

data/History.txt

@@ -0,0 +1,7 @@
+== 0.5.1 2009-03-09
+
+* (timshadel) Added a simple fix to make Note.get(”/notes/“) work.
+
+== 0.5.0 2009-01-29
+
+* Initial release

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+lib/clouder.rb
+lib/clouder/entity.rb
+lib/clouder/rest.rb
+spec/clouder_spec.rb
+spec/entity_spec.rb
+spec/spec_helper.rb
+spec/spec.opts
+spec/config.ru

data/README.rdoc

@@ -0,0 +1,136 @@
+= clouder
+
+* http://github.com/demetriusnunes/clouder
+
+== DESCRIPTION:
+
+A Ruby client library for accessing CloudKit (http://getcloudkit.com) 
+RESTful repositories using simple Ruby objects.
+
+== FEATURES/PROBLEMS:
+
+At this time, *clouder* implements all methods in CloudKit API (as seen
+in the checklist at the requirements section) and is good to be used in 
+most basic cases.
+
+Clouder::Entity is a subclass of OStruct, but that might change in
+the future.
+  
+== SYNOPSIS:
+
+Here is some sample code of how to use *clouder*, assuming that you
+have a CloudKit server running at <tt>http://localhost:9292/</tt> and 
+exposing "*notes*".
+
+=== Entity declaration
+
+  class Note < Clouder::Entity
+    uri "http://localhost:9292/notes"
+  end
+
+=== Creating new documents
+
+  n = Note.new
+  n.new? # true
+  n.text = "My first note"
+  n.author = "John Doe"
+  n.save
+  n.new? # false
+  
+  # Short alternative
+  n = Note.create(:text => "My first note", :author => "John Doe")
+
+=== Retrieving a single document
+
+  n = Note.get("d35bfa70-cca0-012b-cd41-0016cb91f13d") # some valid id
+  puts n.text, n.author
+
+=== Deleting documents
+
+  n = Note.get("d35bfa70-cca0-012b-cd41-0016cb91f13d") # some valid id
+  n.delete
+  n.deleted? # true
+  
+=== Retrieving collections
+
+  # This retrieves only the URIs
+  uris = Note.all
+  uris.each { |uri|
+    n = Note.get(uri)
+    puts n.text, n.author
+  }
+
+  # Using offset and limit
+  uris = Note.all(:offset => 5, :limit => 10)
+
+  # To retrieve full documents, use the :resolved option
+  notes = Note.all(:resolved => true)
+  
+  # You can combine all the options
+  notes = Note.all(:resolved => true, :offset => 3, :limit => 50)
+
+=== Retrieving older versions of a document
+
+  n = Note.get("d35bfa70-cca0-012b-cd41-0016cb91f13d") # some valid id
+
+  # This retrieves only the URIs
+  # - you can also use offset and limit options
+  older_uris = n.versions(:limit => 5)
+
+  # To retrieve full documents, use the :resolved option
+  older_notes = n.versions(:resolved)
+
+=== Inspecting some metadata for a repository
+
+  # Which collections are available for this server?
+  uris = Clouder.collections("http://localhost:9292/")
+  uris # [ "notes" ]
+  
+  # Retrieving only the headers for a valid URI
+  headers = Clouder.head("http://localhost:9292/notes")
+  
+== REQUIREMENTS:
+
+CloudKit API (http://getcloudkit.com/rest-api.html) Checklist:
+
+* GET /cloudkit-meta - OK!
+* OPTIONS /%uri% - OK!
+* GET /%collection% - OK!
+* GET /%collection%/_resolved - OK!
+* GET /%collection%/%uuid% - OK!
+* GET /%collection%/%uuid%/versions - OK! 
+* GET /%collection%/%uuid%/versions/_resolved - OK!
+* GET /%collection%/%uuid%/versions/%etag% - OK!
+* POST /%collection% - OK! 
+* PUT /%collection%/%uuid% - OK! 
+* DELETE /%collection%/%uuid% - OK! 
+* HEAD /%uri% - OK!
+
+== INSTALL:
+
+* sudo gem install clouder
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Demetrius Nunes
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,28 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/clouder'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('clouder', Clouder::VERSION) do |p|
+  p.developer('Demetrius Nunes', 'demetriusnunes@gmail.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+#  p.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  p.rubyforge_name       = p.name # TODO this is default value
+  # p.extra_deps         = [
+  #   ['activesupport','>= 2.0.2'],
+  # ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/lib/clouder.rb

@@ -0,0 +1,31 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "rubygems"
+require 'json'
+require 'restclient'
+require 'clouder/entity'  
+require 'clouder/rest'  
+
+# The Clouder module holds global server-wide functions.
+module Clouder
+  VERSION = '0.5.0'
+
+  # Returns an array of URIs of the resources exposed by
+  # the CloudKit server at the +uri+.
+  #
+  #  Clouder.collection("http://localhost:9292")
+  #  => [ "notes", "comments" ]
+  def Clouder.collections(uri)
+    uris = Rest.get(File.join(uri, "cloudkit-meta"))["uris"]
+    uris.map { |uri| uri.split("/").last }
+  end
+
+  # Makes a HEAD request to the +uri+ and returns a hash
+  # of headers contained in the response.
+  def Clouder.head(uri)
+    Rest.head(uri)
+  end
+  
+end
+

data/lib/clouder/entity.rb

@@ -0,0 +1,255 @@
+require 'ostruct'
+require 'time'
+
+module Clouder
+  # This is the base class to be used when accessing resources
+  # in a CloudKit server. It contains all the basic persistence
+  # methods and attributes. See the entity_spec.rb file for sample usages.
+  #
+  # A Note class should be declared as follows:
+  #   class Note < Clouder::Entity
+  #     uri "http://localhost:9292/notes"
+  #   end
+  class Entity < OpenStruct
+  
+    class << self
+
+      # If +address+ is passed, sets the URI for the target class.
+      # If nothing is passed, returns the current URI for the target class.
+      #
+      #   Note.uri "http://localhost:8989/notes" # changes the old URI
+      #   Note.uri # => "http://localhost:8989/notes"
+      def uri(address = nil)
+        address ? @uri = address : @uri
+      end
+
+      # If +options+ is nil, returns an array containing all URIs 
+      # of existing objects for this class. Sort order is from the 
+      # most recent to the oldest.
+      #
+      # For other results, +options+ can be:
+      # [:resolved] If +true+, returns full objects instead of URIs.
+      # [:offset] A positive integer, starting at 0, offsetting the result.
+      # [:limit] A positive integer, limiting the results.
+      #
+      # All options can be combined.
+      #
+      #   Note.all 
+      #   Note.all(:resolved => true)
+      #   Note.all(:offset => 20, :limit => 10)
+      #   Note.all(:resolved => true, :limit => 20, :offset => 10)
+      def all(options = {})
+        uri = options[:resolved] ? File.join(@uri, "_resolved") : @uri
+        result = Rest.get(Rest.paramify_url(uri, options))
+        options[:resolved] ? result["documents"].map { |d| new(d) } : result["uris"]
+      end
+      
+      # Creates and saves an object with the attributes and values
+      # passed as a hash. Returns the newly created object.
+      #
+      #   note = Note.create(:text => "My note", :author => "John Doe")
+      def create(hsh = {})
+        obj = self.new(hsh || {})
+        obj.save   
+        obj
+      end
+
+      # Retrieves an existing object with the given id or uri.
+      # Returns nil if the object is not found.
+      #
+      #   note = Note.get("ce655c90-cf09-012b-cd41-0016cb91f13d")
+      def get(id_or_uri)
+        uri = uri_from_id(id_or_uri)
+        document = Rest.get(uri)
+        new({'uri' => uri, 'etag' => document.headers[:etag], 
+            'last_modified' => document.headers[:last_modified],
+            'document' => document })
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+      
+      # Returns an array of allowed HTTP methods to be requested at
+      # +uri+. If +uri+ is nil, the class URI is queried.
+      #
+      #  Note.options # => [ "GET", "HEAD", "POST", "OPTIONS" ]
+      def options(uri = self.uri)
+        doc = Rest.custom(:options, uri)
+        doc["allow"].to_s.split(",").map { |s| s.strip }
+      end
+
+      # Extracts object ids from absolute or partial URIs.
+      #
+      #   Note.id_from_uri("http://localhost:9292/notes/ce655c90-cf09-012b-cd41-0016cb91f13d") 
+      #   => "ce655c90-cf09-012b-cd41-0016cb91f13d" 
+      def id_from_uri(uri)
+        id = URI.parse(uri)
+        # /notes/abc
+        if id.path[0,1] == "/"
+          id.path.split("/")[2]
+        else
+          id.to_s
+        end
+      end
+
+      # Composes a full URI from an object id or partial URI.
+      #
+      #   Note.uri_from_id("/notes/ce655c90-cf09-012b-cd41-0016cb91f13d") 
+      #   => "http://localhost:9292/notes/ce655c90-cf09-012b-cd41-0016cb91f13d" 
+      #
+      #   Note.uri_from_id("ce655c90-cf09-012b-cd41-0016cb91f13d") 
+      #   => "http://localhost:9292/notes/ce655c90-cf09-012b-cd41-0016cb91f13d" 
+      def uri_from_id(id)
+        url = URI.parse(id)
+        if url.absolute?
+          url.to_s
+        else
+          # /notes/1234
+          if url.path[0,1] == "/"
+            (URI.parse(self.uri) + url).to_s
+          # 1234
+          else
+            File.join("#{self.uri}", id)
+          end
+        end
+      end
+      
+    end
+
+    # Unique object id - not an URI, just a UUID
+    attr_reader :id
+
+    # ETag, a UUID
+    attr_reader :etag
+
+    # Last modified timestamp
+    attr_reader :last_modified
+
+    # Full URI for the object
+    #   => "http://localhost:9292/notes/ce655c90-cf09-012b-cd41-0016cb91f13d" 
+    def uri
+      @uri ||= self.class.uri_from_id(id) if id
+    end
+
+    # Partial URI for the object (without the protocol, hostname)
+    #   => "/notes/ce655c90-cf09-012b-cd41-0016cb91f13d" 
+    def path
+      URI.parse(uri).path
+    end
+
+    # Constructs a new, unsaved object. If +attributes+ are passed in a hash
+    # the new object is initialized with the corresponding attributes and values.
+    #
+    #  note = Note.new # => new, empty
+    #  note = Note.new(:text => "Ready note", :author => "Myself") # => new, with attributes set
+    def initialize(attributes = {})
+      @id, @etag, @last_modified, @deleted = nil
+      build(attributes)
+    end
+
+    # Saves a new or existing object. If the object already exists,
+    # then its etag should match the etag in the database, otherwise
+    # the operation fails.
+    #
+    # Returns +true+ if save was successful, +false+ otherwise.
+    #  note = Note.new(:text => "Ready note", :author => "Myself")
+    #  note.save # => true
+    def save
+      result = new? ? Rest.post(collection_uri, @table) : Rest.put(uri, @table, "If-Match" => etag)
+      @id, @etag, @last_modified = result.values_at("uri", "etag", "last_modified")
+      @id = self.class.id_from_uri(@id)
+      @last_modified = Time.parse(@last_modified)
+      true
+    rescue RestClient::RequestFailed
+      false
+    end    
+
+    # Deletes an existing object. Its etag should match the etag in 
+    # the database, otherwise the operation fails.
+    #
+    # Returns +true+ if save was successful, +false+ otherwise.
+    #  note = Note.new("ce655c90-cf09-012b-cd41-0016cb91f13d")
+    #  note.delete # => true
+    def delete
+      Rest.delete uri, "If-Match" => etag
+      @deleted = true
+      freeze
+      true
+    rescue RestClient::RequestFailed
+      false
+    end
+
+    # +true+ if object was not saved yet, +false+ otherwise.
+    def new?
+      @uri == nil and @etag == nil and @last_modified == nil
+    end
+
+    # +true+ if object was deleted, +false+ otherwise.
+    def deleted?; @deleted end
+    
+    # Retrieves older versions of the object. Sort order is from the
+    # current version to the oldest one.
+    # The +options+ parameter works as in +all+.
+    #
+    #  note = Note.new("ce655c90-cf09-012b-cd41-0016cb91f13d")
+    #  older_versions = note.versions(:resolved, :limit => 3)
+    def versions(options = {})
+      if uri
+        url = File.join(uri, "versions")
+        if options[:etag]
+          url = File.join(url, options[:etag])
+          self.class.get(url)
+        else
+          url = options[:resolved] ? File.join(url, "_resolved") : url
+          result = Rest.get(Rest.paramify_url(url, options))
+          if options[:resolved]
+            result["documents"].map { |d| self.class.new(d) }
+          else
+            result["uris"]
+          end
+        end
+      else
+        []
+      end
+    end
+
+    # Returns an array of allowed HTTP methods to be requested for
+    # this object.
+    #
+    #  note = Note.new("ce655c90-cf09-012b-cd41-0016cb91f13d") # => existing object
+    #  note.options # => [ "DELETE", "GET", "HEAD", "PUT", "OPTIONS" ]
+    def options
+      self.class.options(uri)
+    end
+    
+    def inspect
+      "#<#{self.class.name} uri=#{uri}, id=#{id}, etag=#{@etag}, last_modified=#{@last_modified}, #{@table.inspect}>"
+    end
+
+    private
+
+    def collection_uri
+      self.class.uri
+    end
+    
+    def build(doc)
+      if doc['uri']
+        set_internal_attributes(doc['uri'], doc['etag'],
+                                doc['last_modified'], doc['document'])
+      else
+        @table = doc
+      end
+      symbolize_table_keys!
+    end
+    
+    def set_internal_attributes(id, etag, last_modified, table)
+      @id = self.class.id_from_uri(id)
+      @etag = etag.to_s.gsub('"', '')
+      @last_modified = Time.parse(last_modified)
+      @table = table.is_a?(String) ? JSON.parse(table) : table
+    end
+
+    def symbolize_table_keys!
+      @table.keys.each { |k| v = @table.delete(k); @table[k.to_sym] = v }
+    end        
+  end
+end

data/lib/clouder/rest.rb

@@ -0,0 +1,80 @@
+require 'cgi'
+
+class Rest
+  class << self
+
+    # set proxy for RestClient to use
+    def proxy url
+      RestClient.proxy = url
+    end
+ 
+    def put uri, doc = nil, headers = {}
+      payload = doc.to_json if doc
+      parse(RestClient.put(uri, payload, headers))
+    end
+ 
+    def get uri
+      parse(RestClient.get(uri), :max_nesting => false)
+    end
+  
+    def post uri, doc = nil, headers = {}
+      payload = doc.to_json if doc
+      parse(RestClient.post(uri, payload, headers))
+    end
+  
+    def delete uri, headers = {}
+      parse(RestClient.delete(uri, headers))
+    end
+    
+    def copy uri, destination
+      parse(RestClient.copy(uri, {'Destination' => destination}))
+    end
+    
+    def move uri, destination
+      parse(RestClient.move(uri, {'Destination' => destination}))
+    end
+
+    def head uri, headers = {}
+      custom(:head, uri, headers)
+    end
+    
+    def custom method, uri, headers = {}
+      response = nil
+      url = URI.parse(uri)
+      Net::HTTP.start(url.host, url.port) { |http|
+        response = http.send(method, url.path, headers)
+      }
+      response.to_hash
+    end
+  
+    def parse(response, opts = {})
+      if response
+        json = JSON.parse(response, opts)
+        json.extend(ResponseHeaders)
+        json.headers = response.headers
+        json
+      end
+    end
+    
+    def paramify_url url, params = {}
+      if params && !params.empty?
+        query = params.collect do |k,v|
+          v = v.to_json if %w{key startkey endkey}.include?(k.to_s)
+          "#{k}=#{CGI.escape(v.to_s)}"
+        end.join("&")
+        url = "#{url}?#{query}"
+      end
+      url
+    end
+  end # class << self
+end
+
+module ResponseHeaders
+  def headers
+    @headers
+  end
+  
+  def headers=(h)
+    @headers = h
+  end
+end

data/spec/clouder_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe "Clouder" do
+  
+  it "should get available collections" do
+    collections = Clouder.collections "http://localhost:9292/"
+    collections.size.should == 1
+    collections.first.should == "notes"
+  end
+  
+  it "should allow to query any uri and just return the headers" do
+    headers = Clouder.head("http://localhost:9292/notes")
+    headers["content-type"].should include("application/json")
+  end
+  
+    
+end

data/spec/config.ru

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'cloudkit'
+
+expose :notes

data/spec/entity_spec.rb

@@ -0,0 +1,303 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe "Entity" do
+
+  before :all do
+    class Note < Clouder::Entity
+      uri "http://localhost:9292/notes"
+    end
+    Note.all(:resolved => true).each { |n| n.delete }
+  end
+
+  it "should let each class be associated with a different uri" do
+    class Comment < Clouder::Entity
+      uri "http://localhost:9292/comments"
+    end
+    
+    Comment.uri.should == "http://localhost:9292/comments"
+    Note.uri.should == "http://localhost:9292/notes"
+  end
+
+  it "should let each subclass be associated with a different uri" do
+    class Reminder < Note
+      uri "http://localhost:9292/reminders"
+    end
+    
+    Reminder.uri.should == "http://localhost:9292/reminders"
+    Note.uri.should == "http://localhost:9292/notes"
+  end
+  
+  it "should let you know the available methods for the class" do
+    options = Note.options
+    options.should == %w(GET HEAD POST OPTIONS)
+  end
+
+  it "should let you know the available methods for the object" do
+    n = Note.new
+    n.text = "My note"
+    n.save
+    n.options.should == %w(GET HEAD PUT DELETE OPTIONS)
+  end
+  
+  it "should let you create entity classes" do
+    n = Note.new
+    n.new?.should == true
+  end
+
+  it "should let you create entity classes with attributes" do
+    n = Note.new(:text => "My first note", :author => "Myself")
+    n.new?.should == true
+    n.text.should == "My first note"
+    n.author.should == "Myself"
+  end
+  
+  it "should let you inspect its uri" do
+    Note.uri.should == "http://localhost:9292/notes"
+  end
+  
+  it "should retrieve all uris" do
+    size = Note.all.size
+    Note.create(:text => "note 1").should be_an_instance_of(Note)
+    Note.create(:text => "note 2").should be_an_instance_of(Note)
+    Note.all.size.should == size + 2
+  end
+
+  it "should retrieve all instances" do
+    size = Note.all.size
+    Note.create(:text => "note 1").should be_an_instance_of(Note)
+    Note.create(:text => "note 2").should be_an_instance_of(Note)
+    
+    notes = Note.all(:resolved => true)
+    notes.each { |n| 
+      n.should be_an_instance_of(Note) 
+      n.etag.should_not == nil
+      n.id.should_not == nil
+      n.last_modified.should_not == nil
+    }
+    Note.all.size.should == size + 2
+  end
+
+  it "should retrieve all uris with limit and offset" do
+    size = Note.all.size
+    
+    notes = []
+    (1..4).each { |i| notes << Note.create(:text => "$note #{i}") }
+    
+    last_notes = Note.all(:limit => 4)
+    last_notes.size.should == 4
+    last_notes.should == notes.map { |n| n.path }.reverse
+    
+    last_notes = Note.all(:offset => 2, :limit => 2)
+    last_notes.size.should == 2
+    last_notes.should == notes[0..1].map { |n| n.path }.reverse
+
+    last_notes = Note.all(:offset => 2)
+    last_notes.size.should == size + 2
+  end
+  
+  it "should let you access attributes" do
+    n = Note.new
+    n.text = "My Note"
+    n.author = "John Doe"
+    
+    n.text.should == "My Note"
+    n.author.should == "John Doe"
+  end
+  
+  it "should let you save new objects" do
+    n = Note.new
+    n.new?.should == true
+    n.uri.should == nil
+    n.last_modified.should == nil
+    n.etag.should == nil
+            
+    n.text = "My Note"
+    n.author = "John Doe"
+   
+    n.save
+    
+    n.new?.should == false
+    n.uri.should_not == nil
+    n.last_modified.should be_close(Time.now, 10)
+    n.etag.should_not == nil
+  end
+  
+  it "should let you retrieve saved objects" do
+    n = Note.new
+    n.text = "My Note"
+    n.author = "John Doe"
+    n.save
+
+    id, etag, last_modified = n.id, n.etag, n.last_modified
+        
+    n = Note.get(id)
+    n.text.should == "My Note"
+    n.author.should == "John Doe"
+    n.id.should == id
+    n.etag.should == etag
+    n.last_modified.should == last_modified
+  end
+
+  it "should let you retrieve saved objects by URI" do
+    n = Note.new
+    n.text = "My Note"
+    n.author = "John Doe"
+    n.save
+
+    id, etag, last_modified = n.id, n.etag, n.last_modified
+        
+    n = Note.get Note.all.first
+    n.text.should == "My Note"
+    n.author.should == "John Doe"
+    n.id.should == id
+    n.etag.should == etag
+    n.last_modified.should == last_modified
+  end
+
+  it "should return nil when trying to retrieve a non-existing object" do
+    Note.get("abcdef").should == nil
+  end
+  
+  it "should let you update saved objects" do
+    n = Note.new
+    n.text = "My Note"
+    n.author = "John Doe"
+    n.save
+
+    n = Note.get(n.id)
+    n.versions.size.should == 1
+    n.text = "My modified note"
+    n.author = "John Doe II"
+    n.save.should == true
+
+    n = Note.get(n.id)
+    n.versions.size.should == 2
+    n.text.should == "My modified note"
+    n.author.should == "John Doe II"
+  end
+
+  it "should let you delete existing objects" do
+    size = Note.all.size
+    n = Note.new
+    n.text = "My Note"
+    n.author = "John Doe"
+    n.save
+    Note.all.size.should == size + 1
+    n.delete
+    n.frozen?.should == true
+    n.deleted?.should == true
+    Note.all.size.should == size
+  end
+  
+  it "should let you query versions about the object" do
+    n = Note.new
+    n.versions.should == []
+    n.text = "First version"
+    n.save
+
+    etag = n.etag
+    n.versions.size.should == 1
+    n.text = "Second version"
+    n.save
+
+    n.versions.size.should == 2
+    n.versions[1].should =~ Regexp.new(etag)
+    n.text = "Third version"   
+    etag = n.etag
+    n.save 
+    n.versions.size.should == 3
+    n.versions[1].should =~ Regexp.new(etag)
+  end
+
+  it "should let you query versions about the object using offset and limit" do
+    etags = []
+    n = Note.new
+    n.text = "First version"
+    n.save
+    etags << n.etag
+    
+    n.text = "Second version"
+    n.save
+    etags << n.etag
+    
+    n.text = "Third version"   
+    etag = n.etag
+    n.save 
+    etags << n.etag
+    
+    versions = n.versions(:limit => 2)
+    versions.size.should == 2
+    versions.first.should include(n.path)    
+    versions.last.should =~ Regexp.new(etags[1])    
+    
+    versions = n.versions(:offset => 1, :limit => 2)
+    versions.size.should == 2
+    versions.first.should =~ Regexp.new(etags[1])    
+    versions.last.should =~ Regexp.new(etags[0])    
+    
+    versions = n.versions(:offset => 2, :limit => 2)
+    versions.size.should == 1
+    versions.first.should =~ Regexp.new(etags[0])    
+  end
+  
+  it "should let you retrieve full objects from versions" do
+    texts = %w{text1 text2 text3}
+    etags = []
+    last_modifieds = []
+    n = Note.new
+    texts.each { |text| 
+      n.text = text
+      n.save
+      etags << n.etag
+      last_modifieds << n.last_modified
+    }
+    versions = n.versions(:resolved => true)
+    versions.size.should == 3
+    versions.map { |v| v.etag }.should == etags.reverse
+    versions.map { |v| v.last_modified }.should == last_modifieds.reverse
+    versions.map { |v| v.text }.should == texts.reverse
+  end
+
+  it "should let you retrieve older versions by etag" do
+    texts = %w{text1 text2 text3}
+    etags = []
+    last_modifieds = []
+    n = Note.new
+    texts.each { |text| 
+      n.text = text
+      n.save
+      etags << n.etag
+      last_modifieds << n.last_modified
+    }
+    
+    etags[0..1].each_with_index { |etag, i| 
+      n = n.versions(:etag => etag)
+      n.etag.should == etag
+      n.text.should == texts[i]
+      n.last_modified.should == last_modifieds[i]
+    }
+  end
+  
+  it "should fail when trying to save an outdated object" do
+    n = Note.create(:text => "Original")
+    
+    n2 = Note.get(n.id)
+    n2.text = "Modified"
+    n2.save.should == true
+    
+    n.text = "Modified but outdated"
+    n.save.should == false
+  end
+
+  it "should fail when trying to delete an outdated object" do
+    n = Note.create(:text => "Original")
+    
+    n2 = Note.get(n.id)
+    n2.text = "Modified"
+    n2.save.should == true
+    
+    n.text = "Modified but outdated"
+    n.delete.should == false
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'clouder'

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: demetriusnunes-clouder
+version: !ruby/object:Gem::Version 
+  version: 0.5.1
+platform: ruby
+authors: 
+- Demetrius Nunes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-29 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: A Ruby client library for accessing CloudKit using Ruby objects.
+email: 
+- demetriusnunes@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- lib/clouder.rb
+- lib/clouder/entity.rb
+- lib/clouder/rest.rb
+- spec/clouder_spec.rb
+- spec/entity_spec.rb
+- spec/spec_helper.rb
+- spec/spec.opts
+- spec/config.ru
+has_rdoc: true
+homepage: http://github.com/demetriusnunes/clouder/tree/master
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: clouder
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A Ruby client library for accessing CloudKit using Ruby objects.
+test_files: []
+