couchrest_model 1.0.0.beta7

data/lib/couchrest/model/collection.rb

@@ -0,0 +1,260 @@
+module CouchRest
+  module Model
+    module Collection
+  
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        # Creates a new class method, find_all_<collection_name>, that will
+        # execute the view specified with the design_doc and view_name 
+        # parameters, along with the specified view_options.  This method will
+        # return the results of the view as an Array of objects which are
+        # instances of the class.
+        #
+        # This method is handy for objects that do not use the view_by method
+        # to declare their views.
+        def provides_collection(collection_name, design_doc, view_name, view_options)
+          class_eval <<-END, __FILE__, __LINE__ + 1
+            def self.find_all_#{collection_name}(options = {})
+              view_options = #{view_options.inspect} || {}
+              CollectionProxy.new(options[:database] || database, "#{design_doc}", "#{view_name}", view_options.merge(options), Kernel.const_get('#{self}'))
+            end
+          END
+        end
+
+        # Fetch a group of objects from CouchDB.  Options can include:
+        #   :page - Specifies the page to load (starting at 1)
+        #   :per_page - Specifies the number of objects to load per page
+        #
+        # Defaults are used if these options are not specified.
+        def paginate(options)
+          proxy = create_collection_proxy(options)
+          proxy.paginate(options)
+        end
+
+        # Iterate over the objects in a collection, fetching them from CouchDB
+        # in groups.  Options can include:
+        #   :page - Specifies the page to load
+        #   :per_page - Specifies the number of objects to load per page
+        #
+        # Defaults are used if these options are not specified.
+        def paginated_each(options, &block)
+          search = options.delete(:search)
+          unless search == true
+            proxy = create_collection_proxy(options)
+          else
+            proxy = create_search_collection_proxy(options)
+          end
+          proxy.paginated_each(options, &block)
+        end
+
+        # Create a CollectionProxy for the specified view and options.
+        # CollectionProxy behaves just like an Array, but offers support for
+        # pagination.
+        def collection_proxy_for(design_doc, view_name, view_options = {})
+          options = view_options.merge(:design_doc => design_doc, :view_name => view_name)
+          create_collection_proxy(options)
+        end
+
+        private
+
+        def create_collection_proxy(options)
+          design_doc, view_name, view_options = parse_view_options(options)
+          CollectionProxy.new(options[:database] || database, design_doc, view_name, view_options, self)
+        end
+
+        def create_search_collection_proxy(options)
+          design_doc, search_name, search_options = parse_search_options(options)
+          CollectionProxy.new(options[:database] || database, design_doc, search_name, search_options, self, :search)
+        end
+
+        def parse_view_options(options)
+          design_doc = options.delete(:design_doc)
+          raise ArgumentError, 'design_doc is required' if design_doc.nil?
+
+          view_name = options.delete(:view_name)
+          raise ArgumentError, 'view_name is required' if view_name.nil?
+
+          default_view_options = (design_doc.class == Design && 
+              design_doc['views'][view_name.to_s] &&
+              design_doc['views'][view_name.to_s]["couchrest-defaults"]) || {}
+          view_options = default_view_options.merge(options)
+
+          [design_doc, view_name, view_options]
+        end
+
+        def parse_search_options(options)
+          design_doc = options.delete(:design_doc)
+          raise ArgumentError, 'design_doc is required' if design_doc.nil?
+
+          search_name = options.delete(:view_name)
+          raise ArgumentError, 'search_name is required' if search_name.nil?
+
+          search_options = options.clone
+          [design_doc, search_name, search_options]
+        end
+
+      end
+
+      class CollectionProxy
+        alias_method :proxy_respond_to?, :respond_to?
+        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+
+        DEFAULT_PAGE = 1
+        DEFAULT_PER_PAGE = 30
+        
+        # Create a new CollectionProxy to represent the specified view.  If a
+        # container class is specified, the proxy will create an object of the
+        # given type for each row that comes back from the view.  If no
+        # container class is specified, the raw results are returned.
+        #
+        # The CollectionProxy provides support for paginating over a collection
+        # via the paginate, and paginated_each methods.
+        def initialize(database, design_doc, view_name, view_options = {}, container_class = nil, query_type = :view)
+          raise ArgumentError, "database is a required parameter" if database.nil?
+
+          @database = database
+          @container_class = container_class
+          @query_type = query_type
+
+          strip_pagination_options(view_options)
+          @view_options = view_options
+
+          if design_doc.class == Design
+            @view_name = "#{design_doc.name}/#{view_name}"
+          else
+            @view_name = "#{design_doc}/#{view_name}"
+          end
+        end
+
+        # See Collection.paginate
+        def paginate(options = {})
+          page, per_page = parse_options(options)
+          results = @database.send(@query_type, @view_name, pagination_options(page, per_page))
+          remember_where_we_left_off(results, page)
+          instances = convert_to_container_array(results)
+
+          begin
+            if Kernel.const_get('WillPaginate')
+              total_rows = results['total_rows'].to_i
+              paginated = WillPaginate::Collection.create(page, per_page, total_rows) do |pager|
+                pager.replace(instances)
+              end
+              return paginated
+            end
+          rescue NameError
+            # When not using will_paginate, not much we could do about this. :x
+          end
+          return instances
+        end
+
+        # See Collection.paginated_each
+        def paginated_each(options = {}, &block)
+          page, per_page = parse_options(options)
+
+          begin
+            collection = paginate({:page => page, :per_page => per_page})
+            collection.each(&block)
+            page += 1
+          end until collection.size < per_page
+        end
+
+        def respond_to?(*args)
+          proxy_respond_to?(*args) || (load_target && @target.respond_to?(*args))
+        end
+
+        # Explicitly proxy === because the instance method removal above
+        # doesn't catch it.
+        def ===(other)
+          load_target
+          other === @target
+        end
+
+        private
+
+        def method_missing(method, *args)
+          if load_target
+            if block_given?
+              @target.send(method, *args)  { |*block_args| yield(*block_args) }
+            else
+              @target.send(method, *args)
+            end
+          end
+        end
+
+        def load_target
+          unless loaded?
+            @view_options.merge!({:include_docs => true}) if @query_type == :search
+            results = @database.send(@query_type, @view_name, @view_options)
+            @target = convert_to_container_array(results)
+          end
+          @loaded = true
+          @target
+        end
+
+        def loaded?
+          @loaded
+        end
+
+        def reload
+          reset
+          load_target
+          self unless @target.nil?
+        end
+
+        def reset
+          @loaded = false
+          @target = nil
+        end
+
+        def inspect
+          load_target
+          @target.inspect
+        end
+
+        def convert_to_container_array(results) 
+          if @container_class.nil?
+            results
+          else
+            results['rows'].collect { |row| @container_class.create_from_database(row['doc']) } unless results['rows'].nil?
+          end
+        end
+
+        def pagination_options(page, per_page)
+          view_options = @view_options.clone
+          if @query_type == :view && @last_key && @last_docid && @last_page == page - 1
+            key = view_options.delete(:key)
+            end_key = view_options[:endkey] || key
+            options = { :startkey => @last_key, :endkey => end_key, :startkey_docid => @last_docid, :limit => per_page, :skip => 1 }
+          else
+            options = { :limit => per_page, :skip => per_page * (page - 1) }
+          end
+          view_options.merge(options)
+        end
+
+        def parse_options(options)
+          page = options.delete(:page) || DEFAULT_PAGE
+          per_page = options.delete(:per_page) || DEFAULT_PER_PAGE
+          [page.to_i, per_page.to_i]
+        end
+
+        def strip_pagination_options(options)
+          parse_options(options)
+        end
+
+        def remember_where_we_left_off(results, page)
+          last_row = results['rows'].last
+          if last_row
+            @last_key = last_row['key']
+            @last_docid = last_row['id']
+          end
+          @last_page = page
+        end
+      end
+
+    end
+  end
+end

