cloudkit 0.10.1 → 0.11.0

data/lib/cloudkit/oauth_store.rb

@@ -1,42 +1,38 @@
 module CloudKit
 
   # An OAuthStore is a thin abstraction around CloudKit::Store, providing
-  # consistent collection names, and allowing automatic migrations in later
+  # consistent collection names, and allowing automatic upgrades in later
   # releases if needed.
   class OAuthStore
     @@store = nil
 
     # Initialize a Store for use with OAuth middleware. Load the static consumer
     # resource if it does not exist.
-    def initialize(uri=nil)
+    def initialize
       @@store = Store.new(
         :collections => [
           :cloudkit_oauth_nonces,
           :cloudkit_oauth_tokens,
           :cloudkit_oauth_request_tokens,
-          :cloudkit_oauth_consumers],
-        :adapter => SQLAdapter.new(uri)) unless @@store
+          :cloudkit_oauth_consumers]
+        ) unless @@store
       load_static_consumer
     end
 
     def get(uri, options={}) #:nodoc:
-      @@store.get(uri, options)
+      @@store.get(CloudKit::URI.new(uri), options)
     end
 
     def post(uri, options={}) #:nodoc:
-      @@store.post(uri, options)
+      @@store.post(CloudKit::URI.new(uri), options)
     end
 
     def put(uri, options={}) #:nodoc:
-      @@store.put(uri, options)
+      @@store.put(CloudKit::URI.new(uri), options)
     end
 
     def delete(uri, options={}) #:nodoc:
-      @@store.delete(uri, options)
-    end
-
-    def reset! #:nodoc:
-      @@store.reset!
+      @@store.delete(CloudKit::URI.new(uri), options)
     end
 
     # Return the version number for this store.
@@ -46,7 +42,7 @@ module CloudKit
     # See the OAuth Discovery spec for more info on static consumers.
     def load_static_consumer
       json = JSON.generate(:secret => '')
-      @@store.put('/cloudkit_oauth_consumers/cloudkitconsumer', :json => json)
+      @@store.put(CloudKit::URI.new('/cloudkit_oauth_consumers/cloudkitconsumer'), :json => json)
     end
   end
 end

data/lib/cloudkit/openid_filter.rb

@@ -3,6 +3,11 @@ module CloudKit
   # An OpenIDFilter provides OpenID authentication, listening for upstream
   # OAuth authentication and bypassing if already authorized.
   #
+  # The root URI, "/", is always bypassed. More URIs can also be bypassed using
+  # the :allow option:
+  #
+  #   use OpenIDFilter, :allow => ['/foo', '/bar']
+  #
   # Responds to the following URIs:
   #   /login
   #   /logout
@@ -15,14 +20,14 @@ module CloudKit
     @@store = nil
 
     def initialize(app, options={})
-      @app = app; @options = options
+      @app     = app
+      @options = options
     end
 
     def call(env)
       @@lock.synchronize do
-        @@store = OpenIDStore.new(env[CLOUDKIT_STORAGE_URI])
-        @users  = UserStore.new(env[CLOUDKIT_STORAGE_URI])
-        @@store.get_association('x') rescue nil # refresh sqlite3
+        @@store = OpenIDStore.new
+        @users  = UserStore.new
       end unless @@store
 
       request = Request.new(env)
@@ -34,7 +39,7 @@ module CloudKit
       when r(:get, '/openid_complete'); complete_openid_login(request)
       when r(:post, request.logout_url); logout(request)
       else
-        if (root_request?(request) || valid_auth_key?(request) || logged_in?(request))
+        if bypass?(request)
           @app.call(env)
         else
           if request.env[CLOUDKIT_AUTH_CHALLENGE]
@@ -103,7 +108,8 @@ module CloudKit
       end
 
       result = @users.get(
-        '/cloudkit_login_view',
+        '/cloudkit_users',
+        # '/cloudkit_login_view',
         :identity_url => idp_response.endpoint.claimed_id)
       user_uris = result.parsed_content['uris']
 
@@ -183,7 +189,8 @@ module CloudKit
     def valid_remember_me_token?(request)
       return false unless token = request.cookies['remember_me']
 
-      result = @users.get('/cloudkit_login_view', :remember_me_token => token)
+      # result = @users.get('/cloudkit_login_view', :remember_me_token => token)
+      result = @users.get('/cloudkit_users', :remember_me_token => token)
       return false unless result.status == 200
 
       user_uris = result.parsed_content['uris']
