couchrest_model 1.1.2 → 1.2.0.beta

data/lib/couchrest/model/collection.rb

@@ -1,273 +0,0 @@
-module CouchRest
-  module Model
-    # Warning! The Collection module is seriously depricated.
-    # Use the new Design Views instead, as this code copies many other parts
-    # of CouchRest Model.
-    #
-    # Expect this to be removed soon.
-    #
-    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)
-          view_options.delete(:database)
-
-          [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
-          search_options.delete(:database)
-
-          [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
-
-          # Save the design doc, ready for use
-          @container_class.save_design_doc(@database)
-        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.build_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
-          options[:include_docs] = true
-          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

@@ -1,115 +0,0 @@
-# encoding: utf-8
-module CouchRest
-  module Model
-    module DesignDoc
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-
-        def design_doc
-          @design_doc ||= ::CouchRest::Design.new(default_design_doc)
-        end
-
-        def design_doc_id
-          "_design/#{design_doc_slug}"
-        end
-
-        def design_doc_slug
-          self.to_s
-        end
-
-        def design_doc_uri(db = database)
-          "#{db.root}/#{design_doc_id}"
-        end
-
-        # Retreive the latest version of the design document directly
-        # from the database. This is never cached and will return nil if
-        # the design is not present.
-        #
-        # Use this method if you'd like to compare revisions [_rev] which
-        # is not stored in the normal design doc.
-        def stored_design_doc(db = database)
-          db.get(design_doc_id)
-        rescue RestClient::ResourceNotFound
-          nil
-        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(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
-
-        private
-
-        def design_doc_cache
-          Thread.current[:couchrest_design_cache] ||= {}
-        end
-        def design_doc_cache_checksum(db)
-          design_doc_cache[design_doc_uri(db)]
-        end
-        def set_design_doc_cache_checksum(db, checksum)
-          design_doc_cache[design_doc_uri(db)] = checksum
-        end
-
-        # Writes out a design_doc to a given database if forced
-        # or the stored checksum is not the same as the current
-        # generated checksum.
-        #
-        # Returns the original design_doc provided, but does 
-        # not update it with the revision.
-        def update_design_doc(db, force = false)
-          return design_doc unless force || auto_update_design_doc
-
-          # Grab the design doc's checksum
-          checksum = design_doc.checksum!
-
-          # If auto updates enabled, check checksum cache
-          return design_doc if auto_update_design_doc && design_doc_cache_checksum(db) == checksum
-
-          # Load up the stored doc (if present), update, and save
-          saved = stored_design_doc(db)
-          if saved
-            if force || saved['couchrest-hash'] != checksum
-              saved.merge!(design_doc)
-              db.save_doc(saved)
-            end
-          else
-            db.save_doc(design_doc)
-            design_doc.delete('_rev') # Prevent conflicts, never store rev as DB specific
-          end
-
-          # Ensure checksum cached for next attempt if using auto updates
-          set_design_doc_cache_checksum(db, checksum) if auto_update_design_doc
-          design_doc
-        end
-
-        def default_design_doc
-          {
-            "_id" => design_doc_id,
-            "language" => "javascript",
-            "views" => {
-              'all' => {
-                'map' => "function(doc) {
-                  if (doc['#{self.model_type_key}'] == '#{self.to_s}') {
-                    emit(doc['_id'],1);
-                  }
-                }"
-              }
-            }
-          }
-        end
-
-      end # module ClassMethods
-
-    end
-  end
-end

data/lib/couchrest/model/support/couchrest_design.rb

@@ -1,33 +0,0 @@
-
-CouchRest::Design.class_eval do
-
-  # Calculate and update the checksum of the Design document.
-  # Used for ensuring the latest version has been sent to the database.
-  #
-  # This will generate an flatterned, ordered array of all the elements of the
-  # design document, convert to string then generate an MD5 Hash. This should
-  # result in a consisitent Hash accross all platforms.
-  #
-  def checksum!
-    # create a copy of basic elements
-    base = self.dup
-    base.delete('_id')
-    base.delete('_rev')
-    base.delete('couchrest-hash')
-    result = nil
-    flatten =
-      lambda {|r|
-        (recurse = lambda {|v|
-          if v.is_a?(Hash) || v.is_a?(CouchRest::Document)
-            v.to_a.map{|v| recurse.call(v)}.flatten
-          elsif v.is_a?(Array)
-            v.flatten.map{|v| recurse.call(v)}
-          else
-            v.to_s
-          end
-        }).call(r)
-      }
-    self['couchrest-hash'] = Digest::MD5.hexdigest(flatten.call(base).sort.join(''))
-  end
-
-end

data/lib/couchrest/model/views.rb

@@ -1,148 +0,0 @@
-module CouchRest
-  module Model
-    module Views
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        # Define a CouchDB view. The name of the view will be the concatenation
-        # of <tt>by</tt> and the keys joined by <tt>_and_</tt>
-        #  
-        # ==== Example views:
-        #  
-        #   class Post
-        #     # view with default options
-        #     # query with Post.by_date
-        #     view_by :date, :descending => true
-        #  
-        #     # view with compound sort-keys
-        #     # query with Post.by_user_id_and_date
-        #     view_by :user_id, :date
-        #  
-        #     # view with custom map/reduce functions
-        #     # query with Post.by_tags :reduce => true
-        #     view_by :tags,                                                
-        #       :map =>                                                     
-        #         "function(doc) {                                          
-        #           if (doc['model'] == 'Post' && doc.tags) {                   
-        #             doc.tags.forEach(function(tag){                       
-        #               emit(doc.tag, 1);                                   
-        #             });                                                   
-        #           }                                                       
-        #         }",                                                       
-        #       :reduce =>                                                  
-        #         "function(keys, values, rereduce) {                       
-        #           return sum(values);                                     
-        #         }"                                                        
-        #   end
-        #  
-        # <tt>view_by :date</tt> will create a view defined by this Javascript
-        # function:
-        #  
-        #   function(doc) {
-        #     if (doc['model'] == 'Post' && doc.date) {
-        #       emit(doc.date, null);
-        #     }
-        #   }
-        #  
-        # It can be queried by calling <tt>Post.by_date</tt> which accepts all
-        # valid options for CouchRest::Database#view. In addition, calling with
-        # the <tt>:raw => true</tt> option will return the view rows
-        # themselves. By default <tt>Post.by_date</tt> will return the
-        # documents included in the generated view.
-        #  
-        # Calling with :database => [instance of CouchRest::Database] will
-        # send the query to a specific database, otherwise it will go to
-        # the model's default database (use_database)
-        #  
-        # CouchRest::Database#view options can be applied at view definition
-        # time as defaults, and they will be curried and used at view query
-        # time. Or they can be overridden at query time.
-        #  
-        # Custom views can be queried with <tt>:reduce => true</tt> to return
-        # reduce results. The default for custom views is to query with
-        # <tt>:reduce => false</tt>.
-        #  
-        # Views are generated (on a per-model basis) lazily on first-access.
-        # This means that if you are deploying changes to a view, the views for
-        # that model won't be available until generation is complete. This can
-        # take some time with large databases. Strategies are in the works.
-        #  
-        # To understand the capabilities of this view system more completely,
-        # it is recommended that you read the RSpec file at
-        # <tt>spec/couchrest/more/extended_doc_spec.rb</tt>.
-
-        def view_by(*keys)
-          opts = keys.pop if keys.last.is_a?(Hash)
-          opts ||= {}
-          ducktype = opts.delete(:ducktype)
-          unless ducktype || opts[:map]
-            opts[:guards] ||= []
-            opts[:guards].push "(doc['#{model_type_key}'] == '#{self.to_s}')"
-          end
-          keys.push opts
-          design_doc.view_by(*keys)
-        end
-
-        # returns stored defaults if there is a view named this in the design doc
-        def has_view?(name)
-          design_doc && design_doc.has_view?(name)
-        end
-
-        # Check if the view can be reduced by checking to see if it has a
-        # reduce function.
-        def can_reduce_view?(name)
-          design_doc && design_doc.can_reduce_view?(name)
-        end
-
-        # Dispatches to any named view.
-        def view(name, query={}, &block)
-          query = query.dup # Modifications made on copy!
-          db = query.delete(:database) || database
-          query[:raw] = true if query[:reduce]
-          raw = query.delete(:raw)
-          save_design_doc(db)
-          fetch_view_with_docs(db, name, query, raw, &block)
-        end
-
-        # Find the first entry in the view. If the second parameter is a string
-        # it will be used as the key for the request, for example:
-        #
-        #     Course.first_from_view('by_teacher', 'Fred')
-        #
-        # More advanced requests can be performed by providing a hash:
-        #
-        #     Course.first_from_view('by_teacher', :startkey => 'bbb', :endkey => 'eee')
-        #
-        def first_from_view(name, *args)
-          query = {:limit => 1}
-          case args.first
-          when String, Array
-            query.update(args[1]) unless args[1].nil?
-            query[:key] = args.first
-          when Hash
-            query.update(args.first)
-          end
-          view(name, query).first
-        end
-
-        private
-
-        def fetch_view_with_docs(db, name, opts, raw=false, &block)
-          if raw || (opts.has_key?(:include_docs) && opts[:include_docs] == false)
-            fetch_view(db, name, opts, &block)
-          else
-            opts = opts.merge(:include_docs => true)
-            view = fetch_view db, name, opts, &block
-            view['rows'].collect{|r| build_from_database(r['doc'])} if view['rows']
-          end
-        end
-
-        def fetch_view(db, view_name, opts, &block)
-          raise "A view needs a database to operate on (specify :database option, or use_database in the #{self.class} class)" unless db
-          design_doc.view_on(db, view_name, opts, &block)
-        end
-      end # module ClassMethods
-
-    end
-  end
-end