samlown-couchrest 0.37.2 → 1.0.0

data/lib/couchrest/mixins/class_proxy.rb

@@ -1,124 +0,0 @@
-module CouchRest
-  module Mixins
-    module ClassProxy
-      
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      module ClassMethods
-
-        # Return a proxy object which represents a model class on a
-        # chosen database instance. This allows you to DRY operations
-        # where a database is chosen dynamically.
-        #  
-        # ==== Example:
-        #  
-        #   db = CouchRest::Database.new(...)
-        #   articles = Article.on(db)
-        #
-        #   articles.all { ... }
-        #   articles.by_title { ... }
-        #
-        #   u = articles.get("someid")
-        #
-        #   u = articles.new(:title => "I like plankton")
-        #   u.save    # saved on the correct database
-
-        def on(database)
-          Proxy.new(self, database)
-        end
-      end
-
-      class Proxy #:nodoc:
-        def initialize(klass, database)
-          @klass = klass
-          @database = database
-        end
-        
-        # ExtendedDocument
-        
-        def new(*args)
-          doc = @klass.new(*args)
-          doc.database = @database
-          doc
-        end
-        
-        def method_missing(m, *args, &block)
-          if has_view?(m)
-            query = args.shift || {}
-            view(m, query, *args, &block)
-          else
-            super
-          end
-        end
-        
-        # Mixins::DocumentQueries
-        
-        def all(opts = {}, &block)
-          docs = @klass.all({:database => @database}.merge(opts), &block)
-          docs.each { |doc| doc.database = @database if doc.respond_to?(:database) } if docs
-          docs
-        end
-        
-        def count(opts = {}, &block)
-          @klass.all({:database => @database, :raw => true, :limit => 0}.merge(opts), &block)['total_rows']
-        end
-        
-        def first(opts = {})
-          doc = @klass.first({:database => @database}.merge(opts))
-          doc.database = @database if doc && doc.respond_to?(:database)
-          doc
-        end
-        
-        def get(id)
-          doc = @klass.get(id, @database)
-          doc.database = @database if doc && doc.respond_to?(:database)
-          doc
-        end
-        
-        # Mixins::Views
-        
-        def has_view?(view)
-          @klass.has_view?(view)
-        end
-        
-        def view(name, query={}, &block)
-          docs = @klass.view(name, {:database => @database}.merge(query), &block)
-          docs.each { |doc| doc.database = @database if doc.respond_to?(:database) } if docs
-          docs
-        end
-        
-        def all_design_doc_versions
-          @klass.all_design_doc_versions(@database)
-        end
-        
-        def model_design_doc
-          @klass.model_design_doc(@database)
-        end
-        
-        def cleanup_design_docs!
-          @klass.cleanup_design_docs!(@database)
-        end
-        
-        # Mixins::DesignDoc
-        
-        def design_doc
-          @klass.design_doc
-        end
-        
-        def design_doc_fresh
-          @klass.design_doc_fresh
-        end
-        
-        def refresh_design_doc
-          @klass.refresh_design_doc_on(@database)
-        end
-        
-        def save_design_doc
-          @klass.save_design_doc_on(@database)
-        end
-      end
-    end
-  end
-end

data/lib/couchrest/mixins/collection.rb

@@ -1,260 +0,0 @@
-module CouchRest
-  module Mixins
-    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/mixins/design_doc.rb

@@ -1,103 +0,0 @@
-require 'digest/md5'
-
-module CouchRest
-  module Mixins
-    module DesignDoc
-      
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      module ClassMethods
-        attr_accessor :design_doc, :design_doc_slug_cache, :design_doc_fresh
-        
-        def design_doc
-          @design_doc ||= Design.new(default_design_doc)
-        end
-        
-        def design_doc_id
-          "_design/#{design_doc_slug}"
-        end
-
-        def design_doc_slug
-          return design_doc_slug_cache if (design_doc_slug_cache && design_doc_fresh)
-          funcs = []
-          design_doc['views'].each do |name, view|
-            funcs << "#{name}/#{view['map']}#{view['reduce']}"
-          end
-          self.design_doc_slug_cache = self.to_s
-        end
-
-        def default_design_doc
-          {
-            "language" => "javascript",
-            "views" => {
-              'all' => {
-                'map' => "function(doc) {
-                  if (doc['couchrest-type'] == '#{self.to_s}') {
-                    emit(doc['_id'],1);
-                  }
-                }"
-              }
-            }
-          }
-        end
-
-        def refresh_design_doc
-          reset_design_doc
-          save_design_doc
-        end
-
-        def refresh_design_doc_on(db)
-          reset_design_doc
-          save_design_doc_on(db)
-        end
-
-        # Save the design doc onto the default database, and update the
-        # design_doc attribute
-        def save_design_doc
-          reset_design_doc unless design_doc_fresh
-          self.design_doc = update_design_doc(design_doc)
-        end
-
-        # Save the design doc onto a target database in a thread-safe way,
-        # not modifying the model's design_doc
-        def save_design_doc_on(db)
-          update_design_doc(Design.new(design_doc), db)
-        end
-
-        private
-        
-        def reset_design_doc
-          current = self.database.get(design_doc_id) rescue nil
-          design_doc['_id']  = design_doc_id
-          if current.nil?
-            design_doc.delete('_rev')
-          else
-            design_doc['_rev'] = current['_rev']
-          end
-          self.design_doc_fresh = true
-        end
-
-        # Writes out a design_doc to a given database, returning the
-        # updated design doc
-        def update_design_doc(design_doc, db = database)
-          saved = db.get(design_doc['_id']) rescue nil
-          if saved
-            design_doc['views'].each do |name, view|
-              saved['views'][name] = view
-            end
-            db.save_doc(saved)
-            saved
-          else
-            design_doc.database = db
-            design_doc.save
-            design_doc
-          end
-        end
-        
-      end # module ClassMethods
-      
-    end
-  end
-end