@@ -204,5 +211,16 @@ module CloudKit
     def two_weeks_from_now
       Time.now.to_i+1209600
     end
+
+    def allow?(uri)
+      @options[:allow] && @options[:allow].include?(uri)
+    end
+
+    def bypass?(request)
+      root_request?(request) ||
+        allow?(request.path_info) ||
+        valid_auth_key?(request) ||
+        logged_in?(request)
+    end
   end
 end

data/lib/cloudkit/openid_store.rb

@@ -6,24 +6,18 @@ module CloudKit
   class OpenIDStore < OpenID::Store::Interface
     @@store = nil
 
-    # Initialize an OpenIDStore and its required views.
-    def initialize(uri=nil)
+    # Initialize an OpenIDStore.
+    def initialize
       unless @@store
-        association_view = ExtractionView.new(
-          :cloudkit_openid_server_handles,
-          :observe => :cloudkit_openid_associations,
-          :extract => [:server_url, :handle])
         @@store = Store.new(
-          :collections => [:cloudkit_openid_associations, :cloudkit_openid_nonces],
-          :views       => [association_view],
-          :adapter     => SQLAdapter.new(uri))
+          :collections => [:cloudkit_openid_associations, :cloudkit_openid_nonces])
       end
     end
 
     def get_association(server_url, handle=nil) #:nodoc:
       options = {:server_url => server_url}
       options.merge!(:handle => Base64.encode64(handle)) if (handle && handle != '')
-      result = @@store.get('/cloudkit_openid_server_handles', options)
+      result = @@store.get(CloudKit::URI.new('/cloudkit_openid_associations'), options)
       return nil unless result.status == 200
       return nil if result.parsed_content['total'] == 0
 
@@ -42,7 +36,7 @@ module CloudKit
 
     def remove_association(server_url, handle) #:nodoc:
       result = @@store.get(
-        '/cloudkit_openid_server_handles',
+        CloudKit::URI.new('/cloudkit_openid_associations'),
         :server_url => server_url,
         :handle     => Base64.encode64(handle))
       return nil unless result.status == 200
@@ -52,7 +46,7 @@ module CloudKit
 
       uris = result.parsed_content['uris']
       responses.each_with_index do |r, index|
-        @@store.delete(uris[index], :etag => r.etag)
+        @@store.delete(CloudKit::URI.new(uris[index]), :etag => r.etag)
       end
     end
 
@@ -65,18 +59,18 @@ module CloudKit
         :issued     => association.issued.to_i,
         :lifetime   => association.lifetime,
         :assoc_type => association.assoc_type)
-      result = @@store.post('/cloudkit_openid_associations', :json => json)
+      result = @@store.post(CloudKit::URI.new('/cloudkit_openid_associations'), :json => json)
       return (result.status == 201)
     end
 
     def use_nonce(server_url, timestamp, salt) #:nodoc:
       return false if (timestamp - Time.now.to_i).abs > OpenID::Nonce.skew
 
-      fragment = URI.escape(
+      fragment = ::URI.escape(
         [server_url, timestamp, salt].join('-'), 
-        Regexp.union(URI::REGEXP::UNSAFE, '/', ':'))
+        Regexp.union(::URI::REGEXP::UNSAFE, '/', ':'))
       uri    = "/cloudkit_openid_nonces/#{fragment}"
-      result = @@store.put(uri, :json => '{}')
+      result = @@store.put(CloudKit::URI.new(uri), :json => '{}')
       return (result.status == 201)
     end
 
@@ -92,10 +86,13 @@ module CloudKit
       # TODO
     end
 
+    # Return the version number for this store.
+    def version; 1; end
+
     protected
 
     def resolve_associations(parsed_content) #:nodoc:
-      uri_list = parsed_content['uris']
+      uri_list = parsed_content['uris'].map! { |u| CloudKit::URI.new(u) }
       association_responses = @@store.resolve_uris(uri_list)
       return association_responses, association_responses.map{|a| a.parsed_content}
     end

data/lib/cloudkit/request.rb

@@ -20,6 +20,11 @@ module CloudKit
       self.body.read
     end
 
+    # Return a CloudKit::URI instance representing the rack request's path info.
+    def uri
+      @uri ||= CloudKit::URI.new(self.path_info)
+    end
+
     # Return true if method, path, and required_params match.
     def match?(method, path, required_params=[])
       (request_method == method) &&
@@ -66,7 +71,7 @@ module CloudKit
 
     # Unescape a value according to the OAuth spec.
     def unescape(value)