data/lib/couchrest/model/design_doc.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+module CouchRest
+  module Model
+    module DesignDoc
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        
+        def design_doc
+          @design_doc ||= Design.new(default_design_doc)
+        end
+    
+        # Use when something has been changed, like a view, so that on the next request
+        # the design docs will be updated (if changed!)
+        def req_design_doc_refresh
+          @design_doc_fresh = { }
+        end
+        
+        def design_doc_id
+          "_design/#{design_doc_slug}"
+        end
+
+        def design_doc_slug
+          self.to_s
+        end
+
+        def default_design_doc
+          {
+            "_id" => design_doc_id,
+            "language" => "javascript",
+            "views" => {
+              'all' => {
+                'map' => "function(doc) {
+                  if (doc['couchrest-type'] == '#{self.to_s}') {
+                    emit(doc['_id'],1);
+                  }
+                }"
+              }
+            }
+          }
+        end
+
+        # DEPRECATED
+        # use stored_design_doc to retrieve the current design doc
+        def all_design_doc_versions(db = database)
+          db.documents :startkey => "_design/#{self.to_s}", 
+            :endkey => "_design/#{self.to_s}-\u9999"
+        end
+       
+        # Retreive the latest version of the design document directly
+        # from the database.
+        def stored_design_doc(db = database)
+          db.get(design_doc_id) rescue nil
+        end
+        alias :model_design_doc :stored_design_doc
+
+        def refresh_design_doc(db = database)
+          raise "Database missing for design document refresh" if db.nil?
+          unless design_doc_fresh(db)
+            save_design_doc(db)
+            design_doc_fresh(db, true)
+          end
+        end
+
+        # Save the design doc onto a target database in a thread-safe way,
+        # not modifying the model's design_doc
+        #
+        # See also save_design_doc! to always save the design doc even if there
+        # are no changes.
+        def save_design_doc(db = database, force = false)
+          update_design_doc(Design.new(design_doc), db, force)
+        end
+
+        # Force the update of the model's design_doc even if it hasn't changed.
+        def save_design_doc!(db = database)
+          save_design_doc(db, true)
+        end
+
+        protected
+
+        def design_doc_fresh(db, fresh = nil)
+          @design_doc_fresh ||= {}
+          if fresh.nil? 
+            @design_doc_fresh[db.uri] || false
+          else
+            @design_doc_fresh[db.uri] = fresh
+          end
+        end
+
+        # Writes out a design_doc to a given database, returning the
+        # updated design doc
+        def update_design_doc(design_doc, db, force = false)
+          saved = stored_design_doc(db)
+          if saved
+            changes = force
+            design_doc['views'].each do |name, view|
+              if !compare_views(saved['views'][name], view)
+                changes = true
+                saved['views'][name] = view
+              end
+            end
+            if changes
+              db.save_doc(saved)
+            end
+            design_doc
+          else
+            design_doc.database = db
+            design_doc.save
+            design_doc
+          end
+        end
+
+        # Return true if the two views match
+        def compare_views(orig, repl)
+          return false if orig.nil? or repl.nil?
+          (orig['map'].to_s.strip == repl['map'].to_s.strip) && (orig['reduce'].to_s.strip == repl['reduce'].to_s.strip)
+        end
+
+      end # module ClassMethods
+      
+    end
+  end
+end

data/lib/couchrest/model/document_queries.rb

@@ -0,0 +1,82 @@
+module CouchRest
+  module Model
+    module DocumentQueries
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        
+        # Load all documents that have the "couchrest-type" field equal to the
+        # name of the current class. Take the standard set of
+        # CouchRest::Database#view options.
+        def all(opts = {}, &block)
+          view(:all, opts, &block)
+        end
+        
+        # Returns the number of documents that have the "couchrest-type" field
+        # equal to the name of the current class. Takes the standard set of 
+        # CouchRest::Database#view options
+        def count(opts = {}, &block)
+          all({:raw => true, :limit => 0}.merge(opts), &block)['total_rows']
+        end
+        
+        # Load the first document that have the "couchrest-type" field equal to
+        # the name of the current class.
+        #
+        # ==== Returns
+        # Object:: The first object instance available
+        # or
+        # Nil:: if no instances available
+        #
+        # ==== Parameters
+        # opts<Hash>::
+        # View options, see <tt>CouchRest::Database#view</tt> options for more info.
+        def first(opts = {})
+          first_instance = self.all(opts.merge!(:limit => 1))
+          first_instance.empty? ? nil : first_instance.first
+        end
+        
+        # Load a document from the database by id
+        # No exceptions will be raised if the document isn't found
+        #
+        # ==== Returns
+        # Object:: if the document was found
+        # or
+        # Nil::
+        # 
+        # === Parameters
+        # id<String, Integer>:: Document ID
+        # db<Database>:: optional option to pass a custom database to use
+        def get(id, db = database)
+          begin
+            get!(id, db)
+          rescue
+            nil
+          end
+        end
+        alias :find :get
+        
+        # Load a document from the database by id
+        # An exception will be raised if the document isn't found
+        #
+        # ==== Returns
+        # Object:: if the document was found
+        # or
+        # Exception
+        # 
+        # === Parameters
+        # id<String, Integer>:: Document ID
+        # db<Database>:: optional option to pass a custom database to use
+        def get!(id, db = database)
+          doc = db.get id
+          create_from_database(doc)
+        end
+        alias :find! :get!
+        
+      end
+      
+    end
+  end
+end