-      URI.unescape(value.gsub('+', '%2B'))
+      ::URI.unescape(value.gsub('+', '%2B'))
     end
 
     # Return the last path element in the request URI.

data/lib/cloudkit/service.rb

@@ -29,6 +29,8 @@ module CloudKit
 
     @@lock = Mutex.new
 
+    attr_reader :store
+
     def initialize(app, options)
       @app         = app
       @collections = options[:collections]
@@ -36,9 +38,7 @@ module CloudKit
 
     def call(env)
       @@lock.synchronize do
-        @store = Store.new(
-          :adapter     => SQLAdapter.new(env[CLOUDKIT_STORAGE_URI]),
-          :collections => @collections)
+        @store = Store.new(:collections => @collections)
       end unless @store
 
       request = Request.new(env)
@@ -55,7 +55,7 @@ module CloudKit
 
     def get(request)
       response = @store.get(
-        request.path_info,
+        request.uri,
         {}.filter_merge!(
           :remote_user => request.current_user,
           :offset      => request['offset'],
@@ -69,14 +69,14 @@ module CloudKit
         return send(request['_method'].downcase)
       end
       @store.post(
-        request.path_info,
+        request.uri,
         {:json => request.json}.filter_merge!(
           :remote_user => request.current_user)).to_rack
     end
 
     def put(request)
       @store.put(
-        request.path_info,
+        request.uri,
         {:json => request.json}.filter_merge!(
           :remote_user => request.current_user,
           :etag        => request.if_match)).to_rack
@@ -84,7 +84,7 @@ module CloudKit
 
     def delete(request)
       @store.delete(
-        request.path_info,
+        request.uri,
         {}.filter_merge!(
           :remote_user => request.current_user,
           :etag        => request.if_match)).to_rack
@@ -92,7 +92,7 @@ module CloudKit
 
     def head(request)
       response = @store.head(
-        request.path_info,
+        request.uri,
         {}.filter_merge!(
           :remote_user => request.current_user,
           :offset      => request['offset'],
@@ -102,15 +102,15 @@ module CloudKit
     end
 
     def options(request)
-      @store.options(request.path_info).to_rack
+      @store.options(request.uri).to_rack
     end
 
     def inject_link_headers(request, response)
-      response['Link'] = versions_link_header(request) if @store.resource_uri?(request.path_info)
-      response['Link'] = resolved_link_header(request) if @store.resource_collection_uri?(request.path_info)
-      response['Link'] = index_link_header(request)    if @store.resolved_resource_collection_uri?(request.path_info)
-      response['Link'] = resolved_link_header(request) if @store.version_collection_uri?(request.path_info)
-      response['Link'] = index_link_header(request)    if @store.resolved_version_collection_uri?(request.path_info)
+      response['Link'] = versions_link_header(request) if request.uri.resource_uri?
+      response['Link'] = resolved_link_header(request) if request.uri.resource_collection_uri?
+      response['Link'] = index_link_header(request)    if request.uri.resolved_resource_collection_uri?
+      response['Link'] = resolved_link_header(request) if request.uri.version_collection_uri?
+      response['Link'] = index_link_header(request)    if request.uri.resolved_version_collection_uri?
     end
 
     def versions_link_header(request)
@@ -147,7 +147,7 @@ module CloudKit
 
     def bypass?(request)
       collection = @collections.detect{|type| request.path_info.match("/#{type.to_s}")}
-      !collection && !@store.meta_uri?(request.path_info)
+      !collection && !request.uri.meta_uri?
     end
   end
 end

data/lib/cloudkit/store.rb

@@ -3,36 +3,22 @@ module CloudKit
   # A functional storage interface with HTTP semantics and pluggable adapters.
   class Store
     include ResponseHelpers
+    include CloudKit::Util
 
-    # Initialize a new Store, creating its schema if needed. All resources in a
-    # Store are automatically versioned.
+    # Initialize a new Store. All resources in a Store are automatically
+    # versioned.
     #
     # ===Options
-    # - :adapter - Optional. An instance of Adapter. Defaults to in-memory SQLite.
     # - :collections - Array of resource collections to manage.
-    # - :views - Optional. Array of views to be updated based on JSON content.
     #
     # ===Example
     #   store = CloudKit::Store.new(:collections => [:foos, :bars])
     #
-    # ===Example
-    #   adapter = CloudKit::SQLAdapter.new('mysql://user:pass@localhost/my_db')
-    #   fruit_color_view = CloudKit::ExtractionView.new(
-    #     :fruits_by_color_and_season,
-    #     :observe => :fruits,
-    #     :extract => [:color, :season])
-    #   store = CloudKit::Store.new(
-    #     :adapter     => adapter,
-    #     :collections => [:foos, :fruits],
-    #     :views       => [fruit_color_view])
-    #
-    # See also: Adapter, ExtractionView, Response
+    # See also: Response
     #
     def initialize(options)
-      @db          = options[:adapter] || SQLAdapter.new
+      CloudKit.setup_storage_adapter unless CloudKit.storage_adapter
       @collections = options[:collections]
-      @views       = options[:views]
-      @views.each {|view| view.initialize_storage(@db)} if @views
     end
 
     # Retrieve a resource or collection of resources based on a URI.
@@ -45,7 +31,7 @@ module CloudKit
     # - :remote_user - Optional. Scopes the dataset if provided.
     # - :limit - Optional. Default is unlimited. Limit the number of records returned by a collection request.
     # - :offset - Optional. Start the list of resources in a collection at offset (0-based).
-    # - :any - Optional. Not a literal ":any", but any key or keys defined as extrations from a view.
+    # - :any - Optional. Not a literal ":any", but any key or keys that are top level JSON keys. This is a starting point for future JSONPath/JSONQuery support.
     #
     # ===URI Types
     #   /cloudkit-meta
@@ -55,7 +41,6 @@ module CloudKit
     #   /{collection}/{uuid}/versions
     #   /{collection}/{uuid}/versions/_resolved
     #   /{collection}/{uuid}/versions/{etag}
-    #   /{view}
     #
     # ===Examples
     #   get('/cloudkit-meta')
@@ -65,20 +50,18 @@ module CloudKit
     #   get('/foos/123')
     #   get('/foos/123/versions')
     #   get('/foos/123/versions/abc')
-    #   get('/shiny_foos', :color => 'green')
     #
     # See also: {REST API}[http://getcloudkit.com/rest-api.html]
     #
     def get(uri, options={})
-      return invalid_entity_type                        if !valid_collection_type?(collection_type(uri))
-      return meta                                       if meta_uri?(uri)
-      return resource_collection(uri, options)          if resource_collection_uri?(uri)
-      return resolved_resource_collection(uri, options) if resolved_resource_collection_uri?(uri)
-      return resource(uri, options)                     if resource_uri?(uri)
-      return version_collection(uri, options)           if version_collection_uri?(uri)
-      return resolved_version_collection(uri, options)  if resolved_version_collection_uri?(uri)
-      return resource_version(uri, options)             if resource_version_uri?(uri)
-      return view(uri, options)                         if view_uri?(uri)
+      return invalid_entity_type                        if !valid_collection_type?(uri.collection_type)
+      return meta                                       if uri.meta_uri?
+      return resource_collection(uri, options)          if uri.resource_collection_uri?
+      return resolved_resource_collection(uri, options) if uri.resolved_resource_collection_uri?
+      return resource(uri, options)                     if uri.resource_uri?
+      return version_collection(uri, options)           if uri.version_collection_uri?
+      return resolved_version_collection(uri, options)  if uri.resolved_version_collection_uri?
+      return resource_version(uri, options)             if uri.resource_version_uri?
       status_404
     end
 
@@ -87,19 +70,14 @@ module CloudKit
     # to the way CloudKit stores its ETags and Last-Modified information on
     # write.
     def head(uri, options={})
-      return invalid_entity_type unless @collections.include?(collection_type(uri))
-      if resource_uri?(uri) || resource_version_uri?(uri)
+      return invalid_entity_type unless @collections.include?(uri.collection_type)
+      if uri.resource_uri? || uri.resource_version_uri?
         # ETag and Last-Modified are already stored for single items, so a slight
         # optimization can be made for HEAD requests.
-        result = @db[CLOUDKIT_STORE].
-          select(:etag, :last_modified, :deleted).
-          filter(options.merge(:uri => uri))
-        if result.any?
-          result = result.first
-          return status_410.head if result[:deleted]
-          return response(200, '', result[:etag], result[:last_modified])
-        end
-        status_404.head
+        result = CloudKit::Resource.first(options.merge(:uri => uri.string))
+        return status_404.head unless result
+        return status_410.head if result.deleted?
+        return response(200, '', result.etag, result.last_modified)
       else
         get(uri, options).head
       end
@@ -110,7 +88,7 @@ module CloudKit
     def put(uri, options={})
       methods = methods_for_uri(uri)
       return status_405(methods) unless methods.include?('PUT')
-      return invalid_entity_type unless @collections.include?(collection_type(uri))
+      return invalid_entity_type unless @collections.include?(uri.collection_type)
       return data_required       unless options[:json]
       current_resource = resource(uri, options.excluding(:json, :etag, :remote_user))
       return update_resource(uri, options) if current_resource.status == 200
@@ -122,9 +100,8 @@ module CloudKit
     def post(uri, options={})
       methods = methods_for_uri(uri)
       return status_405(methods) unless methods.include?('POST')
-      return invalid_entity_type unless @collections.include?(collection_type(uri))
+      return invalid_entity_type unless @collections.include?(uri.collection_type)
       return data_required       unless options[:json]
-      uri = "#{collection_uri_fragment(uri)}/#{UUID.generate}"
       create_resource(uri, options)
     end
 
@@ -132,31 +109,15 @@ module CloudKit
     def delete(uri, options={})
       methods = methods_for_uri(uri)
       return status_405(methods) unless methods.include?('DELETE')
-      return invalid_entity_type unless @collections.include?(collection_type(uri))
+      return invalid_entity_type unless @collections.include?(uri.collection_type)
       return etag_required       unless options[:etag]
-      original = @db[CLOUDKIT_STORE].
-        filter(options.excluding(:etag).merge(:uri => uri))
-      if original.any?
-        item = original.first
-        return status_404 unless item[:remote_user] == options[:remote_user]
-        return status_410 if item[:deleted]
-        return status_412 if item[:etag] != options[:etag]
-        version_uri = ''
-        @db.transaction do
-          version_uri = "#{item[:uri]}/versions/#{item[:etag]}"
-          original.update(:uri => version_uri)
-          @db[CLOUDKIT_STORE].insert(
-            :uri                  => item[:uri],
-            :collection_reference => item[:collection_reference],
-            :resource_reference   => item[:resource_reference],
-            :remote_user          => item[:remote_user],
-            :content              => item[:content],
-            :deleted              => true)
-          unmap(uri)
-        end
-        return json_meta_response(200, version_uri, item[:etag], item[:last_modified])
-      end
-      status_404
+      resource = CloudKit::Resource.first(options.excluding(:etag).merge(:uri => uri.string))
+      return status_404 unless (resource && (resource.remote_user == options[:remote_user]))
+      return status_410 if resource.deleted?
+      return status_412 if resource.etag != options[:etag]
+
+      resource.delete
+      return json_meta_response(200, resource.uri.string, resource.etag, resource.last_modified)
     end
 
     # Build a response containing the allowed methods for a given URI.
@@ -167,13 +128,13 @@ module CloudKit
 
     # Return a list of allowed methods for a given URI.
     def methods_for_uri(uri)
-      return meta_methods                         if meta_uri?(uri)
-      return resource_collection_methods          if resource_collection_uri?(uri)
-      return resolved_resource_collection_methods if resolved_resource_collection_uri?(uri)
-      return resource_methods                     if resource_uri?(uri)
-      return version_collection_methods           if version_collection_uri?(uri)
-      return resolved_version_collection_methods  if resolved_version_collection_uri?(uri)
-      return resource_version_methods             if resource_version_uri?(uri)
+      return meta_methods                         if uri.meta_uri?
+      return resource_collection_methods          if uri.resource_collection_uri?
+      return resolved_resource_collection_methods if uri.resolved_resource_collection_uri?
+      return resource_methods                     if uri.resource_uri?
+      return version_collection_methods           if uri.version_collection_uri?
+      return resolved_version_collection_methods  if uri.resolved_version_collection_uri?
+      return resource_version_methods             if uri.resource_version_uri?
     end
 
     # Return the list of methods allowed for the cloudkit-meta URI.
@@ -221,91 +182,17 @@ module CloudKit
       ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'OPTIONS']
     end
 
-    # Return the resource collection URI fragment.
-    # Example: collection_uri_fragment('/foos/123') => '/foos
-    def collection_uri_fragment(uri)
-      "/#{uri_components(uri)[0]}" rescue nil
-    end
-
-    # Return the resource collection referenced by a URI.
-    # Example: collection_type('/foos/123') => :foos
-    def collection_type(uri)
-      uri_components(uri)[0].to_sym rescue nil
-    end
-
-    # Return the URI for the current version of a resource.
-    # Example: current_resource_uri('/foos/123/versions/abc') => '/foos/123'
-    def current_resource_uri(uri)
-      "/#{uri_components(uri)[0..1].join('/')}" rescue nil
-    end
-
-    # Splits a URI into its components
-    def uri_components(uri)
-      uri.split('/').reject{|x| x == '' || x == nil} rescue []
-    end
-
-    # Returns true if URI matches /cloudkit-meta
-    def meta_uri?(uri)
-      c = uri_components(uri)
-      return c.size == 1 && c[0] == 'cloudkit-meta'
-    end
-
-    # Returns true if URI matches /{collection}
-    def resource_collection_uri?(uri)
-      c = uri_components(uri)
-      return c.size == 1 && @collections.include?(c[0].to_sym)
-    end
-
-    # Returns true if URI matches /{collection}/_resolved
-    def resolved_resource_collection_uri?(uri)
-      c = uri_components(uri)
-      return c.size == 2 && @collections.include?(c[0].to_sym) && c[1] == '_resolved'
-    end
-
-    # Returns true if URI matches /{collection}/{uuid}
-    def resource_uri?(uri)
-      c = uri_components(uri)
-      return c.size == 2 && @collections.include?(c[0].to_sym) && c[1] != '_resolved'
-    end
-
-    # Returns true if URI matches /{collection}/{uuid}/versions
-    def version_collection_uri?(uri)
-      c = uri_components(uri)
-      return c.size == 3 && @collections.include?(c[0].to_sym) && c[2] == 'versions'
-    end
-
-    # Returns true if URI matches /{collection}/{uuid}/versions/_resolved
-    def resolved_version_collection_uri?(uri)
-      c = uri_components(uri)
-      return c.size == 4 && @collections.include?(c[0].to_sym) && c[2] == 'versions' && c[3] == '_resolved'
-    end
-
-    # Returns true if URI matches /{collection}/{uuid}/versions/{etag}
-    def resource_version_uri?(uri)
-      c = uri_components(uri)
-      return c.size == 4 && @collections.include?(c[0].to_sym) && c[2] == 'versions' && c[3] != '_resolved'
-    end
-
-    # Returns true if URI matches /{view}
-    def view_uri?(uri)
-      c = uri_components(uri)
-      return c.size == 1 && @views && @views.map{|v| v.name}.include?(c[0].to_sym)
-    end
-
     # Return an array containing the response for each URI in a list.
-    def resolve_uris(uris)
+    def resolve_uris(uris) # TODO - remove if no longer needed
       result = []
       uris.each do |uri|
         result << get(uri)
       end
       result
     end
-
-    # Clear all contents of the store. Used mostly for testing.
-    def reset!
-      @db.schema.keys.each do |table|
-        @db[table.gsub('`','').to_sym].delete
-      end
+    
+    def storage_adapter
+      CloudKit.storage_adapter
     end
 
     # Return the version number of this Store.
@@ -322,145 +209,96 @@ module CloudKit
     # Return a list of resource URIs for the given collection URI. Sorted by
     # Last-Modified date in descending order.
     def resource_collection(uri, options)
-      result = @db[CLOUDKIT_STORE].
-        select(:uri, :last_modified).
-        filter(options.excluding(:offset, :limit).merge(:deleted => false)).
-        filter(:collection_reference => collection_uri_fragment(uri)).
-        filter('resource_reference = uri').
-        reverse_order(:id)
-      bundle_collection_result(uri, options, result)
+      filter = options.excluding(:offset, :limit).merge(
+        :deleted              => false,
+        :collection_reference => uri.collection_uri_fragment,
+        :archived             => false)
+      result = CloudKit::Resource.current(filter)
+      bundle_collection_result(uri.string, options, result)
     end
 
     # Return all documents and their associated metadata for the given
     # collection URI.
     def resolved_resource_collection(uri, options)
-      result = @db[CLOUDKIT_STORE].
-        filter(options.excluding(:offset, :limit).merge(:deleted => false)).
-        filter(:collection_reference => collection_uri_fragment(uri)).
-        filter('resource_reference = uri').
-        reverse_order(:id)
+      result = CloudKit::Resource.current(
+        options.excluding(:offset, :limit).merge(
+          :collection_reference => uri.collection_uri_fragment))
       bundle_resolved_collection_result(uri, options, result)
     end
 
     # Return the resource for the given URI. Return 404 if not found or if
     # protected and unauthorized, 410 if authorized but deleted.
     def resource(uri, options)
-      result = @db[CLOUDKIT_STORE].
-        select(:content, :etag, :last_modified, :deleted).
-        filter(options.merge!(:uri => uri))
-      if result.any?
-        result = result.first
-        return status_410 if result[:deleted]
-        return response(200, result[:content], result[:etag], result[:last_modified])
+      if resource = CloudKit::Resource.first(options.merge!(:uri => uri.string))
+        return status_410 if resource.deleted?
+        return response(200, resource.json, resource.etag, resource.last_modified)
       end
       status_404
     end
 
     # Return a collection of URIs for all versions of a resource including the
-    #current version. Sorted by Last-Modified date in descending order.
+    # current version. Sorted by Last-Modified date in descending order.
     def version_collection(uri, options)
-      found = @db[CLOUDKIT_STORE].
-        select(:uri).
-        filter(options.excluding(:offset, :limit).merge(
-          :uri => current_resource_uri(uri)))
-      return status_404 unless found.any?
-      result = @db[CLOUDKIT_STORE].
-        select(:uri, :last_modified).
-        filter(:resource_reference => current_resource_uri(uri)).
-        filter(options.excluding(:offset, :limit).merge(:deleted => false)).
-        reverse_order(:id)
-      bundle_collection_result(uri, options, result)
+      found = CloudKit::Resource.first(
+        options.excluding(:offset, :limit).merge(
+          :uri => uri.current_resource_uri))
+      return status_404 unless found
+      result = CloudKit::Resource.all( # TODO - just use found.versions
+        options.excluding(:offset, :limit).merge(
+          :resource_reference => uri.current_resource_uri,
+          :deleted            => false))
+      bundle_collection_result(uri.string, options, result)
     end
 
     # Return all document versions and their associated metadata for a given
     # resource including the current version. Sorted by Last-Modified date in
     # descending order.
     def resolved_version_collection(uri, options)
-      found = @db[CLOUDKIT_STORE].
-        select(:uri).
-        filter(options.excluding(:offset, :limit).merge(
-          :uri => current_resource_uri(uri)))
-      return status_404 unless found.any?
-      result = @db[CLOUDKIT_STORE].
-        filter(:resource_reference => current_resource_uri(uri)).
-        filter(options.excluding(:offset, :limit).merge(:deleted => false)).
-        reverse_order(:id)
+      found = CloudKit::Resource.first(
+        options.excluding(:offset, :limit).merge(
+          :uri => uri.current_resource_uri))
+      return status_404 unless found
+      result = CloudKit::Resource.all(
+        options.excluding(:offset, :limit).merge(
+          :resource_reference => uri.current_resource_uri,
+          :deleted            => false))
       bundle_resolved_collection_result(uri, options, result)
     end
 
     # Return a specific version of a resource.
     def resource_version(uri, options)
-      result = @db[CLOUDKIT_STORE].
-        select(:content, :etag, :last_modified).
-        filter(options.merge(:uri => uri))
-      return status_404 unless result.any?
-      result = result.first
-      response(200, result[:content], result[:etag], result[:last_modified])
-    end
-
-    # Return a list of URIs for all resources matching the list of key value
-    # pairs provided in the options arg.
-    def view(uri, options)
-      result = @db[collection_type(uri)].
-        select(:uri).
-        filter(options.excluding(:offset, :limit))
-      bundle_collection_result(uri, options, result)
+      result = CloudKit::Resource.first(options.merge(:uri => uri.string))
+      return status_404 unless result
+      response(200, result.json, result.etag, result.last_modified)
     end
 
     # Create a resource at the specified URI.
     def create_resource(uri, options)
-      data = JSON.parse(options[:json]) rescue (return status_422)
-      etag = UUID.generate
-      last_modified = timestamp
-      @db[CLOUDKIT_STORE].insert(
-        :uri                  => uri,
-        :collection_reference => collection_uri_fragment(uri),
-        :resource_reference   => uri,
-        :etag                 => etag,
-        :last_modified        => last_modified,
-        :remote_user          => options[:remote_user],
-        :content              => options[:json])
-      map(uri, data)
-      json_meta_response(201, uri, etag, last_modified)
+      JSON.parse(options[:json]) rescue (return status_422)
+      resource = CloudKit::Resource.create(uri, options[:json], options[:remote_user])
+      json_meta_response(201, resource.uri.string, resource.etag, resource.last_modified)
     end
 
     # Update the resource at the specified URI. Requires the :etag option.
     def update_resource(uri, options)
-      data = JSON.parse(options[:json]) rescue (return status_422)
-      original = @db[CLOUDKIT_STORE].
-        filter(options.excluding(:json, :etag).merge(:uri => uri))
-      if original.any?
-        item = original.first
-        return status_404    unless item[:remote_user] == options[:remote_user]
-        return etag_required unless options[:etag]
-        return status_412    unless options[:etag] == item[:etag]
-        etag = UUID.generate
-        last_modified = timestamp
-        @db.transaction do
-          original.update(:uri => "#{uri}/versions/#{item[:etag]}")
-          @db[CLOUDKIT_STORE].insert(
-            :uri                  => uri,
-            :collection_reference => item[:collection_reference],
-            :resource_reference   => item[:resource_reference],
-            :etag                 => etag,
-            :last_modified        => last_modified,
-            :remote_user          => options[:remote_user],
-            :content              => options[:json])
-        end
-        map(uri, data)
-        return json_meta_response(200, uri, etag, last_modified)
-      end
-      status_404
+      JSON.parse(options[:json]) rescue (return status_422)
+      resource = CloudKit::Resource.first(
+        options.excluding(:json, :etag).merge(:uri => uri.string))
+      return status_404    unless (resource && (resource.remote_user == options[:remote_user]))
+      return etag_required unless options[:etag]
+      return status_412    unless options[:etag] == resource.etag
+      resource.update(options[:json])
+      return json_meta_response(200, uri.string, resource.etag, resource.last_modified)
     end
 
     # Bundle a collection of results as a list of URIs for the response.
     def bundle_collection_result(uri, options, result)
-      total  = result.count
+      total  = result.size
       offset = options[:offset].try(:to_i) || 0
       max    = options[:limit] ? offset + options[:limit].to_i : total
-      list   = result.all[offset...max].map{|r| r[:uri]}
+      list   = result.to_a[offset...max].map{|r| r.uri}
       json   = uri_list(list, total, offset)
-      last_modified = result.first[:last_modified] if result.any?
+      last_modified = result.first.try(:last_modified) if result.any?
       response(200, json, build_etag(json), last_modified)
     end
 
@@ -468,18 +306,18 @@ module CloudKit
     # metadata (last_modified, uri, etag) that would have accompanied a response
     # to their singular request.
     def bundle_resolved_collection_result(uri, options, result)
-      total  = result.count
+      total  = result.size
       offset = options[:offset].try(:to_i) || 0
       max    = options[:limit] ? offset + options[:limit].to_i : total
-      list   = result.all[offset...max]
+      list   = result.to_a[offset...max]
       json   = resource_list(list, total, offset)
-      last_modified = result.first[:last_modified] if result.any?
+      last_modified = result.first.last_modified if result.any?
       response(200, json, build_etag(json), last_modified)
     end
 
     # Generate a JSON URI list.
     def uri_list(list, total, offset)
-      JSON.generate(:total => total, :offset => offset, :uris => list)
+      JSON.generate(:total => total, :offset => offset, :uris => list.map { |u| u.string })
     end
 
     # Generate a JSON document list.
@@ -487,10 +325,10 @@ module CloudKit
       results = []
       list.each do |resource|
         results << {
-          :uri           => resource[:uri],
-          :etag          => resource[:etag],
-          :last_modified => resource[:last_modified],
-          :document      => resource[:content]}
+          :uri           => resource.uri.string,
+          :etag          => resource.etag,
+          :last_modified => resource.last_modified,
+          :document      => resource.json}
       end
       JSON.generate(:total => total, :offset => offset, :documents => results)
     end
@@ -502,34 +340,9 @@ module CloudKit
       MD5::md5(data.to_s).hexdigest
     end
 
-    # Returns true if the collection type represents a view.
-    def is_view?(collection_type)
-      @views && @views.map{|v| v.name}.include?(collection_type)
-    end
-
     # Returns true if the collection type is valid for this Store.
     def valid_collection_type?(collection_type)
-      @collections.include?(collection_type) ||
-        is_view?(collection_type) ||
-        collection_type.to_s == 'cloudkit-meta'
-    end
-
-    # Delegates the mapping of data from a resource into a view.
-    def map(uri, data)
-      @views.each{|view| view.map(@db, collection_type(uri), uri, data)} if @views
+      @collections.include?(collection_type) || collection_type.to_s == 'cloudkit-meta'
     end
-
-    # Delegates removal of view data.
-    def unmap(uri)
-      @views.each{|view| view.unmap(@db, collection_type(uri), uri)} if @views
-    end
-
-    # Return a HTTP date representing 'now.'
-    def timestamp
-      Time.now.httpdate
-    end
-
-    # Return the adapter instance used by this Store.
-    def db; @db; end
   end
 end